Added separate compilation and linking example

Author: harrism

posts/separate-compilation-linking/main.cpp

@@ -0,0 +1,47 @@
+#include <particle.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+__global__ void advanceParticles(float dt, particle * pArray, int nParticles)
+{
+	int idx = threadIdx.x + blockIdx.x*blockDim.x;
+	if(idx < nParticles)
+	{
+		pArray[idx].advance(dt);
+	}
+}
+
+int main(int argc, char ** argv)
+{
+	int n = 1000000;
+	if(argc > 1)	{ n = atoi(argv[1]);}     // Number of particles
+	if(argc > 2)	{	srand(atoi(argv[2])); } // Random seed
+
+	particle * pArray = new particle[n];
+	particle * devPArray = NULL;
+	cudaMalloc(&devPArray, n*sizeof(particle));
+	cudaMemcpy(devPArray, pArray, n*sizeof(particle), cudaMemcpyHostToDevice);
+	for(int i=0; i<100; i++)
+	{
+		float dt = (float)rand()/(float) RAND_MAX; // Random distance each step
+		advanceParticles<<< 1 +  n/256, 256>>>(dt, devPArray, n);
+		cudaDeviceSynchronize();
+	}
+	cudaMemcpy(pArray, devPArray, n*sizeof(particle), cudaMemcpyDeviceToHost);
+	v3 totalDistance(0,0,0);
+	v3 temp;
+	for(int i=0; i<n; i++)
+	{
+		temp = pArray[i].getTotalDistance();
+		totalDistance.x += temp.x;
+		totalDistance.y += temp.y;
+		totalDistance.z += temp.z;
+	}
+	float avgX = totalDistance.x /(float)n;
+	float avgY = totalDistance.y /(float)n;
+	float avgZ = totalDistance.z /(float)n;
+	float avgNorm = sqrt(avgX*avgX + avgY*avgY + avgZ*avgZ);
+	printf(	"Moved %d particles 100 steps. Average distance traveled is |(%f, %f, %f)| = %f\n", 
+					n, avgX, avgY, avgZ, avgNorm);
+	return 0;
+}

posts/separate-compilation-linking/makefile

@@ -0,0 +1,10 @@
+objects = main.o particle.o v3.o
+
+all: $(objects)
+		nvcc -arch=sm_20 $(objects) -o app
+
+%.o: %.cpp
+		nvcc -x cu -arch=sm_20 -I. -dc $< -o $@
+
+clean:
+		rm -f *.o app

posts/separate-compilation-linking/particle.cpp

@@ -0,0 +1,23 @@
+#include <particle.h>
+
+particle::particle() : 	position(), velocity(), totalDistance(0,0,0)
+{}
+
+__device__ __host__ 
+void particle::advance(float d)
+{
+	velocity.normalize();
+	float dx = d * velocity.x;
+	position.x += dx;
+	totalDistance.x += dx;
+	float dy = d * velocity.y;
+ 	position.y += dy;
+ 	totalDistance.y += dy;
+ 	float dz = d * velocity.z;
+	position.z += dz;
+	totalDistance.z += dz;
+	velocity.scramble();
+}
+
+const v3& particle::getTotalDistance() const
+{	return totalDistance; }

posts/separate-compilation-linking/particle.h

@@ -0,0 +1,20 @@
+#ifndef __particle_h__
+#define __particle_h__
+
+#include <v3.h>
+
+class particle
+{
+	private:
+		v3 position;
+		v3 velocity;
+		v3 totalDistance;
+
+	public:
+		particle();
+		__host__ __device__ void advance(float dist);
+		const v3& getTotalDistance() const;
+
+};
+
+#endif

posts/separate-compilation-linking/v3.cpp

@@ -0,0 +1,33 @@
+#include <v3.h>
+#include <math.h>
+
+v3::v3()
+{	randomize(); }
+
+v3::v3(float xIn, float yIn, float zIn) : x(xIn), y(yIn), z(zIn)
+{}
+
+void v3::randomize()
+{
+	x = (float)rand() / (float)RAND_MAX;
+	y = (float)rand() / (float)RAND_MAX;
+	z = (float)rand() / (float)RAND_MAX;
+}
+
+__host__ __device__ void v3::normalize()
+{
+	float t = sqrt(x*x + y*y + z*z);
+	x /= t;
+	y /= t;
+	z /= t;
+}
+
+__host__ __device__ void v3::scramble()
+{
+	float tx = 0.317f*(x + 1.0) + y + z * x * x + y + z;
+	float ty = 0.619f*(y + 1.0) + y * y + x * y * z + y + x;
+	float tz = 0.124f*(z + 1.0) + z * y + x * y * z + y + x;
+	x = tx;
+	y = ty;
+	z = tz;
+}

posts/separate-compilation-linking/v3.h

@@ -0,0 +1,19 @@
+#ifndef __v3_h__
+#define __v3_h__
+
+class v3
+{
+public:
+	float x;
+	float y;
+	float z;
+	
+	v3();
+	v3(float xIn, float yIn, float zIn);
+	void randomize();
+	__host__ __device__ void normalize();
+	__host__ __device__ void scramble();
+
+};
+
+#endif