1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

Cache Simulator...PLZ HELP!!

Discussion in 'C' started by Natsoumi_Maya, Apr 25, 2008.

  1. Natsoumi_Maya

    Natsoumi_Maya New Member

    Joined:
    Apr 25, 2008
    Messages:
    1
    Likes Received:
    0
    Trophy Points:
    0
    What im trying to do is implement the cache using C. I have to find out the hit and miss rate of the cache. my code is pretty long so i'll just show u the parts i've implemented and the parts i need help with. If u have any inqueries PLZ feel free to ask. Thank you in advance for any help provided.
    This is the part i have implemented. The code basically implements the Full associative, set associative and direct mapped cache.

    cache - array of SETS

    Code:
    int i;
    if(MAX_SET==1)        // Fully Associative Cache 
    {
         i = 0;
         while (i <=BLOCKS_PER_SET)   // Dividing the SET into 
                                                           //Blocks of size "BYTES_PER_BLOCK" 
         {
             cache[i].block = (struct BLOCK *)malloc(BYTES_PER_BLOCK)    // Not Sure about "  cache[i].block "  
             i ++;
          }
          cache --;
    }
    else
    {
        while (cache )   //THINK OF CONDITION: while the array of SETS is not FULL
        {
            if (MAX_SET == BLOCKS_PER_SET) //Direct Mapped Cache
            {
                 while (MAX_SET != 0)
                 {
                    i = 0;
    	while (i <=BLOCKS_PER_SET) // Dividing the SET into BLOCKS 
                                                                   //of size "BYETS_PER_BLOCK"
    	{
    	    cache[i].block = (struct BLOCK *)malloc 
                        BYTES_PER_BLOCK)    //CHECK the "cache[i].block"
    	     i ++;
    	}
    	MAX_SET --;
                 }
             }
             else // Set Associative Cache
             {
                 while (MAX_SET != 0)
                 {
    	 i = 0;
    	while (i <=BLOCKS_PER_SET) // Dividing the SET into BLOCKS of 
                                                                   //size "BYTES_PER_BLOCK"
    	{
    	    cache[i].block = (struct BLOCK *)malloc(BLOCKS_PER_SET)    		    i ++;
    	}
    	MAX_SET --;
                  }
               }
               cache --;
            }
    }int i;
    if(MAX_SET==1)        // Fully Associative Cache 
    {
         i = 0;
         while (i <=BLOCKS_PER_SET)   // Dividing the SET into 
                                                           //Blocks of size "BYTES_PER_BLOCK" 
         {
             cache[i].block = (struct BLOCK *)malloc(BYTES_PER_BLOCK)    // Not Sure about "  cache[i].block "  
             i ++;
          }
          cache --;
    }
    else
    {
        while (cache )   //THINK OF CONDITION: while the array of SETS is not FULL
        {
            if (MAX_SET == BLOCKS_PER_SET) //Direct Mapped Cache
            {
                 while (MAX_SET != 0)
                 {
                    i = 0;
    	while (i <=BLOCKS_PER_SET) // Dividing the SET into BLOCKS 
                                                                   //of size "BYETS_PER_BLOCK"
    	{
    	    cache[i].block = (struct BLOCK *)malloc 
                        BYTES_PER_BLOCK)    //CHECK the "cache[i].block"
    	     i ++;
    	}
    	MAX_SET --;
                 }
             }
             else // Set Associative Cache
             {
                 while (MAX_SET != 0)
                 {
    	 i = 0;
    	while (i <=BLOCKS_PER_SET) // Dividing the SET into BLOCKS of 
                                                                   //size "BYTES_PER_BLOCK"
    	{
    	    cache[i].block = (struct BLOCK *)malloc(BLOCKS_PER_SET)    		    i ++;
    	}
    	MAX_SET --;
                  }
               }
               cache --;
            }
    }
    
    
    Since my program is incomplete, im not able to test it, SO i was wondering if In the part i implemented
    Code:
     cache[i].block = (struct BLOCK *)malloc(BLOCKS_PER_SET)  
    is correct (Syntax wise).

    This is the part i need help with. I have the algorithim down but im not sure how to implement. Again, any help is most appreciated:


    Code:
     BOOL simulate(unsigned int address)
    {
    	/* Algorithm:
                     * - Find the index for current address
    	 * - For that set, search all valid blocks for matching tags
    	 * - If a match is found, you have a hit:
      	 *   + update timestamp of block and LRU of set
    	 *   + return true
    	 * - If there is no match, you have a miss:
    	 *   + Search for an invalid block and use it to store new block
    	 *   + If there are no invalid blocks, replace the LRU block
    	 *   + update timestamp of block and LRU of set
    	 *   + return false
    	 */
    	/******* Fully Associative Cache*******/
    	
    	/********* Direct Mapped Cache*********/
    	/******** SET Associative Cache********/
    }
    
    Again, thank you in advance for any help provided :)
     

Share This Page