cudaMemGetInfo runs asynchronously with cudaMalloc - cuda

Question

I have been trying to see whether we can cudaMalloc the amount of free memory returned by cudaMemGetInfo. But I encounter a strange problem: the cudaMalloc seems to run before the cudaMemGetInfo, as a result of which the latter returns available memory as zero. How do I enforce no reordering of the calls?
Here is the code:
#include <stdio.h>
#include <cuda.h>
#define cudaMallocError(s) error = cudaGetLastError();\
if (error != cudaSuccess)\
{\
printf("CUDA Error: %s\n", cudaGetErrorString(error));\
printf("Failed to cudaMalloc %s\n", s);\
exit(1);\
}
int main()
{
size_t f, t;
int * x;
cudaError_t error;
cudaMemGetInfo(&f, &t);
error = cudaGetLastError();
if (error != cudaSuccess)
{
printf("cudaMemGetInfo went wrong!\n");
printf("Error: %s\n", cudaGetErrorString(error));
}
printf("Available memory = %ld\n", f);
cudaDeviceSynchronize();
cudaMalloc(&x, f);
cudaMallocError("x");
cudaFree(x);
printf("Success\n");
return 0;
}
It is triggering both the error-handling codes. This is the output:
cudaMemGetInfo went wrong!
Error: out of memory
Available memory = 0
CUDA Error: out of memory
Failed to cudaMalloc x
But if I altogether remove the call to cudaMalloc, then it shows available memory as some non-zero value, clearly indicating that it is calling cudaMalloc before cudaMemGetInfo, even though the latter appears before the former in program order. Why is this so?

Answer 1

There is no reordering. cudaMalloc is executed after cudaMemGetInfo.
You are probably just observing physical memory allocation granularity. The requested bytes are rounded up to physical memory page size. However, if this results in more physical memory requested than available, the allocation fails.
On my machine, it seems to be sufficient to round down the free bytes to the next smallest multiple of 2 megabytes.