Parallel Programming in Native Code

Parallel programming using C++ AMP, PPL and Agents libraries.

Read-only array_view/array in C++ AMP – Part 1 of 2

Read-only array_view/array in C++ AMP – Part 1 of 2

  • Comments 0

concurrency::array_view and concurrency::array are the most common vehicles for reading and writing data collections in your C++ AMP code. Often in your C++ AMP kernels or parts of your host code, some of the referenced data collections are purely inputs to the computation and are only read-from (never written-to) in that part of the code. This is the first post in a two part series, where we will look at how you can express the read-only nature of accesses for array_view/array input data collections in your C++ AMP code. In the second part, I will talk about why it is highly advisable to do so.

concurrency::array_view<const value_type, rank>

A concurrency::array_view object abstractly denotes a reference to an underlying source data container allocated on the host or an accelerator. Whether an array_view instance has read-only or read-write access to the underlying data is dictated by whether the value_type template argument of the array_view type is const qualified. For example, an array_view<const int> object denotes a read-only linear view of a dense collection of integers and can only be used to read the underlying data. An array_view<float, 2> object on the other hand, denotes a read-write 2D view of a dense collection of floats and can be used to both read-from and write-to the underlying data collection.

int *ptr1 = new int[size];
int *ptr2 = new int[size];
 
array_view<const int> roArrView(size, ptr1);
 
// An object of type array_view<const T> can only be read-from
int firstElement = roArrView[0];
 
// Compilation error: The underlying data cannot be modified through
// an array_view<const T> object
roArrView[0] = 5; // ERROR
 
// An array_view<const T> object can be assigned to, to point
// to different underlying data source
roArrView = array_view<const int>(size, ptr2);

 

So if array_view<const value_type> denotes a read-only view of data, what does const array_view<value_type> denote? Well, it denotes the constness of the array_view object itself; i.e. whether the array_view object itself can be modified to reference a different underlying container (or even a different section of its current underlying container) than what it currently references. In other words, the assignment operator cannot be used on a const array_view<T> object to have it point to different underlying data than it currently does. As mentioned earlier, an array_view object just denotes a reference to an underlying data source and using the assignment operator on an array_view object just results in the array_view dropping the reference to its existing data source and start referencing a new data source (underlying the array_view object on the right-hand-side of the assignment operator).

int *ptr1 = new int[size];
int *ptr2 = new int[size];
 
const array_view<int> constArrView(size, ptr1);
 
// A const array_view<T> object can both read-from and write-to the
// underlying data
constArrView[0] = constArrView[1] + 1;
 
// Compilation error: A const array_view<T> object cannot be modified to
// point to different underlying data
constArrView = array_view<int>(size, ptr2); // ERROR
 
const array_view<const int> roConstArrView(size, ptr1);
 
// A const array_view<const T> object can only be used to read the
// underlying data
int firstElement = roConstArrView[0];
 
// Compilation error: a const array_view<const T> object cannot be used to
// modify the underlying data
roConstArrView[0] = 4; // ERROR
 
// Compilation error: a const array_view<const T> object cannot be modified to
// point to different underlying data
roConstArrView = array_view<const int>(size, ptr2); // ERROR

 

This may be easier understood through an analogy with pointers. A pointer to const T (const T* ptr) denotes that the data pointed to (by the pointer) is constant and cannot be modified through the pointer. Analogously, array_view<const T> denotes that the referenced underlying data is constant (or read-only) and cannot be modified through the array_view object. On the other hand, a const pointer to T (T* const ptr) denotes that the pointer variable is constant and cannot be assigned a different address than what it currently points to. However, modifying the referenced data through the pointer is perfectly ok. Analogously, a const array_view<T> object denotes a constant array_view object and cannot be modified (using the assignment operator) to point to different underlying data than what it currently references. But the array_view has read-write access and can be used to modify the referenced data.

array_view type

Analogous pointer type

array_view<const T>

const T*

const array_view<T>

T* const

const array_view<const T>

const T* const

 

Finally, as you would expect, a read-only array_view (array_view<const T>) object can be freely constructed from a read-write array_view (array_view<T>) object. But constructing a read-write array_view from a read-only array_view would compromise the source array_view’s read-only restriction on the referenced data, and this unsafe operation is naturally disallowed.

int *ptr1 = new int[size];
const int *ptr2 = new int[size];
 
// An array_view<const T> object can be constructed from a writable data source
array_view<const int> roArrView(size, ptr1);
 
array_view<int> rwArrView(size, ptr1);
 
// A array_view<const T> object can be freely constructed from an
// array_view<T> object
array_view<const int> roArrView1 = rwArrView;
 
parallel_for_each(roArrView1.extent, [=](index<1> idx) restrict(amp) {
    // The object roArrView is of type array_view<const int> and can only
    // be used to read the source data
    int temp = roArrView[idx];
 
    // Compilation error: Modifying the underlying data through
    // a array_view<const T> object is disallowed
    roArrView[idx] = temp + 5; // ERROR
});
 
// Compilation error: Cannot construct a array_view<T> over
// a read-only data source (const int* ptr2)
array_view rwArrView1(size, ptr2); // ERROR
 
// Compilation error: Cannot construct a array_view<T> object from
// a array_view<const T> object
array_view rwArrView2(roArrView); // ERROR

 

const array<value_type, rank>

A concurrency::array object denotes a dense multi-dimensional data container allocated on a specific accelerator_view of a C++ AMP accelerator. Whether an array object is read-only or read-write is dictated by whether the array object or the C++ reference through which it is accessed is const qualified. For example, a const array<int> object denotes a read-only linear dense container of integers while an array<float, 2> object denotes a 2D dense container of floats. And if you are wondering what array<const T> denotes – it denotes nothing, is disallowed and will result in a compilation error.

Similar to array_view, the read-only restriction can be freely attributed by creating a const array<T> reference to an array<T> object. But, dropping the read-only restriction is unsafe (such as creating a non-const array<T> reference from a const array<T> object) and is disallowed per the normal C++ constness rules. It is worth noting here that an array object denotes the data container itself unlike an array_view object which denotes a reference to an underlying data source. Hence copy constructing an array object or assigning to an array object from another array object results in construction of new container with a deep copy of the source array contents unlike array_view copy construction or assignment which just results in the destination array_view to point to the same underlying data source as the source array_view object it is constructed or assigned from.

int *ptr1 = new int[size];
 
// An array denotes a data container and the contents of the source ptr1
// are copied to the newly allocated memory
array<int> rwArr(size, ptr1);
 
// A const array<T> object denotes a read-only array
const array<float> roArr(size, ptr1);
 
// Read-onliness can be attributed by creating const reference
// to a read-write array<T> object
const array<int>& roArrRef = rwArr;
 
parallel_for_each(roArrRef.extent, [&](index<1> idx) restrict(amp) {
    // Compilation error: roArrRef being a const array<int>& is read-only and
    // cannot be used to modify the array contents
    roArrRef[idx] = roArrRef[idx] + 5; // ERROR
});
 
// Compilation error: Constness of an array cannot be dropped
array<float>& rwArrRef = roArr; // ERROR
array<int>& rwArrRef2 = roArrRef; // ERROR

 

The concurrency::texture type has the same semantics as the array type with regard to constness; i.e. a const texture<T> object denotes read-only access to the texture data.

In closing

Having looked at how to specify the read-only restriction for array_view/array data collections in your C++ AMP code in this part, in the next part I will discuss the benefits of applying the read-only restriction when your array_view/array data collections are only read-from in a C++ AMP kernel or parts of your host code. I would love to hear your thoughts, comments, questions and feedback below or on our MSDN forum.

Blog - Comment List MSDN TechNet
  • Loading...
Leave a Comment
  • Please add 2 and 5 and type the answer here:
  • Post