vout1dfloatn.br

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

                      *streams[4],
                      *streams[5],
                      num,
                      output);
      break;
   case 7:
      floatstreamCombine7f(*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);
      }
      floatstreamCombine8f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      *streams[7],
                      num,
                      output);
      if (num>8) {
         combineStreamsHelperfloat(streams+8,
                                      num-8,
                                      output,
                                      num,
                                      8);
      }
      break;
      */
   }
}




kernel void combinefloat1d (float input1[], 
                           float input2[], 
                           out float 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  voutCombinefloat1d(float outleft_stream<>,
                               float maxshiftleft,
                               unsigned int LEFTWIDTH,
                               float outright_stream<>,
                               float maxshiftright,
                               unsigned int RIGHTWIDTH,
                                    float (*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;
      float output_stream<width>;
      float startsecond,endsecond;
      cpuGetIndexAt1d(maxleftvalue-1,
                    -maxshiftleft,
                    maxleftvalue,
                    &startsecond);
      cpuGetIndexAt1d(maxrightvalue-1,
                    -maxshiftright,
                    maxrightvalue,
                    &endsecond);
      combinefloat1d(outleft_stream,
                   outright_stream,
                   output_stream,
                   startsecond,
                   endsecond,
                   maxrightvalue,
                   1.0f/(float)floor(.5));
      streamSwap (*output,output_stream);
   }
   return totalsize;
}

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

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

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

kernel void valueAtfloat21d (float2 value[],
                             float index,
                             out float2 output<>,
                             float maxvalue,
                             float nothing) {
   if (index>=maxvalue||index<-.1)
      output = nothing;
   else 
      output = value[index];
}
kernel void NanToBoolRightfloat21d (float2 value[], 
                            out float output<>, 
                            float sign,
                            float maxvalue) {
   float nextPlaceToLook=(indexof output).x+sign;
   float2 neighbor;
   valueAtfloat21d(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = (isinf(value[indexof(output)].x)?1:0) 
      + (isinf(neighbor.x)?1:0);
}
kernel void NanToRightfloat21d (float value [],
                                out float output<>,
                                float twotoi,
                                float maxvalue) {
   float nextPlaceToLook=(indexof output).x+twotoi;
   float neighbor;
   valueAtfloat1d(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = round(value[indexof(output)]+neighbor);
}
kernel void CountToRightfloat21d (float2 value [],
                                  out float2 output<>,
                                  float twotoi,
                                  float maxvalue) {
   float nextPlaceToLook=(indexof output).x+twotoi;
   float2 neighbor;
   valueAtfloat21d(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = value[indexof(output)]+neighbor;
}

kernel void GatherGuessfloat21d(float scatterindex[],
                        out float output<>,
                        float2 value[],
                        float twotologkminusi,
                        float maxvalue,
                        float halfk,
                        float sign) {
     float neighbor;
      float nextPlaceToLook=(indexof output).x-sign*halfk;
      valueAtfloat1d(scatterindex,nextPlaceToLook,neighbor,maxvalue,0);
      if (neighbor>halfk) {
         output=halfk+twotologkminusi;
      }else {
         float2 actualValue;
         valueAtfloat21d(value,nextPlaceToLook,actualValue,maxvalue,0);
         if (neighbor==halfk&&!isinf(actualValue.x)) {
            output=halfk;
         }else {
            output = halfk-twotologkminusi;
         }         
      }
}
kernel void EstablishGuessfloat21d(float scatterindex[],
                                   out float output<>,
                                   float2 value[],
                                   float twotologkminusi,
                                   float maxvalue,
                                   float halfk,
                                   float sign) {
   if (scatterindex[indexof(output)]==0) {
      output=0;
   } else {
      GatherGuessfloat21d(scatterindex,
                          output,
                          value,
                          twotologkminusi,
                          maxvalue,
                          halfk,
                          sign);
    }
}
kernel void UpdateGuessfloat21d(float scatterindex[],
                                out float output<>,
                                float2 value[],
                                float twotologkminusi,
                                float maxvalue,
                                float lastguess<>,
                                float sign) {
   GatherGuessfloat21d(scatterindex,
                       output,
                       value,
                       twotologkminusi,
                       maxvalue,
                       lastguess,
                       sign);
}

kernel void RelativeGatherfloat21d(out float2 output<>,
                                float gatherindex[],
                                float2 value[],
                                float2 sign,
                                float maxvalue) {
   float nextPlaceToLook=(indexof output).x-sign.x*gatherindex[indexof(output)];
   valueAtfloat21d(value,nextPlaceToLook,output,maxvalue,sign.y);   
}


float shiftValues1dfloat2(float2 list_stream <>,
                            float2 (*output_stream)<>,
                       int WIDTH, 
                       int unused,
                       int sign) {
   float tmp_stream<WIDTH>;
   float ret_stream<WIDTH>;
   float guess_stream<WIDTH>;
   unsigned int i;
   float maxvalue;
   unsigned int logN;
   unsigned int LogNMinusK;
   float maxshift;
   maxvalue=(float)WIDTH;
   logN=(unsigned int)ceil(log((float)WIDTH)/log(2.0f));
   debugStreamPrint(list_stream,"Combined...");
   NanToBoolRightfloat21d (list_stream,ret_stream,(float)sign,maxvalue);   
   for (i=1;i<logN;++i) {
      streamSwap(ret_stream,tmp_stream);
      NanToRightfloat21d(tmp_stream,ret_stream,(float)sign*(1<<i),maxvalue);
   }
   debugStreamPrint(ret_stream,"scattering...");
   {
     float item<1>;
     float index;
     if (sign==-1) {
       index = (float)(WIDTH-1);
     }else {
       index=0;
     }
     kernelReadItem1d(ret_stream,index,item);
     streamWrite(item,&maxshift);
   }
   LogNMinusK=logN-2;
   i= logN-1;//could make this k! rather than N
   // where k = num elements pushed (N-logN%2?ret_stream,tmp_stream
   EstablishGuessfloat21d(ret_stream,
                            guess_stream,
                            list_stream,
                            (float)(1 << LogNMinusK),
                            maxvalue,
                            (float)(1<<i),
                            (float)sign);
   for (i=1;i<logN;++i) {
      LogNMinusK=logN-1-i;
      streamSwap(tmp_stream,guess_stream);
      UpdateGuessfloat21d (ret_stream,//scatter values
                             guess_stream,//new guess
                             list_stream,//actual values
                             (float)(1<<LogNMinusK),
                             maxvalue,
                             tmp_stream, //old guess
                             (float)sign);
   }
   debugStreamPrint(guess_stream,"Gather Value");
   if (1) {
      unsigned int size,width;
      size = (unsigned int)WIDTH
         - (unsigned int) maxshift;
      width = size;
      if (1) {
        float2 proper_output_stream<width>;
        if (width) {
          RelativeGatherfloat21d(proper_output_stream,
                                   guess_stream,
                                   list_stream,
                                   float2((float)sign,1.0f/(float)floor(.5)),
                                   maxvalue);
        }
        streamSwap(*output_stream,proper_output_stream);
      }
      debugStreamPrint(*output_stream, "Final Value");
   }
   return maxshift;
}

kernel void float21dstreamCombine1(float2 input0[],
                                float modulus,
                                float offset,
                                float2 oldoutput<>,
                                out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float21dstreamCombine2f(float2 input0[],
                            float2 input1[],
                            float modulus,
                            out float2 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 {
      output=input1[newindex];
   }
}

kernel void float21dstreamCombine2(float2 input0[],
                           float2 input1[],
                           float modulus,
                           float offset,
                           float2 oldoutput<>,
                           out float2 output <>) {
   float newindex;
   float whichmod;
   calculateDividedIndex1d(indexof(output), modulus, newindex);
   calculateIndexModulus1d(indexof(output), 
                         modulus,
                         offset,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void float21dstreamCombine3f(float2 input0[],