voutfloatn.br

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

   }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,
                            float length, 
                            float lengthmodmodulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         lengthmodmodulus,
                         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,
                           float length, 
                           float lengthmodmodulus,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         lengthmodmodulus,
                         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,
                            float length, 
                            float lengthmodmodulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         lengthmodmodulus,
                         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,
                           float length, 
                           float lengthmodmodulus,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         offset,
                         lengthmodmodulus,
                         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,
                            float length, 
                            float lengthmodmodulus,
                            out float2 output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus,
                         -0.5f,
                         lengthmodmodulus,
                         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 combineStreamsHelperfloat2 (float2 (**streams) <>,
                                unsigned int num,
                                float2 output<>,
                                float modulus,
                                float offset,
                                float length,
                                float lengthmodmodulus) {
   switch (num) {
   case 1:
      float2streamCombine1(*streams[0],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 2:
      float2streamCombine2(*streams[0],
                     *streams[1],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 3:
      float2streamCombine3(*streams[0],
                     *streams[1],
                     *streams[2],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 4:
   default:
      float2streamCombine4(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelperfloat2(streams+4,
                                      num-4,
                                      output,
                                      modulus,
                                      4+offset,
                                      length,
                                      lengthmodmodulus);         
      }
      /*
   case 5:
      float2streamCombine5(streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 6:
      float2streamCombine6(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   default:
      float2streamCombine7(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     *streams[6],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      if (num>7) {
         combineStreamsHelperfloat2(streams+7,
                                      num-7,
                                      output,
                                      modulus,
                                      7+offset,
                                      length,
                                      lengthmodmodulus);         
      } 
      */     
   }
}
void combineStreamsfloat2 (float2 (**streams)<>,
                          unsigned int num,
                          unsigned int width, 
                          unsigned int length,
                             float2 (*output)<>) {
   unsigned int  lengthmodmodulus=num!=0?(length%num):0;
   float2 tmp<(num*width),length>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,*streams[0]);
      break;
   case 2:
      float2streamCombine2f(*streams[0],
                      *streams[1],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 3:
      float2streamCombine3f(*streams[0],
                      *streams[1],
                      *streams[2],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 4:
      float2streamCombine4f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 5:
   default:
      float2streamCombine5f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      if (num>MAX_VOUT_STREAMS) {
         fprintf (stderr,
                  "vout stream not reconstituted properly. %s%d streams",
                  "Too little precision for more than ",MAX_VOUT_STREAMS);
      }
      if (num>5) {
         combineStreamsHelperfloat2(streams+5,
                                      num-5,
                                      *output,
                                      (float)num,
                                      (float)(5-.5),
                                      (float)length,
                                      (float)lengthmodmodulus);
      }
      /*
      break;
   case 6:
      float2streamCombine6f(*streams[0],
                      *streams[1],