AI/rocm-systems
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SWDEV-563777 - fix warnings related to inconsistent overrides (#1625)

Browse Source 
This patch adds missing override keywords. Fixes this class of warnings.

Signed-off-by: Sebastian Luzynski <Sebastian.Luzynski@amd.com>
This commit is contained in:
sluzynsk-amd
2025-11-24 12:50:07 -05:00
committed by GitHub
parent 1a3564a51a
commit 2cf9faa93f
6 changed files with 52 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files
projects/clr/hipamd/src/hip_event.hpp
+6 -6
View File
@@ -220,16 +220,16 @@ class IPCEvent : public Event {
}
IPCEvent() : Event(hipEventInterprocess) {}
bool createIpcEventShmemIfNeeded();
hipError_t GetHandle(ihipIpcEventHandle_t* handle);
hipError_t OpenHandle(ihipIpcEventHandle_t* handle);
hipError_t synchronize();
hipError_t query();
hipError_t GetHandle(ihipIpcEventHandle_t* handle) override;
hipError_t OpenHandle(ihipIpcEventHandle_t* handle) override;
hipError_t synchronize() override;
hipError_t query() override;
hipError_t streamWait(hip::Stream* stream, uint flags);
hipError_t streamWait(hip::Stream* stream, uint flags) override;
hipError_t recordCommand(amd::Command*& command, amd::HostQueue* queue, uint32_t flags = 0,
bool batch_flush = true) override;
hipError_t enqueueRecordCommand(hip::Stream* stream, amd::Command* command);
hipError_t enqueueRecordCommand(hip::Stream* stream, amd::Command* command) override;
};
projects/clr/hipamd/src/hip_graph_internal.hpp
+3 -3
View File
@@ -2716,7 +2716,7 @@ class hipGraphExternalSemSignalNode : public GraphNode {
GraphNode* clone() const override { return new hipGraphExternalSemSignalNode(*this); }
hipError_t CreateCommand(hip::Stream* stream) {
hipError_t CreateCommand(hip::Stream* stream) override {
hipError_t status = GraphNode::CreateCommand(stream);
if (status != hipSuccess) {
return status;
@@ -2769,7 +2769,7 @@ class hipGraphExternalSemWaitNode : public GraphNode {
GraphNode* clone() const override { return new hipGraphExternalSemWaitNode(*this); }
hipError_t CreateCommand(hip::Stream* stream) {
hipError_t CreateCommand(hip::Stream* stream) override {
hipError_t status = GraphNode::CreateCommand(stream);
if (status != hipSuccess) {
return status;
@@ -2821,7 +2821,7 @@ class hipGraphBatchMemOpNode : public GraphNode {
GraphNode* clone() const override { return new hipGraphBatchMemOpNode(*this); }
hipError_t CreateCommand(hip::Stream* stream) {
hipError_t CreateCommand(hip::Stream* stream) override {
hipError_t status = GraphNode::CreateCommand(stream);
if (status != hipSuccess) {
return status;
projects/clr/rocclr/device/rocm/rocdevice.hpp
+37 -37
View File
@@ -232,12 +232,12 @@ class NullDevice : public amd::Device {
return false;
}
virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) const {
virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) const override {
ShouldNotReachHere();
return false;
}
virtual bool ValidateMemAccess(amd::Memory& mem, bool read_write) const {
virtual bool ValidateMemAccess(amd::Memory& mem, bool read_write) const override {
ShouldNotReachHere();
return true;
}
@@ -371,33 +371,33 @@ class Device : public NullDevice {
///////////////////////////////////////////////////////////////////////////////
//! Instantiate a new virtual device
virtual device::VirtualDevice* createVirtualDevice(amd::CommandQueue* queue = nullptr);
virtual device::VirtualDevice* createVirtualDevice(amd::CommandQueue* queue = nullptr) override;
//! Construct an device program object from the ELF assuming it is valid
virtual device::Program* createProgram(amd::Program& owner,
amd::option::Options* options = nullptr);
amd::option::Options* options = nullptr) override;
virtual device::Memory* createMemory(amd::Memory& owner) const;
virtual device::Memory* createMemory(size_t size, size_t alignment = 0) const;
virtual device::Memory* createMemory(amd::Memory& owner) const override;
virtual device::Memory* createMemory(size_t size, size_t alignment = 0) const override;
//! Sampler object allocation
virtual bool createSampler(const amd::Sampler& owner, //!< abstraction layer sampler object
device::Sampler** sampler //!< device sampler object
) const;
) const override;
//! Just returns nullptr for the dummy device
virtual device::Memory* createView(
amd::Memory& owner, //!< Owner memory object
const device::Memory& parent //!< Parent device memory object for the view
) const {
) const override {
return nullptr;
}
virtual device::Signal* createSignal() const;
virtual device::Signal* createSignal() const override;
//! Acquire external graphics API object in the host thread
//! Needed for OpenGL objects on CPU device
virtual bool bindExternalDevice(uint flags, void* const pDevice[], void* pContext,
bool validateOnly);
bool validateOnly) override;
/**
* @brief Removes the external device as an available device.
@@ -412,66 +412,66 @@ class Device : public NullDevice {
void* gfxContext, //!< HGLRC/GLXContext handle
bool validateOnly //!< Only validate if the device can inter-operate with
//!< pDevice/pContext, do not bind.
);
) override;
//! Gets free memory on a GPU device
virtual bool globalFreeMemory(size_t* freeMemory) const;
virtual bool globalFreeMemory(size_t* freeMemory) const override;
virtual void* hostAlloc(size_t size, size_t alignment,
MemorySegment mem_seg = MemorySegment::kNoAtomics,
const void* agentInfo = nullptr) const override; // nullptr uses default CPU agent
virtual void hostFree(void* ptr, size_t size = 0) const;
virtual void hostFree(void* ptr, size_t size = 0) const override;
virtual bool amdFileRead(amd::Os::FileDesc handle, void* devicePtr, uint64_t size, int64_t file_offset,
uint64_t* size_copied, int32_t* status) override;
virtual bool amdFileWrite(amd::Os::FileDesc handle, void* devicePtr, uint64_t size, int64_t file_offset,
uint64_t* size_copied, int32_t* status) override;
bool deviceAllowAccess(void* dst) const;
bool deviceAllowAccess(void* dst) const override;
bool allowPeerAccess(device::Memory* memory) const;
bool allowPeerAccess(device::Memory* memory) const override;
void deviceVmemRelease(uint64_t mem_handle) const;
uint64_t deviceVmemAlloc(size_t size, uint64_t flags) const;
void* deviceLocalAlloc(size_t size,
const AllocationFlags& flags = AllocationFlags{}) const;
const AllocationFlags& flags = AllocationFlags{}) const override;
void* reserveMemory(size_t size, size_t alignment) const;
void releaseMemory(void* ptr, size_t size) const;
void memFree(void* ptr, size_t size) const;
virtual void* svmAlloc(amd::Context& context, size_t size, size_t alignment,
cl_svm_mem_flags flags = CL_MEM_READ_WRITE, void* svmPtr = nullptr) const;
cl_svm_mem_flags flags = CL_MEM_READ_WRITE, void* svmPtr = nullptr) const override;
virtual void svmFree(void* ptr) const;
virtual void svmFree(void* ptr) const override;
virtual bool SetSvmAttributes(const void* dev_ptr, size_t count, amd::MemoryAdvice advice,
bool use_cpu = false, int numa_id = kDefaultNumaNode) const;
bool use_cpu = false, int numa_id = kDefaultNumaNode) const override;
virtual bool GetSvmAttributes(void** data, size_t* data_sizes, int* attributes,
size_t num_attributes, const void* dev_ptr, size_t count) const;
size_t num_attributes, const void* dev_ptr, size_t count) const override;
virtual size_t ScratchLimitCurrent() const final;
virtual bool UpdateScratchLimitCurrent(size_t limit) const final;
virtual void* virtualAlloc(void* req_addr, size_t size, size_t alignment);
virtual bool virtualFree(void* addr);
virtual void* virtualAlloc(void* req_addr, size_t size, size_t alignment) override;
virtual bool virtualFree(void* addr) override;
virtual bool SetMemAccess(void* va_addr, size_t va_size, VmmAccess access_flags,
VmmLocationType = VmmLocationType::kDevice);
virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) const;
virtual bool ValidateMemAccess(amd::Memory& mem, bool read_write) const { return true; }
VmmLocationType = VmmLocationType::kDevice) override;
virtual bool GetMemAccess(void* va_addr, VmmAccess* access_flags_ptr) const override;
virtual bool ValidateMemAccess(amd::Memory& mem, bool read_write) const override { return true; }
virtual bool ExportShareableVMMHandle(amd::Memory& amd_mem_obj, int flags, void* shareableHandle);
virtual bool ExportShareableVMMHandle(amd::Memory& amd_mem_obj, int flags, void* shareableHandle) override;
bool ImportShareableHSAHandle(void* osHandle, uint64_t* hsa_handle_ptr) const;
virtual amd::Memory* ImportShareableVMMHandle(void* osHandle);
virtual amd::Memory* ImportShareableVMMHandle(void* osHandle) override;
virtual bool SetClockMode(const cl_set_device_clock_mode_input_amd setClockModeInput,
cl_set_device_clock_mode_output_amd* pSetClockModeOutput);
cl_set_device_clock_mode_output_amd* pSetClockModeOutput) override;
virtual bool IsHwEventReady(const amd::Event& event, bool wait = false,
amd::SyncPolicy policy = amd::SyncPolicy::Auto) const;
virtual void getHwEventTime(const amd::Event& event, uint64_t* start, uint64_t* end) const;
virtual void ReleaseGlobalSignal(void* signal) const;
virtual bool CreateUserEvent(amd::UserEvent* event) const;
virtual void SetUserEvent(amd::UserEvent* event) const;
amd::SyncPolicy policy = amd::SyncPolicy::Auto) const override;
virtual void getHwEventTime(const amd::Event& event, uint64_t* start, uint64_t* end) const override;
virtual void ReleaseGlobalSignal(void* signal) const override;
virtual bool CreateUserEvent(amd::UserEvent* event) const override;
virtual void SetUserEvent(amd::UserEvent* event) const override;
//! Allocate host memory in terms of numa policy set by user
void* hostNumaAlloc(size_t size, size_t alignment, MemorySegment mem_seg) const;
@@ -545,7 +545,7 @@ class Device : public NullDevice {
address MGSync() const { return mg_sync_; }
//! Returns value for corresponding Link Attributes in a vector, given other device
virtual bool findLinkInfo(const amd::Device& other_device, std::vector<LinkAttrType>* link_attr);
virtual bool findLinkInfo(const amd::Device& other_device, std::vector<LinkAttrType>* link_attr) override;
//! Returns a GPU memory object from AMD memory object
roc::Memory* getGpuMemory(amd::Memory* mem //!< Pointer to AMD memory object
@@ -560,11 +560,11 @@ class Device : public NullDevice {
static void RegisterBackendErrorCb();
virtual amd::Memory* GetArenaMemObj(const void* ptr, size_t& offset, size_t size = 0);
virtual amd::Memory* GetArenaMemObj(const void* ptr, size_t& offset, size_t size = 0) override;
virtual uint32_t getPreferredNumaNode() const final { return preferred_numa_node_; }
const bool isFineGrainSupported() const;
const bool isFineGrainSupported() const override;
//! Returns True if memory pointer is known to ROCr (excludes HMM allocations)
bool IsValidAllocation(const void* dev_ptr, size_t size, hsa_amd_pointer_info_t* ptr_info);
@@ -574,7 +574,7 @@ class Device : public NullDevice {
//! Init hidden heap for device memory allocations
void HiddenHeapInit(const VirtualGPU& gpu);
void getSdmaRWMasks(uint32_t* readMask, uint32_t* writeMask) const;
bool isXgmi() const { return isXgmi_; }
bool isXgmi() const override { return isXgmi_; }
//! Returns the map of code objects to kernels
const auto& KernelMap() const { return kernel_map_; }
projects/clr/rocclr/device/rocm/rocprogram.hpp
+2 -2
View File
@@ -57,7 +57,7 @@ class Program : public device::Program {
}
virtual bool createGlobalVarObj(amd::Memory** amd_mem_obj, void** device_pptr, size_t* bytes,
const char* global_name) const;
const char* global_name) const override;
protected:
//! Disable default copy constructor
@@ -65,7 +65,7 @@ class Program : public device::Program {
//! Disable operator=
Program& operator=(const Program&) = delete;
virtual bool defineGlobalVar(const char* name, void* dptr);
virtual bool defineGlobalVar(const char* name, void* dptr) override;
bool createBinary(amd::option::Options* options) override final;
projects/clr/rocclr/platform/command.hpp
+3 -3
View File
@@ -502,7 +502,7 @@ class OneMemoryArgCommand : public Command {
memory_->retain();
}
virtual void releaseResources() {
virtual void releaseResources() override {
memory_->release();
DEBUG_ONLY(memory_ = NULL);
Command::releaseResources();
@@ -510,14 +510,14 @@ class OneMemoryArgCommand : public Command {
}
//! Release all pinned memory for this command
virtual void ReleasePinnedMemory() {
virtual void ReleasePinnedMemory() override {
for (auto it : pinned_memory_) {
it->release();
}
pinned_memory_.clear();
}
//! Release all pinned memory for this command
virtual bool IsMemoryPinned() const { return !pinned_memory_.empty(); }
virtual bool IsMemoryPinned() const override { return !pinned_memory_.empty(); }
//! Adds pinned memory, used in this command for later release
virtual void AddPinnedMemory(Memory* pinned) override { pinned_memory_.push_back(pinned); }
projects/hip/VERSION
+1 -1
View File
@@ -3,4 +3,4 @@
#HIP_VERSION_MINOR
2
#HIP_VERSION_PATCH
0
53150