void test_staggered() { mdp << "START TESTING STAGGERED ACTIONS\n"; int box[]={64,6,6,6}, nc=3; generic_lattice lattice(4,box,default_partitioning<0>, torus_topology, 0, 3); gauge_field U(lattice,nc); gauge_field V(lattice,nc); staggered_field psi(lattice, nc); staggered_field chi1(lattice, nc); staggered_field chi2(lattice, nc); coefficients coeff; coeff["mass"]=1.0; double t0, t1; inversion_stats stats; set_hot(U); set_random(psi); mdp << "ATTENTION: need to adjust asqtad coefficnets\n"; default_staggered_action=StaggeredAsqtadActionFast::mul_Q; default_staggered_inverter=MinimumResidueInverter<staggered_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered Min Res TIME=" << t1 << endl; default_staggered_inverter=BiConjugateGradientStabilizedInverter<staggered_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered BiCGStab TIME=" << t1 << endl; default_staggered_inverter=StaggeredBiCGUML::inverter; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered SSE BiCGStabUML TIME=" << t1 << endl; default_staggered_action=StaggeredAsqtadActionSSE2::mul_Q; default_staggered_inverter=MinimumResidueInverter<staggered_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered SSE Min Res TIME=" << t1 << endl; default_staggered_inverter=BiConjugateGradientStabilizedInverter<staggered_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered SSE BiCGStab TIME=" << t1 << endl; default_staggered_inverter=StaggeredBiCGUML::inverter; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Staggered SSE BiCGStabUML TIME=" << t1 << endl; }
int main( void ){ int datas[20]={ 1,12,3,4,15,6,7,18,9,10, 11,2,13,14,5,16,17,8,19,20}; set_random( datas, 20 ); print(datas,20); InsertionSort(datas, 20); print(datas,20); return 0; }
int main( void ){ int datas[20]={ 1,12,3,4,15,6,7,18,9,10, 11,2,13,14,5,16,17,8,19,20}; srand((unsigned int)time(NULL)); set_random( datas, 20 ); print(datas,20); ShellSortDemo(datas,20); print(datas,20); return 0; }
int main(const int argc, const char* const argv[]) { if (argc > 3) { std::cerr << err << "\n At most two arguments are allowed " "(the seed for the random-number generator and the number of elements).\n"; return errcode_parameter; } const int seed = (argc == 1) ? default_seed : boost::lexical_cast<int>(argv[1]); const unsigned int N = (argc < 3) ? default_N : boost::lexical_cast<unsigned int>(argv[2]); vec_t V(N); typedef boost::uniform_int<> uniform_distribution_type; uniform_distribution_type uniform_distribution(0,std::numeric_limits<int>::max()); // is this correct??? typedef boost::variate_generator<base_generator_type&, uniform_distribution_type> generator_type; generator_type rand_gen(base_rand_gen, uniform_distribution); typedef boost::random_number_generator<generator_type> RandomNumberGenerator; RandomNumberGenerator rg(rand_gen); set_random(seed); std::cout << "Underlying random sequence:\n"; for (long n = V.size(); n > 1; --n) std::cout << rg(n) << " "; std::cout << "\n\n"; typedef boost::random_number_generator<base_generator_type> RandomNumberGeneratorWOVariate; RandomNumberGeneratorWOVariate rg_wo_variate(base_rand_gen); set_random(seed); std::cout << "Underlying random sequence (boost::random_number_generator using just boost::mt19937):\n"; for (long n = V.size(); n > 1; --n) std::cout << rg_wo_variate(n) << " "; std::cout << "\n\n"; set_random(seed); std::cout << "Underlying random sequence (randn):\n"; for (long n = V.size(); n > 1; --n) std::cout << ::randn(n) << " "; std::cout << "\n\n"; initialise(V); set_random(seed); std::random_shuffle(V.begin(), V.end(), rg); std::cout << "std::random_shuffle:\n"; output(V); initialise(V); set_random(seed); ::random_shuffle_libcpp(V.begin(), V.end(), rg); std::cout << "std::random_shuffle_libcpp:\n"; output(V); initialise(V); set_random(seed); ::random_shuffle(V.begin(), V.end(), rg); std::cout << "::random_shuffle:\n"; output(V); }
void test_clover() { mdp << "START TESTING CLOVER ACTIONS\n"; int box[]={64,6,6,6}, nc=3; generic_lattice lattice(4,box); gauge_field U(lattice,nc); fermi_field psi(lattice, nc); fermi_field chi2(lattice, nc); coefficients coeff; coeff["kappa_s"]=0.1; coeff["kappa_t"]=0.1; coeff["c_{sw}"]=1.00; set_hot(U); compute_em_field(U); set_random(psi); double t0,t1; inversion_stats stats; default_fermi_action=FermiCloverActionFast::mul_Q; default_fermi_inverter=MinimumResidueInverter<fermi_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Clover Min Res TIME=" << t1 << endl; default_fermi_inverter=BiConjugateGradientStabilizedInverter<fermi_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Clover BiCGStab TIME=" << t1 << endl; default_fermi_action=FermiCloverActionSSE2::mul_Q; default_fermi_inverter=MinimumResidueInverter<fermi_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Clover SSE Min Res TIME=" << t1 << endl; default_fermi_inverter=BiConjugateGradientStabilizedInverter<fermi_field,gauge_field>; t0=mpi.time(); stats=mul_invQ(chi2,psi,U,coeff); t1=(mpi.time()-t0)/lattice.nvol_gl/stats.steps; cout << "Clover SSE BiCGStab TIME=" << t1 << endl; }
int RVB::init(double p[], int n_args) { float outskip, inskip, rvb_time; outskip = p[0]; inskip = p[1]; m_dur = p[2]; if (m_dur < 0) /* "dur" represents timend */ m_dur = -m_dur - inskip; if (rtsetinput(inskip, this) == -1) { // no input return(DONT_SCHEDULE); } insamps = (int)(m_dur * SR); m_amp = p[3]; if (inputChannels() != 2) return die(name(), "Input must be stereo."); if (outputChannels() != 2) return die(name(), "Output must be stereo."); double Matrix[12][12]; /* Get results of Minc setup calls (space, mikes_on, mikes_off, matrix) */ if (get_rvb_setup_params(Dimensions, Matrix, &rvb_time) == -1) return die(name(), "You must call setup routine `space' first."); /* (perform some initialization that used to be in space.c) */ int meanLength = MFP_samps(SR, Dimensions); // mean delay length for reverb get_lengths(meanLength); /* sets up delay lengths */ set_gains(rvb_time); /* sets gains for filters */ set_random(); /* sets up random variation of delays */ set_allpass(); wire_matrix(Matrix); _skip = (int) (SR / (float) resetval); if (rtsetoutput(outskip, m_dur + rvb_time, this) == -1) return DONT_SCHEDULE; DBG1(printf("nsamps = %d\n", nSamps())); return nSamps(); }
const char* parse_command(CLIENT* client,char* command) { char* token; fprintf(stderr,"parse_command: '%s'\n",command); token=strtok(command," \r\n"); if(token!=NULL) { if(strcmp(token,"attach")==0) { // select receiver token=strtok(NULL," \r\n"); if(token!=NULL) { int rx=atoi(token); return attach_receiver(rx,client); } else { return INVALID_COMMAND; } } else if(strcmp(token,"detach")==0) { // select receiver token=strtok(NULL," \r\n"); if(token!=NULL) { int rx=atoi(token); return detach_receiver(rx,client); } else { return INVALID_COMMAND; } } else if(strcmp(token,"frequency")==0) { // set frequency token=strtok(NULL," \r\n"); if(token!=NULL) { long f=atol(token); return set_frequency (client,f); } else { return INVALID_COMMAND; } } else if(strcmp(token,"start")==0) { token=strtok(NULL," \r\n"); if(token!=NULL) { if(strcmp (token,"iq")==0) { token=strtok(NULL," \r\n"); if(token!=NULL) { client->iq_port=atoi(token); } printf("***************************Starting async data acquisition... CLIENT REQUESTED %d port\n", client->iq_port); (receiver[client->receiver]).samples = 0; if ( hiqsdr_start_asynch_input ( user_data_callback, &(receiver[client->receiver])) < 0 ) { printf("start async input error\n" ); return INVALID_COMMAND; } else { printf("start async input: %s\n", "STARTED"); } return OK; } else if(strcmp(token,"bandscope")==0) { token=strtok(NULL," \r\n"); if(token!=NULL) { client->bs_port=atoi(token); } return OK; } else { // invalid command string return INVALID_COMMAND; } } else { // invalid command string return INVALID_COMMAND; } } else if(strcmp(token,"dither")==0) { // set frequency token=strtok(NULL," \r\n"); if(token!=NULL) { if (strcmp(token,"on")==0) { return set_dither (client,true); } if (strcmp(token,"off")==0) { return set_dither (client,false); } return INVALID_COMMAND; } else { return INVALID_COMMAND; } } else if(strcmp(token,"setattenuator")==0) { // set attenuator token=strtok(NULL," \r\n"); if(token!=NULL) { long av=atol(token); return set_attenuator (client,av); } else { return INVALID_COMMAND; } } else if(strcmp(token,"selectantenna")==0) { // select antenna token=strtok(NULL," \r\n"); if(token!=NULL) { long antenna = atol(token); return select_antenna (client,antenna); } else { return INVALID_COMMAND; } } else if(strcmp(token,"selectpresel")==0) { // select preselector token=strtok(NULL," \r\n"); if(token!=NULL) { long presel = atol(token); return select_preselector (client,presel); } else { return INVALID_COMMAND; } } else if(strcmp(token,"activatepreamp")==0) { // activate preamplifier token=strtok(NULL," \r\n"); if(token!=NULL) { long preamp = atol(token); return set_preamplifier (client,preamp); } else { return INVALID_COMMAND; } } else if(strcmp(token,"random")==0) { // set frequency token=strtok(NULL," \r\n"); if(token!=NULL) { if (strcmp(token,"on")==0) { return set_random (client,true); } if (strcmp(token,"off")==0) { return set_random (client,false); } return INVALID_COMMAND; } else { return INVALID_COMMAND; } } else if(strcmp(token,"stop")==0) { token=strtok(NULL," \r\n"); if(token!=NULL) { if(strcmp(token,"iq")==0) { token=strtok(NULL," \r\n"); if(token!=NULL) { client->iq_port=-1; } // try to terminate audio thread close ((receiver[client->receiver]).audio_socket); printf("Quitting...\n"); hiqsdr_stop_asynch_input (); return OK; } else if(strcmp(token,"bandscope")==0) { client->bs_port=-1; } else { // invalid command string return INVALID_COMMAND; } } else { // invalid command string return INVALID_COMMAND; } } else if(strcmp(token,"quit")==0) { return QUIT_ASAP; } else if(strcmp(token,"hardware?")==0) { return "OK HiQSDR"; } else if(strcmp(token,"getserial?")==0) { // no serial number concept available in HiQSDR, returns instead the IP address static char buf[50]; snprintf (buf, sizeof(buf), "OK %s", hiqsdr_get_ip_address()); return buf; } else if(strcmp(token,"getpreselector?")==0) { // get preselector token=strtok(NULL," \r\n"); if(token!=NULL) { long p=atol(token); // preselector query if (p >= 0 && p < 16) { static char buf[50]; static char pd[BUFSIZ]; if (!hiqsdr_get_preselector_desc(p, pd)) { snprintf (buf, sizeof(buf), "OK \"%s\"", pd); return buf; } else return INVALID_COMMAND; } else return INVALID_COMMAND; } else { return INVALID_COMMAND; } } else if(strcmp(token,"getpreampstatus?")==0) { // returns preamp status static char buf[50]; snprintf (buf, sizeof(buf), "OK %d", hiqsdr_get_preamp ()); return buf; } else { // invalid command string return INVALID_COMMAND; } } else { // empty command string return INVALID_COMMAND; } return INVALID_COMMAND; }
static void test_correctness(rsa_context *rsa, int iteration) { int max_len = rsa->max_ptext_bytes(); /* step 1: no batch, static text */ printf("correctness check (no batch): "); fflush(stdout); strcpy((char *)ptext[0], "hello world, hello RSA"); ptext_len[0] = strlen((char *)ptext[0]) + 1; ctext_len[0] = sizeof(ctext[0]); dtext_len[0] = sizeof(dtext[0]); rsa->pub_encrypt(ctext[0], &ctext_len[0], ptext[0], ptext_len[0]); rsa->priv_decrypt(dtext[0], &dtext_len[0], ctext[0], ctext_len[0]); assert(dtext_len[0] == ptext_len[0]); assert(strcmp((char *)dtext[0], (char *)ptext[0]) == 0); printf("OK\n"); /* step 2: no batch, random */ printf("correctness check (no batch, random, iterative): "); fflush(stdout); for (int k = 0; k < iteration; k++) { ptext_len[0] = (rand() % max_len) + 1; ctext_len[0] = sizeof(ctext[0]); dtext_len[0] = sizeof(dtext[0]); set_random(ptext[0], ptext_len[0]); rsa->pub_encrypt(ctext[0], &ctext_len[0], ptext[0], ptext_len[0]); rsa->priv_decrypt(dtext[0], &dtext_len[0], ctext[0], ctext_len[0]); assert(dtext_len[0] == ptext_len[0]); assert(strcmp((char *)dtext[0], (char *)ptext[0]) == 0); printf("."); fflush(stdout); } printf("OK\n"); /* step 3: batch, random */ printf("correctness check (batch, random): "); fflush(stdout); bool all_correct = true; for (int k = 1; k <= rsa_context::max_batch; k *= 2) { unsigned char *ctext_arr[rsa_context::max_batch]; unsigned char *dtext_arr[rsa_context::max_batch]; for (int i = 0; i < k; i++) { ptext_len[i] = (rand() % max_len) + 1; ctext_len[i] = sizeof(ctext[i]); dtext_len[i] = sizeof(dtext[i]); set_random(ptext[i], ptext_len[i]); rsa->pub_encrypt(ctext[i], &ctext_len[i], ptext[i], ptext_len[i]); dtext_arr[i] = dtext[i]; ctext_arr[i] = ctext[i]; } rsa->priv_decrypt_batch((unsigned char **)dtext_arr, dtext_len, (const unsigned char **)ctext_arr, ctext_len, k); bool correct = true; for (int i = 0; i < k; i++) { if (dtext_len[i] != ptext_len[i] || memcmp(dtext[i], ptext[i], dtext_len[i]) != 0) { correct = false; } } if (correct) { printf("."); } else { printf("X"); all_correct = false; } fflush(stdout); } assert(all_correct); printf("OK\n"); }
static void test_latency_stream(rsa_context_mp *rsa, device_context *dev_ctx, int concurrency) { int max_len = rsa->max_ptext_bytes(); printf("# msg throughput(RSA msgs/s)\n"); for (int k = 1; k <= rsa_context::max_batch; k *= 2) { //if (k == 32) // k = 30; // GTX285 has 30 SMs :) uint64_t begin; uint64_t end; for (int s = 1; s <= concurrency; s++) { for (int i = 0; i < k; i++) { ptext_len_str[s][i] = (rand() % max_len + 1); ctext_len_str[s][i] = sizeof(ctext_str[s][i]); dtext_len_str[s][i] = sizeof(dtext_str[s][i]); set_random(ptext_str[s][i], ptext_len_str[s][i]); rsa->pub_encrypt(ctext_str[s][i], &ctext_len_str[s][i], ptext_str[s][i], ptext_len_str[s][i]); dtext_arr_str[s][i] = dtext_str[s][i]; ctext_arr_str[s][i] = ctext_str[s][i]; } } //warmup for (int i = 1; i < concurrency; i++) { rsa->priv_decrypt_stream((unsigned char **)dtext_arr_str[i], dtext_len_str[i], (const unsigned char **)ctext_arr_str[i], ctext_len_str[i], k, i); rsa->sync(i, true); } begin = get_usec(); int rounds = 200; int count = 0; do { int stream = 0; for (int i = 1; i <= concurrency; i++) { if (dev_ctx->get_state(i) == READY) { stream = i; break; } else { if (rsa->sync(i, false)) { count++; if (count == concurrency) begin = get_usec(); } } } if (stream != 0) { rsa->priv_decrypt_stream((unsigned char **)dtext_arr_str[stream], dtext_len_str[stream], (const unsigned char **)ctext_arr_str[stream], ctext_len_str[stream], k, stream); } else { usleep(0); } } while (count < rounds + concurrency); end = get_usec(); for (int s = 1; s <= concurrency; s++) rsa->sync(s, true); double throughput = (k * 1000000.0) * (count - concurrency) / (end - begin); printf("%4d *%2d\t%.2f\n", k, concurrency, throughput); } }
static void test_latency(rsa_context *rsa) { bool warmed_up = false; int max_len = rsa->max_ptext_bytes(); printf("# msg latency CPU kernel throughput(RSA msgs/s)\n"); for (int k = 1; k <= rsa_context::max_batch; k *= 2) { //if (k == 32) // k = 30; // GTX285 has 30 SMs :) unsigned char *ctext_arr[rsa_context::max_batch]; unsigned char *dtext_arr[rsa_context::max_batch]; uint64_t begin; uint64_t end; for (int i = 0; i < k; i++) { ptext_len[i] = (rand() % max_len) + 1; ctext_len[i] = sizeof(ctext[i]); dtext_len[i] = sizeof(dtext[i]); set_random(ptext[i], ptext_len[i]); rsa->pub_encrypt(ctext[i], &ctext_len[i], ptext[i], ptext_len[i]); dtext_arr[i] = dtext[i]; ctext_arr[i] = ctext[i]; } again: int iteration = 1; begin = get_usec(); try_more: rsa->priv_decrypt_batch((unsigned char **)dtext_arr, dtext_len, (const unsigned char **)ctext_arr, ctext_len, k); end = get_usec(); if (end - begin < 300000) { for (int i = 0; i < k; i++) dtext_len[i] = sizeof(dtext[i]); iteration++; if (!warmed_up) { warmed_up = true; goto again; } else goto try_more; } double total_time = (end - begin) / (iteration * 1000.0); double kernel_time = rsa->get_elapsed_ms_kernel(); double throughput = (k * 1000000.0) * iteration / (end - begin); printf("%4d\t%.2f\t%.2f\t%.2f\t%.2f\n", k, total_time, total_time - kernel_time, kernel_time, throughput); } }
int main(void) { setvbuf(stdout, nullptr, _IONBF, 0); Tox *const tox1 = tox_new_log(nullptr, nullptr, nullptr); Tox *const tox2 = tox_new_log(nullptr, nullptr, nullptr); printf("bootstrapping tox2 off tox1\n"); uint8_t dht_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_dht_id(tox1, dht_key); const uint16_t dht_port = tox_self_get_udp_port(tox1, nullptr); tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr); struct test_data to_compare = {{0}}; uint8_t public_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_public_key(tox1, public_key); tox_friend_add_norequest(tox2, public_key, nullptr); tox_self_get_public_key(tox2, public_key); tox_friend_add_norequest(tox1, public_key, nullptr); uint8_t reference_name[TOX_MAX_NAME_LENGTH] = { 0 }; uint8_t reference_status[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 }; set_random(tox1, tox_self_set_name, TOX_MAX_NAME_LENGTH); set_random(tox2, tox_self_set_name, TOX_MAX_NAME_LENGTH); set_random(tox1, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH); set_random(tox2, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH); tox_self_get_name(tox2, reference_name); tox_self_get_status_message(tox2, reference_status); tox_callback_friend_name(tox1, namechange_callback); tox_callback_friend_status_message(tox1, statuschange_callback); while (true) { if (tox_self_get_connection_status(tox1) && tox_self_get_connection_status(tox2) && tox_friend_get_connection_status(tox1, 0, nullptr) == TOX_CONNECTION_UDP) { printf("Connected.\n"); break; } tox_iterate(tox1, &to_compare); tox_iterate(tox2, nullptr); c_sleep(tox_iteration_interval(tox1)); } while (true) { if (to_compare.received_name && to_compare.received_status_message) { printf("Exchanged names and status messages.\n"); break; } tox_iterate(tox1, &to_compare); tox_iterate(tox2, nullptr); c_sleep(tox_iteration_interval(tox1)); } size_t save_size = tox_get_savedata_size(tox1); VLA(uint8_t, savedata, save_size); tox_get_savedata(tox1, savedata); struct Tox_Options *const options = tox_options_new(nullptr); tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE); tox_options_set_savedata_data(options, savedata, save_size); Tox *const tox_to_compare = tox_new_log(options, nullptr, nullptr); tox_friend_get_name(tox_to_compare, 0, to_compare.name, nullptr); tox_friend_get_status_message(tox_to_compare, 0, to_compare.status_message, nullptr); ck_assert_msg(memcmp(reference_name, to_compare.name, TOX_MAX_NAME_LENGTH) == 0, "incorrect name: should be all zeroes"); ck_assert_msg(memcmp(reference_status, to_compare.status_message, TOX_MAX_STATUS_MESSAGE_LENGTH) == 0, "incorrect status message: should be all zeroes"); tox_options_free(options); tox_kill(tox1); tox_kill(tox2); tox_kill(tox_to_compare); return 0; }
void init_random_buffer(void ** buffer, int buf_len) { *buffer = malloc(buf_len); set_random(*buffer, buf_len); }
NumberGene::NumberGene() { set_random(); }
int main(int argc, char *argv[]) { Tox *tox1 = tox_new_log(0, 0, 0); Tox *tox2 = tox_new_log(0, 0, 0); struct test_data to_compare = { { 0 } }; uint8_t public_key[TOX_PUBLIC_KEY_SIZE]; tox_self_get_public_key(tox1, public_key); tox_friend_add_norequest(tox2, public_key, NULL); tox_self_get_public_key(tox2, public_key); tox_friend_add_norequest(tox1, public_key, NULL); uint8_t reference_name[TOX_MAX_NAME_LENGTH] = { 0 }; uint8_t reference_status[TOX_MAX_STATUS_MESSAGE_LENGTH] = { 0 }; set_random(tox1, tox_self_set_name, TOX_MAX_NAME_LENGTH); set_random(tox2, tox_self_set_name, TOX_MAX_NAME_LENGTH); set_random(tox1, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH); set_random(tox2, tox_self_set_status_message, TOX_MAX_STATUS_MESSAGE_LENGTH); tox_self_get_name(tox2, reference_name); tox_self_get_status_message(tox2, reference_status); tox_callback_friend_name(tox1, namechange_callback); tox_callback_friend_status_message(tox1, statuschange_callback); while (true) { if (tox_self_get_connection_status(tox1) && tox_self_get_connection_status(tox2) && tox_friend_get_connection_status(tox1, 0, 0) == TOX_CONNECTION_UDP) { printf("Connected.\n"); break; } tox_iterate(tox1, &to_compare); tox_iterate(tox2, NULL); c_sleep(tox_iteration_interval(tox1)); } while (true) { if (to_compare.received_name && to_compare.received_status_message) { printf("Exchanged names and status messages.\n"); break; } tox_iterate(tox1, &to_compare); tox_iterate(tox2, NULL); c_sleep(tox_iteration_interval(tox1)); } size_t save_size = tox_get_savedata_size(tox1); VLA(uint8_t, savedata, save_size); tox_get_savedata(tox1, savedata); struct Tox_Options *options = tox_options_new(NULL); tox_options_set_savedata_type(options, TOX_SAVEDATA_TYPE_TOX_SAVE); tox_options_set_savedata_data(options, savedata, save_size); Tox *tox_to_compare = tox_new(options, 0); tox_friend_get_name(tox_to_compare, 0, to_compare.name, 0); tox_friend_get_status_message(tox_to_compare, 0, to_compare.status_message, 0); assert(memcmp(reference_name, to_compare.name, TOX_MAX_NAME_LENGTH) == 0); assert(memcmp(reference_status, to_compare.status_message, TOX_MAX_STATUS_MESSAGE_LENGTH) == 0); tox_options_free(options); tox_kill(tox1); tox_kill(tox2); tox_kill(tox_to_compare); return 0; }
int main(int argc, char **argv) { set_random(); int result = libusb_init(NULL); if (result < 0) { printf("libusb_init(): %s\n", libusb_strerror(result)); exit(EXIT_FAILURE); } /////////////////////////////////////////////////////////////// // // 1. Find ZTEX devices, initialize // /////////////////////////////////////////////////////////////// //ZTEX_DEBUG=1; //DEBUG = 1; struct device_list *device_list = device_init_scan(device_list); int device_count = device_list_count(device_list); printf("%d device(s) ZTEX 1.15y ready\n", device_count); if (device_count) ztex_dev_list_print(device_list->ztex_dev_list); //else // exit(0); /////////////////////////////////////////////////////////////// // // 2. Perform I/O. // /////////////////////////////////////////////////////////////// // Signals aren't checked at time of firmware and bitstream uploads signal(SIGHUP, signal_handler); signal(SIGINT, signal_handler); signal(SIGTERM, signal_handler); signal(SIGALRM, signal_handler); printf("Writing to each FPGA of each device and reading back, random length writes (%d-%d)\n", min_len, max_len); struct timeval tv0, tv1; gettimeofday(&tv0, NULL); struct timeval tv2, tv3; gettimeofday(&tv2, NULL); for ( ; ; ) { if (signal_received) { printf("Signal received.\n"); break; } struct device_list *device_list_1 = device_timely_scan(device_list); int found_devices = device_list_count(device_list_1); if (found_devices) { printf("Found %d device(s) ZTEX 1.15y\n", found_devices); ztex_dev_list_print(device_list_1->ztex_dev_list); } device_list_merge(device_list, device_list_1); int device_count = 0; struct device *device; for (device = device_list->device; device; device = device->next) { if (!device_valid(device)) continue; result = device_fpgas_rw(device); if (result < 0) { printf("SN %s error %d doing r/w of FPGAs (%s)\n", device->ztex_device->snString, result, libusb_strerror(result) ); device_invalidate(device); } device_count ++; } if (!device_count) { gettimeofday(&tv3, NULL); if (tv3.tv_sec - tv2.tv_sec == 1) { printf("x"); fflush(stdout); } tv2 = tv3; usleep(500 *1000); } } // for(;;) gettimeofday(&tv1, NULL); unsigned long long usec = (tv1.tv_sec - tv0.tv_sec)*1000000 + tv1.tv_usec - tv0.tv_usec; float kbyte_count = (wr_byte_count+rd_byte_count)/1024; unsigned long long cmd_count = 0; printf("%.2f MB write, %.2f MB read, rate %.2f MB/s, partial reads %d\n", (float)wr_byte_count/1024/1024, (float)rd_byte_count/1024/1024, kbyte_count *1000000/usec /1024, partial_read_count); libusb_exit(NULL); }
Error Connection::flip_random(){ // Tested return set_random(!status.random); }
bool Parameters::arrange() { if(randomf) set_random(); if (num_nodes==unlikely) { cerr<<"\n***********************\nERROR:\t number of nodes unspecified"<<endl; return false; } if (average_k==unlikely) { cerr<<"\n***********************\nERROR:\t average degree unspecified"<<endl; return false; } if (max_degree==unlikely) { cerr<<"\n***********************\nERROR:\t maximum degree unspecified"<<endl; return false; } if (mixing_parameter==unlikely) { cerr<<"\n***********************\nERROR:\t mixing parameter unspecified"<<endl; return false; } if(overlapping_nodes<0 || overlap_membership<0) { cerr<<"\n***********************\nERROR:\tsome positive parameters are negative"<<endl; return -1; } if (num_nodes<=0 || average_k<=0 || max_degree<=0 || mixing_parameter<0 || (nmax<=0 && nmax!=unlikely) || (nmin<=0 && nmin!=unlikely) ) { cerr<<"\n***********************\nERROR:\tsome positive parameters are negative"<<endl; return -1; } if(mixing_parameter > 1) { cerr<<"\n***********************\nERROR:\tmixing parameter > 1 (must be between 0 and 1)"<<endl; return -1; } if(nmax!= unlikely && nmin!=unlikely) fixed_range=true; else fixed_range=false; if(excess && defect) { cerr<<"\n***********************\nERROR:\tboth options -inf and -sup cannot be used at the same time"<<endl; return false; } cout<<"\n**************************************************************"<<endl; cout<<"number of nodes:\t"<<num_nodes<<endl; cout<<"average degree:\t"<<average_k<<endl; cout<<"maximum degree:\t"<<max_degree<<endl; cout<<"exponent for the degree distribution:\t"<<tau<<endl; cout<<"exponent for the community size distribution:\t"<<tau2<<endl; cout<<"mixing parameter:\t"<<mixing_parameter<<endl; cout<<"number of overlapping nodes:\t"<<overlapping_nodes<<endl; cout<<"number of memberships of the overlapping nodes:\t"<<overlap_membership<<endl; if (fixed_range) { cout<<"community size range set equal to ["<<nmin<<" , "<<nmax<<"]"<<endl; if (nmin>nmax) { cerr<<"\n***********************\nERROR: INVERTED COMMUNITY SIZE BOUNDS"<<endl; return false; } if(nmax>num_nodes) { cerr<<"\n***********************\nERROR: maxc BIGGER THAN THE NUMBER OF NODES"<<endl; return false; } } cout<<"**************************************************************"<<endl<<endl; return true; }
int BASE::init(double p[], int n_args) { int UseMikes; float outskip, inskip, abs_factor, rvb_time; outskip = p[0]; inskip = p[1]; m_dur = p[2]; if (m_dur < 0) /* "dur" represents timend */ m_dur = -m_dur - inskip; if (rtsetinput(inskip, this) == -1) { // no input return(DONT_SCHEDULE); } insamps = (int)(m_dur * SR); inamp = p[3]; double Matrix[12][12]; /* Get results of Minc setup calls (space, mikes_on, mikes_off, matrix) */ if (get_setup_params(Dimensions, Matrix, &abs_factor, &rvb_time, &UseMikes, &MikeAngle, &MikePatternFactor) == -1) { return die(name(), "You must call setup routine `space' first."); } // call inst-specific init code if (localInit(p, n_args) == DONT_SCHEDULE) { return die(name(), "localInit failed."); } if (m_inchan >= inputChannels()) { return die(name(), "You asked for channel %d of a %d-channel input file.", m_inchan, inputChannels()); } if (inputChannels() == 1) m_inchan = 0; if (outputChannels() != 2) { return die(name(), "Output must be stereo."); } wire_matrix(Matrix); /* (perform some initialization that used to be in space.c) */ int meanLength = MFP_samps(SR, Dimensions); // mean delay length for reverb get_lengths(meanLength); /* sets up delay lengths */ set_gains(rvb_time); /* sets gains for filters */ set_walls(abs_factor); /* sets wall filts for move routine */ set_allpass(); set_random(); /* sets up random variation of delays */ /* flag for use of ear filters */ m_binaural = (!UseMikes && m_dist < 0.8 && m_dist != 0.0); amparray = floc(1); if (amparray) { int amplen = fsize(1); tableset(SR, m_dur, amplen, amptabs); /* controls input dur only */ } else rtcmix_advise(name(), "Setting phrase curve to all 1's."); /* determine extra run time for this routine before calling rtsetoutput() */ double ringdur = 0.0; finishInit(rvb_time, &ringdur); m_branch = 0; if (rtsetoutput(outskip, m_dur + ringdur, this) == -1) return DONT_SCHEDULE; DBG1(printf("nsamps = %d\n", nSamps())); return nSamps(); }