c++-amp

I am trying to calculate a matrix using C++ AMP. I use an array with width and height of 3000 x 3000 and I repeat the calculating procedure 20000 times: //_height=_width=3000 extent<2> ext(_height,_width); array<int, 2> GPU_main(ext,gpuDevice.default_view); array<int, 2> GPU_res(ext,gpuDevice.default_view); copy(_main, GPU_main); array_view<int,2> main(GPU_main); array_view<int,2> res(GPU_res); res.discard_data(); number=20000; for(int i=0;i<number;i++) { parallel_for_each(e,[=](index<2> idx)restrict(amp) { res(idx)=main(idx)+idx[0];//not depend from calculation type } array_view<TYPE, 2> temp

I'm watching this video by Herb Sutter on GPGPU and the new C++ AMP library. He is talking about memory models and mentions Weak Memory Models and then Strong Memory Models and I think he's referring to read/write ordering etc, but I am however not sure. Google turns up some interesting results (mostly science papers) on memory models, but can someone explain what is a Weak Memory Model and what is a Strong Memory Model and their relation to concurrency? In terms of concurrency, a memory model specifies the constraints on data accesses, and the conditions under which data written by one thread

I am working on high performance code in C++ and have been using both CUDA and OpenCL and more recently C++AMP, which I like very much. I am however a little worried that it is not being developed and extended and will die out. What leads me to this thought is that even the MS C++AMP blogs have been silent for about a year. Looking at the C++ AMP algorithms library http://ampalgorithms.codeplex.com/wikipage/history it seems nothing at all has happened for over a year. The only development I have seen is that now LLVM sort of supports C++AMP, so it is not windows only, but that is all, and not

If I have a concurrency::array_view being operated on in a concurrency::parallel_for_each loop, my understanding is that I can continue other tasks on the CPU while the loop is executing: using namespace Concurrency; array_view<int> av; parallel_for_each(extent<1>(number),[=](index<1> idx) { // do some intense computations on av } // do some stuff on the CPU while we wait av.synchronize(); // wait for the parallel_for_each loop to finish and copy the data But what if I want to not wait for the parallel for loop but start copying data back from the GPU as soon as possible . Will the following

I am working with depth images retrieved from kinect which are 16 bits. I found some difficulties on making my own filters due to the index or the size of the images. I am working with Textures because allows to work with any bit size of images. So, I am trying to compute an easy gradient to understand what is wrong or why it doesn't work as I expected. You can see that there is something wrong when I use y dir. For x: For y: That's my code: typedef concurrency::graphics::texture<unsigned int, 2> TextureData; typedef concurrency::graphics::texture_view<unsigned int, 2> Texture cv::Mat image =