memory.h File Reference

Contains functions for generating memory coverage reports. More...

#include <stdio.h>
#include "defines.h"

Functions
void	memory_get_stat (vsignal sig, unsigned int wr_hit, unsigned int rd_hit, unsigned int ae_total, unsigned int tog01_hit, unsigned int tog10_hit, unsigned int tog_total, unsigned int excluded, bool *cov_found, bool ignore_excl)
	Calculates the memory coverage numbers for a given memory signal.
void	memory_get_stats (func_unit funit, unsigned int wr_hit, unsigned int rd_hit, unsigned int ae_total, unsigned int tog01_hit, unsigned int tog10_hit, unsigned int tog_total, unsigned int excluded, bool *cov_found)
	Calculates memory coverage numbers for the specified signal list.
void	memory_get_funit_summary (func_unit funit, unsigned int hit, unsigned int excluded, unsigned int total)
	Gets memory summary information for a GUI request.
void	memory_get_inst_summary (funit_inst funit, unsigned int hit, unsigned int excluded, unsigned int total)
	Gets memory summary information for a GUI request.
void	memory_get_coverage (func_unit funit, const char signame, char pdim_str, char pdim_array, char udim_str, char memory_info, int excluded, char *reason)
	Gets coverage information for the specified memory.
void	memory_collect (func_unit funit, int cov, sig_link head, sig_link *tail)
	Collects all signals that are memories and match the given coverage metric for the given functional unit.
void	memory_report (FILE *ofile, bool verbose)
	Generates report output for line coverage.

Detailed Description

Contains functions for generating memory coverage reports.

Author:: Trevor Williams (phase1geo@gmail.com)

Date:: 9/24/2006

Function Documentation

void memory_collect	(	func_unit *	funit,
		int	cov,
		sig_link **	head,
		sig_link **	tail
	)

Collects all signals that are memories and match the given coverage metric for the given functional unit.

Collects all signals that are memories and match the given coverage type and stores them in the given signal list.

Parameters:

	funit	Pointer to functional unit
	cov	Set to 0 to get uncovered memories or 1 to get covered memories
	head	Pointer to head of signal list containing retrieved signals
	tail	Pointer to tail of signal list containing retrieved signals

References FALSE, func_iter_dealloc(), func_iter_get_next_signal(), func_iter_init(), memory_get_stat(), ssuppl_u::part, PROFILE, PROFILE_END, sig_link_add(), SSUPPL_TYPE_MEM, vsignal_s::suppl, TRUE, and ssuppl_u::type.

00506   { PROFILE(MEMORY_COLLECT);
00507 
00508   func_iter    fi;             /* Functional unit iterator */
00509   vsignal*     sig;            /* Pointer to current signal */
00510   unsigned int wr_hit    = 0;  /* Total number of addressable elements written */
00511   unsigned int rd_hit    = 0;  /* Total number of addressable elements read */
00512   unsigned int ae_total  = 0;  /* Total number of addressable elements */
00513   unsigned int hit01     = 0;  /* Number of bits that toggled from 0 to 1 */
00514   unsigned int hit10     = 0;  /* Number of bits that toggled from 1 to 0 */
00515   unsigned int tog_total = 0;  /* Total number of toggle bits */
00516   unsigned int excluded  = 0;  /* Number of excluded memory coverage points */
00517   bool         cov_found;
00518 
00519   func_iter_init( &fi, funit, FALSE, TRUE );
00520 
00521   while( (sig = func_iter_get_next_signal( &fi )) != NULL ) {
00522 
00523     if( sig->suppl.part.type == SSUPPL_TYPE_MEM ) {
00524 
00525       ae_total = 0;
00526    
00527       memory_get_stat( sig, &ae_total, &wr_hit, &rd_hit, &tog_total, &hit01, &hit10, &excluded, &cov_found, TRUE );
00528 
00529       /* If this signal meets the coverage requirement, add it to the signal list */
00530       if( ((cov == 1) && (wr_hit > 0) && (rd_hit > 0) && (hit01 == tog_total) && (hit10 == tog_total)) ||
00531           ((cov == 0) && ((wr_hit == 0) || (rd_hit == 0) || (hit01 < tog_total) || (hit10 < tog_total))) ) {
00532 
00533         sig_link_add( sig, head, tail );
00534 
00535       }
00536 
00537     }
00538 
00539   }
00540 
00541   func_iter_dealloc( &fi );
00542 
00543   PROFILE_END;
00544 
00545 }

void memory_get_coverage	(	func_unit *	funit,
		const char *	signame,
		char **	pdim_str,
		char **	pdim_array,
		char **	udim_str,
		char **	memory_info,
		int *	excluded,
		char **	reason
	)

Gets coverage information for the specified memory.

Retrieves memory coverage information for the given signal in the specified functional unit.

Parameters:

	funit	Pointer to functional unit
	signame	Name of signal to find memory coverage information for
	pdim_str	Pointer to string to store packed dimensional information
	pdim_array	Pointer to string to store packed dimensional array
	udim_str	Pointer to string to store unpacked dimensional information
	memory_info	Pointer to string to store memory information into
	excluded	Pointer to excluded indicator to store
	reason	Pointer to reason for exclusion

References vsignal_s::dim, exclude_find_exclude_reason(), ssuppl_u::excluded, FALSE, func_iter_dealloc(), func_iter_get_next_signal(), func_iter_init(), vsignal_s::id, dim_range_s::lsb, malloc_safe, memory_create_pdim_bit_array(), memory_get_mem_coverage(), dim_range_s::msb, vsignal_s::name, ssuppl_u::part, vsignal_s::pdim_num, PROFILE, PROFILE_END, realloc_safe, exclude_reason_s::reason, strdup_safe, vsignal_s::suppl, TRUE, vsignal_s::udim_num, vsignal_s::value, and vector_s::width.

00413   { PROFILE(MEMORY_GET_COVERAGE);
00414 
00415   func_iter       fi;        /* Functional unit iterator */
00416   vsignal*        sig;       /* Pointer to current signal */
00417   unsigned int    i;         /* Loop iterator */
00418   char            tmp1[20];  /* Temporary string holder */
00419   char            tmp2[20];  /* Temporary string holder */
00420   unsigned int    rv;        /* Return value */
00421   exclude_reason* er;
00422 
00423   /* Find the signal in the functional unit */
00424   func_iter_init( &fi, funit, FALSE, TRUE );
00425   while( ((sig = func_iter_get_next_signal( &fi )) != NULL) && (strcmp( sig->name, signame ) != 0) );
00426   func_iter_dealloc( &fi );
00427   assert( sig != NULL );
00428 
00429   /* Allocate and populate the pdim_array and pdim_width parameters */
00430   *pdim_array = (char*)malloc_safe( 1 );
00431   (*pdim_array)[0] = '\0';
00432   memory_create_pdim_bit_array( pdim_array, sig, "", sig->pdim_num );
00433 
00434   /* Allocate and populate the pdim_str string */
00435   *pdim_str = NULL;
00436   for( i=sig->udim_num; i<(sig->pdim_num + sig->udim_num); i++ ) {
00437     unsigned int slen;
00438     rv = snprintf( tmp1, 20, "%d", sig->dim[i].msb );
00439     assert( rv < 20 );
00440     rv = snprintf( tmp2, 20, "%d", sig->dim[i].lsb );
00441     assert( rv < 20 );
00442     slen = strlen( tmp1 ) + strlen( tmp2 ) + 4;
00443     *pdim_str = (char*)realloc_safe( *pdim_str, (strlen( *pdim_str ) + 1), slen );
00444     if( i == sig->udim_num ) {
00445       rv = snprintf( *pdim_str, slen, "[%s:%s]", tmp1, tmp2 );
00446       assert( rv < slen );
00447     } else {
00448       strcat( *pdim_str, "[" );
00449       strcat( *pdim_str, tmp1 );
00450       strcat( *pdim_str, ":" );
00451       strcat( *pdim_str, tmp2 );
00452       strcat( *pdim_str, "]" );
00453     }
00454   }
00455 
00456   /* Allocate and populate the udim_info string */
00457   *udim_str = NULL;
00458   for( i=0; i<sig->udim_num; i++ ) {
00459     unsigned int slen;
00460     rv = snprintf( tmp1, 20, "%d", sig->dim[i].msb );
00461     assert( rv < 20 );
00462     rv = snprintf( tmp2, 20, "%d", sig->dim[i].lsb );
00463     assert( rv < 20 );
00464     slen = strlen( tmp1 ) + strlen( tmp2 ) + 4;
00465     *udim_str = (char*)realloc_safe( *udim_str, (strlen( *udim_str ) + 1), slen );
00466     if( i == 0 ) {
00467       rv = snprintf( *udim_str, slen, "[%s:%s]", tmp1, tmp2 );
00468       assert( rv < slen );
00469     } else {
00470       strcat( *udim_str, "[" );
00471       strcat( *udim_str, tmp1 );
00472       strcat( *udim_str, ":" );
00473       strcat( *udim_str, tmp2 );
00474       strcat( *udim_str, "]" );
00475     }
00476   }
00477 
00478   /* Populate the memory_info string */
00479   *memory_info = (char*)malloc_safe( 1 );
00480   (*memory_info)[0] = '\0';
00481   memory_get_mem_coverage( memory_info, sig, 0, "", 0, sig->value->width );
00482 
00483   /* Populate the excluded value */
00484   *excluded = sig->suppl.part.excluded;
00485 
00486   /* Populate the exclusion reason */
00487   if( (*excluded == 1) && ((er = exclude_find_exclude_reason( 'M', sig->id, funit )) != NULL) ) {
00488     *reason = strdup_safe( er->reason );
00489   } else {
00490     *reason = NULL;
00491   }
00492   
00493   PROFILE_END;
00494 
00495 }

void memory_get_funit_summary	(	func_unit *	funit,
		unsigned int *	hit,
		unsigned int *	excluded,
		unsigned int *	total
	)

Gets memory summary information for a GUI request.

Retrieves memory summary information for a given functional unit made by a GUI request.

Parameters:

	funit	Pointer to found functional unit
	hit	Pointer to number of memories that received 100% coverage of all memory metrics
	excluded	Pointer to number of excluded memory coverage points
	total	Pointer to total number of memories in the given functional unit

References statistic_s::mem_ae_total, statistic_s::mem_excluded, statistic_s::mem_rd_hit, statistic_s::mem_tog01_hit, statistic_s::mem_tog10_hit, statistic_s::mem_tog_total, statistic_s::mem_wr_hit, PROFILE, PROFILE_END, and func_unit_s::stat.

00173   { PROFILE(MEMORY_GET_FUNIT_SUMMARY);
00174 
00175   *hit      = funit->stat->mem_wr_hit + funit->stat->mem_rd_hit + funit->stat->mem_tog01_hit + funit->stat->mem_tog10_hit;
00176   *excluded = funit->stat->mem_excluded;
00177   *total    = (funit->stat->mem_ae_total * 2) + (funit->stat->mem_tog_total * 2);
00178 
00179   PROFILE_END;
00180 
00181 }

void memory_get_inst_summary	(	funit_inst *	inst,
		unsigned int *	hit,
		unsigned int *	excluded,
		unsigned int *	total
	)

Gets memory summary information for a GUI request.

Retrieves memory summary information for a given functional unit instance made by a GUI request.

Parameters:

	inst	Pointer to found functional unit instance
	hit	Pointer to number of memories that received 100% coverage of all memory metrics
	excluded	Pointer to number of excluded memory coverage points
	total	Pointer to total number of memories in the given functional unit instance

References statistic_s::mem_ae_total, statistic_s::mem_excluded, statistic_s::mem_rd_hit, statistic_s::mem_tog01_hit, statistic_s::mem_tog10_hit, statistic_s::mem_tog_total, statistic_s::mem_wr_hit, PROFILE, PROFILE_END, and funit_inst_s::stat.

00191   { PROFILE(MEMORY_GET_INST_SUMMARY);
00192 
00193   *hit      = inst->stat->mem_wr_hit + inst->stat->mem_rd_hit + inst->stat->mem_tog01_hit + inst->stat->mem_tog10_hit;
00194   *excluded = inst->stat->mem_excluded;
00195   *total    = (inst->stat->mem_ae_total * 2) + (inst->stat->mem_tog_total * 2);
00196   
00197   PROFILE_END; 
00198   
00199 }

void memory_get_stat	(	vsignal *	sig,
		unsigned int *	wr_hit,
		unsigned int *	rd_hit,
		unsigned int *	ae_total,
		unsigned int *	tog01_hit,
		unsigned int *	tog10_hit,
		unsigned int *	tog_total,
		unsigned int *	excluded,
		bool *	cov_found,
		bool	ignore_excl
	)

Calculates the memory coverage numbers for a given memory signal.

Calculates the total and hit memory coverage information for the given memory signal.

Parameters:

	sig	Pointer to signal list to traverse for memories
	wr_hit	Pointer to total number of addressable elements written
	rd_hit	Pointer to total number of addressable elements read
	ae_total	Pointer to total number of addressable elements
	tog01_hit	Pointer to total number of bits toggling from 0->1
	tog10_hit	Pointer to total number of bits toggling from 1->0
	tog_total	Pointer to total number of bits in memories that can be toggled
	excluded	Pointer to total number of excluded memory coverage points
	cov_found	Pointer to value that is set to TRUE if at least one memory was found to be fully covered
	ignore_excl	If set to TRUE, ignores the current value of the excluded bit

References vsignal_s::dim, ssuppl_u::excluded, FALSE, dim_range_s::lsb, dim_range_s::msb, ssuppl_u::part, vsignal_s::pdim_num, PROFILE, PROFILE_END, vsignal_s::suppl, TRUE, vsignal_s::udim_num, vsignal_s::value, vector_mem_rw_count(), vector_toggle_count(), and vector_s::width.

Referenced by exclude_sig_assign_and_recalc(), memory_collect(), and memory_get_stats().

00066 00067 00068 00069 00070 00071 00072 00073 00074 00075 00076 00077 00078 00079     } 00080   } 00081 00082 00083 00084 00085 00086 00087 00088 00089 00090 00091 00092 00093 00094       } 00095 00096 00097       } 00098 00099     } 00100 00101   } 00102 00103 00104 00105 00106 00107 00108 00109 00110 00111 00112 00113 00114 00115 00116   } 00117 00118 00119 00120 00121 00122 }

class="fragment">00065 { PROFILE(MEMORY_GET_STAT); unsigned int i; /* Loop iterator */ unsigned int pwidth; /* Width of packed portion of memory */ bool ae_cov_found = TRUE; /* Set to TRUE if wr/rd hits equals the total */ bool tog_cov_found = FALSE; /* Set to TRUE if tog01/10 hits equals the total */ /* Calculate width of smallest addressable element */ pwidth = 1; for( i=(sig->udim_num); i<(sig->udim_num + sig->pdim_num); i++ ) { if( sig->dim[i].msb > sig->dim[i].lsb ) { pwidth *= (sig->dim[i].msb - sig->dim[i].lsb) + 1; } else { pwidth *= (sig->dim[i].lsb - sig->dim[i].msb) + 1; /* Calculate total number of addressable elements and their write/read information */ for( i=0; i<sig->value->width; i+=pwidth ) { if( (sig->suppl.part.excluded == 1) && !ignore_excl ) { (*wr_hit)++; (*rd_hit)++; *excluded += 2; } else { unsigned int wr = 0; unsigned int rd = 0; vector_mem_rw_count( sig->value, (int)i, (int)((i + pwidth) - 1), &wr, &rd ); if( wr > 0 ) { (*wr_hit)++; if( rd > 0 ) { (*rd_hit)++; ae_cov_found &= (wr > 0) && (rd > 0); (*ae_total)++; /* Calculate toggle coverage information for the memory */ *tog_total += sig->value->width; if( (sig->suppl.part.excluded == 1) && !ignore_excl ) { *tog01_hit += sig->value->width; *tog10_hit += sig->value->width; *excluded += (sig->value->width * 2); } else { unsigned int hit01 = 0; unsigned int hit10 = 0; vector_toggle_count( sig->value, &hit01, &hit10 ); *tog01_hit += hit01; *tog10_hit += hit10; tog_cov_found = (hit01 == sig->value->width) && (hit10 == sig->value->width); *cov_found |= ae_cov_found && tog_cov_found; PROFILE_END;

void memory_get_stats	(	func_unit *	funit,
		unsigned int *	wr_hit,
		unsigned int *	rd_hit,
		unsigned int *	ae_total,
		unsigned int *	tog01_hit,
		unsigned int *	tog10_hit,
		unsigned int *	tog_total,
		unsigned int *	excluded,
		bool *	cov_found
	)

Calculates memory coverage numbers for the specified signal list.

Gathers memory statistics for the memories in the given signal list.

Parameters:

	funit	Pointer to current functional unit
	wr_hit	Pointer to total number of addressable elements written
	rd_hit	Pointer to total number of addressable elements read
	ae_total	Pointer to total number of addressable elements
	tog01_hit	Pointer to total number of bits toggling from 0->1
	tog10_hit	Pointer to total number of bits toggling from 1->0
	tog_total	Pointer to total number of bits in memories that can be toggled
	excluded	Pointer to total number of excluded memory coverage points
	cov_found	Pointer to value indicating that at least one memory was found to be fully covered

References FALSE, func_iter_dealloc(), func_iter_get_next_signal(), func_iter_init(), funit_is_unnamed(), memory_get_stat(), ssuppl_u::part, PROFILE, PROFILE_END, SSUPPL_TYPE_MEM, vsignal_s::suppl, TRUE, ssuppl_u::type, and vsignal_s::udim_num.

Referenced by report_gather_funit_stats(), and report_gather_instance_stats().

00137   { PROFILE(MEMORY_GET_STATS);
00138 
00139   if( !funit_is_unnamed( funit ) ) {
00140 
00141     func_iter fi;
00142     vsignal*  sig;
00143 
00144     func_iter_init( &fi, funit, FALSE, TRUE );
00145    
00146     while( (sig = func_iter_get_next_signal( &fi )) != NULL ) {
00147 
00148       /* Calculate only for memory elements (must contain one or more unpacked dimensions) */
00149       if( (sig->suppl.part.type == SSUPPL_TYPE_MEM) && (sig->udim_num > 0) ) {
00150 
00151         memory_get_stat( sig, wr_hit, rd_hit, ae_total, tog01_hit, tog10_hit, tog_total, excluded, cov_found, FALSE );
00152 
00153       }
00154 
00155     }
00156 
00157     func_iter_dealloc( &fi );
00158 
00159   }
00160 
00161   PROFILE_END;
00162 
00163 }

void memory_report	(	FILE *	ofile,
		bool	verbose
	)

Generates report output for line coverage.

Outputs the memory portion of the report to the given output stream.

Parameters:

	ofile	Pointer to output file to write
	verbose	Specifies if verbose coverage information should be output

References curr_db, FALSE, funit_head, inst_link_s::inst, db_s::inst_head, memory_ae_funit_summary(), memory_ae_instance_summary(), memory_display_ae_funit_summary(), memory_display_ae_instance_summary(), memory_display_toggle_funit_summary(), memory_display_toggle_instance_summary(), memory_funit_verbose(), memory_instance_verbose(), memory_toggle_funit_summary(), memory_toggle_instance_summary(), funit_inst_s::name_diff, inst_link_s::next, PROFILE, PROFILE_END, report_covered, report_exclusions, report_instance, and funit_inst_s::suppl.

Referenced by report_generate().

01237   { PROFILE(MEMORY_REPORT);
01238 
01239   bool       missed_found  = FALSE;  /* If set to TRUE, indicates that untoggled bits were found */
01240   inst_link* instl;                  /* Pointer to current instance link */
01241   int        acc_hits01    = 0;      /* Accumulated hits 0 -> 1 count */
01242   int        acc_hits10    = 0;      /* Accumulated hits 1 -> 0 count */
01243   int        acc_tog_total = 0;      /* Accumulated bit toggle count */
01244   int        acc_wr_hits   = 0;      /* Accumulated number of addressable elements written */
01245   int        acc_rd_hits   = 0;      /* Accumulated number of addressable elements read */
01246   int        acc_ae_total  = 0;      /* Accumulated number of addressable elements */
01247 
01248   fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
01249   fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   MEMORY COVERAGE RESULTS   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
01250   fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" );
01251 
01252   if( report_instance ) {
01253 
01254     fprintf( ofile, "                                                           Toggle 0 -> 1                       Toggle 1 -> 0\n" );
01255     fprintf( ofile, "Instance                                           Hit/ Miss/Total    Percent hit      Hit/ Miss/Total    Percent hit\n" );
01256     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01257 
01258     instl = db_list[curr_db]->inst_head;
01259     while( instl != NULL ) {
01260       missed_found |= memory_toggle_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_hits01, &acc_hits10, &acc_tog_total );
01261       instl = instl->next;
01262     }
01263     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01264     (void)memory_display_toggle_instance_summary( ofile, "Accumulated", acc_hits01, acc_hits10, acc_tog_total );
01265 
01266     fprintf( ofile, "\n" );
01267     fprintf( ofile, "                                                    Addressable elements written         Addressable elements read\n" );
01268     fprintf( ofile, "                                                   Hit/ Miss/Total    Percent hit      Hit/ Miss/Total    Percent hit\n" );
01269     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01270 
01271     instl = db_list[curr_db]->inst_head;
01272     while( instl != NULL ) {
01273       missed_found |= memory_ae_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_wr_hits, &acc_rd_hits, &acc_ae_total );
01274       instl = instl->next;
01275     }
01276     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01277     (void)memory_display_ae_instance_summary( ofile, "Accumulated", acc_wr_hits, acc_rd_hits, acc_ae_total );
01278 
01279     if( verbose && (missed_found || report_covered || report_exclusions) ) {
01280       fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01281       instl = db_list[curr_db]->inst_head;
01282       while( instl != NULL ) {
01283         memory_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") );
01284         instl = instl->next;
01285       }
01286     }
01287 
01288   } else {
01289 
01290     fprintf( ofile, "                                                           Toggle 0 -> 1                       Toggle 1 -> 0\n" );
01291     fprintf( ofile, "Module/Task/Function      Filename                 Hit/ Miss/Total    Percent hit      Hit/ Miss/Total    Percent hit\n" );
01292     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01293 
01294     missed_found |= memory_toggle_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_hits01, &acc_hits10, &acc_tog_total );
01295     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01296     (void)memory_display_toggle_funit_summary( ofile, "Accumulated", "", acc_hits01, acc_hits10, acc_tog_total );
01297 
01298     fprintf( ofile, "\n" );
01299     fprintf( ofile, "                                                    Addressable elements written         Addressable elements read\n" );
01300     fprintf( ofile, "                                                   Hit/ Miss/Total    Percent hit      Hit/ Miss/Total    Percent hit\n" );
01301     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01302 
01303     missed_found |= memory_ae_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_wr_hits, &acc_rd_hits, &acc_ae_total );
01304     fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01305     (void)memory_display_ae_funit_summary( ofile, "Accumulated", "", acc_wr_hits, acc_rd_hits, acc_ae_total );
01306 
01307     if( verbose && (missed_found || report_covered || report_exclusions) ) {
01308       fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" );
01309       memory_funit_verbose( ofile, db_list[curr_db]->funit_head );
01310     }
01311 
01312   }
01313 
01314   fprintf( ofile, "\n\n" );
01315 
01316   PROFILE_END;
01317 
01318 }

memory.h File Reference

Functions

Detailed Description

Function Documentation