[llvm-commits] CVS: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/Makefile distray.bc distray.c ref.in test.in
Chris Lattner
lattner at cs.uiuc.edu
Sat Oct 11 16:20:28 PDT 2003
Changes in directory llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray:
Makefile added (r1.1)
distray.bc added (r1.1)
distray.c added (r1.1)
ref.in added (r1.1)
test.in added (r1.1)
---
Log message:
Initial checkin of the FreeBench benchmark suite
---
Diffs of the changes: (+462 -0)
Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/Makefile
diff -c /dev/null llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/Makefile:1.1
*** /dev/null Sat Oct 11 16:18:57 2003
--- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/Makefile Sat Oct 11 16:18:47 2003
***************
*** 0 ****
--- 1,12 ----
+ LEVEL = ../../../../../..
+
+ PROG = distray
+ CPPFLAGS = -DVERSION='"1.00"' -DCOMPDATE="\"today\"" -DCFLAGS='""' -DHOSTNAME="\"thishost\""
+ LDFLAGS = -lm
+ ifdef LARGE_PROBLEM_SIZE
+ RUN_OPTIONS = ref.in
+ else
+ RUN_OPTIONS = test.in
+ endif
+ include $(LEVEL)/test/Programs/MultiSource/Makefile.multisrc
+
Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/distray.bc
Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/distray.c
diff -c /dev/null llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/distray.c:1.1
*** /dev/null Sat Oct 11 16:18:57 2003
--- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/distray.c Sat Oct 11 16:18:47 2003
***************
*** 0 ****
--- 1,448 ----
+ #include <stdio.h>
+ #include <math.h>
+ #include <stdlib.h>
+ #include <sys/time.h>
+ #include <sys/resource.h>
+ #include <unistd.h>
+
+ /* Simple raytracer
+ * ----------------
+ * Features reflections, anti-aliasing
+ * and soft-shadows.
+ *
+ * Written by Marcus Geelnard, benchmarkified by
+ * Peter Rundberg, biff at ce.chalmers.se
+ */
+
+ #define WIDTH 640
+ #define HEIGHT 480
+ #define EPSILON (1e-5) /* Very small value, used for coordinate-comparsions */
+ #define MAXT (1e5) /* Maximum t-distance for an intersection-point */
+ #define MAXREC 6 /* Maximum amount of recursions (reflection etc.) */
+ /* #define DISTRIB 12 */ /* Amount of distributed rays per "virtual" ray */
+ int DISTRIB;
+ #define DISTLEVELS 3 /* How deep in the recursion-tree to allow distribution */
+
+ typedef unsigned char UBYTE;
+ typedef struct { double x,y,z; } VECTOR;
+
+ UBYTE memory[3*WIDTH*HEIGHT];
+
+ typedef struct {
+ VECTOR color; /* Object color (r,g,b) */
+ double diffuse; /* Diffuse reflection (0-1) */
+ double reflect; /* Relefction (0-1) */
+ double roughness; /* How rough the reflection is (0=very sharp) */
+ } TEXTURE;
+
+ typedef struct {
+ VECTOR pos; /* Position (x,y,z) */
+ double r; /* Radius (or size) */
+ TEXTURE t; /* Texture */
+ } OBJ;
+
+ /*
+ * Objects ( = spheres ). Only one sphere. Add more if you like :)
+ */
+
+ OBJ objs[] = {
+ /* Object 1 */
+ {
+ { 0, 4, 1.0 }, 1,
+ {
+ { 1.0, 0.4, 0.0 },
+ 0.4,
+ 0.8,
+ 0.02
+ }
+ },
+ /* Object 2 */
+ {
+ { -1, 3, 0.4 }, 0.4,
+ {
+ { 0.5, 0.3, 1.0 },
+ 0.5,
+ 0.9,
+ 0.01
+ }
+ },
+ /* Object 3 */
+ {
+ { -0.3, 1, 0.4 }, 0.4,
+ {
+ { 0.1, 0.95, 0.2 },
+ 0.6,
+ 0.8,
+ 0.01
+ }
+ },
+ /* Object 4 */
+ {
+ { 1.0, 2, 0.4 }, 0.4,
+ {
+ { 0.86, 0.83, 0 },
+ 0.7,
+ 0.6,
+ 0.01
+ }
+ }
+ };
+
+ #define NUMOBJS 4
+
+
+ /*
+ * Ground position (z-pos), and textures (tiled)
+ */
+
+ double Groundpos = 0.0;
+ TEXTURE Groundtxt[2] = {
+ {
+ { 0.0, 0.1, 0.5 },
+ 0.8,
+ 0.44,
+ 0.02
+ },
+ {
+ { 0.6, 1.0, 0.5 },
+ 0.8,
+ 0.44,
+ 0.01
+ },
+ };
+
+
+ /*
+ * Only one light-source is supported (and it's white).
+ */
+
+ VECTOR Lightpos = {-3.0, 1.0, 5.0};
+ double Lightr = 0.4; /* Light-radius (for soft shadows) */
+
+
+ /*
+ * The camera position (x,y,z), and orientation.
+ */
+
+ VECTOR Camerapos = {1.5, -1.4, 1.2};
+ VECTOR Cameraright = {3.0, 1.0, 0.0};
+ VECTOR Cameradir = {-1.0, 3.0, 0.0};
+ VECTOR Cameraup = {0.0, 0.0, 2.3717};
+
+
+ /*
+ * Ambient lighting (0.0-1.0)
+ */
+
+ double Ambient = 0.3;
+
+
+ /*
+ * Skycolors (Skycolor[0] = horizon, Skycolor[1] = zenit )
+ */
+
+ VECTOR Skycolor[2] = { { 0.5, 0.3, 0.7 }, { 0.0, 0.0, 0.2 } };
+
+
+ /**************************************************************************
+ *
+ * Helpers (geometrical etc).
+ *
+ **************************************************************************/
+
+ long rnd = 0x52462467L;
+
+ static double Jitter( void )
+ {
+ rnd = (1103515245L*rnd + 12345L) & 0x7fffffffL;
+ return( 1.0-((double)rnd/(double)0x3fffffff) );
+ }
+
+
+ static void ReflectVector( VECTOR *v2, VECTOR *v1, VECTOR *n )
+ {
+ double a, b;
+
+ b = n->x*n->x + n->y*n->y + n->z*n->z; /* b = |n|^2 */
+ a = v1->x*n->x + v1->y*n->y + v1->z*n->z; /* a = v1·n */
+ a = -2.0 * a / b; /* a = -2*(v1·n)/|n|^2 */
+ v2->x = v1->x + a*n->x; /* v2 = v1 + n*a */
+ v2->y = v1->y + a*n->y;
+ v2->z = v1->z + a*n->z;
+ }
+
+
+ static double VectorLength( VECTOR *v )
+ {
+ return( sqrt( v->x*v->x + v->y*v->y + v->z*v->z ) );
+ }
+
+
+ static void ScaleVector( VECTOR *v, double s )
+ {
+ v->x *= s; v->y *= s; v->z *= s;
+ }
+
+
+ static void DistribVector( VECTOR *d, VECTOR *n, double sa, double sb )
+ {
+ VECTOR a, b;
+ double nl;
+
+ if( fabs( n->z ) > EPSILON ) {
+ a.x = n->y*n->z; a.y = -n->x*n->z; a.z = 0.0;
+ b.x = a.y*n->z; b.y = -a.x*n->z; b.z = a.x*n->y - a.y*n->x;
+ } else {
+ a.x = n->y; a.y = -n->x; a.z = 0.0;
+ b.x = b.y = 0.0; b.z = 1.0;
+ }
+ nl = VectorLength( n );
+ ScaleVector( &a, sa*(nl/VectorLength( &a ))*Jitter() );
+ ScaleVector( &b, sb*(nl/VectorLength( &b ))*Jitter() );
+ d->x = a.x+b.x; d->y = a.y+b.y; d->z = a.z+b.z;
+ }
+
+
+ /**************************************************************************
+ *
+ * Object intersection calculation routines.
+ *
+ **************************************************************************/
+
+ static double IntersectObjs( VECTOR *LinP, VECTOR *LinD,
+ VECTOR *Pnt, VECTOR *Norm, TEXTURE **txt )
+ {
+ int objn, tilenum;
+ double t, ttmp, A, B, C;
+ VECTOR Pos;
+
+ t = -1.0;
+
+ /* Try intersection with ground plane first */
+ if( fabs(LinD->z) > EPSILON ) {
+ ttmp = (Groundpos - LinP->z)/LinD->z;
+ if( ( ttmp > EPSILON ) && ( ttmp < MAXT ) ) {
+ t = ttmp;
+ Pnt->x = LinP->x + LinD->x*t; /* Calculate intersection point */
+ Pnt->y = LinP->y + LinD->y*t;
+ Pnt->z = LinP->z + LinD->z*t;
+ Norm->x = 0.0; /* Surface normal (always up) */
+ Norm->y = 0.0;
+ Norm->z = 1.0;
+ tilenum = ( ((int)(Pnt->x+50000.0))+((int)(Pnt->y+50000.0)) ) & 1;
+ *txt = & Groundtxt[ tilenum ];
+ }
+ }
+
+ /* Get closest intersection (if any) */
+ for( objn = 0; objn < NUMOBJS; objn++ ) {
+ Pos = objs[objn].pos;
+ Pos.x -= LinP->x; /* Translate object into "line-space" */
+ Pos.y -= LinP->y;
+ Pos.z -= LinP->z;
+ A = 1.0 / (LinD->x*LinD->x + LinD->y*LinD->y + LinD->z*LinD->z);
+ B = (Pos.x*LinD->x + Pos.y*LinD->y + Pos.z*LinD->z) * A;
+ C = (objs[objn].r*objs[objn].r - Pos.x*Pos.x - Pos.y*Pos.y - Pos.z*Pos.z) * A;
+ if( (A = C + B*B) > 0.0 ) { /* ...else no hit */
+ A = sqrt(A);
+ if( (ttmp = B - A) < EPSILON ) ttmp = B + A;
+ if( (EPSILON<ttmp) && ( (ttmp<t)||(t<0.0) ) ) {
+ t = ttmp;
+ Pnt->x = LinD->x*t; /* Calculate intersection point */
+ Pnt->y = LinD->y*t;
+ Pnt->z = LinD->z*t;
+ Norm->x = Pnt->x-Pos.x; /* Calcualate surface normal */
+ Norm->y = Pnt->y-Pos.y;
+ Norm->z = Pnt->z-Pos.z;
+ Pnt->x += LinP->x; /* Translate object back to "true-space" */
+ Pnt->y += LinP->y;
+ Pnt->z += LinP->z;
+ *txt = &objs[objn].t; /* Get surface properties */
+ }
+ }
+ }
+
+ return( t );
+ }
+
+
+ /**************************************************************************
+ *
+ * Line-tracer routine (works recursively).
+ *
+ **************************************************************************/
+
+ static void TraceLine( VECTOR *LinP, VECTOR *LinD, VECTOR *Color, int reccount )
+ {
+ VECTOR Pnt, Norm, LDir, NewDir, NewDir2, TmpCol, TmpCol2;
+ VECTOR TmpPnt, TmpNorm, D;
+ double t, A, cosfi;
+ TEXTURE *txt, *tmptxt;
+ int i, shadowcount, usedist;
+
+ Color->x = Color->y = Color->z = 0.0;
+
+ if( reccount > 0 ) {
+ /* Only use distributed tracing in higher nodes of the recursion tree */
+ usedist = ( (MAXREC-reccount) < DISTLEVELS ) ? 1 : 0;
+
+ /* Try intersection with objects */
+ t = IntersectObjs( LinP, LinD, &Pnt, &Norm, &txt );
+
+ /* Get light-intensity in intersection-point (store in cosfi) */
+ if( t > EPSILON ) {
+ LDir.x = Lightpos.x-Pnt.x; /* Get line to light from surface */
+ LDir.y = Lightpos.y-Pnt.y;
+ LDir.z = Lightpos.z-Pnt.z;
+ cosfi = LDir.x*Norm.x + LDir.y*Norm.y + LDir.z*Norm.z;
+ if(cosfi > 0.0) { /* If angle between lightline and normal < PI/2 */
+ shadowcount = 0;
+ if( usedist ) {
+ A = Lightr / VectorLength( &LDir );
+ for( i = 0; i < DISTRIB; i++ ) {
+ DistribVector( &D, &LDir, A, A );
+ NewDir = LDir;
+ NewDir.x += D.x; NewDir.y += D.y; NewDir.z += D.z;
+ /* Check for shadows (ignore hit info, may be used though) */
+ t = IntersectObjs( &Pnt, &NewDir, &TmpPnt, &TmpNorm, &tmptxt );
+ if( ( t < EPSILON ) || ( t > 1.0 ) ) shadowcount++;
+ }
+ } else {
+ t = IntersectObjs( &Pnt, &LDir, &TmpPnt, &TmpNorm, &tmptxt );
+ if( ( t < EPSILON ) || ( t > 1.0 ) ) shadowcount = DISTRIB;
+ }
+ if( shadowcount > 0 ) {
+ A = Norm.x*Norm.x + Norm.y*Norm.y + Norm.z*Norm.z;
+ A *= LDir.x*LDir.x + LDir.y*LDir.y + LDir.z*LDir.z;
+ cosfi = (cosfi/sqrt(A))*txt->diffuse*(double)shadowcount/DISTRIB;
+ } else {
+ cosfi = 0.0;
+ }
+ } else {
+ cosfi = 0.0;
+ }
+ Color->x = txt->color.x*(Ambient+cosfi);
+ Color->y = txt->color.y*(Ambient+cosfi);
+ Color->z = txt->color.z*(Ambient+cosfi);
+ if( txt->reflect > EPSILON ) {
+ ReflectVector( &NewDir, LinD, &Norm );
+ TmpCol.x = TmpCol.y = TmpCol.z = 0.0;
+ if( usedist && ( txt->roughness > EPSILON ) ) {
+ for( i = 0; i < DISTRIB; i++ ) {
+ DistribVector( &D, &NewDir, txt->roughness, txt->roughness );
+ NewDir2 = NewDir;
+ NewDir2.x += D.x; NewDir2.y += D.y; NewDir2.z += D.z;
+ TraceLine( &Pnt, &NewDir2, &TmpCol2, reccount-1 );
+ TmpCol.x += TmpCol2.x;
+ TmpCol.y += TmpCol2.y;
+ TmpCol.z += TmpCol2.z;
+ }
+ ScaleVector( &TmpCol, 1.0/DISTRIB );
+ } else {
+ TraceLine( &Pnt, &NewDir, &TmpCol, reccount-1 );
+ }
+ Color->x += TmpCol.x * txt->reflect;
+ Color->y += TmpCol.y * txt->reflect;
+ Color->z += TmpCol.z * txt->reflect;
+ }
+ } else {
+ /* Get sky-color (interpolate between horizon and zenit) */
+ A = sqrt( LinD->x*LinD->x + LinD->y*LinD->y );
+ if( A > 0.0 ) A = atan( fabs( LinD->z ) / A )*0.63661977;
+ else A = 1.0;
+ Color->x = Skycolor[1].x*A + Skycolor[0].x*(1.0-A);
+ Color->y = Skycolor[1].y*A + Skycolor[0].y*(1.0-A);
+ Color->z = Skycolor[1].z*A + Skycolor[0].z*(1.0-A);
+ }
+
+ /* Make sure that the color does not exceed the maximum level */
+ if(Color->x > 1.0) Color->x = 1.0;
+ if(Color->y > 1.0) Color->y = 1.0;
+ if(Color->z > 1.0) Color->z = 1.0;
+ }
+ }
+
+ static void TraceScene(void)
+ {
+ VECTOR PixColor, Col, LinD, Scale;
+ VECTOR LinD2, D;
+ int sx, sy, i;
+
+ Scale.y = 1.0;
+ for( sy = 0; sy < HEIGHT; sy++ ) {
+ Scale.z = ((double)(HEIGHT/2-sy))/(double)HEIGHT;
+ for( sx = 0; sx < WIDTH; sx++ ) {
+ Scale.x = ((double)(sx-WIDTH/2))/(double)WIDTH;
+
+ /* Calculate line-direction (from camera-center through a pixel) */
+ LinD.x = Cameraright.x*Scale.x + Cameradir.x*Scale.y + Cameraup.x*Scale.z;
+ LinD.y = Cameraright.y*Scale.x + Cameradir.y*Scale.y + Cameraup.y*Scale.z;
+ LinD.z = Cameraright.z*Scale.x + Cameradir.z*Scale.y + Cameraup.z*Scale.z;
+
+ /* Get color for pixel */
+ #if (DISTLEVELS > 0)
+ PixColor.x = PixColor.y = PixColor.z = 0.0;
+ for( i = 0; i < DISTRIB; i++ ) {
+ DistribVector( &D, &LinD, 0.5/(double)WIDTH, 0.5/(double)HEIGHT );
+ LinD2 = LinD; LinD2.x += D.x; LinD2.y += D.y; LinD2.z += D.z;
+ TraceLine( &Camerapos, &LinD2, &Col, MAXREC );
+ PixColor.x += Col.x;
+ PixColor.y += Col.y;
+ PixColor.z += Col.z;
+ }
+ ScaleVector( &PixColor, 1.0/DISTRIB );
+ #else
+ TraceLine( &Camerapos, &LinD, &PixColor, MAXREC );
+ #endif
+
+ memory[3*(sx+sy*WIDTH)]=(UBYTE)(PixColor.x*255.0);
+ memory[3*(sx+sy*WIDTH)+1]=(UBYTE)(PixColor.y*255.0);
+ memory[3*(sx+sy*WIDTH)+2]=(UBYTE)(PixColor.z*255.0);
+ }
+ }
+ }
+
+
+ /**************************************************************************
+ *
+ * main() - Camera emulation and picture output to stdout.
+ *
+ **************************************************************************/
+
+ int main(int c, char *v[])
+ {
+ int i;
+
+ FILE *in_fp;
+
+ fprintf(stderr,"Compile date: %s\n", COMPDATE);
+ fprintf(stderr,"Compiler switches: %s\n", CFLAGS);
+
+ in_fp=fopen(v[1],"r");
+ if (!in_fp) {
+ printf("ERROR: Could not open indata file\n");
+ exit(1);
+ }
+
+ fscanf(in_fp,"%d",&DISTRIB);
+ fclose(in_fp);
+ /* End of Benchmark stuff */
+
+
+ /* Write PPM header to stdout */
+ fprintf( stdout, "P6" ); fputc( 10, stdout );
+ fprintf( stdout, "%d %d", WIDTH, HEIGHT ); fputc( 10, stdout );
+ fprintf( stdout, "255" ); fputc( 10, stdout );
+
+ /***...calculate image...***/
+ TraceScene();
+
+ /***...write image to stdout...***/
+ for (i=0 ; i<3*WIDTH*HEIGHT ; ) {
+ fputc( memory[i++], stdout);
+ fputc( memory[i++], stdout);
+ fputc( memory[i++], stdout);
+ }
+
+ return 0; /***...ANSI C wants main to return an int...***/
+ }
Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/ref.in
diff -c /dev/null llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/ref.in:1.1
*** /dev/null Sat Oct 11 16:18:57 2003
--- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/ref.in Sat Oct 11 16:18:47 2003
***************
*** 0 ****
--- 1 ----
+ 6
Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/test.in
diff -c /dev/null llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/test.in:1.1
*** /dev/null Sat Oct 11 16:18:57 2003
--- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/distray/test.in Sat Oct 11 16:18:47 2003
***************
*** 0 ****
--- 1 ----
+ 1
More information about the llvm-commits
mailing list