void
test_list(void)
{
struct histogram *hist1 = histogram_create("hist1");
struct histogram *hist2 = histogram_create("hist2");
struct histogram *hist3 = aim_zmalloc(sizeof(*hist3));
histogram_register(hist3, "hist3");
AIM_ASSERT(!strcmp(hist1->name, "hist1"));
AIM_ASSERT(!strcmp(hist2->name, "hist2"));
AIM_ASSERT(!strcmp(hist3->name, "hist3"));
struct list_head *head = histogram_list();
struct list_links *cur = list_first(head);
AIM_ASSERT(container_of(cur, links, struct histogram) == hist1);
cur = cur->next;
AIM_ASSERT(container_of(cur, links, struct histogram) == hist2);
cur = cur->next;
AIM_ASSERT(container_of(cur, links, struct histogram) == hist3);
AIM_ASSERT(cur->next == &head->links);
histogram_destroy(hist1);
histogram_destroy(hist2);
histogram_unregister(hist3);
aim_free(hist3);
}
void
test_basic(void)
{
struct histogram *hist = histogram_create("basic");
check(hist, 0, 0);
histogram_inc(hist, 0);
check(hist, 0, 1);
histogram_inc(hist, 0);
check(hist, 0, 2);
/* 1 is a different bucket */
histogram_inc(hist, 1);
check(hist, 1, 1);
/* 32 and 33 are the same bucket */
histogram_inc(hist, 32);
histogram_inc(hist, 33);
check(hist, 32, 2);
check(hist, 33, 2);
histogram_inc(hist, UINT32_MAX);
check(hist, UINT32_MAX, 1);
histogram_destroy(hist);
}
void
test_all(void)
{
struct histogram *hist = histogram_create("all");
uint32_t k;
for (k = 0; k < UINT32_MAX; k++) {
check(hist, k, 0);
}
check(hist, k, 0);
for (k = 0; k < UINT32_MAX; k++) {
histogram_inc(hist, k);
}
histogram_inc(hist, k);
for (k = 0; k < 16; k++) {
check(hist, k, 1);
}
int i;
for (i = 4; i < 32; i++) {
uint32_t c = (1u << i) / 16;
for (k = 1<<i; k < (2<<i) - 1; k++) {
check(hist, k, c);
}
check(hist, k, c);
}
histogram_destroy(hist);
}
int main(int argc, char **argv) {
// use bucket size of .5
struct histogram *h = histogram_create(.5);
// bucket [3.0, 3.5)
histogram_insert(h, 3.00);
histogram_insert(h, 3.14);
// bucket [21.5, 22.0)
histogram_insert(h, 21.99);
// bucket [22.0, 22.5)
histogram_insert(h, 22.00);
histogram_insert(h, 22.20);
histogram_insert(h, 22.49);
// bucket [22.5, 23.0)
histogram_insert(h, 22.50);
histogram_insert(h, 22.99);
// bucket [-22.0, -21.5)
histogram_insert(h, -21.51);
histogram_insert(h, -22.00);
// bucket [-21.5, -21.0)
histogram_insert(h, -21.49);
histogram_insert(h, -21.20);
histogram_insert(h, -21.01);
double *buckets = histogram_buckets(h);
double b = histogram_bucket_size(h);
int expected_counts[] = {2, 3, 2, 1, 3, 2};
int i;
for(i = 0; i < histogram_size(h); i++) {
double start = buckets[i];
int count = histogram_count(h, start);
if(expected_counts[i] != count) {
fprintf(stderr, "Expected a count of %d, got %d.", expected_counts[i], count);
return -1;
}
fprintf(stdout, "[%6.2lf, %6.2f) count: %d\n", start, start + b, histogram_count(h, start));
}
fprintf(stdout, "max: %6.2lf\n", histogram_max_value(h));
fprintf(stdout, "min: %6.2lf\n", histogram_min_value(h));
fprintf(stdout, "mode: %6.2lf\n", histogram_mode(h));
fprintf(stdout, "mode count: %d\n", histogram_count(h, histogram_mode(h)));
free(buckets);
histogram_delete(h);
return 0;
}
void
test_find(void)
{
AIM_ASSERT(histogram_find("hist1") == NULL);
AIM_ASSERT(histogram_find("hist2") == NULL);
struct histogram *hist1 = histogram_create("hist1");
AIM_ASSERT(histogram_find("hist1") == hist1);
AIM_ASSERT(histogram_find("hist2") == NULL);
struct histogram *hist2 = histogram_create("hist2");
AIM_ASSERT(histogram_find("hist1") == hist1);
AIM_ASSERT(histogram_find("hist2") == hist2);
histogram_destroy(hist1);
AIM_ASSERT(histogram_find("hist1") == NULL);
AIM_ASSERT(histogram_find("hist2") == hist2);
histogram_destroy(hist2);
AIM_ASSERT(histogram_find("hist1") == NULL);
AIM_ASSERT(histogram_find("hist2") == NULL);
}
int main(){
timer_util* tu = malloc(sizeof(timer_util));
int i, j, k;
initialize_timer(tu);
struct histogram* hist = histogram_create(0, 20000, 10);
for(i = 0; i < NUM_TIMER; i++){
timer_set_mode(tu, i, 1);
}
for(i = 0; i < 100; i++){
for(j = 0; j < NUM_TIMER; j++){
timer_start(tu, j);
for(k = 0; k < 1000000; k++){}
timer_end_hist(tu, j, hist);
printf("Timer #%d min: %"PRIu64"\n", j, timer_min(tu, j));
printf("Timer #%d max: %"PRIu64"\n", j, timer_max(tu, j));
printf("Timer #%d avg: %"PRIu64"\n\n", j, timer_avg(tu, j));
}
}
histogram_print(hist);
return 0;
}
int main(int argc, char* argv[]) {
signal(SIGSEGV, as_sig_handle_segv);
signal(SIGTERM , as_sig_handle_term);
fprintf(stdout, "\nAerospike act - device IO test\n");
fprintf(stdout, "Copyright 2011 by Aerospike. All rights reserved.\n\n");
if (! configure(argc, argv)) {
exit(-1);
}
set_schedulers();
srand(time(NULL));
// rand_seed(g_rand_64_buffer);
salter salters[g_num_write_buffers ? g_num_write_buffers : 1];
g_salters = salters;
if (! create_salters()) {
exit(-1);
}
device devices[g_num_devices];
readq readqs[g_num_queues];
g_devices = devices;
g_readqs = readqs;
// TODO - 'salt' drive?
g_p_large_block_read_histogram = histogram_create();
g_p_large_block_write_histogram = histogram_create();
g_p_raw_read_histogram = histogram_create();
g_p_read_histogram = histogram_create();
g_run_start_us = cf_getus();
uint64_t run_stop_us = g_run_start_us + g_run_us;
g_running = 1;
for (int n = 0; n < g_num_devices; n++) {
device* p_device = &g_devices[n];
p_device->name = g_device_names[n];
p_device->p_fd_queue = cf_queue_create(sizeof(int), true);
discover_num_blocks(p_device);
create_large_block_read_buffer(p_device);
p_device->p_raw_read_histogram = histogram_create();
sprintf(p_device->histogram_tag, "%-18s", p_device->name);
if (pthread_create(&p_device->large_block_read_thread, NULL,
run_large_block_reads, (void*)p_device)) {
fprintf(stdout, "ERROR: create large block read thread %d\n", n);
exit(-1);
}
if (pthread_create(&p_device->large_block_write_thread, NULL,
run_large_block_writes, (void*)p_device)) {
fprintf(stdout, "ERROR: create write thread %d\n", n);
exit(-1);
}
}
for (int i = 0; i < g_num_queues; i++) {
readq* p_readq = &g_readqs[i];
p_readq->p_req_queue = cf_queue_create(sizeof(readreq*), true);
p_readq->threads = malloc(sizeof(pthread_t) * g_threads_per_queue);
for (int j = 0; j < g_threads_per_queue; j++) {
if (pthread_create(&p_readq->threads[j], NULL, run_reads,
(void*)p_readq->p_req_queue)) {
fprintf(stdout, "ERROR: create read thread %d:%d\n", i, j);
exit(-1);
}
}
}
pthread_t thr_add_readreqs;
if (pthread_create(&thr_add_readreqs, NULL, run_add_readreqs, NULL)) {
fprintf(stdout, "ERROR: create thread thr_add_readreqs\n");
exit(-1);
}
fprintf(stdout, "\n");
uint64_t now_us;
uint64_t count = 0;
while ((now_us = cf_getus()) < run_stop_us && g_running) {
count++;
int sleep_us = (int)
((count * g_report_interval_us) - (now_us - g_run_start_us));
if (sleep_us > 0) {
usleep((uint32_t)sleep_us);
}
fprintf(stdout, "After %" PRIu64 " sec:\n",
(count * g_report_interval_us) / 1000000);
fprintf(stdout, "read-reqs queued: %" PRIu64 "\n",
cf_atomic_int_get(g_read_reqs_queued));
histogram_dump(g_p_large_block_read_histogram, "LARGE BLOCK READS ");
histogram_dump(g_p_large_block_write_histogram, "LARGE BLOCK WRITES");
histogram_dump(g_p_raw_read_histogram, "RAW READS ");
for (int d = 0; d < g_num_devices; d++) {
histogram_dump(g_devices[d].p_raw_read_histogram,
g_devices[d].histogram_tag);
}
histogram_dump(g_p_read_histogram, "READS ");
fprintf(stdout, "\n");
fflush(stdout);
}
g_running = 0;
void* pv_value;
pthread_join(thr_add_readreqs, &pv_value);
for (int i = 0; i < g_num_queues; i++) {
readq* p_readq = &g_readqs[i];
for (int j = 0; j < g_threads_per_queue; j++) {
pthread_join(p_readq->threads[j], &pv_value);
}
cf_queue_destroy(p_readq->p_req_queue);
free(p_readq->threads);
}
for (int d = 0; d < g_num_devices; d++) {
device* p_device = &g_devices[d];
pthread_join(p_device->large_block_read_thread, &pv_value);
pthread_join(p_device->large_block_write_thread, &pv_value);
fd_close_all(p_device);
cf_queue_destroy(p_device->p_fd_queue);
free(p_device->p_large_block_read_buffer);
free(p_device->p_raw_read_histogram);
}
free(g_p_large_block_read_histogram);
free(g_p_large_block_write_histogram);
free(g_p_raw_read_histogram);
free(g_p_read_histogram);
destroy_salters();
return (0);
}
int main(int argc, char * argv[])
{
//============================================
// Set input parameters
if (argc < 4|| argc > 4){
printf("Wrong number of inputs. You entered %d. You should enter 4\n.", argc);
myusage();
}
int XLENGTH = atoi(argv[1]);
int YLENGTH = atoi(argv[2]);
int NCLUST = atoi(argv[3]);
int HLENGTH;
double px[XLENGTH];
double py[YLENGTH];
double beta = .00001;
double F;
double infocurve[4] = {1,1,1,1};
//int modus = 0;
// modus = 0 : use p(y|c) cluster centers as initialization
// modus = 1 : use p(c|x) assignment ruls as initialization
double annealingrate = 1.1;
bool plotme = true; //some debug printing
bool debug = false;//verbose debug printing
FILE * histFile;
FILE * probFile;
histogram_t *histo;
histogram_t *pxy;
histogram_t *pygc;
histogram_t *pcgx;
histogram_t *pc;
if(plotme)
{
printf("XLENGTH= %d\n", XLENGTH);
printf("YLENGTH= %d\n", YLENGTH);
printf("NCLUST = %d\n", NCLUST);
}
histFile = fopen(histoName, "r");
if(histFile == NULL)
{
printf("Error: can't access %s\n", histoName);
exit(1);
}
float v;
int j,i = 0;
int y;
int x;
char s [YLENGTH*20];
char * tok;
// //allocate memory for large cluster probability arrays
// double** pygc;
// //allocate pointer memory for first dimension
// pygc = (double**)malloc(YLENGTH*sizeof(double));
// if(NULL == pygc){free(pygc); printf("Memory allocation failed while allocating for pygc[].\n"); exit(-1);}
//
// /*allocate memory for second dimension */
// for(i = 0; i < YLENGTH;i++)
// {
// pygc[i] = (double *) malloc( NCLUST * sizeof(double) );
// if(NULL == pygc[i]){free(pygc[i]); printf("Memory allocation failed while allocating for matrix[x][].\n"); exit(-1);}
// }
//
// double** pcgx;
// //allocate pointer memory for first dimension
// pcgx = (double**)malloc(NCLUST*sizeof(double));
// if(NULL == pcgx){free(pcgx); printf("Memory allocation failed while allocating for pcgx[].\n"); exit(-1);}
//
// /*allocate memory for second dimension */
// for(i = 0; i < NCLUST;i++)
// {
// pcgx[i] = (double *) malloc( XLENGTH * sizeof(double) );
// if(NULL == pcgx[i]){free(pcgx[i]); printf("Memory allocation failed while allocating for matrix[x][].\n"); exit(-1);}
// }
//count how many entries are actually in the histogram file -- these are only the non-zero p(y|x)
while(fscanf(histFile, "%f", &v)!= EOF)
{
i++;
}
rewind(histFile);
if(debug){printf("Counted %d entries in histogram file\n", i);}
//make histogram size 1/2 number entries counted because 1/2 are the indices (y values)
HLENGTH = i/2;
histo = histogram_create(HLENGTH);
x = 0;
//make p(y|x) histogram
//YLENGTH*20 is assuming most words are less than 20 chars long
while(fgets(s, (YLENGTH*20), histFile)!= NULL)
{
tok = strtok(s,"\t");
while(tok != NULL)
{
if(debug){printf("Found word: %d\n", atoi(tok));}
y = atoi(tok);
tok = strtok(NULL, "\t");
if(tok != NULL) //hits null in the word
{
if(debug){printf("Found value: %f\n", atof(tok));}
v = atof(tok);
tok = strtok(NULL, "\t");
histogram_set(histo,x,y,v);
}
}
x++;
}
if(debug)
{
printf("Checking histogram\n");
for(x = 0; x < XLENGTH; x++)
{
for(y = 0; y < YLENGTH; y++)
{
if((v = histogram_get(histo, x, y)))
{
printf("Found doc %d - word %d in histo: %f\n",x,y,v);
}
}
}
}
fclose(histFile);
// now read in the other initial probs
probFile = fopen(probName, "r");
if(probFile == NULL)
{
printf("Error: can't access %s\n", histoName);
exit(1);
}
//*********** p(x) is first line *******************
printf("read in p(x)\n");
fgets(s, (XLENGTH*20), probFile);
//printf("s = %s\n",s);
// printf("length of s = %d\n", strlen(s));
tok = strtok(s,"\t");
x = 0;
while(tok != NULL)
{
//printf("tok = %s\n", tok);
if(strcmp(tok,"\n") != 0)
{
px[x] = atof(tok);
//printf("px(%d) = %f\n", x, px[x]);
x++;
}
tok = strtok(NULL,"\t");
}
//second line is blank
fgets(s, (YLENGTH*20), probFile);
//************** p(y) is third line ************************
fgets(s, (YLENGTH*20), probFile);
printf("read in p(y)\n");
// printf("s = %s\n",s);
// printf("length of s = %d\n", strlen(s));
tok = strtok(s,"\t");
x = 0;
while(tok != NULL)
{
if(strcmp(tok,"\n") != 0)
{
py[x] = atof(tok);
// printf("py(%d) = %f\n", x, py[x]);
x++;
}
tok = strtok(NULL,"\t");
}
//fourth line is blank
fgets(s,(YLENGTH*20), probFile);
//******************** fifth line on is p(xy)
printf("Making p(x;y)\n");
pxy = histogram_create(HLENGTH);
x = 0;
while(fgets(s, (YLENGTH*20), probFile)!= NULL)
{
//get line for doc
//printf("Found %s\n", s);
//split y and p
tok = strtok(s,"\t");
while(tok != NULL)
{
//printf("Found word: %d\n", atoi(tok));
y = atoi(tok);
tok = strtok(NULL, "\t");
if(tok != NULL) //hits null in the word
{
//printf("Found value: %f\n", atof(tok));
v = atof(tok);
tok = strtok(NULL, "\t");
histogram_set(pxy,x,y,v);
}
}
x++;
}
fclose(probFile);
if(debug){
printf("Checking pxy\n");
for(x = 0; x < XLENGTH; x++)
{
for(y = 0; y < YLENGTH; y++)
{
if((v = histogram_get(pxy, x, y)))
{
printf("Found doc %d - word %d in histo: %f\n",x,y,v);
}
}
}
}
//****************** initialize cluster probs *****************************
printf("Making p(c|x)\n");
ini_pcgx(NCLUST, XLENGTH, pcgx);
printf("Now going to anneal\n");
//******************* NOW GO TO ANNEAL **************************
F = anneal(XLENGTH, YLENGTH, NCLUST, beta, pxy, histo, pcgx, pygc, pc,
infocurve, annealingrate, plotme);
printf("Returned from anneal\n");
//cleanup
histogram_destroy(pxy);
histogram_destroy(histo);
histogram_destroy(pygc);
histogram_destroy(pcgx);
histogram_destroy(pc);
// for(i = 0; i < YLENGTH; i++)
// free(pygc[i]);
// free(pygc);
// for(i = 0; i < NCLUST; i++)
// free(pcgx[i]);
// free(pcgx);
exit(1);
}
int
main(int argc, char* argv[])
{
signal_setup();
fprintf(stdout, "\nACT version %s\n", VERSION);
fprintf(stdout, "Storage device IO test\n");
fprintf(stdout, "Copyright 2018 by Aerospike. All rights reserved.\n\n");
if (! storage_configure(argc, argv)) {
exit(-1);
}
device devices[g_scfg.num_devices];
queue* trans_qs[g_scfg.num_queues];
g_devices = devices;
g_trans_qs = trans_qs;
histogram_scale scale =
g_scfg.us_histograms ? HIST_MICROSECONDS : HIST_MILLISECONDS;
if (! (g_large_block_read_hist = histogram_create(scale)) ||
! (g_large_block_write_hist = histogram_create(scale)) ||
! (g_raw_read_hist = histogram_create(scale)) ||
! (g_read_hist = histogram_create(scale)) ||
! (g_raw_write_hist = histogram_create(scale)) ||
! (g_write_hist = histogram_create(scale))) {
exit(-1);
}
for (uint32_t n = 0; n < g_scfg.num_devices; n++) {
device* dev = &g_devices[n];
dev->name = (const char*)g_scfg.device_names[n];
if (g_scfg.file_size == 0) { // normally 0
set_scheduler(dev->name, g_scfg.scheduler_mode);
}
if (! (dev->fd_q = queue_create(sizeof(int), true)) ||
! discover_device(dev) ||
! (dev->raw_read_hist = histogram_create(scale)) ||
! (dev->raw_write_hist = histogram_create(scale))) {
exit(-1);
}
sprintf(dev->read_hist_tag, "%s-reads", dev->name);
sprintf(dev->write_hist_tag, "%s-writes", dev->name);
}
rand_seed();
g_run_start_us = get_us();
uint64_t run_stop_us = g_run_start_us + g_scfg.run_us;
g_running = true;
if (g_scfg.write_reqs_per_sec != 0) {
for (uint32_t n = 0; n < g_scfg.num_devices; n++) {
device* dev = &g_devices[n];
if (pthread_create(&dev->large_block_read_thread, NULL,
run_large_block_reads, (void*)dev) != 0) {
fprintf(stdout, "ERROR: create large op read thread\n");
exit(-1);
}
if (pthread_create(&dev->large_block_write_thread, NULL,
run_large_block_writes, (void*)dev) != 0) {
fprintf(stdout, "ERROR: create large op write thread\n");
exit(-1);
}
}
}
if (g_scfg.tomb_raider) {
for (uint32_t n = 0; n < g_scfg.num_devices; n++) {
device* dev = &g_devices[n];
if (pthread_create(&dev->tomb_raider_thread, NULL,
run_tomb_raider, (void*)dev) != 0) {
fprintf(stdout, "ERROR: create tomb raider thread\n");
exit(-1);
}
}
}
uint32_t n_trans_tids = g_scfg.num_queues * g_scfg.threads_per_queue;
pthread_t trans_tids[n_trans_tids];
for (uint32_t i = 0; i < g_scfg.num_queues; i++) {
if (! (g_trans_qs[i] = queue_create(sizeof(trans_req), true))) {
exit(-1);
}
for (uint32_t j = 0; j < g_scfg.threads_per_queue; j++) {
if (pthread_create(&trans_tids[(i * g_scfg.threads_per_queue) + j],
NULL, run_transactions, (void*)g_trans_qs[i]) != 0) {
fprintf(stdout, "ERROR: create transaction thread\n");
exit(-1);
}
}
}
// Equivalent: g_scfg.internal_read_reqs_per_sec != 0.
bool do_reads = g_scfg.read_reqs_per_sec != 0;
pthread_t read_req_tids[g_scfg.read_req_threads];
if (do_reads) {
for (uint32_t k = 0; k < g_scfg.read_req_threads; k++) {
if (pthread_create(&read_req_tids[k], NULL, run_generate_read_reqs,
NULL) != 0) {
fprintf(stdout, "ERROR: create read request thread\n");
exit(-1);
}
}
}
// Equivalent: g_scfg.internal_write_reqs_per_sec != 0.
bool do_commits = g_scfg.commit_to_device && g_scfg.write_reqs_per_sec != 0;
pthread_t write_req_tids[g_scfg.write_req_threads];
if (do_commits) {
for (uint32_t k = 0; k < g_scfg.write_req_threads; k++) {
if (pthread_create(&write_req_tids[k], NULL,
run_generate_write_reqs, NULL) != 0) {
fprintf(stdout, "ERROR: create write request thread\n");
exit(-1);
}
}
}
fprintf(stdout, "\nHISTOGRAM NAMES\n");
if (do_reads) {
fprintf(stdout, "reads\n");
fprintf(stdout, "device-reads\n");
for (uint32_t d = 0; d < g_scfg.num_devices; d++) {
fprintf(stdout, "%s\n", g_devices[d].read_hist_tag);
}
}
if (g_scfg.write_reqs_per_sec != 0) {
fprintf(stdout, "large-block-reads\n");
fprintf(stdout, "large-block-writes\n");
}
if (do_commits) {
fprintf(stdout, "writes\n");
fprintf(stdout, "device-writes\n");
for (uint32_t d = 0; d < g_scfg.num_devices; d++) {
fprintf(stdout, "%s\n", g_devices[d].write_hist_tag);
}
}
fprintf(stdout, "\n");
uint64_t now_us = 0;
uint64_t count = 0;
while (g_running && (now_us = get_us()) < run_stop_us) {
count++;
int64_t sleep_us = (int64_t)
((count * g_scfg.report_interval_us) -
(now_us - g_run_start_us));
if (sleep_us > 0) {
usleep((uint32_t)sleep_us);
}
fprintf(stdout, "after %" PRIu64 " sec:\n",
(count * g_scfg.report_interval_us) / 1000000);
fprintf(stdout, "requests-queued: %" PRIu32 "\n",
atomic32_get(g_reqs_queued));
if (do_reads) {
histogram_dump(g_read_hist, "reads");
histogram_dump(g_raw_read_hist, "device-reads");
for (uint32_t d = 0; d < g_scfg.num_devices; d++) {
histogram_dump(g_devices[d].raw_read_hist,
g_devices[d].read_hist_tag);
}
}
if (g_scfg.write_reqs_per_sec != 0) {
histogram_dump(g_large_block_read_hist, "large-block-reads");
histogram_dump(g_large_block_write_hist, "large-block-writes");
}
if (do_commits) {
histogram_dump(g_write_hist, "writes");
histogram_dump(g_raw_write_hist, "device-writes");
for (uint32_t d = 0; d < g_scfg.num_devices; d++) {
histogram_dump(g_devices[d].raw_write_hist,
g_devices[d].write_hist_tag);
}
}
fprintf(stdout, "\n");
fflush(stdout);
}
g_running = false;
if (do_reads) {
for (uint32_t k = 0; k < g_scfg.read_req_threads; k++) {
pthread_join(read_req_tids[k], NULL);
}
}
if (do_commits) {
for (uint32_t k = 0; k < g_scfg.write_req_threads; k++) {
pthread_join(write_req_tids[k], NULL);
}
}
for (uint32_t j = 0; j < n_trans_tids; j++) {
pthread_join(trans_tids[j], NULL);
}
for (uint32_t i = 0; i < g_scfg.num_queues; i++) {
queue_destroy(g_trans_qs[i]);
}
for (uint32_t d = 0; d < g_scfg.num_devices; d++) {
device* dev = &g_devices[d];
if (g_scfg.tomb_raider) {
pthread_join(dev->tomb_raider_thread, NULL);
}
if (g_scfg.write_reqs_per_sec != 0) {
pthread_join(dev->large_block_read_thread, NULL);
pthread_join(dev->large_block_write_thread, NULL);
}
fd_close_all(dev);
queue_destroy(dev->fd_q);
free(dev->raw_read_hist);
free(dev->raw_write_hist);
}
free(g_large_block_read_hist);
free(g_large_block_write_hist);
free(g_raw_read_hist);
free(g_read_hist);
free(g_raw_write_hist);
free(g_write_hist);
return 0;
}
int main(int argc, char* argv[]) {
signal(SIGSEGV, as_sig_handle_segv);
signal(SIGTERM, as_sig_handle_term);
fprintf(stdout, "\nAerospike act - device IO test\n");
fprintf(stdout, "Copyright 2011 by Aerospike. All rights reserved.\n\n");
if (! configure(argc, argv)) {
exit(-1);
}
set_schedulers();
srand(time(NULL));
// rand_seed(g_rand_64_buffer);
salter salters[g_num_write_buffers ? g_num_write_buffers : 1];
g_salters = salters;
if (! create_salters()) {
exit(-1);
}
device devices[g_num_devices];
g_devices = devices;
g_p_large_block_read_histogram = histogram_create();
g_p_large_block_write_histogram = histogram_create();
g_p_raw_read_histogram = histogram_create();
g_p_read_histogram = histogram_create();
g_run_start_ms = cf_getms();
uint64_t run_stop_ms = g_run_start_ms + g_run_ms;
g_running = 1;
int n;
for (n = 0; n < g_num_devices; n++)
{
device* p_device = &g_devices[n];
p_device->name = g_device_names[n];
p_device->p_fd_queue = cf_queue_create(sizeof(int), true);
discover_num_blocks(p_device);
create_large_block_read_buffer(p_device);
p_device->p_raw_read_histogram = histogram_create();
sprintf(p_device->histogram_tag, "%-18s", p_device->name);
if (pthread_create(&p_device->large_block_read_thread, NULL,
run_large_block_reads, (void*)p_device))
{
fprintf(stdout, "Error: create large block read thread %d\n", n);
exit(-1);
}
if (pthread_create(&p_device->large_block_write_thread, NULL,
run_large_block_writes, (void*)p_device))
{
fprintf(stdout, "Error: create write thread %d\n", n);
exit(-1);
}
}
aio_context_t aio_context = 0;
if(io_setup(MAXEVENTS, &aio_context) != 0)
{
fprintf(stdout, "Error: AIO context not set up \n");
exit(-1);
}
create_async_info_queue();
/* read events generating thread */
pthread_t read_generator;
if (pthread_create(&read_generator, NULL, &generate_async_reads, (void*)&aio_context))
{
fprintf(stdout, "Error: create read generator thread\n");
exit(-1);
}
/* Create the worker threads */
pthread_t workers[g_worker_threads];
int j;
for (j = 0; j < g_worker_threads; j++)
{
if (pthread_create(&workers[j], NULL, &worker_func , (void *)(&aio_context)))
{
fprintf(stdout, "Error: creating worker thread %d failed\n", j);
exit(-1);
}
}
fprintf(stdout, "\n");
uint64_t now_ms;
uint64_t time_count = 0;
int nanosleep_ret = -1;
struct timespec initial,remaining;
while ((now_ms = cf_getms()) < run_stop_ms && g_running)
{
time_count++;
int sleep_ms = (int)
((time_count * g_report_interval_ms) - (now_ms - g_run_start_ms));
if (sleep_ms > 0)
{
initial.tv_sec = sleep_ms / 1000;
initial.tv_nsec = (sleep_ms % 1000) * 1000000;
retry:
memset(&remaining, 0, sizeof(remaining));
nanosleep_ret = nanosleep(&initial, &remaining);
if(nanosleep_ret == -1 && errno == EINTR)
{
/* Interrupted by a signal */
initial.tv_sec = remaining.tv_sec;
initial.tv_nsec = remaining.tv_nsec;
goto retry;
}
}
fprintf(stdout, "After %" PRIu64 " sec:\n",
(time_count * g_report_interval_ms) / 1000);
fprintf(stdout, "read-reqs queued: %" PRIu64 "\n",
cf_atomic_int_get(g_read_reqs_queued));
histogram_dump(g_p_large_block_read_histogram, "LARGE BLOCK READS ");
histogram_dump(g_p_large_block_write_histogram, "LARGE BLOCK WRITES");
histogram_dump(g_p_raw_read_histogram, "RAW READS ");
int d;
for (d = 0; d < g_num_devices; d++) {
histogram_dump(g_devices[d].p_raw_read_histogram,
g_devices[d].histogram_tag);
}
histogram_dump(g_p_read_histogram, "READS ");
fprintf(stdout, "\n");
fflush(stdout);
}
fprintf(stdout, "\nTEST COMPLETED \n");
g_running = 0;
int i;
//TODO aio_destroy?
/* Freeing resources used by async */
void* ret_value;
for (i = 0; i < g_worker_threads; i++)
{
pthread_join(workers[i], &ret_value);
}
destroy_async_info_queue();
int d;
for (d = 0; d < g_num_devices; d++) {
device* p_device = &g_devices[d];
pthread_join(p_device->large_block_read_thread, &ret_value);
pthread_join(p_device->large_block_write_thread, &ret_value);
fd_close_all(p_device);
cf_queue_destroy(p_device->p_fd_queue);
free(p_device->p_large_block_read_buffer);
free(p_device->p_raw_read_histogram);
}
free(g_p_large_block_read_histogram);
free(g_p_large_block_write_histogram);
free(g_p_raw_read_histogram);
free(g_p_read_histogram);
destroy_salters();
return (0);
}
struct category *category_lookup_or_create(struct hash_table *categories, const char *name) {
struct category *c;
if(!name)
name = "default";
c = hash_table_lookup(categories, name);
if(c) return c;
c = calloc(1, sizeof(struct category));
c->name = xxstrdup(name);
c->fast_abort = -1;
c->total_tasks = 0;
c->first_allocation = NULL;
c->max_allocation = rmsummary_create(-1);
c->autolabel_resource = rmsummary_create(0);
c->max_resources_seen = rmsummary_create(-1);
c->cores_histogram = histogram_create(1);
c->wall_time_histogram = histogram_create(time_bucket_size);
c->cpu_time_histogram = histogram_create(time_bucket_size);
c->memory_histogram = histogram_create(memory_bucket_size);
c->swap_memory_histogram = histogram_create(memory_bucket_size);
c->virtual_memory_histogram = histogram_create(memory_bucket_size);
c->bytes_read_histogram = histogram_create(bytes_bucket_size);
c->bytes_written_histogram = histogram_create(bytes_bucket_size);
c->bytes_received_histogram = histogram_create(bytes_bucket_size);
c->bytes_sent_histogram = histogram_create(bytes_bucket_size);
c->bandwidth_histogram = histogram_create(bandwidth_bucket_size);
c->total_files_histogram = histogram_create(1);
c->disk_histogram = histogram_create(disk_bucket_size);
c->total_processes_histogram = histogram_create(1);
c->max_concurrent_processes_histogram = histogram_create(1);
c->time_peak_independece = 0;
c->steady_state = 0;
c->completions_since_last_reset = 0;
c->allocation_mode = CATEGORY_ALLOCATION_MODE_FIXED;
hash_table_insert(categories, name, c);
return c;
}
