int main() { // Example 1 [-1,1] a = -1.0; b = 1.0; n = 1000; int curr_num_threads[3] = {2, 50, 100}; for (int i=0; i<3; i++) { approx = 0; thread_count = curr_num_threads[i]; printf("\nRun with %d threads\n", thread_count); timerStart(); run_threads(); printf("Took %ld ms\n", timerStop()); printf("a:%f\t b:%f\t n:%d\t actual:%f\t approximation:%f\n", a, b, n, NEG_1_TO_POS_1, approx); } // Example 2 [0,10] a = 0.0; b = 10.0; n = 1000; for (int i=0; i<3; i++) { approx = 0; thread_count = curr_num_threads[i]; printf("\nRun with %d threads\n", thread_count); timerStart(); run_threads(); printf("Took %ld ms\n", timerStop()); printf("a:%f\t b:%f\t n:%d\t actual:%f\t approximation:%f\n", a, b, n, ZERO_TO_POS_10, approx); } return 0; }
int main(int argc, char**argv) { // Scan options. char **args = &argv[1]; while (*args) { char *opt = NULL; if ((opt = shift_option(&args, "--test_num="))) g_run_multiplier = atoi(opt); } printf("This test will run %d times.\n", ((1 << LG2_CAPACITY) * g_run_multiplier)); // Make sure we have enough cpus. // if (tmc_cpus_get_dataplane_cpus(&cpus) != 0) if (tmc_cpus_get_my_affinity(&cpus) != 0) tmc_task_die("tmc_cpus_get_my_affinity() failed."); if (tmc_cpus_count(&cpus) < NUM_THREADS) tmc_task_die("Insufficient cpus available."); // Call the main thread function on each cpu, then wait for them all // to exit. run_threads(NUM_THREADS, thread_func); finish_threads(NUM_THREADS); return 0; }
int main(void) { char sfn[24]; FILE *sfp; int fd, i; strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn)); if ((fd = mkstemp(sfn)) == -1 || (sfp = fdopen(fd, "w+")) == NULL) { int saved_errno = errno; if (fd != -1) { unlink(sfn); close(fd); } errc(1, saved_errno, "could not open temporary file"); } for (i = 0; i < 4096 * THREAD_COUNT; i++) if (fwrite(TEXT_N, sizeof(char), strlen(TEXT_N), sfp) == 0) err(1, "Could not populate test file"); run_threads(fgetln_thread, sfp); unlink(sfn); close(fd); exit(0); }
int main(void) { char sfn[24]; char buf[sizeof(TEXT)]; FILE *sfp; int fd; strlcpy(sfn, "/tmp/barnacles.XXXXXXXX", sizeof(sfn)); if ((fd = mkstemp(sfn)) == -1 || (sfp = fdopen(fd, "w+")) == NULL) { int saved_errno = errno; if (fd != -1) { unlink(sfn); close(fd); } errc(1, saved_errno, "could not open temporary file"); } run_threads(fwrite_thread, sfp); while (fread(buf, sizeof(char), strlen(TEXT), sfp)) /* verify */ if (strncmp(buf, TEXT, sizeof(TEXT))) err(1, "Thread writes were not atomic!!!"); unlink(sfn); close(fd); exit(0); }
int main() { // Example 1 [-1,1] a = -1.0; b = 1.0; n = 1000000000; int current_number_of_threads[3] = {2, 50, 100}; pthread_mutex_init(&approx_lock,NULL); int i = 0; for (i = 0; i<3; i++) { approx = 0; thread_amount = current_number_of_threadsi[i]; printf("\nRan with %d threads\n", thread_amount); timerStart(); run_threads(); printf("Took %ld ms\n", timerStop()); printf("a:%f\t b:%f\t n:%d\t actual:%f\t approximation:%f\n", a, b, n, NEG_1_TO_POS_1, approx); } // Example 2 [0,10] a = 0.0; b = 10.0; n = 1000000000; int i = 0; for (i = 0; i<3; i++) { approx = 0; thread_amount = current_number_of_threadsi[i]; printf("\nRan with %d threads\n", thread_amount); timerStart(); run_threads(); printf("Took %ld ms\n", timerStop()); printf("a:%f\t b:%f\t n:%d\t actual:%f\t approximation:%f\n", a, b, n, NEG_1_TO_POS_1, approx); } pthread_mutex_destroy(&approx_lock); return 0; }
int main() { int pids[NTHREADS] = {0}; /* a Matrix multiplying validity function may be needed depending on how this is being tested A and B are both predetermined and equivalent square matrices */ run_threads(pids); return 0; }
int main(int argc, char * argv[]) { std::vector<int> numbers; std::string data; std::getline(std::cin, data); std::stringstream string_stream(data); int x; while(true){ string_stream >> x; if (!string_stream) break; numbers.push_back(x); } int n = numbers.size(); std::cout << run_threads(numbers.data(), n) << std::endl; return 0; }
int main(int argc, char **argv) { // Defaults // pool size = 100 size_t qlen = QLEN_DEFAULT; // 100 producers, 100 consumers size_t nproducers = NPROC_DEFAULT, nconsumers = NCONS_DEFAULT; // pass 1000000 messages size_t nmesgs = NMESG_DEFAULT; // use spinlock instead of mutex int use_spinlock = 0, use_mutexes = 0, use_yield = 0; // Read args int c; while ((c = getopt(argc, argv, "p:c:n:q:smy")) >= 0) if (c == 'p') nproducers = (size_t)atoi(optarg); else if (c == 'c') nconsumers = (size_t)atoi(optarg); else if (c == 'n') nmesgs = (size_t)atoi(optarg); else if (c == 'q') qlen = (size_t)atoi(optarg); else if (c == 's') use_spinlock = 1; else if (c == 'm') use_mutexes = 1; else if (c == 'y') use_yield = 1; else print_usage(); if(optind < argc) print_usage(); if(use_spinlock + use_mutexes + use_yield > 1) print_usage(); if(use_spinlock + use_mutexes + use_yield == 0) use_spinlock = 1; // Create pool of ints of length qlen MsgPool q; if(use_spinlock) msgpool_alloc_spinlock(&q, qlen, sizeof(size_t)); else if(use_mutexes) msgpool_alloc_mutex(&q, qlen, sizeof(size_t)); else msgpool_alloc_yield(&q, qlen, sizeof(size_t)); msgpool_iterate(&q, set_zero, NULL); bool pass = run_threads(&q, nmesgs, nproducers, nconsumers); msgpool_dealloc(&q); printf(pass ? "Done.\n" : "Fail.\n"); return pass ? EXIT_SUCCESS : EXIT_FAILURE; }
DataSet *run_viewshed_terrain(DataSet *terrain, int nthread, unsigned int (*vcount) (DataSet *terrain, GridPoint p)) { static Rtimer rt; DataSet *vmap; Vector *thread_bands; ViewshedBand band; int i; float fNODATA; rt_start(rt); assert(nthread > 0); fNODATA = getNODATA(terrain); vmap = dInit(terrain->grid.nrow, terrain->grid.ncol, UINT); assert(vmap); vmap->grid.uiNODATA = 0; thread_bands = vinit2(sizeof(ViewshedBand), nthread); for (i = 0; i < nthread; i++) { band.nthread = nthread; band.index = i; band.terrain = terrain; band.vmap = vmap; band.fNODATA = fNODATA; band.vcount = vcount; vappend(thread_bands, &band); } run_threads(nthread, viewshed_terrain_sub, thread_bands); rt_stop(rt); static char buf[256]; rt_sprint(buf, rt); printf("run_viewshed_terrain('%s'):\t%s\n", terrain->path, buf); return vmap; }
static void *run_method(hashpipe_thread_args_t * args) { int rv = 0; easy_in_output_databuf_t *db_out = (easy_in_output_databuf_t *)args->obuf; hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; int idx_data = 0; char data = 'a'; while (run_threads()) { while ((rv=hashpipe_databuf_wait_free((hashpipe_databuf_t *)db_out, idx_data)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked_in"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf"); pthread_exit(NULL); break; } } #ifdef DEBUG fprintf(stdout,"easy_in_thread:\n"); fprintf(stdout,"\tcount = %d\n",db_out->count); fprintf(stdout,"\tdata[%d] = %c\n",idx_data,'a' + (char)(db_out->count % 26)); #endif db_out->data[idx_data] = 'a' + (char)(db_out->count % 26); db_out->count++; hashpipe_databuf_set_filled((hashpipe_databuf_t *)db_out, idx_data); idx_data = (idx_data + 1) % db_out->header.n_block; pthread_testcancel(); } // Thread success! return NULL; }
int main(int argn, char **argv) { int dram_refs; int nvm_refs; int interleaved_dram; int interleaved_nvm; int n_threads; if (argn != 6) { printf("INVALID ARGUMENTS:\n"); printf("\t%s [# threads] [# total dram accesses] [# total nvm accesses] [# dram accesses in sequence] [# nvm accesses in sequence]\n", argv[0]); return -1; } n_threads = atoi(argv[1]); dram_refs = atoi(argv[2]); nvm_refs = atoi(argv[3]); interleaved_dram = atoi(argv[4]); interleaved_nvm = atoi(argv[5]); run_threads(n_threads, dram_refs, nvm_refs, interleaved_dram, interleaved_nvm); return 0; }
/* * Method that runs the server's main loop. It reads a message or waits for timeout, checks sent messages, and puts * received messages into buffer * * * server_socket: socket to be used for receiving and sending messages * */ void run_server(int server_socket) { signal(SIGINT, exit_handler); init_server(server_socket); run_threads(); while (1) { struct message received; received = receive_message(server_socket); check_sent_messages(server_socket); if (received.type == -1) { } else if (received.type == -2) { printf("Can't parse message\n"); number_of_unparseable++; } else { pthread_mutex_lock(&mutex); add_message(&buffer, received, NULL, 0); pthread_mutex_unlock(&mutex); sem_post(&sem); } } }
int main(int argc, char *const argv[]) { int detach = 1; const char *rtgconf_file = DEFAULT_RTGCONF_FILE; const char *targets_file = DEFAULT_TARGETS_FILE; int use_db = 1; int use_rate_column = 1; int allow_db_zero = 0; unsigned max_db_queue = DEFAULT_QUEUE_LENGTH; unsigned num_dbthreads = DEFAULT_NUM_DBTHREADS; int c; char *last_component; struct rtgtargets *targets; struct rtgtargets *old_targets = NULL; if (argc < 2) { help(); exit(EXIT_FAILURE); } while ((c = getopt(argc, argv, "c:dt:vzDOOQ:W:")) != -1) { switch (c) { case 'c': rtgconf_file = optarg; break; case 'd': use_db = 0; break; case 't': targets_file = optarg; break; case 'v': verbosity++; break; case 'z': allow_db_zero = 1; break; case 'D': detach = 0; break; case 'O': use_rate_column = 0; break; case 'Q': max_db_queue = (unsigned) strtol(optarg, NULL, 10); break; case 'W': num_dbthreads = (unsigned) strtol(optarg, NULL, 10); break; case '?': default: help(); exit(EXIT_FAILURE); } } if (argc != optind) { help(); exit(EXIT_FAILURE); } if (max_db_queue < MIN_QUEUE_LENGTH) { fprintf(stderr, "Error: minimum queue length is %d.\n", MIN_QUEUE_LENGTH); help(); exit(EXIT_FAILURE); } if (num_dbthreads < 1) { fprintf(stderr, "Error: you need at least one database thread.\n"); help(); exit(EXIT_FAILURE); } /* Convert given path names to full paths. */ rtgconf_file = realpath(rtgconf_file, NULL); targets_file = realpath(targets_file, NULL); cllog(0, "clpoll v%s starting up", VERSION); if (detach) { /* Try to parse configuration and target files so we can give error messages before we detach. */ struct rtgconf *config_test; struct rtgtargets *targets_test; config_test = rtgconf_create(rtgconf_file); if (!config_test || !rtgconf_verify(config_test)) { cllog(0, "Missing or incorrect configuration file, so nothing to do."); exit(EXIT_FAILURE); } rtgconf_free(config_test); targets_test = rtgtargets_parse(targets_file, config_test); if (targets_test->ntargets == 0) { cllog(0, "No targets, so nothing to do."); exit(EXIT_FAILURE); } rtgtargets_free(targets_test); /* Move to backgorund. */ daemonize(); } last_component = strrchr(argv[0], '/'); if (last_component) last_component++; else last_component = argv[0]; openlog(last_component, LOG_PID, LOG_USER); signal(SIGHUP, sighup_handler); signal(SIGTERM, sigterm_handler); clsnmp_global_init(); while (!full_stop_requested) { /* Read rtg.conf */ struct rtgconf *config = rtgconf_create(rtgconf_file); if (!config || !rtgconf_verify(config)) { cllog(0, "Missing or incorrect configuration file, so nothing to do."); exit(EXIT_FAILURE); } /* "Patch" rtgconf with command line values */ config->use_db = use_db; config->use_rate_column = use_rate_column; config->allow_db_zero = allow_db_zero; config->max_db_queue = max_db_queue; config->num_dbthreads = num_dbthreads; /* Read targets.cfg */ targets = rtgtargets_parse(targets_file, config); if (targets->ntargets == 0) { cllog(0, "No targets, so nothing to do."); exit(EXIT_FAILURE); } if (old_targets != NULL) { rtgtargets_copy_cache(targets, old_targets); rtgtargets_free(old_targets); old_targets = NULL; } cllog(1, "Polling every %d seconds.", config->interval); run_threads(targets, config); rtgconf_free(config); old_targets = targets; } return 0; }
/* lock a byte range in a open file */ int main(int argc, char *argv[]) { int nprocs, i; char *tname = "ALL"; #define NREPEATS 10 struct { const char *name; void *(*fn)(int ); } tests[] = { {"noop", test_noop}, {"malloc", test_malloc}, {"setreuid", test_setreuid}, {"readwrite", test_readwrite}, {"stat", test_stat}, {"fstat", test_fstat}, {"dir", test_dir}, {"dirsingle", test_dirsingle}, {"create", test_create}, {"lock", test_lock}, {NULL, NULL} }; if (argc <= 1) { printf("thread_perf NPROCS\n"); exit(1); } nprocs = atoi(argv[1]); if (argc > 2) { tname = argv[2]; } id_data = calloc(nprocs, sizeof(*id_data)); if (!id_data) { exit(1); } #ifndef NO_THREADS printf("NOTE! for accurate process results please compile with -DNO_THREADS and don't link to -lpthread\n\n"); #endif for (i=0;i<nprocs;i++) { char s[30]; sprintf(s, "testd_%d", i); id_data[i].dname = strdup(s); sprintf(s, "%s/test.dat", id_data[i].dname); id_data[i].fname = strdup(s); rmdir(id_data[i].dname); if (mkdir(id_data[i].dname, 0777) != 0) { fprintf(stderr, "Failed to create %s\n", id_data[i].dname); exit(1); } unlink(id_data[i].fname); } for (i=0;tests[i].name;i++) { double t_threads[NREPEATS]; double t_processes[NREPEATS]; int j; if (strcasecmp(tname, "ALL") && strcasecmp(tests[i].name, tname)) { continue; } printf("Running test '%s' with %d tasks\n", tests[i].name, nprocs); for (j=0;j<NREPEATS;j++) { #ifndef NO_THREADS t_threads[j] = run_threads(nprocs, tests[i].fn); #endif t_processes[j] = run_processes(nprocs, tests[i].fn); } #ifndef NO_THREADS show_result("Threads ", t_threads, NREPEATS); #endif show_result("Processes", t_processes, NREPEATS); printf("\n"); fflush(stdout); } for (i=0;i<nprocs;i++) { if (rmdir(id_data[i].dname) != 0) { fprintf(stderr, "Failed to delete %s\n", id_data[i].dname); exit(1); } } for (i=0;i<nprocs;i++) { free(id_data[i].dname); free(id_data[i].fname); } free(id_data); return 0; }
static void *run(hashpipe_thread_args_t * args) { // Local aliases to shorten access to args fields // Our input buffer is a paper_input_databuf // Our output buffer is a paper_gpu_input_databuf paper_input_databuf_t *db_in = (paper_input_databuf_t *)args->ibuf; paper_gpu_input_databuf_t *db_out = (paper_gpu_input_databuf_t *)args->obuf; hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; #ifdef DEBUG_SEMS fprintf(stderr, "s/tid %lu/ FLUFf/\n", pthread_self()); #endif // Init status variables hashpipe_status_lock_safe(&st); hputi8(st.buf, "FLUFMCNT", 0); hashpipe_status_unlock_safe(&st); /* Loop */ int rv; int curblock_in=0; int curblock_out=0; float gbps, min_gbps; struct timespec start, finish; while (run_threads()) { // Note waiting status, // query integrating status // and, if armed, start count hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "waiting"); hashpipe_status_unlock_safe(&st); // Wait for new input block to be filled while ((rv=paper_input_databuf_wait_filled(db_in, curblock_in)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked_in"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for filled databuf"); pthread_exit(NULL); break; } } // Wait for new gpu_input block (our output block) to be free while ((rv=paper_gpu_input_databuf_wait_free(db_out, curblock_out)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked gpu input"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf"); pthread_exit(NULL); break; } } // Got a new data block, update status hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "fluffing"); hputi4(st.buf, "FLUFBKIN", curblock_in); hputu8(st.buf, "FLUFMCNT", db_in->block[curblock_in].header.mcnt); hashpipe_status_unlock_safe(&st); // Copy header and call fluff function clock_gettime(CLOCK_MONOTONIC, &start); memcpy(&db_out->block[curblock_out].header, &db_in->block[curblock_in].header, sizeof(paper_input_header_t)); paper_fluff(db_in->block[curblock_in].data, db_out->block[curblock_out].data); clock_gettime(CLOCK_MONOTONIC, &finish); // Note processing time hashpipe_status_lock_safe(&st); // Bits per fluff / ns per fluff = Gbps hgetr4(st.buf, "FLUFMING", &min_gbps); gbps = (float)(8*N_BYTES_PER_BLOCK)/ELAPSED_NS(start,finish); hputr4(st.buf, "FLUFGBPS", gbps); if(min_gbps == 0 || gbps < min_gbps) { hputr4(st.buf, "FLUFMING", gbps); } hashpipe_status_unlock_safe(&st); // Mark input block as free and advance paper_input_databuf_set_free(db_in, curblock_in); curblock_in = (curblock_in + 1) % db_in->header.n_block; // Mark output block as full and advance paper_gpu_input_databuf_set_filled(db_out, curblock_out); curblock_out = (curblock_out + 1) % db_out->header.n_block; /* Check for cancel */ pthread_testcancel(); } // Thread success! return NULL; }
int main(int argc, char *argv[]) { static struct option long_options[] = { { "block-size", required_argument, 0, 'b' }, { "hash-algo", required_argument, 0, 'h' }, { "hash-algorithm", required_argument, 0, 'h' }, { "max-iter", required_argument, 0, 'i' }, { "freeze", required_argument, 0, 'f' }, { "loop", no_argument, 0, 'l' }, { 0, 0, 0, 0 }, }; int i; int freeze_count = 0; gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread); if (!gcry_check_version(GCRYPT_VERSION)) { fprintf(stderr, "libgcrypt version mismatch\n"); return 1; } while (1) { int c; c = getopt_long(argc, argv, "b:h:i:f:l", long_options, NULL); if (c == -1) break; switch (c) { case 'b': if (sscanf(optarg, "%i", &block_size) != 1) { fprintf(stderr, "cannot parse block size: " "%s\n", optarg); return 1; } if ((block_size & 7) != 0) { fprintf(stderr, "error: block size must be " "a multiple of 8\n"); return 1; } break; case 'h': hash_algo = gcry_md_map_name(optarg); if (hash_algo == 0) { fprintf(stderr, "unknown hash algorithm " "name: %s\n", optarg); return 1; } break; case 'i': if (sscanf(optarg, "%i", &max_iterations) != 1) { fprintf(stderr, "cannot parse iteration " "count: %s\n", optarg); return 1; } break; case 'f': if (freeze_count == MAX_FREEZE) { fprintf(stderr, "too many --freeze options\n"); return 1; } freeze_fs[freeze_count++] = optarg; break; case 'l': loop = 1; break; case '?': return 1; default: abort(); } } if (optind + 4 != argc) { fprintf(stderr, "%s: [opts] <src> <srchashmap> <dst> " "<dsthashmap>\n", argv[0]); fprintf(stderr, " -b, --block-size=SIZE hash block size\n"); fprintf(stderr, " -f, --freeze=MOUNTPOINT freeze " "filesystem\n"); fprintf(stderr, " -h, --hash-algo=ALGO hash algorithm\n"); fprintf(stderr, " -i, --max-iter=ITER maximum number of " "iterations\n"); fprintf(stderr, " -l, --loop create consistent " "image copy\n"); return 1; } hash_size = gcry_md_get_algo_dlen(hash_algo); fd_src = open(argv[optind], O_RDONLY); if (fd_src < 0) { perror("opening src"); return 1; } sizeblocks = lseek(fd_src, 0, SEEK_END); if (sizeblocks < 0) { perror("lseek"); return 1; } sizeblocks = (sizeblocks + block_size - 1) / block_size; if (strcmp(argv[optind + 1], "-")) { int fd_srchashmap; if (loop) { fprintf(stderr, "consistent image copy requested, " "but source hashmap specified\n"); return 1; } fd_srchashmap = open(argv[optind + 1], O_RDONLY); if (fd_srchashmap < 0) { perror("opening srchashmap"); return 1; } srchashmap = malloc(sizeblocks * hash_size); if (srchashmap == NULL) { fprintf(stderr, "out of memory allocating hash map\n"); return 1; } if (read(fd_srchashmap, srchashmap, sizeblocks * hash_size) != sizeblocks * hash_size) { fprintf(stderr, "error reading hash map\n"); return 1; } close(fd_srchashmap); } else { srchashmap = NULL; } fd_dst = open(argv[optind + 2], O_CREAT | O_RDWR, 0666); if (fd_dst < 0) { perror("opening dst"); return 1; } fd_dsthashmap = open(argv[optind + 3], O_CREAT | O_RDWR, 0666); if (fd_dsthashmap < 0) { perror("opening dsthashmap"); return 1; } dsthashmap = malloc(sizeblocks * hash_size); if (dsthashmap == NULL) { fprintf(stderr, "out of memory allocating hash map\n"); return 1; } if (read(fd_dsthashmap, dsthashmap, sizeblocks * hash_size) != sizeblocks * hash_size) { fprintf(stderr, "error reading hash map\n"); return 1; } setup_sig_handlers(); if (freeze_count) { for (i = 0; i < MAX_FREEZE; i++) freeze_fd[i] = -1; atexit(thaw_fs); fprintf(stderr, "freezing filesystems\n"); for (i = 0; i < freeze_count; i++) { int fd; fd = open(freeze_fs[i], O_RDONLY); if (fd < 0) { fprintf(stderr, "error opening freeze mount " "point %s (%s)\n", freeze_fs[i], strerror(errno)); return 1; } if (ioctl(fd, FIFREEZE, 0) < 0) { fprintf(stderr, "error freezing fs %s (%s)\n", freeze_fs[i], strerror(errno)); return 1; } freeze_fd[i] = fd; } } if (loop) { for (i = 0; i < max_iterations; i++) { fd_off = 0; again = 0; fprintf(stderr, "scanning for differences... "); run_threads(copy_thread_no_hashmap); if (!signal_quit_flag) { fprintf(stderr, "done " " \n"); } if (!again) break; if (i == max_iterations - 1) { fprintf(stderr, "maximum iteration count " "reached, bailing out\n"); } else { fprintf(stderr, "repeating scanning due to " "differences\n"); } } } else { fd_off = 0; if (srchashmap == NULL) { fprintf(stderr, "scanning for differences... "); run_threads(copy_thread_no_hashmap); } else { off_t off; mismatch_idx = 0; mismatch_cnt = 0; for (off = 0; off < sizeblocks; off++) { if (memcmp(srchashmap + off * hash_size, dsthashmap + off * hash_size, hash_size)) { mismatch_cnt++; } } fprintf(stderr, "copying differences... "); run_threads(copy_thread_hashmap); } if (!signal_quit_flag) { fprintf(stderr, "done " " \n"); } } fprintf(stderr, "flushing buffers... "); close(fd_src); close(fd_dst); close(fd_dsthashmap); fprintf(stderr, "done\n"); return signal_quit_flag ? EXIT_FAILURE : EXIT_SUCCESS; }
static void *run(hashpipe_thread_args_t * args, int doCPU) { // Local aliases to shorten access to args fields paper_gpu_input_databuf_t *db_in = (paper_gpu_input_databuf_t *)args->ibuf; paper_output_databuf_t *db_out = (paper_output_databuf_t *)args->obuf; hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; #ifdef DEBUG_SEMS fprintf(stderr, "s/tid %lu/ GPU/\n", pthread_self()); #endif // Init integration control status variables int gpu_dev = 0; hashpipe_status_lock_safe(&st); hputs(st.buf, "INTSTAT", "off"); hputi8(st.buf, "INTSYNC", 0); hputi4(st.buf, "INTCOUNT", N_SUB_BLOCKS_PER_INPUT_BLOCK); hputi8(st.buf, "GPUDUMPS", 0); hgeti4(st.buf, "GPUDEV", &gpu_dev); // No change if not found hputi4(st.buf, "GPUDEV", gpu_dev); hashpipe_status_unlock_safe(&st); /* Loop */ int rv; char integ_status[17]; uint64_t start_mcount, last_mcount=0; uint64_t gpu_dumps=0; int int_count; // Number of blocks to integrate per dump int xgpu_error = 0; int curblock_in=0; int curblock_out=0; struct timespec start, stop; uint64_t elapsed_gpu_ns = 0; uint64_t gpu_block_count = 0; // Initialize context to point at first input and output memory blocks. // This seems redundant since we do this just before calling // xgpuCudaXengine, but we need to pass something in for array_h and // matrix_x to prevent xgpuInit from allocating memory. XGPUContext context; context.array_h = (ComplexInput *)db_in->block[0].data; context.array_len = (db_in->header.n_block * sizeof(paper_gpu_input_block_t) - sizeof(paper_input_header_t)) / sizeof(ComplexInput); context.matrix_h = (Complex *)db_out->block[0].data; context.matrix_len = (db_out->header.n_block * sizeof(paper_output_block_t) - sizeof(paper_output_header_t)) / sizeof(Complex); xgpu_error = xgpuInit(&context, gpu_dev); if (XGPU_OK != xgpu_error) { fprintf(stderr, "ERROR: xGPU initialization failed (error code %d)\n", xgpu_error); return THREAD_ERROR; } while (run_threads()) { // Note waiting status, // query integrating status // and, if armed, start count hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "waiting"); hgets(st.buf, "INTSTAT", 16, integ_status); hgeti8(st.buf, "INTSYNC", (long long*)&start_mcount); hashpipe_status_unlock_safe(&st); // Wait for new input block to be filled while ((rv=hashpipe_databuf_wait_filled((hashpipe_databuf_t *)db_in, curblock_in)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked_in"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for filled databuf"); pthread_exit(NULL); break; } } // Got a new data block, update status and determine how to handle it hashpipe_status_lock_safe(&st); hputi4(st.buf, "GPUBLKIN", curblock_in); hputu8(st.buf, "GPUMCNT", db_in->block[curblock_in].header.mcnt); hashpipe_status_unlock_safe(&st); // If integration status "off" if(!strcmp(integ_status, "off")) { // Mark input block as free and advance hashpipe_databuf_set_free((hashpipe_databuf_t *)db_in, curblock_in); curblock_in = (curblock_in + 1) % db_in->header.n_block; // Skip to next input buffer continue; } // If integration status is "start" if(!strcmp(integ_status, "start")) { // If buffer mcount < start_mcount (i.e. not there yet) if(db_in->block[curblock_in].header.mcnt < start_mcount) { // Drop input buffer // Mark input block as free and advance hashpipe_databuf_set_free((hashpipe_databuf_t *)db_in, curblock_in); curblock_in = (curblock_in + 1) % db_in->header.n_block; // Skip to next input buffer continue; // Else if mcount == start_mcount (time to start) } else if(db_in->block[curblock_in].header.mcnt == start_mcount) { // Set integration status to "on" // Read integration count (INTCOUNT) fprintf(stderr, "--- integration on ---\n"); strcpy(integ_status, "on"); hashpipe_status_lock_safe(&st); hputs(st.buf, "INTSTAT", integ_status); hgeti4(st.buf, "INTCOUNT", &int_count); hashpipe_status_unlock_safe(&st); // Compute last mcount last_mcount = start_mcount + (int_count-1) * N_SUB_BLOCKS_PER_INPUT_BLOCK; // Else (missed starting mcount) } else { // Handle missed start of integration // TODO! fprintf(stderr, "--- mcnt=%06lx > start_mcnt=%06lx ---\n", db_in->block[curblock_in].header.mcnt, start_mcount); } } // Integration status is "on" or "stop" // Note processing status hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "processing gpu"); hashpipe_status_unlock_safe(&st); // Setup for current chunk context.input_offset = curblock_in * sizeof(paper_gpu_input_block_t) / sizeof(ComplexInput); context.output_offset = curblock_out * sizeof(paper_output_block_t) / sizeof(Complex); // Call CUDA X engine function int doDump = 0; // Dump if this is the last block or we are doing both CPU and GPU // (GPU and CPU test mode always dumps every input block) if(db_in->block[curblock_in].header.mcnt >= last_mcount || doCPU) { doDump = 1; // Check whether we missed the end of integration. If we get a block // whose mcnt is greater than last_mcount, then for some reason (e.g. // networking problems) we didn't see a block whose mcnt was // last_mcount. This should "never" happen, but it has been seen to // occur when the 10 GbE links have many errors. if(db_in->block[curblock_in].header.mcnt > last_mcount) { // Can't do much error recovery, so just log it. fprintf(stderr, "--- mcnt=%06lx > last_mcnt=%06lx ---\n", db_in->block[curblock_in].header.mcnt, last_mcount); } // Wait for new output block to be free while ((rv=paper_output_databuf_wait_free(db_out, curblock_out)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked gpu out"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf"); pthread_exit(NULL); break; } } } clock_gettime(CLOCK_MONOTONIC, &start); xgpuCudaXengine(&context, doDump ? SYNCOP_DUMP : SYNCOP_SYNC_TRANSFER); clock_gettime(CLOCK_MONOTONIC, &stop); elapsed_gpu_ns += ELAPSED_NS(start, stop); gpu_block_count++; if(doDump) { clock_gettime(CLOCK_MONOTONIC, &start); xgpuClearDeviceIntegrationBuffer(&context); clock_gettime(CLOCK_MONOTONIC, &stop); elapsed_gpu_ns += ELAPSED_NS(start, stop); // TODO Maybe need to subtract all or half the integration time here // depending on recevier's expectations. db_out->block[curblock_out].header.mcnt = last_mcount; // If integration status if "stop" if(!strcmp(integ_status, "stop")) { // Set integration status to "off" strcpy(integ_status, "off"); hashpipe_status_lock_safe(&st); hputs(st.buf, "INTSTAT", integ_status); hashpipe_status_unlock_safe(&st); } else { // Advance last_mcount for end of next integration last_mcount += int_count * N_SUB_BLOCKS_PER_INPUT_BLOCK; } // Mark output block as full and advance paper_output_databuf_set_filled(db_out, curblock_out); curblock_out = (curblock_out + 1) % db_out->header.n_block; // TODO Need to handle or at least check for overflow! // Update GPU dump counter and GPU Gbps gpu_dumps++; hashpipe_status_lock_safe(&st); hputi8(st.buf, "GPUDUMPS", gpu_dumps); hputr4(st.buf, "GPUGBPS", (float)(8*N_FLUFFED_BYTES_PER_BLOCK*gpu_block_count)/elapsed_gpu_ns); hashpipe_status_unlock_safe(&st); // Start new average elapsed_gpu_ns = 0; gpu_block_count = 0; } if(doCPU) { /* Note waiting status */ hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "waiting"); hashpipe_status_unlock_safe(&st); // Wait for new output block to be free while ((rv=paper_output_databuf_wait_free(db_out, curblock_out)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked cpu out"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf"); pthread_exit(NULL); break; } } // Note "processing cpu" status, current input block hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "processing cpu"); hashpipe_status_unlock_safe(&st); /* * Call CPU X engine function */ xgpuOmpXengine((Complex *)db_out->block[curblock_out].data, context.array_h); // Mark output block as full and advance paper_output_databuf_set_filled(db_out, curblock_out); curblock_out = (curblock_out + 1) % db_out->header.n_block; // TODO Need to handle or at least check for overflow! } // Mark input block as free and advance hashpipe_databuf_set_free((hashpipe_databuf_t *)db_in, curblock_in); curblock_in = (curblock_in + 1) % db_in->header.n_block; /* Check for cancel */ pthread_testcancel(); } xgpuFree(&context); // Thread success! return NULL; }
static void *run(hashpipe_thread_args_t * args) { s6_input_databuf_t *db = (s6_input_databuf_t *)args->obuf; hashpipe_status_t *p_st = &(args->st); hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; //s6_input_block_t fake_data_block; /* Main loop */ int i, rv; uint64_t mcnt = 0; uint64_t num_coarse_chan = N_COARSE_CHAN; uint64_t *data; int block_idx = 0; int error_count = 0, max_error_count = 0; float error, max_error = 0.0; int gen_fake = 0; hashpipe_status_lock_safe(&st); //hashpipe_status_lock_safe(p_st); hputi4(st.buf, "NUMCCHAN", N_COARSE_CHAN); hputi4(st.buf, "NUMFCHAN", N_FINE_CHAN); hputi4(st.buf, "NUMBBEAM", N_BYTES_PER_BEAM); hputi4(st.buf, "NUMBBLOC", sizeof(s6_input_block_t)); hputi4(st.buf, "THRESHLD", POWER_THRESH); hgeti4(st.buf, "GENFAKE", &gen_fake); hashpipe_status_unlock_safe(&st); //hashpipe_status_unlock_safe(p_st); time_t t, prior_t; prior_t = time(&prior_t); while (run_threads()) { hashpipe_status_lock_safe(&st); //hashpipe_status_lock_safe(p_st); hputi4(st.buf, "NETBKOUT", block_idx); hputs(st.buf, status_key, "waiting"); hashpipe_status_unlock_safe(&st); //hashpipe_status_unlock_safe(p_st); t = time(&t); fprintf(stderr, "elapsed seconds for block %d : %ld\n", block_idx, t - prior_t); prior_t = t; // Wait for data struct timespec sleep_dur, rem_sleep_dur; sleep_dur.tv_sec = 1; sleep_dur.tv_nsec = 0; //fprintf(stderr, "fake net thread sleeping for %7.5f seconds\n", // sleep_dur.tv_sec + (double)sleep_dur.tv_nsec/1000000000.0); nanosleep(&sleep_dur, &rem_sleep_dur); /* Wait for new block to be free, then clear it * if necessary and fill its header with new values. */ while ((rv=s6_input_databuf_wait_free(db, block_idx)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "blocked"); hashpipe_status_unlock_safe(&st); continue; } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf"); pthread_exit(NULL); break; } } hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "receiving"); hashpipe_status_unlock_safe(&st); // populate block header db->block[block_idx].header.mcnt = mcnt; db->block[block_idx].header.coarse_chan_id = 321; db->block[block_idx].header.num_coarse_chan = num_coarse_chan; memset(db->block[block_idx].header.missed_pkts, 0, sizeof(uint64_t) * N_BEAM_SLOTS); if(gen_fake) { gen_fake = 0; // gen fake data for all beams, all blocks // TODO vary data by beam fprintf(stderr, "generating fake data to block 0 beam 0..."); gen_fake_data(&(db->block[0].data[0])); fprintf(stderr, " done\n"); fprintf(stderr, "copying to block 0 beam"); for(int beam_i = 1; beam_i < N_BEAMS; beam_i++) { fprintf(stderr, " %d", beam_i); memcpy((void *)&db->block[0].data[beam_i*N_BYTES_PER_BEAM/sizeof(uint64_t)], (void *)&db->block[0].data[0], N_BYTES_PER_BEAM); } fprintf(stderr, " done\n"); fprintf(stderr, "copying to block"); for(int block_i = 1; block_i < N_INPUT_BLOCKS; block_i++) { fprintf(stderr, " %d", block_i); memcpy((void *)&db->block[block_i].data[0], (void *)&db->block[0].data[0], N_DATA_BYTES_PER_BLOCK); } fprintf(stderr, " done\n"); } hashpipe_status_lock_safe(&st); hputr4(st.buf, "NETMXERR", max_error); hputi4(st.buf, "NETERCNT", error_count); hputi4(st.buf, "NETMXECT", max_error_count); hashpipe_status_unlock_safe(&st); // Mark block as full s6_input_databuf_set_filled(db, block_idx); // Setup for next block block_idx = (block_idx + 1) % db->header.n_block; mcnt++; // uncomment the following to test dynamic setting of num_coarse_chan //num_coarse_chan--; /* Will exit if thread has been cancelled */ pthread_testcancel(); } // Thread success! return THREAD_OK; }
int main ( int argc, char *argv[] ) { pwr_tStatus sts; int event; plc_sProcess *pp; uid_t ruid; struct passwd *pwd; /* struct rlimit rlim; int i; */ /* Set core dump file size limit to infinite */ /* rlim.rlim_cur = RLIM_INFINITY; rlim.rlim_max = RLIM_INFINITY; sts = setrlimit(RLIMIT_CORE, &rlim); printf("%d\n", sts); i = 1/0; printf("%d\n", i); */ pp = init_process(); qcom_WaitAnd(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_newPlcInit, qcom_cTmoEternal); init_plc(pp); create_threads(pp); init_threads(pp); /* Once threads has set their priority don't run as root */ #if 0 ruid = getuid(); if (ruid == 0) { pwd = getpwnam("pwrp"); if (pwd != NULL) { setreuid(pwd->pw_uid, pwd->pw_uid); } } else setreuid(ruid, ruid); #endif qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_newPlcInitDone); qcom_WaitAnd(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_newPlcStart, qcom_cTmoEternal); // proc_SetPriority(pp->PlcProcess->Prio); set_values(pp); start_threads(pp); run_threads(pp); time_Uptime(&sts, &pp->PlcProcess->StartTime, NULL); qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_newPlcStartDone); #if 0 /* Force the backup to take care initialized backup objects. */ bck_ForceBackup(NULL); #endif errh_SetStatus( PWR__SRUN); qcom_WaitOr(&sts, &pp->eventQ, &qcom_cQini, ini_mEvent_terminate | ini_mEvent_oldPlcStop, qcom_cTmoEternal, &event); switch ( event) { case ini_mEvent_terminate: errh_SetStatus( PWR__SRVTERM); stop_threads(pp); clean_all(pp); nmps_delete_lock( &sts); break; case ini_mEvent_oldPlcStop: errh_SetStatus( PWR__SRVTERM); time_Uptime(&sts, &pp->PlcProcess->StopTime, NULL); stop_threads(pp); save_values(pp); qcom_SignalOr(&sts, &qcom_cQini, ini_mEvent_oldPlcStopDone); #if defined OS_ELN sts = proc_SetPriority(31); #endif clean_all(pp); break; default: ; } exit(0); }
static void *run(hashpipe_thread_args_t * args) { // Local aliases to shorten access to args fields // Our output buffer happens to be a paper_input_databuf hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; st_p = &st; // allow global (this source file) access to the status buffer // Get inital value for crc32 function uint32_t init_crc = crc32(0,0,0); // Flag that holds off the crc thread int holdoff = 1; // Force ourself into the hold off state hashpipe_status_lock_safe(&st); hputi4(st.buf, "CRCHOLD", 1); hashpipe_status_unlock_safe(&st); while(holdoff) { // We're not in any hurry to startup sleep(1); hashpipe_status_lock_safe(&st); // Look for CRCHOLD value hgeti4(st.buf, "CRCHOLD", &holdoff); if(!holdoff) { // Done holding, so delete the key hdel(st.buf, "CRCHOLD"); } hashpipe_status_unlock_safe(&st); } /* Read network params */ struct hashpipe_udp_params up = { .bindhost = "0.0.0.0", .bindport = 8511, .packet_size = 8200 }; hashpipe_status_lock_safe(&st); // Get info from status buffer if present (no change if not present) hgets(st.buf, "BINDHOST", 80, up.bindhost); hgeti4(st.buf, "BINDPORT", &up.bindport); // Store bind host/port info etc in status buffer hputs(st.buf, "BINDHOST", up.bindhost); hputi4(st.buf, "BINDPORT", up.bindport); hputu4(st.buf, "CRCPKOK", 0); hputu4(st.buf, "CRCPKERR", 0); hputs(st.buf, status_key, "running"); hashpipe_status_unlock_safe(&st); struct hashpipe_udp_packet p; /* Give all the threads a chance to start before opening network socket */ sleep(1); /* Set up UDP socket */ int rv = hashpipe_udp_init(&up); if (rv!=HASHPIPE_OK) { hashpipe_error("paper_crc_thread", "Error opening UDP socket."); pthread_exit(NULL); } pthread_cleanup_push((void *)hashpipe_udp_close, &up); /* Main loop */ uint64_t packet_count = 0; uint64_t good_count = 0; uint64_t error_count = 0; uint64_t elapsed_wait_ns = 0; uint64_t elapsed_recv_ns = 0; uint64_t elapsed_proc_ns = 0; float ns_per_wait = 0.0; float ns_per_recv = 0.0; float ns_per_proc = 0.0; struct timespec start, stop; struct timespec recv_start, recv_stop; packet_header_t hdr; while (run_threads()) { /* Read packet */ clock_gettime(CLOCK_MONOTONIC, &recv_start); do { clock_gettime(CLOCK_MONOTONIC, &start); p.packet_size = recv(up.sock, p.data, HASHPIPE_MAX_PACKET_SIZE, 0); clock_gettime(CLOCK_MONOTONIC, &recv_stop); } while (p.packet_size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) && run_threads()); // Break out of loop if stopping if(!run_threads()) break; // Increment packet count packet_count++; // Check CRC if(crc32(init_crc, (/*const?*/ uint8_t *)p.data, p.packet_size) == 0xffffffff) { // CRC OK! Increment good counter good_count++; } else { // CRC error! Increment error counter error_count++; // Log message get_header(&p, &hdr); hashpipe_warn("paper_crc", "CRC error mcnt %llu ; fid %u ; xid %u", hdr.mcnt, hdr.fid, hdr.xid); } clock_gettime(CLOCK_MONOTONIC, &stop); elapsed_wait_ns += ELAPSED_NS(recv_start, start); elapsed_recv_ns += ELAPSED_NS(start, recv_stop); elapsed_proc_ns += ELAPSED_NS(recv_stop, stop); if(packet_count % 1000 == 0) { // Compute stats get_header(&p, &hdr); ns_per_wait = (float)elapsed_wait_ns / packet_count; ns_per_recv = (float)elapsed_recv_ns / packet_count; ns_per_proc = (float)elapsed_proc_ns / packet_count; // Update status hashpipe_status_lock_busywait_safe(&st); hputu8(st.buf, "CRCMCNT", hdr.mcnt); // Gbps = bits_per_packet / ns_per_packet // (N_BYTES_PER_PACKET excludes header, so +8 for the header) hputr4(st.buf, "CRCGBPS", 8*(N_BYTES_PER_PACKET+8)/(ns_per_recv+ns_per_proc)); hputr4(st.buf, "CRCWATNS", ns_per_wait); hputr4(st.buf, "CRCRECNS", ns_per_recv); hputr4(st.buf, "CRCPRCNS", ns_per_proc); // TODO Provide some way to recognize request to zero out the // CRCERR and CRCOK fields. hputu8(st.buf, "CRCPKOK", good_count); hputu8(st.buf, "CRCPKERR", error_count); hashpipe_status_unlock_safe(&st); // Start new average elapsed_wait_ns = 0; elapsed_recv_ns = 0; elapsed_proc_ns = 0; packet_count = 0; } /* Will exit if thread has been cancelled */ pthread_testcancel(); } /* Have to close all push's */ pthread_cleanup_pop(1); /* Closes push(hashpipe_udp_close) */ return NULL; } static hashpipe_thread_desc_t crc_thread = { name: "paper_crc_thread", skey: "CRCSTAT", init: NULL, run: run, ibuf_desc: {NULL},
int main(int argc, char *argv[]) { struct blk_arguments arguments; /* set the random seed value */ srand(time(NULL)); /* set default values */ memset(&arguments, 0, sizeof (struct blk_arguments)); arguments.block_size = 512; arguments.num_ops = 100; arguments.file_size = (PMEMBLK_MIN_POOL / 1024) / 1024; if (argp_parse(&argp, argc, argv, 0, 0, &arguments) != 0) { exit(1); } struct worker_info worker_params[arguments.thread_count]; memset(worker_params, 0, sizeof (struct worker_info)); /* set common values */ worker_params[0].block_size = arguments.block_size; worker_params[0].num_ops = arguments.num_ops; worker_params[0].file_lanes = arguments.thread_count; /* file_size is provided in MB */ unsigned long long file_size_bytes = arguments.file_size * 1024 * 1024; worker *thread_workers = NULL; /* prepare parameters specific for file/pmem */ if (arguments.file_io) { /* prepare open flags */ int flags = O_RDWR | O_CREAT | O_SYNC; /* create file on PMEM-aware file system */ if ((worker_params[0].file_desc = open(arguments.file_path, flags, FILE_MODE)) < 0) { perror(arguments.file_path); exit(1); } /* pre-allocate file_size MB of persistent memory */ if ((errno = posix_fallocate(worker_params[0].file_desc, (off_t)0, (off_t)file_size_bytes)) != 0) { warn("posix_fallocate"); close(worker_params[0].file_desc); exit(1); } worker_params[0].num_blocks = file_size_bytes / worker_params[0].block_size; thread_workers = file_workers; } else { worker_params[0].file_desc = -1; if (arguments.prep_blk_file) { if ((worker_params[0].handle = pmemblk_create( arguments.file_path, worker_params[0].block_size, (off_t)file_size_bytes, FILE_MODE)) == NULL) { err(1, "%s: pmemblk_open", argv[2]); } } else { if ((worker_params[0].handle = pmemblk_open( arguments.file_path, worker_params[0].block_size)) == NULL) { err(1, "%s: pmemblk_open", argv[2]); } } worker_params[0].num_blocks = pmemblk_nblock( worker_params[0].handle); thread_workers = pmem_workers; } /* propagate params to each info_t */ for (int i = 1; i < arguments.thread_count; ++i) { memcpy(&worker_params[i], &worker_params[0], sizeof (struct worker_info)); worker_params[i].thread_index = i; worker_params[i].seed = rand(); } /* The blk mode file prep */ if (arguments.prep_blk_file) { if (worker_params[0].file_desc >= 0) close(worker_params[0].file_desc); return run_threads(prep_worker, arguments.thread_count, worker_params); } struct measurements perf_meas; perf_meas.total_ops = arguments.thread_count * worker_params[0].num_ops; /* perform PMEMBLK warmup */ if (!arguments.file_io) { if (run_threads(warmup_worker, arguments.thread_count, worker_params) != 0) { if (worker_params[0].file_desc >= 0) close(worker_params[0].file_desc); exit(1); } } for (int i = 0; i < WORKER_COUNT_MAX; ++i) { clock_gettime(CLOCK_MONOTONIC, &perf_meas.start_time); if (run_threads(thread_workers[i], arguments.thread_count, worker_params) != 0) { if (worker_params[0].file_desc >= 0) close(worker_params[0].file_desc); exit(1); } clock_gettime(CLOCK_MONOTONIC, &perf_meas.stop_time); calculate_stats(&perf_meas); printf("%f;%f;", perf_meas.total_run_time, perf_meas.ops_per_second); } printf("\n"); if (worker_params[0].file_desc >= 0) close(worker_params[0].file_desc); /* cleanup and check pmem file */ if (!arguments.file_io) { pmemblk_close(worker_params[0].handle); /* not really necessary, but check consistency */ int result = pmemblk_check(arguments.file_path); if (result < 0) { warn("%s: pmemblk_check", arguments.file_path); } else if (result == 0) { warnx("%s: pmemblk_check: not consistent", arguments.file_path); } } exit(0); }
static void test_TDMB() { int key, ret; int num_tbl; int i; unsigned int lock_mask, sub_ch_id, ch_freq_khz; E_RTV_COUNTRY_BAND_TYPE country_band_type; IOCTL_TDMB_SUB_CH_INFO sub_ch_info; IOCTL_TDMB_SIGNAL_INFO dm_info; // BOOL power_on = FALSE; unsigned char fic_buf[384]; char devname[32]; BOOL is_power_on = FALSE; num_tbl = sizeof(tdmb_korea_tbl) / sizeof(uint32_t); tv_mode = 1; sprintf(devname,"/dev/%s", RAONTV_DEV_NAME); fd_dmb_dev = open(devname, O_RDWR); if(fd_dmb_dev<0) { printf("Can't not open %s\n", devname); return; } #if defined(RTV_IF_MPEG2_SERIAL_TSIF) || defined(RTV_IF_SPI_SLAVE) || defined(RTV_IF_QUALCOMM_TSIF) || defined(RTV_IF_MPEG2_PARALLEL_TSIF) sprintf(devname,"/dev/%s", "s3c-tsi"); fd_tsif_dev = open(devname, O_RDWR); if(fd_tsif_dev<0) { printf("Can't not open %s\n",devname); return -1; } #endif #ifdef _TS_FILE_DUMP_ENABLE if((fd_tdmb_ts=fopen("./tdmb_ts.ts", "wb")) == NULL) { printf("tdmb_ts.ts file open error\n"); } #endif tsif_run_flag = 0; if((ret=run_threads()) != 0) { printf("run_threads() failed: %d\n", ret); } while(1) { printf("===============================================\n"); printf("\t0: TDMB Power ON\n"); printf("\t1: TDMB Power OFF\n"); printf("\t2: TDMB Scan freq\n"); printf("\t3: TDMB Open Sub Channel\n"); printf("\t4: TDMB Close Sub Channel\n"); printf("\t5: TDMB Get Lockstatus\n"); printf("\t6: TDMB Get Signal Info\n"); printf("\t7: TDMB [TEST] Set Freq\n"); printf("\t8: GPIO Write(Set) Test\n"); printf("\t9: GPIO Read(Get) Test\n"); printf("\tw: Write Reg\n"); printf("\tr: Read Reg\n"); printf("\ts: Stop TSIF\n"); printf("\tq or Q: Quit\n"); printf("===============================================\n"); //fflush(stdin); key = getc(stdin); CLEAR_STDIN; switch( key ) { case '0': printf("[T-DMB Power ON]\n"); country_band_type = RTV_COUNTRY_BAND_KOREA; if((ret=ioctl(fd_dmb_dev, IOCTL_TDMB_POWER_ON, &country_band_type)) < 0) { printf("IOCTL_TDMB_POWER_ON failed: %d\n", ret); } is_power_on = TRUE; #if 0 //// sub_ch_info.ch_freq_khz = 208736; sub_ch_info.sub_ch_id = 0; //sub_ch_info.ch_freq_khz = 184736; //sub_ch_info.sub_ch_id = 1; sub_ch_info.service_type = RTV_TDMB_SERVICE_VIDEO; if(ioctl(fd_dmb_dev, IOCTL_TDMB_OPEN_SUBCHANNEL, &sub_ch_info) < 0) { printf("IOCTL_TDMB_OPEN_SUBCHANNEL failed\n"); } printf("\n"); //////////////////////////////////////test/////////////////////////////////////// #if 0 for(i=0;i < 400;i++) { /* ioctl_register_access.Addr = 0x03; ioctl_register_access.data[0] = 0x0f; if(ioctl(fd_dmb_dev, IOCTL_REGISTER_WRITE, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_WRITE failed\n"); } */ //ioctl_register_access.Addr = 0x00; if(ioctl(fd_dmb_dev, IOCTL_REGISTER_READ, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_READ failed\n"); } printf("[%d] Address 0x%02x= 0x%02x\n", i, ioctl_register_access.Addr, ioctl_register_access.data[0]); //printf("\n"); usleep(20000); } #endif //////////////////////////////////////test/////////////////////////////////////// #endif break; case '1': printf("[T-DMB Power OFF]\n"); if(ioctl(fd_dmb_dev, IOCTL_TDMB_POWER_OFF) < 0) { printf("IOCTL_TDMB_POWER_OFF failed\n"); } is_power_on = FALSE; break; case '2': printf("TDMB Scan freq\n"); for(i=0; i<num_tbl; i++) { int k; printf("[TDMB Scan start] freq: %u\n", tdmb_korea_tbl[i]); if(ioctl(fd_dmb_dev, IOCTL_TDMB_SCAN_FREQ, &tdmb_korea_tbl[i]) < 0) { printf("scan failed on channel[%d]\n", tdmb_korea_tbl[i]); } else { // Add a channel to scaned list. printf("[TDMB Scan freq] CH DETECTED\n"); for(k=0; k<5; k++) { if((ret=ioctl(fd_dmb_dev, IOCTL_TDMB_READ_FIC, fic_buf)) < 0) { printf("read fic fail: %d\n", ret); } else { printf("\tfic_buf[0]: 0x%02X, fic_buf[1]: 0x%02X, fic_buf[2]: 0x%02X\n", fic_buf[0], fic_buf[1], fic_buf[2]); } } } printf("\n"); } break; case '3': printf("[T-DMB Open Sub Channel]\n"); while(1) { printf("Input Channel freq(ex. 175280):"); scanf("%u", &sub_ch_info.ch_freq_khz); CLEAR_STDIN; for(i=0; i<num_tbl; i++) { if(sub_ch_info.ch_freq_khz == tdmb_korea_tbl[i]) goto call_tdmb_set_ch; } if(i == num_tbl) { printf("Invalid T-DMB freq\n"); } } call_tdmb_set_ch : printf("Input sub channel ID(ex. 0):"); scanf("%u", &sub_ch_info.sub_ch_id); CLEAR_STDIN; printf("Input service type(0: Video, 1:Audio, 2: Data):"); scanf("%u", &sub_ch_info.service_type); CLEAR_STDIN; if((ret=ioctl(fd_dmb_dev, IOCTL_TDMB_OPEN_SUBCHANNEL, &sub_ch_info)) < 0) { printf("IOCTL_TDMB_OPEN_SUBCHANNEL failed: %d\n", ret); } printf("\n"); break; case '4': printf("[TDMB Close Sub Channel]\n"); printf("Input sub channel ID(ex. 0):"); scanf("%u", &sub_ch_id); CLEAR_STDIN; if(ioctl(fd_dmb_dev, IOCTL_TDMB_CLOSE_SUBCHANNEL, &sub_ch_id) < 0) { printf("IOCTL_TDMB_CLOSE_SUBCHANNEL failed\n"); } printf("\n"); break; case '5': printf("[TDMB Get Lockstatus]\n"); if(ioctl(fd_dmb_dev, IOCTL_TDMB_GET_LOCK_STATUS, &lock_mask) < 0) { printf("RTV_IOCTL_TDMB_GET_LOCK_STATUS failed\n"); } printf("lock_mask = %d\n", lock_mask); printf("\n"); break; case '6': printf("[TDMB Get Singal Info]\n"); if(ioctl(fd_dmb_dev, IOCTL_TDMB_GET_SIGNAL_INFO, &dm_info) < 0) { printf("IOCTL_TDMB_GET_SIGNAL_INFO failed\n"); } printf("ber = %f\n", (float)dm_info.ber/RTV_TDMB_BER_DIVIDER); printf("cer = %u\n", dm_info.cer); printf("cnr = %f\n", (float)dm_info.cnr/RTV_TDMB_CNR_DIVIDER); printf("rssi = %f\n", (float)dm_info.rssi/RTV_TDMB_RSSI_DIVIDER); printf("per = %u\n", dm_info.per); printf("\n"); break; case '7': printf("[T-DMB Set Freq]\n"); while(1) { printf("Input Channel freq(ex. 175280):"); scanf("%u", &ch_freq_khz); CLEAR_STDIN; for(i=0; i<num_tbl; i++) { if(ch_freq_khz == tdmb_korea_tbl[i]) goto call_tdmb_set_Freq; } if(i == num_tbl) { printf("Invalid T-DMB freq\n"); } } call_tdmb_set_Freq : if(ioctl(fd_dmb_dev, IOCTL_TEST_TDMB_SET_FREQ, &ch_freq_khz) < 0) { printf("IOCTL_TDMB_SET_FREQ failed\n"); } printf("\n"); break; case '8': printf("[GPIO Write(Set) Test]\n"); printf("Select Pin Number:"); scanf("%u" , &gpio_info.pin); CLEAR_STDIN; retry_gpio_set: printf("Input Pin Level(0 or 1):"); scanf("%u" , &gpio_info.value); CLEAR_STDIN; if((gpio_info.value != 0) && (gpio_info.value != 1)) goto retry_gpio_set; if(ioctl(fd_dmb_dev, IOCTL_TEST_GPIO_SET, &gpio_info) < 0) { printf("IOCTL_TEST_GPIO_SET failed\n"); } break; case '9': printf("[GPIO Write(Set) Test]\n"); printf("Select Pin Number:"); scanf("%u" , &gpio_info.pin); CLEAR_STDIN; if(ioctl(fd_dmb_dev, IOCTL_TEST_GPIO_GET, &gpio_info) < 0) { printf("IOCTL_TEST_GPIO_GET failed\n"); } printf("Pin(%u): %u\n", gpio_info.pin, gpio_info.value); printf("\n"); break; case 'w': printf("[T-DMB] Register Write\n"); printf("===============================================\n"); printf("\t0: HOST_PAGE\n"); printf("\t1: RF_PAGE\n"); printf("\t2: COMM_PAGE\n"); printf("\t3: DD_PAGE\n"); printf("\t4: MSC0_PAGE\n"); printf("\t5: MSC1_PAGE\n"); printf("\t6: OFDM PAGE\n"); printf("\t7: FEC_PAGE\n"); printf("\t8: FIC_PAGE\n"); printf("===============================================\n"); printf("Select Page:"); scanf("%x" , &ioctl_register_access.page); CLEAR_STDIN; printf("Input Address(hex) :, data(hex) : "); scanf("%x" , &ioctl_register_access.Addr); CLEAR_STDIN; scanf("%x" , &ioctl_register_access.data[0]); CLEAR_STDIN; printf("Input Address: 0x%02x, data: 0x%02x \n", ioctl_register_access.Addr, ioctl_register_access.data[0] ); if(ioctl(fd_dmb_dev, IOCTL_REGISTER_WRITE, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_WRITE failed\n"); } break; case 'r': printf("[T-DMB] Register Read\n"); printf("===============================================\n"); printf("\t0: HOST_PAGE\n"); printf("\t1: RF_PAGE\n"); printf("\t2: COMM_PAGE\n"); printf("\t3: DD_PAGE\n"); printf("\t4: MSC0_PAGE\n"); printf("\t5: MSC1_PAGE\n"); printf("\t6: OFDM PAGE\n"); printf("\t7: FEC_PAGE\n"); printf("\t8: FIC_PAGE\n"); printf("===============================================\n"); printf("Select Page:"); scanf("%x" , &ioctl_register_access.page); CLEAR_STDIN; printf("Input Address(hex) : "); scanf("%x", &ioctl_register_access.Addr); CLEAR_STDIN; printf("Input Address: 0x%02x\n ", ioctl_register_access.Addr ); if(ioctl(fd_dmb_dev, IOCTL_REGISTER_READ, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_READ failed\n"); } printf("Address 0x%02x= 0x%02x\n",ioctl_register_access.Addr, ioctl_register_access.data[0]); printf("\n"); break; case 's': break; case 'q': case 'Q': goto TDMB_EXIT; default: printf("[%c]\n", key); } } TDMB_EXIT: #if 0 exit_threads(); //raise(SIGKILL); // raise(SIGUSR1); #else if(is_power_on == TRUE) { // printf("(TDMB_EXIT) IOCTL_TDMB_POWER_OFF\n"); if(ioctl(fd_dmb_dev, IOCTL_TDMB_POWER_OFF) < 0) { printf("IOCTL_TDMB_POWER_OFF failed\n"); } } exit_threads(); #if defined(RTV_IF_MPEG2_SERIAL_TSIF) || defined(RTV_IF_SPI_SLAVE) || defined(RTV_IF_QUALCOMM_TSIF) || defined(RTV_IF_MPEG2_PARALLEL_TSIF) close(fd_tsif_dev); #endif // printf("(TDMB_EXIT) close(fd_dmb_dev)\n"); close(fd_dmb_dev); // printf("(TDMB_EXIT) close(fd_dmb_dev) END\n"); #ifdef _TS_FILE_DUMP_ENABLE fclose(fd_tdmb_ts); #endif #endif printf("TDMB_EXIT\n"); return; }
int main() { std::cout << run_threads(); return 0; }
// Run method for the thread // It is meant to do the following: // (1) Initialize status buffer // (2) Set up network parameters and socket // (3) Start main loop // (3a) Receive packet on socket // (3b) Error check packet (packet size, etc) // (3c) Call process_packet on received packet // (4) Terminate thread cleanly static void *run(hashpipe_thread_args_t * args) { fprintf(stdout, "N_INPUTS = %d\n", N_INPUTS); fprintf(stdout, "N_CHAN = %d\n", N_CHAN); fprintf(stdout, "N_CHAN_PER_X = %d\n", N_CHAN_PER_X); fprintf(stdout, "N_CHAN_PER_PACKET = %d\n", N_CHAN_PER_PACKET); fprintf(stdout, "N_TIME_PER_PACKET = %d\n", N_TIME_PER_PACKET); fprintf(stdout, "N_TIME_PER_BLOCK = %d\n", N_TIME_PER_BLOCK); fprintf(stdout, "N_BYTES_PER_BLOCK = %d\n", N_BYTES_PER_BLOCK); fprintf(stdout, "N_BYTES_PER_PACKET = %d\n", N_BYTES_PER_PACKET); fprintf(stdout, "N_PACKETS_PER_BLOCK = %d\n", N_PACKETS_PER_BLOCK); fprintf(stdout, "N_COR_MATRIX = %d\n", N_COR_MATRIX); // Local aliases to shorten access to args fields // Our output buffer happens to be a paper_input_databuf flag_input_databuf_t *db = (flag_input_databuf_t *)args->obuf; hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; st_p = &st; // allow global (this source file) access to the status buffer /* Read network params */ fprintf(stdout, "Setting up network parameters\n"); struct hashpipe_udp_params up = { .bindhost = "0.0.0.0", .bindport = 8511, .packet_size = 8008 }; hashpipe_status_lock_safe(&st); // Get info from status buffer if present (no change if not present) hgets(st.buf, "BINDHOST", 80, up.bindhost); hgeti4(st.buf, "BINDPORT", &up.bindport); // Store bind host/port info etc in status buffer hputs(st.buf, "BINDHOST", up.bindhost); hputi4(st.buf, "BINDPORT", up.bindport); hputu4(st.buf, "MISSEDFE", 0); hputu4(st.buf, "MISSEDPK", 0); hputs(st.buf, status_key, "running"); hashpipe_status_unlock_safe(&st); struct hashpipe_udp_packet p; /* Give all the threads a chance to start before opening network socket */ int netready = 0; int corready = 0; int checkready = 0; while (!netready) { sleep(1); // Check the correlator to see if it's ready yet hashpipe_status_lock_safe(&st); hgeti4(st.buf, "CORREADY", &corready); hgeti4(st.buf, "SAVEREADY", &checkready); hashpipe_status_unlock_safe(&st); if (!corready) { continue; } //if (!checkready) { // continue; //} // Check the other threads to see if they're ready yet // TBD // If we get here, then all threads are initialized netready = 1; } sleep(3); /* Set up UDP socket */ fprintf(stderr, "NET: BINDHOST = %s\n", up.bindhost); fprintf(stderr, "NET: BINDPORT = %d\n", up.bindport); int rv = hashpipe_udp_init(&up); if (rv!=HASHPIPE_OK) { hashpipe_error("paper_net_thread", "Error opening UDP socket."); pthread_exit(NULL); } pthread_cleanup_push((void *)hashpipe_udp_close, &up); // Initialize first few blocks in the buffer int i; for (i = 0; i < 2; i++) { // Wait until block semaphore is free if (flag_input_databuf_wait_free(db, i) != HASHPIPE_OK) { if (errno == EINTR) { // Interrupt occurred hashpipe_error(__FUNCTION__, "waiting for free block interrupted\n"); pthread_exit(NULL); } else { hashpipe_error(__FUNCTION__, "error waiting for free block\n"); pthread_exit(NULL); } } initialize_block(db, i*Nm); } // Set correlator to "start" state hashpipe_status_lock_safe(&st); hputs(st.buf, "INTSTAT", "start"); hashpipe_status_unlock_safe(&st); /* Main loop */ uint64_t packet_count = 0; fprintf(stdout, "Net: Starting Thread!\n"); while (run_threads()) { // Get packet do { p.packet_size = recv(up.sock, p.data, HASHPIPE_MAX_PACKET_SIZE, 0); } while (p.packet_size == -1 && (errno == EAGAIN || errno == EWOULDBLOCK) && run_threads()); if(!run_threads()) break; if (up.packet_size != p.packet_size && up.packet_size != p.packet_size-8) { // If an error was returned instead of a valid packet size if (p.packet_size == -1) { fprintf(stderr, "uh oh!\n"); // Log error and exit hashpipe_error("paper_net_thread", "hashpipe_udp_recv returned error"); perror("hashpipe_udp_recv"); pthread_exit(NULL); } else { // Log warning and ignore wrongly sized packet hashpipe_warn("paper_net_thread", "Incorrect pkt size (%d)", p.packet_size); continue; } } packet_count++; process_packet(db, &p); /* Will exit if thread has been cancelled */ pthread_testcancel(); } pthread_cleanup_pop(1); /* Closes push(hashpipe_udp_close) */ hashpipe_status_lock_busywait_safe(&st); hputs(st.buf, status_key, "terminated"); hashpipe_status_unlock_safe(&st); return NULL; } static hashpipe_thread_desc_t net_thread = { name: "flag_net_thread", skey: "NETSTAT", init: NULL, run: run, ibuf_desc: {NULL},
int main(){ std::cout << run_threads() << std::endl; return 0; }
/* * main -- entry point, initializes allocated_mem and runs the tasks */ int main(int argc, char *argv[]) { int i, fails = 0; double task_duration; void **arg = NULL; uint64_t pool_size; arguments_t arguments; int per_thread_args = 0; const int min_pool_size = 200; arguments.pool_per_thread = 0; arguments.allocator = ALLOCATOR_VMEM; arguments.dir_path = NULL; if (argp_parse(&argp, argc, argv, 0, 0, &arguments)) { fprintf(stderr, "argp_parse error"); return EXIT_FAILURE; } int pools_count = arguments.pool_per_thread ? arguments.thread_count : 1; VMEM *pools[pools_count]; void *pools_data[pools_count]; allocated_mem = calloc(arguments.ops_count, sizeof (void*)); if (allocated_mem == NULL) { perror("calloc"); return EXIT_FAILURE; } if (arguments.allocator == ALLOCATOR_VMEM) { if (arguments.pool_per_thread && arguments.thread_count > MAX_THREADS) { fprintf(stderr, "Maximum allowed thread count" " with pool per thread option enabled is %u\n", MAX_THREADS); return EXIT_FAILURE; } pools_count = arguments.pool_per_thread ? arguments.thread_count : 1; per_thread_args = arguments.pool_per_thread; pool_size = arguments.ops_count * arguments.allocation_size_max * 2u; pool_size /= pools_count; if (pool_size < min_pool_size * MB) { pool_size = min_pool_size * MB; } for (i = 0; i < pools_count; ++i) { if (arguments.dir_path == NULL) { pools_data[i] = malloc(pool_size); if (pools_data[i] == NULL) { free(allocated_mem); perror("malloc"); return EXIT_FAILURE; } /* suppress valgrind warnings */ memset(pools_data[i], 0xFF, pool_size); pools[i] = vmem_pool_create_in_region( pools_data[i], pool_size); } else { pools[i] = vmem_pool_create(arguments.dir_path, pool_size); } if (pools[i] == NULL) { perror("vmem_pool_create"); free(allocated_mem); return EXIT_FAILURE; } } arg = (void **)pools; } /* Cache warmup. */ for (i = 0; i < MAX_TASK; ++i) { fails += run_threads(&arguments, tasks[i], per_thread_args, arg, &task_duration); } for (i = 0; i < MAX_TASK; ++i) { fails += run_threads(&arguments, tasks[i], per_thread_args, arg, &task_duration); printf("%f;%f;", task_duration, arguments.ops_count/task_duration); } printf("\n"); if (arguments.allocator == ALLOCATOR_VMEM) { for (i = 0; i < pools_count; ++i) { vmem_pool_delete(pools[i]); if (arguments.dir_path == NULL) { free(pools_data[i]); } } } free(allocated_mem); return (fails == 0) ? EXIT_SUCCESS : EXIT_FAILURE; }
static void test_ISDBT(void) { int key, ret; E_RTV_COUNTRY_BAND_TYPE country_band_type; RTV_ISDBT_TMCC_INFO tmcc_info; IOCTL_ISDBT_SIGNAL_INFO dm_info; int num_tbl; int i; int ch; unsigned int lock_mask; char devname[32]; tv_mode = 0; num_tbl = sizeof(gtISDBTFreqTable) / sizeof(TISDBTFREQ); sprintf(devname,"/dev/%s", RAONTV_DEV_NAME); fd_dmb_dev = open(devname, O_RDWR); if(fd_dmb_dev<0) { printf("Can't not open %s\n", devname); return; } #if defined(RTV_IF_MPEG2_SERIAL_TSIF) || defined(RTV_IF_SPI_SLAVE) || defined(RTV_IF_QUALCOMM_TSIF) || defined(RTV_IF_MPEG2_PARALLEL_TSIF) sprintf(devname,"/dev/%s", "s3c-tsi"); fd_tsif_dev = open(devname, O_RDWR); if(fd_tsif_dev<0) { printf("Can't not open %s\n",devname); return -1; } #endif #ifdef _TS_FILE_DUMP_ENABLE if((fd_isdbt_ts=fopen("./isdbt_ts.ts", "wb")) == NULL) { printf("isdbt_ts.ts file open error\n"); } #endif tsif_run_flag = 0; while(1) { printf("===============================================\n"); printf("\t0: 1seg Power ON\n"); printf("\t1: 1seg Power OFF\n"); printf("\t2: 1seg Scan freq\n"); printf("\t3: 1seg Set Channel\n"); printf("\t4: 1seg Get Lockstatus\n"); printf("\t5: 1seg Get TMCC\n"); printf("\t6: 1seg Get Signal Info\n"); printf("\t7: 1seg Start TS\n"); printf("\t8: 1seg Stop TS\n"); printf("\tw: Write Reg\n"); printf("\tr: Read Reg\n"); printf("\tq or Q: Quit\n"); printf("===============================================\n"); fflush(stdin); key = getc(stdin); CLEAR_STDIN; switch( key ) { case '0': printf("[ISDBT DTV Start]\n"); if((ret=run_threads()) != 0) { printf("run_threads() failed: %d\n", ret); } country_band_type = RTV_COUNTRY_BAND_JAPAN; if(ioctl(fd_dmb_dev, IOCTL_ISDBT_POWER_ON, &country_band_type) != 0) { printf("IOCTL_ISDBT_POWER_ON error"); } #if 0 ch = 37; if(ioctl(fd_dmb_dev, IOCTL_ISDBT_SET_FREQ, &ch) < 0) { // scan fail printf("IOCTL_ISDBT_SET_FREQ failed\n"); } sleep(3); printf("After sleep()\n"); ch = 37; if(ioctl(fd_dmb_dev, IOCTL_ISDBT_SET_FREQ, &ch) < 0) { // scan fail printf("IOCTL_ISDBT_SET_FREQ failed\n"); } #endif break; case '1': printf("[ISDBT DTV Stop]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_POWER_OFF) != 0) { printf("IOCTL_ISDBT_POWER_OFF error"); } break; case '2': for(i=0; i<num_tbl; i++) { printf("[ISDB-T Scan start] (ch: %u), freq: %u\n", gtISDBTFreqTable[i].ch, gtISDBTFreqTable[i].freq); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_SCAN_FREQ, >ISDBTFreqTable[i].ch) < 0) { printf("scan failed on channel[%d]\n",gtISDBTFreqTable[i].ch); } // Add a channel to scaned list. printf("\n"); } break; case '3': printf("Input Channel num(ex.13):"); scanf("%d",&ch); CLEAR_STDIN; printf("[ISDBT Set Freq] (ch: %u)\n", ch); #if defined(RTV_IF_MPEG2_SERIAL_TSIF) || defined(RTV_IF_SPI_SLAVE) || defined(RTV_IF_QUALCOMM_TSIF) || defined(RTV_IF_MPEG2_PARALLEL_TSIF) if(tsif_run_flag != 1) tsif_run(1); /* Run TSI */ #endif if(ioctl(fd_dmb_dev, IOCTL_ISDBT_SET_FREQ, &ch) < 0) { // scan fail printf("IOCTL_ISDBT_SET_FREQ failed\n"); } printf("\n"); break; case '4': printf("[ISDB-T Get Lockstatus]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_GET_LOCK_STATUS, &lock_mask) < 0) { printf("IOCTL_ISDBT_GET_LOCK_STATUS failed\n"); } printf("isdbt_lock_mask = %d\n", lock_mask); printf("\n"); break; case '5': printf("[ISDB-T Get Tmcc]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_GET_TMCC, &tmcc_info) < 0) { printf("IOCTL_ISDBT_GET_TMCC failed\n"); } printf("tmcc_info.eCodeRate = %d\n", tmcc_info.eCodeRate); printf("tmcc_info.eGuard = %d\n", tmcc_info.eGuard); printf("tmcc_info.eInterlv = %d\n", tmcc_info.eInterlv); printf("tmcc_info.eModulation = %d\n", tmcc_info.eModulation); printf("tmcc_info.eSeg = %d\n", tmcc_info.eSeg); printf("tmcc_info.eTvMode = %d\n", tmcc_info.eTvMode); printf("tmcc_info.fEWS = %d\n", tmcc_info.fEWS); printf("\n"); break; case '6': printf("[ISDB-T Get Singal Info]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_GET_SIGNAL_INFO, &dm_info) < 0) { printf("IOCTL_ISDBT_GET_SIGNAL_INFO failed\n"); } printf("ber = %f\n", (float)dm_info.ber/(float)RTV_ISDBT_BER_DIVIDER); printf("cnr = %f\n", (float)dm_info.cnr/(float)RTV_ISDBT_CNR_DIVIDER); printf("rssi = %f\n", (float)dm_info.rssi/(float)RTV_ISDBT_RSSI_DIVIDER); printf("per = %u\n", dm_info.per); printf("\n"); break; case '7': printf("[ISDBT Start TS]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_START_TS) != 0) { printf("IOCTL_ISDBT_START_TS error"); } break; case '8': printf("[ISDBT Start TS]\n"); if(ioctl(fd_dmb_dev, IOCTL_ISDBT_STOP_TS) != 0) { printf("IOCTL_ISDBT_STOP_TS error"); } break; case 'w': printf("[ISDB-T Register Write\n"); printf("===============================================\n"); printf("\t0: HOST_PAGE\n"); printf("\t1: RF_PAGE\n"); printf("\t2: COMM_PAGE\n"); printf("\t3: DD_PAGE\n"); printf("\t4: MSC0_PAGE\n"); printf("\t5: MSC1_PAGE\n"); printf("\t6: OFDM PAGE\n"); printf("\t7: FEC_PAGE\n"); printf("===============================================\n"); printf("Select Page:"); scanf("%x" , &ioctl_register_access.page); CLEAR_STDIN; printf("Input Address(hex) :, data(hex) : "); scanf("%x" , &ioctl_register_access.Addr); CLEAR_STDIN; scanf("%x" , &ioctl_register_access.data[0]); CLEAR_STDIN; printf("Input Address: 0x%02x, data: 0x%02x \n", ioctl_register_access.Addr, ioctl_register_access.data[0] ); if(ioctl(fd_dmb_dev, IOCTL_REGISTER_WRITE, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_WRITE failed\n"); } break; case 'r': printf("[ISDB-T Register Read\n"); printf("===============================================\n"); printf("\t0: HOST_PAGE\n"); printf("\t1: RF_PAGE\n"); printf("\t2: COMM_PAGE\n"); printf("\t3: DD_PAGE\n"); printf("\t4: MSC0_PAGE\n"); printf("\t5: MSC1_PAGE\n"); printf("\t6: OFDM PAGE\n"); printf("\t7: FEC_PAGE\n"); printf("===============================================\n"); printf("Select Page:"); scanf("%x" , &ioctl_register_access.page); CLEAR_STDIN; printf("Input Address(hex) : "); scanf("%x", &ioctl_register_access.Addr); CLEAR_STDIN; printf("Input Address: 0x%02x\n ", ioctl_register_access.Addr ); if(ioctl(fd_dmb_dev, IOCTL_REGISTER_READ, &ioctl_register_access) < 0) { printf("IOCTL_REGISTER_READ failed\n"); } printf("Address 0x%02x= 0x%02x\n",ioctl_register_access.Addr, ioctl_register_access.data[0]); printf("\n"); break; case 'q': case 'Q': goto ISDBT_EXIT; default: printf("[%c]\n", key); } } ISDBT_EXIT: if(ioctl(fd_dmb_dev, IOCTL_TDMB_POWER_OFF) < 0) { printf("IOCTL_TDMB_POWER_OFF failed\n"); } #if defined(RTV_IF_MPEG2_SERIAL_TSIF) || defined(RTV_IF_SPI_SLAVE) || defined(RTV_IF_QUALCOMM_TSIF) || defined(RTV_IF_MPEG2_PARALLEL_TSIF) tsif_run(0); /* Stop TSI */ close(fd_tsif_dev); #endif close(fd_dmb_dev); exit_threads(); #ifdef _TS_FILE_DUMP_ENABLE fclose(fd_isdbt_ts); #endif return; }
// Run method for the thread static void *run(hashpipe_thread_args_t * args) { // Local aliases to shorten access to args fields // Our output buffer happens to be a paper_input_databuf grating_input_databuf_t *db_in = (grating_input_databuf_t *)args->ibuf; grating_gpu_input_databuf_t * db_out = (grating_gpu_input_databuf_t *)args->obuf; hashpipe_status_t st = args->st; const char * status_key = args->thread_desc->skey; st_p = &st; // allow global (this source file) access to the status buffer // Set thread to "start" state hashpipe_status_lock_safe(&st); hputs(st.buf, "TRANREADY", "start"); hashpipe_status_unlock_safe(&st); int rv; int curblock_in = 0; int curblock_out = 0; int mcnt; fprintf(stdout, "Tra: Starting Thread!\n"); while (run_threads()) { while ((rv=grating_input_databuf_wait_filled(db_in, curblock_in)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "waiting for filled block"); hashpipe_status_unlock_safe(&st); } else { hashpipe_error(__FUNCTION__, "error waiting for filled databuf block"); pthread_exit(NULL); break; } } while ((rv=grating_gpu_input_databuf_wait_free(db_out, curblock_out)) != HASHPIPE_OK) { if (rv==HASHPIPE_TIMEOUT) { hashpipe_status_lock_safe(&st); hputs(st.buf, status_key, "waiting for free block"); hashpipe_status_unlock_safe(&st); } else { hashpipe_error(__FUNCTION__, "error waiting for free databuf block"); pthread_exit(NULL); break; } } mcnt = db_in->block[curblock_in].header.mcnt_start; int m; int f; int t; int c; uint64_t * in_p; uint64_t * out_p; uint64_t * block_in_p = db_in->block[curblock_in].data; uint64_t * block_out_p = db_out->block[curblock_out].data; for (m = 0; m < Nm; m++) { for (t = 0; t < Nt; t++) { for (f = 0; f < Nf; f++) { for (c = 0; c < Nc; c++) { in_p = block_in_p + grating_input_databuf_idx(m,f,t,c); out_p = block_out_p + grating_gpu_input_databuf_idx(m,f,t,c); memcpy(out_p, in_p, 128/8); } } } } db_out->block[curblock_out].header.mcnt = mcnt; grating_gpu_input_databuf_set_filled(db_out, curblock_out); curblock_out = (curblock_out + 1) % db_out->header.n_block; grating_input_databuf_set_free(db_in, curblock_in); curblock_in = (curblock_in + 1) % db_in->header.n_block; /* Will exit if thread has been cancelled */ pthread_testcancel(); } return NULL; }