utils/ffsb-6.0-rc2/main.c - platform/external/ltp - Git at Google

 /*
  *   Copyright (c) International Business Machines Corp., 2001-2004
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  *   the GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include <pthread.h>
 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>

 #include <assert.h>

 #include "config.h"

 #include "ffsb.h"
 #include "util.h"
 #include "parser.h"

 /* State information for the polling function below */
 struct ffsb_time_poll {
 	struct timeval starttime;
 	int wait_time;
 };

 /* This is the polling function used by the threadgroups to check
  * elapsed time, when it returns 1 they know it is time to stop
  */
 static int ffsb_poll_fn(void *ptr)
 {
 	struct ffsb_time_poll *data = (struct ffsb_time_poll *)ptr;
 	struct timeval curtime, difftime;
 	gettimeofday(&curtime, NULL);

 	timersub(&curtime, &data->starttime, &difftime);
 	if (difftime.tv_sec >= data->wait_time)
 		return 1;
 	return 0;
 }

 int main(int argc, char *argv[])
 {
 	int i;
 	ffsb_config_t fc;
 	ffsb_barrier_t thread_barrier, tg_barrier;
 	tg_run_params_t *params;
 	struct ffsb_time_poll pdata;
 	struct timeval starttime, endtime, difftime;
 	pthread_attr_t attr;
 	ffsb_op_results_t total_results;
 	double totaltime = 0.0f, usertime = 0.0f, systime = 0.0f;
 	struct rusage before_self, before_children, after_self, after_children;
 	pthread_t *fs_pts;	/* threads to do filesystem creates in parallel */
 	char *callout = NULL;

 	char ctime_start_buf[32];
 	char ctime_end_buf[32];

 	memset(&before_self, 0, sizeof(before_self));
 	memset(&before_children, 0, sizeof(before_children));
 	memset(&after_self, 0, sizeof(after_self));
 	memset(&after_children, 0, sizeof(after_children));

 	ffsb_unbuffer_stdout();

 	if (argc < 2) {
 		fprintf(stderr, "usage: %s <config file>\n", argv[0]);
 		exit(1);
 	}

 	/* VERSION comes from config.h (which is autogenerated by autoconf) */
 	printf("FFSB version %s started\n\n", VERSION);

 	ffsb_parse_newconfig(&fc, argv[1]);
 	pdata.wait_time = fc.time;

 	if (fc.time)
 		printf("benchmark time = %u\n", fc.time);
 	else
 		printf("Only creating the fileset, not running benchmark.\n");

 	pthread_attr_init(&attr);
 	pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

 	for (i = 0; i < fc.num_threadgroups; i++)
 		tg_print_config(&fc.groups[i]);

 	fs_pts = ffsb_malloc(sizeof(pthread_t) * fc.num_filesys);

 	gettimeofday(&starttime, NULL);
 	for (i = 0; i < fc.num_filesys; i++) {
 		fs_print_config(&fc.filesystems[i]);
 		pthread_create(fs_pts + i, &attr, construct_ffsb_fs,
 			       &fc.filesystems[i]);
 	}

 	fflush(stdout);
 	for (i = 0; i < fc.num_filesys; i++)
 		pthread_join(fs_pts[i], NULL);

 	gettimeofday(&endtime, NULL);
 	timersub(&endtime, &starttime, &difftime);
 	printf("fs setup took %ld secs\n", difftime.tv_sec);
 	free(fs_pts);

 	if (fc.time == 0) {
 		printf("Setup complete, exiting\n");
 		return 0;
 	}

 	params = ffsb_malloc(sizeof(tg_run_params_t) * fc.num_threadgroups);

 	init_ffsb_op_results(&total_results);
 	ffsb_barrier_init(&thread_barrier, fc.num_totalthreads);
 	ffsb_barrier_init(&tg_barrier, fc.num_threadgroups + 1);

 	ffsb_sync();

 	/* Execute the callout if any and wait for it to return */
 	callout = fc_get_callout(&fc);
 	if (callout) {
 		printf("executing callout: \n %s\n", callout);
 		if (ffsb_system(callout) < 0) {
 			perror("system");
 			exit(1);
 		}
 	}

 	/* Spawn all of the threadgroup master threads */
 	for (i = 0; i < fc.num_threadgroups; i++) {
 		params[i].tg = &fc.groups[i];
 		params[i].fc = &fc;
 		params[i].poll_fn = ffsb_poll_fn;
 		params[i].poll_data = &pdata;
 		params[i].wait_time = FFSB_TG_WAIT_TIME;
 		params[i].tg_barrier = &tg_barrier;
 		params[i].thread_barrier = &thread_barrier;

 		pthread_create(&params[i].pt, &attr, tg_run, &params[i]);
 	}

 	ffsb_getrusage(&before_self, &before_children);
 	gettimeofday(&pdata.starttime, NULL);

 	ffsb_barrier_wait(&tg_barrier);	/* sync with tg's to start */
 	printf("Starting Actual Benchmark At: %s\n",
 	       ctime_r(&pdata.starttime.tv_sec, ctime_start_buf));
 	fflush(stdout);

 	/* Wait for all of the threadgroup master threads to finish */
 	for (i = 0; i < fc.num_threadgroups; i++)
 		pthread_join(params[i].pt, NULL);

 	ffsb_sync();
 	gettimeofday(&endtime, NULL);
 	ffsb_getrusage(&after_self, &after_children);

 	printf("FFSB benchmark finished   at: %s\n",
 	       ctime_r(&endtime.tv_sec, ctime_end_buf));
 	printf("Results:\n");
 	fflush(stdout);

 	timersub(&endtime, &pdata.starttime, &difftime);

 	totaltime = tvtodouble(&difftime);

 	printf("Benchmark took %.2lf sec\n", totaltime);
 	printf("\n");

 	for (i = 0; i < fc.num_threadgroups; i++) {
 		struct ffsb_op_results tg_results;
 		ffsb_tg_t *tg = fc.groups + i;

 		init_ffsb_op_results(&tg_results);

 		/* Grab the individual tg results */
 		tg_collect_results(tg, &tg_results);

 		if (fc.num_threadgroups == 1)
 			printf("Total Results\n");
 		else
 			printf("ThreadGroup %d\n", i);

 		printf("===============\n");
 		print_results(&tg_results, totaltime);

 		if (tg_needs_stats(tg)) {
 			ffsb_statsd_t fsd;
 			tg_collect_stats(tg, &fsd);
 			ffsb_statsd_print(&fsd);
 		}
 		printf("\n");

 		/* Add the tg results to the total */
 		tg_collect_results(&fc.groups[i], &total_results);
 	}

 	if (fc.num_threadgroups > 1) {
 		printf("Total Results\n");
 		printf("===============\n");
 		print_results(&total_results, totaltime);
 	}
 #define USEC_PER_SEC ((double)(1000000.0f))

 	/* sum up self and children after */
 	usertime = (after_self.ru_utime.tv_sec +
 		    ((after_self.ru_utime.tv_usec) / USEC_PER_SEC)) +
 	    ((after_children.ru_utime.tv_sec +
 	      ((after_children.ru_utime.tv_usec) / USEC_PER_SEC)));

 	/* subtract away the before */
 	usertime -= (before_self.ru_utime.tv_sec +
 		     ((before_self.ru_utime.tv_usec) / USEC_PER_SEC)) +
 	    ((before_children.ru_utime.tv_sec +
 	      ((before_children.ru_utime.tv_usec) / USEC_PER_SEC)));

 	/* sum up self and children after */
 	systime = (after_self.ru_stime.tv_sec +
 		   ((after_self.ru_stime.tv_usec) / USEC_PER_SEC)) +
 	    ((after_children.ru_stime.tv_sec +
 	      ((after_children.ru_stime.tv_usec) / USEC_PER_SEC)));

 	/* subtract away the before */
 	systime -= (before_self.ru_stime.tv_sec +
 		    ((before_self.ru_stime.tv_usec) / USEC_PER_SEC)) +
 	    ((before_children.ru_stime.tv_sec +
 	      ((before_children.ru_stime.tv_usec) / USEC_PER_SEC)));

 	printf("\n\n");
 	printf("%.1lf%% User   Time\n", 100 * usertime / totaltime);
 	printf("%.1lf%% System Time\n", 100 * systime / totaltime);
 	printf("%.1f%% CPU Utilization\n", 100 * (usertime + systime) /
 	       totaltime);
 	free(params);
 	destroy_ffsb_config(&fc);

 	return 0;
 }
	/*
	* Copyright (c) International Business Machines Corp., 2001-2004
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	* the GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/
	#include <pthread.h>
	#include <sys/time.h>
	#include <sys/times.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#include <string.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <pthread.h>

	#include <assert.h>

	#include "config.h"

	#include "ffsb.h"
	#include "util.h"
	#include "parser.h"

	/* State information for the polling function below */
	struct ffsb_time_poll {
	struct timeval starttime;
	int wait_time;
	};

	/* This is the polling function used by the threadgroups to check
	* elapsed time, when it returns 1 they know it is time to stop
	*/
	static int ffsb_poll_fn(void *ptr)
	{
	struct ffsb_time_poll data = (struct ffsb_time_poll )ptr;
	struct timeval curtime, difftime;
	gettimeofday(&curtime, NULL);

	timersub(&curtime, &data->starttime, &difftime);
	if (difftime.tv_sec >= data->wait_time)
	return 1;
	return 0;
	}

	int main(int argc, char *argv[])
	{
	int i;
	ffsb_config_t fc;
	ffsb_barrier_t thread_barrier, tg_barrier;
	tg_run_params_t *params;
	struct ffsb_time_poll pdata;
	struct timeval starttime, endtime, difftime;
	pthread_attr_t attr;
	ffsb_op_results_t total_results;
	double totaltime = 0.0f, usertime = 0.0f, systime = 0.0f;
	struct rusage before_self, before_children, after_self, after_children;
	pthread_t fs_pts; / threads to do filesystem creates in parallel */
	char *callout = NULL;

	char ctime_start_buf[32];
	char ctime_end_buf[32];

	memset(&before_self, 0, sizeof(before_self));
	memset(&before_children, 0, sizeof(before_children));
	memset(&after_self, 0, sizeof(after_self));
	memset(&after_children, 0, sizeof(after_children));

	ffsb_unbuffer_stdout();

	if (argc < 2) {
	fprintf(stderr, "usage: %s <config file>\n", argv[0]);
	exit(1);
	}

	/* VERSION comes from config.h (which is autogenerated by autoconf) */
	printf("FFSB version %s started\n\n", VERSION);

	ffsb_parse_newconfig(&fc, argv[1]);
	pdata.wait_time = fc.time;

	if (fc.time)
	printf("benchmark time = %u\n", fc.time);
	else
	printf("Only creating the fileset, not running benchmark.\n");

	pthread_attr_init(&attr);
	pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

	for (i = 0; i < fc.num_threadgroups; i++)
	tg_print_config(&fc.groups[i]);

	fs_pts = ffsb_malloc(sizeof(pthread_t) * fc.num_filesys);

	gettimeofday(&starttime, NULL);
	for (i = 0; i < fc.num_filesys; i++) {
	fs_print_config(&fc.filesystems[i]);
	pthread_create(fs_pts + i, &attr, construct_ffsb_fs,
	&fc.filesystems[i]);
	}

	fflush(stdout);
	for (i = 0; i < fc.num_filesys; i++)
	pthread_join(fs_pts[i], NULL);

	gettimeofday(&endtime, NULL);
	timersub(&endtime, &starttime, &difftime);
	printf("fs setup took %ld secs\n", difftime.tv_sec);
	free(fs_pts);

	if (fc.time == 0) {
	printf("Setup complete, exiting\n");
	return 0;
	}

	params = ffsb_malloc(sizeof(tg_run_params_t) * fc.num_threadgroups);

	init_ffsb_op_results(&total_results);
	ffsb_barrier_init(&thread_barrier, fc.num_totalthreads);
	ffsb_barrier_init(&tg_barrier, fc.num_threadgroups + 1);

	ffsb_sync();

	/* Execute the callout if any and wait for it to return */
	callout = fc_get_callout(&fc);
	if (callout) {
	printf("executing callout: \n %s\n", callout);
	if (ffsb_system(callout) < 0) {
	perror("system");
	exit(1);
	}
	}

	/* Spawn all of the threadgroup master threads */
	for (i = 0; i < fc.num_threadgroups; i++) {
	params[i].tg = &fc.groups[i];
	params[i].fc = &fc;
	params[i].poll_fn = ffsb_poll_fn;
	params[i].poll_data = &pdata;
	params[i].wait_time = FFSB_TG_WAIT_TIME;
	params[i].tg_barrier = &tg_barrier;
	params[i].thread_barrier = &thread_barrier;

	pthread_create(&params[i].pt, &attr, tg_run, &params[i]);
	}

	ffsb_getrusage(&before_self, &before_children);
	gettimeofday(&pdata.starttime, NULL);

	ffsb_barrier_wait(&tg_barrier); /* sync with tg's to start */
	printf("Starting Actual Benchmark At: %s\n",
	ctime_r(&pdata.starttime.tv_sec, ctime_start_buf));
	fflush(stdout);

	/* Wait for all of the threadgroup master threads to finish */
	for (i = 0; i < fc.num_threadgroups; i++)
	pthread_join(params[i].pt, NULL);

	ffsb_sync();
	gettimeofday(&endtime, NULL);
	ffsb_getrusage(&after_self, &after_children);

	printf("FFSB benchmark finished at: %s\n",
	ctime_r(&endtime.tv_sec, ctime_end_buf));
	printf("Results:\n");
	fflush(stdout);

	timersub(&endtime, &pdata.starttime, &difftime);

	totaltime = tvtodouble(&difftime);

	printf("Benchmark took %.2lf sec\n", totaltime);
	printf("\n");

	for (i = 0; i < fc.num_threadgroups; i++) {
	struct ffsb_op_results tg_results;
	ffsb_tg_t *tg = fc.groups + i;

	init_ffsb_op_results(&tg_results);

	/* Grab the individual tg results */
	tg_collect_results(tg, &tg_results);

	if (fc.num_threadgroups == 1)
	printf("Total Results\n");
	else
	printf("ThreadGroup %d\n", i);

	printf("===============\n");
	print_results(&tg_results, totaltime);

	if (tg_needs_stats(tg)) {
	ffsb_statsd_t fsd;
	tg_collect_stats(tg, &fsd);
	ffsb_statsd_print(&fsd);
	}
	printf("\n");

	/* Add the tg results to the total */
	tg_collect_results(&fc.groups[i], &total_results);
	}

	if (fc.num_threadgroups > 1) {
	printf("Total Results\n");
	printf("===============\n");
	print_results(&total_results, totaltime);
	}
	#define USEC_PER_SEC ((double)(1000000.0f))

	/* sum up self and children after */
	usertime = (after_self.ru_utime.tv_sec +
	((after_self.ru_utime.tv_usec) / USEC_PER_SEC)) +
	((after_children.ru_utime.tv_sec +
	((after_children.ru_utime.tv_usec) / USEC_PER_SEC)));

	/* subtract away the before */
	usertime -= (before_self.ru_utime.tv_sec +
	((before_self.ru_utime.tv_usec) / USEC_PER_SEC)) +
	((before_children.ru_utime.tv_sec +
	((before_children.ru_utime.tv_usec) / USEC_PER_SEC)));

	/* sum up self and children after */
	systime = (after_self.ru_stime.tv_sec +
	((after_self.ru_stime.tv_usec) / USEC_PER_SEC)) +
	((after_children.ru_stime.tv_sec +
	((after_children.ru_stime.tv_usec) / USEC_PER_SEC)));

	/* subtract away the before */
	systime -= (before_self.ru_stime.tv_sec +
	((before_self.ru_stime.tv_usec) / USEC_PER_SEC)) +
	((before_children.ru_stime.tv_sec +
	((before_children.ru_stime.tv_usec) / USEC_PER_SEC)));

	printf("\n\n");
	printf("%.1lf%% User Time\n", 100 * usertime / totaltime);
	printf("%.1lf%% System Time\n", 100 * systime / totaltime);
	printf("%.1f%% CPU Utilization\n", 100 * (usertime + systime) /
	totaltime);
	free(params);
	destroy_ffsb_config(&fc);

	return 0;
	}