cache.cpp

Go to the documentation of this file.

/*
        Copyright (C) 1997 CFU Corporation

        File: cache.cpp
        Description: class Cache implementation
        Author: Chao-yinig Fu
        Date: Apr. 6 2000

        ^..^
        (00)

         $__$
        <~00~>
         (oo)
          ||

        ```````
        C ^|^ D
         \ O /
*/
#include <stdio.h>
#include <assert.h>

#include "cache.h"

//
// Return 1 if hit
// Return 0 if miss
//
int Cache::simulate(char rw,unsigned int address,unsigned int global_time)
{
        unsigned int this_tag=address>>(_c-_s);
        unsigned int this_index=(address>>_b)&((1<<(_c-_b-_s))-1);

        unsigned int location=this_index*_blocks_in_set;
        int miss_or_hit;
        unsigned int old_time;  // record the old time of the hit block
        int miss_or_hit_last_time;

        /*
        if(0)
        {
        fprintf(stderr,"\n*** %c %8x ***\n\n",rw,address);
        fprintf(stderr,"===L1 CACHE===\n");
        fprintf(stderr,"index = %x, tag = %x\n",this_index,this_tag);
        }
        */

/*--------------------------------------------------------------------------*/
        if(rw=='r')     // read
/*--------------------------------------------------------------------------*/
        {
                _reads++;

                miss_or_hit=0;

                int index;
                for(int i=0;i<_blocks_in_set;i++)
                {
                        index=location+i;
                        if(_valid_array[index]=='v' && _tag_array[index]==this_tag)
                        {
                                miss_or_hit=1;
                                break;
                        }
                }


/*--------------------------------------------------------------------------*/
                if(miss_or_hit==1)              /* read hit */
/*--------------------------------------------------------------------------*/
                {
                        /*
                        if(0)
                        {
                        fprintf(stderr,"HIT\n");
                        fprintf(stderr,"(BEFORE)");
                        print_this_index(this_index,location);
                        }
                        */

                        old_time=_time_array[index];
                        miss_or_hit_last_time=_miss_or_hit_array[index];
                        _miss_or_hit_array[index]=1;

                        _time_array[index]=global_time;
                }
/*--------------------------------------------------------------------------*/
                else                          /* read miss */
/*--------------------------------------------------------------------------*/
                {
                        /*
                        if(0)
                        {
                        fprintf(stderr,"MISS\n");
                        fprintf(stderr,"(BEFORE)");
                        print_this_index(this_index,location);
                        }
                        */

                        _reads_in_miss++;

                        /* find a empty block to put */
                        int i;
                        int target;     // records which block it reads
                        for(i=0;i<_blocks_in_set;i++)
                        {
                                int index=location+i;
                                if(_valid_array[index]=='i')
                                {
                                        _miss_or_hit_array[index]=0;

                                        _valid_array[index]='v';
                                        _dirty_array[index]='c';
                                        _tag_array[index]=this_tag;
                                        _time_array[index]=global_time;
                                        target=i;
                                        break;
                                }
                        }
                        /* set is full, need LRU replacement */
                        if(i==_blocks_in_set)
                        {
                                target=0;
                                for(int j=1;j<_blocks_in_set;j++)
                                {
                                        if(_time_array[location+target]>_time_array[location+j])
                                        {
                                                target=j;
                                        }
                                }
                                
                                /* dirty block should write back */
                                int index=location+target;
                                if(_dirty_array[index]=='d')
                                {
                                        _writebacks++;
                                }

                                _miss_or_hit_array[index]=0;

                                _valid_array[index]='v';
                                _dirty_array[index]='c';
                                _tag_array[index]=this_tag;
                                _time_array[index]=global_time;
                        }
                }

        }
/*--------------------------------------------------------------------------*/
        else if(rw=='w')        // write
/*--------------------------------------------------------------------------*/
        {
                _writes++;

                miss_or_hit=0;

                int index;
                for(int i=0;i<_blocks_in_set;i++)
                {
                        index=location+i;
                        if(_valid_array[index]=='v' && _tag_array[index]==this_tag)
                        {
                                miss_or_hit=1;
                                break;
                        }
                }

/*--------------------------------------------------------------------------*/
                if(miss_or_hit==1)      /* write hit */
/*--------------------------------------------------------------------------*/
                {
                        /*
                        if(0)
                        {
                        fprintf(stderr,"HIT\n");
                        fprintf(stderr,"(BEFORE)");
                        print_this_index(this_index,location);
                        }
                        */

                        if(_wp==0)      // write back (write allocate)
                        {
                                _dirty_array[index]='d';
                        }
                        else if(_wp==1) // write through (no allocate)
                        {
                                _dirty_array[index]='c';
                                _writebacks++;
                        }

                        _tag_array[index]=this_tag;

                        old_time=_time_array[index];
                        miss_or_hit_last_time=_miss_or_hit_array[index];
                        _miss_or_hit_array[index]=1;

                        _time_array[index]=global_time;
                }
/*--------------------------------------------------------------------------*/
                else                    /* write miss*/
/*--------------------------------------------------------------------------*/
                {
                        /*
                        if(0)
                        {
                        fprintf(stderr,"MISS\n");
                        fprintf(stderr,"(BEFORE)");
                        print_this_index(this_index,location);
                        }
                        */

                        if(_wp==1)      /* no allocate (write through)*/
                        {
                                _writebacks++;
                        }
                        else if(_wp==0) /* write allocate (write back)*/
                        {
                                _writes_in_miss++;

                                /* find a block to write */
                                int i;
                                int target;
                                for(i=0;i<_blocks_in_set;i++)
                                {
                                        int index=location+i;
                                        if(_valid_array[index]=='i')
                                        {
                                                _miss_or_hit_array[index]=0;

                                                _valid_array[index]='v';
                                                _tag_array[index]=this_tag;
                                                _dirty_array[index]='d';
                                                _time_array[index]=global_time;
                                                target=i;
                                                break;
                                        }
                                }

                                if(i==_blocks_in_set)   // need LRU Replacement
                                {
                                        target=0;
                                        for(int j=1;j<_blocks_in_set;j++)
                                        {
                                                if(_time_array[location+target]>_time_array[location+j])
                                                {
                                                        target=j;
                                                }
                                        }

                                        /* dirty block should write back */
                                        int index=location+target;
                                        if(_dirty_array[index]=='d')
                                        {
                                                _writebacks++;
                                        }

                                        _miss_or_hit_array[index]=0;
                                        
                                        _valid_array[index]='v';
                                        _dirty_array[index]='d';
                                        _tag_array[index]=this_tag;
                                        _time_array[index]=global_time;
                                }
                        }
                }

        }

        /*
        if(0)
        {
        fprintf(stderr,"(AFTER )");
        print_this_index(this_index,location);
        }
        */

        //getchar();

        // If hit and the current global_time is the same as old_time
        // it means, we access the same block at the same time
        // we should consider hit_or_miss from its previous status
        if(miss_or_hit==1 && old_time==global_time)
        {
                return miss_or_hit_last_time;
        }
        else
        {
                return miss_or_hit;
        }
}

void Cache::print_this_index(int this_index,int location)
{
        fprintf(stderr," set %5d:",this_index);

        for(int i=0;i<_blocks_in_set;i++)
        {
                int index=location+i;
                if(_valid_array[index]=='v')
                {
                        fprintf(stderr," %8x",_tag_array[index]);
                        if(_dirty_array[index]=='d')
                        {
                                fprintf(stderr," D");
                        }
                        else
                        {
                                fprintf(stderr,"  ");
                        }

                        fprintf(stderr," (%d)",i);
                }
        }

        fprintf(stderr,"\n");
}

void Cache::report(FILE *f)
{
        fprintf(f,"\treads:\t\t%d\n",_reads);
        fprintf(f,"\tread misses:\t%d\n",_reads_in_miss);
        fprintf(f,"\twrites:\t\t%d\n",_writes);
        fprintf(f,"\twrite misses:\t%d\n",_writes_in_miss);
        fprintf(f,"\twritebacks from L1:\t%d\n",_writebacks);
        double miss=(double)(_reads_in_miss+_writes_in_miss)/(_reads+_writes);
        fprintf(f,"\tL1 miss rate:\t%.4f\n",miss);
}

void Cache::show_cache(FILE *f)
{
        fprintf(f,"\tSIZE:\t\t\t%d bytes (%.1f KB)\n",_bytes_in_cache,(double)_bytes_in_cache/1024);
        fprintf(f,"\tASSOC:\t\t\t%d\n",_blocks_in_set);
        fprintf(f,"\tBLOCKSIZE:\t\t%d bytes\n",_bytes_in_block);
        if(_wp==0)
        {
                fprintf(f,"\tWrite Policy:\t\tWBWA\n");
        }
        else if(_wp==1)
        {
                fprintf(f,"\tWrite Policy:\t\tWTNA\n");
        }
        /*
        fprintf(f,"\tPrefetch Seq:\t\t%d\n",_p);
        fprintf(f,"\tUse Stream Buffer:\t");
        if(_use_stream_buffer==0)
        {
                fprintf(stderr,"No\n");
        }
        else if(_use_stream_buffer==1)
        {
                fprintf(stderr,"Yes\n");
        }
        */
        /*
        fprintf(f,"======= L2 CACHE =======\n");
        fprintf(f,"Off\n");
        */
}

void Banked_Cache::show_cache(FILE *f)
{
        fprintf(f,"bank0\n");
        _bank0->show_cache(f);
        fprintf(f,"bank1\n");
        _bank1->show_cache(f);
}

void Banked_Cache::report(FILE *f)
{
        fprintf(f,"bank0\n");
        _bank0->report(f);
        fprintf(f,"bank1\n");
        _bank1->report(f);
        
        //HZ:
        fprintf(f, "Overall: \n");
        fprintf(f, "cache accesses: %d, cache misses: %d \n", t_cache_access,
                t_cache_misses);
        fprintf(f, "access both banks: %d \n", t_cache_access_both_banks);
        fprintf(f, "miss rate: %f, miss penalties: %d\n", t_cache_misses * 1.0 /
                t_cache_access, t_cache_misses * 12);
}

/*
int Banked_Cache::total_penalty()
{
        int bank0_penalty=_bank0->total_penalty();
        int bank1_penalty=_bank1->total_penalty();

        return bank0_penalty+bank1_penalty;
}
*/

int Banked_Cache::total_num_of_miss()
{
        int bank0_miss=_bank0->total_num_of_miss();
        int bank1_miss=_bank1->total_num_of_miss();

        return bank0_miss+bank1_miss;
}

---