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();
}
