How to index, slice, and assign values to arrays

[cadop]

I have been trying to make a 'cheatsheet' for referencing some of the basic utilities in warp that I can't find in the getting started/basics documentation.

One common issue I have run into is how to index and then assign values to arrays, especially for global scope.

Below is an example script with some commented out code and the corresponding errors below it.

I think this is made up of;

1. What is the difference with assigning a warp array outside of a kernel/function and within
2. Can each dimension of an array be assigned like in numpy (and does it matter if its in a kernel or function
3. What does it mean when an array or type is not supported
4. (probably some more cases, but maybe some context for these will help me contextualize the rest)

'''
Examples of using basic functions like loops and arrays
'''

import warp as wp

wp.init()
wp.set_device("cpu")

########################################################
# ### Test for making a full array and assigning
row_cnt = 1000
twoD_floats = wp.full((row_cnt, 2), 9999999.0, dtype=float, device='cpu') # would be nice to have inf
# twoD_floats[0,0] = 1 
####### >>> TypeError: 'array' object does not support item assignment


########################################################
twoD_vec = wp.full((row_cnt), 9999999.0, dtype=wp.vec2, device='cpu') # would be nice to have inf
vec2Data = wp.vec2(666.0,666.0)
# vec2Data[0] = vec2Data 
####### >>> TypeError: incompatible types, vec2f instance instead of c_float instance
########################################################


####################################################################################
twoD_vec_shape = wp.full(shape=(1024,2), value=9999999.0, dtype=wp.vec2, device='cpu')
# twoD_vec_shape[0,0] = wp.vec2(666.0,666.0) 
####### >>> TypeError: 'array' object does not support item assignment


@wp.kernel
def simple_kernel(a: wp.array(dtype=wp.vec3),
                  b: wp.array(dtype=wp.vec3),
                  c: wp.array(dtype=float)):

    # get thread index
    tid = wp.tid()

    # load two vec3s
    x = a[tid]
    y = b[tid]

    # Do this in a function instead
    # r = wp.dot(x, y)
    r = get_r(x, y)

    ######################################################################
    # Modify twoD_floats in kernel
    # twoD_floats[0,0] = 1.0
    ####### >>> 'array' object has no attribute 'type'
    #############################################################################

    # write result back to memory
    c[tid] = r



@wp.func
def get_r(x: wp.vec3,
          y: wp.vec3
          ):

    # Modify the x value
    x[0] = 1.0 + x[0]

    #############################################################################
    # Modify twoD_floats in func
    # twoD_floats[0,0] = 1 
    ####### >>> 'array' object has no attribute 'type'
    #############################################################################
    
    # compute the dot product between vectors
    r = wp.dot(x, y)

    return r

a = wp.full(shape=(1024), value=2.0, dtype=wp.vec3, device='cpu')
b = wp.full(shape=(1024), value=2.0, dtype=wp.vec3, device='cpu')
c = wp.full(shape=(1024), value=99999.0, dtype=float, device='cpu')


wp.launch(kernel=simple_kernel, # kernel to launch
          dim=1024,             # number of threads
          inputs=[a, b, c],     # parameters
          device="cpu")        # execution device

[christophercrouzet]

Hi @cadop,

Thanks for opening this issue and apologies for not getting back to you earlier!

This is just to let you know that we're currently working on addressing some of these issues, either through improving our FAQ or improving or error messages. I'll also try answering your questions now.

---

It's not possible to assign to Warp arrays outside of kernel functions because Warp arrays can represent either CPU or GPU data. In the case of CPU data, that'd be straightforward to support in Python however, if the data is living on the GPU, then this would require launching a CUDA kernel for each item assignment, which wouldn't be efficient.

Instead, we recommend to either initialise a Warp array with another array (Python list, NumPy array, ...) that already describes the desired dataset, or to use a kernel to set the data afterwards.

And, as you already found out, Warp also provides native Python functions to help setting an array with a given value, but that also works on slices, for example: arr[2:].fill_(1.23) is valid.

---

In the following snippet, you are assigning an entire vector onto a single vector component. What are you expecting the result to be?

vec2Data = wp.vec2(666.0,666.0)
vec2Data[0] = vec2Data
####### >>> TypeError: incompatible types, vec2f instance instead of c_float instance

---

As for here, the error message is extremely confusing and we're working on improving that now, but what's happening is that you are trying to access a global array twoD_floats inside a kernel, which is not supported. To access such arrays, they should explicitly be passed to the kernel as argument. There is an exception in the case of constant values where it's possible to access them from within a kernel without passing them as arguments, at the condition that they are defined using the wp.constant() construct.

twoD_floats = wp.full((row_cnt, 2), 9999999.0, dtype=float, device='cpu') # would be nice to have inf

@wp.kernel
def simple_kernel():
    # Modify twoD_floats in kernel
    twoD_floats[0,0] = 1.0
    ####### >>> 'array' object has no attribute 'type'

---

Finally, in regards to supporting infinity, you can already use Python's math.inf for initialising your arrays outside of the kernels. We're currently working on exposing infinity as a Warp constant so that you could use it inside kernels as well if needed.

---

I hope this helps. Please let us know if you have any other questions, thank you!

[cadop]

thanks for the comments, I also see a recent release with wp.inf

could you not close the discussions (especially that are q&a)? I couldn't find this question on the discussions page, which would show up as answered or not.

[christophercrouzet]

My bad, I didn't pay attention to GitHub's discussions feature—I thought it was just a standard issue, sorry!

[christophercrouzet]

In case this might be helpful, there is a link where you can find all the discussions that you participated in: https://github.com/discussions

The equivalent for issues is https://github.com/issues

[cadop]

I have some followups when trying out a few more variants.

---

In the following snippet, you are assigning an entire vector onto a single vector component. What are you expecting the result to be?

This was just a typo, i meant to assign twoD_vec, which I think is the same error about assignment, but was trying different ways to assign something (it said array, so then was wondering if it was the original array or the fact it wasn't a wp.vec etc.)

---

There is an exception in the case of constant values where it's possible to access them from within a kernel without passing them as arguments, at the condition that they are defined using the wp.constant() construct.

Are you just mentioning in general this case, or is there a way to make an array a constant?

twoD_floats = wp.constant(wp.full((row_cnt, 2), 9999999.0, dtype=float, device='cpu') )# would be nice to have inf
>>> Invalid constant type: <class 'warp.types.array'>

---

Are assignments to multiple rows always copied (they aren't by reference so changing one index or the original won't change others)?

---

Regarding:

It's not possible to assign to Warp arrays outside of kernel functions because Warp arrays can represent either CPU or GPU data.

Creating the warp array seems possible outside of the kernel, but assigning values to them is not possible in a function or kernel unless it is passed?

---

Assigning to arrays is not possible outside a kernel, but creating arrays is not possible in a kernel?

@wp.kernel
def array_play(c: wp.array(dtype=float)):
    
    # Make array in kernel, then index and replace value
    twoD_floats = wp.full((c, 2), 9999999.0, dtype=float, device='cpu') 

    # ###### >>> Could not find function wp.full as a built-in or user-defined function. 
    # #####   >>> Note that user functions must be annotated with a @wp.func decorator to be called from a kernel.

But then you can create vectors in a kernel

@wp.kernel
def array_play(c: wp.array(dtype=float)):
    
    # Make a vec2
    vec_in_kernel = wp.vec2(666.0,666.0)

So types are created in vectors but arrays are containers for the built-in and is not creatable.

---

In terminology used, is @wp.func always considered 'a kernel', especially w.r.t. assignment and creating of types?

e.g. also fails

@wp.func
def get_b(x: wp.vec3,
          y: wp.vec3
          ):

    # Create an array that is in a function
    a = wp.full(shape=(1024), value=2.0, dtype=wp.vec3, device='cpu')

---

Warp also provides native Python functions to help setting an array with a given value, but that also works on slices, for example: arr[2:].fill_(1.23) is valid.

I can index in a kernel, but slicing fails

@wp.kernel
def array_assign(a: wp.array(dtype=wp.vec3),
                b: wp.array(dtype=wp.vec3),
                c: wp.array(dtype=float)):
    
    # Make a vec2
    vec_in_kernel = wp.vec3(666.0,666.0,666.0)
    
    # Assign index of array to new vector (of same type)
    a[0] = vec_in_kernel # okay
    
    # # Assign an slice to a value
    a[5:7] = vec_in_kernel
    # ###### >>> 'Syntax error: unsupported construct "ast.Slice" while parsing function "array_assign" at 
    # ###### >>> C:\\Users\....\n    a[5:7] = vec_in_kernel\n;<class \'ast.Slice\'>'
    # ###### >>> KeyError: <class 'ast.Slice'>    

[christophercrouzet]

Are you just mentioning in general this case, or is there a way to make an array a constant?

Arrays are not supported as constants, but simpler types like float or wp.vec are (e.g.: wp.constant(1.23) and wp.constant(wp.vec3(1.0, 2.0, 3.0))).

Vectors can actually be defined with any size, thus making it possible to create, say, a constant vector of 123 elements: wp.constant(wp.vec(length=123, dtype=int)(range(123))). However, in some cases this might increase register pressure and lead to worse performances, so it's worth profiling and comparing against passing array as kernel arguments.

---

Are assignments to multiple rows always copied (they aren't by reference so changing one index or the original won't change others)?

It's possible to pass a ptr to a Warp array, in which case Warp will only refer to the pointed data. Otherwise, the data is always passed by copy onto Warp, including for vectors and matrices.

---

Creating the warp array seems possible outside of the kernel, but assigning values to them is not possible in a function or kernel unless it is passed?

Defining/creating arrays can only be done outside of kernels. What I meant is that assigning specific items to these arrays (e.g.: arr[0] = 1.23) can currently only be done inside kernels. And yes, to be modified inside of kernels, arrays need to be passed as arguments.

---

Assigning to arrays is not possible outside a kernel, but creating arrays is not possible in a kernel?

That's right. Creating arrays means allocating memory either on the CPU or the GPU. Kernels are designed to perform fast computations on data that is already allocated.

---

But then you can create vectors in a kernel

Types like wp.vec3 are similar to other types like float and int that are used as variables storing some temporary state—they are small and can live on the stack.

---

In terminology used, is @wp.func always considered 'a kernel', especially w.r.t. assignment and creating of types?

Only @wp.kernel are consider kernels. Think of these as the “main” function that you launch using wp.launch(). On the other hand, functions marked as @wp.func are meant to be called by kernels or by other functions so, yes, in the end both @wp.kernel and @wp.func functions are eventually run within the context of kernel launches, which is why the same rules apply to both.

---

I can index in a kernel, but slicing fails

It's not yet supported, sorry! Maybe @c0d1f1ed can chime in on this one?