cmdmain.c

这是个trace drive的Cache模拟器

	prefetch_fetch_data = c->fetch[D4PREFETCH+D4XMISC] 
			  + c->fetch[D4PREFETCH+D4XREAD]
		      	  + c->fetch[D4PREFETCH+D4XWRITE];
	if (c->prefetchf != d4prefetch_none) {
		prefetch_fetch_alltype = prefetch_fetch_data 
				  + c->fetch[D4PREFETCH+D4XINSTRN];

		printf(	" Prefetch Fetches	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			prefetch_fetch_alltype,
			c->fetch[D4PREFETCH+D4XINSTRN],
			prefetch_fetch_data,
			c->fetch[D4PREFETCH+D4XREAD],
			c->fetch[D4PREFETCH+D4XWRITE],
			c->fetch[D4PREFETCH+D4XMISC]);

		floatnum = NONZERO(prefetch_fetch_alltype);

		printf(	"  Fraction		%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			prefetch_fetch_alltype / floatnum,
			c->fetch[D4PREFETCH+D4XINSTRN] / floatnum,
			prefetch_fetch_data / floatnum,
			c->fetch[D4PREFETCH+D4XREAD] / floatnum,
			c->fetch[D4PREFETCH+D4XWRITE] / floatnum,
			c->fetch[D4PREFETCH+D4XMISC] / floatnum);

		printf(	" Total Fetches		%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_fetch_alltype + prefetch_fetch_alltype,
			c->fetch[D4XINSTRN] + c->fetch[D4PREFETCH+D4XINSTRN],
			demand_fetch_data + prefetch_fetch_data,
			c->fetch[D4XREAD] + c->fetch[D4PREFETCH+D4XREAD],
			c->fetch[D4XWRITE] + c->fetch[D4PREFETCH+D4XWRITE],
			c->fetch[D4XMISC] + c->fetch[D4PREFETCH+D4XMISC]);

		floatnum = NONZERO(demand_fetch_alltype + prefetch_fetch_alltype);

		printf(	"  Fraction		%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			(demand_fetch_alltype + prefetch_fetch_alltype) / floatnum,
			(c->fetch[D4XINSTRN] + c->fetch[D4PREFETCH+D4XINSTRN]) / floatnum,
			(demand_fetch_data + prefetch_fetch_data) / floatnum,
			(c->fetch[D4XREAD] + c->fetch[D4PREFETCH+D4XREAD]) / floatnum,
			(c->fetch[D4XWRITE] + c->fetch[D4PREFETCH+D4XWRITE]) / floatnum,
			(c->fetch[D4XMISC] + c->fetch[D4PREFETCH+D4XMISC]) / floatnum);

	} /* End of prefetching. */
	printf("\n");

	/*
	 * End of Fetch Numbers
	 */

	/*
	 * Print Miss Numbers
	 */
	demand_data = c->miss[D4XMISC] 
			  + c->miss[D4XREAD]
		      	  + c->miss[D4XWRITE];
	demand_alltype = demand_data 
			  + c->miss[D4XINSTRN];

	printf(	" Demand Misses		%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
		demand_alltype,
		c->miss[D4XINSTRN],
		demand_data,
		c->miss[D4XREAD],
		c->miss[D4XWRITE],
		c->miss[D4XMISC]);


	printf(	"  Demand miss rate	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
		demand_alltype / NONZERO(demand_fetch_alltype),
		c->miss[D4XINSTRN] / NONZERO(c->fetch[D4XINSTRN]),
		demand_data / NONZERO(demand_fetch_data),
		c->miss[D4XREAD] / NONZERO(c->fetch[D4XREAD]),
		c->miss[D4XWRITE] / NONZERO(c->fetch[D4XWRITE]),
		c->miss[D4XMISC] / NONZERO(c->fetch[D4XMISC]));

	if (c->flags & D4F_CCC) {
		demand_comp_data = c->comp_miss[D4XMISC] 
			  + c->comp_miss[D4XREAD]
		      	  + c->comp_miss[D4XWRITE];
		demand_comp_alltype = demand_comp_data 
			  + c->comp_miss[D4XINSTRN];
		demand_cap_data = c->cap_miss[D4XMISC] 
			  + c->cap_miss[D4XREAD]
		      	  + c->cap_miss[D4XWRITE];
		demand_cap_alltype = demand_cap_data 
			  + c->cap_miss[D4XINSTRN];
		demand_conf_data = c->conf_miss[D4XMISC] 
			  + c->conf_miss[D4XREAD]
		      	  + c->conf_miss[D4XWRITE];
		demand_conf_alltype = demand_conf_data 
			  + c->conf_miss[D4XINSTRN];

		printf(	"   Compulsory misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_comp_alltype,
			c->comp_miss[D4XINSTRN],
			demand_comp_data,
			c->comp_miss[D4XREAD],
			c->comp_miss[D4XWRITE],
			c->comp_miss[D4XMISC]);
	    
		printf(	"   Capacity misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_cap_alltype,
			c->cap_miss[D4XINSTRN],
			demand_cap_data,
			c->cap_miss[D4XREAD],
			c->cap_miss[D4XWRITE],
			c->cap_miss[D4XMISC]);
	    
		printf(	"   Conflict misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_conf_alltype,
			c->conf_miss[D4XINSTRN],
			demand_conf_data,
			c->conf_miss[D4XREAD],
			c->conf_miss[D4XWRITE],
			c->conf_miss[D4XMISC]);

		printf(	"   Compulsory fraction	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			demand_comp_alltype / NONZERO(demand_alltype),
			c->comp_miss[D4XINSTRN] / NONZERO(c->miss[D4XINSTRN]),
			demand_comp_data / NONZERO(demand_data),
			c->comp_miss[D4XREAD] / NONZERO(c->miss[D4XREAD]),
			c->comp_miss[D4XWRITE] / NONZERO(c->miss[D4XWRITE]),
			c->comp_miss[D4XMISC] / NONZERO(c->miss[D4XMISC]));
	    
		printf(	"   Capacity fraction	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			demand_cap_alltype / NONZERO(demand_alltype),
			c->cap_miss[D4XINSTRN]  / NONZERO(c->miss[D4XINSTRN]),
			demand_cap_data / NONZERO(demand_data),
			c->cap_miss[D4XREAD] / NONZERO(c->miss[D4XREAD]),
			c->cap_miss[D4XWRITE] / NONZERO(c->miss[D4XWRITE]),
			c->cap_miss[D4XMISC] / NONZERO(c->miss[D4XMISC]));
	    
		printf(	"   Conflict fraction	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			demand_conf_alltype / NONZERO(demand_alltype),
			c->conf_miss[D4XINSTRN] / NONZERO(c->miss[D4XINSTRN]),
			demand_conf_data / NONZERO(demand_data),
			c->conf_miss[D4XREAD] / NONZERO(c->miss[D4XREAD]),
			c->conf_miss[D4XWRITE] / NONZERO(c->miss[D4XWRITE]),
			c->conf_miss[D4XMISC] / NONZERO(c->miss[D4XMISC]));
	}

	/*
	 * Prefetch misses?
	 */
	if (c->prefetchf != d4prefetch_none) {
		prefetch_data = c->miss[D4PREFETCH+D4XMISC] 
				  + c->miss[D4PREFETCH+D4XREAD]
			      	  + c->miss[D4PREFETCH+D4XWRITE];
		prefetch_alltype = prefetch_data 
				  + c->miss[D4PREFETCH+D4XINSTRN];

		printf(	" Prefetch Misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			prefetch_alltype,
			c->miss[D4PREFETCH+D4XINSTRN],
			prefetch_data,
			c->miss[D4PREFETCH+D4XREAD],
			c->miss[D4PREFETCH+D4XWRITE],
			c->miss[D4PREFETCH+D4XMISC]);

		printf(	"  PF miss rate		%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			prefetch_alltype / NONZERO(prefetch_fetch_alltype),
			c->miss[D4PREFETCH+D4XINSTRN] / NONZERO(c->fetch[D4PREFETCH+D4XINSTRN]),
			prefetch_data / NONZERO(prefetch_fetch_data),
			c->miss[D4PREFETCH+D4XREAD] / NONZERO(c->fetch[D4PREFETCH+D4XREAD]),
			c->miss[D4PREFETCH+D4XWRITE] / NONZERO(c->fetch[D4PREFETCH+D4XWRITE]),
			c->miss[D4PREFETCH+D4XMISC] / NONZERO(c->fetch[D4PREFETCH+D4XMISC]));

		if (c->flags & D4F_CCC) {
			demand_comp_data = c->comp_miss[D4PREFETCH+D4XMISC] 
			  + c->comp_miss[D4PREFETCH+D4XREAD]
		      	  + c->comp_miss[D4PREFETCH+D4XWRITE];
			demand_comp_alltype = demand_comp_data 
			  + c->comp_miss[D4PREFETCH+D4XINSTRN];
			demand_cap_data = c->cap_miss[D4PREFETCH+D4XMISC] 
			  + c->cap_miss[D4PREFETCH+D4XREAD]
		      	  + c->cap_miss[D4PREFETCH+D4XWRITE];
			demand_cap_alltype = demand_cap_data 
			  + c->cap_miss[D4PREFETCH+D4XINSTRN];
			demand_conf_data = c->conf_miss[D4PREFETCH+D4XMISC] 
			  + c->conf_miss[D4PREFETCH+D4XREAD]
		      	  + c->conf_miss[D4PREFETCH+D4XWRITE];
			demand_conf_alltype = demand_conf_data 
			  + c->conf_miss[D4PREFETCH+D4XINSTRN];

			printf(	"   PF compulsory misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_comp_alltype,
				c->comp_miss[D4PREFETCH+D4XINSTRN],
				demand_comp_data,
				c->comp_miss[D4PREFETCH+D4XREAD],
				c->comp_miss[D4PREFETCH+D4XWRITE],
				c->comp_miss[D4PREFETCH+D4XMISC]);

			printf(	"   PF capacity misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_cap_alltype,
				c->cap_miss[D4PREFETCH+D4XINSTRN],
				demand_cap_data,
				c->cap_miss[D4PREFETCH+D4XREAD],
				c->cap_miss[D4PREFETCH+D4XWRITE],
				c->cap_miss[D4PREFETCH+D4XMISC]);

			printf(	"   PF conflict misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_conf_alltype,
				c->conf_miss[D4PREFETCH+D4XINSTRN],
				demand_conf_data,
				c->conf_miss[D4PREFETCH+D4XREAD],
				c->conf_miss[D4PREFETCH+D4XWRITE],
				c->conf_miss[D4PREFETCH+D4XMISC]);

			printf(	"   PF compulsory fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_comp_alltype / NONZERO(prefetch_alltype),
				c->comp_miss[D4PREFETCH+D4XINSTRN] / NONZERO(c->miss[D4PREFETCH+D4XINSTRN]),
				demand_comp_data / NONZERO(prefetch_data),
				c->comp_miss[D4PREFETCH+D4XREAD] / NONZERO(c->miss[D4PREFETCH+D4XREAD]),
				c->comp_miss[D4PREFETCH+D4XWRITE] / NONZERO(c->miss[D4PREFETCH+D4XWRITE]),
				c->comp_miss[D4PREFETCH+D4XMISC] / NONZERO(c->miss[D4PREFETCH+D4XMISC]));

			printf(	"   PF capacity fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_cap_alltype / NONZERO(prefetch_alltype),
				c->cap_miss[D4PREFETCH+D4XINSTRN] / NONZERO(c->miss[D4PREFETCH+D4XINSTRN]),
				demand_cap_data / NONZERO(prefetch_data),
				c->cap_miss[D4PREFETCH+D4XREAD] / NONZERO(c->miss[D4PREFETCH+D4XREAD]),
				c->cap_miss[D4PREFETCH+D4XWRITE] / NONZERO(c->miss[D4PREFETCH+D4XWRITE]),
				c->cap_miss[D4PREFETCH+D4XMISC] / NONZERO(c->miss[D4PREFETCH+D4XMISC]));

			printf(	"   PF conflict fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_conf_alltype / NONZERO(prefetch_alltype),
				c->conf_miss[D4PREFETCH+D4XINSTRN] / NONZERO(c->miss[D4PREFETCH+D4XINSTRN]),
				demand_conf_data / NONZERO(prefetch_data),
				c->conf_miss[D4PREFETCH+D4XREAD] / NONZERO(c->miss[D4PREFETCH+D4XREAD]),
				c->conf_miss[D4PREFETCH+D4XWRITE] / NONZERO(c->miss[D4PREFETCH+D4XWRITE]),
				c->conf_miss[D4PREFETCH+D4XMISC] / NONZERO(c->miss[D4PREFETCH+D4XMISC]));
		}

		printf(	" Total Misses		%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_alltype + prefetch_alltype,
			c->miss[D4XINSTRN] + c->miss[D4PREFETCH+D4XINSTRN],
			demand_data + prefetch_data,
			c->miss[D4XREAD] + c->miss[D4PREFETCH+D4XREAD],
			c->miss[D4XWRITE] + c->miss[D4PREFETCH+D4XWRITE],
			c->miss[D4XMISC] + c->miss[D4PREFETCH+D4XMISC]);

		printf(	"  Total miss rate	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			(demand_alltype + prefetch_alltype) / NONZERO(demand_fetch_alltype + prefetch_fetch_alltype),
			(c->miss[D4XINSTRN] + c->miss[D4PREFETCH+D4XINSTRN]) / NONZERO(c->fetch[D4XINSTRN] + c->fetch[D4PREFETCH+D4XINSTRN]),
			(demand_data + prefetch_data) / NONZERO(demand_fetch_data + prefetch_fetch_data),
			(c->miss[D4XREAD] + c->miss[D4PREFETCH+D4XREAD]) / NONZERO(c->fetch[D4XREAD] + c->fetch[D4PREFETCH+D4XREAD]),
			(c->miss[D4XWRITE] + c->miss[D4PREFETCH+D4XWRITE]) / NONZERO(c->fetch[D4XWRITE] + c->fetch[D4PREFETCH+D4XWRITE]),
			(c->miss[D4XMISC] + c->miss[D4PREFETCH+D4XMISC]) / NONZERO(c->fetch[D4XMISC] + c->fetch[D4PREFETCH+D4XMISC]));

	} /* End of prefetch misses. */
	printf("\n");

	/*
	 * End of Misses Numbers
	 */


	/*
	 * Print Block Miss Numbers
	 */
	if (c->lg2subblocksize != c->lg2blocksize) {
		demand_data = c->blockmiss[D4XMISC] 
			  + c->blockmiss[D4XREAD]
		      	  + c->blockmiss[D4XWRITE];
		demand_alltype = demand_data 
			  + c->blockmiss[D4XINSTRN];

		printf(	" Demand Block Misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
			demand_alltype,
			c->blockmiss[D4XINSTRN],
			demand_data,
			c->blockmiss[D4XREAD],
			c->blockmiss[D4XWRITE],
			c->blockmiss[D4XMISC]);

		printf(	"  DB miss rate		%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
			demand_alltype / NONZERO(demand_fetch_alltype),
			c->blockmiss[D4XINSTRN] / NONZERO(c->fetch[D4XINSTRN]),
			demand_data / NONZERO(demand_fetch_data),
			c->blockmiss[D4XREAD] / NONZERO(c->fetch[D4XREAD]),
			c->blockmiss[D4XWRITE] / NONZERO(c->fetch[D4XWRITE]),
			c->blockmiss[D4XMISC] / NONZERO(c->fetch[D4XMISC]));

		if (c->flags & D4F_CCC) {
			demand_comp_data = c->comp_blockmiss[D4XMISC] 
			  + c->comp_blockmiss[D4XREAD]
		      	  + c->comp_blockmiss[D4XWRITE];
			demand_comp_alltype = demand_comp_data 
			  + c->comp_blockmiss[D4XINSTRN];
			demand_cap_data = c->cap_blockmiss[D4XMISC] 
			  + c->cap_blockmiss[D4XREAD]
		      	  + c->cap_blockmiss[D4XWRITE];
			demand_cap_alltype = demand_cap_data 
			  + c->cap_blockmiss[D4XINSTRN];
			demand_conf_data = c->conf_blockmiss[D4XMISC] 
			  + c->conf_blockmiss[D4XREAD]
		      	  + c->conf_blockmiss[D4XWRITE];
			demand_conf_alltype = demand_conf_data 
			  + c->conf_blockmiss[D4XINSTRN];

			printf(	"   DB compulsory misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_comp_alltype,
				c->comp_blockmiss[D4XINSTRN],
				demand_comp_data,
				c->comp_blockmiss[D4XREAD],
				c->comp_blockmiss[D4XWRITE],
				c->comp_blockmiss[D4XMISC]);

			printf(	"   DB capacity misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_cap_alltype,
				c->cap_blockmiss[D4XINSTRN],
				demand_cap_data,
				c->cap_blockmiss[D4XREAD],
				c->cap_blockmiss[D4XWRITE],
				c->cap_blockmiss[D4XMISC]);

			printf(	"   DB conflict misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				demand_conf_alltype,
				c->conf_blockmiss[D4XINSTRN],
				demand_conf_data,
				c->conf_blockmiss[D4XREAD],
				c->conf_blockmiss[D4XWRITE],
				c->conf_blockmiss[D4XMISC]);

			printf(	"   DB compulsory fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_comp_alltype / NONZERO(demand_alltype),
				c->comp_blockmiss[D4XINSTRN] / NONZERO(c->blockmiss[D4XINSTRN]),
				demand_comp_data / NONZERO(demand_data),
				c->comp_blockmiss[D4XREAD] / NONZERO(c->blockmiss[D4XREAD]),
				c->comp_blockmiss[D4XWRITE] / NONZERO(c->blockmiss[D4XWRITE]),
				c->comp_blockmiss[D4XMISC]) / NONZERO(c->blockmiss[D4XMISC]);

			printf(	"   DB capacity fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_cap_alltype / NONZERO(demand_alltype),
				c->cap_blockmiss[D4XINSTRN] / NONZERO(c->blockmiss[D4XINSTRN]),
				demand_cap_data / NONZERO(demand_data),
				c->cap_blockmiss[D4XREAD] / NONZERO(c->blockmiss[D4XREAD]),
				c->cap_blockmiss[D4XWRITE] / NONZERO(c->blockmiss[D4XWRITE]),
				c->cap_blockmiss[D4XMISC] / NONZERO(c->blockmiss[D4XMISC]));
	    
			printf(	"   DB conflict fract	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				demand_conf_alltype / NONZERO(demand_alltype),
				c->conf_blockmiss[D4XINSTRN] / NONZERO(c->blockmiss[D4XINSTRN]),
				demand_conf_data / NONZERO(demand_data),
				c->conf_blockmiss[D4XREAD] / NONZERO(c->blockmiss[D4XREAD]),
				c->conf_blockmiss[D4XWRITE] / NONZERO(c->blockmiss[D4XWRITE]),
				c->conf_blockmiss[D4XMISC] / NONZERO(c->blockmiss[D4XMISC]));
		}

		/*
		 * Prefetch block misses?
		 */
		if (c->prefetchf != d4prefetch_none) {
			prefetch_data = c->blockmiss[D4PREFETCH+D4XMISC] 
				  + c->blockmiss[D4PREFETCH+D4XREAD]
		      		  + c->blockmiss[D4PREFETCH+D4XWRITE];
			prefetch_alltype = prefetch_data 
				  + c->blockmiss[D4PREFETCH+D4XINSTRN];

			printf(	" Prefetch Block Misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
				prefetch_alltype,
				c->blockmiss[D4PREFETCH+D4XINSTRN],
				prefetch_data,
				c->blockmiss[D4PREFETCH+D4XREAD],
				c->blockmiss[D4PREFETCH+D4XWRITE],
				c->blockmiss[D4PREFETCH+D4XMISC]);

			printf(	"  PFB miss rate		%12.4f	%12.4f	%12.4f	%12.4f	%12.4f	%12.4f\n",
				prefetch_alltype / NONZERO(prefetch_fetch_alltype),
				c->blockmiss[D4PREFETCH+D4XINSTRN] / NONZERO(c->fetch[D4PREFETCH+D4XINSTRN]),
				prefetch_data / NONZERO(prefetch_fetch_data),
				c->blockmiss[D4PREFETCH+D4XREAD] / NONZERO(c->fetch[D4PREFETCH+D4XREAD]),
				c->blockmiss[D4PREFETCH+D4XWRITE] / NONZERO(c->fetch[D4PREFETCH+D4XWRITE]),
				c->blockmiss[D4PREFETCH+D4XMISC] / NONZERO(c->fetch[D4PREFETCH+D4XMISC]));

			if (c->flags & D4F_CCC) {
				demand_comp_data = c->comp_blockmiss[D4PREFETCH+D4XMISC] 
					+ c->comp_blockmiss[D4PREFETCH+D4XREAD]
					+ c->comp_blockmiss[D4PREFETCH+D4XWRITE];
				demand_comp_alltype = demand_comp_data 
					+ c->comp_blockmiss[D4PREFETCH+D4XINSTRN];
				demand_cap_data = c->cap_blockmiss[D4PREFETCH+D4XMISC] 
					+ c->cap_blockmiss[D4PREFETCH+D4XREAD]
					+ c->cap_blockmiss[D4PREFETCH+D4XWRITE];
				demand_cap_alltype = demand_cap_data 
					+ c->cap_blockmiss[D4PREFETCH+D4XINSTRN];
				demand_conf_data = c->conf_blockmiss[D4PREFETCH+D4XMISC] 
					+ c->conf_blockmiss[D4PREFETCH+D4XREAD]
					+ c->conf_blockmiss[D4PREFETCH+D4XWRITE];
				demand_conf_alltype = demand_conf_data 
					+ c->conf_blockmiss[D4PREFETCH+D4XINSTRN];

				printf(	"   PFB comp misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
					demand_comp_alltype,
					c->comp_blockmiss[D4PREFETCH+D4XINSTRN],
					demand_comp_data,
					c->comp_blockmiss[D4PREFETCH+D4XREAD],
					c->comp_blockmiss[D4PREFETCH+D4XWRITE],
					c->comp_blockmiss[D4PREFETCH+D4XMISC]);

				printf(	"   PFB cap misses	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f	%12.0f\n",
					demand_cap_alltype,