Thread: What is with this error?

This error is generated 3 times in reference to the code below. It has to do with the [][] operators. CUDA:: DeviceMemory<> is a class I defined, almost identical to a std::vector<> class type, with the [] operators behaving the same as vector's would. I am lead to think it is being generated by the [] operators, yet I don't know how to solve it, especially since I have it working in another part of the code. Any help on what this error means, or what causes it would be appreciated.

Code:

error: operand of "*" must be a pointer

Code:

// code that does not compile, and generates above error
__global__ void Kernel_square2d(CUDA::DeviceMemory< CUDA::DeviceMemory<float> > a)
{
	const int idx = blockIdx.x * blockDim.x + threadIdx.x; // these are just for indexing
	const int idy = blockIdx.y * blockDim.y + threadIdx.y; // indexing

	if (idx < a.size() && idy < a[idx].size()) {
		a[idx][idy] = a[idx][idy] + a[idx][idy]; // get an error here, 3 times, one for each a[idx][idy]
	}
}

// code that does work, HostMemory is virtually identical to DeviceMemory.
        // make a 2D array
	printf("Allocating a 10x10 2 dimensional array of type float\n");

	HostMemory< HostMemory<float> > twoDimArray;
	twoDimArray.allocate(10);

	for(unsigned int i = 0; i < twoDimArray.size(); i++) {
		twoDimArray[i].allocate(10);
	}

	// assign values to the 2D array
	printf("Assigning values of 10x10 matrix\n");

	for(unsigned int i = 0; i < twoDimArray.size(); i++) {
		for(unsigned int n = 0; n < twoDimArray[i].size(); n++) {
			twoDimArray[i][n] = twoDimArray.size()*i + n;
		}
	}

I have it defined twice, one for modifying the value, and one for accessing the value. I've used this operator before when I made different 3d vector classes. It still blows my mind as to why it will work in one instance, but not in another.

memoryType is from the definition of the class, CUDA:: DeviceMemory<class memoryType>. the variable memory that is being returned is a pointer of type memoryType.

Code:

// in the definition

private:
	memoryType* memory;

// elsewhere in the definition

memoryType& operator [] (const int a)
{
	return memory[a];
}

memoryType operator [] (const int a) const
{
	return memory[a];
}

Originally Posted by whiteflags

You could be using two operator[]s from different classes. Say memoryType is an array class, and the array is a pointer array--the rows of your matrix. memoryType uses it's operator[] to return the pointer element. Then the pointer's operator[] indexes the column part of your matrix.

There are other things people like to do... like memory(a , b). Or you could use member functions instead of overloading operators.

I did not think of that, and that would make total sense since that is basically what is happening, and that's a very good solution. I may go that route and "fake" a 2 dimensional array. I am trying to program this in to a CUDA kernel for an nVidia card (if anyone has heard of this). Turns out 2 dimensional arrays are not advised on kernels since allocating a 2D array on the GPU is still in a linear block or memoy anywho (possibly on the host also?). The best bet is to flatten the 2 dimensional array in to a single dimension.

Or maybe I'll just stick with a single dimensioned array since that works perfectly

Your class might also support a unary operator *(), and that is causing some form of ambiguity.

More generally, however, you will have more chance finding the cause of your problem by providing a small but complete example of code that exhibits your concern. Paraphrasing, as you are, means you are making an assumption about where the problem is. When people do that, they often leave out a key bit of information that is relevant to solving their problem because they considered it irrelevant.

Originally Posted by scwizzo

I did not think of that, and that would make total sense since that is basically what is happening, and that's a very good solution. I may go that route and "fake" a 2 dimensional array. I am trying to program this in to a CUDA kernel for an nVidia card (if anyone has heard of this). Turns out 2 dimensional arrays are not advised on kernels since allocating a 2D array on the GPU is still in a linear block or memoy anywho (possibly on the host also?). The best bet is to flatten the 2 dimensional array in to a single dimension.

Or maybe I'll just stick with a single dimensioned array since that works perfectly

You can make a 2D array contiguous.
Example using new:
int (*p)[100] = new int[100][100];