bones-compiler 1.1.0

data/examples/chunk/example3.c

@@ -0,0 +1,59 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........chunk/example3.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+#define BASE 2048
+#define TILE 64
+#define SIZE (BASE*TILE)
+
+// This is 'example3', demonstrating a chunked input and a chunked output, and showing the importance of ordering (array referenced first should be placed first)
+int main(void) {
+	int i;
+	int t = 0;
+	float result = 0;
+	
+	// Declare input/output arrays
+	float A[BASE];
+	float B[SIZE];
+	float out1[SIZE];
+	float out2[SIZE];
+	
+	// Set the input data
+	for(i=0;i<BASE;i++) {
+		A[i] = 0.6;
+	}
+	for(i=0;i<SIZE;i++) {
+		B[i] = i%6+i;
+	}
+	
+	// Perform the computation
+	#pragma species kernel 0:BASE-1|element ^ 0:SIZE-1|chunk(0:TILE-1) -> 0:SIZE-1|chunk(0:TILE-1) ^ 0:SIZE-1|chunk(0:TILE-1)
+	for(i=0;i<BASE;i++) {
+		result = A[i];
+		for(t=0;t<TILE;t++) {
+			result = result + t*B[i*TILE+t];
+		}
+		for(t=0;t<TILE;t++) {
+			out1[i*TILE+t] = result;
+			out2[i*TILE+t] = -result;
+		}
+	}
+	#pragma species endkernel example3
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/chunk/example4.c

@@ -0,0 +1,55 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........chunk/example4.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+#define SIZE 1024
+
+// This is 'example4', a basic element to chunk example with an if-statement in the body
+int main(void) {
+	int i;
+	int threshold = 19;
+	
+	// Declare input/output arrays
+	char A[SIZE];
+	char B[SIZE*2];
+	
+	// Set the input data
+	for(i=0;i<SIZE;i++) {
+		A[i] = i%100;
+	}
+	
+	// Set the output data to zero
+	for(i=0;i<SIZE*2;i++) {
+		B[i] = 0;
+	}
+	
+	// Perform the computation
+	#pragma species kernel 0:SIZE-1|element -> 0:SIZE*2-1|chunk(0:1)
+	for(i=0;i<SIZE;i++) {
+		B[i*2] = A[i];
+		if (A[i] > threshold) {
+			B[i*2+1] = A[i];
+		}
+		else {
+			B[i*2+1] = 0;
+		}
+	}
+	#pragma species endkernel example4
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/chunk/example5.c

@@ -0,0 +1,52 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........chunk/example5.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+
+// This is 'example5', demonstrating a chunk to element example without a temporary variable but directly writing to the output
+int main(void) {
+	int i,j;
+	int i2,j2;
+	
+	// Declare input/output arrays
+	int A[560][32];
+	int B[56][16];
+	
+	// Set the input data
+	for(i=0;i<560;i++) {
+		for(j=0;j<32;j++) {
+			A[i][j] = i+j;
+		}
+	}
+	
+	// Perform the computation
+	#pragma species kernel 0:559,0:31|chunk(0:9,0:1) -> 0:55,0:15|element
+	for(i=0;i<56;i++) {
+		for(j=0;j<16;j++) {
+			B[i][j] = 0;
+			for (i2=0;i2<10;i2++) {
+				for (j2=0;j2<2;j2++) {
+					B[i][j] = B[i][j] + A[i*10+i2][j*2+j2];
+				}
+			}
+		}
+	}
+	#pragma species endkernel example5
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/element/example1.c

@@ -0,0 +1,46 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example1.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+
+// This is 'example1', a very basic element to element example using 2D arrays.
+int main(void) {
+	int i,j;
+	
+	// Declare input/output arrays
+	int A[100][16];
+	int B[100][16];
+	
+	// Set the input data
+	for(i=0;i<100;i++) {
+		for(j=0;j<16;j++) {
+			A[i][j] = i+j;
+		}
+	}
+	
+	// Perform the computation
+	#pragma species kernel 0:99,0:15|element -> 0:99,0:15|element
+	for(i=0;i<100;i++) {
+		for(j=0;j<16;j++) {
+			B[i][j] = 2*A[i][j];
+		}
+	}
+	#pragma species endkernel example1
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/element/example10.c

@@ -0,0 +1,50 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example10.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+
+// This is 'example10', demonstrating multiple loops not starting at 0 for a 2D array and a kernel without a given name
+int main(void) {
+	int i,j;
+	int N = 4;
+	int M = 5;
+	
+	// Declare input/output arrays
+	int A[N][M];
+	int B[N][M];
+	
+	// Set the input data
+	for(i=0;i<N;i++) {
+		for(j=0;j<M;j++) {
+			A[i][j] = i*M+j;
+			B[i][j] = 9;
+		}
+	}
+	
+	// Perform the computation
+	#pragma species kernel 2:N-1,1:M-1|element -> 2:N-1,1:M-1|element
+	for(i=2;i<N;i++) {
+		for(j=1;j<M;j++) {
+			B[i][j] = A[i][j];
+		}
+	}
+	#pragma species endkernel
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/element/example11.c

@@ -0,0 +1,47 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example11.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+
+// This is 'example11', demonstrating an inner-loop which is dependent on an outer-loop variable and a classification of the inner-loop only
+int main(void) {
+	int i,j;
+	
+	// Declare input/output arrays
+	int A[128][128];
+	int B[128][128];
+	
+	// Set the input data
+	for(i=0;i<128;i++) {
+		for(j=0;j<128;j++) {
+			A[i][j] = i+j;
+			B[i][j] = 999;
+		}
+	}
+	
+	// Perform the computation
+	for(i=0;i<128;i++) {
+		#pragma species kernel i:i,i:127|element -> i:i,i:127|element
+		for(j=i;j<128;j++) {
+			B[i][j] = 2*A[i][j];
+		}
+		#pragma species endkernel example11
+	}
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/element/example12.c

@@ -0,0 +1,56 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example12.c
+// Author.............Cedric Nugteren
+// Last modified on...06-Aug-2012
+//
+
+#include <stdio.h>
+#include <stdlib.h>
+
+void computation(int* A, int* B, int constant);
+
+// This is 'example12', demonstrating a classification in another function
+int main(void) {
+	int i;
+	
+	// Declare input/output arrays
+	int* A = (int*)malloc(128*sizeof(int));
+	int* B = (int*)malloc(128*sizeof(int));
+	
+	// Set the input data
+	for(i=0;i<128;i++) {
+		A[i] = i+3;
+		B[i] = 999;
+	}
+	int constant = 3;
+	
+	// Call the computation function
+	computation(A,B,constant);
+	
+	// Clean-up and exit the function
+	free(A);
+	free(B);
+	fflush(stdout);
+	return 0;
+}
+
+// Function implementing the computation for 'example12'
+void computation(int* A, int* B, int constant) {
+	int i;
+	
+	// Perform the computation
+	#pragma species kernel 0:127|element -> 0:127|element
+	for(i=0;i<128;i++) {
+		B[i] = 2*A[i] + constant;
+	}
+	#pragma species endkernel example12
+}

data/examples/element/example2.c

@@ -0,0 +1,46 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example2.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+
+// This is 'example2', demonstrating unordered element-wise computation
+int main(void) {
+	int i,j;
+	
+	// Declare input/output arrays
+	int A[4][8];
+	int B[4][8];
+	
+	// Set the input data
+	for(i=0;i<4;i++) {
+		for(j=0;j<8;j++) {
+			A[i][j] = i+j;
+		}
+	}
+	
+	// Perform the computation
+	#pragma species kernel unordered 0:3,0:7|element -> 0:3,0:7|element
+	for(i=0;i<4;i++) {
+		for(j=0;j<8;j++) {
+			B[i][j] = A[i][7-j];
+		}
+	}
+	#pragma species endkernel example2
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+

data/examples/element/example3.c

@@ -0,0 +1,58 @@
+//
+// This file is part of the Bones source-to-source compiler examples. This C-code
+// example is meant to illustrate the use of Bones. For more information on Bones
+// use the contact information below.
+//
+// == More information on Bones
+// Contact............Cedric Nugteren <c.nugteren@tue.nl>
+// Web address........http://parse.ele.tue.nl/bones/
+//
+// == File information
+// Filename...........element/example3.c
+// Author.............Cedric Nugteren
+// Last modified on...16-April-2012
+//
+
+#include <stdio.h>
+#define N1 2//8
+#define N2 4//16
+#define N3 8//32
+#define N4 16//64
+
+// This is 'example3', demonstrating a 4D array and defines for array sizes
+int main(void) {
+	int i,j,k,l;
+	
+	// Declare input/output arrays
+	int A[N1][N2][N3][N4];
+	int B[N1][N2][N3][N4];
+	
+	// Set the input data
+	for(i=0;i<N1;i++) {
+		for(j=0;j<N2;j++) {
+			for(k=0;k<N3;k++) {
+				for(l=0;l<N4;l++) {
+					A[i][j][k][l] = i*j+k-l;
+				}
+			}
+		}
+	}
+	
+	// Perform the computation
+	#pragma species kernel 0:N1-1,0:N2-1,0:N3-1,0:N4-1|element -> 0:N1-1,0:N2-1,0:N3-1,0:N4-1|element
+	for(i=0;i<N1;i++) {
+		for(j=0;j<N2;j++) {
+			for(k=0;k<N3;k++) {
+				for(l=0;l<N4;l++) {
+					B[i][j][k][l] = 3*A[i][j][k][l]+6;
+				}
+			}
+		}
+	}
+	#pragma species endkernel example3
+	
+	// Clean-up and exit the function
+	fflush(stdout);
+	return 0;
+}
+