cmdargs.c

这是个trace drive的Cache模拟器

/*
 * Special help routine for -lN-Twback.
 * List the choices on subsequent lines.
 */
void
phelp_wback (const struct arglist *adesc)
{
	phelp_char (adesc);
	printf ("\n %*s (a=always, n=never, f=nofetch)",
		optstringmax, " ");
}


/*
 * Complain about an unspecified option
 */
void
unspec (int lev, int idu, char *name, void *var, char *suggest)
{
	int iduchar = idu==0?'u':(idu==1?'i':'d');
	struct arglist *argl;

	for (argl = args;  argl->var != var;  argl++)
		if (argl->optstring == NULL)
			die ("internal problem with arglist table\n");
	
	fprintf (stderr, "level %d %ccache %s must be specified, "
		 "e.g., -l%d-%c%s %s\n",
		 lev+1, iduchar, name, lev+1, iduchar, argl->optstring, suggest);
}


/*
 * Called after all the options and args are consumed.
 * Check them for consistency and reasonableness.
 * Die with an error message if there are serious problems.
 */
void
verify_options()
{
	int lev, idu;

	/*
	 * Allow some default values
	 *	subblocksize (default to blocksize)
	 *	prefetch distance (default to 1)
	 *	other defaults defined as DEFVAL_xxx
	 */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			if (level_blocksize[idu][lev]!=0 && level_subblocksize[idu][lev]==0)
				level_subblocksize[idu][lev] = level_blocksize[idu][lev];
			if (level_size[idu][lev]!=0 && level_assoc[idu][lev]==0)
				level_assoc[idu][lev] = DEFVAL_assoc;
			if (level_size[idu][lev]!=0 && level_replacement[idu][lev]==0)
				level_replacement[idu][lev] = DEFVAL_repl;
			if (level_size[idu][lev]!=0 && level_fetch[idu][lev]==0)
				level_fetch[idu][lev] = DEFVAL_fetch;
			if (level_size[idu][lev]!=0 &&
			    level_fetch[idu][lev]!='d' && level_prefetch_distance[idu][lev]==0)
				level_prefetch_distance[idu][lev] = 1;
			if (idu!=1 && level_size[idu][lev]!=0 && level_walloc[idu][lev]==0)
				level_walloc[idu][lev] = DEFVAL_walloc;
			if (idu!=1 && level_size[idu][lev]!=0 && level_wback[idu][lev]==0)
				level_wback[idu][lev] = DEFVAL_wback;
		}
	}

	/*
	 * check for missing required parameters
	 */
	if (maxlevel <= 0)
		shorthelp ("cache size and block size must be specified,\n"
			   "e.g.: -l1-isize 16k -l1-dsize 8192 "
				 "-l1-ibsize 32 -l1-dbsize 16\n");
	for (lev = 0;  lev < maxlevel;  lev++) {
		int nerr = 0, nidu = 0;
		for (idu = 0;  idu < 3;  idu++) {
			int nparams = (level_blocksize[idu][lev]!=0) +
				      (level_subblocksize[idu][lev]!=0) +
				      (level_size[idu][lev]!=0) +
				      (level_assoc[idu][lev]!=0) +
				      (level_replacement[idu][lev]!=0) +
				      (level_fetch[idu][lev]!=0) +
				      (level_walloc[idu][lev]!=0) +	/* only for u or d */
				      (level_wback[idu][lev]!=0);	/* only for u or d */
			int active = nparams != 0 || level_doccc[idu][lev] != 0;
			nidu += active;
			if (active && nparams != (6+2*(idu!=1))) {
				if (level_blocksize[idu][lev]==0)
					unspec (lev, idu, "block size", &level_blocksize[0][0], "16");
				if (level_size[idu][lev]==0)
					unspec (lev, idu, "size", &level_size[0][0], "16k");
				nerr++;
			}
		}
		if (nidu == 0)
			shorthelp ("no level %d cache specified\n", lev+1);
		else if (nerr != 0)
			shorthelp ("level %d cache parameters incomplete\n", lev+1);
	}

	verify_trace_format();	/* look for this in tracein.c */

	/* allowable replacement policies */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			if (level_replacement[idu][lev]!=0 &&
			    level_replacement[idu][lev]!='l' &&	/* LRU */
			    level_replacement[idu][lev]!='f' &&	/* FIFO */
			    level_replacement[idu][lev]!='r')	/* random */
				shorthelp ("level %d %ccache replacement policy unrecognized\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
		}
	}

	/* allowable fetch policies and prefetch parameters */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			if (level_fetch[idu][lev]!=0 &&
			    level_fetch[idu][lev]!='d' &&	/* demand fetch */
			    level_fetch[idu][lev]!='a' &&	/* always prefetch */
			    level_fetch[idu][lev]!='m' &&	/* miss prefetch */
			    level_fetch[idu][lev]!='t' &&	/* tagged prefetch */
			    level_fetch[idu][lev]!='l' &&	/* load forward prefetch */
			    level_fetch[idu][lev]!='s')		/* subblock prefetch */
				shorthelp ("level %d %ccache fetch policy unrecognized\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
			if ((level_fetch[idu][lev]=='l' || level_fetch[idu][lev]=='s') &&
			    level_prefetch_distance[idu][lev] >
			    level_blocksize[idu][lev]/(level_subblocksize[idu][lev]
			    ?level_subblocksize[idu][lev]:level_blocksize[idu][lev]))
				shorthelp ("level %d %ccache prefetch distance > block size\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
			if (level_fetch[idu][lev]=='d' &&
			    level_prefetch_abortpercent[idu][lev]!=0)
				shorthelp ("level %d %ccache abort %% not allowed "
					   "with demand fetch policy\n", lev+1,
					   idu==0?'u':(idu==1?'i':'d'));
			if (level_prefetch_abortpercent[idu][lev] < 0 ||
			    level_prefetch_abortpercent[idu][lev] > 100)
				shorthelp ("level %d %ccache abort %% out of range\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
		}
	}

	/* allowable walloc policies */
	for (lev = 0;  lev < maxlevel;  lev++) {
		if (level_walloc[1][lev]!=0)
			shorthelp ("level %d icache cannot have write allocate policy\n", lev+1);
		for (idu = 0;  idu < 3;  idu++) {
			if (level_walloc[idu][lev]!=0 &&
			    level_walloc[idu][lev]!='a' &&	/* always write allocate */
			    level_walloc[idu][lev]!='n' &&	/* never write allocate */
			    level_walloc[idu][lev]!='f')	/* walloc only w/o fetch */
				shorthelp ("level %d %ccache write allocate policy unrecognized\n",
					   lev+1, idu==0?'u':'d');
		}
	}

	/* allowable wback policies */
	for (lev = 0;  lev < maxlevel;  lev++) {
		if (level_wback[1][lev]!=0)
			shorthelp ("level %d icache cannot have write back policy\n", lev+1);
		for (idu = 0;  idu < 3;  idu++) {
			if (level_wback[idu][lev]!=0 &&
			    level_wback[idu][lev]!='a' &&	/* always write back */
			    level_wback[idu][lev]!='n' &&	/* never write back (i.e., write through) */
			    level_wback[idu][lev]!='f')		/* wback only w/o fetch */
				shorthelp ("level %d %ccache write back policy unrecognized\n",
					   lev+1, idu==0?'u':'d');
		}
	}

	/* the sub-block size is limited by size specified in memory reference */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			d4memref x;
			/* put a 1 in MSB position; x.size is unsigned */
			x.size = ~0;
			x.size = ~(x.size >> 1);
			if (level_subblocksize[idu][lev] > x.size)
				shorthelp ("level %d %ccache sub-block size must be <= %u\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'), x.size);
		}
	}

	/* block size/sub-block size */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			d4stacknode *xp;
			if (level_blocksize[idu][lev]!= 0 &&
			    level_subblocksize[idu][lev] > level_blocksize[idu][lev])
				shorthelp ("level %d %ccache has sub-blocksize > blocksize\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
			if (level_subblocksize[idu][lev] != 0 &&
			    level_blocksize[idu][lev] / level_subblocksize[idu][lev] > sizeof(xp->valid)*CHAR_BIT)
				shorthelp ("level %d %ccache must have no more than %u sub-blocks per block\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'), sizeof(xp->valid)*CHAR_BIT);
			if (level_subblocksize[idu][lev] != 0 && level_doccc[idu][lev] != 0 &&
			    D4_BITMAP_RSIZE < level_blocksize[idu][lev] / level_subblocksize[idu][lev])
				shorthelp ("level %d %ccache must have no more than %u sub-blocks per block for CCC\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'), D4_BITMAP_RSIZE);
		}
	}

	/* block and sub-block sizes must match for -stat-idcombine */
	if (stat_idcombine) {
		for (lev = 0;  lev < maxlevel;  lev++) {
			if (level_blocksize[1][lev] != level_blocksize[2][lev])
				shorthelp ("level %d i & d cache block sizes must match for -stat-idcombine\n", lev+1);
			if (level_subblocksize[1][lev] != level_subblocksize[2][lev])
				shorthelp ("level %d i & d cache sub-block sizes must match for -stat-idcombine\n", lev+1);
		}
	}

	/*
	 * Check for u and (i or d) at each level
	 */
	for (lev = 0;  lev < maxlevel;  lev++) {
		if (0 != (level_blocksize[0][lev]    |
			  level_subblocksize[0][lev] |
			  level_size[0][lev]         |
			  level_assoc[0][lev]        |
			  level_replacement[0][lev]  |
			  level_fetch[0][lev]        | 
			  level_walloc[0][lev]       |
			  level_wback[0][lev]        |
			  level_doccc[0][lev]         ) &&
		    0 != (level_blocksize[1][lev]    | level_blocksize[2][lev]    |
			  level_subblocksize[1][lev] | level_subblocksize[2][lev] |
			  level_size[1][lev]         | level_size[2][lev]         |
			  level_assoc[1][lev]        | level_assoc[2][lev]        |
			  level_replacement[1][lev]  | level_replacement[2][lev]  |
			  level_fetch[1][lev]        | level_fetch[2][lev]        |
			  level_walloc[1][lev]       | level_walloc[2][lev]       |
			  level_wback[1][lev]        | level_wback[2][lev]        |
			  level_doccc[1][lev]        | level_doccc[2][lev]         ))
			shorthelp ("level %d has i or d together with u cache parameters\n",
				   lev+1);
	}

	/* check consistency of sizes */
	for (lev = 0;  lev < maxlevel;  lev++) {
		for (idu = 0;  idu < 3;  idu++) {
			if (level_blocksize[idu][lev] != 0 &&
			    level_blocksize[idu][lev] * level_assoc[idu][lev] > level_size[idu][lev])
				shorthelp ("level %d %ccache size < blocksize * associativity\n",
					   lev+1, idu==0?'u':(idu==1?'i':'d'));
		}
	}

	/* check for no u->id split */
	for (lev = 1;  lev < maxlevel;  lev++) {
		if (level_blocksize[0][lev-1] != 0 &&
		    level_blocksize[0][lev] == 0)
			shorthelp ("level %d cache is unified, level %d is not\n", lev, lev+1);
	}
}


/*
 * Initialize one cache based on args
 * Die with an error message if there are serious problems.
 */
void
init_1cache (d4cache *c, int lev, int idu)
{
	c->name = malloc (30);
	if (c->name == NULL)
		die ("malloc failure initializing l%d%ccache\n", lev+1, idu==0?'u':(idu==1?'i':'d'));
	sprintf (c->name, "l%d-%ccache", lev+1, idu==0?'u':(idu==1?'i':'d'));

	c->flags |= level_doccc[idu][lev] ? D4F_CCC : 0;
	if (idu == 1)
		c->flags |= D4F_RO;
	c->lg2blocksize = clog2 (level_blocksize[idu][lev]);
	c->lg2subblocksize = clog2 (level_subblocksize[idu][lev]);
	c->lg2size = clog2 (level_size[idu][lev]);
	c->assoc = level_assoc[idu][lev];

	switch (level_replacement[idu][lev]) {
	default:  die ("replacement policy '%c' initialization botch\n", level_replacement[idu][lev]);
	case 'l': c->replacementf = d4rep_lru; c->name_replacement = "LRU"; break;
	case 'f': c->replacementf = d4rep_fifo; c->name_replacement = "FIFO"; break;
	case 'r': c->replacementf = d4rep_random; c->name_replacement = "random"; break;
	}

	switch (level_fetch[idu][lev]) {
	default:  die ("fetch policy '%c' initialization botch\n", level_fetch[idu][lev]);
	case 'd': c->prefetchf = d4prefetch_none; c->name_prefetch = "demand only"; break;
	case 'a': c->prefetchf = d4prefetch_always; c->name_prefetch = "always"; break;
	case 'm': c->prefetchf = d4prefetch_miss; c->name_prefetch = "miss"; break;
	case 't': c->prefetchf = d4prefetch_tagged; c->name_prefetch = "tagged"; break;
	case 'l': c->prefetchf = d4prefetch_loadforw; c->name_prefetch = "load forward"; break;
	case 's': c->prefetchf = d4prefetch_subblock; c->name_prefetch = "subblock"; break;
	}

	switch (level_walloc[idu][lev]) {
	default:  die ("write allocate policy '%c' initialization botch\n", level_walloc[idu][lev]);
	case 0:   c->wallocf = d4walloc_impossible; c->name_walloc = "impossible"; break;
	case 'a': c->wallocf = d4walloc_always; c->name_walloc = "always"; break;
	case 'n': c->wallocf = d4walloc_never; c->name_walloc = "never"; break;
	case 'f': c->wallocf = d4walloc_nofetch; c->name_walloc = "nofetch"; break;
	}

	switch (level_wback[idu][lev]) {
	default:  die ("write back policy '%c' initialization botch\n", level_wback[idu][lev]);
	case 0:   c->wbackf = d4wback_impossible; c->name_wback = "impossible"; break;
	case 'a': c->wbackf = d4wback_always; c->name_wback = "always"; break;
	case 'n': c->wbackf = d4wback_never; c->name_wback = "never"; break;
	case 'f': c->wbackf = d4wback_nofetch; c->name_wback = "nofetch"; break;
	}

	c->prefetch_distance = level_prefetch_distance[idu][lev] * level_subblocksize[idu][lev];
	c->prefetch_abortpercent = level_prefetch_abortpercent[idu][lev];
}