voutfloatn.br

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

                     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/(float)floor(.5));
      streamSwap (*output,output_stream);
   }
   return totalsize;
}

unsigned int totalCombineVoutfloat (float list_stream<>, 
                                    unsigned int WIDTH,
                                    float list2_stream<>,
                                    unsigned int WIDTH2,
                                    unsigned int LENGTH,
                                       float (*output)<>){

   float outleft_stream<WIDTH,LENGTH>;
   float outright_stream<WIDTH2,LENGTH>;
   float maxshiftleft =shiftValuesfloat(list_stream,
                                           &outleft_stream,
                                           WIDTH,
                                           LENGTH,
                                           -1);
   float maxshiftright=shiftValuesfloat(list2_stream,
                                           &outright_stream,
                                           WIDTH2,
                                           LENGTH,
                                           -1);
   return voutCombinefloat (outleft_stream,
                            maxshiftleft,
                            WIDTH,
                            outright_stream,
                            maxshiftright,
                            WIDTH2,
                            LENGTH,
                            output);
}
#undef VECTOR_TEMPLATIZED_FUNCTIONS
#define VECTOR_TEMPLATIZED_FUNCTIONS
reduce void valueProducedfloat2 (float2 input <>, 
                                   reduce float2 output<>) {
   output=isinf(input.x)?output:input;
}
kernel void isFiniteKernelfloat2(float2 inp<>, out float outp<>) {
   outp=!isinf(inp.x);
}

int finiteValueProducedfloat2 (float2 input<>) {
   float2 output<1,1>;
   float finiteout<1,1>;
   float2 rettype;
   float ret;
  
   debugStreamPrint (input,"Finite Values in...");
   valueProducedfloat2(input,output);
   streamWrite(output,&rettype);
   isFiniteKernelfloat2(output,finiteout);
   streamWrite(finiteout,&ret);
   return (int)ret;
}

kernel void valueAtfloat2 (float2 value[][],
                             float2 index,
                             out float2 output<>,
                             float2 maxvalue,
                             float nothing) {
   if (index.y>=maxvalue.y||index.y<-.1)
      output = nothing;
   else 
      output = value[index];
}
kernel void NanToBoolRightfloat2 (float2 value[][], 
                            out float output<>, 
                            float sign,
                            float2 maxvalue) {
   float2 nextPlaceToLook;
   float2 neighbor;
   getIndexAt(indexof(output),sign,maxvalue,nextPlaceToLook);
   valueAtfloat2(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = (isinf(value[indexof(output)].x)?1:0) 
      + (isinf(neighbor.x)?1:0);
}
kernel void NanToRightfloat2 (float value [][],
                                out float output<>,
                                float twotoi,
                                float2 maxvalue) {
   float2 nextPlaceToLook;
   float neighbor;
   getIndexAt(indexof(output),twotoi,maxvalue,nextPlaceToLook);
   valueAtfloat(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = round(value[indexof(output)]+neighbor);
}
kernel void CountToRightfloat2 (float2 value [][],
                                  out float2 output<>,
                                  float twotoi,
                                  float2 maxvalue) {
   float2 nextPlaceToLook;
   float2 neighbor;
   getIndexAt(indexof(output),twotoi,maxvalue,nextPlaceToLook);
   valueAtfloat2(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = value[indexof(output)]+neighbor;
}

kernel void GatherGuessfloat2(float scatterindex[][],
                        out float output<>,
                        float2 value[][],
                        float twotologkminusi,
                        float2 maxvalue,
                        float halfk,
                        float sign) {