C   113

correlating

Guest on 6th June 2022 01:22:04 AM

  1. /************************************/
  2. /*      Comp Arc Project
  3. /*      By: Simon Foucher
  4. /************************************/
  5. /************************************/
  6. /*      includes and definitions                               
  7. /************************************/
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <ctype.h>
  12.  
  13.  
  14. #define TRUE 1
  15. #define FALSE 0
  16. typedef int BOOL;
  17.  
  18.  
  19. /************************************/
  20. /*      Function declarations                          
  21. /************************************/
  22.  
  23.  
  24. /************************************/
  25. /*      Global Variables & datatypes                           
  26. /************************************/
  27.  
  28.  
  29. /************************************/
  30. /*      Functions                                              
  31. /************************************/
  32.  
  33. // To clean up gathered strings from text
  34. void stripCRLF(char array[])
  35. {
  36.     int i;
  37.  
  38.     for(i=0;i<500 && array[i]!='\0';i++)
  39.       if (array[i]=='\r' || array[i]=='\n')
  40.                 array[i]='\0';
  41. }
  42.  
  43.  
  44. void readTrace(FILE *fp)
  45. {
  46.  
  47.         // Following arrays used to store statistical data (related elements share a common index)
  48.         char addresses[10000][20];
  49.         int frequency[10000];
  50.         int predictor[10000];                                                           // See Book p 83; 0 = 00, 1 = 01, 2 = 10, 3 = 11
  51.         int predictionGood[10000];
  52.         int totalBR = 0, totalGood = 0;
  53.  
  54.         char temp[50];
  55.         char tmpAddress[10];
  56.         int i, j, k;
  57.  
  58.  
  59.         // Format arrays and give preditction not taken
  60.         for(i = 0; i < 10000; i++){
  61.                 frequency[i] = 0;
  62.                 predictor[i] = 0;
  63.                 predictionGood[i] = 0;
  64.         }
  65.        
  66.  
  67.  
  68.         // Extract lines of data; break at EOF
  69.         while( fgets(temp, sizeof(temp), fp) != NULL ){
  70.  
  71.                 stripCRLF(temp);                                                                // Clean up the string
  72.                 //printf("Line: %s", temp);            
  73.                 totalBR++;                                                                              // Increment total branch count
  74.                
  75.  
  76.                 for(i = 0; ; i++){                                                              // Extract address of branch
  77.                         tmpAddress[i] = temp[i];
  78.                         if(tmpAddress[i] == ' ')
  79.                                 break;
  80.                 }
  81.  
  82.                 tmpAddress[i++] = NULL;                                                 // Add a proper null terminator and increment index (i points at branch result)
  83.  
  84.                 //for(;i<15; i++)
  85.                 //      printf("--temp[%d] = %d\n",i, temp[i]);
  86.  
  87.  
  88.  
  89.                 for(k = 0; k < 10000; k++)                                              // Find out if the entry already exists
  90.                         if(addresses[k][0] == NULL || !strncmp(addresses[k], tmpAddress, 9))
  91.                                 break;                 
  92.  
  93.                 if(k != 9999){                                                                  // If it is a new entry, k points at the first empt spot
  94.                         if(addresses[k][0] == NULL)
  95.                                 //printf("\tNew Entry: %s \tat index: %d \t taken (if 1) '%c' \n\t", tmpAddress, k, temp[i]);
  96.                         strcpy(addresses[k], tmpAddress);
  97.                 }
  98.  
  99.                
  100.                 // At this point, i points at the branch result and k at the array index whete the element goes.
  101.                 // record the statistics
  102.                 frequency[k]++;
  103.  
  104.                 /* Lookup prediction taken, update predictor and statistics
  105.                  NOTES:
  106.                  ASCII 48 = 0, 49 = 1
  107.                  For prediction FSM, See Book p 83;
  108.                  0 = 00 = Predict Not taken stable
  109.                  1 = 01 = Predict Not taken transition
  110.                  2 = 10 = Predict Taken transition
  111.                  3 = 11 = Predict Taken stable
  112.                 */
  113.                
  114. //Debugging
  115. //printf("\tPrediction was: %d\n", predictor[k]);
  116.  
  117.                 switch (predictor[k]) {
  118.                                
  119.                 case  0:                                                                                // Prediction NOT taken stable
  120.                         if(temp[i] == 49){                                                      // if branch IS taken
  121.                                 predictor[k] = 1;                                               // Update predictor to NOT taken unstable
  122.                         }                                                                                      
  123.                         if(temp[i] == 48){                                                      // if branch is NOT taken
  124.                                 predictionGood[k] += 1;                                 // Add one to local good prediction count
  125.                                 totalGood += 1;                                                 // Add one to global good prediction count
  126.                         }                                                                                       // No need to update predictor                 
  127.                         break;
  128.  
  129.                 case  1:                                                                                // Prediction NOT taken unstable
  130.                         if(temp[i] == 49){                                                      // if branch IS taken
  131.                                 predictor[k] = 2;                                               // Update predictor to taken unstable
  132.                         }                                                                                      
  133.                         if(temp[i] == 48){                                                      // if branch is NOT taken
  134.                                 predictionGood[k] += 1;                                 // Add one to local good prediction count
  135.                                 totalGood += 1;                                                 // Add one to global good prediction count
  136.                                 predictor[k] = 0;                                               // Update predictor to NOT taken stable
  137.                         }                                                                                      
  138.                         break;
  139.  
  140.                 case  2:                                                                                // Prediction IS taken unstable
  141.                         if(temp[i] == 49){                                                      // if branch IS taken
  142.                                 predictor[k] = 3;                                               // Update predictor to taken stable
  143.                                 predictionGood[k] += 1;                                 // Add one to local good prediction count
  144.                                 totalGood += 1;                                                 // Add one to global good prediction count
  145.                         }                                                                                      
  146.                         if(temp[i] == 48){                                                      // if branch is NOT taken
  147.                                 predictor[k] = 1;                                               // Update predictor to not taken unstable
  148.                         }                                                                                      
  149.                         break;
  150.  
  151.                 case  3:                                                                                // Prediction IS taken stable
  152.                         if(temp[i] == 49){                                                      // if branch IS taken
  153.                                 predictionGood[k] += 1;                                 // Add one to local good prediction count
  154.                                 totalGood += 1;                                                 // Add one to global good prediction count
  155.                         }                                                                                      
  156.                         if(temp[i] == 48){                                                      // if branch is NOT taken
  157.                                 predictor[k] = 2;                                               // Update predictor to taken not stable
  158.                         }                                                                                      
  159.                         break;
  160.  
  161.  
  162.                 default:
  163.                         break;
  164.                 }
  165. //Debugging            
  166. //printf("Now Prediction is: %d\n\n", predictor[k]);
  167.  
  168.         }// End of while getting lines
  169.  
  170.         fclose(fp);
  171.  
  172.         printf("\n DONE!!\n\nResults:\n");
  173.  
  174. /*      for(k = 0; k < 9999; k++){
  175.                 if(addresses[k][0] == NULL)
  176.                         break;
  177.                 printf("k: %d\t Add: %s\tTaken: %d\tFreq: %d\tRatio: %d\n", k, addresses[k], taken[k], frequency[k], taken[k]*100/frequency[k]);
  178.         }
  179. */
  180.         printf("\n\nTotal BR: %d\tTaken: %d\tRatio: %d%\n\n",totalBR, totalGood, totalGood*100/totalBR);
  181.         printf("---------------------------------------------\n");
  182.        
  183.  
  184. }// End if readTrace
  185.  
  186.  
  187.  
  188.  
  189. /*******************************************************************************/
  190. /*      Function  main (int argc, char *argv[])
  191. /*******************************************************************************/
  192.  
  193. int main (int argc, char *argv[])
  194. {
  195.         FILE *fp;
  196.  
  197.         // FP.trace
  198.         if((fp = fopen("traces/FP.trace","r"))==NULL)               //Open the password file
  199.                 {
  200.                         puts("Cannot open FP.trace\n"          
  201.                                  "Please make sure it is located in a directory called 'traces/'\n"
  202.                                  "having this program's directory as a root\n");
  203.                 }
  204.         else
  205.                 printf("Sucessfully opened FP.trace\nStarting analysis\n");
  206.  
  207.         readTrace(fp);
  208.  
  209.  
  210.         // INT.trace
  211.         if((fp = fopen("traces/INT.trace","r"))==NULL)              //Open the password file
  212.                 {
  213.                         puts("Cannot open INT.trace\n"         
  214.                                  "Please make sure it is located in a directory called 'traces/'\n"
  215.                                  "having this program's directory as a root\n");
  216.                 }
  217.         else
  218.                 printf("Sucessfully opened INT.trace\nStarting analysis\n\n");
  219.  
  220.         readTrace(fp);
  221.  
  222.  
  223.         // MM.trace
  224.         if((fp = fopen("traces/MM.trace","r"))==NULL)               //Open the password file
  225.                 {
  226.                         puts("Cannot open MM.trace\n"          
  227.                                  "Please make sure it is located in a directory called 'traces/'\n"
  228.                                  "having this program's directory as a root\n");
  229.                 }
  230.         else
  231.                 printf("Sucessfully opened MM.trace\nStarting analysis\n\n");
  232.  
  233.         readTrace(fp);
  234.  
  235.         // SERV.trace
  236.         if((fp = fopen("traces/SERV.trace","r"))==NULL)             //Open the password file
  237.                 {
  238.                         puts("Cannot open SERV.trace\n"        
  239.                                  "Please make sure it is located in a directory called 'traces/'\n"
  240.                                  "having this program's directory as a root\n");
  241.                 }
  242.         else
  243.                 printf("Sucessfully opened SERV.trace\nStarting analysis\n\n");
  244.  
  245.         readTrace(fp);
  246.  
  247.  
  248. }

Raw Paste


Login or Register to edit or fork this paste. It's free.