vout1dfloatn.br

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

   default:
      float2streamCombine7(*streams[0],
                     *streams[1],
                     *streams[2],
                     *streams[3],
                     *streams[4],
                     *streams[5],
                     *streams[6],
                     modulus,
                     offset,

                     output,
                     output);
      if (num>7) {
         combineStreamsHelper1dfloat2(streams+7,
                                      num-7,
                                      output,
                                      modulus,
                                      7+offset);         
      } 
      */     
   }
}
void combineStreams1dfloat2 (float2 (**streams)<>,
                          unsigned int num,
                          unsigned int width, 
                          unsigned int UNUSED,
                               float2 (*output)<>) {
   float2 tmp<(num*width)>;
   streamSwap(tmp,*output);
   switch (num) {
   case 0:
      return;
   case 1:
      streamSwap(*output,*streams[0]);
      break;
   case 2:
      float21dstreamCombine2f(*streams[0],
                      *streams[1],
                      (float)num,
                      *output);
      break;
   case 3:
      float21dstreamCombine3f(*streams[0],
                      *streams[1],
                      *streams[2],
                      (float)num,
                      *output);
      break;
   case 4:
      float21dstreamCombine4f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      (float)num,
                      *output);
      break;
   case 5:
   default:
      float21dstreamCombine5f(*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) {
         combineStreamsHelper1dfloat2(streams+5,
                                      num-5,
                                      *output,
                                      (float)num,
                                      (float)(5-.5));
      }
      /*
      break;
   case 6:
      float2streamCombine6f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      num,
                      output);
      break;
   case 7:
      float2streamCombine7f(*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);
      }
      float2streamCombine8f(*streams[0],
                      *streams[1],
                      *streams[2],
                      *streams[3],
                      *streams[4],
                      *streams[5],
                      *streams[6],
                      *streams[7],
                      num,
                      output);
      if (num>8) {
         combineStreamsHelperfloat2(streams+8,
                                      num-8,
                                      output,
                                      num,
                                      8);
      }
      break;
      */
   }
}




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

unsigned int totalCombineVoutfloat21d (float2 list_stream<>, 
                                    unsigned int WIDTH,
                                    float2 list2_stream<>,
                                    unsigned int WIDTH2,
                                         float2 (*output)<>){

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

int finiteValueProduced1dfloat3 (float3 input<>) {
   float3 output<1>;
   float finiteout<1>;
   float3 rettype;
   float ret;
  
   debugStreamPrint (input,"Finite Values in...");
   valueProducedfloat31d(input,output);
   streamWrite(output,&rettype);
   isFiniteKernelfloat31d(output,finiteout);
   streamWrite(finiteout,&ret);
   return (int)ret;
}

kernel void valueAtfloat31d (float3 value[],
                             float index,
                             out float3 output<>,
                             float maxvalue,
                             float nothing) {
   if (index>=maxvalue||index<-.1)
      output = nothing;
   else 
      output = value[index];
}
kernel void NanToBoolRightfloat31d (float3 value[], 
                            out float output<>, 
                            float sign,
                            float maxvalue) {
   float nextPlaceToLook=(indexof output).x+sign;
   float3 neighbor;
   valueAtfloat31d(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = (isinf(value[indexof(output)].x)?1:0) 
      + (isinf(neighbor.x)?1:0);
}
kernel void NanToRightfloat31d (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 CountToRightfloat31d (float3 value [],
                                  out float3 output<>,
                                  float twotoi,
                                  float maxvalue) {
   float nextPlaceToLook=(indexof output).x+twotoi;
   float3 neighbor;
   valueAtfloat31d(value,nextPlaceToLook,neighbor,maxvalue,0);
   output = value[indexof(output)]+neighbor;
}

kernel void GatherGuessfloat31d(float scatterindex[],
                        out float output<>,
                        float3 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 {
         float3 actualValue;
         valueAtfloat31d(value,nextPlaceToLook,actualValue,maxvalue,0);
         if (neighbor==halfk&&!isinf(actualValue.x)) {
            output=halfk;
         }else {
            output = halfk-twotologkminusi;
         }         
      }
}
kernel void EstablishGuessfloat31d(float scatterindex[],
                                   out float output<>,
                                   float3 value[],
                                   float twotologkminusi,
                                   float maxvalue,
                                   float halfk,
                                   float sign) {
   if (scatterindex[indexof(output)]==0) {
      output=0;
   } else {
      GatherGuessfloat31d(scatterindex,
                          output,
                          value,
                          twotologkminusi,
                          maxvalue,
                          halfk,
                          sign);
    }
}
kernel void UpdateGuessfloat31d(float scatterindex[],
                                out float output<>,
                                float3 value[],
                                float twotologkminusi,
                                float maxvalue,
                                float lastguess<>,
                                float sign) {
   GatherGuessfloat31d(scatterindex,
                       output,
                       value,
                       twotologkminusi,
                       maxvalue,
                       lastguess,
                       sign);
}

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


float shiftValues1dfloat3(float3 list_stream <>,
                            float3 (*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...");
   NanToBoolRightfloat31d (list_stream,ret_stream,(float)sign,maxvalue);   
   for (i=1;i<logN;++i) {
      streamSwap(ret_stream,tmp_stream);
      NanToRightfloat31d(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
   EstablishGuessfloat31d(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);