vout.br

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

#include <stdio.h>
#include <stdlib.h>
/* vc7 floating point paranoia.  This program is in serious violation. */
#ifdef _WIN32
#pragma warning(disable:4244)
#endif
void __printf_cpu_inner(float inx, float iny, float outx, float outy) {
   printf("%g %g -> %g %g\n",inx,iny,outx,outy);
}
unsigned int debug_vout = 0;
void debugStreamPrint (float stream<>,char * title) {
   if (debug_vout) {
      printf ("%s\n",title);
      
      streamPrint(stream,1);
      printf ("\n\n");
   }
}
const unsigned int MAX_VOUT_STREAMS=31;//if you change this, change one 5 lines
                                       // later
kernel void calculateDividedIndex(float4 index, 
                                  float modulus, 
                                  float length, 
                                  out float2 newindex<>){
   float epsilon=1.0f/32.0f;
   //this is needed because the division may result in
   // loss of accuracy.  We know that for a 2048 texture the mantissa holds 
   // 1/32 precision
   newindex=float2(index.x,index.y);
   newindex/=modulus;
   newindex.x=floor(fmod(newindex.x+frac(newindex.y)*length+epsilon,length));
   newindex.y=floor(newindex.y+epsilon);

}
kernel void calculateIndexModulus (float4 index, 
                                   float modulus,
                                   float mod, 
                                   float offset,
                                   float lengthmodmodulus, 
                                   out float which <>) {
   which= floor(fmod(round(index.y*lengthmodmodulus 
                + fmod(index.x,mod)),
	               modulus)-offset);
}
kernel void streamCombine1(float input0[][],
                           float modulus,
                           float mod, 
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         offset,
                         lengthmodmodulus,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else {
      output=oldoutput;
   }

}

kernel void streamCombine2f(float input0[][],
                            float input1[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod, 
                         -0.5f,
                         lengthmodmodulus,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else {
      output=input1[newindex];
   }
//output=newindex.x;
}

kernel void streamCombine2(float input0[][],
                           float input1[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod, 
                         offset,
                         lengthmodmodulus,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else {
      output=oldoutput;
   }
}

kernel void streamCombine3f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod, 
                         -0.5f,
                         lengthmodmodulus,
                         whichmod);
   if (whichmod==0||whichmod==modulus) {
      output=input0[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else {
      output=input2[newindex];
   }
}

kernel void streamCombine3(float input0[][],
                           float input1[][],
                           float input2[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod, 
                         offset,
                         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 {
      output=oldoutput;
   }
}

kernel void streamCombine4f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float input3[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod, 
                         -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 {
      output=input3[newindex];
   }
}

kernel void streamCombine4(float input0[][],
                           float input1[][],
                           float input2[][],
                           float input3[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         offset,
                         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 {
      output=oldoutput;
   }
}

kernel void streamCombine5f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float input3[][],
                            float input4[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         -0.5f,
                         lengthmodmodulus,
                         whichmod);
   if (whichmod==4) {
      output=input4[newindex];
   }else if (whichmod==1) {
      output=input1[newindex];
   }else if (whichmod==2) {
      output=input2[newindex];
   }else if (whichmod==3) {
     output=input3[newindex];
   }else {
     output=input0[newindex];
   }
}
/*
kernel void streamCombine5(float input0[][],
                           float input1[][],
                           float input2[][],
                           float input3[][],
                           float input4[][],
                           float modulus,
                           float mod,
                           float offset,
                           float length, 
                           float lengthmodmodulus,
                           float oldoutput<>,
                           out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         offset,
                         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 {
      output=oldoutput;
   }
}


kernel void streamCombine6f(float input0[][],
                            float input1[][],
                            float input2[][],
                            float input3[][],
                            float input4[][],
                            float input5[][],
                            float modulus,
                           float mod,
                            float length, 
                            float lengthmodmodulus,
                            out float output <>) {
   float2 newindex;
   float whichmod;
   calculateDividedIndex(indexof(output), modulus, length, newindex);
   calculateIndexModulus(indexof(output), 
                         modulus, mod,
                         -0.5f,