void *thread_cli_fun(void *arg) { double busy; int inx; Msg *msg; struct rusage r_start; struct rusage r_stop; struct timeval t_elapsed_data; struct timeval t_elapsed_total; struct timeval t_start_data; struct timeval t_start_total; struct timeval t_stop; arg = arg; // touch util_time_timer_start(&t_start_total); util_time_timer_start(&t_start_data); util_cpu_timer_start(&r_start); for (inx = 0; inx < loop; inx++) { if (verbose) printf("count=%d\n", inx); msg = msg_queue_remove(&mutex_pool, &queue_pool); assert(msg != NULL); if (csize) { msg->cbuf = (char *) malloc(csize); memcpy(msg->cbuf, send_buffer2, csize); } if (dsize) { msg->dbuf = (char *) malloc(dsize); memcpy(msg->dbuf, send_buffer, dsize); } msg_queue_add(&mutex_srv, &queue_srv, msg); cv_signal(&cv_srv); cv_wait(&cv_cli); msg = msg_queue_remove(&mutex_cli, &queue_cli); assert(msg != NULL); msg_queue_add(&mutex_pool, &queue_pool, msg); } util_cpu_timer_stop(&r_stop); util_time_timer_stop(&t_stop); util_time_elapsed(&t_start_total, &t_stop, &t_elapsed_total); util_time_elapsed(&t_start_data, &t_stop, &t_elapsed_data); util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed_data, &busy); if (!bm) { print_elapsed("", &t_elapsed_total); print_elapsed(" (data)", &t_elapsed_data); } print_rate(bm, "", bidir ? 2 * loop : loop, dsize, &t_elapsed_data, busy); return NULL; }
static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data) { GList *list, *option_value = NULL; char *address; print_elapsed(); printf("Lease available\n"); address = g_dhcp_client_get_address(dhcp_client); printf("address %s\n", address); if (address == NULL) return; option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET); for (list = option_value; list; list = list->next) printf("sub-mask %s\n", (char *) list->data); option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER); for (list = option_value; list; list = list->next) printf("domain-name-servers %s\n", (char *) list->data); option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME); for (list = option_value; list; list = list->next) printf("domain-name %s\n", (char *) list->data); option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER); for (list = option_value; list; list = list->next) printf("routers %s\n", (char *) list->data); option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME); for (list = option_value; list; list = list->next) printf("hostname %s\n", (char *) list->data); }
static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data) { print_elapsed(); printf("No lease available\n"); g_main_loop_quit(main_loop); }
spocp_result_t get_rules( srv_t *srv ) { spocp_result_t rc = SPOCP_SUCCESS; int nrules = 0, r; dbcmd_t dbc; struct timeval start, end; memset( &dbc, 0, sizeof( dbcmd_t )); dbc.dback = srv->dback; if (srv->dback) { /* * does the persistent database store need any initialization * ?? * if( srv.dback->init ) srv.dback->init( dbcmd_t *dbc ) * ; */ if ((nrules = dback_read_rules(&dbc, srv, &rc)) < 0) return rc; } if (nrules == 0) { if (srv->rulefile) { LOG(SPOCP_INFO) traceLog(LOG_INFO, "Opening rules file \"%s\"", srv->rulefile); if (0) gettimeofday(&start, NULL); /* dbc.dback = srv->dback; dbc.handle = 0; */ r = read_rules(srv, srv->rulefile, &dbc) ; if( r == -1 ) { LOG(SPOCP_ERR) traceLog(LOG_ERR,"Error while reading rules"); rc = SPOCP_OPERATIONSERROR; } if (0) { gettimeofday(&end, NULL); print_elapsed("readrule time:", start, end); } } else LOG(SPOCP_INFO) traceLog(LOG_INFO, "No rule file to start with"); } else { LOG(SPOCP_INFO) traceLog(LOG_INFO, "Got the rules from the persistent store, will not read the rulefile"); } return rc; }
int main() { int good_queens[] = {4, 1, 3, 5, 7, 2, 0, 6}; int bad_queens[] = {4, 3, 1, 5, 7, 2, 0, 6}; board good_board = new_board_from_queens(8, good_queens); board bad_board = new_board_from_queens(8, bad_queens); boards solutions, diagonals; int n; printf("==== print_board(good_board) ====\n"); print_board(good_board); printf("==== print_board_as_perm(good_board) ====\n"); print_board_as_perm(good_board); printf("==== valid_diagonals ====\n"); printf(" good board : %i \n", valid_diagonals(8, good_queens)); printf(" bad board : %i \n", valid_diagonals(8, bad_queens)); free_board(good_board); free_board(bad_board); printf("==== small n behavior ====\n"); for (n=0; n<4; n++){ printf(" n=%i : ", n); solutions = queens_search(n); print_boards_as_perms(solutions); free_boards(solutions); } printf("==== queens_search n=4 ====\n"); solutions = queens_search(4); print_boards(solutions); free_boards(solutions); printf("==== search n=8 ====\n"); solutions = queens_search(8); printf(" number of solutions = %i \n", solutions->count); free_boards(solutions); diagonals = queens_search_diagonals(8); printf(" number of queens_search_diagonals = %i \n", diagonals->count); free_boards(diagonals); diagonals = in_both_diagonals(solutions); // same, another way printf(" number of in_both_diagonals = %i \n", diagonals->count); free_boards(diagonals); printf("==== queens_search_diagonals for various n ====\n", n); for (n=4; n<15; n++){ reset_timer(); diagonals = queens_search_diagonals(n); printf(" n = %2i ; count = %7i ; time = ", n, diagonals->count); print_elapsed(); printf("\n"); fflush(stdout); free_boards(diagonals); } printf("=== memory check ===\n"); printf(" malloc() + calloc() - free() = %i \n\n", get_allocation_count()); return 0; }
void time_iterator(const dtable * table, size_t count, ATX_DEF) { struct timeval start; dtable::iter * iter = table->iterator(atx); printf("Iterate %zu time%s... ", count, (count == 1) ? "" : "s"); fflush(stdout); gettimeofday(&start, NULL); for(size_t i = 0; i < count; i++) { iter->first(); while(iter->valid()) { dtype key = iter->key(); dtype value = iter->value(); iter->next(); } } print_elapsed(&start); delete iter; }
int main(int argc, char *argv[]) { int arg; bool bm = false; char *buf; double busy; bool chook = false; bool client = false; char errnobuf[100]; char error_txt[200]; int event_len; char event_data[MS_MON_MAX_SYNC_DATA]; int ferr; int inx; int key; int lerr; int loop = 10; int msid; int pid; char prog[MS_MON_MAX_PROCESS_PATH]; struct rusage r_start; struct rusage r_stop; const char *server_name = "$SRV"; int server_nid; TPT_DECL (server_phandle); int server_pid; bool shook = false; struct timeval t_elapsed; struct timeval t_start; struct timeval t_stop; TAD zargs[] = { { "-bm", TA_Bool, TA_NOMAX, &bm }, { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-shook", TA_Bool, TA_NOMAX, &shook }, { "", TA_End, TA_NOMAX, NULL } }; ferr = msg_init(&argc, &argv); arg_proc_args(zargs, false, argc, argv); if (chook && client) test_debug_hook("c", "c"); if (shook && !client) test_debug_hook("s", "s"); util_test_start(client); ferr = msg_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); proc_enable_external_wakeups(); // allow external wakeups if (client) { ferr = msg_mon_get_process_info(NULL, &server_nid, &server_pid); TEST_CHK_FEOK(ferr); sprintf(prog, "%s/%s", getenv("PWD"), argv[0]); for (arg = 0; arg < argc; arg++) if (strcmp(argv[arg], "-client") == 0) // start_process argv[arg] = (char *) "-server"; ferr = msg_mon_start_process(prog, // prog (char *) server_name, // name NULL, // ret name argc, argv, TPT_REF(server_phandle), 0, // open NULL, // oid MS_ProcessType_Generic, // type 0, // priority 0, // debug 0, // backup &server_nid, // nid &server_pid, // pid NULL, // infile NULL); // outfile printf("process started, err=%d\n", ferr); TEST_CHK_FEOK(ferr); } util_gethostname(my_name, sizeof(my_name)); lerr = XWAIT(LREQ, -1); // remove first LREQ assert(lerr == LREQ); ferr = msg_mon_get_my_segid(&key); TEST_CHK_FEOK(ferr); // process-wait for client/server/shell ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, 3, NULL, false); TEST_CHK_FEOK(ferr); if (client) { ferr = msg_mon_event_wait(1, &event_len, event_data); TEST_CHK_FEOK(ferr); msid = shmget(key, sizeof(recv_buffer), 0640); if (msid == -1) { perror("client shmget"); sprintf(error_txt, "client shmget(%d)=%s\n", key, strerror_r(errno, errnobuf, sizeof(errnobuf))); } assert(msid != -1); buf = (char *) shmat(msid, NULL, 0); assert(buf != NULL); } else { msid = shmget(key, sizeof(recv_buffer), IPC_CREAT | 0640); if (msid == -1) { perror("server shmget"); sprintf(error_txt, "server shmget(%d)=%s\n", key, strerror_r(errno, errnobuf, sizeof(errnobuf))); } assert(msid != -1); buf = (char *) shmat(msid, NULL, 0); assert(buf != NULL); ferr = msg_mon_event_send(-1, // nid -1, // pid MS_ProcessType_Undefined, // process-type 1, // event-id 0, // event-len NULL); // event-data TEST_CHK_FEOK(ferr); ferr = msg_mon_event_wait(1, &event_len, event_data); TEST_CHK_FEOK(ferr); } util_time_timer_start(&t_start); util_cpu_timer_start(&r_start); if (client) { pid = server_pid; for (inx = 0; inx < loop; inx++) { lerr = XPROCESS_AWAKE_(pid, LREQ); assert(lerr == XZFIL_ERR_OK); lerr = XWAIT(LDONE, -1); assert(lerr == LDONE); } } else { ferr = msg_mon_get_process_info((char *) "$CLI", &server_nid, &pid); TEST_CHK_FEOK(ferr); for (inx = 0; inx < loop; inx++) { lerr = XWAIT(LREQ, -1); assert(lerr == LREQ); lerr = XPROCESS_AWAKE_(pid, LDONE); assert(lerr == XZFIL_ERR_OK); } } util_cpu_timer_stop(&r_stop); util_time_timer_stop(&t_stop); util_time_elapsed(&t_start, &t_stop, &t_elapsed); util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed, &busy); if (client) { if (!bm) print_elapsed("", &t_elapsed); print_rate(bm, "", loop, 1024, &t_elapsed, busy); } else print_server_busy(bm, "", busy); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
int main(int argc, char *argv[]) { int arg; char *argvn[100]; char argvna[100][200]; bool chook = false; bool client = false; int ferr; int linx; int loop = 1; char name[20]; int pid; bool server0 = false; bool server1 = false; bool server2 = false; char *server_name = (char *) "$SRV"; bool shook = false; int status; bool strace = false; struct timeval t_elapsed; struct timeval t_start; struct timeval t_stop; bool test[] = { true, true, true }; bool test0 = false; bool test1 = false; bool test2 = false; int tinx; int uerr; bool verbose = false; const char *who; TAD zargs[] = { { "-chook", TA_Bool, TA_NOMAX, &chook }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-server0", TA_Bool, TA_NOMAX, &server0 }, { "-server1", TA_Bool, TA_NOMAX, &server1 }, { "-server2", TA_Bool, TA_NOMAX, &server2 }, { "-shook", TA_Bool, TA_NOMAX, &shook }, { "-strace", TA_Bool, TA_NOMAX, &strace }, { "-test0", TA_Bool, TA_NOMAX, &test0 }, { "-test1", TA_Bool, TA_NOMAX, &test1 }, { "-test2", TA_Bool, TA_NOMAX, &test2 }, { "-v", TA_Bool, TA_NOMAX, &verbose }, { "", TA_End, TA_NOMAX, NULL } }; arg_proc_args(zargs, false, argc, argv); if (test0) { test[0] = true; test[1] = false; test[2] = false; } else if (test1) { test[0] = false; test[1] = true; test[2] = false; } else if (test2) { test[0] = false; test[1] = false; test[2] = true; } if (client) who = "cli"; else if (server0) who = "srv0"; else if (server1) who = "srv1"; else who = "srv2"; if (verbose) for (arg = 0; arg < argc; arg++) printf("%s: argv[%d]=%s\n", who, arg, argv[arg]); if (chook && client) test_debug_hook("c", "c"); if (shook && !client) test_debug_hook("s", "s"); if (client) { if (verbose) printf("%s: about to msg_init\n", who); ferr = msg_init(&argc, &argv); TEST_CHK_FEOK(ferr); } else if (server0) { if (verbose) printf("%s: about to msg_init_attach\n", who); ferr = msg_init_attach(&argc, &argv, false, server_name); TEST_CHK_FEOK(ferr); } else if (server1) { if (verbose) printf("%s: about to msg_init_attach\n", who); ferr = msg_test_enable_client_only(); TEST_CHK_FEOK(ferr); ferr = msg_init_attach(&argc, &argv, false, server_name); TEST_CHK_FEOK(ferr); } if (client) util_test_start(client); if (verbose) printf("%s: about to msg_mon_process_startup\n", who); if (client || server0 || server1) { ferr = msg_mon_process_startup(!client); // system messages TEST_CHK_FEOK(ferr); } if (client) { for (linx = 0; linx < loop; linx++) { for (tinx = 0; tinx < 3; tinx++) { if (!test[tinx]) continue; for (arg = 0; arg < argc; arg++) { if (strcmp(argv[arg], "-client") == 0) { // start_process sprintf(argvna[arg], "-server%d", tinx); argvn[arg] = argvna[arg]; } else argvn[arg] = argv[arg]; } argvn[arg] = NULL; if (strace) { sprintf(argvna[0], "xt172ms%d", tinx); argvn[0] = argvna[0]; } if (verbose) printf("%s: about to fork-exec\n", who); util_time_timer_start(&t_start); pid = fork(); switch (pid) { case 0: // child uerr = execvp(argvn[0], argvn); if (uerr == -1) perror("execvp"); exit(0); case -1: // parent perror("fork"); exit(1); default: // parent while (wait(&status) != pid) ; util_time_timer_stop(&t_stop); util_time_elapsed(&t_start, &t_stop, &t_elapsed); sprintf(name, " server%d", tinx); print_elapsed(name, &t_elapsed); } TEST_CHK_FEOK(ferr); } } } if (client || server0 || server1) { if (verbose) printf("%s: about to msg_mon_process_shutdown\n", who); ferr = msg_mon_process_shutdown(); TEST_CHK_FEOK(ferr); } if (client) { util_test_finish(client); util_time_timer_stop(&t_stop); util_time_elapsed(&t_start, &t_stop, &t_elapsed); print_elapsed(" client", &t_elapsed); } if (verbose) printf("%s: about to exit main\n", who); return 0; }
int main(int argc, char *argv[]) { bool bidir = false; bool bm = false; void *buf; double busy; _xcc_status cc; int count_read; int count_written; int count_xferred; int dsize = 1024; int ferr; short filenum[MAX_SERVERS]; short filenumr; int inx; int loop = 10; int max; int maxsp = 1; bool mq = false; bool nocopy = false; bool nowaitc = false; bool nowaits = false; int pinx; struct rusage r_start; struct rusage r_stop; char *recv_buffer_ptr; RI_Type ri; short sender_len; int sys_msg; struct timeval t_elapsed_data; struct timeval t_elapsed_open; struct timeval t_elapsed_total; struct timeval t_start_data; struct timeval t_start_total; struct timeval t_stop; SB_Tag_Type tag; short tfilenum; int timeout = -1; bool verbose = false; TAD zargs[] = { { "-bidir", TA_Bool, TA_NOMAX, &bidir }, { "-bm", TA_Bool, TA_NOMAX, &bm }, { "-client", TA_Bool, TA_NOMAX, &client }, { "-dsize", TA_Int, MAX_DBUF, &dsize }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-maxcp", TA_Int, MAX_CLIENTS, &maxcp }, { "-maxsp", TA_Int, MAX_SERVERS, &maxsp }, { "-mq", TA_Bool, TA_NOMAX, &mq }, { "-nocopy", TA_Bool, TA_NOMAX, &nocopy }, { "-nowaitc", TA_Bool, TA_NOMAX, &nowaitc }, { "-nowaits", TA_Bool, TA_NOMAX, &nowaits }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "", TA_End, TA_NOMAX, NULL } }; for (inx = 0; inx < MAX_CLIENTS; inx++) account[inx] = 0; signal(SIGUSR2, printaccount); ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); if (maxcp < 0) maxcp = 1; if (maxsp < 0) maxsp = 1; util_test_start(client); ferr = file_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); if (nocopy) { ferr = file_buf_register(buf_alloc, buf_free); TEST_CHK_FEOK(ferr); } ferr = msg_mon_get_my_process_name(my_name, BUFSIZ); TEST_CHK_FEOK(ferr); // process-wait for clients/servers/shell ferr = msfs_util_wait_process_count(MS_ProcessType_Generic, maxcp + maxsp + 1, NULL, verbose); if (client) sleep(1); util_time_timer_start(&t_start_total); if (client) { inx = atoi(&my_name[4]); printf("dsize=%d, loop=%d\n", dsize, loop); for (pinx = 0; pinx < maxsp; pinx++) { sprintf(serv, "$srv%d", pinx); ferr = BFILE_OPEN_(serv, (short) strlen(serv), &filenum[pinx], 0, 0, nowaitc ? (short) 1 : (short) 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); } util_time_timer_start(&t_start_data); util_cpu_timer_start(&r_start); util_time_elapsed(&t_start_total, &t_start_data, &t_elapsed_open); max = loop; for (inx = 0; inx < max; inx++) { for (pinx = 0; pinx < maxsp; pinx++) { if (pinx == 0) { if (verbose) printf("%s-count=%d\n", my_name, inx); else if (mq && ((inx % 1000) == 0)) printf("%s-count=%d\n", my_name, inx); } cc = BWRITEREADX(filenum[pinx], send_buffer, (int) dsize, // cast bidir ? dsize : 0, &count_read, 0); } for (pinx = 0; pinx < maxsp; pinx++) { if (nowaitc) { TEST_CHK_CCEQ(cc); tfilenum = filenum[pinx]; cc = BAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); TEST_CHK_CCEQ(cc); } } } } else { ferr = BFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr, 0, 0, nowaits ? (short) 1 : (short) 0, // nowait 1, 0, // sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); util_time_timer_start(&t_start_data); util_cpu_timer_start(&r_start); max = maxcp * loop; for (inx = 0; inx < max; inx++) { if (nocopy) { cc = file_buf_readupdatex(filenumr, &recv_buffer_ptr, &count_read, 0); buf_free(recv_buffer_ptr); } else cc = BREADUPDATEX(filenumr, recv_buffer, (int) dsize, // cast &count_read, 0); if (nowaits) { tfilenum = -1; cc = BAWAITIOX(&tfilenum, &buf, &count_xferred, &tag, timeout, NULL); // don't check cc - could be sys msg sys_msg = _xstatus_ne(cc); } else sys_msg = _xstatus_ne(cc); if (sys_msg) inx--; if (!sys_msg) { getri(&ri); ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(ri.sender), NULL, // cpu NULL, // pin NULL, // nodenumber NULL, // nodename 0, // nodename NULL, // nodename_length sender, sizeof(sender), &sender_len, NULL); // sequence_number TEST_CHK_FEOK(ferr); sender[sender_len] = 0; if (verbose) printf("sender=%s\n", sender); char *p = &sender[4]; // past $cli int sender_inx = atoi(p); account[sender_inx]++; } cc = BREPLYX(recv_buffer, bidir ? dsize : 0, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); } } util_cpu_timer_stop(&r_stop); util_time_timer_stop(&t_stop); util_time_elapsed(&t_start_total, &t_stop, &t_elapsed_total); util_time_elapsed(&t_start_data, &t_stop, &t_elapsed_data); util_cpu_timer_busy(&r_start, &r_stop, &t_elapsed_data, &busy); if (client) { if (!bm) { print_elapsed("", &t_elapsed_total); print_elapsed(" (data)", &t_elapsed_data); print_elapsed(" (open)", &t_elapsed_open); } print_rate(bm, "", bidir ? 2 * loop : loop, dsize, &t_elapsed_data, busy); } else print_server_busy(bm, "", busy); if (client) { for (pinx = 0; pinx < maxsp; pinx++) { ferr = BFILE_CLOSE_(filenum[pinx], 0); TEST_CHK_FEOK(ferr); } } else { ferr = BFILE_CLOSE_(filenumr, 0); TEST_CHK_FEOK(ferr); ferr = file_mon_process_close(); TEST_CHK_FEOK(ferr); } ferr = file_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); printaccount(0); return 0; }
int main(int argc, char **argv) { int debug = 0, conftest = 0, nodaemon = 0; int i = 0; unsigned int clilen; struct sockaddr_in cliaddr; struct timeval start, end; char *cnfg = DEF_CNFG; char localhost[MAXNAMLEN + 1], path[MAXNAMLEN + 1]; FILE *pidfp; octet_t oct; ruleset_t *rs; /* * Who am I running as ? */ uname(&myname); /* * spocp_err = 0 ; */ memset(&srv, 0, sizeof(srv_t)); pthread_mutex_init(&(srv.mutex), NULL); pthread_mutex_init(&(srv.mlock), NULL); gethostname(localhost, MAXNAMLEN); #ifdef HAVE_GETDOMAINNAME getdomainname(path, MAXNAMLEN); #else { char *pos; if(pos = strstr(localhost, ".")) strncpy(path, pos+1, MAXNAMLEN); else strcpy(path, ""); } #endif if (0) printf("Domain: %s\n", path); srv.hostname = Strdup(localhost); /* * truncating input strings to reasonable length */ for (i = 0; i < argc; i++) if (strlen(argv[i]) > 512) argv[i][512] = '\0'; while ((i = getopt(argc, argv, "Dhrtf:d:")) != EOF) { switch (i) { case 'D': nodaemon = 1; break; case 'f': cnfg = Strdup(optarg); break; case 'd': debug = atoi(optarg); if (debug < 0) debug = 0; break; case 't': conftest = 1; break; case 'r': srv.readonly = 1; case 'h': default: fprintf(stderr, "Usage: %s [-t] ", argv[0]); fprintf(stderr, "[-f configfile] "); fprintf(stderr, "[-D] [-d debuglevel]\n"); exit(0); } } srv.root = ruleset_new(0); if (srv_init(&srv, cnfg) < 0) exit(1); if (srv.port && srv.uds) { fprintf(stderr, "Sorry are not allowed to listen on both a unix domain socket and a port\n"); exit(1); } if (srv.logfile) spocp_open_log(srv.logfile, debug); else if (debug) spocp_open_log(0, debug); if (srv.name){ localcontext = (char *) Calloc(strlen(srv.name) + strlen("//") + 1, sizeof(char)); /* Flawfinder: ignore */ sprintf(localcontext, "//%s", srv.name); } else { localcontext = (char *) Calloc(strlen(localhost) + strlen("//") + 1, sizeof(char)); /* Flawfinder: ignore */ sprintf(localcontext, "//%s", localhost); } /* * where I put the access rules for access to this server and its * rules */ snprintf(path, MAXNAMLEN, "%s/server", localcontext); oct_assign(&oct, path); if ((rs = ruleset_create(&oct, srv.root)) == 0) exit(1); rs->db = db_new(); /* * access rules for operations */ snprintf(path, MAXNAMLEN, "%s/operation", localcontext); oct_assign(&oct, path); if ((rs = ruleset_create(&oct, srv.root)) == 0) exit(1); rs->db = db_new(); LOG(SPOCP_INFO) { traceLog(LOG_INFO, "Local context: \"%s\"", localcontext); traceLog(LOG_INFO, "initializing backends"); if (srv.root->db) plugin_display(srv.plugin); } if (srv.plugin) { run_plugin_init(&srv); } if ( get_rules( &srv ) != SPOCP_SUCCESS ) exit(1); /*ruleset_tree( srv.root, 0);*/ /* If only testing configuration and rulefile this is as far as I go */ if (conftest) { traceLog(LOG_INFO,"Configuration was OK"); exit(0); } gettimeofday(&start, NULL); if (srv.port || srv.uds) { /* * stdin and stdout will not be used from here on, close to * save file descriptors */ fclose(stdin); fclose(stdout); #ifdef HAVE_SSL /* * ---------------------------------------------------------- */ /* * build our SSL context, whether it will ever be used or not */ /* * mutex'es for openSSL to use */ THREAD_setup(); if (srv.certificateFile && srv.privateKey && srv.caList) { traceLog(LOG_INFO,"Initializing the TLS/SSL environment"); if (!(srv.ctx = tls_init(&srv))) { return FALSE; } } /* * ---------------------------------------------------------- */ #endif #ifdef HAVE_SASL { int r = sasl_server_init(sasl_cb, "spocp"); if (r != SASL_OK) { traceLog( LOG_ERR, "Unable to initialized SASL library: %s", sasl_errstring(r, NULL, NULL)); return FALSE; } } #endif saci_init(); if( nodaemon == 0 ) { #ifdef HAVE_DAEMON if (daemon(1, 1) < 0) { fprintf(stderr, "couldn't go daemon\n"); exit(1); } #else daemon_init("spocp", 0); #endif } if (srv.pidfile) { /* * Write the PID file. */ pidfp = fopen(srv.pidfile, "w"); if (pidfp == (FILE *) 0) { fprintf(stderr, "Couldn't open pidfile \"%s\"\n", srv.pidfile); exit(1); } fprintf(pidfp, "%d\n", (int) getpid()); fclose(pidfp); } if (srv.port) { LOG(SPOCP_INFO) traceLog( LOG_INFO, "Asked to listen on port %d", srv.port); if ((srv.listen_fd = spocp_stream_socket(srv.port)) < 0) exit(1); srv.id = (char *) Malloc(16); sprintf(srv.id, "spocp-%d", srv.port); srv.type = AF_INET; } else { LOG(SPOCP_INFO) traceLog(LOG_INFO,"Asked to listen on unix domain socket"); if ((srv.listen_fd = spocp_unix_domain_socket(srv.uds)) < 0) exit(1); srv.id = (char *) Malloc(7 + strlen(srv.uds)); /* Flawfinder: ignore */ sprintf(srv.id, "spocp-%s", srv.uds); srv.type = AF_UNIX; } xsignal(SIGCHLD, sig_chld); xsignal(SIGPIPE, sig_pipe); xsignal(SIGINT, sig_int); xsignal(SIGTERM, sig_term); xsignal(SIGUSR1, sig_usr1); clilen = sizeof(cliaddr); DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"Creating threads"); /* * returns the pool the threads are picking work from */ srv.work = tpool_init(srv.threads, 64, 1); spocp_srv_run(&srv); } else { conn_t *conn; saci_init(); DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"---->"); LOG(SPOCP_INFO) traceLog(LOG_INFO,"Reading STDIN"); /* * If I want to use this I have to do init_server() first * conn = spocp_open_connection( STDIN_FILENO, &srv ) ; */ /* * this is much simpler */ conn = conn_new(); conn_setup(conn, &srv, STDIN_FILENO, "localhost", "127.0.0.1"); LOG(SPOCP_INFO) traceLog(LOG_INFO,"Running server"); spocp_server((void *) conn); gettimeofday(&end, NULL); print_elapsed("query time:", start, end); conn_free( conn ); } srv_free( &srv ); if (cnfg != DEF_CNFG) Free( cnfg ); exit(0); }
int main(int argc, char *argv[]) { _xcc_status cc; bool client = false; unsigned short count_read; unsigned short count_written; int ferr; short filenumr; short filenums[MAXSRV]; int inxl; int inxs; int loop = 10; int maxsp = 2; bool verbose = false; xzsys_ddl_smsg_def *sys_msg = (xzsys_ddl_smsg_def *) recv_buffer; struct timeval t_elapsed_close; struct timeval t_elapsed_closem1; struct timeval t_elapsed_open; struct timeval t_elapsed_openm1; struct timeval t_start_close; struct timeval t_start_closem1; struct timeval t_start_open; struct timeval t_start_openm1; struct timeval t_stop_close; struct timeval t_stop_closem1; struct timeval t_stop_open; struct timeval t_stop_openm1; TAD zargs[] = { { "-client", TA_Bool, TA_NOMAX, &client }, { "-loop", TA_Int, TA_NOMAX, &loop }, { "-maxsp", TA_Int, MAXSRV, &maxsp }, { "-server", TA_Ign, TA_NOMAX, NULL }, { "-v", TA_Bool, TA_NOMAX, &verbose }, { "", TA_End, TA_NOMAX, NULL } }; ferr = file_init(&argc, &argv); TEST_CHK_FEOK(ferr); msfs_util_init_fs(&argc, &argv, file_debug_hook); arg_proc_args(zargs, false, argc, argv); util_test_start(client); ferr = file_mon_process_startup(!client); // system messages? TEST_CHK_FEOK(ferr); if (client) { util_time_timer_start(&t_start_open); for (inxs = 0; inxs < maxsp; inxs++) { ferr = XFILE_OPEN_((char *) "$srv", 4, &filenums[inxs], 0, 0, 0, 0, 0, 0, 0, NULL); TEST_CHK_FEOK(ferr); if (inxs == 0) util_time_timer_start(&t_start_openm1); } util_time_timer_stop(&t_stop_open); util_time_timer_stop(&t_stop_openm1); for (inxs = 0; inxs < maxsp; inxs++) { for (inxl = 0; inxl < loop; inxl++) { sprintf(send_buffer, "hello, greetings %d from %s, inx=%d", inxs, my_name, inxl); cc = XWRITEREADX(filenums[inxs], send_buffer, (unsigned short) (strlen(send_buffer) + 1), // cast BUFSIZ, &count_read, 0); TEST_CHK_CCEQ(cc); printf("%s\n", send_buffer); } } util_time_timer_start(&t_start_close); util_time_timer_start(&t_start_closem1); for (inxs = 0; inxs < maxsp; inxs++) { if (inxs == (maxsp - 1)) util_time_timer_stop(&t_stop_closem1); ferr = XFILE_CLOSE_(filenums[inxs], 0); TEST_CHK_FEOK(ferr); } util_time_timer_stop(&t_stop_close); util_time_elapsed(&t_start_open, &t_stop_open, &t_elapsed_open); util_time_elapsed(&t_start_openm1, &t_stop_openm1, &t_elapsed_openm1); util_time_elapsed(&t_start_close, &t_stop_close, &t_elapsed_close); util_time_elapsed(&t_start_closem1, &t_stop_closem1, &t_elapsed_closem1); print_elapsed(" (open)", &t_elapsed_open); print_elapsed(" (open-1st)", &t_elapsed_openm1); print_elapsed(" (close)", &t_elapsed_close); print_elapsed(" (close-lst)", &t_elapsed_closem1); } else { ferr = XFILE_OPEN_((char *) "$RECEIVE", 8, &filenumr, 0, 0, 0, 1, 0, // sys msg 0, 0, NULL); TEST_CHK_FEOK(ferr); // process opens for (inxs = 0; inxs < maxsp; inxs++) { cc = XREADUPDATEX(filenumr, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCNE(cc); if (verbose) { int mt = sys_msg->u_z_msg.z_msgnumber[0]; printf("inx=%d, type=%d\n", inxs, mt); } cc = XREPLYX(recv_buffer, 0, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); } for (inxs = 0; inxs < maxsp; inxs++) { for (inxl = 0; inxl < loop; inxl++) { cc = XREADUPDATEX(filenumr, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCEQ(cc); strcat(recv_buffer, "- reply from "); strcat(recv_buffer, my_name); count_read = (unsigned short) (strlen(recv_buffer) + 1); // cast cc = XREPLYX(recv_buffer, count_read, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); } } // process closes for (inxs = 0; inxs < maxsp; inxs++) { cc = XREADUPDATEX(filenumr, recv_buffer, BUFSIZ, &count_read, 0); TEST_CHK_CCNE(cc); if (verbose) { int mt = sys_msg->u_z_msg.z_msgnumber[0]; printf("inx=%d, type=%d\n", inxs, mt); } cc = XREPLYX(recv_buffer, 0, &count_written, 0, XZFIL_ERR_OK); TEST_CHK_CCEQ(cc); } ferr = XFILE_CLOSE_(filenumr, 0); TEST_CHK_FEOK(ferr); } ferr = file_mon_process_shutdown(); TEST_CHK_FEOK(ferr); util_test_finish(client); return 0; }
void print_elapsed(const struct timeval * start, bool elapsed) { struct timeval end; gettimeofday(&end, NULL); print_elapsed(start, &end, elapsed); }
/*============================================================== * Main Program *==============================================================*/ int main(int argc, char *argv[]) { int numints = 0; int numiterations = 0; FILE *fp; int* data = NULL; long* partial_sums = NULL; long sum_int; long total_sum = 0; struct timeval start, end; /* gettimeofday stuff */ struct timezone tzp; if( argc < 3) { printf("Usage: %s [numints] [numiterations]\n\n", argv[0]); exit(1); } numints = atoi(argv[1]); numiterations = atoi(argv[2]); //printf("\nExecuting %s: nthreads=%d, numints=%d, numiterations=%d\n", //argv[0], omp_get_max_threads(), numints, numiterations); /* Allocate shared memory, enough for each thread to have numints*/ data = (int *) malloc(sizeof(int) * numints); /* Allocate shared memory for partial_sums */ partial_sums = (long *) malloc(sizeof(long) * numints ); //partial_sums_f = (long *) malloc(sizeof(long) * numints ); /***************************************************** * Generate the random ints in parallel * *****************************************************/ int i=0; srand(i + time(NULL)); for(i = 0; i < numints; ++i) { data[i] = rand()/10000; } int iterations; gettimeofday(&start, &tzp); // time point from where the actual calculation begins for (iterations=0;iterations<numiterations;iterations++) { sum_int=0; for(i=0; i< numints; i++){ sum_int = sum_int+data[i]; partial_sums[i] = sum_int; } } gettimeofday(&end, &tzp); // time point from where the actual calculation begins print_elapsed("Summation", &start, &end, numiterations); free(data); free(partial_sums); return(0); }
int main(int argc, char *argv[]) { FILE *fd = NULL; Tstate prev_state; char filename[256]; time_t rstart, rend, tnow; struct tm tm; char tag[32] = "default"; char *home = getenv("HOME"); // check for explicit tag name if (argc > 2 && argv[1][1] == 't') { strncpy(tag, argv[2], sizeof(tag)); argc -= 2; argv += 2; } if (argc < 2) { printf("usage: %s", usage); exit(EXIT_SUCCESS); } snprintf(filename, sizeof(filename), "%s/.wtimed/%s", home, tag); if ((fd = fopen(filename, "r+")) == NULL) { if ((fd = fopen(filename, "w+")) == NULL) { fprintf(stderr, "Error while opening data file '%s'.\n", filename); exit(EXIT_FAILURE); } } if (argv[1][0] != '-') { fprintf(stderr, "Unknown parameter: %s\n", argv[1]); } else { if ((prev_state = cur_state(fd)) == UNKNOWN) { fprintf(stderr, "Corrupted data file '%s'.\n", filename); exit(EXIT_FAILURE); } switch (argv[1][1]) { case 'h': printf("usage: %s", usage); break; case 'a': if (prev_state == STARTED) fprintf(stderr, "We are allready counting.\n"); else start_counting(fd); break; case 's': if (prev_state != STARTED) fprintf(stderr, "We are not counting.\n"); else stop_counting(fd); break; case 'r': if (argc == 4) { // end if (strptime(argv[3], "%d-%m-%Y", &tm) == NULL) { fprintf(stderr, "Malformated end date\n"); exit(EXIT_FAILURE); } tm.tm_min = tm.tm_sec = 59; tm.tm_hour = 23; rend = mktime(&tm); } else { rend = time(NULL); } if (argc >= 3) { // start if (strptime(argv[2], "%d-%m-%Y", &tm) == NULL) { fprintf(stderr, "Malformated start date\n"); exit(EXIT_FAILURE); } tm.tm_sec = tm.tm_min = tm.tm_hour = 0; rstart = mktime(&tm); } else { // beginning of month tnow = time(NULL); tm = *localtime(&tnow); tm.tm_mday = 1; tm.tm_sec = tm.tm_min = tm.tm_hour = 0; rstart = mktime(&tm); } if (rstart > rend) { fprintf(stderr, "Start date is further then end date.\n"); exit(EXIT_FAILURE); } print_report(fd, rstart, rend); break; case 'c': if (prev_state != STARTED) { fprintf(stderr, "We are not counting.\n"); exit(EXIT_FAILURE); } else print_elapsed(fd); break; default: fprintf(stderr, "Unknown parameter: %s\n", argv[1]); break; } } if (fd) fclose(fd); return (0); }