#!/usr/bin/ksh93

#

#

# Tests whether clock_gettime() is implemented via traditional

# syscalls or uses a shortcut (e.g. via shared memory/Linux VDSO)

#

builtin cat

builtin wc

#builtin rm

set -o nounset

function enumerate_clock_sources

{

	typeset s

	typeset dummy aname avalue

	nameref ar="$1"

	s="$( clang -E -dM -m32 -include time.h - < '/dev/null' | \

		egrep \

			'#[[:space:]]*define[[:space:]]+CLOCK_.+[[:space:]]+[[:digit:]]+'

		)"

	while read dummy aname avalue ; do

		if [[ \

			"${aname}" != ~(El)CLOCK_ || \

			"${avalue}" != ~(Elr)[[:digit:]]+ ]] ; then

			continue

		fi

		integer ar["$aname"].value

		ar["$aname"].name="${aname}"

		ar["$aname"].value="${avalue}"

	done <<<"$s"

	return 0

}

function generate_test_code

{

	nameref ar="$1"

	set -o errexit

	printf $"## Generating test code...\n"

	rm -f \

		'generated_count_timer_syscalls.c' \

		'generated_count_timer_syscalls'

	{

		cat <<EOF

/*

 * count_timer_syscalls.c - runs timer NUM_TESTRUNS times,

 * strace can then be used to count syscalls

 *

 * Compile with:

 * $ clang -g -Wall -Wextra count_timer_syscalls.c

 *

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <time.h>

#include <sched.h>

#include <stdlib.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#ifndef CLOCK_INVALID

#define CLOCK_INVALID -1

#endif

#define NSEC_PER_SEC (1000000000LL)

static

clockid_t get_clockid(int fd)

{

	const int CLOCKFD = 3;

        return (((unsigned int) ~fd) << 3) | CLOCKFD;

}

static

void test_loop_on_clock(clockid_t clkid, unsigned long num_cycles)

{

	struct timespec ts;

	unsigned long cycles;

	for(cycles = 0UL ; cycles < num_cycles ; cycles++)

	{

		(void)clock_gettime(clkid, &ts);

		(void)ts;

	}

}

int main(int ac, char *av[])

{

	const char *clockname = av[1];

	(void)puts("# start.");

	if ((ac != 2) || (!clockname)) {

		(void)fprintf(stderr, "%s: Missing clockname argument\n", av[0]);

		return EXIT_FAILURE;

	}

	if (!strcmp(clockname, "nic")) {

		int fd;

		clockid_t clkid;

		const char *devicename = "/dev/ptp0";

		fd = open(devicename, O_RDWR);

		if (fd < 0) {

			(void)fprintf(stderr, "opening %s: %s\n", devicename,

				strerror(errno));

			return(EXIT_FAILURE);

        	}

		clkid = get_clockid(fd);

		if (CLOCK_INVALID == clkid) {

			(void)fprintf(stderr, "failed to read clock id\n");

			return(EXIT_FAILURE);

		}

		(void)printf("## test run using nic clock\n");

		test_loop_on_clock(clkid, NUM_TESTRUNS);

		(void)close(fd);

EOF

		typeset i

		for i in "${!ar[@]}" ; do

			typeset name="${ar[$i].name}"

			printf '\t} else if (!strcmp(clockname, "%s")) {\n' "$name"

			printf '\t\t(void)printf("## test run using %s\\n");\n' "$name"

			printf '\n'

			printf '\t\ttest_loop_on_clock(%s, NUM_TESTRUNS);\n' "$name"

		done

		cat <<EOF

	} else {

		(void)fprintf(stderr, "%s: Unknown clockname argument %s\n",

			av[0], clockname);

		return EXIT_FAILURE;

	}

	(void)puts("# end.");

	return(EXIT_SUCCESS);

}

EOF

	} >"generated_count_timer_syscalls.c"

	return 0

}

function compile_test_code

{

	set -o errexit

	printf $"## Compiling test code...\n"

	clang -m32 -g -Wall -Wextra \

		-o generated_count_timer_syscalls \

		generated_count_timer_syscalls.c

	return 0

}

function run_tests

{

	nameref ar="$1"

	compound cmd

	typeset cmd.output

	integer cmd.exit_code

	typeset i

	printf $"## Running tests...\n"

	for i in "${!ar[@]}" ; do

		nameref n=ar["$i"]

		printf $"Probing %q...\n" "${n.name}"

		cmd.output="${ strace ./generated_count_timer_syscalls "${n.name}" 2>&1 ; cmd.exit_code="$?" ; }"

		integer n.num_syscalls_clock_gettime="${ egrep 'clock_gettime' <<<"${cmd.output}" | wc -l ;}"

		integer n.num_syscalls_total="${ wc -l <<<"${cmd.output}" ; }"

		integer n.exit_code=${cmd.exit_code}

	done

}

function print_results

{

	nameref c=$1

		printf $"Clock name %-20s \t" ${n.name}

		if (( (n.exit_code != 0) || (n.num_syscalls_total < 30) )) ; then

			printf $"TEST FAILED\n"

			printf $"uses traditional syscalls\n"

		elif (( n.num_syscalls_clock_gettime <= 1 )) ; then

			printf $"uses shortcut\n"

		else

			printf $"Data inconclusive\n"

		fi

	done

	return 0

}

function main

{

	compound c

	compound -A c.clock_names

	typeset c.uname="$(uname -a)"

	typeset c.hostname="$(hostname)"

	if ! enumerate_clock_sources c.clock_names ; then

		print -u2 -f $"%s: Could not enumerate clock names.\n" "$1"

		return 1

	fi

		print -u2 -f $"%s: Could not generate test code.\n" "$1"

		return 1

	fi

	if ! compile_test_code ; then

		print -u2 -f $"%s: Could not compile test code.\n" "$1"

		return 1

	fi

	run_tests c.clock_names

	print_results c

	print $"## Done."

	return 0

}

main "$@"

# EOF.