voutloopy.br

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

   }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,
                            float length, 
                            float lengthmodmodulus,
                            out float 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 combineStreamsHelperfloat (float (**streams) <>,
                                unsigned int num,
                                float output<>,
                                float modulus,
                                float offset,
                                float length,
                                float lengthmodmodulus) {
   switch (num) {
   case 1:
      floatstreamCombine1(*streams[0],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 2:
      floatstreamCombine2(*streams[0],
                     *streams[1],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 3:
      floatstreamCombine3(*streams[0],
                     *streams[1],
                     *streams[2],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 4:
   default:
      floatstreamCombine4(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelperfloat(streams+4,
                                      num-4,
                                      output,
                                      modulus,
                                      4+offset,
                                      length,
                                      lengthmodmodulus);         
      }
      /*
   case 5:
      floatstreamCombine5(streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   case 6:
      floatstreamCombine6(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      break;
   default:
      floatstreamCombine7(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     *streams[6],
                     modulus,
                     offset,
                     length,
                     lengthmodmodulus,
                     output,
                     output);
      if (num>7) {
         combineStreamsHelperfloat(streams+7,
                                      num-7,
                                      output,
                                      modulus,
                                      7+offset,
                                      length,
                                      lengthmodmodulus);         
      } 
      */     
   }
}
void combineStreamsfloat (float (**streams)<>,
                          unsigned int num,
                          unsigned int width, 
                          unsigned int length,
                             float (*output)<>) {
   unsigned int  lengthmodmodulus=num!=0?(length%num):0;
   float tmp<(num*width),length>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,*streams[0]);
      break;
   case 2:
      floatstreamCombine2f(*streams[0],
                      *streams[1],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 3:
      floatstreamCombine3f(*streams[0],
                      *streams[1],
                      *streams[2],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 4:
      floatstreamCombine4f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      (float)num,
                      (float)length,
                      (float)lengthmodmodulus,
                      *output);
      break;
   case 5:
   default:
      floatstreamCombine5f(*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) {
         combineStreamsHelperfloat(streams+5,
                                      num-5,
                                      *output,
                                      (float)num,
                                      (float)(5-.5),
                                      (float)length,
                                      (float)lengthmodmodulus);
      }
      /*
      break;
   case 6:
      floatstreamCombine6f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      num,
                      length,
                      lengthmodmodulus,
                      output);
      break;
   case 7:
      floatstreamCombine7f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      num,
                      length,
                      lengthmodmodulus,
                      output);
      break;
   default:
      if (num>MAX_VOUT_STREAMS) {
         fprintf (stderr,
                  "vout stream not reconstituted properly. %s%d streams",
                  "Too little precision for more than ",MAX_VOUT_STREAMS);
      }
      floatstreamCombine8f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      *streams[7],
                      num,
                      length,
                      lengthmodmodulus,
                      output);
      if (num>8) {
         combineStreamsHelperfloat(streams+8,
                                      num-8,
                                      output,
                                      num,
                                      8,
                                      length,
                                      lengthmodmodulus);
      }
      break;
      */
   }
}




kernel void combinefloat (float input1[][], 
                           float input2[][], 
                           out float output<>,
                           float2 startsecond,
                           float2 endsecond,
                           float2 maxinput2value,
                           float inf){
   //   getIndexAt(float4(maxinputvalue.x,maxinputvalue.y-1,0,0),
   //              -shift1,
   //              maxinput1value,
   //              startsecond);//moved outside kernel
   if ((indexof(output)).y>startsecond.y
       ||((indexof(output)).y==startsecond.y
          &&(indexof(output)).x>=startsecond.x)) {
      float2 secondindex;
      getIndexAt(float4((indexof(output)).x,
                        (indexof(output)).y-startsecond.y,
                        0,
                        0),
                 -startsecond.x,
                 maxinput2value,
                 secondindex);
      //getIndexAt(float4(maxinputvalue.x,maxinputvalue.y-1,0,0),
      //           -shift2,
      //           maxinput1value,
      //           endsecond); // moved outside kernel
      if (secondindex.y>endsecond.y
          ||(secondindex.y==endsecond.y
             &&secondindex.x>=endsecond.x)) {
         output=inf;
      }else {
         output = input2[secondindex];
      }
   }else {
      output=input1[indexof(output)];
   }
}
unsigned int  voutCombinefloat(float outleft_stream<>,
                               float maxshiftleft,
                               unsigned int LEFTWIDTH,
                               float outright_stream<>,
                               float maxshiftright,
                               unsigned int RIGHTWIDTH,
                               unsigned int LENGTH,
                                  float (*output)<>){
   unsigned int totalsize;
   float2 maxleftvalue,maxrightvalue;
   maxleftvalue.x=(float)LENGTH;maxleftvalue.y=(float)LEFTWIDTH;
   maxrightvalue.x=(float)LENGTH;maxrightvalue.y=(float)RIGHTWIDTH;
   totalsize = (LEFTWIDTH*LENGTH
                +RIGHTWIDTH*LENGTH
                -(unsigned int)maxshiftleft-(unsigned int)maxshiftright);
   if (1) {      
      unsigned int length = LENGTH;
      unsigned int width = totalsize/length+((totalsize%length!=0)?1:0);
      float output_stream<width,length>;
      float2 startsecond,endsecond;
      cpuGetIndexAt(float2(maxleftvalue.x,maxleftvalue.y-1),
                    -maxshiftleft,
                    maxleftvalue,
                    &startsecond);
      cpuGetIndexAt(float2(maxrightvalue.x,maxrightvalue.y-1),
                    -maxshiftright,
                    maxrightvalue,
                    &endsecond);
      combinefloat(outleft_stream,
                   outright_stream,
                   output_stream,
                   startsecond,
                   endsecond,
                   maxrightvalue,
                   1.0f/absolutezero);
      streamSwap (*output,output_stream);
   }
   return totalsize;
}