void test_rsa_mp()
{
device_context dev_ctx;
dev_ctx.init(10485760, 0);
// srinath commenting out
#if 0
printf("------------------------------------------\n");
printf("RSA512, GPU (MP), random\n");
printf("------------------------------------------\n");
rsa_context_mp rsa512_mp(512);
rsa512_mp.set_device_context(&dev_ctx);
test_latency(&rsa512_mp);
test_correctness(&rsa512_mp, 20);
#endif
printf("------------------------------------------\n");
printf("RSA1024, GPU (MP), random\n");
printf("------------------------------------------\n");
rsa_context_mp rsa1024_mp(1024);
rsa1024_mp.set_device_context(&dev_ctx);
test_latency(&rsa1024_mp);
test_correctness(&rsa1024_mp, 20);
// srinath commenting out
#if 0
printf("------------------------------------------\n");
printf("RSA2048, GPU (MP), random\n");
printf("------------------------------------------\n");
rsa_context_mp rsa2048_mp(2048);
rsa2048_mp.set_device_context(&dev_ctx);
test_latency(&rsa2048_mp);
test_correctness(&rsa2048_mp, 20);
printf("------------------------------------------\n");
printf("RSA4096, GPU (MP), random\n");
printf("------------------------------------------\n");
rsa_context_mp rsa4096_mp(4096);
rsa4096_mp.set_device_context(&dev_ctx);
test_latency(&rsa4096_mp);
test_correctness(&rsa4096_mp, 20);
#endif
}
void
release_spinlock(spinlock *lock)
{
#if DEBUG_SPINLOCK_LATENCIES
test_latency(lock);
#endif
if (sNumCPUs > 1) {
if (are_interrupts_enabled())
panic("release_spinlock: attempt to release lock %p with "
"interrupts enabled\n", lock);
#if B_DEBUG_SPINLOCK_CONTENTION
{
int32 count = atomic_and(&lock->lock, 0) - 1;
if (count < 0) {
panic("release_spinlock: lock %p was already released\n", lock);
} else {
// add to the total count -- deal with carry manually
if ((uint32)atomic_add(&lock->count_low, count) + count
< (uint32)count) {
atomic_add(&lock->count_high, 1);
}
}
}
#else
if (atomic_and((int32*)lock, 0) != 1)
panic("release_spinlock: lock %p was already released\n", lock);
#endif
} else {
#if DEBUG_SPINLOCKS
if (are_interrupts_enabled()) {
panic("release_spinlock: attempt to release lock %p with "
"interrupts enabled\n", lock);
}
if (atomic_and((int32*)lock, 0) != 1)
panic("release_spinlock: lock %p was already released\n", lock);
#endif
#if DEBUG_SPINLOCK_LATENCIES
test_latency(lock);
#endif
}
}
void test_rsa_cpu()
{
printf("------------------------------------------\n");
printf("RSA1024, CPU, random\n");
printf("------------------------------------------\n");
rsa_context rsa1024_cpu(1024);
test_latency(&rsa1024_cpu);
test_correctness(&rsa1024_cpu, 20);
printf("------------------------------------------\n");
printf("RSA2048, CPU, random\n");
printf("------------------------------------------\n");
rsa_context rsa2048_cpu(2048);
test_latency(&rsa2048_cpu);
test_correctness(&rsa2048_cpu, 20);
printf("------------------------------------------\n");
printf("RSA4096, CPU, random\n");
printf("------------------------------------------\n");
rsa_context rsa4096_cpu(4096);
test_latency(&rsa4096_cpu);
test_correctness(&rsa4096_cpu, 20);
}
void test_rsa_mp_cert(unsigned num_stream)
{
device_context dev_ctx;
dev_ctx.init(10485760, num_stream);
printf("------------------------------------------\n");
printf("RSA1024, GPU (MP), server.key\n");
printf("------------------------------------------\n");
rsa_context_mp rsa("../../server.key", "anlab");
rsa.set_device_context(&dev_ctx);
//rsa.dump();
if (num_stream == 0) {
test_latency(&rsa);
test_correctness(&rsa, 20);
}
else {
for (unsigned int i = 1; i <= 16; i++)
test_latency_stream(&rsa, &dev_ctx, i);
}
}
static int get_best_server(int *p_index)
{
int i;
double minimum = DBL_MAX;
char server[URL_LENGTH_MAX] = {0};
for (i = 0; i < MAX_CLOSEST_SERVER_NUM; i++) {
double latency;
sscanf(servers[i].url, "http://%[^/]speedtest/upload.%*s", server);
latency = test_latency(server);
if (minimum > latency ) {
minimum = latency;
*p_index = i;
}
}
if (minimum == DBL_MAX)
return NOK;
return OK;
}
int main(int argc, char *argv[])
{
int opt, num_thread;
char server_url[URL_LENGTH_MAX], ext[UPLOAD_EXT_LENGTH_MAX];
double latency, speed, download_speed, upload_speed;
int dsize, sindex;
sindex = -1;
num_thread = 4;
dsize = INIT_DOWNLOAD_FILE_RESOLUTION;
memset(server_url, 0, sizeof(server_url));
memset(ext, 0, sizeof(ext));
while ( (opt = getopt(argc, argv, "p:s:lh")) > 0) {
switch (opt) {
case 'p':
if (atoi(optarg) > THREAD_NUM_MAX) {
fprintf(stderr, "Only support %d threads meanwhile", THREAD_NUM_MAX);
exit(-1);
}
num_thread = atoi(optarg);
break;
case 's':
strncpy(server_url, optarg, URL_LENGTH_MAX);
break;
case 'l':
break;
case 'h':
show_usage(argv);
break;
}
}
if (server_url[0] == 0) {
printf("Retrieving speedtest.net configuration...\n");
get_client_info(&client);
printf("Retrieving speedtest.net server list...\n");
get_closest_server();
printf("Testing from %s (%s)...\n", client.isp, client.ip);
printf("Selecting best server based on ping...\n");
get_best_server(&sindex);
sscanf(servers[sindex].url, "http://%[^/]/speedtest/upload.%4s", server_url, ext);
printf("Bestest server: %s(%0.2fKM)\n", server_url, servers[sindex].distance);
}
/* Must initialize libcurl before any threads are started */
curl_global_init(CURL_GLOBAL_ALL);
latency = test_latency(server_url);
if (latency == DBL_MAX)
exit(-1);
printf("Server latency is %0.0fms\n", latency);
speed = test_download(server_url, num_thread, dsize, 0);
dsize = get_download_filename(speed, num_thread);
fprintf(stderr, "Testing download speed");
download_speed = test_download(server_url, num_thread, dsize, 1);
printf("Download speed: %0.2fMbps\n", ((download_speed*8)/(1024*1024)));
if (ext[0] == 0 && get_upload_extension(server_url, ext) != OK)
exit(-1);
speed = test_upload(server_url, num_thread, speed, ext, 0);
fprintf(stderr, "Testing upload speed");
upload_speed = test_upload(server_url, num_thread, speed*SPEEDTEST_TIME_MAX, ext, 1);
printf("Upload speed: %0.2fMbps\n", ((upload_speed*8)/(1024*1024)));
}
