static void mac_bench(int algo, int size) { void *_key; int blocksize = gnutls_hmac_get_len(algo); int step = size * 1024; struct benchmark_st st; _key = malloc(blocksize); if (_key == NULL) return; memset(_key, 0xf0, blocksize); printf("%16s ", gnutls_mac_get_name(algo)); fflush(stdout); start_benchmark(&st); do { gnutls_hmac_fast(algo, _key, blocksize, data, step, _key); st.size += step; } while (benchmark_must_finish == 0); stop_benchmark(&st, NULL, 1); free(_key); }
static void cipher_bench(int algo, int size, int aead) { int ret; gnutls_cipher_hd_t ctx; void *_key, *_iv; gnutls_datum_t key, iv; int ivsize = gnutls_cipher_get_iv_size(algo); int keysize = gnutls_cipher_get_key_size(algo); int step = size * 1024; struct benchmark_st st; _key = malloc(keysize); if (_key == NULL) return; memset(_key, 0xf0, keysize); _iv = malloc(ivsize); if (_iv == NULL) return; memset(_iv, 0xf0, ivsize); iv.data = _iv; if (aead) iv.size = 12; else iv.size = ivsize; key.data = _key; key.size = keysize; printf("%16s ", gnutls_cipher_get_name(algo)); fflush(stdout); start_benchmark(&st); ret = gnutls_cipher_init(&ctx, algo, &key, &iv); if (ret < 0) { fprintf(stderr, "error: %s\n", gnutls_strerror(ret)); goto leave; } if (aead) gnutls_cipher_add_auth(ctx, data, 1024); do { gnutls_cipher_encrypt2(ctx, data, step, data, step + 64); st.size += step; } while (benchmark_must_finish == 0); gnutls_cipher_deinit(ctx); stop_benchmark(&st, NULL, 1); leave: free(_key); free(_iv); }
int IPCohort::start_server () { IPCohortContext ctx; char temp_char; TEST_NZ (establish_tcp_connection(TRX_MANAGER_ADDR.c_str(), TRX_MANAGER_TCP_PORT, &ctx.sockfd)); TEST_NZ (ctx.create_context()); srand (time(NULL)); // initialize random seed start_benchmark(ctx); /* Sync so server will know that client is done mucking with its memory */ DEBUG_COUT("[Info] Cohort client is done, and is ready to destroy its resources!"); TEST_NZ (sock_sync_data (ctx.sockfd, 1, "W", &temp_char)); /* just send a dummy char back and forth */ TEST_NZ(ctx.destroy_context()); }
int Coordinator::start () { CoordinatorContext ctx[SERVER_CNT]; struct sockaddr_in returned_addr; socklen_t len = sizeof(returned_addr); char temp_char; srand (generate_random_seed()); // initialize random seed // Call socket(), bind() and listen() TEST_NZ (server_socket_setup(&server_sockfd, SERVER_CNT)); // accept connections from Cohorts std::cout << "[Info] Waiting for " << SERVER_CNT << " cohort(s) on port " << TRX_MANAGER_TCP_PORT << std::endl; for (int s = 0; s < SERVER_CNT; s++) { ctx[s].sockfd = accept (server_sockfd, (struct sockaddr *) &returned_addr, &len); if (ctx[s].sockfd < 0){ std::cerr << "ERROR on accept() for RM #" << s << std::endl; return -1; } std::cout << "[Conn] Received Cohort #" << s << " on sock " << ctx[s].sockfd << std::endl; // create all resources ctx[s].ib_port = TRX_MANAGER_IB_PORT; TEST_NZ (ctx[s].create_context()); DEBUG_COUT("[Info] Context for cohort " << s << " created"); // connect the QPs TEST_NZ (RDMACommon::connect_qp (&(ctx[s].qp), ctx[s].ib_port, ctx[s].port_attr.lid, ctx[s].sockfd)); DEBUG_COUT("[Conn] QPed to cohort " << s); } std::cout << "[Info] Established connection to all " << SERVER_CNT << " resource-manager(s)." << std::endl; start_benchmark(ctx); DEBUG_COUT("[Info] Coordinator is done, and is ready to destroy its resources!"); for (int i = 0; i < SERVER_CNT; i++) { TEST_NZ (sock_sync_data (ctx[i].sockfd, 1, "W", &temp_char)); /* just send a dummy char back and forth */ DEBUG_COUT("[Conn] Notified cohort " << i << " it's done"); TEST_NZ ( ctx[i].destroy_context()); } }
int main (void) { int i = 10; int * p; GPIO_InitTypeDef GPIO_init; RCC_Configuration(); usart_init(230400); /* Enable GPIOA clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); GPIO_init.GPIO_Pin = GPIO_Pin_2; GPIO_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_init.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_init); GPIO_init.GPIO_Pin = GPIO_Pin_3; GPIO_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_init.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_init); GPIO_init.GPIO_Pin = GPIO_Pin_0; GPIO_init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_init.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOA, &GPIO_init); //SysTick_Config(16000000); for(;;) { GPIO_SetBits(GPIOA, GPIO_Pin_2); start_benchmark(); } return 0; }
static int run_test(int nthreads) { struct benchmark_data * bdata = start_benchmark(); struct thread_pool * threadpool = thread_pool_new(nthreads); struct arg2 args = { .a = 20, .b = 22, }; struct future * sum = thread_pool_submit(threadpool, (fork_join_task_t) adder_task, &args); uintptr_t ssum = (uintptr_t) future_get(sum); future_free(sum); thread_pool_shutdown_and_destroy(threadpool); stop_benchmark(bdata); // consistency check if (ssum != 42) { fprintf(stderr, "Wrong result, expected 42, got %ld\n", ssum); abort(); } report_benchmark_results(bdata); printf("Test successful.\n"); free(bdata); return 0; } /**********************************************************************************/ static void usage(char *av0, int exvalue) { fprintf(stderr, "Usage: %s [-n <n>]\n" " -n number of threads in pool, default %d\n" , av0, DEFAULT_THREADS); exit(exvalue); }
static void mac_bench(int algo, int size) { void *_key; int blocksize = gnutls_hmac_get_len(algo); int step = size * 1024; struct benchmark_st st; void *input; unsigned char c, *i; ALLOCM(input, MAX_MEM); i = input; _key = malloc(blocksize); if (_key == NULL) return; memset(_key, 0xf0, blocksize); printf("%16s ", gnutls_mac_get_name(algo)); fflush(stdout); assert(gnutls_rnd(GNUTLS_RND_NONCE, &c, 1) >= 0); start_benchmark(&st); do { gnutls_hmac_fast(algo, _key, blocksize, i, step, _key); st.size += step; INC(input, i, step); } while (benchmark_must_finish == 0); stop_benchmark(&st, NULL, 1); FREE(input); free(_key); }
static void cipher_bench(int algo, int size, int aead) { int ret; gnutls_cipher_hd_t ctx; void *_key, *_iv; gnutls_aead_cipher_hd_t actx; gnutls_datum_t key, iv; int ivsize = gnutls_cipher_get_iv_size(algo); int keysize = gnutls_cipher_get_key_size(algo); int step = size * 1024; void *input, *output; struct benchmark_st st; unsigned char c, *i; _key = malloc(keysize); if (_key == NULL) return; memset(_key, 0xf0, keysize); _iv = malloc(ivsize); if (_iv == NULL) { free(_key); return; } memset(_iv, 0xf0, ivsize); iv.data = _iv; iv.size = ivsize; key.data = _key; key.size = keysize; printf("%24s ", gnutls_cipher_get_name(algo)); fflush(stdout); assert(gnutls_rnd(GNUTLS_RND_NONCE, &c, 1) >= 0); ALLOCM(input, MAX_MEM); ALLOCM(output, step+64); i = input; start_benchmark(&st); if (algo == GNUTLS_CIPHER_NULL) { do { force_memcpy(output, i, step); st.size += step; INC(input, i, step); } while (benchmark_must_finish == 0); } else if (aead != 0) { unsigned tag_size = gnutls_cipher_get_tag_size(algo); size_t out_size; ret = gnutls_aead_cipher_init(&actx, algo, &key); if (ret < 0) { fprintf(stderr, "error: %s\n", gnutls_strerror(ret)); goto leave; } do { out_size = step+64; assert(gnutls_aead_cipher_encrypt(actx, iv.data, iv.size, NULL, 0, tag_size, i, step, output, &out_size) >= 0); st.size += step; INC(input, i, step); } while (benchmark_must_finish == 0); gnutls_aead_cipher_deinit(actx); } else { ret = gnutls_cipher_init(&ctx, algo, &key, &iv); if (ret < 0) { fprintf(stderr, "error: %s\n", gnutls_strerror(ret)); goto leave; } do { gnutls_cipher_encrypt2(ctx, i, step, output, step + 64); st.size += step; INC(input, i, step); } while (benchmark_must_finish == 0); gnutls_cipher_deinit(ctx); } stop_benchmark(&st, NULL, 1); FREE(input); FREE(output); leave: free(_key); free(_iv); }
int main(int argc, char **argv) { int c; int option_index = 0; struct config *config = NULL; config = prepare_default_config(); if (config == NULL) return EXIT_FAILURE; while (1) { c = getopt_long (argc, argv, "hg:o:s:l:vc:p:f:n:r:x:y:", long_options, &option_index); if (c == -1) break; switch (c) { case 'o': if (config->output != NULL) fclose(config->output); config->output = prepare_output(optarg); if (config->output == NULL) return EXIT_FAILURE; dprintf("user output path -> %s\n", optarg); break; case 's': sscanf(optarg, "%li", &config->sleep); dprintf("user sleep time -> %s\n", optarg); break; case 'l': sscanf(optarg, "%li", &config->load); dprintf("user load time -> %s\n", optarg); break; case 'c': sscanf(optarg, "%u", &config->cpu); dprintf("user cpu -> %s\n", optarg); break; case 'g': strncpy(config->governor, optarg, 14); dprintf("user governor -> %s\n", optarg); break; case 'p': if (string_to_prio(optarg) != SCHED_ERR) { config->prio = string_to_prio(optarg); dprintf("user prio -> %s\n", optarg); } else { if (config != NULL) { if (config->output != NULL) fclose(config->output); free(config); } usage(); } break; case 'n': sscanf(optarg, "%u", &config->cycles); dprintf("user cycles -> %s\n", optarg); break; case 'r': sscanf(optarg, "%u", &config->rounds); dprintf("user rounds -> %s\n", optarg); break; case 'x': sscanf(optarg, "%li", &config->load_step); dprintf("user load_step -> %s\n", optarg); break; case 'y': sscanf(optarg, "%li", &config->sleep_step); dprintf("user sleep_step -> %s\n", optarg); break; case 'f': if (prepare_config(optarg, config)) return EXIT_FAILURE; break; case 'v': config->verbose = 1; dprintf("verbose output enabled\n"); break; case 'h': case '?': default: if (config != NULL) { if (config->output != NULL) fclose(config->output); free(config); } usage(); } } if (config->verbose) { printf("starting benchmark with parameters:\n"); printf("config:\n\t" "sleep=%li\n\t" "load=%li\n\t" "sleep_step=%li\n\t" "load_step=%li\n\t" "cpu=%u\n\t" "cycles=%u\n\t" "rounds=%u\n\t" "governor=%s\n\n", config->sleep, config->load, config->sleep_step, config->load_step, config->cpu, config->cycles, config->rounds, config->governor); } prepare_user(config); prepare_system(config); start_benchmark(config); if (config->output != stdout) fclose(config->output); free(config); return EXIT_SUCCESS; }
static void test_ciphersuite_kx(const char *cipher_prio) { /* Server stuff. */ gnutls_anon_server_credentials_t s_anoncred; const gnutls_datum_t p3 = { (char *) pkcs3, strlen(pkcs3) }; static gnutls_dh_params_t dh_params; gnutls_session_t server; int sret, cret; const char *str; const char *suite = NULL; /* Client stuff. */ gnutls_anon_client_credentials_t c_anoncred; gnutls_session_t client; /* Need to enable anonymous KX specifically. */ int ret; struct benchmark_st st; /* Init server */ gnutls_anon_allocate_server_credentials(&s_anoncred); gnutls_dh_params_init(&dh_params); gnutls_dh_params_import_pkcs3(dh_params, &p3, GNUTLS_X509_FMT_PEM); gnutls_anon_set_server_dh_params(s_anoncred, dh_params); start_benchmark(&st); do { gnutls_init(&server, GNUTLS_SERVER); ret = gnutls_priority_set_direct(server, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(server, GNUTLS_CRD_ANON, s_anoncred); gnutls_transport_set_push_function(server, server_push); gnutls_transport_set_pull_function(server, server_pull); gnutls_transport_set_ptr(server, (gnutls_transport_ptr_t) server); reset_buffers(); /* Init client */ gnutls_anon_allocate_client_credentials(&c_anoncred); gnutls_init(&client, GNUTLS_CLIENT); ret = gnutls_priority_set_direct(client, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(client, GNUTLS_CRD_ANON, c_anoncred); gnutls_transport_set_push_function(client, client_push); gnutls_transport_set_pull_function(client, client_pull); gnutls_transport_set_ptr(client, (gnutls_transport_ptr_t) client); HANDSHAKE(client, server); if (suite == NULL) suite = gnutls_cipher_suite_get_name(gnutls_kx_get(server), gnutls_cipher_get(server), gnutls_mac_get(server)); gnutls_deinit(client); gnutls_deinit(server); st.size += 1; } while (benchmark_must_finish == 0); fprintf(stdout, "Tested %s: ", suite); stop_benchmark(&st, "transactions"); gnutls_anon_free_client_credentials(c_anoncred); gnutls_anon_free_server_credentials(s_anoncred); gnutls_dh_params_deinit(dh_params); }
static void test_ciphersuite_kx(const char *cipher_prio, unsigned pk) { /* Server stuff. */ gnutls_anon_server_credentials_t s_anoncred; gnutls_session_t server; int sret, cret; const char *str; char *suite = NULL; /* Client stuff. */ gnutls_anon_client_credentials_t c_anoncred; gnutls_certificate_credentials_t c_certcred, s_certcred; gnutls_session_t client; /* Need to enable anonymous KX specifically. */ int ret; struct benchmark_st st; struct timespec tr_start, tr_stop; double avg, sstddev; gnutls_priority_t priority_cache; total_diffs_size = 0; /* Init server */ gnutls_certificate_allocate_credentials(&s_certcred); gnutls_anon_allocate_server_credentials(&s_anoncred); ret = 0; if (pk == GNUTLS_PK_RSA_PSS) ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_rsa_pss_cert, &server_key, GNUTLS_X509_FMT_PEM); else if (pk == GNUTLS_PK_RSA) ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_cert, &server_key, GNUTLS_X509_FMT_PEM); if (ret < 0) { fprintf(stderr, "Error in %d: %s\n", __LINE__, gnutls_strerror(ret)); exit(1); } ret = 0; if (pk == GNUTLS_PK_ECDSA) ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_ecc_cert, &server_ecc_key, GNUTLS_X509_FMT_PEM); else if (pk == GNUTLS_PK_EDDSA_ED25519) ret = gnutls_certificate_set_x509_key_mem(s_certcred, &server_ed25519_cert, &server_ed25519_key, GNUTLS_X509_FMT_PEM); if (ret < 0) { fprintf(stderr, "Error in %d: %s\n", __LINE__, gnutls_strerror(ret)); exit(1); } /* Init client */ gnutls_anon_allocate_client_credentials(&c_anoncred); gnutls_certificate_allocate_credentials(&c_certcred); start_benchmark(&st); ret = gnutls_priority_init(&priority_cache, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } do { gnutls_init(&server, GNUTLS_SERVER); ret = gnutls_priority_set(server, priority_cache); if (ret < 0) { fprintf(stderr, "Error in setting priority: %s\n", gnutls_strerror(ret)); exit(1); } gnutls_credentials_set(server, GNUTLS_CRD_ANON, s_anoncred); gnutls_credentials_set(server, GNUTLS_CRD_CERTIFICATE, s_certcred); gnutls_transport_set_push_function(server, server_push); gnutls_transport_set_pull_function(server, server_pull); gnutls_transport_set_ptr(server, (gnutls_transport_ptr_t) server); reset_buffers(); gnutls_init(&client, GNUTLS_CLIENT); ret = gnutls_priority_set(client, priority_cache); if (ret < 0) { fprintf(stderr, "Error in setting priority: %s\n", gnutls_strerror(ret)); exit(1); } gnutls_credentials_set(client, GNUTLS_CRD_ANON, c_anoncred); gnutls_credentials_set(client, GNUTLS_CRD_CERTIFICATE, c_certcred); gnutls_transport_set_push_function(client, client_push); gnutls_transport_set_pull_function(client, client_pull); gnutls_transport_set_ptr(client, (gnutls_transport_ptr_t) client); gettime(&tr_start); HANDSHAKE(client, server); gettime(&tr_stop); if (suite == NULL) suite = gnutls_session_get_desc(server); gnutls_deinit(client); gnutls_deinit(server); total_diffs[total_diffs_size++] = timespec_sub_ms(&tr_stop, &tr_start); if (total_diffs_size > sizeof(total_diffs)/sizeof(total_diffs[0])) abort(); st.size += 1; } while (benchmark_must_finish == 0); fprintf(stdout, "%38s ", suite); gnutls_free(suite); stop_benchmark(&st, "transactions", 1); gnutls_priority_deinit(priority_cache); avg = calc_avg(total_diffs, total_diffs_size); sstddev = calc_sstdev(total_diffs, total_diffs_size, avg); printf("%32s %.2f ms, sample variance: %.2f)\n", "(avg. handshake time:", avg, sstddev); gnutls_anon_free_client_credentials(c_anoncred); gnutls_anon_free_server_credentials(s_anoncred); }
static void test_ciphersuite(const char *cipher_prio, int size) { /* Server stuff. */ gnutls_anon_server_credentials_t s_anoncred; gnutls_certificate_credentials_t c_certcred, s_certcred; gnutls_session_t server; int sret, cret; const char *str; /* Client stuff. */ gnutls_anon_client_credentials_t c_anoncred; gnutls_session_t client; /* Need to enable anonymous KX specifically. */ int ret; struct benchmark_st st; gnutls_packet_t packet; const char *name; /* Init server */ gnutls_anon_allocate_server_credentials(&s_anoncred); gnutls_certificate_allocate_credentials(&s_certcred); gnutls_certificate_set_x509_key_mem(s_certcred, &server_cert, &server_key, GNUTLS_X509_FMT_PEM); gnutls_certificate_set_x509_key_mem(s_certcred, &server_ecc_cert, &server_ecc_key, GNUTLS_X509_FMT_PEM); gnutls_init(&server, GNUTLS_SERVER); ret = gnutls_priority_set_direct(server, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(server, GNUTLS_CRD_ANON, s_anoncred); gnutls_credentials_set(server, GNUTLS_CRD_CERTIFICATE, s_certcred); gnutls_transport_set_push_function(server, server_push); gnutls_transport_set_pull_function(server, server_pull); gnutls_transport_set_ptr(server, (gnutls_transport_ptr_t) server); reset_buffers(); /* Init client */ gnutls_anon_allocate_client_credentials(&c_anoncred); gnutls_certificate_allocate_credentials(&c_certcred); gnutls_init(&client, GNUTLS_CLIENT); ret = gnutls_priority_set_direct(client, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(client, GNUTLS_CRD_ANON, c_anoncred); gnutls_credentials_set(client, GNUTLS_CRD_CERTIFICATE, c_certcred); gnutls_transport_set_push_function(client, client_push); gnutls_transport_set_pull_function(client, client_pull); gnutls_transport_set_ptr(client, (gnutls_transport_ptr_t) client); HANDSHAKE(client, server); name = gnutls_cipher_get_name(gnutls_cipher_get(server)); fprintf(stdout, "%30s - %s ", name, gnutls_protocol_get_name( gnutls_protocol_get_version(server))); fflush(stdout); ret = gnutls_rnd(GNUTLS_RND_NONCE, buffer, sizeof(buffer)); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } start_benchmark(&st); do { do { ret = gnutls_record_send(client, buffer, size); } while (ret == GNUTLS_E_AGAIN); if (ret < 0) { fprintf(stderr, "Failed sending to server\n"); exit(1); } do { ret = gnutls_record_recv_packet(server, &packet); } while (ret == GNUTLS_E_AGAIN); if (ret < 0) { fprintf(stderr, "Failed receiving from client: %s\n", gnutls_strerror(ret)); exit(1); } st.size += size; gnutls_packet_deinit(packet); } while (benchmark_must_finish == 0); stop_benchmark(&st, NULL, 1); gnutls_bye(client, GNUTLS_SHUT_WR); gnutls_bye(server, GNUTLS_SHUT_WR); gnutls_deinit(client); gnutls_deinit(server); gnutls_anon_free_client_credentials(c_anoncred); gnutls_anon_free_server_credentials(s_anoncred); }
int main(int argc, char **argv ) { int myopt = 0; float d; int s, u, n, i, t, r, v; //Various parameters //myname = argv[0]; i = 1023; //default initial element count t = 1023; //default triangle size r = 5000000; //default range size u = 10; //default update rate s = 0; //default seed n = 1; //default number of thread d = (float)1/2; //default density v=0; //default valgrind mode (reduce stats) fprintf(stderr,"\nSVEB v0.1\n===============\n\n"); if(argc < 2) fprintf(stderr,"NOTE: No parameters supplied, will continue with defaults\n"); fprintf(stderr,"Use -h switch for help.\n\n"); while( EOF != myopt ) { myopt = getopt(argc,argv,"r:t:n:i:u:s:d:v:hb:"); switch( myopt ) { case 'r': r = atoi( optarg ); break; case 'n': n = atoi( optarg ); break; case 't': t = atoi( optarg ); break; case 'i': i = atoi( optarg ); break; case 'u': u = atoi( optarg ); break; case 's': s = atoi( optarg ); break; case 'd': d = atof( optarg ); break; case 'v': v = atof( optarg ); break; case 'h': fprintf(stderr,"Accepted parameters\n"); fprintf(stderr,"-r <NUM> : Range size\n"); fprintf(stderr,"-u <0..100> : Update ratio. 0 = Only search; 100 = Only updates\n"); fprintf(stderr,"-i <NUM> : Initial tree size (inital pre-filled element count)\n"); fprintf(stderr,"-t <NUM> : VEB size\n"); fprintf(stderr,"-n <NUM> : Number of threads\n"); fprintf(stderr,"-s <NUM> : Random seed. 0 = using time as seed\n"); fprintf(stderr,"-h : This help\n\n"); fprintf(stderr,"Benchmark output format: \n\"0: range, insert ratio, delete ratio, #threads, attempted insert, attempted delete, attempted search, effective insert, effective delete, effective search, time (in msec)\"\n\n"); exit(0); } } fprintf(stderr,"Parameters:\n"); fprintf(stderr,"- Range size r:\t\t %d\n", r); fprintf(stderr,"- VEB size t:\t %d\n", t); fprintf(stderr,"- Update rate u:\t %d%% \n", u); fprintf(stderr,"- Number of threads n:\t %d\n", n); fprintf(stderr,"- Initial tree inserts i:\t %d\n", i); fprintf(stderr,"- Random seed s:\t %d\n", s); if (s == 0) srand((int)time(0)); else srand(s); init_tree(t); #if !defined(__TEST) initial_add(1, r); if(i){ fprintf(stderr,"Now pre-filling %d random elements...\n", i); start_prefill(NULL, r, u, n, i); } fprintf(stderr, "Finished init a SVEB (VEB layout tree) with initial %d members\n", r, i); fflush(stderr); start_benchmark(NULL, r, u, n, v); #else testseq(NULL, 1); testpar(NULL, u, n, 1); #endif exit(0); }
void convolution(int argc, char *argv[]) { if (argc != 3) { printf("Invalid number of arguments.\n"); return; } Image *input_image; Image *output_image; int error; if ((error = TGA_readImage(argv[0], &input_image)) != 0) { printf("Error when opening image: %d\n", error); return; } if ((error = Image_new(input_image->width, input_image->height, input_image->channels, &output_image)) != 0) { printf("Error when creating output image : %d\n", error); Image_delete(input_image); return; } Kernel kernel; if ((error = get_kernel(argv[1], &kernel)) != 0) { printf("Error when opening kernel : %d\n", error); Image_delete(input_image); Image_delete(output_image); return; } int radius_x, radius_y; int x, y, c; radius_x = (kernel.width - 1) / 2; radius_y = (kernel.height - 1) / 2; Benchmark bench; start_benchmark(&bench); for (c = 0; c < input_image->channels; ++c) { uint8_t *out_data = output_image->data[c]; for (y = 0; y < input_image->height; ++y) { for (x = 0; x < input_image->width; ++x) { int kx, ky; float *kernel_data = kernel.data; float sum = 0; for (ky = -radius_y; ky <= radius_y; ++ky) { for (kx = -radius_x; kx <= radius_x; ++kx) { int xx = clip(x + kx, 0, input_image->width - 1); int yy = clip(y + ky, 0, input_image->height - 1); sum += Image_getPixel(input_image, xx, yy, c) * *kernel_data++; } } sum /= kernel.sum; *out_data++ = clip(sum, 0, 255); } } } end_benchmark(&bench); printf("%lu ", bench.elapsed_ticks); printf("%lf\n", bench.elapsed_time); if ((error = TGA_writeImage(argv[2], output_image)) != 0) { printf("Error when writing image: %d\n", error); } Image_delete(input_image); Image_delete(output_image); kernel_delete(kernel); }
void erosion(int argc, char *argv[]) { if (argc != 3) { printf("Invalid number of arguments.\n"); return; } Image *input_image; Image *output_image; int error; int radius; radius = (int) atoi(argv[1]); if (radius < 1) { printf("Invalid erosion radius value.\n"); return; } if ((error = TGA_readImage(argv[0], &input_image)) != 0) { printf("Error when opening image: %d\n", error); return; } if ((error = Image_copy(input_image, &output_image)) != 0) { printf("Error when copying image: %d\n", error); Image_delete(input_image); return; } int c, i, size, x, y; int line_offset; uint8_t *in_data, *out_data; uint8_t current_min; line_offset = input_image->width; size = input_image->width * input_image->height; Benchmark bench; start_benchmark(&bench); for (c = 0; c < input_image->channels; ++c) { in_data = input_image->data[c]; out_data = output_image->data[c]; for (i = 0; i < size; ++i) { x = i % input_image->width; y = i / input_image->width; current_min = 0xff; int x1 = max(0, x - radius); int x2 = min(input_image->width - 1, x + radius); int y1 = max(0, y - radius); int y2 = min(input_image->height - 1, y + radius); int xx, yy; uint8_t *region = in_data + Image_getOffset(input_image, x1, y1); for (yy = y1; yy <= y2; ++yy) { for (xx = x1; xx <= x2; ++xx) { current_min = min(current_min, *region); ++region; } region += line_offset - (x2 - x1 + 1); } *out_data++ = current_min; } } end_benchmark(&bench); printf("%lu ", bench.elapsed_ticks); printf("%lf\n", bench.elapsed_time); if ((error = TGA_writeImage(argv[2], output_image)) != 0) { printf("Error when writing image: %d\n", error); } Image_delete(input_image); Image_delete(output_image); }
static void cipher_mac_bench(int algo, int mac_algo, int size) { int ret; gnutls_cipher_hd_t ctx; gnutls_hmac_hd_t mac_ctx; void *_key, *_iv; gnutls_datum_t key, iv; int ivsize = gnutls_cipher_get_iv_size(algo); int keysize = gnutls_cipher_get_key_size(algo); int step = size * 1024; struct benchmark_st st; void *output, *input; unsigned char c, *i; _key = malloc(keysize); if (_key == NULL) return; memset(_key, 0xf0, keysize); _iv = malloc(ivsize); if (_iv == NULL) { free(_key); return; } memset(_iv, 0xf0, ivsize); iv.data = _iv; iv.size = ivsize; key.data = _key; key.size = keysize; assert(gnutls_rnd(GNUTLS_RND_NONCE, &c, 1) >= 0); printf("%19s-%s ", gnutls_cipher_get_name(algo), gnutls_mac_get_name(mac_algo)); fflush(stdout); ALLOCM(input, MAX_MEM); ALLOC(output); i = input; start_benchmark(&st); ret = gnutls_hmac_init(&mac_ctx, mac_algo, key.data, key.size); if (ret < 0) { fprintf(stderr, "error: %s\n", gnutls_strerror(ret)); goto leave; } ret = gnutls_cipher_init(&ctx, algo, &key, &iv); if (ret < 0) { fprintf(stderr, "error: %s\n", gnutls_strerror(ret)); goto leave; } do { gnutls_hmac(mac_ctx, i, step); gnutls_cipher_encrypt2(ctx, i, step, output, step + 64); st.size += step; INC(input, i, step); } while (benchmark_must_finish == 0); gnutls_cipher_deinit(ctx); gnutls_hmac_deinit(mac_ctx, NULL); stop_benchmark(&st, NULL, 1); leave: FREE(input); FREE(output); free(_key); free(_iv); }
void ReceiveClient::on_connected(const std::shared_ptr<ynet::Connection>& connection) { start_benchmark(); }
static void test_ciphersuite(const char *cipher_prio, int size) { /* Server stuff. */ gnutls_anon_server_credentials_t s_anoncred; const gnutls_datum_t p3 = { (char *) pkcs3, strlen(pkcs3) }; static gnutls_dh_params_t dh_params; gnutls_session_t server; int sret, cret; const char *str; /* Client stuff. */ gnutls_anon_client_credentials_t c_anoncred; gnutls_session_t client; /* Need to enable anonymous KX specifically. */ int ret; struct benchmark_st st; /* Init server */ gnutls_anon_allocate_server_credentials(&s_anoncred); gnutls_dh_params_init(&dh_params); gnutls_dh_params_import_pkcs3(dh_params, &p3, GNUTLS_X509_FMT_PEM); gnutls_anon_set_server_dh_params(s_anoncred, dh_params); gnutls_init(&server, GNUTLS_SERVER); ret = gnutls_priority_set_direct(server, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(server, GNUTLS_CRD_ANON, s_anoncred); gnutls_dh_set_prime_bits(server, 1024); gnutls_transport_set_push_function(server, server_push); gnutls_transport_set_pull_function(server, server_pull); gnutls_transport_set_ptr(server, (gnutls_transport_ptr_t) server); reset_buffers(); /* Init client */ gnutls_anon_allocate_client_credentials(&c_anoncred); gnutls_init(&client, GNUTLS_CLIENT); ret = gnutls_priority_set_direct(client, cipher_prio, &str); if (ret < 0) { fprintf(stderr, "Error in %s\n", str); exit(1); } gnutls_credentials_set(client, GNUTLS_CRD_ANON, c_anoncred); gnutls_transport_set_push_function(client, client_push); gnutls_transport_set_pull_function(client, client_pull); gnutls_transport_set_ptr(client, (gnutls_transport_ptr_t) client); HANDSHAKE(client, server); fprintf(stdout, "Testing %s with %d packet size: ", gnutls_cipher_suite_get_name(gnutls_kx_get(server), gnutls_cipher_get(server), gnutls_mac_get(server)), size); fflush(stdout); gnutls_rnd(GNUTLS_RND_NONCE, buffer, sizeof(buffer)); start_benchmark(&st); do { do { ret = gnutls_record_send(client, buffer, size); } while (ret == GNUTLS_E_AGAIN); if (ret < 0) { fprintf(stderr, "Failed sending to server\n"); exit(1); } do { ret = gnutls_record_recv(server, buffer, sizeof(buffer)); } while (ret == GNUTLS_E_AGAIN); if (ret < 0) { fprintf(stderr, "Failed receiving from client\n"); exit(1); } st.size += size; } while (benchmark_must_finish == 0); stop_benchmark(&st, NULL); gnutls_bye(client, GNUTLS_SHUT_WR); gnutls_bye(server, GNUTLS_SHUT_WR); gnutls_deinit(client); gnutls_deinit(server); gnutls_anon_free_client_credentials(c_anoncred); gnutls_anon_free_server_credentials(s_anoncred); gnutls_dh_params_deinit(dh_params); }