/Users/trevorw/projects/release/covered-0.7.4/src/memory.h File Reference

---

Detailed Description

Contains functions for generating memory coverage reports.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

9/24/2006

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

Go to the source code of this file.

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.

---

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 { PROFILE(MEMORY_COLLECT); func_iter fi; /* Functional unit iterator */ vsignal* sig; /* Pointer to current signal */ unsigned int wr_hit = 0; /* Total number of addressable elements written */ unsigned int rd_hit = 0; /* Total number of addressable elements read */ unsigned int ae_total = 0; /* Total number of addressable elements */ unsigned int hit01 = 0; /* Number of bits that toggled from 0 to 1 */ unsigned int hit10 = 0; /* Number of bits that toggled from 1 to 0 */ unsigned int tog_total = 0; /* Total number of toggle bits */ unsigned int excluded = 0; /* Number of excluded memory coverage points */ bool cov_found; func_iter_init( &fi, funit, FALSE, TRUE ); while( (sig = func_iter_get_next_signal( &fi )) != NULL ) { if( sig->suppl.part.type == SSUPPL_TYPE_MEM ) { ae_total = 0; memory_get_stat( sig, &ae_total, &wr_hit, &rd_hit, &tog_total, &hit01, &hit10, &excluded, &cov_found, TRUE ); /* If this signal meets the coverage requirement, add it to the signal list */ if( ((cov == 1) && (wr_hit > 0) && (rd_hit > 0) && (hit01 == tog_total) && (hit10 == tog_total)) || ((cov == 0) && ((wr_hit == 0) || (rd_hit == 0) || (hit01 < tog_total) || (hit10 < tog_total))) ) { sig_link_add( sig, head, tail ); } } } func_iter_dealloc( &fi ); PROFILE_END; }

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 { PROFILE(MEMORY_GET_COVERAGE); func_iter fi; /* Functional unit iterator */ vsignal* sig; /* Pointer to current signal */ unsigned int i; /* Loop iterator */ char tmp1[20]; /* Temporary string holder */ char tmp2[20]; /* Temporary string holder */ unsigned int rv; /* Return value */ exclude_reason* er; /* Find the signal in the functional unit */ func_iter_init( &fi, funit, FALSE, TRUE ); while( ((sig = func_iter_get_next_signal( &fi )) != NULL) && (strcmp( sig->name, signame ) != 0) ); func_iter_dealloc( &fi ); assert( sig != NULL ); /* Allocate and populate the pdim_array and pdim_width parameters */ *pdim_array = (char*)malloc_safe( 1 ); (*pdim_array)[0] = '\0'; memory_create_pdim_bit_array( pdim_array, sig, "", sig->pdim_num ); /* Allocate and populate the pdim_str string */ *pdim_str = NULL; for( i=sig->udim_num; i<(sig->pdim_num + sig->udim_num); i++ ) { unsigned int slen; rv = snprintf( tmp1, 20, "%d", sig->dim[i].msb ); assert( rv < 20 ); rv = snprintf( tmp2, 20, "%d", sig->dim[i].lsb ); assert( rv < 20 ); slen = strlen( tmp1 ) + strlen( tmp2 ) + 4; *pdim_str = (char*)realloc_safe( *pdim_str, (strlen( *pdim_str ) + 1), slen ); if( i == sig->udim_num ) { rv = snprintf( *pdim_str, slen, "[%s:%s]", tmp1, tmp2 ); assert( rv < slen ); } else { strcat( *pdim_str, "[" ); strcat( *pdim_str, tmp1 ); strcat( *pdim_str, ":" ); strcat( *pdim_str, tmp2 ); strcat( *pdim_str, "]" ); } } /* Allocate and populate the udim_info string */ *udim_str = NULL; for( i=0; i<sig->udim_num; i++ ) { unsigned int slen; rv = snprintf( tmp1, 20, "%d", sig->dim[i].msb ); assert( rv < 20 ); rv = snprintf( tmp2, 20, "%d", sig->dim[i].lsb ); assert( rv < 20 ); slen = strlen( tmp1 ) + strlen( tmp2 ) + 4; *udim_str = (char*)realloc_safe( *udim_str, (strlen( *udim_str ) + 1), slen ); if( i == 0 ) { rv = snprintf( *udim_str, slen, "[%s:%s]", tmp1, tmp2 ); assert( rv < slen ); } else { strcat( *udim_str, "[" ); strcat( *udim_str, tmp1 ); strcat( *udim_str, ":" ); strcat( *udim_str, tmp2 ); strcat( *udim_str, "]" ); } } /* Populate the memory_info string */ *memory_info = (char*)malloc_safe( 1 ); (*memory_info)[0] = '\0'; memory_get_mem_coverage( memory_info, sig, 0, "", 0, sig->value->width ); /* Populate the excluded value */ *excluded = sig->suppl.part.excluded; /* Populate the exclusion reason */ if( (*excluded == 1) && ((er = exclude_find_exclude_reason( 'M', sig->id, funit )) != NULL) ) { *reason = strdup_safe( er->reason ); } else { *reason = NULL; } PROFILE_END; }

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 { PROFILE(MEMORY_GET_FUNIT_SUMMARY); *hit = funit->stat->mem_wr_hit + funit->stat->mem_rd_hit + funit->stat->mem_tog01_hit + funit->stat->mem_tog10_hit; *excluded = funit->stat->mem_excluded; *total = (funit->stat->mem_ae_total * 2) + (funit->stat->mem_tog_total * 2); PROFILE_END; }

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 { PROFILE(MEMORY_GET_INST_SUMMARY); *hit = inst->stat->mem_wr_hit + inst->stat->mem_rd_hit + inst->stat->mem_tog01_hit + inst->stat->mem_tog10_hit; *excluded = inst->stat->mem_excluded; *total = (inst->stat->mem_ae_total * 2) + (inst->stat->mem_tog_total * 2); PROFILE_END; }

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 { 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 { PROFILE(MEMORY_GET_STATS); if( !funit_is_unnamed( funit ) ) { func_iter fi; vsignal* sig; func_iter_init( &fi, funit, FALSE, TRUE ); while( (sig = func_iter_get_next_signal( &fi )) != NULL ) { /* Calculate only for memory elements (must contain one or more unpacked dimensions) */ if( (sig->suppl.part.type == SSUPPL_TYPE_MEM) && (sig->udim_num > 0) ) { memory_get_stat( sig, wr_hit, rd_hit, ae_total, tog01_hit, tog10_hit, tog_total, excluded, cov_found, FALSE ); } } func_iter_dealloc( &fi ); } PROFILE_END; }

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 { PROFILE(MEMORY_REPORT); bool missed_found = FALSE; /* If set to TRUE, indicates that untoggled bits were found */ inst_link* instl; /* Pointer to current instance link */ int acc_hits01 = 0; /* Accumulated hits 0 -> 1 count */ int acc_hits10 = 0; /* Accumulated hits 1 -> 0 count */ int acc_tog_total = 0; /* Accumulated bit toggle count */ int acc_wr_hits = 0; /* Accumulated number of addressable elements written */ int acc_rd_hits = 0; /* Accumulated number of addressable elements read */ int acc_ae_total = 0; /* Accumulated number of addressable elements */ fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ MEMORY COVERAGE RESULTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); fprintf( ofile, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" ); if( report_instance ) { fprintf( ofile, " Toggle 0 -> 1 Toggle 1 -> 0\n" ); fprintf( ofile, "Instance Hit/ Miss/Total Percent hit Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { missed_found |= memory_toggle_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_hits01, &acc_hits10, &acc_tog_total ); instl = instl->next; } fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)memory_display_toggle_instance_summary( ofile, "Accumulated", acc_hits01, acc_hits10, acc_tog_total ); fprintf( ofile, "\n" ); fprintf( ofile, " Addressable elements written Addressable elements read\n" ); fprintf( ofile, " Hit/ Miss/Total Percent hit Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { missed_found |= memory_ae_instance_summary( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*"), &acc_wr_hits, &acc_rd_hits, &acc_ae_total ); instl = instl->next; } fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)memory_display_ae_instance_summary( ofile, "Accumulated", acc_wr_hits, acc_rd_hits, acc_ae_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); instl = db_list[curr_db]->inst_head; while( instl != NULL ) { memory_instance_verbose( ofile, instl->inst, (instl->inst->suppl.name_diff ? "<NA>" : "*") ); instl = instl->next; } } } else { fprintf( ofile, " Toggle 0 -> 1 Toggle 1 -> 0\n" ); fprintf( ofile, "Module/Task/Function Filename Hit/ Miss/Total Percent hit Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); missed_found |= memory_toggle_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_hits01, &acc_hits10, &acc_tog_total ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)memory_display_toggle_funit_summary( ofile, "Accumulated", "", acc_hits01, acc_hits10, acc_tog_total ); fprintf( ofile, "\n" ); fprintf( ofile, " Addressable elements written Addressable elements read\n" ); fprintf( ofile, " Hit/ Miss/Total Percent hit Hit/ Miss/Total Percent hit\n" ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); missed_found |= memory_ae_funit_summary( ofile, db_list[curr_db]->funit_head, &acc_wr_hits, &acc_rd_hits, &acc_ae_total ); fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); (void)memory_display_ae_funit_summary( ofile, "Accumulated", "", acc_wr_hits, acc_rd_hits, acc_ae_total ); if( verbose && (missed_found || report_covered || report_exclusions) ) { fprintf( ofile, "---------------------------------------------------------------------------------------------------------------------\n" ); memory_funit_verbose( ofile, db_list[curr_db]->funit_head ); } } fprintf( ofile, "\n\n" ); PROFILE_END; }

---