vout1d.br

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

   }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 combineStreamsHelper1dBRT_TYPE (BRT_TYPE (**streams) <>,
                                unsigned int num,
                                BRT_TYPE output<>,
                                float modulus,
                                float offset) {
   switch (num) {
   case 1:
      BRT_TYPE1dstreamCombine1(*streams[0],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 2:
      BRT_TYPE1dstreamCombine2(*streams[0],
                     *streams[1],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 3:
      BRT_TYPE1dstreamCombine3(*streams[0],
                     *streams[1],
                     *streams[2],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 4:
   default:
      BRT_TYPE1dstreamCombine4(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     modulus,
                     offset,
                     output,
                     output);
      if (num>4) {
         combineStreamsHelper1dBRT_TYPE(streams+4,
                                      num-4,
                                      output,
                                      modulus,
                                      4+offset);
      }
      /*
   case 5:
      BRT_TYPEstreamCombine5(streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     modulus,
                     offset,
                     output,
                     output);
      break;
   case 6:
      BRT_TYPEstreamCombine6(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     modulus,
                     offset,

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

                     output,
                     output);
      if (num>7) {
         combineStreamsHelper1dBRT_TYPE(streams+7,
                                      num-7,
                                      output,
                                      modulus,
                                      7+offset);         
      } 
      */     
   }
}
void combineStreams1dBRT_TYPE (BRT_TYPE (**streams)<>,
                          unsigned int num,
                          unsigned int width, 
                          unsigned int UNUSED,
                               BRT_TYPE (*output)<>) {
   BRT_TYPE tmp<(num*width)>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,*streams[0]);
      break;
   case 2:
      BRT_TYPE1dstreamCombine2f(*streams[0],
                      *streams[1],
                      (float)num,
                      *output);
      break;
   case 3:
      BRT_TYPE1dstreamCombine3f(*streams[0],
                      *streams[1],
                      *streams[2],
                      (float)num,
                      *output);
      break;
   case 4:
      BRT_TYPE1dstreamCombine4f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      (float)num,
                      *output);
      break;
   case 5:
   default:
      BRT_TYPE1dstreamCombine5f(*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) {
         combineStreamsHelper1dBRT_TYPE(streams+5,
                                      num-5,
                                      *output,
                                      (float)num,
                                      (float)(5-.5));
      }
      /*
      break;
   case 6:
      BRT_TYPEstreamCombine6f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      num,
                      output);
      break;
   case 7:
      BRT_TYPEstreamCombine7f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      num,
                      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);
      }
      BRT_TYPEstreamCombine8f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      *streams[7],
                      num,
                      output);
      if (num>8) {
         combineStreamsHelperBRT_TYPE(streams+8,
                                      num-8,
                                      output,
                                      num,
                                      8);
      }
      break;
      */
   }
}




kernel void combineBRT_TYPE1d (BRT_TYPE input1[], 
                           BRT_TYPE input2[], 
                           out BRT_TYPE output<>,
                           float startsecond,
                           float endsecond,
                           float maxinput2value,
                           float inf){
   if ((indexof output).x>=startsecond.x) {
      float secondindex=(indexof output).x-startsecond;
      //getIndexAt(float4(maxinputvalue.x,maxinputvalue.y-1,0,0),
      //           -shift2,
      //           maxinput1value,
      //           endsecond); // moved outside kernel
      if (secondindex.x>=endsecond.x) {
         output=inf;
      }else {
         output = input2[secondindex];
      }
   }else {
      output=input1[(indexof output).x];
   }
}

unsigned int  voutCombineBRT_TYPE1d(BRT_TYPE outleft_stream<>,
                               float maxshiftleft,
                               unsigned int LEFTWIDTH,
                               BRT_TYPE outright_stream<>,
                               float maxshiftright,
                               unsigned int RIGHTWIDTH,
                                    BRT_TYPE (*output)<>){
   unsigned int totalsize;
   float maxleftvalue,maxrightvalue;
   maxleftvalue=(float)LEFTWIDTH;
   maxrightvalue=(float)RIGHTWIDTH;
   totalsize = (LEFTWIDTH
                +RIGHTWIDTH
                -(unsigned int)maxshiftleft-(unsigned int)maxshiftright);
   if (1) {      
      unsigned int width = totalsize;
      BRT_TYPE output_stream<width>;
      float startsecond,endsecond;
      cpuGetIndexAt1d(maxleftvalue-1,
                    -maxshiftleft,
                    maxleftvalue,
                    &startsecond);
      cpuGetIndexAt1d(maxrightvalue-1,
                    -maxshiftright,
                    maxrightvalue,
                    &endsecond);
      combineBRT_TYPE1d(outleft_stream,
                   outright_stream,
                   output_stream,
                   startsecond,
                   endsecond,
                   maxrightvalue,
                   1.0f/absolutezero);
      streamSwap (*output,output_stream);
   }
   return totalsize;
}

unsigned int totalCombineVoutBRT_TYPE1d (BRT_TYPE list_stream<>, 
                                    unsigned int WIDTH,
                                    BRT_TYPE list2_stream<>,
                                    unsigned int WIDTH2,
                                         BRT_TYPE (*output)<>){

   float outleft_stream<WIDTH>;
   float outright_stream<WIDTH2>;
   float maxshiftleft =shiftValues1dBRT_TYPE(list_stream,
                                           &outleft_stream,
                                           WIDTH,1,
                                           -1);
   float maxshiftright=shiftValues1dBRT_TYPE(list2_stream,
                                           &outright_stream,
                                           WIDTH2,1,
                                           -1);
   return voutCombineBRT_TYPE1d (outleft_stream,
                            maxshiftleft,
                               WIDTH,
                            outright_stream,
                            maxshiftright,
                               WIDTH2,
                            output);
}
#undef VECTOR_TEMPLATIZED_FUNCTIONS