void display_close(void)
{
switch(DisplayMode) {
case DisplayReport:
report_close();
break;
case DisplayTXT:
txt_close();
break;
case DisplayXML:
xml_close();
break;
case DisplayCSV:
csv_close();
break;
case DisplayCurses:
mtr_curses_close();
break;
case DisplaySplit: /* BL */
split_close();
break;
case DisplayGTK:
gtk_close();
break;
}
}
void display_close(time_t now)
{
switch(DisplayMode) {
case DisplayReport:
report_close();
break;
case DisplayTXT:
txt_close();
break;
case DisplayXML:
xml_close();
break;
case DisplayJSON:
json_close();
break;
case DisplayCSV:
csv_close(now);
break;
case DisplayCurses:
#ifdef IPINFO
if (ipinfo_no >= 0)
asn_close();
#endif
mtr_curses_close();
break;
case DisplaySplit:
split_close();
break;
case DisplayGTK:
gtk_close();
break;
}
}
int
main (int argc, char *argv[])
{
GError *err = NULL;
Csv *csv;
GList *cur;
if (argc != 2) {
g_printerr ("Usage: %s CSVFILE\n", argv[0]);
exit (EXIT_FAILURE);
}
if ((csv = csv_open_r (argv[1], DELIMITER, &err)) == NULL) {
g_printerr ("%s: %s\n", argv[0], err->message);
g_error_free (err);
exit (EXIT_FAILURE);
}
while (csv_read_row (csv, &err) != NULL) {
for (cur = csv->row; cur != NULL; cur = cur->next)
g_print ("{%s}\n", (gchar*)cur->data);
g_print ("\n");
}
if (err) {
g_printerr ("%s\n", err->message);
g_error_free (err);
}
csv_close (csv);
return EXIT_SUCCESS;
}
int main(int argc, char **argv) {
const int maxThreads = omp_get_max_threads();
if (argc < 4) {
fprintf(stderr, "Usage: bench <csv file> <input size> <num threads> [<num threads> ...]\n");
return -1;
}
FILE *const csvFile = csv_open(argv[1]);
if (csvFile == NULL) {
return -1;
}
const int len = safe_strtol(argv[2]);
if (len < 1) {
fprintf(stderr, "Input size must be positive\n");
return -1;
}
TYPE *nrs = random_array(len, time(NULL));
if (nrs == NULL) {
return -1;
}
for (int i = 3; i < argc; i++) {
int threads = safe_strtol(argv[i]);
if (threads < 1) {
threads = maxThreads;
}
omp_set_num_threads(threads);
printf("%s. omp_get_max_threads() == %d\n", algorithm_name, threads);
/* Bench the parallel implementation. */
double start = omp_get_wtime();
if (prefix_sums(nrs, len, NULL) != 0) {
return -1;
}
double par_time = omp_get_wtime() - start;
printf("elements: %d; par time: %f\n\n",
len, par_time);
fprintf(csvFile, "%s,%d,%d,%f\n", algorithm_name, threads, len, par_time);
}
free(nrs);
csv_close(csvFile);
return 0;
}
/*
** Decrement the CSV reference count. When the reference count reaches
** zero the structure is deleted.
*/
static int csvRelease( CSV *pCSV ){
pCSV->nBusy--;
if( pCSV->nBusy<1 ){
/* finalize any prepared statements here */
csv_close( pCSV );
if( pCSV->zRow ) sqlite3_free( pCSV->zRow );
if( pCSV->aCols ) sqlite3_free( pCSV->aCols );
if( pCSV->aEscapedQuotes ) sqlite3_free( pCSV->aEscapedQuotes );
sqlite3_free( pCSV );
}
return 0;
}
int main(int argc, char **argv)
{
int ret = 0;
MPI_Init(&argc, &argv);
if (argc < 4) {
fprintf(stderr, "Usage: bench <csv file> <input size> <input upper bound>\n");
ret = -1;
goto out;
}
const int size = safe_strtol(argv[2]);
if (size < 1) {
fprintf(stderr, "Input size must be greater than 0\n");
ret = -1;
goto out;
}
const int upper_bound = safe_strtol(argv[3]);
if (size < 1) {
fprintf(stderr, "Input upper bound must be greater than 0\n");
ret = -1;
goto out;
}
int processes;
MPI_Comm_size(MPI_COMM_WORLD, &processes);
int rank;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
/* We need to generate the same array in each process. The master process
* determines a seed and broadcasts it to all others. */
int seed = time(NULL);
MPI_Bcast(&seed, 1, MPI_INT, MASTER, MPI_COMM_WORLD);
TYPE *a = random_array(size, upper_bound, seed);
DEBUG("%s. MPI_Comm_size %d, MPI_Comm_rank %d, seed %d\n",
algorithm_name, processes, rank, seed);
/* Everything is set up, start sorting and time how long it takes. */
MPI_Barrier(MPI_COMM_WORLD);
double start = MPI_Wtime();
TYPE *c = bucket_sort(a, size, upper_bound);
double end = MPI_Wtime();
double localElapsed = end - start;
double totalElapsed;
MPI_Reduce(&localElapsed, &totalElapsed, 1, MPI_DOUBLE, MPI_MAX, MASTER, MPI_COMM_WORLD);
free(a);
free(c);
/* Only the master process (rank 0) outputs information. */
if (rank == MASTER) {
printf("processes: %d, elements: %d; upper bound: %d; time: %f\n",
processes, size, upper_bound, totalElapsed);
/* Persist this run in our csv file. */
FILE *const csvFile = csv_open(argv[1]);
if (csvFile == NULL) {
return -1;
}
fprintf(csvFile, "%s,%d,%d,%f\n", algorithm_name, processes, size, totalElapsed);
csv_close(csvFile);
}
out:
MPI_Finalize();
return ret;
}
int csvredis_close(struct state_conf* c, struct state_send* s, struct state_recv* r)
{
csv_close(c,s,r);
redismodule_close(c,s,r);
return EXIT_SUCCESS;
}
