@@@ bench wip

[mLib] / test / tvec-main.c

/* -*-c-*-
 *
 * Main entry point for test-vector processing
 *
 * (c) 2023 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Library General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * mLib 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 Library General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib.  If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 */

/*----- Header files ------------------------------------------------------*/

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <unistd.h>

#include "bench.h"
#include "dstr.h"
#include "macros.h"
#include "mdwopt.h"
#include "quis.h"
#include "report.h"
#include "tvec.h"

/*----- Main code ---------------------------------------------------------*/

/* Table of output formats. */
static const struct outform {
  const char *name;
  struct tvec_output *(*makefn)(FILE *fp);
} outtab[] = {
  { "human",		tvec_humanoutput },
  { "tap",		tvec_tapoutput },
  { 0,			0 }
};

/* Configuration for ad-hoc testing. */
const struct tvec_config tvec_adhocconfig =
  { 0, 1, 1, sizeof(struct tvec_reg) };

/* Common benchmark state. */
static struct bench_state bench;

/* --- @find_outform@ ---
 *
 * Arguments:	@const char *p@ = output name
 *
 * Returns:	Pointer to output format record.
 *
 * Use:		Looks up an output format by name.  Reports a fatal error if
 *		no matching record is found.
 */

static const struct outform *find_outform(const char *p)
{
  const struct outform *best = 0, *of;
  size_t n = strlen(p);

  for (of = outtab; of->name; of++)
    if (!STRNCMP(p, ==, of->name, n))
      ;
    else if (!of->name[n])
      return (of);
    else if (best)
      die(2, "ambiguous output format name (`%s' or `%s'?)",
	  best->name, of->name);
    else
      best = of;
  if (best) return (best);
  else die(2, "unknown output format `%s'", optarg);
}

/* --- @version@, @usage@, @help@ --- *
 *
 * Arguments:	@FILE *fp@ = stream to write on
 *
 * Returns:	---
 *
 * Use:		Output information about the program.
 */

static void version(FILE *fp)
  { pquis(fp, "$, mLib test-vector framework version " VERSION "\n"); }

static void usage(FILE *fp)
{
  pquis(fp, "\
usage: $ [-B CONFIG] [-f FORMAT] [-o OUTPUT] [-t SECS] [TEST-FILE ...]\n\
");
}

static void help(FILE *fp)
{
  version(fp); fputc('\n', fp);
  usage(fp); fputs("\
Options:\n\
  -h, --help			show this help text.\n\
  -v, --version			show version number.\n\
  -u, --usage			show usage synopsis.\n\
\n\
  -B, --bench-config=CONFIG	set benchmark configuration string.\n\
  -f, --format=FORMAT		produce output in FORMAT.\n\
  -o, --output=OUTPUT		write output to OUTPUT file.\n\
  -t, --target-time=DURATION	run benchmarks for DURATION.\n\
", fp);
}

/* --- @tvec_parseargs@ --- *
 *
 * Arguments:	@int argc@ = number of command-line arguments
 *		@char *argv[]@ = vector of argument strings
 *		@struct tvec_state *tv_out@ = test vector state to initialize
 *		@int *argpos_out@ = where to leave unread argument index
 *		@const struct tvec_config *cofig@ = test vector configuration
 *
 * Returns:	---
 *
 * Use:		Parse arguments and set up the test vector state @*tv_out@.
 *		If errors occur, print messages to standard error and exit
 *		with status 2.
 *
 *		This function also establishes a common benchmark state.
 */

void tvec_parseargs(int argc, char *argv[], struct tvec_state *tv_out,
		    int *argpos_out, const struct tvec_config *config)
{
  FILE *ofp = 0;
  const struct outform *of = 0;
  struct tvec_output *o;
  const char *benchconf = 0;
  double benchtime = 1.0, scale;
  struct bench_timer *tm;
  const char *p; char *q;
  int opt;
  unsigned f = 0;
#define f_bogus 1u
#define f_bench 2u

  static const struct option options[] = {
    { "help",		0,		0,	'h' },
    { "version",	0,		0,	'v' },
    { "usage",		0,		0,	'u' },

    { "bench-config",	OPTF_ARGREQ,	0,	'B' },
    { "format",		OPTF_ARGREQ,	0,	'f' },
    { "output",		OPTF_ARGREQ,	0,	'o' },
    { "target-time",	OPTF_ARGREQ,	0,	't' },
    { 0,		0,		0,	0 }
  };

  ego(argv[0]);
  for (;;) {
    opt = mdwopt(argc, argv, "hvu" "B:f:o:t:", options, 0, 0, 0);
    if (opt < 0) break;
    switch (opt) {
      case 'h': help(stdout); exit(0);
      case 'v': version(stdout); exit(0);
      case 'u': usage(stdout); exit(0);

      case 'B': benchconf = optarg; f |= f_bench; break;
      case 'f': of = find_outform(optarg); break;
      case 'o':
	if (ofp) fclose(ofp);
	ofp = fopen(optarg, "w");
	if (!ofp)
	  die(2, "failed to open `%s' for writing: %s",
	      optarg, strerror(errno));
	break;
      case 't':
	if (*optarg != '.' && !ISDIGIT(*optarg)) goto bad_time;
	errno = 0; benchtime = strtod(optarg, &q);
	if (errno) goto bad_time;
	p = q;
	if (ISSPACE(*p)) {
	  do p++; while (ISSPACE(*p));
	  if (!*p) goto bad_time;
	}
	if (tvec_parsedurunit(&scale, &p)) goto bad_time;
	if (*p) goto bad_time;
	benchtime *= scale; f |= f_bench;
	break;
      bad_time:
	die(2, "invalid time duration `%s'", optarg);

      default:
	f |= f_bogus;
	break;
    }
  }
  if (f&f_bogus) { usage(stderr); exit(2); }
  if (!ofp) ofp = stdout;
  if (!of) {
    p = getenv("TVEC_FORMAT");
    if (p) of = find_outform(p);
  }
  if (of) o = of->makefn(ofp);
  else o = tvec_dfltout(ofp);

  tm = bench_createtimer(benchconf);
  if (tm) {
    bench_init(&bench, tm); bench.target_s = benchtime;
    tvec_benchstate = &bench;
  } else if (f&f_bench) {
    moan("failed to create benchmark timer");
    if (!getenv("MLIB_BENCH_DEBUG"))
      moan("set `MLIB_BENCH_DEBUG=t' in the envionment for more detail");
    exit(2);
  }

  tvec_begin(tv_out, config, o); *argpos_out = optind;
}

/* --- @tvec_readstdin@, @tvec_readfile@, @tvec_readarg@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@const char *file@ = pathname of file to read
 *		@const char *arg@ = argument to interpret
 *
 * Returns:	Zero on success, @-1@ on error.
 *
 * Use:		Read test vector data from stdin or a named file.  The
 *		@tvec_readarg@ function reads from stdin if @arg@ is `%|-|%',
 *		and from the named file otherwise.
 */

int tvec_readstdin(struct tvec_state *tv)
  { return (tvec_read(tv, "<stdin>", stdin)); }

int tvec_readfile(struct tvec_state *tv, const char *file)
{
  FILE *fp = 0;
  int rc;

  fp = fopen(file, "r");
  if (!fp) {
    tvec_error(tv, "failed to open `%s' for reading: %s",
	       file, strerror(errno));
    rc = -1; goto end;
  }
  if (tvec_read(tv, file, fp)) { rc = -1; goto end; }
  rc = 0;
end:
  if (fp) fclose(fp);
  return (rc);
}

int tvec_readarg(struct tvec_state *tv, const char *arg)
{
  int rc;

  if (STRCMP(arg, ==, "-")) rc = tvec_readstdin(tv);
  else rc = tvec_readfile(tv, arg);
  return (rc);
}

/* --- @tvec_readdflt@ --- *
 *
 * Arguments:	@struct tvec_state *tv@ = test vector state
 *		@const char *dflt@ = defsault filename or null
 *
 * Returns:	Zero on success, @-1@ on error.
 *
 * Use:		Reads from the default test vector data.  If @file@ is null,
 *		then read from standard input, unless that's a terminal; if
 *		@file@ is not null, then read the named file, looking in the
 *		directory named by the `%|srcdir|%' environment variable if
 *		that's set, or otherwise in the current directory.
 */

int tvec_readdflt(struct tvec_state *tv, const char *dflt)
{
  dstr d = DSTR_INIT;
  const char *p;
  int rc;

  if (dflt) {
    p = getenv("srcdir");
    if (p) { dstr_putf(&d, "%s/%s", p, dflt); dflt = d.buf; }
    rc = tvec_readfile(tv, dflt);
  } else if (isatty(0))
    rc = tvec_error(tv, "use `-' to force reading from interactive stdin");
  else
    rc = tvec_readstdin(tv);
  dstr_destroy(&d);
  return (rc);
}

/* --- @tvec_readargs@ --- *
 *
 * Arguments:	@int argc@ = number of command-line arguments
 *		@char *argv[]@ = vector of argument strings
 *		@struct tvec_state *tv@ = test vector state
 *		@int *argpos_inout@ = current argument position (updated)
 *		@const char *dflt@ = default filename or null
 *
 * Returns:	Zero on success, @-1@ on error.
 *
 * Use:		Reads from the sources indicated by the command-line
 *		arguments, in order, interpreting each as for @tvec_readarg@;
 *		if no arguments are given then read from @dflt@ as for
 *		@tvec_readdflt@.
 */

int tvec_readargs(int argc, char *argv[], struct tvec_state *tv,
		   int *argpos_inout, const char *dflt)
{
  int i = *argpos_inout;
  int rc;

  if (i == argc)
    rc = tvec_readdflt(tv, dflt);
  else {
    rc = 0;
    while (i < argc)
      if (tvec_readarg(tv, argv[i++])) rc = -1;
  }
  *argpos_inout = i;
  return (rc);
}

/* --- @tvec_main@ --- *
 *
 * Arguments:	@int argc@ = number of command-line arguments
 *		@char *argv[]@ = vector of argument strings
 *		@const struct tvec_config *cofig@ = test vector configuration
 *		@const char *dflt@ = default filename or null
 *
 * Returns:	Exit code.
 *
 * Use:		All-in-one test vector front-end.  Parse options from the
 *		command-line as for @tvec_parseargs@, and then process the
 *		remaining positional arguments as for @tvec_readargs@.  The
 *		function constructs and disposes of a test vector state.
 */

int tvec_main(int argc, char *argv[],
	      const struct tvec_config *config, const char *dflt)
{
  struct tvec_state tv;
  int argpos;

  tvec_parseargs(argc, argv, &tv, &argpos, config);
  tvec_readargs(argc, argv, &tv, &argpos, dflt);
  return (tvec_end(&tv));
}

/*----- That's all, folks -------------------------------------------------*/