Skip to content

Fix the GPU Memory Tests #213

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
MrBurmark merged 10 commits into from
Jul 23, 2026
Merged

Fix the GPU Memory Tests #213

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
10 commits
Select commit Hold shift + click to select a range
62596bc
Fix resource allocators with 0 size
MrBurmark Jul 14, 2026
485b3e4
Remove MemoryAccess::Unknown tests
MrBurmark Jul 15, 2026
7f8689f
Unify resource memory 0 size handling
MrBurmark Jul 15, 2026
6d0ab82
Unify MemoryAccess::Unknown behavior
MrBurmark Jul 15, 2026
0d73df9
Fix Hip Managed lookup deallocation failure
MrBurmark Jul 15, 2026
a4f5c35
Remove ifdef for hip >= 6
MrBurmark Jul 15, 2026
c83fe4b
Explicitly handle null pointers in Omp registration
MrBurmark Jul 15, 2026
af0ee60
Alloc calloc to return nullptr
MrBurmark Jul 15, 2026
c10081b
Use std::calloc in Host::calloc
MrBurmark Jul 22, 2026
bc4c594
Merge branch 'main' into bugfix/burmark1/res_mem_test
rhornung67 Jul 23, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
6 changes: 3 additions & 3 deletions include/camp/resource.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -109,15 +109,15 @@ namespace resources
}

template <typename T>
T* allocate(size_t size, MemoryAccess ma = MemoryAccess::Device)
T* allocate(size_t n, MemoryAccess ma = MemoryAccess::Device)
{
if (size == 0) {
if (n == 0) {
return nullptr;
}
if (!m_value) {
::camp::throw_re("Empty Resource type allocate call.");
}
return (T*)m_value->allocate(size * sizeof(T), ma);
return (T*)m_value->allocate(n * sizeof(T), ma);
}

void* calloc(size_t size, MemoryAccess ma = MemoryAccess::Device)
Expand Down
83 changes: 48 additions & 35 deletions include/camp/resource/cuda.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -184,14 +184,14 @@ namespace resources
cudaError_t status = cudaPointerGetAttributes(&a, p);
if (status == cudaSuccess) {
switch (a.type) {
case cudaMemoryTypeUnregistered:
return MemoryAccess::Unknown;
case cudaMemoryTypeHost:
return MemoryAccess::Pinned;
case cudaMemoryTypeDevice:
return MemoryAccess::Device;
case cudaMemoryTypeManaged:
return MemoryAccess::Managed;
default:
return MemoryAccess::Unknown;
}
}
::camp::throw_re("invalid pointer detected");
Expand Down Expand Up @@ -272,44 +272,55 @@ namespace resources

// Memory
template <typename T>
T* allocate(size_t size, MemoryAccess ma = MemoryAccess::Device)
T* allocate(size_t n, MemoryAccess ma = MemoryAccess::Device)
{
if (n == 0) {
return nullptr;
}
T* ret = nullptr;
if (size > 0) {
auto d{device_guard(device)};
switch (ma) {
case MemoryAccess::Unknown:
case MemoryAccess::Device:
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMalloc,
(void**)&ret,
sizeof(T) * size);
break;
case MemoryAccess::Pinned:
// TODO: do a test here for whether managed is *actually* shared
// so we can use the better performing memory
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMallocHost,
(void**)&ret,
sizeof(T) * size);
break;
case MemoryAccess::Managed:
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMallocManaged,
(void**)&ret,
sizeof(T) * size);
break;
}
auto d{device_guard(device)};
switch (ma) {
case MemoryAccess::Device:
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMalloc,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Pinned:
// TODO: do a test here for whether managed is *actually* shared
// so we can use the better performing memory
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMallocHost,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Managed:
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMallocManaged,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Unknown:
::camp::throw_re("Unknown memory access type, cannot allocate");
break;
}
return ret;
}

void* calloc(size_t size, MemoryAccess ma = MemoryAccess::Device)
{
void* p = allocate<char>(size, ma);
this->memset(p, 0, size);
return p;
if (size == 0) {
return nullptr;
}
void* ret = allocate<char>(size, ma);
if (ret != nullptr) {
this->memset(ret, 0, size);
}
return ret;
}

void deallocate(void* p, MemoryAccess ma = MemoryAccess::Unknown)
{
if (p == nullptr) {
return;
}
auto d{device_guard(device)};
if (ma == MemoryAccess::Unknown) {
ma = get_access_type(p);
Expand All @@ -334,19 +345,21 @@ namespace resources

void memcpy(void* dst, const void* src, size_t size)
{
if (size > 0) {
auto d{device_guard(device)};
CAMP_CUDA_API_INVOKE_AND_CHECK(
cudaMemcpyAsync, dst, src, size, cudaMemcpyDefault, stream);
if (size == 0) {
return;
}
auto d{device_guard(device)};
CAMP_CUDA_API_INVOKE_AND_CHECK(
cudaMemcpyAsync, dst, src, size, cudaMemcpyDefault, stream);
}

void memset(void* p, int val, size_t size)
{
if (size > 0) {
auto d{device_guard(device)};
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemsetAsync, p, val, size, stream);
if (size == 0) {
return;
}
auto d{device_guard(device)};
CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemsetAsync, p, val, size, stream);
}

cudaStream_t get_stream() const { return stream; }
Expand Down
85 changes: 47 additions & 38 deletions include/camp/resource/hip.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -184,16 +184,12 @@ namespace resources
hipPointerAttribute_t a;
hipError_t status = hipPointerGetAttributes(&a, p);
if (status == hipSuccess) {
#if (HIP_VERSION_MAJOR >= 6)
switch (a.type) {
#else
switch (a.memoryType) {
#endif
case hipMemoryTypeHost:
return MemoryAccess::Pinned;
case hipMemoryTypeDevice:
return MemoryAccess::Device;
case hipMemoryTypeUnified:
case hipMemoryTypeManaged:
return MemoryAccess::Managed;
default:
return MemoryAccess::Unknown;
Expand Down Expand Up @@ -274,44 +270,55 @@ namespace resources

// Memory
template <typename T>
T* allocate(size_t size, MemoryAccess ma = MemoryAccess::Device)
T* allocate(size_t n, MemoryAccess ma = MemoryAccess::Device)
{
if (n == 0) {
return nullptr;
}
T* ret = nullptr;
if (size > 0) {
auto d{device_guard(device)};
switch (ma) {
case MemoryAccess::Unknown:
case MemoryAccess::Device:
CAMP_HIP_API_INVOKE_AND_CHECK(hipMalloc,
(void**)&ret,
sizeof(T) * size);
break;
case MemoryAccess::Pinned:
// TODO: do a test here for whether managed is *actually* shared
// so we can use the better performing memory
CAMP_HIP_API_INVOKE_AND_CHECK(hipHostMalloc,
(void**)&ret,
sizeof(T) * size);
break;
case MemoryAccess::Managed:
CAMP_HIP_API_INVOKE_AND_CHECK(hipMallocManaged,
(void**)&ret,
sizeof(T) * size);
break;
}
auto d{device_guard(device)};
switch (ma) {
case MemoryAccess::Device:
CAMP_HIP_API_INVOKE_AND_CHECK(hipMalloc,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Pinned:
// TODO: do a test here for whether managed is *actually* shared
// so we can use the better performing memory
CAMP_HIP_API_INVOKE_AND_CHECK(hipHostMalloc,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Managed:
CAMP_HIP_API_INVOKE_AND_CHECK(hipMallocManaged,
(void**)&ret,
sizeof(T) * n);
break;
case MemoryAccess::Unknown:
::camp::throw_re("Unknown memory access type, cannot allocate");
break;
}
return ret;
}

void* calloc(size_t size, MemoryAccess ma)
{
void* p = allocate<char>(size, ma);
this->memset(p, 0, size);
return p;
if (size == 0) {
return nullptr;
}
void* ret = allocate<char>(size, ma);
if (ret != nullptr) {
this->memset(ret, 0, size);
}
return ret;
}

void deallocate(void* p, MemoryAccess ma = MemoryAccess::Unknown)
{
if (p == nullptr) {
return;
}
auto d{device_guard(device)};
if (ma == MemoryAccess::Unknown) {
ma = get_access_type(p);
Expand All @@ -336,19 +343,21 @@ namespace resources

void memcpy(void* dst, const void* src, size_t size)
{
if (size > 0) {
auto d{device_guard(device)};
CAMP_HIP_API_INVOKE_AND_CHECK(
hipMemcpyAsync, dst, src, size, hipMemcpyDefault, stream);
if (size == 0) {
return;
}
auto d{device_guard(device)};
CAMP_HIP_API_INVOKE_AND_CHECK(
hipMemcpyAsync, dst, src, size, hipMemcpyDefault, stream);
}

void memset(void* p, int val, size_t size)
{
if (size > 0) {
auto d{device_guard(device)};
CAMP_HIP_API_INVOKE_AND_CHECK(hipMemsetAsync, p, val, size, stream);
if (size == 0) {
return;
}
auto d{device_guard(device)};
CAMP_HIP_API_INVOKE_AND_CHECK(hipMemsetAsync, p, val, size, stream);
}

hipStream_t get_stream() const { return stream; }
Expand Down
24 changes: 20 additions & 4 deletions include/camp/resource/host.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -114,27 +114,43 @@ namespace resources
template <typename T>
T* allocate(size_t n, MemoryAccess = MemoryAccess::Device)
{
if (n == 0) {
return nullptr;
}
return (T*)std::malloc(sizeof(T) * n);
}

void* calloc(size_t size, MemoryAccess = MemoryAccess::Device)
{
void* p = allocate<char>(size);
this->memset(p, 0, size);
return p;
if (size == 0) {
return nullptr;
}
return std::calloc(size, 1);
}

void deallocate(void* p, MemoryAccess = MemoryAccess::Device)
{
if (p == nullptr) {
return;
}
std::free(p);
}

void memcpy(void* dst, const void* src, size_t size)
{
if (size == 0) {
return;
}
std::memcpy(dst, src, size);
}

void memset(void* p, int val, size_t size) { std::memset(p, val, size); }
void memset(void* p, int val, size_t size)
{
if (size == 0) {
return;
}
std::memset(p, val, size);
}

/*
* \brief Compares two (Host) resources to see if they are equal
Expand Down
Loading
Loading