PR/Applications/Vthread/Vthread__Best_Effort_Msg_

comparison c-ray-mt.c @ 1:3840d91821c4

VPThread version is working

author	Merten Sach <msach@mailbox.tu-berlin.de>
date	Tue, 16 Aug 2011 20:31:31 +0200
parents	4ae1d7ffb1ae
children	75c818c6cad1

comparison

equal deleted inserted replaced

-:3390c1245541
+:c09da66b67c8
 	struct vec3 pos, targ;
 	double fov;
 };
 struct thread_data {
-	pthread_t tid;
+	VirtProcr *VP;
 	int sl_start, sl_count;
 	uint32_t *pixels;
 };
+typedef struct thread_data thread_data;
 void render_scanline(int xsz, int ysz, int sl, uint32_t *fb, int samples);
 struct vec3 trace(struct ray ray, int depth);
 struct vec3 shade(struct sphere *obj, struct spoint *sp, int depth);
 struct vec3 reflect(struct vec3 v, struct vec3 n);
 struct vec3 jitter(int x, int y, int s);
 int ray_sphere(const struct sphere *sph, struct ray ray, struct spoint *sp);
 void load_scene(FILE *fp);
 unsigned long get_msec(void);
-void *thread_func(void *tdata);
+void thread_func(void *tdata, VirtProcr *VProc);
 #define MAX_LIGHTS		16				/* maximum number of lights */
 #define RAY_MAG			1000.0			/* trace rays of this magnitude */
 #define MAX_RAY_DEPTH	5				/* raytrace recursion limit */
 #define FOV				0.78539816		/* field of view in rads (pi/4) */
 struct camera cam;
 int thread_num = 1;
 struct thread_data *threads;
-int start = 0;
+volatile int end = 0;
-pthread_mutex_t start_mutex = PTHREAD_MUTEX_INITIALIZER;
+volatile int start = 0;
-pthread_cond_t start_cond = PTHREAD_COND_INITIALIZER;
+int32 end_mutex, end_cond;
+int32 start_cond, start_mutex;
 #define NRAN	1024
 #define MASK	(NRAN - 1)
 struct vec3 urand[NRAN];
 int irand[NRAN];
 	"  -i <file>  read from <file> instead of stdin\n"
 	"  -o <file>  write to <file> instead of stdout\n"
 	"  -h         this help screen\n\n"
 };
-void raytrace(uint32_t *pixels);
+char __ProgrammName[] = "c-ray";
+char __DataSet[255];
+void raytrace(void *pixels, VirtProcr *Vprocr);
 int main(int argc, char **argv) {
 	int i;
 	uint32_t *pixels;
-double sl, sl_per_thread;
 	FILE *infile = stdin, *outfile = stdout;
 	for(i=1; i<argc; i++) {
 		if(argv[i][0] == '-' && argv[i][2] == 0) {
 			char *sep;
 		perror("pixel buffer allocation failed");
 		return EXIT_FAILURE;
 	}
 	load_scene(infile);
-raytrace(pixels);
+//This is the transition to the VMS runtime
+VPThread__create_seed_procr_and_do_work(raytrace, (void*)pixels);
 	/* output statistics to stderr */
 	fprintf(stderr, "Rendering took: %lu seconds (%lu milliseconds)\n", rend_time / 1000, rend_time);
 	/* output the image */
 		struct sphere *tmp = walker;
 		walker = walker->next;
 		free(tmp);
 	}
 	free(pixels);
-	free(threads);
 	return 0;
 }
 /* this is run after the VMS is set up*/
-void raytrace(uint32_t *pixels)
+void raytrace(void *pixels, VirtProcr *VProc)
 {
 int i;
 double sl, sl_per_thread;
 /* initialize the random number tables for the jitter */
 if(thread_num > yres) {
 fprintf(stderr, "more threads than scanlines specified, reducing number of threads to %d\n", yres);
 thread_num = yres;
 }
-if(!(threads = malloc(thread_num * sizeof *threads))) {
+if(!(threads = VPThread__malloc(thread_num * sizeof(thread_data), VProc))) {
 perror("failed to allocate thread table");
 exit(EXIT_FAILURE);
 }
+end_mutex = VPThread__make_mutex(VProc);
+end_cond  = VPThread__make_cond(end_mutex, VProc);
+start_mutex = VPThread__make_mutex(VProc);
+start_cond  = VPThread__make_cond(start_mutex, VProc);
 sl = 0.0;
 sl_per_thread = (double)yres / (double)thread_num;
 for(i=0; i<thread_num; i++) {
 threads[i].sl_start = (int)sl;
 sl += sl_per_thread;
 threads[i].sl_count = (int)sl - threads[i].sl_start;
-threads[i].pixels = pixels;
+threads[i].pixels = (uint32_t*)pixels;
-if(pthread_create(&threads[i].tid, 0, thread_func, &threads[i]) != 0) {
+threads[i].VP =
-perror("failed to spawn thread");
+VPThread__create_thread((VirtProcrFnPtr)thread_func,
-exit(EXIT_FAILURE);
+(void*)(&threads[i]), VProc);
-}
 }
 threads[thread_num - 1].sl_count = yres - threads[thread_num - 1].sl_start;
 fprintf(stderr, VER_STR, VER_MAJOR, VER_MINOR);
-pthread_mutex_lock(&start_mutex);
+// start worker threads
+//printf("start of worker thread (%d)\n", VProc->procrID);
+VPThread__mutex_lock(start_mutex, VProc);
 start_time = get_msec();
 start = 1;
-pthread_cond_broadcast(&start_cond);
+for(i=0; i<thread_num; i++)
-pthread_mutex_unlock(&start_mutex);
+VPThread__cond_signal(start_cond, VProc);
+VPThread__mutex_unlock(start_mutex, VProc);
-for(i=0; i<thread_num; i++) {
-pthread_join(threads[i].tid, 0);
+//printf("wait for worker (%d)\n", VProc->procrID);
-}
+VPThread__mutex_lock(end_mutex, VProc);
+while(end < thread_num)
+VPThread__cond_wait(end_cond, VProc);
+VPThread__mutex_unlock(end_mutex, VProc);
 rend_time = get_msec() - start_time;
+VPThread__free(threads,VProc);
+VPThread__dissipate_thread(VProc);
 }
 /* render a frame of xsz/ysz dimensions into the provided framebuffer */
 void render_scanline(int xsz, int ysz, int sl, uint32_t *fb, int samples) {
 	int i, s;
 }
 #else
 #error "I don't know how to measure time on your platform"
 #endif
-void *thread_func(void *tdata) {
+void thread_func(void *tdata, VirtProcr *VProc) {
 	int i;
 	struct thread_data *td = (struct thread_data*)tdata;
-	pthread_mutex_lock(&start_mutex);
+VPThread__mutex_lock(start_mutex, VProc);
-	while(!start) {
+while(!start)
-		pthread_cond_wait(&start_cond, &start_mutex);
+VPThread__cond_wait(start_cond, VProc);
-	}
+VPThread__mutex_unlock(start_mutex, VProc);
-	pthread_mutex_unlock(&start_mutex);
 	for(i=0; i<td->sl_count; i++) {
 		render_scanline(xres, yres, i + td->sl_start, td->pixels, rays_per_pixel);
 	}
-	return 0;
+VPThread__mutex_lock(end_mutex, VProc);
-}
+end++;
+VPThread__cond_signal(end_cond, VProc);
+VPThread__mutex_unlock(end_mutex, VProc);
+	VPThread__dissipate_thread(VProc);
+}

Mercurial > cgi-bin > hgwebdir.cgi > PR > Applications > Vthread > Vthread__Best_Effort_Msg__Bench

comparison c-ray-mt.c @ 1:3840d91821c4