vout1dfloatn.br

用于GPU通用计算的编程语言BrookGPU 0.4

                            float2 input1[],
                            float2 input2[],
                            float modulus,
                            out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else {
      output=input2[newindex];
   }
}

kernel void float21dstreamCombine3(float2 input0[],
                           float2 input1[],
                           float2 input2[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float21dstreamCombine4f(float2 input0[],
                            float2 input1[],
                            float2 input2[],
                            float2 input3[],
                            float modulus,
                            out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else {
      output=input3[newindex];
   }
}

kernel void float21dstreamCombine4(float2 input0[],
                           float2 input1[],
                           float2 input2[],
                           float2 input3[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus,  newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float21dstreamCombine5f(float2 input0[],
                            float2 input1[],
                            float2 input2[],
                            float2 input3[],
                            float2 input4[],
                            float modulus,
                            out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else {
      output=input4[newindex];
   }
}
/*
kernel void float2streamCombine5(float2 input0[],
                           float2 input1[],
                           float2 input2[],
                           float2 input3[],
                           float2 input4[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else {
      output=oldoutput;
   }
}


kernel void float2streamCombine6f(float2 input0[],
                            float2 input1[],
                            float2 input2[],
                            float2 input3[],
                            float2 input4[],
                            float2 input5[],
                            float modulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus,  newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else {
      output=input5[newindex];
   }
}

kernel void float2streamCombine6(float2 input0[],
                           float2 input1[],
                           float2 input2[],
                           float2 input3[],
                           float2 input4[],
                           float2 input5[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float2streamCombine7f(float2 input0[],
                            float2 input1[],
                            float2 input2[],
                            float2 input3[],
                            float2 input4[],
                            float2 input5[],
                            float2 input6[],
                            float modulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else {
      output=input6[newindex];
   }
}

kernel void float2streamCombine7(float2 input0[],
                           float2 input1[],
                           float2 input2[],
                           float2 input3[],
                           float2 input4[],
                           float2 input5[],
                           float2 input6[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else if (whichmod==6) {
      output=input6[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float2streamCombine8f(float2 input0[],
                            float2 input1[],
                            float2 input2[],
                            float2 input3[],
                            float2 input4[],
                            float2 input5[],
                            float2 input6[],
                            float2 input7[],
                            float modulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
      output=input3[newindex];
   }else if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==5) {
      output=input5[newindex];
   }else if (whichmod==6) {
      output=input6[newindex];
   }else {
      output=input7[newindex];
   }
}
*/
void combineStreamsHelper1dfloat2 (float2 (**streams) <>,
                                unsigned int num,
                                float2 output<>,
                                float modulus,
                                float offset) {
   switch (num) {
   case 1:
      float21dstreamCombine1(*streams[0],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 2:
      float21dstreamCombine2(*streams[0],
                     *streams[1],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 3:
      float21dstreamCombine3(*streams[0],
                     *streams[1],
                     *streams[2],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 4:
   default:
      float21dstreamCombine4(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     modulus,
                     offset,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelper1dfloat2(streams+4,
                                      num-4,
                                      output,
                                      modulus,
                                      4+offset);
      }
      /*
   case 5:
      float2streamCombine5(streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 6:
      float2streamCombine6(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     modulus,
                     offset,

                     output,
                     output);
      break;