vout.br

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

                         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 streamCombine6(float input0[][],
                           float input1[][],
                           float input2[][],
                           float input3[][],
                           float input4[][],
                           float input5[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         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 {
      output=oldoutput;
   }
}

kernel void streamCombine7f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float input3[][],
                            float input4[][],
                            float input5[][],
                            float input6[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         -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 streamCombine7(float input0[][],
                           float input1[][],
                           float input2[][],
                           float input3[][],
                           float input4[][],
                           float input5[][],
                           float input6[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         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 streamCombine8f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float input3[][],
                            float input4[][],
                            float input5[][],
                            float input6[][],
                            float input7[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         -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 combineStreamsHelper (float (*streams)<>,
                           unsigned int num,
                           float output<>,
                           float modulus,
                           float offset,
                           float length,
                           float lengthmodmodulus) {
   switch (num) {
   case 1:
      streamCombine1(streams[0],
                     modulus, modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 2:
      streamCombine2(streams[0],
                     streams[1],
                     modulus, modulus, 
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 3:
      streamCombine3(streams[0],
                     streams[1],
                     streams[2],
                     modulus, modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 4:
   default:
      streamCombine4(streams[0],
                     streams[1],
                     streams[2],
                     streams[3],
                     modulus, modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelper(streams+4,
                              num-4,
                              output,
                              modulus,
                              4+offset,
                              length,
                              lengthmodmodulus);         
      }      
   }
}
void combineStreams (float (*streams)<>,
                     unsigned int num,
                     unsigned int width, 
                     unsigned int length,
                     float (*output)<>) {
   unsigned int  lengthmodmodulus=length%num;
   float tmp<(num*width),length>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,streams[0]);
      break;
   case 2:
      streamCombine2f(streams[0],
                      streams[1],
                      num, num,
                      length,
                      lengthmodmodulus,
                      *output);
      break;
   case 3:
      streamCombine3f(streams[0],
                      streams[1],
                      streams[2],
                      num, num,
                      length,
                      lengthmodmodulus,
                      *output);
      break;
   case 4:
      streamCombine4f(streams[0],
                      streams[1],
                      streams[2],
                      streams[3],
                      num, num,
                      length,
                      lengthmodmodulus,
                      *output);
      break;
   case 5:
   default:
      streamCombine5f(streams[0],
                      streams[1],
                      streams[2],
                      streams[3],
                      streams[4],
                      num, num,
                      length,
                      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) {
         combineStreamsHelper(streams+5,
                              num-5,
                              *output,
                              num,
                              5-.5,
                              length,
                              lengthmodmodulus);
      }
      break;

   }
}

void cpuGetIndexAt(float2 inputindex,
                   float shiftRight,
                   float2 maxvalue,
                   float2 *index) {
   index->x=inputindex.x+shiftRight;
   index->y=inputindex.y+floor(index->x/maxvalue.x);
   index->x=fmod(index->x,maxvalue.x);
   if (index->x<0)
      index->x+=maxvalue.x;//only necessary if shiftRight<0
}