/*
	 * Copyright (c) 2009 Red Hat, Inc.
	 *
	 * All rights reserved.
	 *
	 * Author: Steven Dake (sdake@redhat.com)
	 *
	 * libqb is free software: you can redistribute it and/or modify
	 * it under the terms of the GNU Lesser General Public License as published by
	 * the Free Software Foundation, either version 2.1 of the License, or
	 * (at your option) any later version.
	 *
	 * libqb 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 Lesser General Public License for more details.
	 *
	 * You should have received a copy of the GNU Lesser General Public License
	 * along with libqb.  If not, see <http://www.gnu.org/licenses/>.
	 */
	
	#include <sys/types.h>
	#include <sys/socket.h>
	#include <qb/qbipcc.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <string.h>
	#include <sys/time.h>
	#include <time.h>
	#include <unistd.h>
	#include <signal.h>
	
	#include <qb/qbrb.h>
	#include <qb/qbdefs.h>
	#include <qb/qbutil.h>
	#include <qb/qblog.h>
	
	static int alarm_notice = 0;
	static qb_ringbuffer_t *rb = NULL;
	static qb_util_stopwatch_t *sw;
	#define ONE_MEG 1048576
	static char buffer[ONE_MEG * 3];
	
	static void sigalrm_handler (int num)
	{
		alarm_notice = 1;
	}
	
	static void sigterm_handler(int32_t num)
	{
		qb_log(LOG_INFO, "writer: %s(%d)\n", __func__, num);
		qb_rb_close(rb);
		exit(0);
	}
	
	static void
	_benchmark(ssize_t write_size)
	{
		ssize_t res;
		int write_count = 0;
		float secs;
	
		alarm_notice = 0;
	
		alarm (10);
	
		qb_util_stopwatch_start(sw);
		do {
			res = qb_rb_chunk_write(rb, buffer, write_size);

			if (res == write_size) {
				write_count++;

			}

		} while (alarm_notice == 0 && (res == write_size || res == -EAGAIN));

		if (res < 0) {
			perror("qb_ipcc_sendv");
		}
		qb_util_stopwatch_stop(sw);

		secs = qb_util_stopwatch_sec_elapsed_get(sw);
	
		printf ("%5d messages sent ", write_count);
		printf ("%5ld bytes per write ", (long int) write_size);
		printf ("%7.3f Seconds runtime ", secs);
		printf ("%9.3f TP/s ",
			((float)write_count) / secs);

		printf ("%7.3f MB/s.\n",
			((float)write_count) * ((float)write_size) / secs);
	}
	
	
	static void
	do_throughput_benchmark(void)
	{
		ssize_t size = 64;
		int i;
	
		signal (SIGALRM, sigalrm_handler);
		sw =  qb_util_stopwatch_create();
	
		for (i = 0; i < 10; i++) { /* number of repetitions - up to 50k */
			_benchmark(size);
			signal (SIGALRM, sigalrm_handler);
			size *= 5;
			if (size >= ONE_MEG) {
				break;
			}
		}
	}
	
	static void show_usage(const char *name)
	{
		printf("usage: \n");
		printf("%s <options>\n", name);
		printf("\n");
		printf("  options:\n");
		printf("\n");
		printf("  -n             non-blocking ipc (default blocking)\n");
		printf("  -v             verbose\n");
		printf("  -h             show this help text\n");
		printf("\n");
	}
	
	int32_t main(int32_t argc, char *argv[])
	{
		const char *options = "vh";
		int32_t opt;
		int32_t verbose = 0;
	
		while ((opt = getopt(argc, argv, options)) != -1) {
			switch (opt) {
			case 'v':
				verbose++;
				break;
			case 'h':
			default:
				show_usage(argv[0]);
				exit(0);
				break;
			}
		}
	
		signal(SIGINT, sigterm_handler);
	
		qb_log_init("rbwriter", LOG_USER, LOG_EMERG);
		qb_log_ctl(QB_LOG_SYSLOG, QB_LOG_CONF_ENABLED, QB_FALSE);
		qb_log_filter_ctl(QB_LOG_STDERR, QB_LOG_FILTER_ADD,
				  QB_LOG_FILTER_FILE, "*", LOG_INFO + verbose);
		qb_log_ctl(QB_LOG_STDERR, QB_LOG_CONF_ENABLED, QB_TRUE);
	
		rb = qb_rb_open("tester", ONE_MEG * 3,
				QB_RB_FLAG_SHARED_PROCESS, 0);
		do_throughput_benchmark();
		qb_rb_close(rb);
		qb_log_fini();
		return EXIT_SUCCESS;
	}