vout1dfloatn.br

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

      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 float1dstreamCombine5f(float input0[],
                            float input1[],
                            float input2[],
                            float input3[],
                            float input4[],
                            float modulus,
                            out float 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 floatstreamCombine5(float input0[],
                           float input1[],
                           float input2[],
                           float input3[],
                           float input4[],
                           float modulus,
                           float offset,
                           float oldoutput<>,
                           out float 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 floatstreamCombine6f(float input0[],
                            float input1[],
                            float input2[],
                            float input3[],
                            float input4[],
                            float input5[],
                            float modulus,
                            out float 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 floatstreamCombine6(float input0[],
                           float input1[],
                           float input2[],
                           float input3[],
                           float input4[],
                           float input5[],
                           float modulus,
                           float offset,
                           float oldoutput<>,
                           out float 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 floatstreamCombine7f(float input0[],
                            float input1[],
                            float input2[],
                            float input3[],
                            float input4[],
                            float input5[],
                            float input6[],
                            float modulus,
                            out float 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 floatstreamCombine7(float input0[],
                           float input1[],
                           float input2[],
                           float input3[],
                           float input4[],
                           float input5[],
                           float input6[],
                           float modulus,
                           float offset,
                           float oldoutput<>,
                           out float 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 floatstreamCombine8f(float input0[],
                            float input1[],
                            float input2[],
                            float input3[],
                            float input4[],
                            float input5[],
                            float input6[],
                            float input7[],
                            float modulus,
                            out float 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 combineStreamsHelper1dfloat (float (**streams) <>,
                                unsigned int num,
                                float output<>,
                                float modulus,
                                float offset) {
   switch (num) {
   case 1:
      float1dstreamCombine1(*streams[0],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 2:
      float1dstreamCombine2(*streams[0],
                     *streams[1],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 3:
      float1dstreamCombine3(*streams[0],
                     *streams[1],
                     *streams[2],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 4:
   default:
      float1dstreamCombine4(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     modulus,
                     offset,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelper1dfloat(streams+4,
                                      num-4,
                                      output,
                                      modulus,
                                      4+offset);
      }
      /*
   case 5:
      floatstreamCombine5(streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 6:
      floatstreamCombine6(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     modulus,
                     offset,

                     output,
                     output);
      break;
   default:
      floatstreamCombine7(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     *streams[6],
                     modulus,
                     offset,

                     output,
                     output);
      if (num>7) {
         combineStreamsHelper1dfloat(streams+7,
                                      num-7,
                                      output,
                                      modulus,
                                      7+offset);         
      } 
      */     
   }
}
void combineStreams1dfloat (float (**streams)<>,
                          unsigned int num,
                          unsigned int width, 
                          unsigned int UNUSED,
                               float (*output)<>) {
   float tmp<(num*width)>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,*streams[0]);
      break;
   case 2:
      float1dstreamCombine2f(*streams[0],
                      *streams[1],
                      (float)num,
                      *output);
      break;
   case 3:
      float1dstreamCombine3f(*streams[0],
                      *streams[1],
                      *streams[2],
                      (float)num,
                      *output);
      break;
   case 4:
      float1dstreamCombine4f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      (float)num,
                      *output);
      break;
   case 5:
   default:
      float1dstreamCombine5f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      (float)num,
                      *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) {
         combineStreamsHelper1dfloat(streams+5,
                                      num-5,
                                      *output,
                                      (float)num,
                                      (float)(5-.5));
      }
      /*
      break;
   case 6:
      floatstreamCombine6f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],