okennedy
/
tpch
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
tpch/dbgen/driver.c

801 lines
20 KiB
C
Executable File
Raw Permalink Blame History

/*
* $Id: driver.c,v 1.7 2008/09/24 22:35:21 jms Exp $
*
* Revision History
* ===================
* $Log: driver.c,v $
* Revision 1.7 2008/09/24 22:35:21 jms
* remove build number header
*
* Revision 1.6 2008/09/24 22:30:29 jms
* remove build number from default header
*
* Revision 1.5 2008/03/21 17:38:39 jms
* changes for 2.6.3
*
* Revision 1.4 2006/04/26 23:01:10 jms
* address update generation problems
*
* Revision 1.3 2005/10/28 02:54:35 jms
* add release.h changes
*
* Revision 1.2 2005/01/03 20:08:58 jms
* change line terminations
*
* Revision 1.1.1.1 2004/11/24 23:31:46 jms
* re-establish external server
*
* Revision 1.5 2004/04/07 20:17:29 jms
* bug #58 (join fails between order/lineitem)
*
* Revision 1.4 2004/02/18 16:26:49 jms
* 32/64 bit changes for overflow handling needed additional changes when ported back to windows
*
* Revision 1.3 2004/01/22 05:49:29 jms
* AIX porting (AIX 5.1)
*
* Revision 1.2 2004/01/22 03:54:12 jms
* 64 bit support changes for customer address
*
* Revision 1.1.1.1 2003/08/08 21:50:33 jms
* recreation after CVS crash
*
* Revision 1.3 2003/08/08 21:35:26 jms
* first integration of rng64 for o_custkey and l_partkey
*
* Revision 1.2 2003/08/07 17:58:34 jms
* Convery RNG to 64bit space as preparation for new large scale RNG
*
* Revision 1.1.1.1 2003/04/03 18:54:21 jms
* initial checkin
*
*
*/
/* main driver for dss banchmark */
#define DECLARER /* EXTERN references get defined here */
#define NO_FUNC (int (*) ()) NULL /* to clean up tdefs */
#define NO_LFUNC (long (*) ()) NULL /* to clean up tdefs */
#include "config.h"
#include "release.h"
#include <stdlib.h>
#if (defined(_POSIX_)||!defined(WIN32)) /* Change for Windows NT */
#include <unistd.h>
#include <sys/wait.h>
#endif /* WIN32 */
#include <stdio.h> /* */
#include <limits.h>
#include <math.h>
#include <ctype.h>
#include <signal.h>
#include <string.h>
#include <errno.h>
#ifdef HP
#include <strings.h>
#endif
#if (defined(WIN32)&&!defined(_POSIX_))
#include <process.h>
#pragma warning(disable:4201)
#pragma warning(disable:4214)
#pragma warning(disable:4514)
#define WIN32_LEAN_AND_MEAN
#define NOATOM
#define NOGDICAPMASKS
#define NOMETAFILE
#define NOMINMAX
#define NOMSG
#define NOOPENFILE
#define NORASTEROPS
#define NOSCROLL
#define NOSOUND
#define NOSYSMETRICS
#define NOTEXTMETRIC
#define NOWH
#define NOCOMM
#define NOKANJI
#define NOMCX
#include <windows.h>
#pragma warning(default:4201)
#pragma warning(default:4214)
#endif
#include "dss.h"
#include "dsstypes.h"
/*
* Function prototypes
*/
void usage (void);
void kill_load (void);
int pload (int tbl);
void gen_tbl (int tnum, DSS_HUGE start, DSS_HUGE count, long upd_num);
int pr_drange (int tbl, DSS_HUGE min, DSS_HUGE cnt, long num);
int set_files (int t, int pload);
int partial (int, int);
extern int optind, opterr;
extern char *optarg;
DSS_HUGE rowcnt = 0, minrow = 0;
long upd_num = 0;
double flt_scale;
#if (defined(WIN32)&&!defined(_POSIX_))
char *spawn_args[25];
#endif
#ifdef RNG_TEST
extern seed_t Seed[];
#endif
static int bTableSet = 0;
/*
* general table descriptions. See dss.h for details on structure
* NOTE: tables with no scaling info are scaled according to
* another table
*
*
* the following is based on the tdef structure defined in dss.h as:
* typedef struct
* {
* char *name; -- name of the table;
* flat file output in <name>.tbl
* long base; -- base scale rowcount of table;
* 0 if derived
* int (*loader) (); -- function to present output
* long (*gen_seed) (); -- functions to seed the RNG
* int child; -- non-zero if there is an associated detail table
* unsigned long vtotal; -- "checksum" total
* } tdef;
*
*/
/*
* flat file print functions; used with -F(lat) option
*/
int pr_cust (customer_t * c, int mode);
int pr_line (order_t * o, int mode);
int pr_order (order_t * o, int mode);
int pr_part (part_t * p, int mode);
int pr_psupp (part_t * p, int mode);
int pr_supp (supplier_t * s, int mode);
int pr_order_line (order_t * o, int mode);
int pr_part_psupp (part_t * p, int mode);
int pr_nation (code_t * c, int mode);
int pr_region (code_t * c, int mode);
/*
* seed generation functions; used with '-O s' option
*/
long sd_cust (int child, DSS_HUGE skip_count);
long sd_line (int child, DSS_HUGE skip_count);
long sd_order (int child, DSS_HUGE skip_count);
long sd_part (int child, DSS_HUGE skip_count);
long sd_psupp (int child, DSS_HUGE skip_count);
long sd_supp (int child, DSS_HUGE skip_count);
long sd_order_line (int child, DSS_HUGE skip_count);
long sd_part_psupp (int child, DSS_HUGE skip_count);
tdef tdefs[] =
{
{"part.tbl", "part table", 200000,
pr_part, sd_part, PSUPP, 0},
{"partsupp.tbl", "partsupplier table", 200000,
pr_psupp, sd_psupp, NONE, 0},
{"supplier.tbl", "suppliers table", 10000,
pr_supp, sd_supp, NONE, 0},
{"customer.tbl", "customers table", 150000,
pr_cust, sd_cust, NONE, 0},
{"orders.tbl", "order table", 150000,
pr_order, sd_order, LINE, 0},
{"lineitem.tbl", "lineitem table", 150000,
pr_line, sd_line, NONE, 0},
{"orders.tbl", "orders/lineitem tables", 150000,
pr_order_line, sd_order, LINE, 0},
{"part.tbl", "part/partsupplier tables", 200000,
pr_part_psupp, sd_part, PSUPP, 0},
{"nation.tbl", "nation table", NATIONS_MAX,
pr_nation, NO_LFUNC, NONE, 0},
{"region.tbl", "region table", NATIONS_MAX,
pr_region, NO_LFUNC, NONE, 0},
};
/*
* re-set default output file names
*/
int
set_files (int i, int pload)
{
char line[80], *new_name;
if (table & (1 << i))
child_table:
{
if (pload != -1)
sprintf (line, "%s.%d", tdefs[i].name, pload);
else
{
printf ("Enter new destination for %s data: ",
tdefs[i].name);
if (fgets (line, sizeof (line), stdin) == NULL)
return (-1);;
if ((new_name = strchr (line, '\n')) != NULL)
*new_name = '\0';
if ((int)strlen (line) == 0)
return (0);
}
new_name = (char *) malloc ((int)strlen (line) + 1);
MALLOC_CHECK (new_name);
strcpy (new_name, line);
tdefs[i].name = new_name;
if (tdefs[i].child != NONE)
{
i = tdefs[i].child;
tdefs[i].child = NONE;
goto child_table;
}
}
return (0);
}
/*
* read the distributions needed in the benchamrk
*/
void
load_dists (void)
{
read_dist (env_config (DIST_TAG, DIST_DFLT), "p_cntr", &p_cntr_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "colors", &colors);
read_dist (env_config (DIST_TAG, DIST_DFLT), "p_types", &p_types_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "nations", &nations);
read_dist (env_config (DIST_TAG, DIST_DFLT), "regions", &regions);
read_dist (env_config (DIST_TAG, DIST_DFLT), "o_oprio",
&o_priority_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "instruct",
&l_instruct_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "smode", &l_smode_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "category",
&l_category_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "rflag", &l_rflag_set);
read_dist (env_config (DIST_TAG, DIST_DFLT), "msegmnt", &c_mseg_set);
/* load the distributions that contain text generation */
read_dist (env_config (DIST_TAG, DIST_DFLT), "nouns", &nouns);
read_dist (env_config (DIST_TAG, DIST_DFLT), "verbs", &verbs);
read_dist (env_config (DIST_TAG, DIST_DFLT), "adjectives", &adjectives);
read_dist (env_config (DIST_TAG, DIST_DFLT), "adverbs", &adverbs);
read_dist (env_config (DIST_TAG, DIST_DFLT), "auxillaries", &auxillaries);
read_dist (env_config (DIST_TAG, DIST_DFLT), "terminators", &terminators);
read_dist (env_config (DIST_TAG, DIST_DFLT), "articles", &articles);
read_dist (env_config (DIST_TAG, DIST_DFLT), "prepositions", &prepositions);
read_dist (env_config (DIST_TAG, DIST_DFLT), "grammar", &grammar);
read_dist (env_config (DIST_TAG, DIST_DFLT), "np", &np);
read_dist (env_config (DIST_TAG, DIST_DFLT), "vp", &vp);
}
/*
* generate a particular table
*/
void
gen_tbl (int tnum, DSS_HUGE start, DSS_HUGE count, long upd_num)
{
static order_t o;
supplier_t supp;
customer_t cust;
part_t part;
code_t code;
static int completed = 0;
DSS_HUGE i;
DSS_HUGE rows_per_segment=0;
DSS_HUGE rows_this_segment=-1;
DSS_HUGE residual_rows=0;
if (insert_segments)
{
rows_per_segment = count / insert_segments;
residual_rows = count - (rows_per_segment * insert_segments);
}
for (i = start; count; count--, i++)
{
LIFENOISE (1000, i);
row_start(tnum);
switch (tnum)
{
case LINE:
case ORDER:
case ORDER_LINE:
mk_order (i, &o, upd_num % 10000);
if (insert_segments && (upd_num > 0))
if((upd_num / 10000) < residual_rows)
{
if((++rows_this_segment) > rows_per_segment)
{
rows_this_segment=0;
upd_num += 10000;
}
}
else
{
if((++rows_this_segment) >= rows_per_segment)
{
rows_this_segment=0;
upd_num += 10000;
}
}
if (set_seeds == 0)
tdefs[tnum].loader(&o, upd_num);
break;
case SUPP:
mk_supp (i, &supp);
if (set_seeds == 0)
tdefs[tnum].loader(&supp, upd_num);
break;
case CUST:
mk_cust (i, &cust);
if (set_seeds == 0)
tdefs[tnum].loader(&cust, upd_num);
break;
case PSUPP:
case PART:
case PART_PSUPP:
mk_part (i, &part);
if (set_seeds == 0)
tdefs[tnum].loader(&part, upd_num);
break;
case NATION:
mk_nation (i, &code);
if (set_seeds == 0)
tdefs[tnum].loader(&code, 0);
break;
case REGION:
mk_region (i, &code);
if (set_seeds == 0)
tdefs[tnum].loader(&code, 0);
break;
}
row_stop(tnum);
if (set_seeds && (i % tdefs[tnum].base) < 2)
{
printf("\nSeeds for %s at rowcount %ld\n", tdefs[tnum].comment, i);
dump_seeds(tnum);
}
}
completed |= 1 << tnum;
}
void
usage (void)
{
fprintf (stderr, "%s\n%s\n\t%s\n%s %s\n\n",
"USAGE:",
"dbgen [-{vf}][-T {pcsoPSOL}]",
"[-s <scale>][-C <procs>][-S <step>]",
"dbgen [-v] [-O m] [-s <scale>]",
"[-U <updates>]");
fprintf (stderr, "Basic Options\n===========================\n");
fprintf (stderr, "-C <n> -- separate data set into <n> chunks (requires -S, default: 1)\n");
fprintf (stderr, "-f -- force. Overwrite existing files\n");
fprintf (stderr, "-h -- display this message\n");
fprintf (stderr, "-q -- enable QUIET mode\n");
fprintf (stderr, "-s <n> -- set Scale Factor (SF) to <n> (default: 1) \n");
fprintf (stderr, "-S <n> -- build the <n>th step of the data/update set (used with -C or -U)\n");
fprintf (stderr, "-U <n> -- generate <n> update sets\n");
fprintf (stderr, "-v -- enable VERBOSE mode\n");
fprintf (stderr, "\nAdvanced Options\n===========================\n");
fprintf (stderr, "-b <s> -- load distributions for <s> (default: dists.dss)\n");
fprintf (stderr, "-d <n> -- split deletes between <n> files (requires -U)\n");
fprintf (stderr, "-i <n> -- split inserts between <n> files (requires -U)\n");
fprintf (stderr, "-T c -- generate cutomers ONLY\n");
fprintf (stderr, "-T l -- generate nation/region ONLY\n");
fprintf (stderr, "-T L -- generate lineitem ONLY\n");
fprintf (stderr, "-T n -- generate nation ONLY\n");
fprintf (stderr, "-T o -- generate orders/lineitem ONLY\n");
fprintf (stderr, "-T O -- generate orders ONLY\n");
fprintf (stderr, "-T p -- generate parts/partsupp ONLY\n");
fprintf (stderr, "-T P -- generate parts ONLY\n");
fprintf (stderr, "-T r -- generate region ONLY\n");
fprintf (stderr, "-T s -- generate suppliers ONLY\n");
fprintf (stderr, "-T S -- generate partsupp ONLY\n");
fprintf (stderr,
"\nTo generate the SF=1 (1GB), validation database population, use:\n");
fprintf (stderr, "\tdbgen -vf -s 1\n");
fprintf (stderr, "\nTo generate updates for a SF=1 (1GB), use:\n");
fprintf (stderr, "\tdbgen -v -U 1 -s 1\n");
}
/*
* int partial(int tbl, int s) -- generate the s-th part of the named tables data
*/
int
partial (int tbl, int s)
{
DSS_HUGE rowcnt;
DSS_HUGE extra;
if (verbose > 0)
{
fprintf (stderr, "\tStarting to load stage %d of %d for %s...",
s, children, tdefs[tbl].comment);
}
set_files (tbl, s);
rowcnt = set_state(tbl, scale, children, s, &extra);
if (s == children)
gen_tbl (tbl, rowcnt * (s - 1) + 1, rowcnt + extra, upd_num);
else
gen_tbl (tbl, rowcnt * (s - 1) + 1, rowcnt, upd_num);
if (verbose > 0)
fprintf (stderr, "done.\n");
return (0);
}
void
process_options (int count, char **vector)
{
int option;
FILE *pF;
while ((option = getopt (count, vector,
"b:C:d:fi:hO:P:qs:S:T:U:v")) != -1)
switch (option)
{
case 'b': /* load distributions from named file */
d_path = (char *)malloc((int)strlen(optarg) + 1);
MALLOC_CHECK(d_path);
strcpy(d_path, optarg);
if ((pF = fopen(d_path, "r")) == NULL)
{
fprintf(stderr, "ERROR: Invalid argument to -b");
exit(-1);
}
else
fclose(pF);
break;
case 'C':
children = atoi (optarg);
break;
case 'd':
delete_segments = atoi (optarg);
break;
case 'f': /* blind overwrites; Force */
force = 1;
break;
case 'i':
insert_segments = atoi (optarg);
break;
case 'q': /* all prompts disabled */
verbose = -1;
break;
case 's': /* scale by Percentage of base rowcount */
case 'P': /* for backward compatibility */
flt_scale = atof (optarg);
if (flt_scale < MIN_SCALE)
{
int i;
int int_scale;
scale = 1;
int_scale = (int)(1000 * flt_scale);
for (i = PART; i < REGION; i++)
{
tdefs[i].base = (DSS_HUGE)(int_scale * tdefs[i].base)/1000;
if (tdefs[i].base < 1)
tdefs[i].base = 1;
}
}
else
scale = (long) flt_scale;
if (scale > MAX_SCALE)
{
fprintf (stderr, "%s %5.0f %s\n\t%s\n\n",
"NOTE: Data generation for scale factors >",
MAX_SCALE,
"GB is still in development,",
"and is not yet supported.\n");
fprintf (stderr,
"Your resulting data set MAY NOT BE COMPLIANT!\n");
}
break;
case 'S': /* generate a particular STEP */
step = atoi (optarg);
break;
case 'U': /* generate flat files for update stream */
updates = atoi (optarg);
break;
case 'v': /* life noises enabled */
verbose = 1;
break;
case 'T': /* generate a specifc table */
switch (*optarg)
{
case 'c': /* generate customer ONLY */
table = 1 << CUST;
bTableSet = 1;
break;
case 'L': /* generate lineitems ONLY */
table = 1 << LINE;
bTableSet = 1;
break;
case 'l': /* generate code table ONLY */
table = 1 << NATION;
table |= 1 << REGION;
bTableSet = 1;
break;
case 'n': /* generate nation table ONLY */
table = 1 << NATION;
bTableSet = 1;
break;
case 'O': /* generate orders ONLY */
table = 1 << ORDER;
bTableSet = 1;
break;
case 'o': /* generate orders/lineitems ONLY */
table = 1 << ORDER_LINE;
bTableSet = 1;
break;
case 'P': /* generate part ONLY */
table = 1 << PART;
bTableSet = 1;
break;
case 'p': /* generate part/partsupp ONLY */
table = 1 << PART_PSUPP;
bTableSet = 1;
break;
case 'r': /* generate region table ONLY */
table = 1 << REGION;
bTableSet = 1;
break;
case 'S': /* generate partsupp ONLY */
table = 1 << PSUPP;
bTableSet = 1;
break;
case 's': /* generate suppliers ONLY */
table = 1 << SUPP;
bTableSet = 1;
break;
default:
fprintf (stderr, "Unknown table name %s\n",
optarg);
usage ();
exit (1);
}
break;
case 'O': /* optional actions */
switch (tolower (*optarg))
{
case 's': /* calibrate the RNG usage */
set_seeds = 1;
break;
default:
fprintf (stderr, "Unknown option name %s\n",
optarg);
usage ();
exit (1);
}
break;
default:
printf ("ERROR: option '%c' unknown.\n",
*(vector[optind] + 1));
case 'h': /* something unexpected */
fprintf (stderr,
"%s Population Generator (Version %d.%d.%d build %d)\n",
NAME, VERSION, RELEASE, PATCH, BUILD);
fprintf (stderr, "Copyright %s %s\n", TPC, C_DATES);
usage ();
exit (1);
}
return;
}
void validate_options(void)
{
// DBGenOptions, 3.1
if (children != 1)
{
if (updates != 0)
{
fprintf(stderr, "ERROR: -C is not valid when generating updates\n");
exit(-1);
}
if (step == -1)
{
fprintf(stderr, "ERROR: -S must be specified when generating data in multiple chunks\n");
exit(-1);
}
}
// DBGenOptions, 3.3
if (updates == 0)
{
if ((insert_segments != 0) || (delete_segments != 0))
{
fprintf(stderr, "ERROR: -d/-i are only valid when generating updates\n");
exit(-1);
}
}
// DBGenOptions, 3.9
if (step != -1)
{
if ((children == 1) && (updates == 0))
{
fprintf(stderr, "ERROR: -S is only valid when generating data in multiple chunks or generating updates\n");
exit(-1);
}
}
// DBGenOptions, 3.10
if (bTableSet && (updates != 0))
{
fprintf(stderr, "ERROR: -T not valid when generating updates\n");
exit(-1);
}
return;
}
/*
* MAIN
*
* assumes the existance of getopt() to clean up the command
* line handling
*/
int
main (int ac, char **av)
{
DSS_HUGE i;
table = (1 << CUST) |
(1 << SUPP) |
(1 << NATION) |
(1 << REGION) |
(1 << PART_PSUPP) |
(1 << ORDER_LINE);
force = 0;
insert_segments=0;
delete_segments=0;
insert_orders_segment=0;
insert_lineitem_segment=0;
delete_segment=0;
verbose = 0;
set_seeds = 0;
scale = 1;
flt_scale = 1.0;
updates = 0;
step = -1;
tdefs[ORDER].base *=
ORDERS_PER_CUST; /* have to do this after init */
tdefs[LINE].base *=
ORDERS_PER_CUST; /* have to do this after init */
tdefs[ORDER_LINE].base *=
ORDERS_PER_CUST; /* have to do this after init */
children = 1;
d_path = NULL;
#ifdef NO_SUPPORT
signal (SIGINT, exit);
#endif /* NO_SUPPORT */
process_options (ac, av);
validate_options();
#if (defined(WIN32)&&!defined(_POSIX_))
for (i = 0; i < ac; i++)
{
spawn_args[i] = malloc (((int)strlen (av[i]) + 1) * sizeof (char));
MALLOC_CHECK (spawn_args[i]);
strcpy (spawn_args[i], av[i]);
}
spawn_args[ac] = NULL;
#endif
if (verbose >= 0)
{
fprintf (stderr,
"%s Population Generator (Version %d.%d.%d)\n",
NAME, VERSION, RELEASE, PATCH);
fprintf (stderr, "Copyright %s %s\n", TPC, C_DATES);
}
load_dists ();
#ifdef RNG_TEST
for (i=0; i <= MAX_STREAM; i++)
Seed[i].nCalls = 0;
#endif
/* have to do this after init */
tdefs[NATION].base = nations.count;
tdefs[REGION].base = regions.count;
/*
* updates are never parallelized
*/
if (updates)
{
/*
* set RNG to start generating rows beyond SF=scale
*/
set_state (ORDER, scale, 100, 101, &i);
rowcnt = (int)(tdefs[ORDER_LINE].base / 10000 * scale * UPD_PCT);
if (step > 0)
{
/*
* adjust RNG for any prior update generation
*/
for (i=1; i < step; i++)
{
sd_order(0, rowcnt);
sd_line(0, rowcnt);
}
upd_num = step - 1;
}
else
upd_num = 0;
while (upd_num < updates)
{
if (verbose > 0)
fprintf (stderr,
"Generating update pair #%d for %s",
upd_num + 1, tdefs[ORDER_LINE].comment);
insert_orders_segment=0;
insert_lineitem_segment=0;
delete_segment=0;
minrow = upd_num * rowcnt + 1;
gen_tbl (ORDER_LINE, minrow, rowcnt, upd_num + 1);
if (verbose > 0)
fprintf (stderr, "done.\n");
pr_drange (ORDER_LINE, minrow, rowcnt, upd_num + 1);
upd_num++;
}
exit (0);
}
/**
** actual data generation section starts here
**/
/*
* traverse the tables, invoking the appropriate data generation routine for any to be built
*/
for (i = PART; i <= REGION; i++)
if (table & (1 << i))
{
if (children > 1 && i < NATION)
{
partial ((int)i, step);
}
else
{
minrow = 1;
if (i < NATION)
rowcnt = tdefs[i].base * scale;
else
rowcnt = tdefs[i].base;
if (verbose > 0)
fprintf (stderr, "Generating data for %s", tdefs[i].comment);
gen_tbl ((int)i, minrow, rowcnt, upd_num);
if (verbose > 0)
fprintf (stderr, "done.\n");
}
}
return (0);
}
Reference in New Issue View Git Blame Copy Permalink