Share pointer between two classes in CUDA - cuda

Question

I would like to create a vertices and edge structure with CUDA.
I have two classes.
Connection {
public:
float value;
Connection()
{
this->value = 0;
}
}
Node
{
public:
Connection *incoming;
Connection *outgoing;
int lenIncoming;
int lenOutgoing;
node(Connection *incoming, Connection *outgoing, int lenIncoming, int lenOutgoing)
{
this->incoming = incoming;
this->outgoing = outgoing;
this->lenIncoming = lenIncoming;
this->lenOutgoing = lenOutgoing;
}
}
When I "connect" the nodes, I do the following:
Connection XA = Connection(10);
Connection AB = Connection(2);
Connection XB = Connection(10);
Connection BX = Connection(2);
Connection* incomingA;
Connection* outgoingA;
Connection* ingoingB;
Connection* outgoingB;
cudaMallocManaged(&incomingA, 1 * sizeof(Connection*));
cudaMallocManaged(&outgoingA, 1 * sizeof(Connection*));
cudaMallocManaged(&ingoingB, 2 * sizeof(Connection*));
cudaMallocManaged(&outgoingB, 1 * sizeof(Connection*));
incomingA[0] = XA;
outgoingA[0] = AB;
incomingB[0] = XB;
incomingB[1] = AB;
outgoingB[0]= BX;
Node nodeA = Node(incomingA, outgoingA);
Node nodeB = Node(incomingB, outgoingB);
The thing I would like to happen is when I change the value of nodaA->outgoing[0].value from within a method in Node, it should impact nodaB.incoming[1].value, however that is not the case.
When I change the value from within nodeA, it remains the starting value in nodeB. I thought since I passed a copy of the pointer to the object, I would mean that it updated the original object, however it seems I am mistaken, or I have made some error along the way.
Any suggestions on how this should be done, will be greatly appreciated.
(BTW; The reason I use a class Connection instead of just Floats, is that in the future it will include more)
The classes are created on host.
Node has a method called run, which is running on the device.
__device__ __host__
run()
{
for(int i=0; i<this->lenIncoming; i++)
{
this->incoming[i].value += 1;
}
for(int i=0; i< this->lenOutgoing; i++)
{
this->outgoing[i].value += 2;
}
}
Which in turn is called from a kernel
__global__
void kernel_run(node *nodes)
{
node[0].run();
node[1].run();
};
The kernel is launched by running
kernel_run<<<1, 1>> > (nodes);
I can see that the value changes locally within nodeA, when debugging with Nsight.

Answer 1

As you have already mentioned, the problem is that the objects AB, XB, BX, etc. are being assigned by value rather than by reference, so copies are made of each object each time it is used (i.e. each time it is assigned to an incoming or outgoing connection), and the update to AB from one operation does not affect any other instance of AB.
One possible solution is to make all of your objects "singletons" and refer to them by reference. To make this work on both host and device we will allocate for these objects using cudaMallocManaged. Here's an example:
$ cat t1494.cu
#include <iostream>
class Connection {
public:
float value;
Connection()
{
this->value = 0;
}
Connection(float val)
{
this->value = val;
}
};
class Node
{
public:
Connection **incoming;
Connection **outgoing;
int lenIncoming;
int lenOutgoing;
Node(Connection **incoming, Connection **outgoing, int lenIncoming, int lenOutgoing)
{
this->incoming = incoming;
this->outgoing = outgoing;
this->lenIncoming = lenIncoming;
this->lenOutgoing = lenOutgoing;
}
__device__ __host__
void run()
{
for(int i=0; i<this->lenIncoming; i++)
{
this->incoming[i]->value += 1;
}
for(int i=0; i< this->lenOutgoing; i++)
{
this->outgoing[i]->value += 2;
}
}
};
__global__
void kernel_run(Node *nodes)
{
nodes[0].run();
nodes[1].run();
};
int main(){
Connection *XA;
cudaMallocManaged(&XA, sizeof(Connection));
*XA = Connection(10);
Connection *AB;
cudaMallocManaged(&AB, sizeof(Connection));
*AB = Connection(2);
Connection *XB;
cudaMallocManaged(&XB, sizeof(Connection));
*XB = Connection(10);
Connection *BX;
cudaMallocManaged(&BX, sizeof(Connection));
*BX = Connection(2);
Connection ** incomingA;
Connection ** outgoingA;
Connection ** incomingB;
Connection ** outgoingB;
cudaMallocManaged(&incomingA, 1 * sizeof(Connection*));
cudaMallocManaged(&outgoingA, 1 * sizeof(Connection*));
cudaMallocManaged(&incomingB, 2 * sizeof(Connection*));
cudaMallocManaged(&outgoingB, 1 * sizeof(Connection*));
incomingA[0] = XA;
outgoingA[0] = AB;
incomingB[0] = XB;
incomingB[1] = AB;
outgoingB[0]= BX;
Node *nodes;
cudaMallocManaged(&nodes, 2 * sizeof(Node));
nodes[0] = Node(incomingA, outgoingA, 1, 1);
nodes[1] = Node(incomingB, outgoingB, 2, 1);
std::cout << nodes[0].incoming[0]->value << std::endl;
std::cout << nodes[0].outgoing[0]->value << std::endl;
std::cout << nodes[1].incoming[0]->value << std::endl;
std::cout << nodes[1].incoming[1]->value << std::endl;
std::cout << nodes[1].outgoing[0]->value << std::endl;
kernel_run<<<1, 1>> > (nodes);
cudaDeviceSynchronize();
std::cout << nodes[0].incoming[0]->value << std::endl;
std::cout << nodes[0].outgoing[0]->value << std::endl;
std::cout << nodes[1].incoming[0]->value << std::endl;
std::cout << nodes[1].incoming[1]->value << std::endl;
std::cout << nodes[1].outgoing[0]->value << std::endl;
}
$ nvcc -o t1494 t1494.cu
$ cuda-memcheck ./t1494
========= CUDA-MEMCHECK
10
2
10
2
2
11
5
11
5
4
========= ERROR SUMMARY: 0 errors
$
Note that this system works fine for updating these objects from a single thread. It is not guaranteed to work correctly if you update an object from separate CUDA threads. CUDA does not automatically sort out that kind of multi-thread concurrent access for you. It may be possible to use atomics or some other method, however.
Note that my objective has been to address the original design presented and identify a relatively minor design modification that would meet the stated request. I'm not intending to make any statements about the relative performance merits of this approach, or the suitability of this or any other approach for graph traversal algorithms.