2 Nov
2009
2 Nov
'09
2:09 p.m.
Hi all,
Just wondering if there is any scope for mapping between host and device
data which is in vector formats? I couldn't see anything obvious in the
documentation, but for example if you had (in openCL, from memory):
float4 v = float4(1,2,3,4);
then could this somehow be mapped/copied into host memory, or do all
vector variables exist only in device memory?
I ask since in python I have something like:
self.r = zeros((num_particles,3))
and it would be great to be able to map this directly into a vector
variable in device-space (perhaps with a fourth data element!), rather
than needing to have:
self.r0 = zeros(num_particles)
self.r1 = zeros(num_particles)
self.r2 = zeros(num_particles)
and copy each across to separate arrays in device space and then also
convert them into vector memory in device space, if I want vector
operations.
Of course, this partly assumes that vector operations are even
worthwhile at the current stage of development...any anecdotal or other
evidence, anyone?
Thanks Andreas - all working so far!
--
Neil
3 Nov
3 Nov
4:10 a.m.
Hi Neil,
On Montag 02 November 2009, Neil Pilgrim wrote:
Just wondering if there is any scope for mapping
between host and device
data which is in vector formats? I couldn't see anything obvious in the
documentation, but for example if you had (in openCL, from memory):
float4 v = float4(1,2,3,4);
then could this somehow be mapped/copied into host memory, or do all
vector variables exist only in device memory?
You can easily mimic the vector types' memory layout in numpy. Just make sure
that the stride of the relevant dimension (see myarray.strides, in bytes) is
the smallest one. The example you give:
I ask since in python I have something like:
self.r = zeros((num_particles,3))
should already work perfectly for a double3 (if such a thing existed in
vanilla CL).
Of course, this partly assumes that vector operations
are even
worthwhile at the current stage of development...any anecdotal or other
evidence, anyone?
None, sorry. In CUDA, the answer depends on a number of factors, too.
Andreas
11 Nov
11 Nov
3:17 p.m.
Hi Andreas,
Andreas Klöckner wrote:
Eventually I might manage to investigate this... [sigh]
Thanks again,
--
Neil
On Montag 02 November 2009, Neil Pilgrim wrote:
[...]
You can easily mimic the vector types' memory
layout in numpy. Just make sure
that the stride of the relevant dimension (see myarray.strides, in bytes) is
the smallest one. The example you give:
So to clarify, a numpy array of:
arr = zeros((N,4),dtype=float32)
should be able to be converted to a buffer buf and then accessed via
something like the following in a kernel:
float *off = buf + get_global_id(0)*4;
float4 v = float4(off,off+1,off+2,off+3);
...followed by various vector operations on v.
Perhaps there is some better way, or is this the expectation of how
vectors are going to be used/coded?
I assume that one kernel function could be called from the host to
declare __local arrays in a particular format (vector or otherwise) and
which are initialized from host memory, ie. the data on the card is
"known" as being in float4. Or perhaps the assumption is that
constructing vector variables 'on the fly' is sufficient, as above.
There doesn't seem to be much guidance on this, from what I've seen so
far - and CUDA doesn't seem to focus on vector operation support too
much in comparison, though I've not read anywhere near as much about
CUDA as openCL.
I ask since in python I have something like:
self.r = zeros((num_particles,3))
should already work perfectly for a double3 (if such a thing existed in
vanilla CL). Of course,
this partly assumes that vector operations are even
worthwhile at the current stage of development...any anecdotal or other
evidence, anyone?
None, sorry. In CUDA, the answer depends on a number of factors, too.
3:47 p.m.
On Mittwoch 11 November 2009, Neil Pilgrim wrote:
Hi Andreas,
Andreas Klöckner wrote:
Just declare buf to be "float4 *", and then use
float4 v = buf[get_global_id(0)];
Realize that there is no type checking at the Python-CL boundary.
Andreas
On Montag 02 November 2009, Neil Pilgrim wrote:
[...]
You can easily mimic the vector types' memory
layout in numpy. Just make
sure that the stride of the relevant dimension (see myarray.strides, in
bytes) is
the smallest one. The example you give:
So to clarify, a numpy array of:
arr = zeros((N,4),dtype=float32)
should be able to be converted to a buffer buf and then accessed via
something like the following in a kernel:
float *off = buf + get_global_id(0)*4;
float4 v = float4(off,off+1,off+2,off+3); I ask since in python I have something like:
self.r = zeros((num_particles,3))
should already work perfectly for a double3 (if such a thing existed in
vanilla CL).
4131
days inactive
4140
days old
3 comments
2 participants
participants (2)
-
Andreas Klöckner -
Neil Pilgrim