reduction

问题 I have this piece of code that is parallelized. int i,n; double area,pi,x; area=0.0; #pragma omp parallel for private(x) reduction (+:area) for(i=0; i<n; i++){ x= (i+0.5)/n; area+= 4.0/(1.0+x*x); } pi = area/n; It is said that the reduction will remove the race condition that could happen if we didn't use a reduction. Still I'm wondering do we need to add lastprivate for area since its used outside the parallel loop and will not be visible outside of it. Else does the reduction cover this as

问题 Both of reduction and collapse clauses in OMP confuses me, some points raised popped into my head Why reduction doesn't work with minus? as in the limitation listed here Is there any work around to achieve minus? How does a unary operator work, i.e. x++ or x--? is the -- or ++ applied to each partial result? or only once at the creation of the global result? both cases are totally different. About the collapse.. could we apply collapse on a nested loops but have some lines of code in between

问题 I am working with a signal matrix and my goal is to calculate the sum of all elements of a row. The matrix is represented by the following struct: typedef struct matrix { float *data; int rows; int cols; int leading_dim; } matrix; I have to mention the matrix is stored in column-major order (http://en.wikipedia.org/wiki/Row-major_order#Column-major_order), which should explain the formula column * tan_hd.rows + row for retrieving the correct indices. for(int row = 0; row < tan_hd.rows; row++)

问题 I'm trying to develop a reduction function for use within a rainbow table generator. The basic principle behind a reduction function is that it takes in a hash, performs some calculations, and returns a string of a certain length. At the moment I'm using SHA1 hashes, and I need to return a string with a length of three. I need the string to be made up on any three random characters from: abcdefghijklmnopqrstuvwxyz0123456789 The major problem I'm facing is that any reduction function I write,

问题 Is there a way to know the order of execution for a reduction operator in OpenMP? In other words, I would like to know how the threads execute reduction operation- is it left to right? What happens when there are numbers that are not power of 2? 回答1: I think you'll find that OpenMP will only reduce on associative operations, such as + and * (or addition and multiplication if you prefer) which means that it can proceed oblivious to the order of evaluation of the component parts of the

问题 In following reduction + map operations, no. 3 is puzzling me. Can anyone please explain why // 1 [1,2,3,4,5].filter(x => x==3).reduce((x, y) => y) // -> 3, all good // 2 [1,2,3,4,5].filter(x => x<=3).reduce((x, y) => 0) // -> 0, still good // 3 [1,2,3,4,5].filter(x => x==3).reduce((x, y) => 0) // -> 3, hello? In other words: how come the reduction on the array of one element ignores the map to 0 operation? This would ultimately be used on an array of objects, as in .reduce((x,y) => y.attr)

问题 Since OpenMP 4.0, user-defined reduction is supported. So I defined the reduction on std::vector in C++ exactly from here. It works fine with GNU/5.4.0 and GNU/6.4.0, but it returns random values for the reduction with intel/2018.1.163. This is the example: #include <iostream> #include <vector> #include <algorithm> #include "omp.h" #pragma omp declare reduction(vec_double_plus : std::vector<double> : \ std::transform(omp_out.begin(), omp_out.end(), omp_in.begin(), omp_out.begin(), std::plus

问题 I am trying to implement an OpenCL version for doing reduction of a array of float. To achieve it, I took the following code snippet found on the web : __kernel void sumGPU ( __global const double *input, __global double *partialSums, __local double *localSums) { uint local_id = get_local_id(0); uint group_size = get_local_size(0); // Copy from global memory to local memory localSums[local_id] = input[get_global_id(0)]; // Loop for computing localSums for (uint stride = group_size/2; stride>0

问题 I'm implementing a function to find the sum of an array by using reduction, my array have 32*32 elements and its values is 0 ... 1023. The my expected sum value is 523776, but my reult is 15872, it wrong. Here is my code: #include <stdio.h> #include <cuda.h> #define w 32 #define h 32 #define N w*h __global__ void reduce(int *g_idata, int *g_odata); void fill_array (int *a, int n); int main( void ) { int a[N], b[N]; // copies of a, b, c int *dev_a, *dev_b; // device copies of a, b, c int size

问题 I used AMD's two-stage reduction example to compute the sum of all numbers from 0 to 65 536 using floating point precision. Unfortunately, the result is not correct. However, when I modify my code, so that I compute the sum of 65 536 smaller numbers (for example 1), the result is correct. I couldn't find any error in the code. Is it possible that I am getting wrong results, because of the float type? If this is the case, what is the best approach to solve the issue? 回答1: There is probably no