Memory alignment function using pointers - c++

Question

I am trying to modify an existing code to make use of the memory align function below:
void* acl_aligned_malloc (size_t size)
{
void *result = NULL;
posix_memalign (&result, ACL_ALIGNMENT, size);
return result;
}
The function is taken from one of the examples provided by the vendor, and I am trying to optimize the execution of my code by incorporating the recommended function. This is how the function is used in the examples:
static void *X;
X = (void *) acl_aligned_malloc(sizeof(cl_float) * vectorSize);
initializeVector((float*)X, vectorSize);
status = clEnqueueWriteBuffer(queue, kernelX, CL_FALSE, 0, sizeof(cl_float) * vectorSize, X, 0, NULL, NULL);
Observe that the code uses pointer *X to hold the return value of the memory align function. However, the data type that I am working with is not pointer, but of vector float type called vec_t.
vec_t input_;
How can I adapt vec_t input_ to use the memory align function? I have tried the modification below, but I am getting segmentation fault error. Should I change vec_t into a pointer? How can I do that?
void *X;
vec_t input_;
X = (void *) acl_aligned_malloc(batch_size * in_width_ * in_height_ * in_depth_ * sizeof(cl_float));
input_ = *((vec_t*) X);
queue.enqueueWriteBuffer(input_batch_buf, CL_TRUE, 0, batch_size * in_width_ * in_height_ * in_depth_ * sizeof(cl_float), &input_[0]);

Answer 1

"the data type that I am working with is ... of vector float type"
This is going to cause you problems. Vectors handle their own internal storage structures. There is no way to manually manipulate those that I know of (nor would you want to, you'd have to manage the size and capacity variables too and that would get messy). Also as far as I know, there is no way to guarantee memory alignment with vectors.
When I've optimized code on Windows that required aligned memory (SIMD stuff), I implemented a template function [you could use a void*, but if you put types on it then you just have to use the intended size of the array instead of intended size * sizeof()] to allocate aligned memory with _aligned_malloc. I also had the function throw a std::bad_alloc if the alloc came back with a null pointer. You'll also have to implement a custom deleter for the associated free function (_aligned_free in my case). Then I type def'ed all of the types I'd use ("aligned_complex", "aligned_float", etc).
With unique_ptrs and throwing std::bad_alloc you can make it easy to use aligned memory in a very C++/RAII fashion, but not with vectors. I hope they change that someday, it'd make life easier.

Answer 2

input, as in:
vec_t input_;
Will have enough memory to hold only the size of one vec_t element. Now I see that in the call to acl_aligned_malloc() you might want to allocate space for a multidimensional array (which most likely will be larger that vec_t).
Then, when you do:
input_ = *((vec_t*) X);
You are copying only the size of one vec_t element from all the space allocated at the address pointed by X.
Then in this call:
queue.enqueueWriteBuffer(input_batch_buf, CL_TRUE, 0, batch_size * in_width_ * in_height_ * in_depth_ * sizeof(cl_float), &input_[0]);
Which might be a wrapper for 'clEnqueueWriteBuffer' you are declaring that you want to operate the whole size of memory allocated to 'X', instead of only the size of 'vec_t' (which is the memory allocated to 'input_'). Hence the memory overflow.
My suggestion would be making 'input_' a pointer to the type that you want, and use pointer casting.
What happens if you do this?
vec_t *input_;
input_ = (vec_t *) acl_aligned_malloc(batch_size * in_width_ * in_height_ * in_depth_ * sizeof(cl_float));
queue.enqueueWriteBuffer(input_batch_buf, CL_TRUE, 0, batch_size * in_width_ * in_height_ * in_depth_ * sizeof(cl_float), (void *) &input_[0]);