int main() { spe_context_ptr_t ctx; unsigned int entry = SPE_DEFAULT_ENTRY; init_matrix(); if((ctx = spe_context_create(0, NULL)) == NULL) { perror ("Failed creating context"); exit (1); } if(spe_program_load(ctx, &lab10_spu)) { perror ("Failed loading program"); exit (1); } printf("SPU:\n"); if(spe_context_run(ctx, &entry, 0, (void*)&v, (void*)M, NULL) < 0) { perror ("Failed running context"); exit (1); } if(spe_context_destroy(ctx) != 0) { perror("Failed destroying context"); exit (1); } printf("PPU:\n"); printf("received: %d %d \n", v[0][0].x, v[0][0].y); printf("correct: %d\n", (destination.x == v[0][0].x) && (destination.y == v[0][0].y)); return 0; }
static void free_memory() { spe_context_destroy(context); spe_image_close(spe_program); free((void *) mControlBlockAddr); free(binary); }
void *ppu_pthread_function(void *thread_arg) { spe_context_ptr_t ctx; struct package_t *arg = (struct package_t *) thread_arg; /* Create SPE context */ if ((ctx = spe_context_create (0, NULL)) == NULL) { perror ("Failed creating context"); exit (1); } /* Load SPE program into context */ if (spe_program_load (ctx, &lab8_spu)) { perror ("Failed loading program"); exit (1); } /* Run SPE context */ unsigned int entry = SPE_DEFAULT_ENTRY; /* transferul adresei structurii initiale */ if (spe_context_run(ctx, &entry, 0, (void *)arg, (void *)sizeof(struct package_t), NULL) < 0) { perror ("Failed running context"); exit (1); } /* Destroy context */ if (spe_context_destroy (ctx) != 0) { perror("Failed destroying context"); exit (1); } pthread_exit(NULL); }
int main (void) { pthread_t pts; spe_context_ptr_t ctx; unsigned int value; unsigned int pid; ctx = spe_context_create (0, NULL); pthread_create (&pts, NULL, &spe_thread, &ctx); /* Wait until the SPU thread is running. */ spe_out_intr_mbox_read (ctx, &value, 1, SPE_MBOX_ALL_BLOCKING); pid = fork (); if (pid == 0) { /* This is the child. Just exit immediately. */ exit (0); } else { /* This is the parent. Wait for the child to exit. */ waitpid (pid, NULL, 0); } /* Tell SPU to continue. */ spe_in_mbox_write (ctx, &value, 1, SPE_MBOX_ALL_BLOCKING); pthread_join (pts, NULL); spe_context_destroy (ctx); return 0; }
int main() { spe_context_ptr_t speid; unsigned int flags = 0; unsigned int entry = SPE_DEFAULT_ENTRY; void *argp = NULL; void *envp = NULL; spe_stop_info_t stop_info; int rc; speid = spe_context_create(0,NULL); if (speid==NULL) { perror("spe_context_create"); return -1; } //Load SPE executable object into the SPE context local store if (spe_program_load(speid, &hello_spu)) { perror("spe_program_load"); return -2; } //Run the SPE context rc = spe_context_run(speid, &entry, flags, argp, envp, &stop_info); if (rc<0) perror("spe_context_run"); //Destroy the SPE context spe_context_destroy(speid); return 0; }
int main (void) { int thread_id[nr_t]; pthread_t pts[nr_t]; spe_context_ptr_t ctx[nr_t]; int cnt; char var_char = 'c'; short var_short = 7; int var_int = 1337; long var_long = 123456; long long var_longlong = 123456789; float var_float = 1.23; double var_double = 2.3456; long double var_longdouble = 3.45678; for (cnt = 0; cnt < nr_t; cnt++) { ctx[cnt] = spe_context_create(0, NULL); thread_id[cnt] = pthread_create (&pts[cnt], NULL, &spe_thread, &ctx[cnt]); } for (cnt = 0; cnt < nr_t; cnt++) pthread_join (pts[cnt], NULL); for (cnt = 0; cnt < nr_t; cnt++) spe_context_destroy (ctx[cnt]); return 0; }
int main (void) { int thread_id[nr_t]; pthread_t pts[nr_t]; spe_context_ptr_t ctx[nr_t]; int value = 1; int cnt; spe_callback_handler_register (indirect_handler, 0x11, SPE_CALLBACK_NEW); spe_callback_handler_register (crash_handler, 0x12, SPE_CALLBACK_NEW); for (cnt = 0; cnt < nr_t; cnt++) { ctx[cnt] = spe_context_create (0, NULL); thread_id[cnt] = pthread_create (&pts[cnt], NULL, &spe_thread, &ctx[cnt]); } for (cnt = 0; cnt < nr_t; cnt++) pthread_join (pts[cnt], NULL); for (cnt = 0; cnt < nr_t; cnt++) spe_context_destroy (ctx[cnt]); return 0; }
int main (void) { int thread_id[nr_t]; pthread_t pts[nr_t]; spe_context_ptr_t ctx[nr_t]; int value = 1; int cnt; static int test_var; test_var = 5; for (cnt = 0; cnt < nr_t; cnt++) /* Marker PPUEA */ { ctx[cnt] = spe_context_create (0, NULL); thread_id[cnt] = pthread_create (&pts[cnt], NULL, &spe_thread, &ctx[cnt]); } for (cnt = 0; cnt < nr_t; cnt++) pthread_join (pts[cnt], NULL); for (cnt = 0; cnt < nr_t; cnt++) spe_context_destroy (ctx[cnt]); return 0; }
///tell the task scheduler we are done with the SPU tasks void SpuLibspe2Support::stopSPU() { // wait for all threads to finish int i; for ( i = 0; i < this->numThreads; i++ ) { unsigned int event = Spu_Mailbox_Event_Shutdown; spe_context_ptr_t context = data[i].context; spe_in_mbox_write(context, &event, 1, SPE_MBOX_ALL_BLOCKING); pthread_join (data[i].pthread, NULL); } // close SPE program spe_image_close(program); // destroy SPE contexts for ( i = 0; i < this->numThreads; i++ ) { if(data[i].context != NULL) { spe_context_destroy (data[i].context); } } m_activeSpuStatus.clear(); }
int main(int argc, char **argv) { int i; int ret; spe_context_ptr_t spe; spe_program_handle_t *prog; unsigned int entry; spe_stop_info_t stop_info; prog = spe_image_open("vec_abs_spe.elf"); if (!prog) { perror("spe_image_open"); exit(1); } spe = spe_context_create(0, NULL); if (!spe) { perror("spe_context_create"); exit(1); } ret = spe_program_load(spe, prog); if (ret) { perror("spe_program_load"); exit(1); } abs_params.ea_in = (unsigned long) in; abs_params.ea_out = (unsigned long) out; abs_params.size = SIZE; entry = SPE_DEFAULT_ENTRY; ret = spe_context_run(spe, &entry, 0, &abs_params, NULL, &stop_info); if (ret < 0) { perror("spe_context_run"); exit(1); } ret = spe_context_destroy(spe); if (ret) { perror("spe_context_destroy"); exit(1); } ret = spe_image_close(prog); if (ret) { perror("spe_image_close"); exit(1); } for (i = 0; i < SIZE; i++) { printf("out[%02d]=%0.0f\n", i, out[i]); } return 0; }
int main(int argc, char **argv) { int i; int ret; spe_context_ptr_t spe[NUM_SPE]; spe_program_handle_t *prog; pthread_t thread[NUM_SPE]; prog = spe_image_open("increment_spe.elf"); if (!prog) { perror("spe_image_open"); exit(1); } for (i = 0; i < NUM_SPE; i++) { spe[i] = spe_context_create(0, NULL); if (!spe) { perror("spe_context_create"); exit(1); } ret = spe_program_load(spe[i], prog); if (ret) { perror("spe_program_load"); exit(1); } } for (i = 0; i < NUM_SPE; i++) { ret = pthread_create(&thread[i], NULL, run_increment_spe, &spe[i]); if (ret) { perror("pthread_create"); exit(1); } } for (i = 0; i < NUM_SPE; i++) { pthread_join(thread[i], NULL); ret = spe_context_destroy(spe[i]); if (ret < 0) { perror("spe_context_destroy"); exit(1); } } ret = spe_image_close(prog); if (ret) { perror("spe_image_close"); exit(1); } printf("result=%d\n", counter[0]); return 0; }
int main() { int i, spu_threads; spe_context_ptr_t ctxs[MAX_SPU_THREADS]; pthread_t threads[MAX_SPU_THREADS]; /* * Determine the number of SPE threads to create. */ spu_threads = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, -1); if (spu_threads > MAX_SPU_THREADS) spu_threads = MAX_SPU_THREADS; /* * Create several SPE-threads to execute 'simple_spu'. */ for(i=0; i<spu_threads; i++) { /* Create context */ if ((ctxs[i] = spe_context_create (0, NULL)) == NULL) { perror ("Failed creating context"); exit (1); } /* Load program into context */ if (spe_program_load (ctxs[i], &simple_spu)) { perror ("Failed loading program"); exit (1); } /* Create thread for each SPE context */ if (pthread_create (&threads[i], NULL, &ppu_pthread_function, &ctxs[i])) { perror ("Failed creating thread"); exit (1); } } /* Wait for SPU-thread to complete execution. */ for (i=0; i<spu_threads; i++) { if (pthread_join (threads[i], NULL)) { perror("Failed pthread_join"); exit (1); } /* Destroy context */ if (spe_context_destroy (ctxs[i]) != 0) { perror("Failed destroying context"); exit (1); } } printf("\nThe program has successfully executed.\n"); return 0; }
void sws_yuvscaler_destroy(yuvscaler_t* arg) { unsigned int message=STOP; struct yuvscaler_s * arg_ptr; arg_ptr=(struct yuvscaler_s *) arg; spe_in_mbox_write(arg_ptr->ctx,&message,1,SPE_MBOX_ALL_BLOCKING); pthread_join(arg_ptr->pts,NULL); spe_context_destroy(arg_ptr->ctx); }
int main(int argc, char **argv) { int ret; spe_context_ptr_t spe; spe_program_handle_t *prog; unsigned int entry; spe_stop_info_t stop_info; unsigned long param; prog = spe_image_open("print_param_spe.elf"); if (!prog) { perror("spe_image_open"); exit(1); } spe = spe_context_create(0, NULL); if (!spe) { perror("spe_context_create"); exit(1); } ret = spe_program_load(spe, prog); if (ret) { perror("spe_program_load"); exit(1); } param = 12345678; printf("[PPE] param=%ld\n", param); entry = SPE_DEFAULT_ENTRY; ret = spe_context_run(spe, &entry, 0, (void *) param, NULL, &stop_info); if (ret < 0) { perror("spe_context_run"); exit(1); } ret = spe_context_destroy(spe); if (ret) { perror("spe_context_destroy"); exit(1); } ret = spe_image_close(prog); if (ret) { perror("spe_image_close"); exit(1); } return 0; }
void *pthread_run_spe(void *arg){ spe_context_ptr_t spe_ctx; context *data = (context *)arg; void *argp; unsigned int entry; spe_ctx = spe_context_create(0, NULL); spe_program_load (spe_ctx, &spu_pi); entry=SPE_DEFAULT_ENTRY; argp=data; spe_context_run(spe_ctx, &entry,0,argp,NULL,NULL); spe_context_destroy(spe_ctx); pthread_exit(NULL); }
spe_context_ptr_t ps3_assign_context_to_program(spe_program_handle_t *program) { static spe_context_ptr_t cached_context; static spe_program_handle_t *cached_program; static int cached_pid; int current_pid = getpid(); int thread_index = 99; /* Todo: get true cruncher index */ int retval; if (cached_context) { if (cached_pid != current_pid) { Log("!!! FATAL !!! Cached SPE context forked from another pid (%d)\n", cached_pid); abort(); } if (cached_program != program) { // Log("Replacing SPE context because SPE program changed\n"); if (spe_context_destroy(cached_context)) Log("Alert SPE%d! spe_context_destroy() failed, errno=%d\n", thread_index, errno); cached_context = NULL; } } if (cached_context == NULL) { cached_context = spe_context_create(0, NULL); if (cached_context == NULL) { Log("Alert SPE#%d! spe_context_create() failed\n", thread_index); abort(); } retval = spe_program_load(cached_context, program); if (retval != 0) { Log("Alert SPE#%d: spe_program_load() returned %d\n", thread_index, retval); abort(); } cached_program = program; cached_pid = current_pid; } return cached_context; }
int SPE_Shutdown(_THIS, spu_data_t * spe_data) { if (spe_data->keepalive && spe_data->booted) { SPE_SendMsg(this, spe_data, SPU_EXIT); SPE_Stop(this, spe_data); } deprintf(2, "[PS3->SPU] Destroy SPE context: %s\n", spe_data->program_name); if (spe_context_destroy(spe_data->ctx)) { deprintf(2, "[PS3->SPU] Failed destroying context: %s\n", spe_data->program_name); SDL_SetError("[PS3->SPU] Failed destroying context"); return -1; } deprintf(2, "[PS3->SPU] SPE shutdown successful: %s\n", spe_data->program_name); return 0; }
int CompleteSPEThreads( PpuPthreadData_t *spedata ) { // Wait for the SPE threads to end if ( pthread_join ( spedata->pthread, NULL ) ) { perror ("Failed joining thread"); return -1; } // Destroy context if ( spe_context_destroy ( spedata->spe_ctx ) != 0 ) { perror( "Failed destroying context" ); return -1; } return 1; }
int main(int argc, char **argv) { int ret; spe_context_ptr_t ctx; unsigned int entry_point; spe_stop_info_t stop_info; /* Display the EA of the array */ printf("PPU array location: %#llx\n", (unsigned long long)prime); /* Create the SPE Context */ ctx = spe_context_create(0, NULL); if (!ctx) { perror("spe_context_create"); exit(1); } /* Load the program into the context */ ret = spe_program_load(ctx, &spu_prime_handle); if (ret) { perror("spe_program_load"); exit(1); } /* Run the program */ entry_point = SPE_DEFAULT_ENTRY; ret = spe_context_run(ctx, &entry_point, 0, NULL, NULL, &stop_info); if (ret < 0) { perror("spe_context_run"); exit(1); } /* Deallocate the context */ ret = spe_context_destroy(ctx); if (ret) { perror("spe_context_destroy"); exit(1); } return 0; }
void *ppu_pthread_function(void *thread_arg) { spe_context_ptr_t ctx; pointers_t *arg = (pointers_t *) thread_arg; /* Create SPE context */ if ((ctx = spe_context_create (0, NULL)) == NULL) { perror ("Failed creating context"); exit (1); } /* Load SPE program into context */ if (spe_program_load (ctx, &ex1_spu)) { perror ("Failed loading program"); exit (1); } pthread_t mbox_thread; if (pthread_create (&mbox_thread, NULL, &mailbox_pthread_function, &ctx)) { perror ("Failed creating thread"); exit (1); } /* Run SPE context */ unsigned int entry = SPE_DEFAULT_ENTRY; if (spe_context_run(ctx, &entry, 0, arg, (void*)sizeof(pointers_t), NULL) < 0) { perror ("Failed running context"); exit (1); } /* Destroy context */ if (spe_context_destroy (ctx) != 0) { perror("Failed destroying context"); exit (1); } return NULL; }
//PPU Code int main(void){ int retval; unsigned int entry_point = SPE_DEFAULT_ENTRY; // Required for continuing //execution, SPE_DEFAULT_ENTRY is the standard starting offset. spe_context_ptr_t my_context; spe_stop_info_t stopinfo; int stop_counter = 0; spe_callback_handler_register(null_callback, 0x11, SPE_CALLBACK_NEW); while(true) { // Create the SPE Context my_context = spe_context_create(SPE_EVENTS_ENABLE|SPE_MAP_PS, NULL); // Load the embedded code into this context spe_program_load(my_context, &spe_program_zero); entry_point = SPE_DEFAULT_ENTRY; do { printf("before running the spu code\n"); retval = spe_context_run(my_context, &entry_point, 0, NULL, NULL, &stopinfo); /* consume the stop info so we don't get the spu_stop in loop bug */ spe_stop_info_read(my_context, &stopinfo); stop_counter++; printf("after running the spu code (%d)\n", stop_counter); printf("retval = %d\n", retval); if(retval == 0x10) /* spu_stop(0x10) is sent from the spe when the loop is done */ { break; } } while (retval > 0); // Run until exit or error spe_context_destroy(my_context); } printf("finished with computation\n"); }
void *spe_code_launch_6(void *data) { // printf("inside of thread function\n"); int retval; unsigned int entry_point = SPE_DEFAULT_ENTRY; /* Required for continuing execution, SPE_DEFAULT_ENTRY is the standard starting offset. */ spe_context_ptr_t my_context; // printf("before creating context\n"); /* Create the SPE Context */ my_context = spe_context_create(SPE_EVENTS_ENABLE|SPE_MAP_PS, NULL); // printf("context created\n"); /* Load the embedded code into this context */ spe_program_load(my_context, &spe_code); // printf("program loaded\n"); /* Run the SPE program until completion */ do { retval = spe_context_run(my_context, &entry_point, 0, spe6_Data, 6, NULL); } while (retval > 0); /* Run until exit or error */ spe_context_destroy(my_context); pthread_exit(NULL); }
int main(int argc, char **argv) { int i; int ret; spe_context_ptr_t spe; spe_program_handle_t *prog; unsigned int entry; spe_stop_info_t stop_info; if (argc == 1) { fprintf(stderr, "usage: %s <spu_image>\n", argv[0]); return -1; } prog = spe_image_open(argv[1]); if (!prog) { perror("spe_image_open"); exit(1); } spe = spe_context_create(0, NULL); if (!spe) { perror("spe_context_create"); exit(1); } ret = spe_program_load(spe, prog); if (ret) { perror("spe_program_load"); exit(1); } abs_params.ea_in = (unsigned long) in; abs_params.ea_out = (unsigned long) out; abs_params.size = SIZE; entry = SPE_DEFAULT_ENTRY; ret = spe_context_run(spe, &entry, 0, &abs_params, NULL, &stop_info); if (ret < 0) { perror("spe_context_run"); exit(1); } ret = spe_context_destroy(spe); if (ret) { perror("spe_context_destroy"); exit(1); } ret = spe_image_close(prog); if (ret) { perror("spe_image_close"); exit(1); } for (i = 0; i < SIZE; i++) { printf("%5.0f ", i, out[i]); if ((i+1) % 4 == 0) printf("\n"); } return 0; }
/* Spu control function */ void * spuCtrlFunc(void *arg) { int i; SpuThreadData * spu_data; struct ctrl_thread_args * ctrlArgs = *((struct ctrl_thread_args **) ctrlArgs); if ((spu_data = (SpuThreadData *) malloc(sizeof(SpuThreadData))) == NULL) { perror("Failed to allocate SPU data\n"); } spu_data->boot_record = ctrlArgs->boot_record; spu_data->main_boot_record = ctrlArgs->main_boot_record; // initialize threads startSpuThreads(ctrlArgs->no_spus, spu_data); initJavaThreads(spu_data, MAX_JAVA_SPU_THREADS); free(ctrlArgs); // register interest in events registerEventHandlers(spu_data); // wait for the threads to signal that they have started waitForSpus(spu_data); // transfer runtime code to spus loadRuntimeOnSpus(spu_data); // wait for SPU to transition to Java runtime waitForRuntime(spu_data); global_spu_data = spu_data; // start support threads startSpuSupportThreads(spu_data); // signal completion of SPU boot process spu_data->boot_record->noSubArchProcs = spu_data->no_spu_threads; spu_data->boot_record->subArchBootComplete = 1; // now sit waiting for the kill signal pthread_mutex_lock(&exit_mutex); pthread_cond_wait(&exit_signal, &exit_mutex); pthread_mutex_unlock(&exit_mutex); /* shutdown other threads */ for (i=0; i<spu_data->no_spu_threads; i++) { if (pthread_cancel (spu_data->spus[i].boot_thread)) { perror("Failed to shutdown Cell SPU thread"); exit (1); } if (pthread_cancel (spu_data->spus[i].support_thread)) { perror("Failed to shutdown Cell SPU support thread"); exit (1); } // destroy resources spe_event_handler_destroy(spu_data->spus[i].evnt_handler); spe_context_destroy(spu_data->spus[i].ctx); } spe_gang_context_destroy(spu_data->gang); }
void SPEContext::Destroy() { if(ptr) if(( spe_context_destroy(ptr) ) != 0) THROW("Error while destroying context: ", strerror(errno)); }
int main(int argc, char **argv) { int i, n, retval, nspus; char temp[256]; struct dirent **spu_files; FILE *fh; unsigned int one = 1; nspus = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, 0); printf(" [PPU]: # usable synergistic processing units = %d\n", nspus); for (i = 0; i < nspus; ++i) { if (NULL == (data[i].id = spe_context_create(0, NULL))) { perror("spe_context_create"); exit(128); } retval = spe_program_load(data[i].id, &spu_program); if (unlikely(retval)) { perror("spe_program_load"); exit(128); } data[i].argp = (void *)(ull )i; retval = pthread_create(&data[i].pthread, NULL, ppu_pthread_function, &data[i]); if (unlikely(retval)) { perror("pthread_create"); exit(128); } } n = scandir("/spu", &spu_files, NULL, alphasort); while (n--) { if (!strncmp(spu_files[n]->d_name, "spethread", 9)) { snprintf(temp, sizeof(temp), "/spu/%s/phys-id", spu_files[n]->d_name); if (NULL == (fh = fopen(temp, "r"))) { perror("fopen"); exit(128); } fgets(temp, 128, fh); fclose(fh); printf(" [PPU]: context = %s: physical id = %s", spu_files[n]->d_name, temp); } } free(spu_files); for (i = 0; i < nspus; ++i) { retval = spe_in_mbox_write(data[i].id, &one, 1, SPE_MBOX_ALL_BLOCKING); if (unlikely(1 != retval)) { perror("spe_in_mbox_write"); exit(128); } retval = pthread_join(data[i].pthread, NULL); if (unlikely(retval)) { perror("pthread_join"); exit(128); } retval = spe_context_destroy(data[i].id); if (unlikely(retval)) { perror("spe_context_destroy"); exit(128); } } return 0; }
int main(int argc, char **argv) { int i, retval, spus; /* Determine number of available SPUs */ spus = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, 0); if (argc != 2) { printf("Usage: 'ppu_threads <1-%u>'\n", spus); exit(1); } else if ((atoi(argv[1]) < 1) || (atoi(argv[1]) > spus)) { printf("Usage: 'ppu_threads <1-%u>'\n", spus); exit(1); } else { spus = atoi(argv[1]); } /* Create a context and thread for each SPU */ for (i=0; i<spus; i++) { /* Create context */ if ((data[i].speid = spe_context_create(0, NULL)) == NULL) { perror("spe_context_create"); exit(1); } /* Load program into the context */ if ((retval = spe_program_load(data[i].speid, &spu_threads)) != 0) { perror("spe_program_load"); exit (1); } /* Initialize control block and thread data */ control_block = i; data[i].argp = (void*)control_block; /* Create thread */ if ((retval = pthread_create( &data[i].pthread, NULL, &ppu_pthread_function, &data[i])) != 0) { perror("pthread_create"); exit (1); } } /* Wait for the threads to finish processing */ for (i = 0; i < spus; i++) { if ((retval = pthread_join(data[i].pthread, NULL)) != 0) { perror("pthread_join"); exit (1); } if ((retval = spe_context_destroy (data[i].speid)) != 0) { perror("spe_context_destroy"); exit (1); } } return 0; }
int main(int argc, char** argv) { double begin; double end; int errnum; size_t nthread = P; size_t i; size_t nvertex; unsigned int x; // sent to each SPU int code; // status; unsigned int reply; // from SPU arg_t data[nthread]; param_t param[nthread] A16; argc = argc; // to silence gcc... progname = argv[0]; nvertex = atoi(argv[2]); printf("nthread = %zu\n", nthread); printf("nvertex = %zu\n", nvertex); printf("ctx = %zu\n", sizeof(param_t)); printf("arg = %zu\n", sizeof(arg_t)); begin = sec(); for (i = 0; i < nthread; ++i) { param[i].proc = i; param[i].nvertex = nvertex; if ((data[i].ctx = spe_context_create (0, NULL)) == NULL) { perror ("Failed creating context"); exit(1); } if (spe_program_load (data[i].ctx, &dataflow)) { perror ("Failed loading program"); exit(1); } data[i].arg = ¶m[i]; printf("i=%d param=%p\n", i, data[i].arg); if (pthread_create (&data[i].pthread, NULL, work, &data[i])) { perror ("Failed creating thread"); exit(1); } } // send some data to each SPU and wait for a reply. x = 42; for (i = 0; i < nthread; ++i) { reply = 0; code = spe_out_mbox_read(data[i].ctx, &reply, 1); printf("spu-%d reply-0: %u\tcode: %d\n",i, reply, code); code = spe_in_mbox_write(data[i].ctx, &x, 1, 1); code = spe_out_mbox_read(data[i].ctx, &reply, 1); printf("spu-%d reply-1: %u\tcode: %d\n",i, reply, code); code = spe_out_mbox_read(data[i].ctx, &reply, 1); printf("spu-%d reply-2: %u\tcode: %d\n",i, reply, code); } end = sec(); printf("%1.3lf s\n", end-begin); for (i = 0; i < nthread; ++i) { printf("joining with PPU pthread %zu...\n", i); errnum = pthread_join(data[i].pthread, NULL); if (errnum != 0) syserror(errnum, "pthread_join failed"); if (spe_context_destroy (data[i].ctx) != 0) { perror("Failed destroying context"); exit(1); } } return 0; }
float calc_integral(float start, float end, float delta) { int i; int ret; float sum = 0.0f; spe_program_handle_t *prog; spe_context_ptr_t spe[NUM_SPE]; pthread_t thread[NUM_SPE]; thread_arg_t arg[NUM_SPE]; prog = spe_image_open("integral_spe.elf"); if (!prog) { perror("spe_image_open"); exit(1); } for (i = 0; i < NUM_SPE; i++) { spe[i] = spe_context_create(0, NULL); if (!spe) { perror("spe_context_create"); exit(1); } ret = spe_program_load(spe[i], prog); if (ret) { perror("spe_program_load"); exit(1); } } for (i = 0; i < NUM_SPE; i++) { integral_params[i].start = start + (end-start)/NUM_SPE * i; integral_params[i].end = start + (end-start)/NUM_SPE * (i+1); integral_params[i].delta = delta; integral_params[i].sum = 0.0f; arg[i].spe = spe[i]; arg[i].integral_params = &integral_params[i]; ret = pthread_create(&thread[i], NULL, run_integral_spe, &arg[i]); if (ret) { perror("pthread_create"); exit(1); } } for (i = 0; i < NUM_SPE; i++) { pthread_join(thread[i], NULL); ret = spe_context_destroy(spe[i]); if (ret) { perror("spe_context_destroy"); exit(1); } } ret = spe_image_close(prog); if (ret) { perror("spe_image_close"); exit(1); } for (i = 0; i < NUM_SPE; i++) { printf("[PPE] sum = %f\n", integral_params[i].sum); sum += integral_params[i].sum; } return sum; }
int main( int argc, char *argv[] ) { int i, j, dummy; int tmi, tmj; pthread_t threads [ NUM_THREADS ]; spe_context_ptr_t spe_contexts[ NUM_THREADS ]; thread_args_t thread_args [ NUM_THREADS ]; int rows; dummy = argc; dummy = (int)argv; // initialize initial & final matrix for(i = 0; i < tsize; i++) { for(j = 0; j < tsize; j++) { tmi = tsize-i; tmj = tsize-j; Amatrix[i][j] = 3*tmi+tmj ; Bmatrix[i][j] = 3*tmi+tmj ; Cmatrix[i][j] = 0 ; Dmatrix[i][j] = 0 ; } } // perform multiply printf( "SPE: Multiply \n"); gettimeofday( &time0, &tzone ); // start jobs rows = ((tsize/32)+NUM_THREADS-1)/NUM_THREADS ; // determine amount of work each spe should do for (i = 0; i < NUM_THREADS; i++ ) { // set arguments args.Amat = (float (*)[tsize][tsize])Amatrix ; args.Bmat = (float (*)[tsize][tsize])Bmatrix ; args.Cmat = (float (*)[tsize][tsize])Cmatrix ; args.i_initial = i*rows ; spe_contexts[i] = spe_context_create( 0, NULL ); // (flags, gang) spe_program_load( spe_contexts[i], &multiply_spu ); thread_args[i].spe_context = spe_contexts[i]; thread_args[i].argp = &args ; thread_args[i].envp = NULL; pthread_create( &threads[i], NULL, &spe_thread, &thread_args[i] ); } // wait for tasks to complete for (i = 0; i < NUM_THREADS; i++) { pthread_join( threads[i], NULL ); } // wait for threads gettimeofday( &time1, &tzone ); // print time to complete sec = time1.tv_sec - time0.tv_sec ; usec = time1.tv_usec - time0.tv_usec ; if ( usec < 0 ) { sec--; usec+=1000000 ; } printf( "SPE: Multiply Done -- matrix[%d][%d]: time=%d.%06d\n", tsize, tsize, sec, usec); for (i = 0; i < NUM_THREADS; i++) { spe_context_destroy( spe_contexts[i] ); } // destroy threads // Check for correctness of final matrix { int error, i, j, k ; for(i = 0; i < tsize; i++) { for(j = 0; j < tsize; j++) { for(k = 0; k < tsize; k++) { Dmatrix[i][j] += Amatrix[i][k] * Bmatrix[k][j] ; } } } error = 0; for(i = 0; i < tsize; i++) { for(j = 0; j < tsize; j++) { if ( Cmatrix[i][j] != Dmatrix[i][j] ) error = 1 ; } } if (error) { printf("Error in Multiply.\n"); } else { printf("Multiply is correct.\n"); fflush(stdout); } } return 0; }