Context Navigation

source: benchmark/readyQ/rq_bench.hpp @ de3a579

Last change on this file since de3a579 was 8faa6612, checked in by Thierry Delisle <tdelisle@…>, 2 years ago
Minor fixes to how benchmarks handle yes/no arguments
Property mode set to `100644`
File size: 11.4 KB

Rev	Line
[2c7eee0]	1	#include <cassert>
[f9b2e73]	2	#include <climits>
	3	#include <cstdint>
	4	#include <cstdio>
[2c7eee0]	5
	6	#include <time.h> // timespec
	7	#include <sys/time.h> // timeval
	8
[56ac392]	9	typedef __uint128_t __lehmer64_state_t;
	10	static inline uint64_t __lehmer64( __lehmer64_state_t & state ) {
	11	state *= 0xda942042e4dd58b5;
	12	return state >> 64;
	13	}
	14
[2c7eee0]	15	enum { TIMEGRAN = 1000000000LL }; // nanosecond granularity, except for timeval
	16
	17
	18	volatile bool stop = false;
	19	bool clock_mode;
	20	double duration = -1;
	21	unsigned long long stop_count = 0;
	22	unsigned nprocs = 1;
	23	unsigned nthreads = 1;
	24
	25	volatile unsigned long long threads_left;
	26
	27	#define BENCH_OPT \
	28	{'d', "duration", "Duration of the experiments in seconds", duration }, \
	29	{'i', "iterations", "Number of iterations of the experiments", stop_count }, \
	30	{'t', "nthreads", "Number of threads to use", nthreads }, \
	31	{'p', "nprocs", "Number of processors to use", nprocs }
	32
	33	#define BENCH_OPT_PARSE(name) \
	34	{ \
	35	int opt_cnt = sizeof(opt) / sizeof(option_t); \
	36	char **left; \
	37	parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]...\n" name, &left ); \
	38	if(duration > 0 && stop_count > 0) { \
	39	fprintf(stderr, "--duration and --iterations cannot be used together\n"); \
	40	print_args_usage(argc, argv, opt, opt_cnt, "[OPTIONS]...\n" name, true); \
	41	} else if(duration > 0) { \
	42	clock_mode = true; \
	43	stop_count = 0xFFFFFFFFFFFFFFFF; \
	44	printf("Running for %lf seconds\n", duration); \
	45	} else if(stop_count > 0) { \
	46	clock_mode = false; \
	47	printf("Running for %llu iterations\n", stop_count); \
	48	} else { \
	49	duration = 5; clock_mode = true;\
	50	printf("Running for %lf seconds\n", duration); \
	51	} \
	52	}
	53
[e54d0c3]	54	uint64_t timeHiRes() {
[2c7eee0]	55	timespec curr;
	56	clock_gettime( CLOCK_REALTIME, &curr );
	57	return (int64_t)curr.tv_sec * TIMEGRAN + curr.tv_nsec;
	58	}
	59
	60	uint64_t to_miliseconds( uint64_t durtn ) { return durtn / (TIMEGRAN / 1000LL); }
	61	double to_fseconds(uint64_t durtn ) { return durtn / (double)TIMEGRAN; }
	62	uint64_t from_fseconds(double sec) { return sec * TIMEGRAN; }
	63
[f9b2e73]	64	template<typename Sleeper>
[2c7eee0]	65	void wait(const uint64_t & start, bool is_tty) {
	66	for(;;) {
[f9b2e73]	67	Sleeper::usleep(100000);
[e54d0c3]	68	uint64_t end = timeHiRes();
[2c7eee0]	69	uint64_t delta = end - start;
	70	if(is_tty) {
	71	printf(" %.1f\r", to_fseconds(delta));
	72	fflush(stdout);
	73	}
	74	if( clock_mode && delta >= from_fseconds(duration) ) {
	75	break;
	76	}
	77	else if( !clock_mode && threads_left == 0 ) {
	78	break;
	79	}
	80	}
	81	}
	82
[56ac392]	83	class Fibre;
	84	int fibre_park();
	85	int fibre_unpark( Fibre * );
	86	Fibre * fibre_self();
	87
	88	class __attribute__((aligned(128))) bench_sem {
	89	Fibre * volatile ptr = nullptr;
	90	public:
	91	inline bool wait() {
	92	static Fibre * const ready = reinterpret_cast<Fibre *>(1ull);
	93	for(;;) {
	94	Fibre * expected = this->ptr;
	95	if(expected == ready) {
	96	if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
	97	return false;
	98	}
	99	}
	100	else {
	101	/* paranoid */ assert( expected == nullptr );
	102	if(__atomic_compare_exchange_n(&this->ptr, &expected, fibre_self(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
	103	fibre_park();
	104	return true;
	105	}
	106	}
	107
	108	}
	109	}
	110
	111	inline bool post() {
	112	static Fibre * const ready = reinterpret_cast<Fibre *>(1ull);
	113	for(;;) {
	114	Fibre * expected = this->ptr;
	115	if(expected == ready) return false;
	116	if(expected == nullptr) {
	117	if(__atomic_compare_exchange_n(&this->ptr, &expected, ready, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
	118	return false;
	119	}
	120	}
	121	else {
	122	if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
	123	fibre_unpark( expected );
	124	return true;
	125	}
	126	}
	127	}
	128	}
	129	};
	130
[2c7eee0]	131	// ==========================================================================================
[f9b2e73]	132	#include <cstdlib>
[2c7eee0]	133	#include <cstring>
	134
[f9b2e73]	135	#include <algorithm>
	136
[2c7eee0]	137	//-----------------------------------------------------------------------------
	138	// Typed argument parsing
	139	bool parse_yesno(const char * arg, bool & value ) {
	140	if(strcmp(arg, "yes") == 0) {
	141	value = true;
	142	return true;
	143	}
	144
[8faa6612]	145	if(strcmp(arg, "Y") == 0) {
	146	value = true;
	147	return true;
	148	}
	149
	150	if(strcmp(arg, "y") == 0) {
	151	value = true;
	152	return true;
	153	}
	154
[2c7eee0]	155	if(strcmp(arg, "no") == 0) {
	156	value = false;
	157	return true;
	158	}
	159
[8faa6612]	160	if(strcmp(arg, "N") == 0) {
	161	value = false;
	162	return true;
	163	}
	164
	165	if(strcmp(arg, "n") == 0) {
	166	value = false;
	167	return true;
	168	}
	169
[2c7eee0]	170	return false;
	171	}
	172
[c4241b6]	173	bool parse_truefalse(const char * arg, bool & value) {
	174	if(strcmp(arg, "true") == 0) {
	175	value = true;
	176	return true;
	177	}
	178
	179	if(strcmp(arg, "false") == 0) {
	180	value = false;
	181	return true;
	182	}
	183
	184	return false;
	185	}
	186
[2c7eee0]	187	bool parse_settrue (const char *, bool & value ) {
	188	value = true;
	189	return true;
	190	}
	191
	192	bool parse_setfalse(const char *, bool & value ) {
	193	value = false;
	194	return true;
	195	}
	196
	197	bool parse(const char * arg, const char * & value ) {
	198	value = arg;
	199	return true;
	200	}
	201
	202	bool parse(const char * arg, int & value) {
	203	char * end;
	204	int r = strtoll(arg, &end, 10);
	205	if(*end != '\0') return false;
	206
	207	value = r;
	208	return true;
	209	}
	210
	211	bool parse(const char * arg, unsigned & value) {
	212	char * end;
	213	unsigned long long int r = strtoull(arg, &end, 10);
	214	if(*end != '\0') return false;
	215	if(r > UINT_MAX) return false;
	216
	217	value = r;
	218	return true;
	219	}
	220
	221	bool parse(const char * arg, unsigned long & value) {
	222	char * end;
	223	unsigned long long int r = strtoull(arg, &end, 10);
	224	if(*end != '\0') return false;
	225	if(r > ULONG_MAX) return false;
	226
	227	value = r;
	228	return true;
	229	}
	230
	231	bool parse(const char * arg, unsigned long long & value) {
	232	char * end;
	233	unsigned long long int r = strtoull(arg, &end, 10);
	234	if(*end != '\0') return false;
	235	if(r > ULLONG_MAX) return false;
	236
	237	value = r;
	238	return true;
	239	}
	240
	241	bool parse(const char * arg, double & value) {
	242	char * end;
	243	double r = strtod(arg, &end);
	244	if(*end != '\0') return false;
	245
	246	value = r;
	247	return true;
	248	}
	249
	250	//-----------------------------------------------------------------------------
	251	struct option_t {
	252	char short_name;
	253	const char * long_name;
	254	const char * help;
	255	void * variable;
	256	bool (parse_fun)(const char , void * );
	257
	258	template<typename T>
	259	inline option_t( char short_name, const char * long_name, const char * help, T & variable ) {
	260	this->short_name = short_name;
	261	this->long_name = long_name;
	262	this->help = help;
	263	this->variable = reinterpret_cast<void*>(&variable);
[56ac392]	264	#pragma GCC diagnostic push
	265	#pragma GCC diagnostic ignored "-Wcast-function-type"
	266	this->parse_fun = reinterpret_cast<bool ()(const char , void * )>(static_cast<bool ()(const char , T & )>(parse));
	267	#pragma GCC diagnostic pop
[2c7eee0]	268	}
	269
	270	template<typename T>
	271	inline option_t( char short_name, const char * long_name, const char * help, T & variable, bool (parse)(const char , T & )) {
	272	this->short_name = short_name;
	273	this->long_name = long_name;
	274	this->help = help;
	275	this->variable = reinterpret_cast<void*>(&variable);
[56ac392]	276	#pragma GCC diagnostic push
	277	#pragma GCC diagnostic ignored "-Wcast-function-type"
	278	this->parse_fun = reinterpret_cast<bool ()(const char , void * )>(parse);
	279	#pragma GCC diagnostic pop
[2c7eee0]	280	}
	281	};
	282
	283	extern option_t last_option;
	284
	285
	286	//-----------------------------------------------------------------------------
	287	#include <cstdint>
	288	#include <climits>
	289	#include <errno.h>
	290	#include <unistd.h>
	291	extern "C" {
	292	#include <getopt.h>
	293	#include <sys/ioctl.h>
	294
	295	extern FILE * stderr;
	296	extern FILE * stdout;
	297
	298	extern int fileno(FILE *stream);
	299
	300	extern int fprintf ( FILE * stream, const char * format, ... );
	301
	302	extern long long int strtoll (const char* str, char** endptr, int base);
	303	extern unsigned long long int strtoull(const char* str, char** endptr, int base);
	304	extern double strtod (const char* str, char** endptr);
	305	}
	306
	307	static void usage(char * cmd, option_t options[], size_t opt_count, const char * usage, FILE * out) __attribute__ ((noreturn));
	308
	309	//-----------------------------------------------------------------------------
	310	// getopt_long wrapping
	311	void parse_args(
	312	int argc,
	313	char * argv[],
	314	option_t options[],
	315	size_t opt_count,
	316	const char * usage_msg,
	317	char ** * left
	318	) {
	319	struct option optarr[opt_count + 2];
	320	{
	321	int idx = 0;
[c4241b6]	322	for(size_t i = 0; i < opt_count; i++) {
[2c7eee0]	323	if(options[i].long_name) {
	324	optarr[idx].name = options[i].long_name;
	325	optarr[idx].flag = nullptr;
	326	optarr[idx].val = options[i].short_name;
	327	if( ((intptr_t)options[i].parse_fun) == ((intptr_t)parse_settrue)
	328	\|\| ((intptr_t)options[i].parse_fun) == ((intptr_t)parse_setfalse) ) {
	329	optarr[idx].has_arg = no_argument;
	330	} else {
	331	optarr[idx].has_arg = required_argument;
	332	}
	333	idx++;
	334	}
	335	}
	336	optarr[idx+0].name = "help";
	337	optarr[idx+0].has_arg = no_argument;
	338	optarr[idx+0].flag = 0;
	339	optarr[idx+0].val = 'h';
	340	optarr[idx+1].name = 0;
	341	optarr[idx+1].has_arg = no_argument;
	342	optarr[idx+1].flag = 0;
	343	optarr[idx+1].val = 0;
	344	}
	345
	346	char optstring[opt_count * 3];
	347	for(auto & o : optstring) {
	348	o = '\0';
	349	}
	350	{
	351	int idx = 0;
[c4241b6]	352	for(size_t i = 0; i < opt_count; i++) {
[2c7eee0]	353	optstring[idx] = options[i].short_name;
	354	idx++;
	355	if( ((intptr_t)options[i].parse_fun) != ((intptr_t)parse_settrue)
	356	&& ((intptr_t)options[i].parse_fun) != ((intptr_t)parse_setfalse) ) {
	357	optstring[idx] = ':';
	358	idx++;
	359	}
	360	}
	361	optstring[idx+0] = 'h';
	362	optstring[idx+1] = '\0';
	363	}
	364
	365	FILE * out = stderr;
	366	for(;;) {
	367	int idx = 0;
	368	int opt = getopt_long(argc, argv, optstring, optarr, &idx);
	369	switch(opt) {
	370	case -1:
	371	if(left != nullptr) *left = argv + optind;
	372	return;
	373	case 'h':
	374	out = stdout;
[c4241b6]	375	[[fallthrough]];
[2c7eee0]	376	case '?':
	377	usage(argv[0], options, opt_count, usage_msg, out);
	378	default:
[c4241b6]	379	for(size_t i = 0; i < opt_count; i++) {
[2c7eee0]	380	if(opt == options[i].short_name) {
	381	const char * arg = optarg ? optarg : "";
[c4241b6]	382	if( arg[0] == '=' ) { arg++; }
[2c7eee0]	383	bool success = options[i].parse_fun( arg, options[i].variable );
	384	if(success) goto NEXT_ARG;
	385
	386	fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
	387	usage(argv[0], options, opt_count, usage_msg, out);
	388	}
	389	}
	390	std::abort();
	391	}
	392	NEXT_ARG:;
	393	}
	394	}
	395
	396	//-----------------------------------------------------------------------------
	397	// Print usage
	398	static void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
	399	int hwidth = max - (11 + width);
	400	if(hwidth <= 0) hwidth = max;
	401
	402	fprintf(out, " -%c, --%-s %.s\n", sn, width, ln, hwidth, help);
	403	for(;;) {
	404	help += std::min(strlen(help), (unsigned long)hwidth);
	405	if('\0' == *help) break;
	406	fprintf(out, "%s%.s\n", width + 11, "", hwidth, help);
	407	}
	408	}
	409
	410	__attribute__((noreturn)) void print_args_usage(int , char * argv[], option_t options[], size_t opt_count, const char * usage_msg, bool error) {
	411	usage(argv[0], options, opt_count, usage_msg, error ? stderr : stdout);
	412	}
	413
	414	static __attribute__((noreturn)) void usage(char * cmd, option_t options[], size_t opt_count, const char * help, FILE * out) {
	415	int width = 0;
	416	{
[c4241b6]	417	for(size_t i = 0; i < opt_count; i++) {
[2c7eee0]	418	if(options[i].long_name) {
	419	int w = strlen(options[i].long_name);
	420	if(w > width) width = w;
	421	}
	422	}
	423	}
	424
	425	int max_width = 1000000;
	426	int outfd = fileno(out);
	427	if(isatty(outfd)) {
	428	struct winsize size;
	429	int ret = ioctl(outfd, TIOCGWINSZ, &size);
	430	if(ret < 0) abort(); // "ioctl error: (%d) %s\n", (int)errno, strerror(errno)
	431	max_width = size.ws_col;
	432	}
	433
	434	fprintf(out, "Usage:\n %s %s\n", cmd, help);
	435
[c4241b6]	436	for(size_t i = 0; i < opt_count; i++) {
[2c7eee0]	437	printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
	438	}
	439	fprintf(out, " -%c, --%-*s %s\n", 'h', width, "help", "print this help message");
	440	exit(out == stdout ? 0 : 1);
	441	}
	442

Note: See TracBrowser for help on using the repository browser.

Download in other formats: