int main(int argc, char* argv[])
{
uint64_t i;
struct bitarray* bits;
fprintf_blue(stdout, "-- Bitarray Test Suite --\n");
fprintf_light_blue(stdout, "* test bitarray_init()\n");
bits = bitarray_init(8*512);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_set_all()\n");
bitarray_set_all(bits);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_clear()\n");
bitarray_unset_all(bits);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_set_bit()\n");
for (i = 0; i < 31; i++)
{
bitarray_set_bit(bits, test_nums[i]);
}
fprintf_light_blue(stdout, "* test bitarray_get_bit()\n");
for (i = 0; i < 31; i++)
{
assert(bitarray_get_bit(bits, test_nums[i]) == true);
}
fprintf_light_blue(stdout, "* test bitarray_unset_bit()\n");
bitarray_unset_bit(bits, test_nums[4]);
bitarray_unset_bit(bits, test_nums[9]);
for (i = 0; i < 31; i++)
{
if (i == 4 || i == 9) continue;
assert(bitarray_get_bit(bits, test_nums[i]) == true);
}
for (i = 0; i < 31; i++)
{
bitarray_unset_bit(bits, test_nums[i]);
}
for (i = 0; i < 31; i++)
{
assert(bitarray_get_bit(bits, test_nums[i]) == false);
}
bitarray_print(bits);
bitarray_destroy(bits);
test_throughput();
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
if (argc > 1) {
if (strcmp(argv[1],"-s") == 0)
use_unix = 1;
}
signal(SIGPIPE, SIG_IGN);
test_format_commands();
test_blocking_connection();
test_reply_reader();
// test_nonblocking_connection();
test_throughput();
cleanup();
if (fails == 0) {
printf("ALL TESTS PASSED\n");
} else {
printf("*** %d TESTS FAILED ***\n", fails);
}
return 0;
}
int main(int argc, char* args[]){
assert(argc == 3);
clock_t start, end;
int r;
int data_size = atoi(args[1]);
int buffer_size = atoi(args[2]);
bool sorted = true;
lsm *tree;
tree = init_new_lsm(buffer_size, sorted);
///// TEST PUT - SORTED /////
r = test_put(tree, data_size,buffer_size, sorted);
r = test_throughput(tree, data_size, buffer_size, sorted);
/* sorted = false; */
/* //r = test_put(data_size,buffer_size, sorted); */
/* r = test_throughput(data_size, buffer_size, sorted); */
destruct_lsm(tree);
return r;
}
/** ***************************************************************
* MAIN
*/
int main(int argc, char **argv)
{
unsigned int threads=THREADS;
unsigned int chunk = CHUNK;
unsigned int test_length = SECONDS; /* how many seconds before stopping generation
* negative to infinite (until ESC) */
unsigned int cycles = CYCLES; // how many times to run generators to get average throughput
unsigned int cycle;
double throughputs [cycles][METHODS_COUNT];
double averages [METHODS_COUNT];
double sum, max_throughput;
int max_throughput_method, method;
int tested_methods_count = compute_tests_amount(TESTED_METHODS);
FILE *stream;
max_throughput = 0;
max_throughput_method = 0;
if(rdrand_testSupport() == RDRAND_UNSUPPORTED)
{
fprintf(stderr,"FATAL ERROR: RdRand is not supported on this CPU!\n");
exit (EXIT_FAILURE);
}
get_opts(argc,
argv,
&threads,
&chunk,
&test_length,
&cycles,
&stream,
&tested_methods_count);
if(verbose_flag)
{
fprintf(stderr,"This test will run %d methods for %d times in %d threads.\n", tested_methods_count, cycles, threads);
fprintf(stderr,"Each method will run for %d seconds, the overall time of this test is %d seconds.\n",
test_length, test_length*cycles*tested_methods_count );
fprintf(stderr,"The random values are generated in chunks of size %u 64 bit values (per thread).\n",chunk);
if(print_numbers_flag == 0)
fprintf(stderr,"Generated values will be print raw.\n");
else
fprintf(stderr,"Generated values will be print as readable numbers.\n");
if(no_print_flag)
fprintf(stderr,"Will not print generates values.\n");
fprintf(stderr,"-------------------------------------------------------------------\n");
}
/************** DO THE TESTING ******************************************/
/* run all methods in required count */
for ( cycle = 0; cycle < cycles; cycle++)
{
if(verbose_flag)
fprintf(stderr,"\nDoing %d. run:\n",cycle+1);
/* run all methods */
for( method = 0; method < tested_methods_count; method++)
{
if(verbose_flag)
fprintf(stderr,"%s:\n",METHOD_NAMES[TESTED_METHODS[method]]);
throughputs[cycle][method] = test_throughput(threads, chunk, test_length, stream, TESTED_METHODS[method]);
}
}
/************** PRINT OVERALL RESULTS **********************************/
if(print_numbers_flag == 1)
fprintf(stderr,"\n"); // to break line after numbers
if(verbose_flag)
fprintf(stderr,"\n-------------------------------------------------------------------\n");
for( method = 0; method< tested_methods_count; method++)
{
sum = 0;
for( cycle = 0; cycle < cycles; cycle++)
{
sum += throughputs[cycle][method];
}
averages[method] = sum/cycles;
// find the maximum throughput
if(max_throughput < averages[method])
{
max_throughput = averages[method];
max_throughput_method = TESTED_METHODS[method];
}
}
if(verbose_flag)
{
fprintf(stderr,"The fastest method (%g MiB/s) was: %s\n",max_throughput, METHOD_NAMES[max_throughput_method]);
fprintf(stderr,"Average throughputs in %d runs:\n", cycles);
}
for( method = 0; method< tested_methods_count; method++)
{
if(verbose_flag)
{
fprintf(stderr," (%.2f %%) Method %s: %.3f MiB/s\n",
(averages[method]/max_throughput)*100, // percents of max throughput
METHOD_NAMES[TESTED_METHODS[method]],
averages[method]
);
}
else
{
fprintf(stderr,"%s %.3f MiB/s %.2f %%\n",
METHOD_NAMES[TESTED_METHODS[method]],
averages[method],
(averages[method]/max_throughput)*100 // percents of max throughput
);
}
}
fclose(stream);
return 1;
}
