import  java.awt.*;						import  java.awt.*;
//import Brace;						      |	import Brace;

class AddressCanvas extends Canvas{				class AddressCanvas extends Canvas{
  								  
  private final boolean UP = true,				  private final boolean UP = true,
                        DOWN = false;				                        DOWN = false;
  private int mem_size, ca_size ,bl_size ,se_size,method ;	  private int mem_size, ca_size ,bl_size ,se_size,method ;
  private String memS_String ,caS_String ,blS_String ,seS_Str	  private String memS_String ,caS_String ,blS_String ,seS_Str
  								  
  private final int xBase = 10,					  private final int xBase = 10,
    yBase = 50,							    yBase = 50,
    unit_width = 20,						    unit_width = 20,
    unit_height = 30;						    unit_height = 30;

  private Font font = new Font("TimesRoman", Font.BOLD, 14);	  private Font font = new Font("TimesRoman", Font.BOLD, 14);
  private Font sub_font = new Font("TimesRoman", Font.BOLD, 1	  private Font sub_font = new Font("TimesRoman", Font.BOLD, 1
  FontMetrics fm;						  FontMetrics fm;

  Color subColor = Color.blue;					  Color subColor = Color.blue;
  Color back_gr = new Color(					  Color back_gr = new Color(
        (float)0.9444,(float)0.9444,(float)0.9444);		        (float)0.9444,(float)0.9444,(float)0.9444);

  //************************************************		  //************************************************
  //*** Constructor ***						  //*** Constructor ***
  AddressCanvas(int M, int C, int B, int T, int S,		  AddressCanvas(int M, int C, int B, int T, int S,
                String MStr, String CStr, String BStr, String	                String MStr, String CStr, String BStr, String
    super();							    super();
    								    
    SetAll( M,C, B,T, S, MStr, CStr, BStr, SStr);		    SetAll( M,C, B,T, S, MStr, CStr, BStr, SStr);
    setBackground(back_gr);					    setBackground(back_gr);
    								    
    setFont(font);						    setFont(font);
  }								  }
  								  
  //************************************************		  //************************************************
  public void SetAll(int M, int C, int B, int T, int S,		  public void SetAll(int M, int C, int B, int T, int S,
		     String MStr, String CStr, String BStr, S			     String MStr, String CStr, String BStr, S
    mem_size = M;						    mem_size = M;
    ca_size = C;						    ca_size = C;
    bl_size = B;						    bl_size = B;
    se_size = S;						    se_size = S;
    method = T;							    method = T;
    								    
    memS_String = new String(MStr);				    memS_String = new String(MStr);
    caS_String = new String(CStr);				    caS_String = new String(CStr);
    blS_String = new String(BStr);				    blS_String = new String(BStr);
    seS_String = new String(SStr);				    seS_String = new String(SStr);
  }								  }
   								   
  //************************************************		  //************************************************
  public void paint( Graphics a){				  public void paint( Graphics a){
    								    
    //address area						    //address area
    int addr_width = mem_size * unit_width;			    int addr_width = mem_size * unit_width;
    a.setColor(AddressForm.fillColor);				    a.setColor(AddressForm.fillColor);
    a.fillRect (xBase, yBase, addr_width, unit_height);		    a.fillRect (xBase, yBase, addr_width, unit_height);
    a.setColor(AddressForm.drawColor);				    a.setColor(AddressForm.drawColor);
    a.drawRect(xBase, yBase, addr_width, unit_height);		    a.drawRect(xBase, yBase, addr_width, unit_height);
    								    
    //bits in address						    //bits in address
    for (int i = 1; i<=mem_size; i++){				    for (int i = 1; i<=mem_size; i++){
      a.drawLine(xBase+unit_width*i, yBase,			      a.drawLine(xBase+unit_width*i, yBase,
		 xBase+unit_width*i, yBase+unit_height);			 xBase+unit_width*i, yBase+unit_height);
    }								    }
    								    
    //curly brace for total memory size				    //curly brace for total memory size
    Brace br = new Brace(a);					    Brace br = new Brace(a);
    fm = getFontMetrics(font);					    fm = getFontMetrics(font);
    br.DrawCurBr(fm, xBase, yBase+unit_height, addr_width, DO	    br.DrawCurBr(fm, xBase, yBase+unit_height, addr_width, DO
	      mem_size + " bits");					      mem_size + " bits");
    								    
    //calculate and draw Offset					    //calculate and draw Offset
    int Offset_width = bl_size * unit_width;			    int Offset_width = bl_size * unit_width;
    int xOffset= xBase + addr_width- Offset_width;		    int xOffset= xBase + addr_width- Offset_width;
    a.drawLine(xOffset+1, yBase, xOffset+1, yBase+unit_height	    a.drawLine(xOffset+1, yBase, xOffset+1, yBase+unit_height
    								    
    br.DrawCurBr(fm, xOffset, yBase, Offset_width, UP,		    br.DrawCurBr(fm, xOffset, yBase, Offset_width, UP,
	      bl_size + " bits");					      bl_size + " bits");
    a.drawString("Offset",xOffset+Offset_width/2-15,		    a.drawString("Offset",xOffset+Offset_width/2-15,
		 yBase+unit_height/2+5);					 yBase+unit_height/2+5);
    								    
    								    
    //calculate and draw Index					    //calculate and draw Index
    boolean index_status = true;				    boolean index_status = true;
    int Index_width = 0 ;					    int Index_width = 0 ;
    int Index_bit_count = 0;					    int Index_bit_count = 0;
    								    
    if (method == AddressForm.DIRECT){				    if (method == AddressForm.DIRECT){
      //direct							      //direct
      Index_bit_count = ca_size - bl_size; 			      Index_bit_count = ca_size - bl_size; 
      Index_width = (ca_size - bl_size) * unit_width;		      Index_width = (ca_size - bl_size) * unit_width;
    }								    }
    else 							    else 
      if (method == AddressForm.SET){				      if (method == AddressForm.SET){
	//set associative						//set associative

        //*********** the following commented line has been c	        //*********** the following commented line has been c
	Index_bit_count = ca_size - (se_size+bl_size); 			Index_bit_count = ca_size - (se_size+bl_size); 
	//Index_bit_count = ca_size - ((int)(Math.log(se_size		//Index_bit_count = ca_size - ((int)(Math.log(se_size
        //***************************************************	        //***************************************************

        Index_width = Index_bit_count * unit_width;		        Index_width = Index_bit_count * unit_width;
      }								      }
      else {							      else {
	//method is "fully associative" 				//method is "fully associative" 
	index_status = false;						index_status = false;
      }								      }
    								    
    if (index_status){						    if (index_status){
      int xIndex = xBase + addr_width - Index_width - Offset_	      int xIndex = xBase + addr_width - Index_width - Offset_
      a.drawLine(xIndex+1, yBase, xIndex+1, yBase+unit_height	      a.drawLine(xIndex+1, yBase, xIndex+1, yBase+unit_height
      br.DrawCurBr(fm, xIndex, yBase, Index_width, UP,		      br.DrawCurBr(fm, xIndex, yBase, Index_width, UP,
		Index_bit_count + " bits");					Index_bit_count + " bits");
      a.drawString("Index",xIndex+Index_width/2-15,yBase+unit	      a.drawString("Index",xIndex+Index_width/2-15,yBase+unit
    }								    }
    								    
    //draw tag							    //draw tag
    int Tag_width = addr_width - Offset_width - Index_width;	    int Tag_width = addr_width - Offset_width - Index_width;
    int Tag_bit_count = mem_size - bl_size - Index_bit_count;	    int Tag_bit_count = mem_size - bl_size - Index_bit_count;
    								    
    if (Tag_bit_count <= 0)					    if (Tag_bit_count <= 0)
      a.setColor(Color.red);					      a.setColor(Color.red);
    br.DrawCurBr(fm, xBase, yBase, Tag_width, UP,		    br.DrawCurBr(fm, xBase, yBase, Tag_width, UP,
	      Tag_bit_count + " bits");					      Tag_bit_count + " bits");
    a.drawString("Tag",xBase+Tag_width/2-5,yBase+unit_height/	    a.drawString("Tag",xBase+Tag_width/2-5,yBase+unit_height/
    								    
    //explanations under address				    //explanations under address
    int yTextBase = yBase+unit_height+50;			    int yTextBase = yBase+unit_height+50;
    int stepDown = 20;						    int stepDown = 20;
    								    
    //total							    //total
    a.drawString("Memory size = "+ memS_String + " = 2" , 	    a.drawString("Memory size = "+ memS_String + " = 2" , 
		 xBase,yTextBase+stepDown);					 xBase,yTextBase+stepDown);
    a.setFont(sub_font);					    a.setFont(sub_font);
    Color prev_color = a.getColor();				    Color prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(mem_size+"", xBase+165,yTextBase+stepDown-7)	    a.drawString(mem_size+"", xBase+165,yTextBase+stepDown-7)
    a.setFont(font);    					    a.setFont(font);    
    a.setColor(prev_color);					    a.setColor(prev_color);

    //offset							    //offset
    a.drawString("Block size = "+ blS_String + " = 2" ,		    a.drawString("Block size = "+ blS_String + " = 2" ,
		 xBase,yTextBase+stepDown*3);					 xBase,yTextBase+stepDown*3);
    //subscript!!!						    //subscript!!!
    a.setFont(sub_font);					    a.setFont(sub_font);
    prev_color = a.getColor();					    prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(bl_size+"", xBase+135,yTextBase+stepDown*3-7	    a.drawString(bl_size+"", xBase+135,yTextBase+stepDown*3-7
    a.setFont(font);						    a.setFont(font);
    a.setColor(prev_color);					    a.setColor(prev_color);

    //Index							    //Index
    if (index_status){						    if (index_status){
      if (method == AddressForm.SET){				      if (method == AddressForm.SET){
	a.drawString("Number of sets in cache = "+ 			a.drawString("Number of sets in cache = "+ 
		     "Cache Size / ( Set Size * Block Size ) 			     "Cache Size / ( Set Size * Block Size ) 
		     xBase,yTextBase+stepDown*5);				     xBase,yTextBase+stepDown*5);
	a.drawString("                  " + caS_String + " / 		a.drawString("                  " + caS_String + " / 
		     seS_String +						     seS_String +
		     " * "+							     " * "+
		     blS_String +						     blS_String +
		     " ) = 2   / ( 2   * 2   ) = 2",				     " ) = 2   / ( 2   * 2   ) = 2",
		     xBase,yTextBase+stepDown*6);				     xBase,yTextBase+stepDown*6);
	//subscripts !!!						//subscripts !!!
	a.setFont(sub_font);						a.setFont(sub_font);
	prev_color = a.getColor();					prev_color = a.getColor();
        //int exp_se_size = (int) (Math.log(se_size)/Math.log	        //int exp_se_size = (int) (Math.log(se_size)/Math.log

	a.drawString(ca_size+"", xBase+265,yTextBase+stepDown		a.drawString(ca_size+"", xBase+265,yTextBase+stepDown
	a.drawString(se_size+"", xBase+300,yTextBase+stepDown		a.drawString(se_size+"", xBase+300,yTextBase+stepDown
	a.drawString(bl_size+"", xBase+335,yTextBase+stepDown		a.drawString(bl_size+"", xBase+335,yTextBase+stepDown
	a.setColor(subColor);						a.setColor(subColor);
	a.drawString(Index_bit_count+"", xBase+375,yTextBase+		a.drawString(Index_bit_count+"", xBase+375,yTextBase+
	a.setFont(font);						a.setFont(font);
	a.setColor(prev_color);						a.setColor(prev_color);
      }else{							      }else{
	a.drawString("Number of blocks in cache = "+			a.drawString("Number of blocks in cache = "+
		     "Cache Size / Block Size  = ",				     "Cache Size / Block Size  = ",
		     xBase,yTextBase+stepDown*5);				     xBase,yTextBase+stepDown*5);
	a.drawString("                  " + caS_String + " / 		a.drawString("                  " + caS_String + " / 
		     blS_String +						     blS_String +
		     " = 2   /  2   = 2",					     " = 2   /  2   = 2",
		     xBase,yTextBase+stepDown*6);				     xBase,yTextBase+stepDown*6);
	//subscripts !!!						//subscripts !!!
	 a.setFont(sub_font);						 a.setFont(sub_font);
	 prev_color = a.getColor();					 prev_color = a.getColor();

	 a.drawString(ca_size+"", xBase+180,yTextBase+stepDow		 a.drawString(ca_size+"", xBase+180,yTextBase+stepDow
	 a.drawString(bl_size+"", xBase+215,yTextBase+stepDow		 a.drawString(bl_size+"", xBase+215,yTextBase+stepDow
	 a.setColor(subColor);						 a.setColor(subColor);
	 a.drawString(Index_bit_count+"", xBase+245,yTextBase		 a.drawString(Index_bit_count+"", xBase+245,yTextBase
	 a.setFont(font);						 a.setFont(font);
	 a.setColor(prev_color);					 a.setColor(prev_color);
      }								      }
    }								    }
    								    
    //Tag							    //Tag
    a.drawString("Number of bits in Tag = "+mem_size+		    a.drawString("Number of bits in Tag = "+mem_size+
		 " - "+Index_bit_count+" - "+ bl_size+				 " - "+Index_bit_count+" - "+ bl_size+
		 " = ",								 " = ",
		 xBase,yTextBase+stepDown*8);					 xBase,yTextBase+stepDown*8);
    prev_color = a.getColor();					    prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(Tag_bit_count+"", xBase+245,yTextBase+stepDo	    a.drawString(Tag_bit_count+"", xBase+245,yTextBase+stepDo
    a.setColor(prev_color);					    a.setColor(prev_color);
    								    
    if (Tag_bit_count <= 0) {					    if (Tag_bit_count <= 0) {
      Color next_color = Color.black;				      Color next_color = Color.black;
      								      
      for( int j = 0; j<10; j++){				      for( int j = 0; j<10; j++){
	try{								try{
	  Thread.sleep(200);						  Thread.sleep(200);
	  a.setColor(next_color);					  a.setColor(next_color);
	  if (next_color == Color.black) next_color = Color.r		  if (next_color == Color.black) next_color = Color.r
	  else next_color = Color.black;				  else next_color = Color.black;
	  a.drawString("Number of bits in Tag = "+mem_size+		  a.drawString("Number of bits in Tag = "+mem_size+
		       " - "+Index_bit_count+" - "+ bl_size+			       " - "+Index_bit_count+" - "+ bl_size+
		       " = ",							       " = ",
		       xBase,yTextBase+stepDown*8);				       xBase,yTextBase+stepDown*8);
	  prev_color = a.getColor();					  prev_color = a.getColor();
	  a.setColor(subColor);						  a.setColor(subColor);
	  a.drawString(Tag_bit_count+"", xBase+245,yTextBase+		  a.drawString(Tag_bit_count+"", xBase+245,yTextBase+
	  a.setColor(prev_color);					  a.setColor(prev_color);
	}catch(InterruptedException ent){}				}catch(InterruptedException ent){}
      }//for							      }//for
      								      
    }//if							    }//if
  }//paint							  }//paint
}								}
//**************************** END **************************	//**************************** END **************************


import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AddressForm extends Applet{			public class AddressForm extends Applet{
  								  
  private final String[][] Table_of_mem_sizes ={		  private final String[][] Table_of_mem_sizes ={
    {"16 MB ","8 MB  ","4 MB  ","2 MB  ","1 MB  ","512 KB","2	    {"16 MB ","8 MB  ","4 MB  ","2 MB  ","1 MB  ","512 KB","2
    {"24",     "23",    "22",   "21",     "20",    "19",     	    {"24",     "23",    "22",   "21",     "20",    "19",     
  								  
  private final String[][] Table_of_cac_sizes = {		  private final String[][] Table_of_cac_sizes = {
    {"512 KB","256 KB","128 KB","64 KB "},			    {"512 KB","256 KB","128 KB","64 KB "},
    {"19",    "18",    "17",    "16"    }};			    {"19",    "18",    "17",    "16"    }};
  								  
  private final String[][] Table_of_blo_sizes = {		  private final String[][] Table_of_blo_sizes = {
    {"32 B","16 B","8 B "},					    {"32 B","16 B","8 B "},
    {"5",   "4",   "3"   }};					    {"5",   "4",   "3"   }};
  								  
  private final String[][] Table_of_set_sizes = {		  private final String[][] Table_of_set_sizes = {
    {"2 blocks","4 blocks","8 blocks"},				    {"2 blocks","4 blocks","8 blocks"},
    {"1",       "2",        "3"      }};			    {"1",       "2",        "3"      }};
  								  
  public static final int DIRECT = 0,				  public static final int DIRECT = 0,
    FULL = 1,							    FULL = 1,
    SET = 2;							    SET = 2;
  								  
  private Choice MemSize, CacheSize, BlockSize, SetSize;	  private Choice MemSize, CacheSize, BlockSize, SetSize;
  private Button Solve;						  private Button Solve;
  private CheckboxGroup Method;					  private CheckboxGroup Method;
  private Checkbox direct, full, set;				  private Checkbox direct, full, set;
  								  
  private int mem_index = 0,					  private int mem_index = 0,
    cac_index = 0,						    cac_index = 0,
    blo_index =0,						    blo_index =0,
    set_index =0,						    set_index =0,
    method ;							    method ;
  								  
  private Panel p5,p6,p7, p_s, p_l,p_head, p_Sizes;		  private Panel p5,p6,p7, p_s, p_l,p_head, p_Sizes;
  								  
  private AddressCanvas a ;					  private AddressCanvas a ;
  								  
  public  static final Color fillColor=				  public  static final Color fillColor=
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  								  
  public  static final Color drawColor = Color.black;		  public  static final Color drawColor = Color.black;
  								  
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);

  								  
  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){

    boolean b ;							    boolean b ;
    setBackground (						    setBackground (
		   new Color((float)0.9444,(float)0.9444,(flo			   new Color((float)0.9444,(float)0.9444,(flo
    setFont(font);						    setFont(font);
       								       
    //creating,filling and adding choice buttons		    //creating,filling and adding choice buttons
    MemSize = new Choice();					    MemSize = new Choice();
    for (int i = 0; i<Table_of_mem_sizes[0].length; i++){	    for (int i = 0; i<Table_of_mem_sizes[0].length; i++){
      MemSize.addItem(Table_of_mem_sizes[0][i]);		      MemSize.addItem(Table_of_mem_sizes[0][i]);
    }								    }
    								    
    CacheSize = new Choice();					    CacheSize = new Choice();
    for (int i = 0; i<Table_of_cac_sizes[0].length; i++){	    for (int i = 0; i<Table_of_cac_sizes[0].length; i++){
      CacheSize.addItem(Table_of_cac_sizes[0][i]);		      CacheSize.addItem(Table_of_cac_sizes[0][i]);
    }								    }
    								    
    BlockSize = new Choice ();					    BlockSize = new Choice ();
    for (int i = 0; i<Table_of_blo_sizes[0].length; i++){	    for (int i = 0; i<Table_of_blo_sizes[0].length; i++){
      BlockSize.addItem(Table_of_blo_sizes[0][i]);		      BlockSize.addItem(Table_of_blo_sizes[0][i]);
    }								    }
    								    
    SetSize = new Choice();					    SetSize = new Choice();
    for (int i = 0; i<Table_of_set_sizes[0].length; i++){	    for (int i = 0; i<Table_of_set_sizes[0].length; i++){
      SetSize.addItem(Table_of_set_sizes[0][i]);		      SetSize.addItem(Table_of_set_sizes[0][i]);
    }								    }
    								    
    p_Sizes = new Panel();					    p_Sizes = new Panel();
    p_Sizes.setLayout(new GridLayout(1,2));			    p_Sizes.setLayout(new GridLayout(1,2));
    p_Sizes.setBackground(fillColor);				    p_Sizes.setBackground(fillColor);
    								    
    p_s = new Panel();						    p_s = new Panel();
    p_s.setLayout (new GridLayout(3,1));			    p_s.setLayout (new GridLayout(3,1));
    								    
    p_l = new Panel();						    p_l = new Panel();
    p_l.setLayout (new GridLayout(3,1));			    p_l.setLayout (new GridLayout(3,1));
    								    
    p_s.add(new Label("Memory size: "));			    p_s.add(new Label("Memory size: "));
    p_l.add(MemSize);						    p_l.add(MemSize);
    								    
    p_s.add(new Label("Cache size: "));				    p_s.add(new Label("Cache size: "));
    p_l.add(CacheSize);						    p_l.add(CacheSize);
    								    
    p_s.add(new Label("Block size: "));				    p_s.add(new Label("Block size: "));
    p_l.add(BlockSize);						    p_l.add(BlockSize);
    								    
    p_Sizes.add(p_s);						    p_Sizes.add(p_s);
    p_Sizes.add(p_l);						    p_Sizes.add(p_l);
    								    
    p_head = new Panel();					    p_head = new Panel();
    p_head.setLayout(new BorderLayout(20,15));			    p_head.setLayout(new BorderLayout(20,15));
    p_head.add("West",p_Sizes);					    p_head.add("West",p_Sizes);
    								    
    p7 = new Panel();						    p7 = new Panel();
    p7.setLayout(new BorderLayout(20,15));			    p7.setLayout(new BorderLayout(20,15));
    p7.add("West",new Label("Set size :"));			    p7.add("West",new Label("Set size :"));
    b = false ;							    b = false ;
    //SetSize.disable();					    //SetSize.disable();
    SetSize.setEnabled(b);					    SetSize.setEnabled(b);
    p7.add("East",SetSize);					    p7.add("East",SetSize);
    								    
    //adding Checkboxes						    //adding Checkboxes
    Method = new CheckboxGroup();				    Method = new CheckboxGroup();
    direct = new Checkbox("Direct", Method,true);		    direct = new Checkbox("Direct", Method,true);
    full = new Checkbox("Fully Associative", Method, false);	    full = new Checkbox("Fully Associative", Method, false);
    set = new Checkbox ("Set Associative", Method, false);	    set = new Checkbox ("Set Associative", Method, false);
    								    
    p5 = new Panel();						    p5 = new Panel();
    p5.setLayout(new GridLayout(4,1));				    p5.setLayout(new GridLayout(4,1));
    p5.setBackground(fillColor);				    p5.setBackground(fillColor);
    								    
    p5.add(new Label("Method:"));				    p5.add(new Label("Method:"));
    p5.add(direct);						    p5.add(direct);
    p5.add(full);						    p5.add(full);
    p5.add(set);						    p5.add(set);
    p_head.add("East",p5);					    p_head.add("East",p5);
    								    
    add(p_head);						    add(p_head);
    								    
    p6 = new Panel();						    p6 = new Panel();
    p6.add(Solve = new Button("Solve"));			    p6.add(Solve = new Button("Solve"));
    p7.add("South",p6);						    p7.add("South",p6);
    add(p7);							    add(p7);
    								    
    //draw initial setting on the canvas			    //draw initial setting on the canvas
    								    
    //get method used						    //get method used
    if (direct.getState()==true)				    if (direct.getState()==true)
      method = DIRECT;						      method = DIRECT;
    else if (full.getState() == true)				    else if (full.getState() == true)
      method = FULL;						      method = FULL;
    else 							    else 
      method = SET;						      method = SET;
    								    
    a = new AddressCanvas(					    a = new AddressCanvas(
			  Integer.parseInt(Table_of_mem_sizes				  Integer.parseInt(Table_of_mem_sizes
			  Integer.parseInt(Table_of_cac_sizes				  Integer.parseInt(Table_of_cac_sizes
			  Integer.parseInt(Table_of_blo_sizes				  Integer.parseInt(Table_of_blo_sizes
			  method,							  method,
			  Integer.parseInt(Table_of_set_sizes				  Integer.parseInt(Table_of_set_sizes
			  Table_of_mem_sizes[0][mem_index],				  Table_of_mem_sizes[0][mem_index],
			  Table_of_cac_sizes[0][cac_index],				  Table_of_cac_sizes[0][cac_index],
			  Table_of_blo_sizes[0][blo_index],				  Table_of_blo_sizes[0][blo_index],
			  Table_of_set_sizes[0][set_index]); 				  Table_of_set_sizes[0][set_index]); 
    								    
    //adding canvas						    //adding canvas
    a.resize(500,350);						    a.resize(500,350);
    add(a);							    add(a);
    								    
    resize(500,550);						    resize(500,550);
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public boolean action (Event e,Object o){			  public boolean action (Event e,Object o){
    								    
    if (e.target instanceof Choice){				    if (e.target instanceof Choice){
      if (e.target == MemSize){					      if (e.target == MemSize){
									
	for (int i = 0; i<Table_of_mem_sizes[0].length; i++){		for (int i = 0; i<Table_of_mem_sizes[0].length; i++){
	  if (e.arg.equals(Table_of_mem_sizes[0][i])){			  if (e.arg.equals(Table_of_mem_sizes[0][i])){
	    mem_index = i;						    mem_index = i;
	    System.out.println("mem_index = "+mem_index);		    System.out.println("mem_index = "+mem_index);
	    break;							    break;
	  }								  }
	}								}
      }								      }

      if (e.target == CacheSize){				      if (e.target == CacheSize){
	for (int i = 0; i<Table_of_cac_sizes[0].length; i++){		for (int i = 0; i<Table_of_cac_sizes[0].length; i++){
	  if (e.arg.equals(Table_of_cac_sizes[0][i])){			  if (e.arg.equals(Table_of_cac_sizes[0][i])){
	    cac_index = i;						    cac_index = i;
	    System.out.println("cac_index = "+cac_index);		    System.out.println("cac_index = "+cac_index);
	    break;							    break;
	  }								  }
	}								}
      }								      }

      if (e.target == BlockSize){				      if (e.target == BlockSize){
	for (int i = 0; i<Table_of_blo_sizes[0].length; i++){		for (int i = 0; i<Table_of_blo_sizes[0].length; i++){
	  if (e.arg.equals(Table_of_blo_sizes[0][i])){			  if (e.arg.equals(Table_of_blo_sizes[0][i])){
	    blo_index = i;						    blo_index = i;
	    System.out.println("blo_index = "+blo_index);		    System.out.println("blo_index = "+blo_index);
	    break;							    break;
	  }								  }
	}								}
      }								      }

      if (e.target == SetSize){					      if (e.target == SetSize){
	for (int i = 0; i<Table_of_set_sizes[0].length; i++){		for (int i = 0; i<Table_of_set_sizes[0].length; i++){
	  if (e.arg.equals(Table_of_set_sizes[0][i])){			  if (e.arg.equals(Table_of_set_sizes[0][i])){
	    set_index = i;						    set_index = i;
	    System.out.println("set_index = "+set_index);		    System.out.println("set_index = "+set_index);
	    break;							    break;
	  }								  }
	}								}
									
      }								      }
    }								    }
    								    
    if (e.target instanceof Checkbox){				    if (e.target instanceof Checkbox){
      //get method used						      //get method used
      if (direct.getState()==true){				      if (direct.getState()==true){
	SetSize.disable();						SetSize.disable();
	method = DIRECT;						method = DIRECT;
      }								      }
      else if (full.getState() == true){			      else if (full.getState() == true){
	SetSize.disable();						SetSize.disable();
	method = FULL;							method = FULL;
      }else {							      }else {
	SetSize.enable();						SetSize.enable();
									
	method = SET;							method = SET;
      }								      }
    }								    }
    								    
    if (e.target instanceof Button){				    if (e.target instanceof Button){
      a.SetAll(							      a.SetAll(
	       (int)Integer.parseInt(Table_of_mem_sizes[1][me		       (int)Integer.parseInt(Table_of_mem_sizes[1][me
	       (int)Integer.parseInt(Table_of_cac_sizes[1][ca		       (int)Integer.parseInt(Table_of_cac_sizes[1][ca
	       (int)Integer.parseInt(Table_of_blo_sizes[1][bl		       (int)Integer.parseInt(Table_of_blo_sizes[1][bl
	       method,							       method,
	       (int)Integer.parseInt(Table_of_set_sizes[1][se		       (int)Integer.parseInt(Table_of_set_sizes[1][se
	       Table_of_mem_sizes[0][mem_index],			       Table_of_mem_sizes[0][mem_index],
	       Table_of_cac_sizes[0][cac_index],			       Table_of_cac_sizes[0][cac_index],
	       Table_of_blo_sizes[0][blo_index],			       Table_of_blo_sizes[0][blo_index],
	       Table_of_set_sizes[0][set_index]);   			       Table_of_set_sizes[0][set_index]);   
      								      
      a.repaint();						      a.repaint();
      								      
    }								    }
    return true;						    return true;
  }								  }
}								}

//**************** END **************************************	//**************** END **************************************
import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AddressStructure extends Applet{			public class AddressStructure extends Applet{
  								  
  int xBase = 50;						  int xBase = 50;
  int yBase = 40;						  int yBase = 40;
  int width = 400;						  int width = 400;
  int height= 80;						  int height= 80;
  int Offset_width = 100;					  int Offset_width = 100;
  int Index_width = 120;					  int Index_width = 120;
  								  
  Color fillColor =						  Color fillColor =
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  Color drawColor = Color.black;				  Color drawColor = Color.black;
  								  
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  								  
//***********************************************************	//***********************************************************
  public void init(){						  public void init(){
    setFont(font);						    setFont(font);
    setBackground (						    setBackground (
		   new Color((float)0.9444,(float)0.9444,(flo			   new Color((float)0.9444,(float)0.9444,(flo
    resize(500,150);						    resize(500,150);
  }								  }
  								  
//***********************************************************	//***********************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
    //shadow							    //shadow
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.fillRect(xBase+5, yBase+5, width, height);		    g.fillRect(xBase+5, yBase+5, width, height);
    								    
    //main border						    //main border
    g.drawRect(xBase,yBase,width,height);			    g.drawRect(xBase,yBase,width,height);
    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(xBase,yBase,width,height);			    g.fillRect(xBase,yBase,width,height);
    g.setColor(Color.black);					    g.setColor(Color.black);
    								    
    //inside lines						    //inside lines
    int Offset_start = xBase+width-Offset_width;		    int Offset_start = xBase+width-Offset_width;
    								    
    g.drawLine(Offset_start,yBase,				    g.drawLine(Offset_start,yBase,
	       Offset_start,yBase+height);				       Offset_start,yBase+height);
    g.drawLine(Offset_start+1,yBase,				    g.drawLine(Offset_start+1,yBase,
	       Offset_start+1,yBase+height);				       Offset_start+1,yBase+height);
    								    
    								    
    int horiz_half = yBase+height/2;				    int horiz_half = yBase+height/2;
    g.drawLine(xBase, horiz_half , Offset_start, horiz_half);	    g.drawLine(xBase, horiz_half , Offset_start, horiz_half);
    g.drawLine(xBase, horiz_half+1, 				    g.drawLine(xBase, horiz_half+1, 
	       Offset_start, horiz_half+1);				       Offset_start, horiz_half+1);
    								    
    int Index_start = xBase + width - Offset_width - Index_wi	    int Index_start = xBase + width - Offset_width - Index_wi
    g.drawLine(Index_start,horiz_half,				    g.drawLine(Index_start,horiz_half,
	       Index_start, horiz_half+height/2);			       Index_start, horiz_half+height/2);
    g.drawLine(Index_start+1,horiz_half,			    g.drawLine(Index_start+1,horiz_half,
	       Index_start+1, horiz_half+height/2);			       Index_start+1, horiz_half+height/2);
    								    
    //labels							    //labels
    								    
    //Address							    //Address
    g.drawString("Address", xBase+width/2-20,yBase-5);		    g.drawString("Address", xBase+width/2-20,yBase-5);
    								    
    //Block Address						    //Block Address
    g.drawString("Block Address", xBase+100,horiz_half-10);	    g.drawString("Block Address", xBase+100,horiz_half-10);
    								    
    //block offset						    //block offset
    g.drawString("Block", Offset_start+30,horiz_half-10);	    g.drawString("Block", Offset_start+30,horiz_half-10);
    g.drawString("Offset", Offset_start+30,horiz_half+5);	    g.drawString("Offset", Offset_start+30,horiz_half+5);
    								    
    //tag							    //tag
    g.drawString("Tag", xBase+80,horiz_half + 25);		    g.drawString("Tag", xBase+80,horiz_half + 25);
    								    
    //index 							    //index 
    g.drawString("Index", Index_start+40,horiz_half + 25);	    g.drawString("Index", Index_start+40,horiz_half + 25);
    								    
  }								  }
}								}
//************************ END ******************************	//************************ END ******************************
import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AmCalc2 extends Applet{				public class AmCalc2 extends Applet{
  								  
  private Choice f_value, s_value;				  private Choice f_value, s_value;
  private TextField t;						  private TextField t;
  private Button b;						  private Button b;
  private Panel p1,p2,p3;					  private Panel p1,p2,p3;
  								  
  private int f=90,s=10;					  private int f=90,s=10;
  								  
  Color fillColor=						  Color fillColor=
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  								  
  //*****************************************************	  //*****************************************************
  public void init(){						  public void init(){
    								    
    setBackground (fillColor);					    setBackground (fillColor);
    setFont(font);						    setFont(font);
    								    
    f_value = new Choice();					    f_value = new Choice();
    for (int i = 90; i>0; i-=10){				    for (int i = 90; i>0; i-=10){
      f_value.addItem(i+"");					      f_value.addItem(i+"");
    }								    }
    								    
    s_value = new Choice();					    s_value = new Choice();
    for (int i = 10; i<100; i+=10){				    for (int i = 10; i<100; i+=10){
      s_value.addItem(i+"");					      s_value.addItem(i+"");
    }								    }
    								    
    p1 = new Panel();						    p1 = new Panel();
    p1.add(new Label("Make "));					    p1.add(new Label("Make "));
    p1.add(f_value);						    p1.add(f_value);
    p1.add(new Label("% of a program "));			    p1.add(new Label("% of a program "));
    								    
    p2=new Panel();						    p2=new Panel();
    p2.add(new Label("run "));					    p2.add(new Label("run "));
    p2.add(s_value);						    p2.add(s_value);
    p2.add(new Label(" times faster."));			    p2.add(new Label(" times faster."));
    								    
    p3=new Panel();						    p3=new Panel();
    p3.add(new Label("Overall Speedup: "));			    p3.add(new Label("Overall Speedup: "));
    p3.add(t = new TextField(5));				    p3.add(t = new TextField(5));
    								    
    t.setText(CalcSp(f,s));					    t.setText(CalcSp(f,s));
    t.setEditable(false);					    t.setEditable(false);
    								    
    add(p1);							    add(p1);
    add(p2);							    add(p2);
    add(b=new Button("Solve"));					    add(b=new Button("Solve"));
    add(p3);							    add(p3);
    								    
    resize(250,250);						    resize(250,250);
  }								  }
  								  
  //*************************************************		  //*************************************************
  public boolean action(Event e, Object o){			  public boolean action(Event e, Object o){
    if (e.target ==f_value){					    if (e.target ==f_value){
      f= Integer.parseInt(e.arg.toString());			      f= Integer.parseInt(e.arg.toString());
    }								    }
    if (e.target ==s_value){					    if (e.target ==s_value){
      s= Integer.parseInt(e.arg.toString());			      s= Integer.parseInt(e.arg.toString());
    }								    }
    if (e.target ==b){						    if (e.target ==b){
      t.setText(CalcSp(f,s));					      t.setText(CalcSp(f,s));
    }								    }
    return true;						    return true;
  } 								  } 
 								 
  //******************************************			  //******************************************
  private String CalcSp(int f, int s){				  private String CalcSp(int f, int s){
    double sp = 1/((1-f*0.01)+f*0.01/s);			    double sp = 1/((1-f*0.01)+f*0.01/s);
    String t = new String(String.valueOf(sp));			    String t = new String(String.valueOf(sp));
    String r = t.substring(0,6);				    String r = t.substring(0,6);
    return r;							    return r;
  } 								  } 
}								}
//*************** end *******************************		//*************** end *******************************







import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AmCalc extends Applet{				public class AmCalc extends Applet{
  								  
  private Choice f_value, s_value;				  private Choice f_value, s_value;
  private TextField t;						  private TextField t;
  private Button b;						  private Button b;
  private Panel p1,p2,p3;					  private Panel p1,p2,p3;
  								  
  private int f=10,						  private int f=10,
    s=90;							    s=90;
  								  
  Color fillColor=						  Color fillColor=
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
 								 
  //*****************************************************	  //*****************************************************
  public void init(){						  public void init(){
    								    
    setBackground (fillColor);					    setBackground (fillColor);
    setFont(font);						    setFont(font);

    f_value = new Choice();					    f_value = new Choice();
    for (int i = 10; i<100; i+=10){				    for (int i = 10; i<100; i+=10){
      f_value.addItem(i+"");					      f_value.addItem(i+"");
    }								    }
    								    
    s_value = new Choice();					    s_value = new Choice();
    for (int i = 90; i>0; i-=10){				    for (int i = 90; i>0; i-=10){
      s_value.addItem(i+"");					      s_value.addItem(i+"");
    }								    }
    								    
    p1 = new Panel();						    p1 = new Panel();
    p1.add(new Label("Make "));					    p1.add(new Label("Make "));
    p1.add(f_value);						    p1.add(f_value);
    p1.add(new Label("% of a program "));			    p1.add(new Label("% of a program "));
    								    
    p2=new Panel();						    p2=new Panel();
    p2.add(new Label("run "));					    p2.add(new Label("run "));
    p2.add(s_value);						    p2.add(s_value);
    p2.add(new Label(" times faster."));			    p2.add(new Label(" times faster."));
    								    
    p3=new Panel();						    p3=new Panel();
    p3.add(new Label("Overall Speedup: "));			    p3.add(new Label("Overall Speedup: "));
    p3.add(t = new TextField(5));				    p3.add(t = new TextField(5));
    								    
    t.setText(CalcSp(f,s));					    t.setText(CalcSp(f,s));
    t.setEditable(false);					    t.setEditable(false);
    								    
    add(p1);							    add(p1);
    add(p2);							    add(p2);
    add(b=new Button("Solve"));					    add(b=new Button("Solve"));
    add(p3);							    add(p3);
    								    
    resize(250,250);						    resize(250,250);
  }								  }
  								  
  //*************************************************		  //*************************************************
  public boolean action(Event e, Object o){			  public boolean action(Event e, Object o){
    if (e.target ==f_value){					    if (e.target ==f_value){
      f= (int)Integer.parseInt(e.arg.toString());		      f= (int)Integer.parseInt(e.arg.toString());
    }								    }
    if (e.target ==s_value){					    if (e.target ==s_value){
      s= (int)Integer.parseInt(e.arg.toString());		      s= (int)Integer.parseInt(e.arg.toString());
    }								    }
    if (e.target ==b){						    if (e.target ==b){
      t.setText(CalcSp(f,s));					      t.setText(CalcSp(f,s));
    }								    }
    return true;						    return true;
  } 								  } 
 								 
  //******************************************			  //******************************************
  private String CalcSp(int f, int s){				  private String CalcSp(int f, int s){
    double sp = 1/((1-f*0.01)+f*0.01/s);			    double sp = 1/((1-f*0.01)+f*0.01/s);
    String t = new String(String.valueOf(sp));			    String t = new String(String.valueOf(sp));
    String r = t.substring(0,6);				    String r = t.substring(0,6);
    return r;							    return r;
    								    
  }								  }
}								}
//*************** end *******************************		//*************** end *******************************


import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AmForm2 extends Applet{				public class AmForm2 extends Applet{

  int axBase = 50;						  int axBase = 50;
  int ayBase = 40;						  int ayBase = 40;
  int width = 400;						  int width = 400;
  int height = 80;						  int height = 80;

  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  								  
  Color fillColor =						  Color fillColor =
  new Color ((float)0.4375,(float)0.8125,(float)0.8125);	  new Color ((float)0.4375,(float)0.8125,(float)0.8125);
  Color drawColor = Color.black;				  Color drawColor = Color.black;
  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo	  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo

  //******************************************************	  //******************************************************
  public void init(){						  public void init(){
    setFont(font);						    setFont(font);
    setBackground (bkgColor);					    setBackground (bkgColor);
    resize(width,height);					    resize(width,height);
  }								  }

  //******************************************************	  //******************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
    								    
    //border around						    //border around
    g.setColor(Color.red);					    g.setColor(Color.red);
    g.fillRect(5,5,width-5, height-5);				    g.fillRect(5,5,width-5, height-5);
    g.setColor(bkgColor);					    g.setColor(bkgColor);
    g.fillRect(0,0,width-5, height-5);				    g.fillRect(0,0,width-5, height-5);
    g.setColor(Color.red);					    g.setColor(Color.red);
    g.drawRect(0,0,width-5, height-5);				    g.drawRect(0,0,width-5, height-5);
    								    
    //Amdahl's law						    //Amdahl's law
    g.setColor(Color.red);					    g.setColor(Color.red);
    g.drawString ("Overall speedup   = ",axBase,ayBase);	    g.drawString ("Overall speedup   = ",axBase,ayBase);
    								    
    g.drawLine(axBase+140,ayBase-5,axBase+225,ayBase-5);	    g.drawLine(axBase+140,ayBase-5,axBase+225,ayBase-5);
    g.drawString("1",axBase+170,ayBase-10);			    g.drawString("1",axBase+170,ayBase-10);
    g.drawString("( 1 - f ) + ",axBase+140,ayBase+15);		    g.drawString("( 1 - f ) + ",axBase+140,ayBase+15);
    								    
    g.drawString("f",axBase+140+63,ayBase+15-7); 		    g.drawString("f",axBase+140+63,ayBase+15-7); 
    g.drawString("s",axBase+140+63,ayBase+15+10); 		    g.drawString("s",axBase+140+63,ayBase+15+10); 
    g.drawLine(axBase+140+60,ayBase+15-5,			    g.drawLine(axBase+140+60,ayBase+15-5,
	       axBase+140+72,ayBase+15-5);				       axBase+140+72,ayBase+15-5);
  }								  }
}								}
//************** end *************************************	//************** end *************************************

import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class AmPict extends Applet{				public class AmPict extends Applet{
  int dxBase = 50;						  int dxBase = 50;
  int dyBase = 40;						  int dyBase = 40;
  int width = 500;						  int width = 500;
  int height = 200;						  int height = 200;
  								  
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  								  
  Color fillColor=new Color ((float)0.4375,(float)0.8125,(flo	  Color fillColor=new Color ((float)0.4375,(float)0.8125,(flo
  Color drawColor = Color.black;				  Color drawColor = Color.black;
  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo	  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo
  								  
  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){
    setFont(font);						    setFont(font);
    setBackground (bkgColor);					    setBackground (bkgColor);
    resize(width,height);					    resize(width,height);
  }								  }

  //*********************************************************	  //*********************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
    								    
    //Program picture						    //Program picture
    int dWidth = 120;						    int dWidth = 120;
    int dHeight = 150;						    int dHeight = 150;
    								    
    g.setColor(new Color((float)0.625,(float)0.8125,(float)0.	    g.setColor(new Color((float)0.625,(float)0.8125,(float)0.
    g.fillRect(dxBase,dyBase,dWidth, dHeight);			    g.fillRect(dxBase,dyBase,dWidth, dHeight);
    g.setColor(Color.black);					    g.setColor(Color.black);
    								    
    g.drawString("Program",dxBase, dyBase-5);			    g.drawString("Program",dxBase, dyBase-5);
    g.drawRect(dxBase,dyBase,dWidth, dHeight);			    g.drawRect(dxBase,dyBase,dWidth, dHeight);
    								    
    //inside loops						    //inside loops
    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(dxBase+10,dyBase+20,dWidth-20, 55);		    g.fillRect(dxBase+10,dyBase+20,dWidth-20, 55);
    g.fillRect(dxBase+10,dyBase+20+55+20,dWidth-20, 35);	    g.fillRect(dxBase+10,dyBase+20+55+20,dWidth-20, 35);
    								    
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(dxBase+10,dyBase+20,dWidth-20, 55);		    g.drawRect(dxBase+10,dyBase+20,dWidth-20, 55);
    g.drawRect(dxBase+10,dyBase+20+55+20,dWidth-20, 35);	    g.drawRect(dxBase+10,dyBase+20+55+20,dWidth-20, 35);
    								    
    g.drawString("Loop 1",dxBase+10+10,dyBase+20+55-25);	    g.drawString("Loop 1",dxBase+10+10,dyBase+20+55-25);
    g.drawString("Loop 2",dxBase+10+10,dyBase+20+55+20+35-15)	    g.drawString("Loop 2",dxBase+10+10,dyBase+20+55+20+35-15)
    								    
    DrawCurBr(g,dxBase+dHeight-15,dyBase+20-5,55+10,true,"200	    DrawCurBr(g,dxBase+dHeight-15,dyBase+20-5,55+10,true,"200
    DrawCurBr(g,dxBase+dHeight-15,dyBase+20+55+20-5,35+10,	    DrawCurBr(g,dxBase+dHeight-15,dyBase+20+55+20-5,35+10,
	      true,"10 lines");						      true,"10 lines");
    								    
    //line between loops					    //line between loops
    g.drawLine(dxBase+dHeight+80,dyBase+20+55+20-5-3,		    g.drawLine(dxBase+dHeight+80,dyBase+20+55+20-5-3,
	       dxBase+dHeight+230,dyBase+20+55+20-5-3);			       dxBase+dHeight+230,dyBase+20+55+20-5-3);
    								    
    g.drawString("10% of total execution",dxBase+dHeight+80,	    g.drawString("10% of total execution",dxBase+dHeight+80,
		 dyBase+20+55-30);						 dyBase+20+55-30);
    g.drawString("90% of total execution",dxBase+dHeight+80,	    g.drawString("90% of total execution",dxBase+dHeight+80,
		 dyBase+20+55+20+35-20);					 dyBase+20+55+20+35-20);
    								    
    g.drawString("time",dxBase+dHeight+80+50,			    g.drawString("time",dxBase+dHeight+80+50,
		 dyBase+20+55-15);						 dyBase+20+55-15);
    g.drawString("time",dxBase+dHeight+80+50,			    g.drawString("time",dxBase+dHeight+80+50,
		 dyBase+20+55+20+35-5);						 dyBase+20+55+20+35-5);
    								    
  }								  }

  //****************************************************	  //****************************************************
  public void DrawCurBr(Graphics g,				  public void DrawCurBr(Graphics g,
			int x,        // base coordinates def				int x,        // base coordinates def
			int y,        // as very left point o				int y,        // as very left point o
			int width,    //width of the brace				int width,    //width of the brace
			boolean Right, //true if brace pointe				boolean Right, //true if brace pointe
			String label){          					String label){          
    								    
    int w=15;            //width and height of the rectangle	    int w=15;            //width and height of the rectangle
    int h=10;            //an arcs are bounded by.		    int h=10;            //an arcs are bounded by.
    int height = h;      //height of the whole brace		    int height = h;      //height of the whole brace
    								    
    double Y_step, Y_raise;                //to combine up/do	    double Y_step, Y_raise;                //to combine up/do
    int angle_1,angle_2 ,angle_3 ,angle_4 ;			    int angle_1,angle_2 ,angle_3 ,angle_4 ;
    								    
    if (Right){							    if (Right){
      Y_step = 0.5;						      Y_step = 0.5;
      Y_raise = 0.5;						      Y_raise = 0.5;
      angle_1 = 0;						      angle_1 = 0;
      angle_2 = 180;						      angle_2 = 180;
      angle_3 = 90;						      angle_3 = 90;
      angle_4 = 270;						      angle_4 = 270;
    }								    }
    else {							    else {
      Y_step = -0.5;						      Y_step = -0.5;
      Y_raise = -1.5;						      Y_raise = -1.5;
      angle_1 = 90;						      angle_1 = 90;
      angle_2 = 270;						      angle_2 = 270;
      angle_3 = 0;						      angle_3 = 0;
      angle_4 = 180;						      angle_4 = 180;
    }								    }
    								    
    g.drawArc(x-h/2, y, h, w, angle_1,90);			    g.drawArc(x-h/2, y, h, w, angle_1,90);
    g.drawArc((int)(x+height*Y_raise),y+width/2-w,h, w,angle_	    g.drawArc((int)(x+height*Y_raise),y+width/2-w,h, w,angle_
    g.drawArc((int)(x+height*Y_raise), y+width/2,h, w,angle_3	    g.drawArc((int)(x+height*Y_raise), y+width/2,h, w,angle_3
    g.drawArc(x-h/2, y+width-w, h,w,angle_4,90);		    g.drawArc(x-h/2, y+width-w, h,w,angle_4,90);
    								    
    g.drawLine((int)(x+h*Y_step), y+w/2, (int)(x+h*Y_step),	    g.drawLine((int)(x+h*Y_step), y+w/2, (int)(x+h*Y_step),
	       y+width/2-w/2 );						       y+width/2-w/2 );
    g.drawLine((int)(x+h*Y_step),y+width/2+w/2,(int)(x+h*Y_st	    g.drawLine((int)(x+h*Y_step),y+width/2+w/2,(int)(x+h*Y_st
	       y+width-w/2);						       y+width-w/2);
    								    
    int yLabel = y+width/2+5;					    int yLabel = y+width/2+5;
    int xLabel;							    int xLabel;
    if (Right) 							    if (Right) 
      xLabel= x+height+5;					      xLabel= x+height+5;
    else 							    else 
      xLabel= x-height-30;					      xLabel= x-height-30;
    g.drawString(label, xLabel, yLabel);			    g.drawString(label, xLabel, yLabel);
    								    
  }//end DrawCurBr						  }//end DrawCurBr
}								}

import java.awt.*;						import java.awt.*;

public class Brace{						public class Brace{
  private Graphics g; 						  private Graphics g; 

  //*********************************************************	  //*********************************************************
  public Brace(Graphics G){					  public Brace(Graphics G){
    g=G;							    g=G;
  }								  }

  //*********************************************************	  //*********************************************************
  public void DrawCurBr( FontMetrics font_m,			  public void DrawCurBr( FontMetrics font_m,
			int x,        // base coordinates def				int x,        // base coordinates def
			int y,        // as very left point o				int y,        // as very left point o
			int width,    //width of the brace				int width,    //width of the brace
			boolean up,    //true if brace pointe				boolean up,    //true if brace pointe
			String label){ 							String label){ 
    								    
    int w=15;            //width and height of the rectangle	    int w=15;            //width and height of the rectangle
    int h=10;            //an arcs are bounded by.		    int h=10;            //an arcs are bounded by.
    int height = h;      //height of the whole brace		    int height = h;      //height of the whole brace
    								    
    double Y_step, Y_raise;                //to combine up/do	    double Y_step, Y_raise;                //to combine up/do
    int angle_1,angle_2 ,angle_3 ,angle_4 ;			    int angle_1,angle_2 ,angle_3 ,angle_4 ;
    								    
    if (up){							    if (up){
      Y_step = -0.5;						      Y_step = -0.5;
      Y_raise = -1.5;						      Y_raise = -1.5;
      angle_1 = 90;						      angle_1 = 90;
      angle_2 = 270;						      angle_2 = 270;
      angle_3 = 180;						      angle_3 = 180;
      angle_4 = 0;						      angle_4 = 0;
    }								    }
    else {							    else {
      Y_step = 0.5;						      Y_step = 0.5;
      Y_raise = 0.5;						      Y_raise = 0.5;
      angle_1 = 180;						      angle_1 = 180;
      angle_2 = 0;						      angle_2 = 0;
      angle_3 = 90;						      angle_3 = 90;
      angle_4 = 270;						      angle_4 = 270;
    }								    }
    								    
    g.drawArc(x, y-h/2, w, h, angle_1,90);			    g.drawArc(x, y-h/2, w, h, angle_1,90);
    g.drawArc(x+width/2-w, (int)(y+height*Y_raise), w, h,angl	    g.drawArc(x+width/2-w, (int)(y+height*Y_raise), w, h,angl
    g.drawArc(x+width/2, (int)(y+height*Y_raise), w,h,angle_3	    g.drawArc(x+width/2, (int)(y+height*Y_raise), w,h,angle_3
    g.drawArc(x+width-w, y-h/2, w,h,angle_4,90);		    g.drawArc(x+width-w, y-h/2, w,h,angle_4,90);
    								    
    g.drawLine(x+w/2,(int)(y+h*Y_step),  x+width/2-w/2, 	    g.drawLine(x+w/2,(int)(y+h*Y_step),  x+width/2-w/2, 
               (int)(y+h*Y_step));				               (int)(y+h*Y_step));
    g.drawLine(x+width/2+w/2,(int)(y+h*Y_step), x+width-w/2,	    g.drawLine(x+width/2+w/2,(int)(y+h*Y_step), x+width-w/2,
               (int)(y+h*Y_step));				               (int)(y+h*Y_step));

    int strLength = font_m.stringWidth(label);			    int strLength = font_m.stringWidth(label);

    int xLabel = x+(width-strLength)/2;				    int xLabel = x+(width-strLength)/2;
    int yLabel;							    int yLabel;
    if (up) 							    if (up) 
      yLabel= y-height-5;					      yLabel= y-height-5;
    else 							    else 
      yLabel= y+height+10;					      yLabel= y+height+10;
    g.drawString(label, xLabel, yLabel);			    g.drawString(label, xLabel, yLabel);
  }//end DrawCurBr						  }//end DrawCurBr
}								}
//********************** end ********************************	//********************** end ********************************


import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;
//import Brace;						      |	import Brace;

public class CacheStructure extends Applet{			public class CacheStructure extends Applet{

  int xBase = 50;						  int xBase = 50;
  int yBase = 40;						  int yBase = 40;
  int width = 300;						  int width = 300;
  int height= 250;						  int height= 250;
  								  
  int Offset_width = 100;					  int Offset_width = 100;
  int Index_width = 120;					  int Index_width = 120;
  								  
  Color fillColor =						  Color fillColor =
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  Color drawColor = Color.black;				  Color drawColor = Color.black;
  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo	  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  FontMetrics font_m;						  FontMetrics font_m;

  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){
    setFont(font);						    setFont(font);
    font_m = getFontMetrics(font);				    font_m = getFontMetrics(font);
    setBackground (bkgColor);					    setBackground (bkgColor);
    resize(width, height);					    resize(width, height);
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
    int tag_width = 100;					    int tag_width = 100;
    int tag_height = 20;					    int tag_height = 20;
    								    
    int fr_width = 120;						    int fr_width = 120;
    int fr_height = 40;						    int fr_height = 40;
    								    
    int rxBase = xBase+tag_width;				    int rxBase = xBase+tag_width;
    int ryBase = yBase;						    int ryBase = yBase;
    								    
    int Num_bl = 4;						    int Num_bl = 4;
    								    
    //RAM							    //RAM
    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(rxBase, ryBase, fr_width, fr_height*Num_bl);	    g.fillRect(rxBase, ryBase, fr_width, fr_height*Num_bl);
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(rxBase, ryBase, fr_width, fr_height*Num_bl);	    g.drawRect(rxBase, ryBase, fr_width, fr_height*Num_bl);
    int shift = 0;						    int shift = 0;
    int j;							    int j;
    for (int i = 1; i <= Num_bl; i++){				    for (int i = 1; i <= Num_bl; i++){
      j = i-1;							      j = i-1;
      shift = fr_height*i;					      shift = fr_height*i;
      g.drawLine(rxBase,ryBase+shift,				      g.drawLine(rxBase,ryBase+shift,
		 rxBase+fr_width, ryBase+shift);				 rxBase+fr_width, ryBase+shift);
      g.drawString("Block Frame "+j, 				      g.drawString("Block Frame "+j, 
		   rxBase+10, ryBase+shift-fr_height/2+5);			   rxBase+10, ryBase+shift-fr_height/2+5);
    }								    }
    								    
    //tags							    //tags
    int step = 0;						    int step = 0;
    for (int i = 0; i< Num_bl; i++){				    for (int i = 0; i< Num_bl; i++){
      step = i*fr_height;					      step = i*fr_height;
      								      
      g.setColor(Color.lightGray);				      g.setColor(Color.lightGray);
      g.fillRect(xBase, yBase+step, tag_width, tag_height);	      g.fillRect(xBase, yBase+step, tag_width, tag_height);
      								      
      g.setColor(Color.gray);					      g.setColor(Color.gray);
      g.fillRect(xBase, yBase+step, 20,20);			      g.fillRect(xBase, yBase+step, 20,20);
      								      
      g.setColor(Color.black);					      g.setColor(Color.black);
      g.drawRect(xBase, yBase+step, tag_width, tag_height);	      g.drawRect(xBase, yBase+step, tag_width, tag_height);
      								      
      g.drawLine(xBase+20, yBase+step, xBase+20, yBase+step+t	      g.drawLine(xBase+20, yBase+step, xBase+20, yBase+step+t
      								      
      g.drawString ("tag", xBase+40, yBase+step+tag_height-5)	      g.drawString ("tag", xBase+40, yBase+step+tag_height-5)
    }								    }
    Brace br = new Brace(g);    				    Brace br = new Brace(g);    
    br.DrawCurBr(font_m, xBase, yBase-5,tag_width,true, "Dire	    br.DrawCurBr(font_m, xBase, yBase-5,tag_width,true, "Dire
    br.DrawCurBr(font_m, xBase+tag_width, yBase-5,fr_width,tr	    br.DrawCurBr(font_m, xBase+tag_width, yBase-5,fr_width,tr
    								    
    g.setColor(Color.gray);					    g.setColor(Color.gray);
    g.fillRect(xBase,yBase+ Num_bl*fr_height+20, 20,20);	    g.fillRect(xBase,yBase+ Num_bl*fr_height+20, 20,20);
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(xBase,yBase+ Num_bl*fr_height+20, 20,20);	    g.drawRect(xBase,yBase+ Num_bl*fr_height+20, 20,20);
    g.drawString(" - Control Bit",xBase+25,yBase+ Num_bl*fr_h	    g.drawString(" - Control Bit",xBase+25,yBase+ Num_bl*fr_h
  }								  }
}								}
//******************* end ***********************************	//******************* end ***********************************




import  java.awt.*;						import  java.awt.*;
//import Brace;						      |	import Brace;
import java.applet.Applet;					import java.applet.Applet;

public class ex18_applet1 extends Applet{			public class ex18_applet1 extends Applet{
  								  
  private final boolean UP = true,				  private final boolean UP = true,
                        DOWN = false;				                        DOWN = false;
  private int mem_size, ca_size ,bl_size ,se_size,method ;	  private int mem_size, ca_size ,bl_size ,se_size,method ;
  private String memS_String ,caS_String ,blS_String ,seS_Str	  private String memS_String ,caS_String ,blS_String ,seS_Str
  								  
  private final int xBase = 10,					  private final int xBase = 10,
    yBase = 50,							    yBase = 50,
    unit_width = 20,						    unit_width = 20,
    unit_height = 30;						    unit_height = 30;

  private Font font = new Font("TimesRoman", Font.BOLD, 14);	  private Font font = new Font("TimesRoman", Font.BOLD, 14);
  private Font sub_font = new Font("TimesRoman", Font.BOLD, 1	  private Font sub_font = new Font("TimesRoman", Font.BOLD, 1
  FontMetrics fm;						  FontMetrics fm;

  Color subColor = Color.blue;					  Color subColor = Color.blue;
  Color back_gr = new Color(					  Color back_gr = new Color(
        (float)0.9444,(float)0.9444,(float)0.9444);		        (float)0.9444,(float)0.9444,(float)0.9444);
  private final Color fillColor=				  private final Color fillColor=
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  								  
  private final Color drawColor = Color.black;			  private final Color drawColor = Color.black;

  //************************************************		  //************************************************
  /*								  /*
  AddressCanvas(int M, int C, int B, int T, int S,		  AddressCanvas(int M, int C, int B, int T, int S,
                String MStr, String CStr, String BStr, String	                String MStr, String CStr, String BStr, String
    super();							    super();
    */								    */

  public void init(){						  public void init(){
    SetAll( 18,12,6 ,2,2 , "256 KW", " 4 KW ", "64 W","4 bloc	    SetAll( 18,12,6 ,2,2 , "256 KW", " 4 KW ", "64 W","4 bloc
//    SetAll( M,C, B,T, S, MStr, CStr, BStr, SStr);		//    SetAll( M,C, B,T, S, MStr, CStr, BStr, SStr);
    setBackground(back_gr);					    setBackground(back_gr);
    								    
    setFont(font);						    setFont(font);
  }								  }
  								  
  //************************************************		  //************************************************
  public void SetAll(int M, int C, int B, int T, int S,		  public void SetAll(int M, int C, int B, int T, int S,
		     String MStr, String CStr, String BStr, S			     String MStr, String CStr, String BStr, S
    mem_size = M;						    mem_size = M;
    ca_size = C;						    ca_size = C;
    bl_size = B;						    bl_size = B;
    se_size = S;						    se_size = S;
    method = T;							    method = T;
    								    
    memS_String = new String(MStr);				    memS_String = new String(MStr);
    caS_String = new String(CStr);				    caS_String = new String(CStr);
    blS_String = new String(BStr);				    blS_String = new String(BStr);
    seS_String = new String(SStr);				    seS_String = new String(SStr);
  }								  }
   								   
  //************************************************		  //************************************************
  public void paint( Graphics a){				  public void paint( Graphics a){
    								    
    //address area						    //address area
    int addr_width = mem_size * unit_width;			    int addr_width = mem_size * unit_width;
    a.setColor(fillColor);					    a.setColor(fillColor);
    a.fillRect (xBase, yBase, addr_width, unit_height);		    a.fillRect (xBase, yBase, addr_width, unit_height);
    a.setColor(drawColor);					    a.setColor(drawColor);
    a.drawRect(xBase, yBase, addr_width, unit_height);		    a.drawRect(xBase, yBase, addr_width, unit_height);
    								    
    //bits in address						    //bits in address
    for (int i = 1; i<=mem_size; i++){				    for (int i = 1; i<=mem_size; i++){
      a.drawLine(xBase+unit_width*i, yBase,			      a.drawLine(xBase+unit_width*i, yBase,
		 xBase+unit_width*i, yBase+unit_height);			 xBase+unit_width*i, yBase+unit_height);
    }								    }
    								    
    //curly brace for total memory size				    //curly brace for total memory size
    Brace br = new Brace(a);					    Brace br = new Brace(a);
    fm = getFontMetrics(font);					    fm = getFontMetrics(font);
    br.DrawCurBr(fm, xBase, yBase+unit_height, addr_width, DO	    br.DrawCurBr(fm, xBase, yBase+unit_height, addr_width, DO
	      mem_size + " bits");					      mem_size + " bits");
    								    
    //calculate and draw Offset					    //calculate and draw Offset
    int Offset_width = bl_size * unit_width;			    int Offset_width = bl_size * unit_width;
    int xOffset= xBase + addr_width- Offset_width;		    int xOffset= xBase + addr_width- Offset_width;
    a.drawLine(xOffset+1, yBase, xOffset+1, yBase+unit_height	    a.drawLine(xOffset+1, yBase, xOffset+1, yBase+unit_height
    								    
    br.DrawCurBr(fm, xOffset, yBase, Offset_width, UP,		    br.DrawCurBr(fm, xOffset, yBase, Offset_width, UP,
	      bl_size + " bits");					      bl_size + " bits");
    a.drawString("Offset",xOffset+Offset_width/2-15,		    a.drawString("Offset",xOffset+Offset_width/2-15,
		 yBase+unit_height/2+5);					 yBase+unit_height/2+5);
    								    
    								    
    //calculate and draw Index					    //calculate and draw Index
    boolean index_status = true;				    boolean index_status = true;
    int Index_width = 0 ;					    int Index_width = 0 ;
    int Index_bit_count = 0;					    int Index_bit_count = 0;
    								    
int DIRECT = 1; int SET = 2;					int DIRECT = 1; int SET = 2;
    if (method == DIRECT){					    if (method == DIRECT){
      //direct							      //direct
      Index_bit_count = ca_size - bl_size; 			      Index_bit_count = ca_size - bl_size; 
      Index_width = (ca_size - bl_size) * unit_width;		      Index_width = (ca_size - bl_size) * unit_width;
    }								    }
    else 							    else 
      if (method == SET){					      if (method == SET){
	//set associative						//set associative
	Index_bit_count = ca_size - (se_size+bl_size); 			Index_bit_count = ca_size - (se_size+bl_size); 
	Index_width = Index_bit_count * unit_width;			Index_width = Index_bit_count * unit_width;
      }								      }
      else {							      else {
	//method is "fully associative" 				//method is "fully associative" 
	index_status = false;						index_status = false;
      }								      }
      								      
    if (index_status){						    if (index_status){
      int xIndex = xBase + addr_width - Index_width - Offset_	      int xIndex = xBase + addr_width - Index_width - Offset_
      a.drawLine(xIndex+1, yBase, xIndex+1, yBase+unit_height	      a.drawLine(xIndex+1, yBase, xIndex+1, yBase+unit_height
      br.DrawCurBr(fm, xIndex, yBase, Index_width, UP,		      br.DrawCurBr(fm, xIndex, yBase, Index_width, UP,
		Index_bit_count + " bits");					Index_bit_count + " bits");
      a.drawString("Index",xIndex+Index_width/2-15,yBase+unit	      a.drawString("Index",xIndex+Index_width/2-15,yBase+unit
    }								    }
    								    
    //draw tag							    //draw tag
    int Tag_width = addr_width - Offset_width - Index_width;	    int Tag_width = addr_width - Offset_width - Index_width;
    int Tag_bit_count = mem_size - bl_size - Index_bit_count;	    int Tag_bit_count = mem_size - bl_size - Index_bit_count;
    								    
    if (Tag_bit_count <= 0)					    if (Tag_bit_count <= 0)
      a.setColor(Color.red);					      a.setColor(Color.red);
    br.DrawCurBr(fm, xBase, yBase, Tag_width, UP,		    br.DrawCurBr(fm, xBase, yBase, Tag_width, UP,
	      Tag_bit_count + " bits");					      Tag_bit_count + " bits");
    a.drawString("Tag",xBase+Tag_width/2-5,yBase+unit_height/	    a.drawString("Tag",xBase+Tag_width/2-5,yBase+unit_height/
    								    
    //explanations under address				    //explanations under address
    int yTextBase = yBase+unit_height+50;			    int yTextBase = yBase+unit_height+50;
    int stepDown = 20;						    int stepDown = 20;
    								    
    //total							    //total
    a.drawString("Memory size = "+ memS_String + " = 2" , 	    a.drawString("Memory size = "+ memS_String + " = 2" , 
		 xBase,yTextBase+stepDown);					 xBase,yTextBase+stepDown);
    a.setFont(sub_font);					    a.setFont(sub_font);
    Color prev_color = a.getColor();				    Color prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(mem_size+"", xBase+170,yTextBase+stepDown-7)	    a.drawString(mem_size+"", xBase+170,yTextBase+stepDown-7)
    a.setFont(font);    					    a.setFont(font);    
    a.setColor(prev_color);					    a.setColor(prev_color);

    //offset							    //offset
    a.drawString("Block size = "+ blS_String + " = 2" ,		    a.drawString("Block size = "+ blS_String + " = 2" ,
		 xBase,yTextBase+stepDown*3);					 xBase,yTextBase+stepDown*3);
    //subscript!!!						    //subscript!!!
    a.setFont(sub_font);					    a.setFont(sub_font);
    prev_color = a.getColor();					    prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(bl_size+"", xBase+140,yTextBase+stepDown*3-7	    a.drawString(bl_size+"", xBase+140,yTextBase+stepDown*3-7
    a.setFont(font);						    a.setFont(font);
    a.setColor(prev_color);					    a.setColor(prev_color);

    //Index							    //Index
    if (index_status){						    if (index_status){
      if (method == SET){					      if (method == SET){
	a.drawString("Number of sets in cache = "+ 			a.drawString("Number of sets in cache = "+ 
		     "Cache Size / ( Set Size * Block Size ) 			     "Cache Size / ( Set Size * Block Size ) 
		     xBase,yTextBase+stepDown*5);				     xBase,yTextBase+stepDown*5);
	a.drawString("                  " + caS_String + " / 		a.drawString("                  " + caS_String + " / 
		     seS_String +						     seS_String +
		     " * "+							     " * "+
		     blS_String +						     blS_String +
		     " ) = 2   / ( 2   * 2   ) = 2",				     " ) = 2   / ( 2   * 2   ) = 2",
		     xBase,yTextBase+stepDown*6);				     xBase,yTextBase+stepDown*6);
	//subscripts !!!						//subscripts !!!
	a.setFont(sub_font);						a.setFont(sub_font);
	prev_color = a.getColor();					prev_color = a.getColor();

	a.drawString(ca_size+"", xBase+268,yTextBase+stepDown		a.drawString(ca_size+"", xBase+268,yTextBase+stepDown
	a.drawString(se_size+"", xBase+305,yTextBase+stepDown		a.drawString(se_size+"", xBase+305,yTextBase+stepDown
	a.drawString(bl_size+"", xBase+335,yTextBase+stepDown		a.drawString(bl_size+"", xBase+335,yTextBase+stepDown
	a.setColor(subColor);						a.setColor(subColor);
	a.drawString(Index_bit_count+"", xBase+375,yTextBase+		a.drawString(Index_bit_count+"", xBase+375,yTextBase+
	a.setFont(font);						a.setFont(font);
	a.setColor(prev_color);						a.setColor(prev_color);
      }else{							      }else{
	a.drawString("Number of blocks in cache = "+			a.drawString("Number of blocks in cache = "+
		     "Cache Size / Block Size  = ",				     "Cache Size / Block Size  = ",
		     xBase,yTextBase+stepDown*5);				     xBase,yTextBase+stepDown*5);
	a.drawString("                  " + caS_String + " / 		a.drawString("                  " + caS_String + " / 
		     blS_String +						     blS_String +
		     " = 2   /  2   = 2",					     " = 2   /  2   = 2",
		     xBase,yTextBase+stepDown*6);				     xBase,yTextBase+stepDown*6);
	//subscripts !!!						//subscripts !!!
	 a.setFont(sub_font);						 a.setFont(sub_font);
	 prev_color = a.getColor();					 prev_color = a.getColor();

	 a.drawString(ca_size+"", xBase+180,yTextBase+stepDow		 a.drawString(ca_size+"", xBase+180,yTextBase+stepDow
	 a.drawString(bl_size+"", xBase+215,yTextBase+stepDow		 a.drawString(bl_size+"", xBase+215,yTextBase+stepDow
	 a.setColor(subColor);						 a.setColor(subColor);
	 a.drawString(Index_bit_count+"", xBase+245,yTextBase		 a.drawString(Index_bit_count+"", xBase+245,yTextBase
	 a.setFont(font);						 a.setFont(font);
	 a.setColor(prev_color);					 a.setColor(prev_color);
      }								      }
    }								    }
    								    
    //Tag							    //Tag
    a.drawString("Number of bits in Tag = "+mem_size+		    a.drawString("Number of bits in Tag = "+mem_size+
		 " - "+Index_bit_count+" - "+ bl_size+				 " - "+Index_bit_count+" - "+ bl_size+
		 " = ",								 " = ",
		 xBase,yTextBase+stepDown*8);					 xBase,yTextBase+stepDown*8);
    prev_color = a.getColor();					    prev_color = a.getColor();
    a.setColor(subColor);					    a.setColor(subColor);
    a.drawString(Tag_bit_count+"", xBase+235,yTextBase+stepDo	    a.drawString(Tag_bit_count+"", xBase+235,yTextBase+stepDo
    a.setColor(prev_color);					    a.setColor(prev_color);
    								    
  }//paint							  }//paint
}								}
//**************************** END **************************	//**************************** END **************************


import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;
//import Brace;						      |	import Brace;

public class ex21_applet extends Applet{			public class ex21_applet extends Applet{

  int x = 30;							  int x = 30;
  int y = 40;							  int y = 40;
  int width = 300;						  int width = 300;
  int height= 250;						  int height= 250;
  								  
  int Offset_width = 100;					  int Offset_width = 100;
  int Index_width = 120;					  int Index_width = 120;
  								  
  Color fillColor =						  Color fillColor =
  new Color ((float)0.625,(float)0.8125,(float)0.8125);		  new Color ((float)0.625,(float)0.8125,(float)0.8125);
  Color drawColor = Color.black;				  Color drawColor = Color.black;
  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo	  Color bkgColor = new Color((float)0.9444,(float)0.9444,(flo
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  FontMetrics fm;						  FontMetrics fm;

  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){
    setFont(font);						    setFont(font);
    fm = getFontMetrics(font);					    fm = getFontMetrics(font);
    setBackground (bkgColor);					    setBackground (bkgColor);
    resize(width, height);					    resize(width, height);
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
    //CPU							    //CPU
    g.setColor(Color.gray);					    g.setColor(Color.gray);
    g.fillRect(x,y,40,40);					    g.fillRect(x,y,40,40);
    g.setColor(Color.black);    				    g.setColor(Color.black);    
    g.drawRect(x,y,40,40);					    g.drawRect(x,y,40,40);
    g.drawString("CPU",x+(40-fm.stringWidth("CPU"))/2,y+20+5)	    g.drawString("CPU",x+(40-fm.stringWidth("CPU"))/2,y+20+5)

    //line between Cpu and Cache				    //line between Cpu and Cache
g.drawLine(x+40, y+20, x+40+40, y+20);				g.drawLine(x+40, y+20, x+40+40, y+20);

    //Cache							    //Cache
    g.setColor(Color.lightGray);				    g.setColor(Color.lightGray);
    g.fillRect(x+40+40,y,50,50);				    g.fillRect(x+40+40,y,50,50);
    g.setColor(Color.black);    				    g.setColor(Color.black);    
    g.drawRect(x+40+40, y, 50,50);				    g.drawRect(x+40+40, y, 50,50);
    g.drawString("Cache",x+40+40+(50-fm.stringWidth("Cache"))	    g.drawString("Cache",x+40+40+(50-fm.stringWidth("Cache"))

    //Bus							    //Bus
    g.setColor(Color.red);					    g.setColor(Color.red);
    g.drawLine(x+40+40+50, y+20,x+40+40+50+40,y+20);		    g.drawLine(x+40+40+50, y+20,x+40+40+50+40,y+20);
    g.drawLine(x+40+40+50, y+20+3,x+40+40+50+40,y+20+3);	    g.drawLine(x+40+40+50, y+20+3,x+40+40+50+40,y+20+3);
    g.drawString("Bus",x+40+40+50+(40-fm.stringWidth("Bus"))/	    g.drawString("Bus",x+40+40+50+(40-fm.stringWidth("Bus"))/

    //Memory							    //Memory
    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(x+40+40+50+40,y, 60,60);				    g.fillRect(x+40+40+50+40,y, 60,60);
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(x+40+40+50+40,y, 60,60);				    g.drawRect(x+40+40+50+40,y, 60,60);
     g.drawString("Memory",x+40+40+50+40+(60-fm.stringWidth("	     g.drawString("Memory",x+40+40+50+40+(60-fm.stringWidth("
                   y+20+5);					                   y+20+5);

  }								  }
}								}
//******************* end ***********************************	//******************* end ***********************************




import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class HierarchyApplet extends Applet implements Runnab	public class HierarchyApplet extends Applet implements Runnab

  HierarchyCanvas c = new HierarchyCanvas();			  HierarchyCanvas c = new HierarchyCanvas();
  Thread Animation_thread;					  Thread Animation_thread;

//***********************************************************	//***********************************************************
  public void init(){						  public void init(){
    c.resize(720,420);						    c.resize(720,420);
    add(c);							    add(c);
  }								  }

//***********************************************************	//***********************************************************
  public void start(){						  public void start(){
    Animation_thread = new Thread(this, "Animation_thread");	    Animation_thread = new Thread(this, "Animation_thread");
    Animation_thread.start();					    Animation_thread.start();
  }								  }

//**********************************************************	//**********************************************************
  public void run(){						  public void run(){
    Graphics g = c.getGraphics();				    Graphics g = c.getGraphics();
    int i = 0;							    int i = 0;
    int j = 0;							    int j = 0;

    while(true){						    while(true){
      //make reg-cpu line active				      //make reg-cpu line active
      g.setColor(Color.red);					      g.setColor(Color.red);
      g.drawLine(50,188, 150,188);				      g.drawLine(50,188, 150,188);
      g.drawLine(50,187, 150,187);				      g.drawLine(50,187, 150,187);
      								      
      								      
      //make other lines blinking with different frequency	      //make other lines blinking with different frequency
      if (i== 0){						      if (i== 0){
	g.setColor(Color.red);						g.setColor(Color.red);
	i++;								i++;
      }else{							      }else{
	g.setColor(new Color((float)0.4375,(float)0.625,(floa		g.setColor(new Color((float)0.4375,(float)0.625,(floa
	i--;								i--;
      }								      }
      								      
      g.drawLine(150,120, 250,120);				      g.drawLine(150,120, 250,120);
      g.drawLine(150,119, 250,119);				      g.drawLine(150,119, 250,119);
      								      
      if ((j%20) == 0) {					      if ((j%20) == 0) {
	//blink mem-cache bus						//blink mem-cache bus
	g.drawLine(310,120, 400,120);					g.drawLine(310,120, 400,120);
	g.drawLine(310,119, 400,119);//for thick line			g.drawLine(310,119, 400,119);//for thick line
      }								      }
      if ((j%21) == 0) {					      if ((j%21) == 0) {
	//blink mem-cache bus						//blink mem-cache bus
	g.drawLine(310,120, 400,120);					g.drawLine(310,120, 400,120);
	g.drawLine(310,119, 400,119);//for thick line			g.drawLine(310,119, 400,119);//for thick line
      }								      }
      								      
      if ((j%100) == 0){					      if ((j%100) == 0){
	//blink IO-bus 							//blink IO-bus 
	g.drawLine(500,120, 570,120);					g.drawLine(500,120, 570,120);
	g.drawLine(500,119, 570,119);//for thick line			g.drawLine(500,119, 570,119);//for thick line
	g.drawLine(500,121, 570,121);//for thick line			g.drawLine(500,121, 570,121);//for thick line
      }								      }
      if ((j%101) == 0){					      if ((j%101) == 0){
	//blink IO-bus 							//blink IO-bus 
	g.drawLine(500,120, 570,120);					g.drawLine(500,120, 570,120);
	g.drawLine(500,119, 570,119);//for thick line			g.drawLine(500,119, 570,119);//for thick line
	g.drawLine(500,121, 570,121);//for thick line			g.drawLine(500,121, 570,121);//for thick line
      }								      }
      								      
      j++; 							      j++; 
      if (j == 1000) j=0;					      if (j == 1000) j=0;
      								      
      try{							      try{
	Thread.sleep(100);						Thread.sleep(100);
      }catch (InterruptedException e_int){			      }catch (InterruptedException e_int){
	showStatus(e_int.toString());					showStatus(e_int.toString());
      }								      }
    }//while							    }//while
  }//run							  }//run
  								  
  //*********************************************************	  //*********************************************************
  public void stop(){						  public void stop(){
    if (Animation_thread != null)				    if (Animation_thread != null)
      Animation_thread.stop();					      Animation_thread.stop();
  }								  }
}								}
//**************** end **************************************	//**************** end **************************************
import  java.awt.*;						import  java.awt.*;

class HierarchyCanvas extends Canvas{				class HierarchyCanvas extends Canvas{
  private Font font;						  private Font font;

  //*************************************************		  //*************************************************
  HierarchyCanvas(){						  HierarchyCanvas(){
    super();							    super();
    setBackground(new Color((float)0.95,(float)0.95,(float)0.	    setBackground(new Color((float)0.95,(float)0.95,(float)0.
    font = new Font("TimesRoman", Font.BOLD, 16);		    font = new Font("TimesRoman", Font.BOLD, 16);
    setFont(font);						    setFont(font);
  }								  }

  //***************************************************		  //***************************************************
  public void paint( Graphics canvasH){				  public void paint( Graphics canvasH){
    //cpu							    //cpu
    canvasH.drawRect(50,85, 100,100);				    canvasH.drawRect(50,85, 100,100);
    canvasH.drawRect(49,84, 102,102);//for thick line		    canvasH.drawRect(49,84, 102,102);//for thick line
    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasH.fillRect(50,85, 100,100);				    canvasH.fillRect(50,85, 100,100);
    								    
    //cpu label							    //cpu label
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);
    canvasH.drawString("CPU", 80,135);				    canvasH.drawString("CPU", 80,135);
    								    
    //registers							    //registers
    canvasH.drawRect(50,190, 100,30);				    canvasH.drawRect(50,190, 100,30);
    canvasH.drawRect(49,189, 102,32);//for thick line		    canvasH.drawRect(49,189, 102,32);//for thick line
    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasH.fillRect(50,190, 100,30);				    canvasH.fillRect(50,190, 100,30);
    								    
    //registers label						    //registers label
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);
    canvasH.drawString("Register File", 57,210);		    canvasH.drawString("Register File", 57,210);
    								    
    //reg reference						    //reg reference
    canvasH.drawString("Register", 70,310);			    canvasH.drawString("Register", 70,310);
    canvasH.drawString("Reference", 67,325);			    canvasH.drawString("Reference", 67,325);
    								    
    canvasH.drawString("Cache", 260,310);			    canvasH.drawString("Cache", 260,310);
    canvasH.drawString("Reference", 250,325);			    canvasH.drawString("Reference", 250,325);
    								    
    canvasH.drawString("Main Memory", 400,310);			    canvasH.drawString("Main Memory", 400,310);
    canvasH.drawString("Reference", 415,325);			    canvasH.drawString("Reference", 415,325);
    								    
    canvasH.drawString("Disk", 590,295);			    canvasH.drawString("Disk", 590,295);
    canvasH.drawString("Memory", 585,310);			    canvasH.drawString("Memory", 585,310);
    canvasH.drawString("Reference", 580,325);			    canvasH.drawString("Reference", 580,325);
    								    
    canvasH.drawLine(50,335, 690,335);				    canvasH.drawLine(50,335, 690,335);
    canvasH.drawLine(50,375, 690,375);				    canvasH.drawLine(50,375, 690,375);
    								    
    canvasH.drawString("Size:", 10,350);			    canvasH.drawString("Size:", 10,350);
    								    
    canvasH.drawString("Speed:", 10,370);			    canvasH.drawString("Speed:", 10,370);
    								    
    canvasH.drawString("200 B", 90,350);			    canvasH.drawString("200 B", 90,350);
    canvasH.drawString("5 ns", 90,370);				    canvasH.drawString("5 ns", 90,370);
    								    
    canvasH.drawString("64 KB", 270,350);			    canvasH.drawString("64 KB", 270,350);
    canvasH.drawString("10 ns", 270,370);			    canvasH.drawString("10 ns", 270,370);
    								    
    canvasH.drawString("32 MB", 420,350);			    canvasH.drawString("32 MB", 420,350);
    canvasH.drawString("100 ns", 420,370);			    canvasH.drawString("100 ns", 420,370);
    								    
    canvasH.drawString("2 GB", 590,350);			    canvasH.drawString("2 GB", 590,350);
    canvasH.drawString("5 ms", 590,370);			    canvasH.drawString("5 ms", 590,370);
    								    
    //around							    //around
    canvasH.drawRect(230,60, 290,230);				    canvasH.drawRect(230,60, 290,230);
    canvasH.drawRect(229,59, 292,232);				    canvasH.drawRect(229,59, 292,232);
    canvasH.setColor(new Color((float)0.625,(float)0.8125,(fl	    canvasH.setColor(new Color((float)0.625,(float)0.8125,(fl
    canvasH.fillRect(230,60, 290,230);				    canvasH.fillRect(230,60, 290,230);

    //around label						    //around label
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);
    canvasH.drawString("Memory", 350,50);			    canvasH.drawString("Memory", 350,50);
    								    
    //cache							    //cache
    canvasH.drawRect(250,100,60,120);				    canvasH.drawRect(250,100,60,120);
    canvasH.drawRect(249,99,62,122);//for thick line		    canvasH.drawRect(249,99,62,122);//for thick line
    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasH.fillRect(250,100,60,120);				    canvasH.fillRect(250,100,60,120);

    //cache labels						    //cache labels
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);
    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));	    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));
    canvasH.drawString("Upper level", 250,90);			    canvasH.drawString("Upper level", 250,90);
    								    
    canvasH.setFont(new Font("TimesRoman", Font.BOLD, 16));	    canvasH.setFont(new Font("TimesRoman", Font.BOLD, 16));
    canvasH.drawString("Cache", 260,160);			    canvasH.drawString("Cache", 260,160);

    //main mem							    //main mem
     canvasH.drawRect(400,100, 100,180);			     canvasH.drawRect(400,100, 100,180);
    canvasH.drawRect(399,99, 102,182);//for thick line		    canvasH.drawRect(399,99, 102,182);//for thick line
    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasH.fillRect(400,100, 100,180);				    canvasH.fillRect(400,100, 100,180);

    //main mem label						    //main mem label
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);
    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));	    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));
    canvasH.drawString("Lower level", 400,90);			    canvasH.drawString("Lower level", 400,90);

    canvasH.setFont(new Font("TimesRoman", Font.BOLD, 16));	    canvasH.setFont(new Font("TimesRoman", Font.BOLD, 16));
    canvasH.drawString("Main", 425,160);			    canvasH.drawString("Main", 425,160);
    canvasH.drawString("Memory", 415,180);			    canvasH.drawString("Memory", 415,180);

    // IO devices						    // IO devices
    canvasH.drawRect(570,100, 110,120);				    canvasH.drawRect(570,100, 110,120);
    canvasH.drawRect(569,99, 112,122);				    canvasH.drawRect(569,99, 112,122);
    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasH.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasH.fillRect(570,100, 110,120);				    canvasH.fillRect(570,100, 110,120);

    //IO label							    //IO label
    canvasH.setColor(Color.black);				    canvasH.setColor(Color.black);

    //canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));	    //canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 16));
    canvasH.drawString("IO", 615,160);				    canvasH.drawString("IO", 615,160);
    canvasH.drawString("Devices", 605,180);			    canvasH.drawString("Devices", 605,180);
    								    
    //line IO - mem						    //line IO - mem
    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));
    canvasH.drawString("IO bus", 525,115);			    canvasH.drawString("IO bus", 525,115);
    canvasH.drawLine(500,120, 570,120);				    canvasH.drawLine(500,120, 570,120);
    canvasH.drawLine(500,119, 570,119);//for thick line		    canvasH.drawLine(500,119, 570,119);//for thick line
    canvasH.drawLine(500,121, 570,121);//for thick line		    canvasH.drawLine(500,121, 570,121);//for thick line
    								    
    //line cpu-cache						    //line cpu-cache
    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));
    canvasH.drawLine(150,120, 250,120);				    canvasH.drawLine(150,120, 250,120);
    canvasH.drawLine(150,119, 250,119);//for thick line		    canvasH.drawLine(150,119, 250,119);//for thick line
    canvasH.drawLine(150,121, 250,121);//for thick line		    canvasH.drawLine(150,121, 250,121);//for thick line
    								    
    //line cache-main mem					    //line cache-main mem
    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasH.setFont(new Font("TimesRoman",Font.PLAIN, 14));
    canvasH.drawString("bus", 350,115);				    canvasH.drawString("bus", 350,115);
    canvasH.drawLine(310,120, 400,120);				    canvasH.drawLine(310,120, 400,120);
    canvasH.drawLine(310,119, 400,119);//for thick line		    canvasH.drawLine(310,119, 400,119);//for thick line
    canvasH.drawLine(310,121, 400,121);//for thick line		    canvasH.drawLine(310,121, 400,121);//for thick line
    								    
    //line cpu-reg						    //line cpu-reg
    canvasH.drawLine(100,205, 100,210);				    canvasH.drawLine(100,205, 100,210);
  }								  }
}								}
//**************** end *************************************	//**************** end *************************************

import  java.awt.*;						import  java.awt.*;
import java.util.Vector;					import java.util.Vector;
import java.util.StringTokenizer;				import java.util.StringTokenizer;
//import Rectangle;					      |	import Rectangle;

class InterCanvas extends Canvas implements Runnable{		class InterCanvas extends Canvas implements Runnable{
  								  
  private Font font;						  private Font font;
  private FontMetrics fm;					  private FontMetrics fm;

  private Color groundfillColor = 				  private Color groundfillColor = 
  new Color((float)0.4375,(float)0.8125,(float)0.8125);		  new Color((float)0.4375,(float)0.8125,(float)0.8125);
  								  
  private Color fillColor = 					  private Color fillColor = 
  new Color((float)0.625,(float)0.8125,(float)0.8125);		  new Color((float)0.625,(float)0.8125,(float)0.8125);
  								  
  private Color backgr = 					  private Color backgr = 
  new Color((float)0.86,(float)0.86,(float)0.86);		  new Color((float)0.86,(float)0.86,(float)0.86);
  								  
  								  
  public Vector inter_vec = new Vector(); //holds rectangles 	  public Vector inter_vec = new Vector(); //holds rectangles 
  								  
  public final int UNDEF = -1,  //constants to define  		  public final int UNDEF = -1,  //constants to define  
    R_HIT = 0,              //the mode or rectangle		    R_HIT = 0,              //the mode or rectangle
    R_MISS_TH = 1,          //purpose				    R_MISS_TH = 1,          //purpose
    R_MISS_NoTH = 2,						    R_MISS_NoTH = 2,
    W_HIT_TH= 3,						    W_HIT_TH= 3,
    W_HIT_BACK = 4,						    W_HIT_BACK = 4,
    W_MISS_ALLOC = 5,						    W_MISS_ALLOC = 5,
    W_MISS_NoALLOC = 6;						    W_MISS_NoALLOC = 6;

  public int mode = UNDEF;  //mode in which to run animation	  public int mode = UNDEF;  //mode in which to run animation
  private final boolean SOLID = true,				  private final boolean SOLID = true,
    DIM = false; 						    DIM = false; 
  private final int CPU = 30,					  private final int CPU = 30,
      CACHE =10, 						      CACHE =10, 
      MEMORY = 20;						      MEMORY = 20;
  								  
  int my_width = 600;      //width of the canvas		  int my_width = 600;      //width of the canvas
  int my_height = 400;     //height of the canvas		  int my_height = 400;     //height of the canvas
  int x_write_start = 300; //base for "write" scheme		  int x_write_start = 300; //base for "write" scheme
  int x_read_start = 10;   //base for "read" scheme		  int x_read_start = 10;   //base for "read" scheme
  								  
  //base for CPU box						  //base for CPU box
  int xb = 50;            //x base for cpu-memory part		  int xb = 50;            //x base for cpu-memory part
  int yb = 200;           //y base				  int yb = 200;           //y base
  int cpu_width = 100;    //cpu box width			  int cpu_width = 100;    //cpu box width
  int cpu_height = 100;   //cpu box height			  int cpu_height = 100;   //cpu box height
  int distance = 50;      //distance between boxes		  int distance = 50;      //distance between boxes
  								  
  //base for cache box						  //base for cache box
  int x_cache = xb + cpu_width + distance;     			  int x_cache = xb + cpu_width + distance;     
  int y_cache = yb;						  int y_cache = yb;
  int cache_width = 100 ,cache_height = 120;			  int cache_width = 100 ,cache_height = 120;
  								  
  //base for main memory box					  //base for main memory box
  int x_mem = x_cache + cache_width + distance;			  int x_mem = x_cache + cache_width + distance;
  int y_mem = yb;						  int y_mem = yb;
  int mem_width = 100 ,mem_height = 150;			  int mem_width = 100 ,mem_height = 150;

  //block found in cache					  //block found in cache
  int bl_width = cache_width-20;				  int bl_width = cache_width-20;
  int bl_height = 20;						  int bl_height = 20;
  int x_read_hit_bl=x_cache+10;					  int x_read_hit_bl=x_cache+10;
  int y_read_hit_bl = y_cache+cache_height-bl_height-20;	  int y_read_hit_bl = y_cache+cache_height-bl_height-20;

  //block found in memory					  //block found in memory
  int x_read_miss_bl=x_mem+10;					  int x_read_miss_bl=x_mem+10;
  int y_read_miss_bl = y_mem+mem_height-bl_height-20;		  int y_read_miss_bl = y_mem+mem_height-bl_height-20;
  								  
  //*********************************************************	  //*********************************************************
  InterCanvas(){						  InterCanvas(){
    super();							    super();
    setBackground(backgr);					    setBackground(backgr);
    font = new Font("TimesRoman", Font.BOLD, 14);		    font = new Font("TimesRoman", Font.BOLD, 14);
    fm = getFontMetrics(font);					    fm = getFontMetrics(font);
    setFont(font);						    setFont(font);
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public synchronized void paint( Graphics g){			  public synchronized void paint( Graphics g){
    int strWidth = fm.stringWidth("WRITE");			    int strWidth = fm.stringWidth("WRITE");
    int x_median1 = x_write_start +				    int x_median1 = x_write_start +
      (my_width - x_write_start)/2;				      (my_width - x_write_start)/2;
    int x_strPos = x_median1 - strWidth/2;			    int x_strPos = x_median1 - strWidth/2;
    int y_strPos = 30;						    int y_strPos = 30;
    int line_down = 10;						    int line_down = 10;
    int y_line_down = y_strPos+5+line_down;			    int y_line_down = y_strPos+5+line_down;
    								    
    g.drawString("WRITE", x_strPos, y_strPos);			    g.drawString("WRITE", x_strPos, y_strPos);
    g.drawLine(x_median1,y_strPos+5,				    g.drawLine(x_median1,y_strPos+5,
	       x_median1,y_line_down);					       x_median1,y_line_down);
    int x_median2 = x_write_start + (x_median1 - x_write_star	    int x_median2 = x_write_start + (x_median1 - x_write_star
    int x_median2_end = x_median2+x_median1-x_write_start;	    int x_median2_end = x_median2+x_median1-x_write_start;

    //horis line						    //horis line
    g.drawLine(x_median2, y_line_down, 				    g.drawLine(x_median2, y_line_down, 
	       x_median2_end , y_line_down);				       x_median2_end , y_line_down);
    //vert lines						    //vert lines
    g.drawLine(x_median2,y_line_down,x_median2,y_line_down+li	    g.drawLine(x_median2,y_line_down,x_median2,y_line_down+li
    g.drawLine(x_median2_end ,y_line_down,			    g.drawLine(x_median2_end ,y_line_down,
	       x_median2_end ,y_line_down+line_down);			       x_median2_end ,y_line_down+line_down);
    								    
    //hit , miss						    //hit , miss
    strWidth = fm.stringWidth("hit");				    strWidth = fm.stringWidth("hit");
    								    
    y_strPos = y_line_down+line_down+15;			    y_strPos = y_line_down+line_down+15;
    y_line_down = y_strPos+5+line_down;				    y_line_down = y_strPos+5+line_down;
    								    
    g.drawString("hit", x_median2-strWidth/2,y_strPos);		    g.drawString("hit", x_median2-strWidth/2,y_strPos);
    								    
    strWidth = fm.stringWidth("miss");				    strWidth = fm.stringWidth("miss");
    g.drawString("miss", x_median2_end-strWidth/2,		    g.drawString("miss", x_median2_end-strWidth/2,
		 y_strPos);							 y_strPos);
    int box_width = x_median2 - x_write_start;			    int box_width = x_median2 - x_write_start;
    								    
    //~~~~~~~~~~~~~~~~~~~~~					    //~~~~~~~~~~~~~~~~~~~~~
    g.drawLine(x_median2,y_strPos+5,				    g.drawLine(x_median2,y_strPos+5,
	       x_median2,y_line_down);					       x_median2,y_line_down);
    int x_median3 = x_write_start + (x_median2 - x_write_star	    int x_median3 = x_write_start + (x_median2 - x_write_star
    int x_median3_end = x_median3+x_median2-x_write_start;	    int x_median3_end = x_median3+x_median2-x_write_start;

    //horis line						    //horis line
    g.drawLine(x_median3, y_line_down, 				    g.drawLine(x_median3, y_line_down, 
	       x_median3_end , y_line_down);				       x_median3_end , y_line_down);
    //vert lines						    //vert lines
    g.drawLine(x_median3,y_line_down,x_median3,y_line_down+li	    g.drawLine(x_median3,y_line_down,x_median3,y_line_down+li
    g.drawLine(x_median3_end ,y_line_down,			    g.drawLine(x_median3_end ,y_line_down,
	       x_median3_end ,y_line_down+line_down);			       x_median3_end ,y_line_down+line_down);

    //boxes for hit						    //boxes for hit
    								    
    DrawBox(x_median3-(box_width-10)/2,y_line_down+line_down,	    DrawBox(x_median3-(box_width-10)/2,y_line_down+line_down,
	    box_width-10, box_width - 10,				    box_width-10, box_width - 10,
	    TranslateStr(W_HIT_TH), Color.white);			    TranslateStr(W_HIT_TH), Color.white);
    DrawBox(x_median3_end-(box_width-10)/2,y_line_down+line_d	    DrawBox(x_median3_end-(box_width-10)/2,y_line_down+line_d
	    box_width-10, box_width - 10,				    box_width-10, box_width - 10,
	    TranslateStr(W_HIT_BACK), Color.white);			    TranslateStr(W_HIT_BACK), Color.white);
    								    
    								    
    //create an Rectangle Object				    //create an Rectangle Object
    Rectangle r = new Rectangle(x_median3-(box_width-10)/2,	    Rectangle r = new Rectangle(x_median3-(box_width-10)/2,
				y_line_down+line_down+box_wid					y_line_down+line_down+box_wid
				box_width-10, box_width - 10,					box_width-10, box_width - 10,
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(x_median3_end-(box_width-10)/2,		    r = new Rectangle(x_median3_end-(box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      box_width-10, box_width - 10, W_HIT_BAC			      box_width-10, box_width - 10, W_HIT_BAC
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    								    
    //~~~~~~~~~~~~~~~~~						    //~~~~~~~~~~~~~~~~~
    g.drawLine(x_median2_end,y_strPos+5,			    g.drawLine(x_median2_end,y_strPos+5,
	       x_median2_end,y_line_down);				       x_median2_end,y_line_down);
    int x_median4 = x_median1 + (x_median2_end - x_median1)/2	    int x_median4 = x_median1 + (x_median2_end - x_median1)/2
    								    
    int x_median4_end = x_median4+x_median2_end - x_median1;	    int x_median4_end = x_median4+x_median2_end - x_median1;

    //horis line						    //horis line
    g.drawLine(x_median4, y_line_down, 				    g.drawLine(x_median4, y_line_down, 
	       x_median4_end , y_line_down);				       x_median4_end , y_line_down);
    //vert lines						    //vert lines
    g.drawLine(x_median4,y_line_down,x_median4,y_line_down+li	    g.drawLine(x_median4,y_line_down,x_median4,y_line_down+li
    g.drawLine(x_median4_end ,y_line_down,			    g.drawLine(x_median4_end ,y_line_down,
	       x_median4_end ,y_line_down+line_down);			       x_median4_end ,y_line_down+line_down);

    //boxes for miss						    //boxes for miss
    DrawBox(x_median4-(box_width-10)/2,y_line_down+line_down,	    DrawBox(x_median4-(box_width-10)/2,y_line_down+line_down,
	    box_width-10, box_width - 10,				    box_width-10, box_width - 10,
	    TranslateStr(W_MISS_ALLOC), Color.white);			    TranslateStr(W_MISS_ALLOC), Color.white);
    DrawBox(x_median4_end-(box_width-10)/2,y_line_down+line_d	    DrawBox(x_median4_end-(box_width-10)/2,y_line_down+line_d
	    box_width-10, box_width - 10,				    box_width-10, box_width - 10,
	    TranslateStr(W_MISS_NoALLOC), Color.white);			    TranslateStr(W_MISS_NoALLOC), Color.white);
    								    
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(x_median4-(box_width-10)/2,		    r = new Rectangle(x_median4-(box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      box_width-10, box_width - 10, W_MISS_AL			      box_width-10, box_width - 10, W_MISS_AL
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    								    
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(x_median4_end-(box_width-10)/2,		    r = new Rectangle(x_median4_end-(box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      box_width-10, box_width - 10, W_MISS_No			      box_width-10, box_width - 10, W_MISS_No
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    								    
    //~~~~~~~~~~~~~~~~~~~~~					    //~~~~~~~~~~~~~~~~~~~~~
    strWidth = fm.stringWidth("READ");				    strWidth = fm.stringWidth("READ");
    								    
    int xr_median1 =  x_read_start+(x_write_start - x_read_st	    int xr_median1 =  x_read_start+(x_write_start - x_read_st
    x_strPos = xr_median1 - strWidth/2;				    x_strPos = xr_median1 - strWidth/2;
    y_strPos = 30;						    y_strPos = 30;
    line_down = 10;						    line_down = 10;
    y_line_down = y_strPos+5+line_down;				    y_line_down = y_strPos+5+line_down;
    								    
    g.drawString("READ", x_strPos, y_strPos);			    g.drawString("READ", x_strPos, y_strPos);
    g.drawLine(xr_median1,y_strPos+5,				    g.drawLine(xr_median1,y_strPos+5,
	       xr_median1,y_line_down);					       xr_median1,y_line_down);
    int xr_median2 = x_read_start + (xr_median1 - x_read_star	    int xr_median2 = x_read_start + (xr_median1 - x_read_star
    int xr_median2_end = xr_median2+xr_median1-x_read_start;	    int xr_median2_end = xr_median2+xr_median1-x_read_start;

    //horis line						    //horis line
    g.drawLine(xr_median2, y_line_down, 			    g.drawLine(xr_median2, y_line_down, 
	       xr_median2_end , y_line_down);				       xr_median2_end , y_line_down);
    //vert lines						    //vert lines
    g.drawLine(xr_median2,y_line_down,xr_median2,y_line_down+	    g.drawLine(xr_median2,y_line_down,xr_median2,y_line_down+
    g.drawLine(xr_median2_end ,y_line_down,			    g.drawLine(xr_median2_end ,y_line_down,
	       xr_median2_end ,y_line_down+line_down);			       xr_median2_end ,y_line_down+line_down);
    								    
    //hit , miss						    //hit , miss
    								    
    strWidth = fm.stringWidth("hit");				    strWidth = fm.stringWidth("hit");
    								    
    y_strPos = y_line_down+line_down+15;			    y_strPos = y_line_down+line_down+15;
    y_line_down = y_strPos+5+line_down;				    y_line_down = y_strPos+5+line_down;
    								    
    g.drawString("hit", xr_median2-strWidth/2,y_strPos);	    g.drawString("hit", xr_median2-strWidth/2,y_strPos);
    								    
    strWidth = fm.stringWidth("miss");				    strWidth = fm.stringWidth("miss");
    g.drawString("miss", xr_median2_end-strWidth/2,		    g.drawString("miss", xr_median2_end-strWidth/2,
		 y_strPos);							 y_strPos);
    int r_box_width = xr_median2 - x_read_start;		    int r_box_width = xr_median2 - x_read_start;
    								    
    //~~~~~~~~~~~~~~~~~~~~~					    //~~~~~~~~~~~~~~~~~~~~~
    								    
    g.drawLine(xr_median2,y_strPos+5,				    g.drawLine(xr_median2,y_strPos+5,
	       xr_median2,y_line_down+line_down);			       xr_median2,y_line_down+line_down);
    //box for hit						    //box for hit
    DrawBox(xr_median2-(r_box_width-10)/2,y_line_down+line_do	    DrawBox(xr_median2-(r_box_width-10)/2,y_line_down+line_do
	    r_box_width-10, box_width - 10,				    r_box_width-10, box_width - 10,
	    TranslateStr(R_HIT), Color.white);				    TranslateStr(R_HIT), Color.white);
    								    
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(xr_median2-(r_box_width-10)/2,		    r = new Rectangle(xr_median2-(r_box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      r_box_width-10, box_width - 10, R_HIT);			      r_box_width-10, box_width - 10, R_HIT);
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    								    
    //~~~~~~~~~~~~~~~~~						    //~~~~~~~~~~~~~~~~~
    g.drawLine(xr_median2_end,y_strPos+5,			    g.drawLine(xr_median2_end,y_strPos+5,
	       xr_median2_end,y_line_down);				       xr_median2_end,y_line_down);
    int xr_median4 = xr_median1 + (xr_median2_end - xr_median	    int xr_median4 = xr_median1 + (xr_median2_end - xr_median
    								    
    int xr_median4_end = xr_median4+xr_median2_end - xr_media	    int xr_median4_end = xr_median4+xr_median2_end - xr_media

    //horis line						    //horis line
    g.drawLine(xr_median4, y_line_down, 			    g.drawLine(xr_median4, y_line_down, 
	       xr_median4_end , y_line_down);				       xr_median4_end , y_line_down);
    //vert lines						    //vert lines
    g.drawLine(xr_median4,y_line_down,xr_median4,y_line_down+	    g.drawLine(xr_median4,y_line_down,xr_median4,y_line_down+
    g.drawLine(xr_median4_end ,y_line_down,			    g.drawLine(xr_median4_end ,y_line_down,
	       xr_median4_end ,y_line_down+line_down);			       xr_median4_end ,y_line_down+line_down);

    //boxes for miss						    //boxes for miss
    DrawBox(xr_median4-(r_box_width-10)/2,y_line_down+line_do	    DrawBox(xr_median4-(r_box_width-10)/2,y_line_down+line_do
	    r_box_width-10, box_width - 10,				    r_box_width-10, box_width - 10,
	    TranslateStr(R_MISS_TH), Color.white);			    TranslateStr(R_MISS_TH), Color.white);
    DrawBox(xr_median4_end-(r_box_width-10)/2,y_line_down+lin	    DrawBox(xr_median4_end-(r_box_width-10)/2,y_line_down+lin
	    r_box_width-10, box_width - 10,				    r_box_width-10, box_width - 10,
	    TranslateStr(R_MISS_NoTH), Color.white);			    TranslateStr(R_MISS_NoTH), Color.white);
    								    
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(xr_median4-(r_box_width-10)/2,		    r = new Rectangle(xr_median4-(r_box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      r_box_width-10, box_width - 10, R_MISS_			      r_box_width-10, box_width - 10, R_MISS_
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    //create an Rectangle Object				    //create an Rectangle Object
    r = new Rectangle(xr_median4_end-(r_box_width-10)/2,	    r = new Rectangle(xr_median4_end-(r_box_width-10)/2,
		      y_line_down+line_down+box_width-10,			      y_line_down+line_down+box_width-10,
		      r_box_width-10, box_width - 10, R_MISS_			      r_box_width-10, box_width - 10, R_MISS_
    inter_vec.addElement(r);					    inter_vec.addElement(r);
    								    
    DrawMemoryStructure();					    DrawMemoryStructure();
  }								  }
  								  
  //***************************************************		  //***************************************************
  public void update(Graphics g){				  public void update(Graphics g){
    paint(g);							    paint(g);
  }								  }

  //***************************************************		  //***************************************************
  public void DrawMemoryStructure(){				  public void DrawMemoryStructure(){
    								    
    Graphics g = getGraphics(); 				    Graphics g = getGraphics(); 
    //cpu							    //cpu
    DrawCPU();							    DrawCPU();

    //cache    							    //cache    
    DrawCache();						    DrawCache();

    //main mem							    //main mem
    DrawMemory();						    DrawMemory();
    								    
    //line cpu-cache						    //line cpu-cache
    g.drawLine(xb+cpu_width,yb+30, x_cache,yb+30);		    g.drawLine(xb+cpu_width,yb+30, x_cache,yb+30);
    g.drawLine(xb+cpu_width,yb+30-1, x_cache,yb+30-1);//for t	    g.drawLine(xb+cpu_width,yb+30-1, x_cache,yb+30-1);//for t
    g.drawLine(xb+cpu_width,yb+30+1, x_cache,yb+30+1);//for t	    g.drawLine(xb+cpu_width,yb+30+1, x_cache,yb+30+1);//for t
    								    
    //line cache-main mem					    //line cache-main mem
    g.drawLine(x_cache+cache_width,yb+30,x_mem,yb+30);		    g.drawLine(x_cache+cache_width,yb+30,x_mem,yb+30);
    g.drawLine(x_cache+cache_width,yb+30-1,x_mem,yb+30-1);//f	    g.drawLine(x_cache+cache_width,yb+30-1,x_mem,yb+30-1);//f
    g.drawLine(x_cache+cache_width,yb+30+1,x_mem,yb+30+1);//f	    g.drawLine(x_cache+cache_width,yb+30+1,x_mem,yb+30+1);//f
  }								  }
  								  
  //*************************************************		  //*************************************************
  public void run(){						  public void run(){
    switch(mode){						    switch(mode){
    case R_HIT:							    case R_HIT:
      ReadHitAnim();						      ReadHitAnim();
      break;							      break;
    case R_MISS_TH:						    case R_MISS_TH:
      ReadMissThroughAnim();					      ReadMissThroughAnim();
      break;							      break;
    case R_MISS_NoTH:						    case R_MISS_NoTH:
      ReadMissNoThroughAnim();					      ReadMissNoThroughAnim();
      break;							      break;
    case W_HIT_TH:						    case W_HIT_TH:
      WriteHitThroughAnim();					      WriteHitThroughAnim();
      break;							      break;
    case W_HIT_BACK:						    case W_HIT_BACK:
      WriteHitBackAnim();					      WriteHitBackAnim();
      break;							      break;
    case W_MISS_ALLOC:						    case W_MISS_ALLOC:
      WriteMissAllocAnim();					      WriteMissAllocAnim();
      break;							      break;
    case W_MISS_NoALLOC:					    case W_MISS_NoALLOC:
      WriteMissNoAllocAnim();					      WriteMissNoAllocAnim();
      break;							      break;
    default:							    default:
      System.out.println("Error: mode " + mode + " is not rec	      System.out.println("Error: mode " + mode + " is not rec
    }								    }
  }								  }

  //*************************************************		  //*************************************************
  private void ReadHitAnim(){					  private void ReadHitAnim(){
    System.out.println("ReadHitAnim running");			    System.out.println("ReadHitAnim running");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"found");					    Found(CACHE,SOLID,"found");
    Drag(x_read_hit_bl, y_read_hit_bl,				    Drag(x_read_hit_bl, y_read_hit_bl,
	 xb+10, yb+cpu_height-30);					 xb+10, yb+cpu_height-30);
    Found(CACHE,DIM,"found");					    Found(CACHE,DIM,"found");
  }								  }

  //*************************************************		  //*************************************************
  private void ReadMissThroughAnim(){				  private void ReadMissThroughAnim(){
    System.out.println("ReadMissThroughAnim running");		    System.out.println("ReadMissThroughAnim running");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"not found");				    Found(CACHE,SOLID,"not found");
    Search(MEMORY);						    Search(MEMORY);
    Found(MEMORY,SOLID,"found");				    Found(MEMORY,SOLID,"found");
    Drag(x_read_miss_bl, y_read_miss_bl,			    Drag(x_read_miss_bl, y_read_miss_bl,
	 xb+10, yb+cpu_height-30);    					 xb+10, yb+cpu_height-30);    
    Found(MEMORY,DIM,"found");					    Found(MEMORY,DIM,"found");
    Found(CACHE,DIM,"transfered");				    Found(CACHE,DIM,"transfered");
    								    
    //line from memory to CPU direct				    //line from memory to CPU direct
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    g.drawLine(x_mem, y_mem+mem_height -10, 			    g.drawLine(x_mem, y_mem+mem_height -10, 
	       xb + cpu_width/2, y_mem+mem_height -10);			       xb + cpu_width/2, y_mem+mem_height -10);
    g.drawLine(xb + cpu_width/2, y_mem+mem_height -10,		    g.drawLine(xb + cpu_width/2, y_mem+mem_height -10,
	       xb + cpu_width/2, yb+cpu_height);			       xb + cpu_width/2, yb+cpu_height);
    //arrow							    //arrow
    g.drawLine(xb + cpu_width/2-3, yb+cpu_height+7,		    g.drawLine(xb + cpu_width/2-3, yb+cpu_height+7,
	       xb + cpu_width/2, yb+cpu_height);			       xb + cpu_width/2, yb+cpu_height);
    g.drawLine(xb + cpu_width/2+3, yb+cpu_height+7,		    g.drawLine(xb + cpu_width/2+3, yb+cpu_height+7,
	       xb + cpu_width/2, yb+cpu_height);			       xb + cpu_width/2, yb+cpu_height);
  }								  }

  //*************************************************		  //*************************************************
  private void ReadMissNoThroughAnim(){				  private void ReadMissNoThroughAnim(){
    System.out.println("ReadMissNoThroughAnim running");	    System.out.println("ReadMissNoThroughAnim running");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"not found");				    Found(CACHE,SOLID,"not found");
    Search(MEMORY);						    Search(MEMORY);
    Found(MEMORY,SOLID,"found");				    Found(MEMORY,SOLID,"found");
    Drag(x_read_miss_bl, y_read_miss_bl,			    Drag(x_read_miss_bl, y_read_miss_bl,
	 x_read_hit_bl, y_read_hit_bl);    				 x_read_hit_bl, y_read_hit_bl);    
    Found(MEMORY,DIM,"found");					    Found(MEMORY,DIM,"found");
    Drag(x_read_hit_bl, y_read_hit_bl,				    Drag(x_read_hit_bl, y_read_hit_bl,
	 xb+10, yb+cpu_height-30);    					 xb+10, yb+cpu_height-30);    
    Found(MEMORY,DIM,"found");					    Found(MEMORY,DIM,"found");
    Found(CACHE,DIM,"stored");					    Found(CACHE,DIM,"stored");
  }								  }
  								  
  //*************************************************		  //*************************************************
  private void WriteHitThroughAnim(){				  private void WriteHitThroughAnim(){
    System.out.println("WriteHitThroughAnim running");		    System.out.println("WriteHitThroughAnim running");
    Found(CPU,SOLID,"to write");				    Found(CPU,SOLID,"to write");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"found");					    Found(CACHE,SOLID,"found");
    Drag(xb+10, yb+cpu_height-30,				    Drag(xb+10, yb+cpu_height-30,
         x_read_hit_bl, y_read_hit_bl );			         x_read_hit_bl, y_read_hit_bl );
    Found(CACHE,DIM,"updated");					    Found(CACHE,DIM,"updated");
    Drag(x_read_hit_bl, y_read_hit_bl,				    Drag(x_read_hit_bl, y_read_hit_bl,
         x_read_miss_bl, y_read_miss_bl );			         x_read_miss_bl, y_read_miss_bl );
    Found(CPU,DIM,"to write");					    Found(CPU,DIM,"to write");
    Found(CACHE,DIM,"updated");					    Found(CACHE,DIM,"updated");
    Found(MEMORY,SOLID,"updated");				    Found(MEMORY,SOLID,"updated");
  }								  }

  //*************************************************		  //*************************************************
  private void WriteHitBackAnim(){				  private void WriteHitBackAnim(){
    System.out.println("WriteHitBackAnim running");		    System.out.println("WriteHitBackAnim running");
    Found(CPU,SOLID,"to write");				    Found(CPU,SOLID,"to write");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"found");					    Found(CACHE,SOLID,"found");
    Drag(xb+10, yb+cpu_height-30,				    Drag(xb+10, yb+cpu_height-30,
         x_read_hit_bl, y_read_hit_bl );			         x_read_hit_bl, y_read_hit_bl );
    Found(CPU,DIM,"to write");					    Found(CPU,DIM,"to write");
    Found(CACHE,SOLID,"dirty");					    Found(CACHE,SOLID,"dirty");
  }								  }
  								  
  //*************************************************		  //*************************************************
  private void WriteMissAllocAnim(){				  private void WriteMissAllocAnim(){
    System.out.println("WriteMissAllocAnim running");		    System.out.println("WriteMissAllocAnim running");
    Found(CPU,SOLID,"to write");				    Found(CPU,SOLID,"to write");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"not found");				    Found(CACHE,SOLID,"not found");
    Search(MEMORY);						    Search(MEMORY);
    Found(MEMORY,SOLID,"found");				    Found(MEMORY,SOLID,"found");
    Drag(x_read_miss_bl, y_read_miss_bl,			    Drag(x_read_miss_bl, y_read_miss_bl,
	 x_read_hit_bl, y_read_hit_bl);    				 x_read_hit_bl, y_read_hit_bl);    
    Found(CPU,DIM,"to write");					    Found(CPU,DIM,"to write");
    Found(CACHE,DIM,"transfered");				    Found(CACHE,DIM,"transfered");
    Found(MEMORY,DIM,"found");					    Found(MEMORY,DIM,"found");
    Drag(xb+10, yb+cpu_height-30,				    Drag(xb+10, yb+cpu_height-30,
         x_read_hit_bl, y_read_hit_bl);    			         x_read_hit_bl, y_read_hit_bl);    
    Found(MEMORY,DIM,"updated");				    Found(MEMORY,DIM,"updated");
    Found(CPU,DIM,"to write");					    Found(CPU,DIM,"to write");
    Found(CACHE,SOLID,"updated");				    Found(CACHE,SOLID,"updated");
  }								  }

  //*************************************************		  //*************************************************
  private void WriteMissNoAllocAnim(){				  private void WriteMissNoAllocAnim(){
    System.out.println("WriteMissNoAllocAnim running");		    System.out.println("WriteMissNoAllocAnim running");
    Found(CPU,SOLID,"to write");				    Found(CPU,SOLID,"to write");
    Search(CACHE);						    Search(CACHE);
    Found(CACHE,SOLID,"not found");				    Found(CACHE,SOLID,"not found");
    Search(MEMORY);						    Search(MEMORY);
    Found(MEMORY,SOLID,"found");				    Found(MEMORY,SOLID,"found");
    Drag(xb+10, yb+cpu_height-30,				    Drag(xb+10, yb+cpu_height-30,
         x_read_miss_bl, y_read_miss_bl);    			         x_read_miss_bl, y_read_miss_bl);    
    Found(MEMORY,SOLID,"updated");				    Found(MEMORY,SOLID,"updated");
    Found(CPU,DIM,"to write");					    Found(CPU,DIM,"to write");
    Found(CACHE,DIM,"not found");				    Found(CACHE,DIM,"not found");
  }								  }
  								  
  //*************************************************		  //*************************************************
  private void  Search(int box){				  private void  Search(int box){
    int x=0, y=0,h=0,w=0;					    int x=0, y=0,h=0,w=0;
    int desh = 5;						    int desh = 5;
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    								    
    if (box == CACHE) {						    if (box == CACHE) {
      x=x_cache;						      x=x_cache;
      y=y_cache;						      y=y_cache;
      h= cache_height;						      h= cache_height;
      w = cache_width;						      w = cache_width;
    }else if (box == MEMORY){					    }else if (box == MEMORY){
      x= x_mem;							      x= x_mem;
      y= y_mem;							      y= y_mem;
      h=mem_height;						      h=mem_height;
      w = mem_width;						      w = mem_width;
    }								    }
    								    
    Color prev = g.getColor();					    Color prev = g.getColor();
    g.drawString("search",x+15, y+15);				    g.drawString("search",x+15, y+15);
    try{ Thread.sleep(200);}catch(InterruptedException e){}	    try{ Thread.sleep(200);}catch(InterruptedException e){}
    								    
    g.setColor(Color.red);					    g.setColor(Color.red);
    								    
    for (int j = 0; j<10; j++){					    for (int j = 0; j<10; j++){
      int y_temp = y+h/10; 					      int y_temp = y+h/10; 
      for (int k = 1; k<(h/10); k++){				      for (int k = 1; k<(h/10); k++){
	int x_temp = x;							int x_temp = x;
									
	for (int i = 0; i<w/(2*desh); i++){				for (int i = 0; i<w/(2*desh); i++){
	  g.drawLine( x_temp, y_temp, x_temp+desh, y_temp);		  g.drawLine( x_temp, y_temp, x_temp+desh, y_temp);
	  x_temp+= 2*desh; 						  x_temp+= 2*desh; 
	}								}
	y_temp+=10;							y_temp+=10;
      }								      }
      try{ Thread.sleep(100);}catch(InterruptedException e){}	      try{ Thread.sleep(100);}catch(InterruptedException e){}
      if (box ==CACHE) DrawCache();				      if (box ==CACHE) DrawCache();
      else if (box == MEMORY) DrawMemory();			      else if (box == MEMORY) DrawMemory();
      try{ Thread.sleep(100);}catch(InterruptedException e){}	      try{ Thread.sleep(100);}catch(InterruptedException e){}
      								      
    }								    }
    g.setColor(prev);						    g.setColor(prev);
  }								  }

  //*************************************************		  //*************************************************
  private void Found(int box, boolean Appearence,		  private void Found(int box, boolean Appearence,
                 String str){					                 String str){
    int x=0, y=0;						    int x=0, y=0;
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    								    
    if (box == CACHE) {						    if (box == CACHE) {
      x=x_read_hit_bl;						      x=x_read_hit_bl;
      y=y_read_hit_bl;						      y=y_read_hit_bl;
    }else if (box == MEMORY){					    }else if (box == MEMORY){
      x= x_read_miss_bl;					      x= x_read_miss_bl;
      y= y_read_miss_bl;					      y= y_read_miss_bl;
    }else if (box == CPU){					    }else if (box == CPU){
      x= xb+10;							      x= xb+10;
      y= yb+cpu_height-30;					      y= yb+cpu_height-30;
    }								    }
    								    
    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(x,y,bl_width, bl_height);			    g.fillRect(x,y,bl_width, bl_height);
    g.setColor(Color.black);					    g.setColor(Color.black);
    if (Appearence == SOLID)					    if (Appearence == SOLID)
      g.drawRect(x, y, bl_width, bl_height);			      g.drawRect(x, y, bl_width, bl_height);
    else if (Appearence == DIM){				    else if (Appearence == DIM){
      int  shtrich = 2;						      int  shtrich = 2;

      for (int i=x; i< x+bl_width; i+=2*shtrich) 		      for (int i=x; i< x+bl_width; i+=2*shtrich) 
        g.drawLine(i, y ,i+shtrich,y);				        g.drawLine(i, y ,i+shtrich,y);
      for (int i=x; i< x+bl_width; i+=2*shtrich) 		      for (int i=x; i< x+bl_width; i+=2*shtrich) 
        g.drawLine(i,y+bl_height,i+shtrich,y+bl_height);	        g.drawLine(i,y+bl_height,i+shtrich,y+bl_height);
      for (int i=y; i< y+bl_height; i+=2*shtrich) 		      for (int i=y; i< y+bl_height; i+=2*shtrich) 
        g.drawLine(x, i ,x,i+shtrich);				        g.drawLine(x, i ,x,i+shtrich);
      for (int i=y; i< y+bl_height; i+=2*shtrich) 		      for (int i=y; i< y+bl_height; i+=2*shtrich) 
        g.drawLine(x+bl_width, i ,x+bl_width,i+shtrich);	        g.drawLine(x+bl_width, i ,x+bl_width,i+shtrich);
    }								    }
    //center the string						    //center the string
    int len = fm.stringWidth(str);				    int len = fm.stringWidth(str);
    g.drawString(str, x+bl_width/2-len/2,y+15);			    g.drawString(str, x+bl_width/2-len/2,y+15);

    try{ Thread.sleep(250);}catch(InterruptedException e){}  	    try{ Thread.sleep(250);}catch(InterruptedException e){}  
  }								  }

  //*************************************************		  //*************************************************
  private void Drag(int x_start,int y_start,			  private void Drag(int x_start,int y_start,
		    int x_finish, int y_finish){				    int x_finish, int y_finish){
    //System.out.println("Dragging now");			    //System.out.println("Dragging now");

    int num_iter = 10;						    int num_iter = 10;

    int x_path = x_start - x_finish;				    int x_path = x_start - x_finish;
    int y_path = y_start - y_finish;				    int y_path = y_start - y_finish;
    int x_delta = x_path/num_iter;				    int x_delta = x_path/num_iter;
    int y_delta = y_path/num_iter;				    int y_delta = y_path/num_iter;
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    int x_cur=x_start,						    int x_cur=x_start,
      y_cur=y_start;						      y_cur=y_start;

    for (int i = 0; i<=num_iter; i++){				    for (int i = 0; i<=num_iter; i++){
      //draw moving block					      //draw moving block
      g.setColor(fillColor);					      g.setColor(fillColor);
      g.fillRect(x_cur, y_cur, bl_width, bl_height);		      g.fillRect(x_cur, y_cur, bl_width, bl_height);
      								      
      g.setColor(Color.black);					      g.setColor(Color.black);
      g.drawRect(x_cur, y_cur, bl_width, bl_height); 		      g.drawRect(x_cur, y_cur, bl_width, bl_height); 
      								      
    								    
      //sleep for a while					      //sleep for a while
      try{Thread.sleep(100);}catch(InterruptedException e){}	      try{Thread.sleep(100);}catch(InterruptedException e){}
      								      
      //clear moving block area					      //clear moving block area
      g.setColor(backgr);					      g.setColor(backgr);
      g.fillRect(x_cur, y_cur, bl_width+2, bl_height+2);//2 f	      g.fillRect(x_cur, y_cur, bl_width+2, bl_height+2);//2 f
									
      //shift coordinates					      //shift coordinates
      x_cur -=x_delta;						      x_cur -=x_delta;
      y_cur -=y_delta; 						      y_cur -=y_delta; 
     								     
      g.setColor(Color.black);					      g.setColor(Color.black);
      DrawCPU();						      DrawCPU();
      DrawCache();						      DrawCache();
      DrawMemory();						      DrawMemory();
     }								     }

    g.setColor(fillColor);					    g.setColor(fillColor);
    g.fillRect(x_finish, y_finish, bl_width, bl_height);	    g.fillRect(x_finish, y_finish, bl_width, bl_height);
    								    
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(x_finish, y_finish, bl_width, bl_height);	    g.drawRect(x_finish, y_finish, bl_width, bl_height);
    g.drawString("transfered",x_finish+10,y_finish+15);		    g.drawString("transfered",x_finish+10,y_finish+15);
  }								  }
  								  
  //*************************************************		  //*************************************************
  private void DrawCPU(){					  private void DrawCPU(){
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    								    
    g.drawRect(xb,yb,cpu_width,cpu_height);			    g.drawRect(xb,yb,cpu_width,cpu_height);
    g.drawRect(xb - 1,yb - 1, 					    g.drawRect(xb - 1,yb - 1, 
	       cpu_width+2,cpu_height+2);//for thick line		       cpu_width+2,cpu_height+2);//for thick line
    g.setColor(groundfillColor);				    g.setColor(groundfillColor);
    g.fillRect(xb,yb, cpu_width,cpu_height);			    g.fillRect(xb,yb, cpu_width,cpu_height);
    								    
    //cpu label							    //cpu label
    g.setColor(Color.black);					    g.setColor(Color.black);
    //center the string						    //center the string
    int len = fm.stringWidth("CPU");				    int len = fm.stringWidth("CPU");
    g.drawString("CPU", xb+cpu_width/2-len/2,yb + 50);    	    g.drawString("CPU", xb+cpu_width/2-len/2,yb + 50);    
  }								  }

  //*************************************************		  //*************************************************
  private void DrawCache(){					  private void DrawCache(){
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    g.drawRect(x_cache,y_cache,cache_width,cache_height);	    g.drawRect(x_cache,y_cache,cache_width,cache_height);
    g.drawRect(x_cache-1,y_cache-1,				    g.drawRect(x_cache-1,y_cache-1,
	       cache_width+2,cache_height+2);//for thick line		       cache_width+2,cache_height+2);//for thick line
    g.setColor(groundfillColor);				    g.setColor(groundfillColor);
    g.fillRect(x_cache,y_cache,cache_width,cache_height);	    g.fillRect(x_cache,y_cache,cache_width,cache_height);
    								    
    //cache labels						    //cache labels
    g.setColor(Color.black);					    g.setColor(Color.black);
    //center the string						    //center the string
    int len = fm.stringWidth("Cache");				    int len = fm.stringWidth("Cache");
    g.drawString("Cache", x_cache+cache_width/2-len/2,yb+50);	    g.drawString("Cache", x_cache+cache_width/2-len/2,yb+50);
  }								  }

  //*************************************************		  //*************************************************
  private void DrawMemory(){					  private void DrawMemory(){
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    g.drawRect(x_mem,y_mem, mem_width,mem_height);		    g.drawRect(x_mem,y_mem, mem_width,mem_height);
    g.drawRect(x_mem-1,y_mem-1, 				    g.drawRect(x_mem-1,y_mem-1, 
	       mem_width+2,mem_height+2);//for thick line		       mem_width+2,mem_height+2);//for thick line
    g.setColor(groundfillColor);				    g.setColor(groundfillColor);
    g.fillRect(x_mem,y_mem, mem_width,mem_height);		    g.fillRect(x_mem,y_mem, mem_width,mem_height);
    								    
    //main mem label						    //main mem label
    g.setColor(Color.black);					    g.setColor(Color.black);
    //center the string						    //center the string
    int len = fm.stringWidth("Memory");				    int len = fm.stringWidth("Memory");
    g.drawString("Memory", x_mem+mem_width/2-len/2,y_mem+50);	    g.drawString("Memory", x_mem+mem_width/2-len/2,y_mem+50);
  }								  }

  //*************************************************		  //*************************************************
  public void Redraw(Rectangle cur, Rectangle new_r){		  public void Redraw(Rectangle cur, Rectangle new_r){
    if (cur !=null)						    if (cur !=null)
      DrawBox(cur.x, cur.y-cur.h, cur.w,cur.h,			      DrawBox(cur.x, cur.y-cur.h, cur.w,cur.h,
	      TranslateStr(cur.b),Color.white);				      TranslateStr(cur.b),Color.white);
    								    
    DrawBox(new_r.x, new_r.y-new_r.h, new_r.w,new_r.h,		    DrawBox(new_r.x, new_r.y-new_r.h, new_r.w,new_r.h,
	    TranslateStr(new_r.b),Color.gray);				    TranslateStr(new_r.b),Color.gray);
  }								  }

  //************************************			  //************************************
  private String TranslateStr(int i ){				  private String TranslateStr(int i ){
    String str = null;						    String str = null;
    								    
    switch(i){							    switch(i){
    case R_HIT:							    case R_HIT:
      str = new String(":)");					      str = new String(":)");
      break;							      break;
    case R_MISS_TH:						    case R_MISS_TH:
      str = new String("read through");				      str = new String("read through");
      break;							      break;
    case R_MISS_NoTH:						    case R_MISS_NoTH:
      str = new String("no read through");			      str = new String("no read through");
      break;							      break;
    case W_HIT_TH:						    case W_HIT_TH:
      str = new String("write through");			      str = new String("write through");
      break;							      break;
    case W_HIT_BACK:						    case W_HIT_BACK:
      str = new String("write back");				      str = new String("write back");
      break;							      break;
    case W_MISS_ALLOC:						    case W_MISS_ALLOC:
      str = new String("write allocate");			      str = new String("write allocate");
      break;							      break;
    case W_MISS_NoALLOC:					    case W_MISS_NoALLOC:
      str = new String("no write allocate");			      str = new String("no write allocate");
    }								    }
    return str;							    return str;
  }								  }
  								  
  //*************************************			  //*************************************
  private void DrawBox(int x, int y, int w, int h,		  private void DrawBox(int x, int y, int w, int h,
		       String str, Color bcgr){					       String str, Color bcgr){
    Graphics g = getGraphics();					    Graphics g = getGraphics();
    Color prev = g.getColor();					    Color prev = g.getColor();

    //redraw rect 						    //redraw rect 
    g.setColor(bcgr);						    g.setColor(bcgr);
    g.fillRect(x,y,w, h);					    g.fillRect(x,y,w, h);
    g.setColor(Color.black);					    g.setColor(Color.black);
    g.drawRect(x,y,w,h);					    g.drawRect(x,y,w,h);
    								    
    //label							    //label
    int strWidth;						    int strWidth;
    int step = 20;						    int step = 20;
    int y_strPos = y + step;					    int y_strPos = y + step;
    String temp = str;						    String temp = str;
    System.out.println("In DrawBox str = "+str);		    System.out.println("In DrawBox str = "+str);
    								    
    StringTokenizer st = new StringTokenizer(str);		    StringTokenizer st = new StringTokenizer(str);
    while (!temp.equals("through")&&				    while (!temp.equals("through")&&
	   !temp.equals("back")&&					   !temp.equals("back")&&
	   !temp.equals("allocate")&&					   !temp.equals("allocate")&&
	   !temp.equals(":)")){						   !temp.equals(":)")){
      								      
      temp = st.nextToken();					      temp = st.nextToken();
      strWidth = fm.stringWidth(temp);				      strWidth = fm.stringWidth(temp);
      g.drawString(temp, x + w/2 -strWidth/2,y_strPos);		      g.drawString(temp, x + w/2 -strWidth/2,y_strPos);
      y_strPos +=step;						      y_strPos +=step;
    }								    }
    g.setColor(prev);						    g.setColor(prev);
  }//end DrawBox						  }//end DrawBox
}								}
//**************** END *********************			//**************** END *********************

import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;
//import Rectangle;					      |	import Rectangle;
import java.util.Enumeration;					import java.util.Enumeration;
import java.util.Vector;					import java.util.Vector;

public class Inter extends Applet {				public class Inter extends Applet {
 								 
 private Button Start, Suspend, Resume, Stop; 			 private Button Start, Suspend, Resume, Stop; 
  InterCanvas c = new InterCanvas();				  InterCanvas c = new InterCanvas();
  Thread Animation_thread;					  Thread Animation_thread;
  private Rectangle cur_rec;					  private Rectangle cur_rec;
  								  
  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){
    Start = new Button("Start");				    Start = new Button("Start");
    Stop = new Button("Stop");					    Stop = new Button("Stop");
    Suspend = new Button ("Suspend");				    Suspend = new Button ("Suspend");
    Resume = new Button ("Resume");				    Resume = new Button ("Resume");
    c.resize(600,400);						    c.resize(600,400);
    add(c);							    add(c);
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public void start(){						  public void start(){
    Animation_thread = new Thread(c, "Animation_thread");	    Animation_thread = new Thread(c, "Animation_thread");
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public boolean mouseDown(Event e, int x, int y){		  public boolean mouseDown(Event e, int x, int y){
    Rectangle r = cur_rec;					    Rectangle r = cur_rec;
    //Dump(c.inter_vec, "Inter_vec");				    //Dump(c.inter_vec, "Inter_vec");
    								    
    if ((r = BelongsTo(c.inter_vec, x,y))!=null){		    if ((r = BelongsTo(c.inter_vec, x,y))!=null){
      								      
      //post event						      //post event
      System.out.println("Event #"+r.b);			      System.out.println("Event #"+r.b);
      c.mode = r.b;						      c.mode = r.b;
      if (Animation_thread !=null){				      if (Animation_thread !=null){
	Animation_thread.stop();					Animation_thread.stop();
	c.DrawMemoryStructure();					c.DrawMemoryStructure();
      }								      }
      //redraw clicked area					      //redraw clicked area
      c.Redraw(cur_rec, r);					      c.Redraw(cur_rec, r);
      								      
      Animation_thread = new Thread(c, "Animation_thread");	      Animation_thread = new Thread(c, "Animation_thread");
      Animation_thread.start();					      Animation_thread.start();
    }								    }
    								    
    cur_rec = r ;						    cur_rec = r ;
    								    
    return true;						    return true;
  }//end MoouseDown						  }//end MoouseDown
  								  
  //*********************************************************	  //*********************************************************
  public void stop(){						  public void stop(){
    if (Animation_thread != null)				    if (Animation_thread != null)
      Animation_thread.stop();					      Animation_thread.stop();
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  private Rectangle BelongsTo(Vector v, int x_down, int y_dow	  private Rectangle BelongsTo(Vector v, int x_down, int y_dow
    if ((v != null)						    if ((v != null)
	&& (!v.isEmpty())){						&& (!v.isEmpty())){
      								      
      Enumeration enum = v.elements();				      Enumeration enum = v.elements();
      								      
      while (enum.hasMoreElements()){				      while (enum.hasMoreElements()){
	Rectangle r = (Rectangle)enum.nextElement();			Rectangle r = (Rectangle)enum.nextElement();
	if (r.IsIn(x_down,y_down)) return r;				if (r.IsIn(x_down,y_down)) return r;
      }								      }
    } 								    } 
    return null;						    return null;
  }//end BelongsTo						  }//end BelongsTo
  								  
  //*********************************************************	  //*********************************************************
  private void Dump(Vector vec, String name){			  private void Dump(Vector vec, String name){
    //  System.out.println("Dump");				    //  System.out.println("Dump");
    System.out.println("vector dump for " + name);		    System.out.println("vector dump for " + name);
    if (vec != null){						    if (vec != null){
      Enumeration e = vec.elements();				      Enumeration e = vec.elements();
      while (e.hasMoreElements()){				      while (e.hasMoreElements()){
	System.out.println(e.nextElement()+"");				System.out.println(e.nextElement()+"");
      }								      }
    }								    }
  }								  }
  								  
}								}
//**************** end **************************************	//**************** end **************************************
import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;
import java.util.*;						import java.util.*;

public class PlacementApplet extends Applet {			public class PlacementApplet extends Applet {
  boolean mode = true; //true when ready to select a block in	  boolean mode = true; //true when ready to select a block in
  // false when a block is selected				  // false when a block is selected

  PlacementCanvas pl_c = new PlacementCanvas();			  PlacementCanvas pl_c = new PlacementCanvas();
  Graphics g ;							  Graphics g ;

  //*********************************************************	  //*********************************************************
  public void init(){						  public void init(){
    pl_c.resize(650,510);					    pl_c.resize(650,510);
    add(pl_c);							    add(pl_c);
    g = pl_c.getGraphics();					    g = pl_c.getGraphics();
  }								  }

  //*********************************************************	  //*********************************************************
  public void start(){						  public void start(){
    mode = true;						    mode = true;
  }								  }

  //*********************************************************	  //*********************************************************
  public boolean mouseDown(Event e, int x, int y){		  public boolean mouseDown(Event e, int x, int y){

    if ((e.modifiers & Event.META_MASK) != 0){			    if ((e.modifiers & Event.META_MASK) != 0){
      //clear to original (start all over)			      //clear to original (start all over)
      pl_c.repaint();						      pl_c.repaint();
      mode = true;						      mode = true;
    }								    }
    else{							    else{
      if (mode){						      if (mode){
									
	Rectangle r;							Rectangle r;
	if ((r = BelongsTo(pl_c.rect_vec, x,y))!=null){			if ((r = BelongsTo(pl_c.rect_vec, x,y))!=null){
	  mode = false;							  mode = false;
	  								  
	  //redraw clicked area						  //redraw clicked area
	  //	  Highlight(g, r, "frame");				  //	  Highlight(g, r, "frame");
	  Highlight(g, r, "block");					  Highlight(g, r, "block");

	  //draw block placement					  //draw block placement
	  								  
	  //direct mapped						  //direct mapped

	  //text explanation						  //text explanation
	  g.drawString("CacheSize = " + pl_c.Num_Bl_in_C,		  g.drawString("CacheSize = " + pl_c.Num_Bl_in_C,
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+pl_c.C_height + pl_c.ste			       pl_c.C_y_base+pl_c.C_height + pl_c.ste
	  g.drawString("Block Number chosen = " + r.b,			  g.drawString("Block Number chosen = " + r.b,
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+pl_c.C_height + pl_c.ste			       pl_c.C_y_base+pl_c.C_height + pl_c.ste

	  int temp1 = r.b % pl_c.Num_Bl_in_C;				  int temp1 = r.b % pl_c.Num_Bl_in_C;

	  g.drawString("Frame Number = " + 				  g.drawString("Frame Number = " + 
		       r.b +" mod " + pl_c.Num_Bl_in_C +" = "			       r.b +" mod " + pl_c.Num_Bl_in_C +" = "
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+pl_c.C_height + pl_c.ste			       pl_c.C_y_base+pl_c.C_height + pl_c.ste

	  //redraw possible placement					  //redraw possible placement
	  int dir_frame = r.b % pl_c.Num_Bl_in_C;			  int dir_frame = r.b % pl_c.Num_Bl_in_C;
	  								  
	  //find the frame to redraw					  //find the frame to redraw
	  if (pl_c.dir_rect_vec != null)				  if (pl_c.dir_rect_vec != null)
	    if (!pl_c.dir_rect_vec.isEmpty()){				    if (!pl_c.dir_rect_vec.isEmpty()){
	      Enumeration dir_enum = pl_c.dir_rect_vec.elemen		      Enumeration dir_enum = pl_c.dir_rect_vec.elemen
	      								      
	      while (dir_enum.hasMoreElements()){			      while (dir_enum.hasMoreElements()){
		Rectangle dir_r = (Rectangle)dir_enum.nextEle			Rectangle dir_r = (Rectangle)dir_enum.nextEle
										
		if (dir_frame == dir_r.b){                			if (dir_frame == dir_r.b){                
		  								  
		  //redraw							  //redraw
		  g.setColor(new Color((float)0.4375,(float)0			  g.setColor(new Color((float)0.4375,(float)0
				       (float)0.625));						       (float)0.625));
		  								  
		  g.fillRect(dir_r.x, dir_r.y - r.h, r.w, r.h			  g.fillRect(dir_r.x, dir_r.y - r.h, r.w, r.h
		  								  
		  g.setColor(Color.red);					  g.setColor(Color.red);
		  g.drawString("frame "+ dir_r.b, dir_r.x + 2			  g.drawString("frame "+ dir_r.b, dir_r.x + 2
			       dir_r.y - 5);						       dir_r.y - 5);
		  break;							  break;
		}								}
	      }//while dir_enum						      }//while dir_enum
	    }//if !pl_c...						    }//if !pl_c...
	  								  
	  //fully associative						  //fully associative
	  //redraw all in different color				  //redraw all in different color
	  pl_c.draw_fully_assoc(g,new Color((float)0.4375,		  pl_c.draw_fully_assoc(g,new Color((float)0.4375,
					    (float)0.625,(flo						    (float)0.625,(flo
	  								  
	  								  
	  //set associative						  //set associative
	  int Num_Sets = 4;						  int Num_Sets = 4;
	  int set_frames = r.b % Num_Sets;				  int set_frames = r.b % Num_Sets;
	  								  
	  //text explanation						  //text explanation
	  g.drawString("Number of Sets = " + Num_Sets,			  g.drawString("Number of Sets = " + Num_Sets,
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+2*(pl_c.C_height + pl_c.			       pl_c.C_y_base+2*(pl_c.C_height + pl_c.

	  g.drawString("Block Number chosen = " + r.b,			  g.drawString("Block Number chosen = " + r.b,
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+2*(pl_c.C_height + pl_c.			       pl_c.C_y_base+2*(pl_c.C_height + pl_c.

	  int temp3 = r.b % Num_Sets;					  int temp3 = r.b % Num_Sets;

	  g.drawString("Set Number = " + 				  g.drawString("Set Number = " + 
		       r.b +" mod " + Num_Sets +" = "+temp3,			       r.b +" mod " + Num_Sets +" = "+temp3,
		       pl_c.C_x_base+20,					       pl_c.C_x_base+20,
		       pl_c.C_y_base+2*(pl_c.C_height + pl_c.			       pl_c.C_y_base+2*(pl_c.C_height + pl_c.
	  								  
	  if (pl_c.set_rect_vec != null)				  if (pl_c.set_rect_vec != null)
	    if (!pl_c.set_rect_vec.isEmpty()){				    if (!pl_c.set_rect_vec.isEmpty()){
	      Enumeration set_enum = pl_c.set_rect_vec.elemen		      Enumeration set_enum = pl_c.set_rect_vec.elemen
	      								      
	      while (set_enum.hasMoreElements()){			      while (set_enum.hasMoreElements()){
		Rectangle set_r = (Rectangle)set_enum.nextEle			Rectangle set_r = (Rectangle)set_enum.nextEle
		if ((set_frames == set_r.s)&&					if ((set_frames == set_r.s)&&
		     (set_r.b == 0)){                				     (set_r.b == 0)){                
		  								  
		  //redraw possible placement					  //redraw possible placement
		  g.setColor(new Color((float)0.4375,(float)0			  g.setColor(new Color((float)0.4375,(float)0
				       (float)0.625));						       (float)0.625));
		  								  
		  g.fillRect(set_r.x, set_r.y - r.h, r.w, 2*r			  g.fillRect(set_r.x, set_r.y - r.h, r.w, 2*r
		  								  
		  g.setColor(Color.black);					  g.setColor(Color.black);
		  g.drawLine(set_r.x,set_r.y, r.w +set_r.x, s			  g.drawLine(set_r.x,set_r.y, r.w +set_r.x, s
		  								  
		  g.setColor(Color.red);					  g.setColor(Color.red);
		  g.drawString("frame "+ set_r.b, set_r.x + 2			  g.drawString("frame "+ set_r.b, set_r.x + 2
			       set_r.y - 5);						       set_r.y - 5);
		  								  
		  g.drawString("frame 1", set_r.x + 20, 			  g.drawString("frame 1", set_r.x + 20, 
			       set_r.y+r.h - 5);					       set_r.y+r.h - 5);
		  break;							  break;
		}//if set_frame							}//if set_frame
	      }//while							      }//while
	    }//if !pl_c							    }//if !pl_c
									
	}//if Belongs							}//if Belongs
									
	else 								else 
									
	  if ((r = BelongsTo(pl_c.dir_rect_vec, x,y))!=null){		  if ((r = BelongsTo(pl_c.dir_rect_vec, x,y))!=null){
	    mode = false;						    mode = false;	
	    Highlight(g, r, "frame");					    Highlight(g, r, "frame");
	    								    
	    //calculate and highlight possible blocks mapped 		    //calculate and highlight possible blocks mapped 
	    if (pl_c.rect_vec != null)					    if (pl_c.rect_vec != null)
	      if (!pl_c.rect_vec.isEmpty()){				      if (!pl_c.rect_vec.isEmpty()){
		Enumeration enum1 = pl_c.rect_vec.elements();			Enumeration enum1 = pl_c.rect_vec.elements();
										
		while (enum1.hasMoreElements()){				while (enum1.hasMoreElements()){
		  Rectangle mem_r = (Rectangle)enum1.nextElem			  Rectangle mem_r = (Rectangle)enum1.nextElem
		  								  
		  if (r.b == (mem_r.b%pl_c.Num_Bl_in_C)){    			  if (r.b == (mem_r.b%pl_c.Num_Bl_in_C)){    
		    								    
		    Highlight(g,mem_r,"block ");				    Highlight(g,mem_r,"block ");
		  }								  }
		}								}
	      }								      }
	  }								  }
									
	  else 								  else 
	    								    
	    if ((r = BelongsTo(pl_c.set_fr_rect_vec, x,y))!=n		    if ((r = BelongsTo(pl_c.set_fr_rect_vec, x,y))!=n
	      mode = false;						      mode = false;	
	      Highlight(g, r, "frame");					      Highlight(g, r, "frame");

	    //calculate and highlight possible blocks mapped 		    //calculate and highlight possible blocks mapped 
	    if (pl_c.rect_vec != null)					    if (pl_c.rect_vec != null)
	      if (!pl_c.rect_vec.isEmpty()){				      if (!pl_c.rect_vec.isEmpty()){
		Enumeration enum3 = pl_c.rect_vec.elements();			Enumeration enum3 = pl_c.rect_vec.elements();
										
		while (enum3.hasMoreElements()){				while (enum3.hasMoreElements()){
		  Rectangle mem_r = (Rectangle)enum3.nextElem			  Rectangle mem_r = (Rectangle)enum3.nextElem
		  								  
		  if (r.s == (mem_r.b % 4)){                			  if (r.s == (mem_r.b % 4)){                
		    								    
		    Highlight(g,mem_r,"block ");				    Highlight(g,mem_r,"block ");
		  }								  }
		}								}
	      }								      }

	    }								    }
									
	    else 							    else 
	      								      
	      if ((r = BelongsTo(pl_c.ful_rect_vec, x,y))!=nu		      if ((r = BelongsTo(pl_c.ful_rect_vec, x,y))!=nu
		mode = false;							mode = false;	
		Highlight(g, r, "frame");					Highlight(g, r, "frame");

		//highlight all main mem area					//highlight all main mem area
		if (pl_c.rect_vec != null)					if (pl_c.rect_vec != null)
		  if (!pl_c.rect_vec.isEmpty()){				  if (!pl_c.rect_vec.isEmpty()){
		    Enumeration enum2 = pl_c.rect_vec.element			    Enumeration enum2 = pl_c.rect_vec.element
		    								    
		    while (enum2.hasMoreElements()){				    while (enum2.hasMoreElements()){
		      Rectangle mem_r = (Rectangle)enum2.next			      Rectangle mem_r = (Rectangle)enum2.next
		      Highlight(g,mem_r,"block ");				      Highlight(g,mem_r,"block ");
		    }								    }
		  }								  }
	      }								      }
      								      
									
      }//if mode						      }//if mode
    }//else for if e.modifiers					    }//else for if e.modifiers
  								  
    return true;						    return true;
  }//end MoouseDown						  }//end MoouseDown

  //*********************************************************	  //*********************************************************
    private void Highlight(Graphics g,Rectangle rec, String s	    private void Highlight(Graphics g,Rectangle rec, String s
      //highlight clicked rect					      //highlight clicked rect
      g.setColor(new Color((float)0.4375,(float)0.625,(float)	      g.setColor(new Color((float)0.4375,(float)0.625,(float)
      g.fillRect(rec.x,rec.y-rec.h,rec.w, rec.h);		      g.fillRect(rec.x,rec.y-rec.h,rec.w, rec.h);
      								      
      g.setColor(Color.black);					      g.setColor(Color.black);
      g.drawLine(rec.x, rec.y-rec.h, rec.x + rec.w, rec.y-rec	      g.drawLine(rec.x, rec.y-rec.h, rec.x + rec.w, rec.y-rec
      								      
      g.setColor(Color.red);					      g.setColor(Color.red);
      g.drawString(str+ rec.b, rec.x + 20, rec.y - 5);		      g.drawString(str+ rec.b, rec.x + 20, rec.y - 5);
    }								    }

  //*********************************************************	  //*********************************************************
    private Rectangle BelongsTo(Vector v, int x_down, int y_d	    private Rectangle BelongsTo(Vector v, int x_down, int y_d
      if ((v != null)						      if ((v != null)
	  && (!v.isEmpty())){						  && (!v.isEmpty())){
									
	Enumeration enum = v.elements();				Enumeration enum = v.elements();
									
	while (enum.hasMoreElements()){					while (enum.hasMoreElements()){
	  Rectangle r = (Rectangle)enum.nextElement();			  Rectangle r = (Rectangle)enum.nextElement();
	  								  
	  if (r.IsIn(x_down,y_down)) return r;				  if (r.IsIn(x_down,y_down)) return r;
	}								}
      } 							      } 
      return null;						      return null;
    }//end BelongsTo						    }//end BelongsTo

}//end Applet							}//end Applet
//********************* END *********************************	//********************* END *********************************














import  java.awt.*;						import  java.awt.*;
import java.util.Vector;					import java.util.Vector;

class PlacementCanvas extends Canvas{				class PlacementCanvas extends Canvas{

  public Vector rect_vec = new Vector();			  public Vector rect_vec = new Vector();
  public Vector dir_rect_vec = new Vector();			  public Vector dir_rect_vec = new Vector();
  public Vector set_rect_vec = new Vector();			  public Vector set_rect_vec = new Vector();
  public Vector set_fr_rect_vec = new Vector();			  public Vector set_fr_rect_vec = new Vector();
  public Vector ful_rect_vec = new Vector();			  public Vector ful_rect_vec = new Vector();
  								  
  int Num_Bl_in_MM = 32;  //number of blocks in MAin Memory	  int Num_Bl_in_MM = 32;  //number of blocks in MAin Memory
  								  
  int BL_width = 100;						  int BL_width = 100;
  int BL_height = 15;						  int BL_height = 15;
  								  
  int MM_x_base = 540;						  int MM_x_base = 540;
  int MM_y_base = 20;						  int MM_y_base = 20;
  int MM_width = BL_width;					  int MM_width = BL_width;
  int MM_height = Num_Bl_in_MM * BL_height;			  int MM_height = Num_Bl_in_MM * BL_height;
  								  
  int C_x_base = 10;						  int C_x_base = 10;
  int C_y_base = MM_y_base;					  int C_y_base = MM_y_base;
  								  
  int C_width = 515;						  int C_width = 515;
  int C_height = 155;						  int C_height = 155;
  int step = 8;							  int step = 8;
  								  
  int CM_x_base = 405;						  int CM_x_base = 405;
  int CM_y_base = C_y_base + 15;				  int CM_y_base = C_y_base + 15;
  int Num_Bl_in_C = 8;						  int Num_Bl_in_C = 8;
  								  
  //*********************************************************	  //*********************************************************
  PlacementCanvas(){						  PlacementCanvas(){
    super();							    super();
    setBackground(new Color((float)0.9444,(float)0.9444,(floa	    setBackground(new Color((float)0.9444,(float)0.9444,(floa
  }								  }
  								  
  //*********************************************************	  //*********************************************************
  public void paint( Graphics canvasP){				  public void paint( Graphics canvasP){
    								    
    //Main mem 							    //Main mem 
    canvasP.drawRect(MM_x_base,MM_y_base, MM_width,MM_height)	    canvasP.drawRect(MM_x_base,MM_y_base, MM_width,MM_height)
    canvasP.drawRect(MM_x_base-1,MM_y_base-1, MM_width+2,MM_h	    canvasP.drawRect(MM_x_base-1,MM_y_base-1, MM_width+2,MM_h
    								    
    canvasP.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasP.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasP.fillRect(MM_x_base,MM_y_base, MM_width,MM_height)	    canvasP.fillRect(MM_x_base,MM_y_base, MM_width,MM_height)
    canvasP.setColor(Color.black);				    canvasP.setColor(Color.black);
    								    
    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));
    canvasP.drawString("Main Memory",MM_x_base , MM_y_base - 	    canvasP.drawString("Main Memory",MM_x_base , MM_y_base - 
    								    
    for ( int k = 0; k<= Num_Bl_in_MM - 1; k++){		    for ( int k = 0; k<= Num_Bl_in_MM - 1; k++){

      int  Y_end_of_line = MM_y_base + BL_height * (k+1);	      int  Y_end_of_line = MM_y_base + BL_height * (k+1);

      canvasP.drawLine(MM_x_base,Y_end_of_line,			      canvasP.drawLine(MM_x_base,Y_end_of_line,
		       MM_x_base + BL_width,Y_end_of_line);			       MM_x_base + BL_width,Y_end_of_line);

      canvasP.drawString("block "+ k,MM_x_base +20, Y_end_of_	      canvasP.drawString("block "+ k,MM_x_base +20, Y_end_of_

      //create an Rectangle Object				      //create an Rectangle Object
      Rectangle r = new Rectangle(MM_x_base,Y_end_of_line,	      Rectangle r = new Rectangle(MM_x_base,Y_end_of_line,
				  BL_width,BL_height,k);					  BL_width,BL_height,k);
      rect_vec.addElement(r);					      rect_vec.addElement(r);
    }//for							    }//for

    canvasP.drawString("Cache",C_x_base + 250 , C_y_base - 5)	    canvasP.drawString("Cache",C_x_base + 250 , C_y_base - 5)

    canvasP.drawRect(C_x_base,C_y_base, C_width,C_height);	    canvasP.drawRect(C_x_base,C_y_base, C_width,C_height);
    canvasP.drawRect(C_x_base-1,C_y_base-1, C_width+2,C_heigh	    canvasP.drawRect(C_x_base-1,C_y_base-1, C_width+2,C_heigh

    canvasP.drawRect(C_x_base,C_y_base + C_height + step, C_w	    canvasP.drawRect(C_x_base,C_y_base + C_height + step, C_w
    canvasP.drawRect(C_x_base-1,C_y_base+C_height + step-1,	    canvasP.drawRect(C_x_base-1,C_y_base+C_height + step-1,
		     C_width+2,C_height+2);					     C_width+2,C_height+2);

    canvasP.drawRect(C_x_base,C_y_base + 2*(C_height + step),	    canvasP.drawRect(C_x_base,C_y_base + 2*(C_height + step),
		     C_width,C_height);						     C_width,C_height);
    canvasP.drawRect(C_x_base-1,C_y_base + 2*(C_height + step	    canvasP.drawRect(C_x_base-1,C_y_base + 2*(C_height + step
		     C_width+2,C_height+2);					     C_width+2,C_height+2);

    canvasP.setColor(new Color((float)0.625,(float)0.8125,(fl	    canvasP.setColor(new Color((float)0.625,(float)0.8125,(fl
    canvasP.fillRect(C_x_base,C_y_base, C_width,C_height); 	    canvasP.fillRect(C_x_base,C_y_base, C_width,C_height); 
    canvasP.fillRect(C_x_base,C_y_base + C_height + step, C_w	    canvasP.fillRect(C_x_base,C_y_base + C_height + step, C_w
    canvasP.fillRect(C_x_base,C_y_base + 2*(C_height + step),	    canvasP.fillRect(C_x_base,C_y_base + 2*(C_height + step),
		     C_width,C_height);						     C_width,C_height);

    canvasP.setColor(Color.black);				    canvasP.setColor(Color.black);
   								   
    canvasP.drawRect(CM_x_base,CM_y_base, BL_width,BL_height*	    canvasP.drawRect(CM_x_base,CM_y_base, BL_width,BL_height*
    canvasP.drawRect(CM_x_base-1,CM_y_base-1, BL_width+2,	    canvasP.drawRect(CM_x_base-1,CM_y_base-1, BL_width+2,
		     BL_height*Num_Bl_in_C+2);					     BL_height*Num_Bl_in_C+2);

    canvasP.drawRect(CM_x_base,CM_y_base+C_height + step,	    canvasP.drawRect(CM_x_base,CM_y_base+C_height + step,
		     BL_width,BL_height*Num_Bl_in_C);				     BL_width,BL_height*Num_Bl_in_C);
    canvasP.drawRect(CM_x_base-1,CM_y_base+C_height + step-1,	    canvasP.drawRect(CM_x_base-1,CM_y_base+C_height + step-1,
		     BL_width+2,BL_height*Num_Bl_in_C+2);			     BL_width+2,BL_height*Num_Bl_in_C+2);

    canvasP.drawRect(CM_x_base,CM_y_base+2*(C_height + step),	    canvasP.drawRect(CM_x_base,CM_y_base+2*(C_height + step),
		     BL_width,BL_height*Num_Bl_in_C);				     BL_width,BL_height*Num_Bl_in_C);
    canvasP.drawRect(CM_x_base-1,CM_y_base+2*(C_height + step	    canvasP.drawRect(CM_x_base-1,CM_y_base+2*(C_height + step
		     BL_width+2,BL_height*Num_Bl_in_C+2);			     BL_width+2,BL_height*Num_Bl_in_C+2);

    canvasP.setColor(new Color((float)0.4375,(float)0.8125,(f	    canvasP.setColor(new Color((float)0.4375,(float)0.8125,(f
    canvasP.fillRect(CM_x_base,CM_y_base, BL_width,BL_height*	    canvasP.fillRect(CM_x_base,CM_y_base, BL_width,BL_height*

    canvasP.fillRect(CM_x_base,CM_y_base+C_height + step,	    canvasP.fillRect(CM_x_base,CM_y_base+C_height + step,
		     BL_width,BL_height*Num_Bl_in_C);				     BL_width,BL_height*Num_Bl_in_C);
    canvasP.fillRect(CM_x_base,CM_y_base+2*(C_height + step),	    canvasP.fillRect(CM_x_base,CM_y_base+2*(C_height + step),
		     BL_width,BL_height*Num_Bl_in_C);				     BL_width,BL_height*Num_Bl_in_C);
    canvasP.setColor(Color.black);				    canvasP.setColor(Color.black);

    canvasP.setFont(new Font("TimesRoman", Font.BOLD+Font.ITA	    canvasP.setFont(new Font("TimesRoman", Font.BOLD+Font.ITA
    canvasP.drawString("Fully associative cache",		    canvasP.drawString("Fully associative cache",
		       C_x_base+20,C_y_base+30);				       C_x_base+20,C_y_base+30);
    								    
    canvasP.drawString("Direct mapped cache",			    canvasP.drawString("Direct mapped cache",
		       C_x_base+20,C_y_base+C_height + step+3			       C_x_base+20,C_y_base+C_height + step+3
   								   
    canvasP.drawString("Set associative cache",			    canvasP.drawString("Set associative cache",
		       C_x_base+20,C_y_base+2*(C_height + ste			       C_x_base+20,C_y_base+2*(C_height + ste
   								   
    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));
    canvasP.drawString("The block can be placed anywhere",	    canvasP.drawString("The block can be placed anywhere",
		       C_x_base+20,C_y_base+50);				       C_x_base+20,C_y_base+50);
    canvasP.drawString(						    canvasP.drawString(
                   "The block can be placed according to the 	                   "The block can be placed according to the 
		       C_x_base+20,C_y_base+C_height + step+5			       C_x_base+20,C_y_base+C_height + step+5
    canvasP.drawString("The block can be placed according to 	    canvasP.drawString("The block can be placed according to 
		       C_x_base+20,C_y_base+2*(C_height + ste			       C_x_base+20,C_y_base+2*(C_height + ste

    canvasP.setFont(new Font("TimesRoman",Font.BOLD, 14));	    canvasP.setFont(new Font("TimesRoman",Font.BOLD, 14));
    canvasP.drawString("Frame Number = Block Number mod Cache	    canvasP.drawString("Frame Number = Block Number mod Cache
		       C_x_base+20,C_y_base+C_height + step+7			       C_x_base+20,C_y_base+C_height + step+7
    canvasP.drawString("Set Number = Block Number mod Number 	    canvasP.drawString("Set Number = Block Number mod Number 
		       C_x_base+20,C_y_base+2*(C_height + ste			       C_x_base+20,C_y_base+2*(C_height + ste
    								    
    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));	    canvasP.setFont(new Font("TimesRoman",Font.PLAIN, 14));

    //fully associative						    //fully associative

    for ( int m = 0; m<= Num_Bl_in_C - 1; m++){			    for ( int m = 0; m<= Num_Bl_in_C - 1; m++){
      								      
     int Y_end_of_line_m = CM_y_base + BL_height * (m+1);	     int Y_end_of_line_m = CM_y_base + BL_height * (m+1);
     canvasP.drawLine(CM_x_base,Y_end_of_line_m,		     canvasP.drawLine(CM_x_base,Y_end_of_line_m,
		      CM_x_base + BL_width,Y_end_of_line_m);			      CM_x_base + BL_width,Y_end_of_line_m);
     canvasP.drawString("frame "+ m,CM_x_base +20, Y_end_of_l	     canvasP.drawString("frame "+ m,CM_x_base +20, Y_end_of_l

     Rectangle ful_r = new 					     Rectangle ful_r = new 
       Rectangle(CM_x_base,Y_end_of_line_m,BL_width,BL_height	       Rectangle(CM_x_base,Y_end_of_line_m,BL_width,BL_height
     ful_rect_vec.addElement(ful_r); 				     ful_rect_vec.addElement(ful_r); 
    }//for							    }//for

    //direct							    //direct

    int CM_y_base_1 =CM_y_base+C_height + step;			    int CM_y_base_1 =CM_y_base+C_height + step;

    for ( int l = 0; l<= Num_Bl_in_C - 1; l++){			    for ( int l = 0; l<= Num_Bl_in_C - 1; l++){
      								      
      int  Y_end_of_line_l = CM_y_base_1 + BL_height * (l+1);	      int  Y_end_of_line_l = CM_y_base_1 + BL_height * (l+1);
      canvasP.drawLine(CM_x_base,Y_end_of_line_l,		      canvasP.drawLine(CM_x_base,Y_end_of_line_l,
		       CM_x_base + BL_width,Y_end_of_line_l);			       CM_x_base + BL_width,Y_end_of_line_l);
      canvasP.drawString("frame "+ l,CM_x_base +20, Y_end_of_	      canvasP.drawString("frame "+ l,CM_x_base +20, Y_end_of_

      Rectangle dir_r = new 					      Rectangle dir_r = new 
	Rectangle(CM_x_base,Y_end_of_line_l,BL_width,BL_heigh		Rectangle(CM_x_base,Y_end_of_line_l,BL_width,BL_heigh
      dir_rect_vec.addElement(dir_r);				      dir_rect_vec.addElement(dir_r);

    }//for							    }//for
    								    
    //set associative						    //set associative
    int CM_y_base_2 =CM_y_base+2*(C_height + step);		    int CM_y_base_2 =CM_y_base+2*(C_height + step);
    								    
    int set_num = 0;						    int set_num = 0;
    int frame_num = 0;						    int frame_num = 0;
    //int prev_set_num  = 0;					    //int prev_set_num  = 0;
    boolean first = true;					    boolean first = true;

    for (int n = 0; n<= Num_Bl_in_C - 1; n++){			    for (int n = 0; n<= Num_Bl_in_C - 1; n++){
      int Y_end_of_line_n = CM_y_base_2 + BL_height * (n+1);	      int Y_end_of_line_n = CM_y_base_2 + BL_height * (n+1);
      canvasP.drawLine(CM_x_base,Y_end_of_line_n,		      canvasP.drawLine(CM_x_base,Y_end_of_line_n,
		       CM_x_base + BL_width,Y_end_of_line_n);			       CM_x_base + BL_width,Y_end_of_line_n);
      if ((n % 2) != 0){					      if ((n % 2) != 0){
	canvasP.drawLine(CM_x_base-20,Y_end_of_line_n,			canvasP.drawLine(CM_x_base-20,Y_end_of_line_n,
			 CM_x_base + BL_width,Y_end_of_line_n				 CM_x_base + BL_width,Y_end_of_line_n
									
	//prev_set_num = set_num;					//prev_set_num = set_num;
	//set_num ++;							//set_num ++;
	frame_num = 1;							frame_num = 1;
      }								      }
      else{							      else{
	if (first){ first = false;}					if (first){ first = false;}
	else { set_num++;}						else { set_num++;}	
	frame_num = 0;							frame_num = 0;
	canvasP.drawString("set "+ set_num, CM_x_base-30,Y_en		canvasP.drawString("set "+ set_num, CM_x_base-30,Y_en
									
	Rectangle set_r = new 						Rectangle set_r = new 
	  Rectangle(CM_x_base,Y_end_of_line_n,BL_width,BL_hei		  Rectangle(CM_x_base,Y_end_of_line_n,BL_width,BL_hei
		    frame_num, set_num);					    frame_num, set_num);
	set_rect_vec.addElement(set_r);					set_rect_vec.addElement(set_r);
									
      }								      }

      canvasP.drawString("frame "+ frame_num,CM_x_base+20,Y_e	      canvasP.drawString("frame "+ frame_num,CM_x_base+20,Y_e
      System.out.println("set ass "+frame_num+" "+set_num);	      System.out.println("set ass "+frame_num+" "+set_num);
      Rectangle set_frames_r = new 				      Rectangle set_frames_r = new 
	Rectangle(CM_x_base,Y_end_of_line_n,BL_width,BL_heigh		Rectangle(CM_x_base,Y_end_of_line_n,BL_width,BL_heigh
		  frame_num, set_num);						  frame_num, set_num);
      set_fr_rect_vec.addElement(set_frames_r);			      set_fr_rect_vec.addElement(set_frames_r);
    }//for							    }//for
  }//paint							  }//paint

  //*********************************************************	  //*********************************************************
  public void draw_fully_assoc(Graphics g,Color col){		  public void draw_fully_assoc(Graphics g,Color col){
    //save current color??!					    //save current color??!
    Color cur_col = g.getColor();				    Color cur_col = g.getColor();
    								    
    g.setColor(col);						    g.setColor(col);
    g.fillRect(CM_x_base,CM_y_base, BL_width,BL_height*Num_Bl	    g.fillRect(CM_x_base,CM_y_base, BL_width,BL_height*Num_Bl
    int m;							    int m;

    for ( m = 0; m<= Num_Bl_in_C - 1; m++){			    for ( m = 0; m<= Num_Bl_in_C - 1; m++){
      								      
     int Y_end_of_line_m = CM_y_base + BL_height * (m+1);	     int Y_end_of_line_m = CM_y_base + BL_height * (m+1);

      g.setColor(Color.black);					      g.setColor(Color.black);
      g.drawLine(CM_x_base,Y_end_of_line_m,			      g.drawLine(CM_x_base,Y_end_of_line_m,
		       CM_x_base + BL_width,Y_end_of_line_m);			       CM_x_base + BL_width,Y_end_of_line_m);
      								      
      g.setColor(Color.red);					      g.setColor(Color.red);
      g.drawString("frame "+ m,CM_x_base +20, Y_end_of_line_m	      g.drawString("frame "+ m,CM_x_base +20, Y_end_of_line_m
    }//for							    }//for

    //restore current color of canvas				    //restore current color of canvas
    g.setColor(cur_col);					    g.setColor(cur_col);
  }								  }
}//class							}//class
//******************** end **********************************	//******************** end **********************************




class Rectangle{						class Rectangle{

  public int x, y, w, h, b,s;					  public int x, y, w, h, b,s;
  //********************************************************	  //********************************************************
  public Rectangle(int X, int Y, int W, int H, int block){	  public Rectangle(int X, int Y, int W, int H, int block){
    x= X;							    x= X;
    y = Y;							    y = Y;
    w = W;							    w = W;
    h = H;							    h = H;
    b = block;							    b = block;
    s =0;							    s =0;
  }								  }

  //********************************************************	  //********************************************************
  public Rectangle(int X, int Y, int W, int H, int block, int	  public Rectangle(int X, int Y, int W, int H, int block, int
    x= X;							    x= X;
    y = Y;							    y = Y;
    w = W;							    w = W;
    h = H;							    h = H;
    b = block;							    b = block;
    s=set;							    s=set;
  }								  }

  //********************************************************	  //********************************************************
  public boolean IsIn (int X_coord, int Y_coord){		  public boolean IsIn (int X_coord, int Y_coord){

    if ( (X_coord < (x + w)) && (X_coord > x) &&		    if ( (X_coord < (x + w)) && (X_coord > x) &&
	 (Y_coord > (y - h)) && (Y_coord < y))				 (Y_coord > (y - h)) && (Y_coord < y))
      return true;						      return true;
    return false;						    return false;
  }								  }
}								}
  //****************** end **********************************	  //****************** end **********************************
import  java.awt.*;					      |	import  java.awt.*;
								
import java.util.*;					      |	import java.util.*;
								
import java.awt.Dimension;				      |	import java.awt.Dimension;
								
							      |	
								
class ReplaceCanvas extends Canvas implements Runnable{	      |	class ReplaceCanvas extends Canvas implements Runnable{
								
  							      |	  
								
  private Font font;					      |	  private Font font;
								
  private FontMetrics font_m;				      |	  private FontMetrics font_m;
								
							      |	
								
  Color back_gr = new Color((float)0.9444,(float)0.9444,(floa |	  Color back_gr = new Color((float)0.9444,(float)0.9444,(floa
								
  Color fillColor= new Color((float)0.4375,(float)0.8125,(flo |	  Color fillColor= new Color((float)0.4375,(float)0.8125,(flo
								
  Color missColor = Color.blue;				      |	  Color missColor = Color.blue;
								
  Color hitColor = Color.red;				      |	  Color hitColor = Color.red;
								
  Color regColor = Color.black;				      |	  Color regColor = Color.black;
								
							      |	
								
  private Vector v;      //keeps elements of the ref string   |	  private Vector v;      //keeps elements of the ref string
								
							      |	
								
  private Vector Order; //order of references to keep track o |	  private Vector Order; //order of references to keep track o
								
							      |	
								
  private int count=0;					      |	  private int count=0;
								
  private String policy_str;				      |	  private String policy_str;
								
  private String method_str;				      |	  private String method_str;
								
  private int cache_size;				      |	  private int cache_size;
								
  private String Incoming;				      |	  private String Incoming;
								
							      |	
								
  private int my_width ;				      |	  private int my_width ;
								
  private int my_height;				      |	  private int my_height;
								
							      |	
								
  private final int HIT = 1,				      |	  private final int HIT = 1,
								
    MISS = 0,						      |	    MISS = 0,
								
    UNDEF = -1;						      |	    UNDEF = -1;
								
							      |	
								
  private int[] Cache;					      |	  private int[] Cache;
								
  private int replaced_bl = UNDEF;			      |	  private int replaced_bl = UNDEF;
								
							      |	
								
  private int ref_int[];				      |	  private int ref_int[];
								
  private String ref_str[] ;				      |	  private String ref_str[] ;
								
  private int ref_status[];				      |	  private int ref_status[];
								
  private int ref_frame[];				      |	  private int ref_frame[];
								
							      |	
								
  private boolean reset_done = true;			      |	  private boolean reset_done = true;
								
							      |	
								
  private int hits = 0;					      |	  private int hits = 0;
								
  private int misses = 0;				      |	  private int misses = 0;
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  //*** Constructor ***					      |	  //*** Constructor ***
								
  ReplaceCanvas(String S,String Policy, String Method, int Ca |	  ReplaceCanvas(String S,String Policy, String Method, int Ca
								
    super();						      |	    super();
								
							      |	
								
    setBackground(back_gr);				      |	    setBackground(back_gr);
								
    font = new Font("TimesRoman", Font.BOLD, 14);	      |	    font = new Font("TimesRoman", Font.BOLD, 14);
								
    font_m = getFontMetrics(font);			      |	    font_m = getFontMetrics(font);
								
    setFont(font);					      |	    setFont(font);
								
							      |	
								
    Incoming = new String(S);				      |	    Incoming = new String(S);
								
							      |	
								
    setPolicy(Policy);					      |	    setPolicy(Policy);
								
   							      |	   
								
    setMethod(Method);					      |	    setMethod(Method);
								
							      |	
								
    setCacheSize(CacheSize);				      |	    setCacheSize(CacheSize);
								
   							      |	   
								
    setStr(S);						      |	    setStr(S);
								
							      |	
								
    reset_done = false;					      |	    reset_done = false;
								
  }							      |	  }
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public void Modify(){					      |	  public void Modify(){
								
    reset_done = false;					      |	    reset_done = false;
								
  } 							      |	  } 
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public int getHits(){					      |	  public int getHits(){
								
    return hits;					      |	    return hits;
								
  } 							      |	  } 
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public int getMisses(){				      |	  public int getMisses(){
								
    return misses;					      |	    return misses;
								
  } 							      |	  } 
								
							      |	
								
  //******************* for debug only ************* 	      |	  //******************* for debug only ************* 
								
  public static void main(String args[]){		      |	  public static void main(String args[]){
								
    ReplaceCanvas r = new ReplaceCanvas("1 2 3", "p","m",3 ); |	    ReplaceCanvas r = new ReplaceCanvas("1 2 3", "p","m",3 );
								
  }							      |	  }
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public void setStr(String s){				      |	  public void setStr(String s){
								
    Incoming = new String(s);				      |	    Incoming = new String(s);
								
							      |	
								
    count = Parse(s);					      |	    count = Parse(s);
								
    ref_int = new int[count];				      |	    ref_int = new int[count];
								
    ref_status = new int[count];			      |	    ref_status = new int[count];
								
    ref_frame = new int[count];				      |	    ref_frame = new int[count];
								
							      |	
								
    ref_str = new String[count];			      |	    ref_str = new String[count];
								
    //allocation of strings in the array		      |	    //allocation of strings in the array
								
    for(int k=0; k<count; k++){				      |	    for(int k=0; k<count; k++){
								
      ref_str[k] =new String();				      |	      ref_str[k] =new String();
								
      ref_int[k] = UNDEF;				      |	      ref_int[k] = UNDEF;
								
      ref_status[k] = UNDEF;				      |	      ref_status[k] = UNDEF;
								
      ref_frame[k] = UNDEF;				      |	      ref_frame[k] = UNDEF;
								
    }							      |	    }
								
    							      |	    
								
    Enumeration e1 = v.elements();			      |	    Enumeration e1 = v.elements();
								
    							      |	    
								
    for(int k=0; k<count; k++){				      |	    for(int k=0; k<count; k++){
								
      Object to = e1.nextElement();			      |	      Object to = e1.nextElement();
								
      ref_int[k] =Integer.parseInt(((Integer) to ).toString() |	      ref_int[k] =Integer.parseInt(((Integer) to ).toString()
								
      ref_str[k] =((Integer) to ).toString();		      |	      ref_str[k] =((Integer) to ).toString();
								
    }							      |	    }
								
							      |	
								
    if (!reset_done){					      |	    if (!reset_done){
								
      reset_done = true;				      |	      reset_done = true;
								
      hits = 0; 					      |	      hits = 0; 
								
      misses = 0;					      |	      misses = 0;
								
      setPolicy(policy_str);				      |	      setPolicy(policy_str);
								
      setCacheSize(cache_size);				      |	      setCacheSize(cache_size);
								
    }							      |	    }
								
  }							      |	  }
								
 							      |	 
								
  //************************************************	      |	  //************************************************
								
  public void setPolicy(String p){			      |	  public void setPolicy(String p){
								
    policy_str = new String(p);				      |	    policy_str = new String(p);
								
    Order = new Vector();				      |	    Order = new Vector();
								
    							      |	    
								
    if (!reset_done){					      |	    if (!reset_done){
								
      reset_done = true;				      |	      reset_done = true;
								
      hits = 0; 					      |	      hits = 0; 
								
      misses = 0;					      |	      misses = 0;
								
      setStr(Incoming);					      |	      setStr(Incoming);
								
      setCacheSize(cache_size);				      |	      setCacheSize(cache_size);
								
    }							      |	    }
								
  }							      |	  }
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public void setMethod(String m){			      |	  public void setMethod(String m){
								
    method_str = new String(m);				      |	    method_str = new String(m);
								
							      |	
								
    if (!reset_done){					      |	    if (!reset_done){
								
      reset_done = true;				      |	      reset_done = true;
								
      hits = 0; 					      |	      hits = 0; 
								
      misses = 0;					      |	      misses = 0;
								
      setStr(Incoming);					      |	      setStr(Incoming);
								
      setPolicy(policy_str);				      |	      setPolicy(policy_str);
								
      setCacheSize(cache_size);				      |	      setCacheSize(cache_size);
								
    }							      |	    }
								
  }							      |	  }
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  public void setCacheSize(int CacheSize){		      |	  public void setCacheSize(int CacheSize){
								
    cache_size = CacheSize;				      |	    cache_size = CacheSize;
								
							      |	
								
    Cache = new int[cache_size];			      |	    Cache = new int[cache_size];
								
    for (int i = 0; i<cache_size; i++){			      |	    for (int i = 0; i<cache_size; i++){
								
      Cache[i] = UNDEF; //load cache values as null elements  |	      Cache[i] = UNDEF; //load cache values as null elements 
								
    }							      |	    }
								
							      |	
								
    if (!reset_done){					      |	    if (!reset_done){
								
      reset_done = true;				      |	      reset_done = true;
								
      hits = 0; 					      |	      hits = 0; 
								
      misses = 0;					      |	      misses = 0;
								
      setStr(Incoming);					      |	      setStr(Incoming);
								
      setPolicy(policy_str);				      |	      setPolicy(policy_str);
								
    } 							      |	    } 
								
  }							      |	  }
								
							      |	
								
  //************************************************	      |	  //************************************************
								
  private int Parse(String s){				      |	  private int Parse(String s){
								
    							      |	    
								
    String my_s = new String(s);			      |	    String my_s = new String(s);
								
    String temp = my_s;					      |	    String temp = my_s;
								
    String temp_short;					      |	    String temp_short;
								
    int c;						      |	    int c;
								
							      |	
								
    v = new Vector();					      |	    v = new Vector();
								
    c = 0;						      |	    c = 0;
								
    							      |	    
								
    int j = 1;						      |	    int j = 1;
								
    							      |	    
								
    while ((j != -1)||(temp == null)){			      |	    while ((j != -1)||(temp == null)){
								
      j = my_s.indexOf((int)' ');			      |	      j = my_s.indexOf((int)' ');
								
      if (j == -1) {					      |	      if (j == -1) {
								
	temp_short = my_s;				      |		temp_short = my_s;
								
      }else{						      |	      }else{
								
	temp = my_s.substring(j+1);			      |		temp = my_s.substring(j+1);
								
	temp_short = my_s.substring(0,j);		      |		temp_short = my_s.substring(0,j);
								
      }							      |	      }
								
      if (temp != null){				      |	      if (temp != null){
								
	Integer i = new Integer(Integer.parseInt(temp_short)) |		Integer i = new Integer(Integer.parseInt(temp_short))
								
	my_s=temp;					      |		my_s=temp;
								
	v.addElement(i);				      |		v.addElement(i);
								
	c++; 						      |		c++; 
								
      }							      |	      }
								
    }							      |	    }
								
   return c;						      |	   return c;
								
  }							      |	  }
								
  							      |	  
								
  //******************************************************    |	  //******************************************************
								
  public void run(){					      |	  public void run(){
								
    Graphics g = getGraphics();				      |	    Graphics g = getGraphics();
								
    g.setColor (back_gr);				      |	    g.setColor (back_gr);	
								
    g.fillRect(0,0, 500, 200);				      |	    g.fillRect(0,0, 500, 200);
								
    g.setColor(Color.black);				      |	    g.setColor(Color.black);	
								
    int xb = 30;					      |	    int xb = 30;
								
    int yb = 30;					      |	    int yb = 30;
								
    int shift = 20;					      |	    int shift = 20;
								
							      |	
								
    g.drawString("hit/miss", xb,yb);			      |	    g.drawString("hit/miss", xb,yb);
								
    g.drawString("Ref string  ", xb,yb+shift);		      |	    g.drawString("Ref string  ", xb,yb+shift);
								
    							      |	    
								
    int accum = 0, len; 				      |	    int accum = 0, len; 
								
    String t_str;					      |	    String t_str;
								
							      |	
								
    for (int k=0; k<count;k++){				      |	    for (int k=0; k<count;k++){
								
      t_str = new String(ref_str[k]+" ");		      |	      t_str = new String(ref_str[k]+" ");
								
      len = font_m.stringWidth(t_str);			      |	      len = font_m.stringWidth(t_str);
								
      g.drawString(t_str,xb+100+accum,yb+shift);	      |	      g.drawString(t_str,xb+100+accum,yb+shift);
								
      accum +=len; 					      |	      accum +=len; 
								
  }							      |	  }
								
							      |	
								
    int x1 = xb;					      |	    int x1 = xb;
								
    int y1 = yb+2*shift;				      |	    int y1 = yb+2*shift;
								
							      |	
								
    //Dimension d = getSize();				      |	    //Dimension d = getSize();
								
    // my_width = d.width;				      |	    // my_width = d.width;
								
    // my_height = d.height;				      |	    // my_height = d.height;
								
							      |	
								
    my_width = 415;   //getSize is not found by brouser, so t |	    my_width = 415;   //getSize is not found by brouser, so t
								
    my_height = 175;  // are from empirical observations      |	    my_height = 175;  // are from empirical observations
								
							      |	
								
    int y_left = my_height-y1-5;//5 for margin		      |	    int y_left = my_height-y1-5;//5 for margin
								
							      |	
								
    int bl_width = font_m.stringWidth("frame 0")+10;	      |	    int bl_width = font_m.stringWidth("frame 0")+10;
								
    int bl_height = y_left/cache_size;			      |	    int bl_height = y_left/cache_size;
								
    							      |	    
								
    g.drawRect(x1,y1,bl_width, y_left);			      |	    g.drawRect(x1,y1,bl_width, y_left);
								
    g.setColor(fillColor);				      |	    g.setColor(fillColor);
								
    g.fillRect(x1+1,y1+1,bl_width-2, y_left-2);		      |	    g.fillRect(x1+1,y1+1,bl_width-2, y_left-2);
								
    g.setColor(Color.black);				      |	    g.setColor(Color.black);
								
							      |	
								
    int k=0, y_temp;					      |	    int k=0, y_temp;
								
    for(int i = 1; i<= cache_size; i++){		      |	    for(int i = 1; i<= cache_size; i++){
								
      k=i-1;						      |	      k=i-1;
								
      y_temp = y1+bl_height*i;				      |	      y_temp = y1+bl_height*i;
								
      							      |	      
								
      g.drawLine(x1,y_temp, x1+bl_width,y_temp);	      |	      g.drawLine(x1,y_temp, x1+bl_width,y_temp);
								
      g.drawString("frame "+k, x1+5,y_temp-3);  	      |	      g.drawString("frame "+k, x1+5,y_temp-3);  
								
    }							      |	    }
								
							      |	
								
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |	    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
								
    int accum_count=0;					      |	    int accum_count=0;
								
							      |	
								
    hits = 0;						      |	    hits = 0;
								
    misses = 0;						      |	    misses = 0;
								
    Replace.appendString("********* New round **********\n"); |	    Replace.appendString("********* New round **********\n");
								
    Replace.appendString("*** Policy: "+policy_str+" ******** |	    Replace.appendString("*** Policy: "+policy_str+" ********
								
    Replace.appendString("*** Method: "+method_str+" ******** |	    Replace.appendString("*** Method: "+method_str+" ********
								
    Replace.appendString("*** Cache Size: "+cache_size+"      |	    Replace.appendString("*** Cache Size: "+cache_size+"     
								
    Replace.appendString("*** Ref String: ("+Incoming+")***\n |	    Replace.appendString("*** Ref String: ("+Incoming+")***\n
								
    Replace.appendString("******************************\n"); |	    Replace.appendString("******************************\n");
								
    							      |	    
								
    for (int i=0; i<count; i++){			      |	    for (int i=0; i<count; i++){
								
      accum_count++;					      |	      accum_count++;
								
      int frame = UNDEF;				      |	      int frame = UNDEF;
								
							      |	
								
      if (Block_in_Cache(ref_int[i])){			      |	      if (Block_in_Cache(ref_int[i])){
								
	//hit						      |		//hit
								
	hits++;						      |		hits++;
								
							      |	
								
	ref_status[i] = HIT;				      |		ref_status[i] = HIT;
								
	frame = GetFrame(ref_int[i]);			      |		frame = GetFrame(ref_int[i]);
								
	ref_frame[i] = frame;				      |		ref_frame[i] = frame;
								
      Replace.appendString("Block "+ref_int[i]+" found in Fra |	      Replace.appendString("Block "+ref_int[i]+" found in Fra
								
                         ref_frame[i]+"\n");		      |	                         ref_frame[i]+"\n");
								
      }else{						      |	      }else{
								
	//miss						      |		//miss
								
	misses++;					      |		misses++;
								
							      |	
								
	ref_status[i] = MISS;				      |		ref_status[i] = MISS;
								
							      |	
								
	//calculate what frame the block maps to (defined by  |		//calculate what frame the block maps to (defined by 
								
	frame = FindFrame(ref_int[i]);			      |		frame = FindFrame(ref_int[i]);
								
	ref_frame[i] = frame;				      |		ref_frame[i] = frame;
								
							      |	
								
      Insert_in_Cache(frame, ref_int[i]);		      |	      Insert_in_Cache(frame, ref_int[i]);
								
							      |	
								
      if (replaced_bl == -1)				      |	      if (replaced_bl == -1)
								
         Replace.appendString("Block "+ref_int[i]+" put in Fr |	         Replace.appendString("Block "+ref_int[i]+" put in Fr
								
                         ref_frame[i]+"\n");		      |	                         ref_frame[i]+"\n");
								
      else						      |	      else
								
         Replace.appendString("Block "+ref_int[i]+" replaced  |	         Replace.appendString("Block "+ref_int[i]+" replaced 
								
                      replaced_bl+" in Frame "+ref_frame[i]+" |	                      replaced_bl+" in Frame "+ref_frame[i]+"
								
      replaced_bl=UNDEF;				      |	      replaced_bl=UNDEF;
								
      }							      |	      }
								
							      |	
								
      //update Order vector				      |	      //update Order vector
								
      UpdateOrder(frame);				      |	      UpdateOrder(frame);
								
     							      |	     
								
      //display the block				      |	      //display the block
								
      int step = 10;					      |	      int step = 10;
								
      int x2 = x1 + bl_width+step*accum_count;		      |	      int x2 = x1 + bl_width+step*accum_count;
								
      int y2 = y1 +bl_height*(ref_frame[i]+1)-3;	      |	      int y2 = y1 +bl_height*(ref_frame[i]+1)-3;
								
      if (ref_status[i] == HIT) g.setColor(hitColor);	      |	      if (ref_status[i] == HIT) g.setColor(hitColor);
								
      if (ref_status[i] == MISS) g.setColor(missColor);	      |	      if (ref_status[i] == MISS) g.setColor(missColor);
								
							      |	
								
      g.drawString(ref_str[i], x2,y2);			      |	      g.drawString(ref_str[i], x2,y2);
								
      g.setColor(regColor);				      |	      g.setColor(regColor);
								
							      |	
								
      try{Thread.sleep(100);}				      |	      try{Thread.sleep(100);}
								
      catch(InterruptedException e){//do nothing	      |	      catch(InterruptedException e){//do nothing
								
      }							      |	      }
								
    }							      |	    }
								
							      |	
								
    //send a message to applet to redraw hit/miss values      |	    //send a message to applet to redraw hit/miss values
								
    Replace.setNumHitsMisses(hits, misses);		      |	    Replace.setNumHitsMisses(hits, misses);
								
    							      |	    
								
    //redraw the ref string				      |	    //redraw the ref string
								
    accum = 0; 						      |	    accum = 0; 
								
							      |	
								
    for (int n = 0; n < count; n++){			      |	    for (int n = 0; n < count; n++){
								
      t_str = new String(ref_str[n]+" ");		      |	      t_str = new String(ref_str[n]+" ");
								
      len = font_m.stringWidth(t_str);			      |	      len = font_m.stringWidth(t_str);
								
							      |	
								
      if (ref_status[n] == HIT) {			      |	      if (ref_status[n] == HIT) {
								
	g.setColor(hitColor);				      |		g.setColor(hitColor);
								
	g.drawString("h",xb+100+accum,yb);		      |		g.drawString("h",xb+100+accum,yb);
								
      }							      |	      }
								
      if (ref_status[n] == MISS){			      |	      if (ref_status[n] == MISS){
								
	g.setColor(missColor);				      |		g.setColor(missColor);
								
	g.drawString("m",xb+100+accum,yb);		      |		g.drawString("m",xb+100+accum,yb);
								
      }							      |	      }
								
      g.drawString(t_str,xb+100+accum,yb+shift);	      |	      g.drawString(t_str,xb+100+accum,yb+shift);
								
      accum +=len; 					      |	      accum +=len; 
								
							      |	
								
      try{Thread.sleep(100);}				      |	      try{Thread.sleep(100);}
								
      catch(InterruptedException e){//do nothing	      |	      catch(InterruptedException e){//do nothing
								
      }							      |	      }
								
    }							      |	    }
								
  }							      |	  }
								
							      |	
								
  //********************************************************* |	  //*********************************************************
								
  private void UpdateOrder(int frame){			      |	  private void UpdateOrder(int frame){
								
    //    Dump(Order, "Order in UpdateOrder begin");	      |	    //    Dump(Order, "Order in UpdateOrder begin");
								
    							      |	    boolean found = false;
								
    if (frame == UNDEF){				      |	    if (frame == UNDEF){
								
      System.out.println("internal ERROR");		      |	      System.out.println("internal ERROR");
								
    }else {						      |	    }else {
								
      							      |	      
								
      if (policy_str.equals("RANDOM")){			      |	      if (policy_str.equals("RANDOM")){
								
	//there is no order for random selection	      |		//there is no order for random selection
								
      }							      |	      }
								
      else{						      |	      else{
								
	// - find the frame in Order			      |		// - find the frame in Order
								
	Enumeration e = Order.elements();		      |		Enumeration e = Order.elements();
								
							      |		Object o = null;
								
	while(e.hasMoreElements()){			      |		while(e.hasMoreElements()){
								
	  Object o = e.nextElement();			      |		  o = e.nextElement();
								
	  if (frame == Integer.parseInt(((Integer)o).toString |		  if (frame == ((Integer)o).intValue()){
								
	    //   yes:delete it				      |		    //break
								
	    Order.removeElement(Integer.valueOf(String.valueO |	//	    Dump(Order, "Order in UpdateOrder middle");
								
//	    Dump(Order, "Order in UpdateOrder middle");	      |	            found = true;
								
	    break;					      |		    break;
								
	  }						      |		  }
								
	}						      |		}
								
	// - append the frame to position defined in replace  |		// - append the frame to position defined in replace 
								
	Order.addElement(Integer.valueOf(String.valueOf(frame |	        
								
      }							      |	        if(!policy_str.equals("FIFO")){
								
    }     						      |	            if(found){
								
//    Dump(Order, "Order in UpdateOrder end");		      |	            //delete the element 
								
  }							      |	            Order.removeElement(o);
								
							      |	            }
								
  //********************************************************* |	            //add it to the end of the list
								
  private void Dump(Vector vec, String name){		      |	            Order.addElement(new Integer(frame));
								
  //  System.out.println("Dump");			      |	        }
								
    System.out.println("vector dump for " + name);	      |	        else{
								
    Enumeration e = vec.elements();			      |	            //add the element only if it is not already in th
								
    while (e.hasMoreElements()){			      |	            if(!found){
								
      System.out.println(e.nextElement()+"");		      |	                 Order.addElement(new Integer(frame));
								
    }							      |	            }
								
  }							      |	        }
								
							      |	 
								
  //********************************************************* |	      }
								
  private int FindReplacedFrame(){			      |	    }     
								
  //  System.out.println("FindReplaceFrame");		      |	//    Dump(Order, "Order in UpdateOrder end");
								
    //consider different replacement policies		      |	  }
								
    int f = -5;						      |	
								
    Integer I;						      |	  //*********************************************************
								
    							      |	  private void Dump(Vector vec, String name){
								
    if (policy_str.equals("RANDOM")){			      |	  //  System.out.println("Dump");
								
       f = (int)(Math.random()*cache_size);		      |	    System.out.println("vector dump for " + name);
								
    }							      |	    Enumeration e = vec.elements();
								
    else{						      |	    while (e.hasMoreElements()){
								
      if (policy_str.equals("MRU"))			      |	      System.out.println(e.nextElement()+"");
								
        I = (Integer)Order.lastElement();		      |	    }
								
      else 						      |	  }
								
        I = (Integer)Order.firstElement();		      |	
								
							      |	  //*********************************************************
								
      //find the placement of that element		      |	  private int FindReplacedFrame(){
								
      f = Integer.parseInt(I.toString());		      |	  //  System.out.println("FindReplaceFrame");
								
    }      						      |	    //consider different replacement policies
								
    return f;						      |	    int f = -5;
								
  }							      |	    Integer I;
								
							      |	    
								
  //********************************************************* |	    if (policy_str.equals("RANDOM")){
								
  private void Insert_in_Cache(int fr, int bl){		      |	       f = (int)(Math.random()*cache_size);
								
//    System.out.println("Insert_in_Cache");		      |	    }
								
    Cache[fr] = bl;					      |	    else{
								
  }							      |	      if (policy_str.equals("MRU"))
								
  							      |	        I = (Integer)Order.lastElement();
								
  //********************************************************* |	      else 
								
  private boolean Frame_is_Empty(int fr){		      |	        I = (Integer)Order.firstElement();
								
//    System.out.println("Frame_is_Empty");		      |	
								
    if (Cache[fr] == UNDEF) return true;		      |	      //find the placement of that element
								
    else return false;					      |	      f = Integer.parseInt(I.toString());
								
  }							      |	    }      
								
  							      |	    return f;
								
  //********************************************************* |	  }
								
  private int GetFrame(int bl){				      |	
								
//    System.out.println("GetFrame");			      |	  //*********************************************************
								
    for (int i = 0; i<cache_size; i++){			      |	  private void Insert_in_Cache(int fr, int bl){
								
      if (Cache[i] == bl) {				      |	//    System.out.println("Insert_in_Cache");
								
//	System.out.println("GetFrame returns "+i);	      |	    Cache[fr] = bl;
								
	return i;					      |	  }
								
      }							      |	  
								
    }							      |	  //*********************************************************
								
    System.out.println("internal error");		      |	  private boolean Frame_is_Empty(int fr){
								
    return -5; //not found				      |	//    System.out.println("Frame_is_Empty");
								
  }							      |	    if (Cache[fr] == UNDEF) return true;
								
							      |	    else return false;
								
  //********************************************************* |	  }
								
  private int FindFrame(int bl){			      |	  
								
//    System.out.println("FindFrame");			      |	  //*********************************************************
								
    int r = 0;						      |	  private int GetFrame(int bl){
								
							      |	//    System.out.println("GetFrame");
								
    if (method_str.equals("FULL")){			      |	    for (int i = 0; i<cache_size; i++){
								
							      |	      if (Cache[i] == bl) {
								
//check if placement is also random!!!!!!!!!!!!!!!!!!	      |	//	System.out.println("GetFrame returns "+i);
								
      if (policy_str.equals("RANDOM")){			      |		return i;
								
       r = (int)(Math.random()*cache_size);		      |	      }
								
      }							      |	    }
								
      else{						      |	    System.out.println("internal error");
								
        //any empty frame will do			      |	    return -5; //not found
								
        for (int i = 0; i<cache_size; i++){		      |	  }
								
	  if (Cache[i] == UNDEF) return i;		      |	
								
        }						      |	  //*********************************************************
								
        //there is no empty frame!			      |	  private int FindFrame(int bl){
								
        r = FindReplacedFrame();			      |	//    System.out.println("FindFrame");
								
      }							      |	    int r = 0;
								
    }else 						      |	
								
      if (method_str.equals("DIRECT"))			      |	    if (method_str.equals("FULL")){
								
	r = bl%cache_size;	//frame is determined	      |	
								
  							      |	//check if placement is also random!!!!!!!!!!!!!!!!!!
								
    //set replaced_bl					      |	      if (policy_str.equals("RANDOM")){
								
    replaced_bl = Cache[r];				      |	       r = (int)(Math.random()*cache_size);
								
    return r;						      |	      }
								
  }							      |	      else{
								
  							      |	        //any empty frame will do
								
  //********************************************************* |	        for (int i = 0; i<cache_size; i++){
								
  private boolean Block_in_Cache(int bl){		      |		  if (Cache[i] == UNDEF) return i;
								
//    System.out.println("Block_in_Cache");		      |	        }
								
							      |	        //there is no empty frame!
								
    for (int i = 0; i<cache_size; i++){			      |	        r = FindReplacedFrame();
								
      if (bl == Cache[i]) 				      |	      }
								
	return true;					      |	    }else 
								
    }							      |	      if (method_str.equals("DIRECT"))
								
    return false;					      |		r = bl%cache_size;	//frame is determined
								
  }							      |	  
								
}							      |	    //set replaced_bl
								
//******************** END ****************************	      |	    replaced_bl = Cache[r];
								
							      |	    return r;
								
							      |	  }
								
							      |	  
								
							      |	  //*********************************************************
								
							      |	  private boolean Block_in_Cache(int bl){
								
							      |	//    System.out.println("Block_in_Cache");
								
							      |	
								
							      >	    for (int i = 0; i<cache_size; i++){
								
							      >	      if (bl == Cache[i]) 
								
							      >		return true;
								
							      >	    }
								
							      >	    return false;
								
							      >	  }
								
							      >	}
								
							      >	//******************** END ****************************
								
							      >	
								
							      >	
								
							      >	
								
							      >	
								
							      >	
								
							      >	
								
							      >	
								
import java.applet.Applet;					import java.applet.Applet;
import java.awt.*;						import java.awt.*;

public class Replace extends Applet{				public class Replace extends Applet{
  								  
  private CheckboxGroup Method;					  private CheckboxGroup Method;
  private Checkbox direct, full, set;				  private Checkbox direct, full, set;
  private String methodStr;					  private String methodStr;

  private CheckboxGroup Policy;					  private CheckboxGroup Policy;
  private Checkbox random, fifo, lru, mru;			  private Checkbox random, fifo, lru, mru;
  private String policyStr;					  private String policyStr;
  								  
  private Choice CacheSize;					  private Choice CacheSize;
  private static TextField t_ref_str,t_num_ref, t_num_hit, t_	  private static TextField t_ref_str,t_num_ref, t_num_hit, t_
  private static TextArea Exp_Ar;				  private static TextArea Exp_Ar;
  								  
  private Button Enter,Reset, Start, Suspend, Continue;		  private Button Enter,Reset, Start, Suspend, Continue;
  								  
  private  final String default_ref_str = "2 4 3 1 4 3 2 1 4 	  private  final String default_ref_str = "2 4 3 1 4 3 2 1 4 
  private String cur_ref_str = default_ref_str;			  private String cur_ref_str = default_ref_str;
  								  
  private int[] Table_of_Cache_Sizes={3,4,5,6,7,8};		  private int[] Table_of_Cache_Sizes={3,4,5,6,7,8};
  								  
  private int count_num_ref = getNumEl(cur_ref_str),		  private int count_num_ref = getNumEl(cur_ref_str),
    count_num_hit = 0,						    count_num_hit = 0,
    count_num_miss=0;						    count_num_miss=0;
  								  
  private int cache_size = Table_of_Cache_Sizes[0] ;		  private int cache_size = Table_of_Cache_Sizes[0] ;
  private ReplaceCanvas r ;					  private ReplaceCanvas r ;
  Thread Animation_thread;					  Thread Animation_thread;
  								  
  Font font = new Font("TimesRoman", Font.BOLD, 14);		  Font font = new Font("TimesRoman", Font.BOLD, 14);
  public  static final Color fillColor=				  public  static final Color fillColor=
  new Color ((float)0.4375,(float)0.8125,(float)0.8125);	  new Color ((float)0.4375,(float)0.8125,(float)0.8125);
  								  
  public  static final Color drawColor = Color.black;		  public  static final Color drawColor = Color.black;
  								  
  								  
  //**************************************			  //**************************************
  public void init(){						  public void init(){
    setBackground (						    setBackground (
		   new Color((float)0.9444,(float)0.9444,(flo			   new Color((float)0.9444,(float)0.9444,(flo
    setFont(font);						    setFont(font);
    								    
    GridBagLayout gridbag = new GridBagLayout();		    GridBagLayout gridbag = new GridBagLayout();
    GridBagConstraints constraints = new GridBagConstraints()	    GridBagConstraints constraints = new GridBagConstraints()
    setLayout(gridbag);						    setLayout(gridbag);
    								    
    buildConstraints(constraints,1,0,2,1,30,100);		    buildConstraints(constraints,1,0,2,1,30,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    Label label1 = new Label("Replacement");			    Label label1 = new Label("Replacement");
    gridbag.setConstraints(label1, constraints);		    gridbag.setConstraints(label1, constraints);
    add(label1);						    add(label1);
    								    
    //adding Checkboxes						    //adding Checkboxes
    Policy = new CheckboxGroup();				    Policy = new CheckboxGroup();
    random = new Checkbox("Random", Policy,true);		    random = new Checkbox("Random", Policy,true);
    fifo = new Checkbox("FIFO", Policy, false);			    fifo = new Checkbox("FIFO", Policy, false);
    lru = new Checkbox ("LRU", Policy, false);			    lru = new Checkbox ("LRU", Policy, false);
    mru = new Checkbox ("MRU", Policy, false);			    mru = new Checkbox ("MRU", Policy, false);
    								    
    buildConstraints(constraints,1,1,2,1,0,100);		    buildConstraints(constraints,1,1,2,1,0,100);
    								    
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    gridbag.setConstraints(random, constraints);		    gridbag.setConstraints(random, constraints);
    add(random);						    add(random);
    								    
    buildConstraints(constraints,1,2,2,1,0,100);		    buildConstraints(constraints,1,2,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(fifo, constraints);			    gridbag.setConstraints(fifo, constraints);
    add(fifo);							    add(fifo);
    								    
    buildConstraints(constraints,1,3,2,1,0,100);		    buildConstraints(constraints,1,3,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    gridbag.setConstraints(lru, constraints);			    gridbag.setConstraints(lru, constraints);
    add(lru);							    add(lru);
        							        
    buildConstraints(constraints,1,4,2,1,0,100);		    buildConstraints(constraints,1,4,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    gridbag.setConstraints(mru, constraints);			    gridbag.setConstraints(mru, constraints);
    add(mru);							    add(mru);
    								    
    buildConstraints(constraints,3,0,2,1,0,100);		    buildConstraints(constraints,3,0,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    Label label6 = new Label("Method");				    Label label6 = new Label("Method");
    gridbag.setConstraints(label6, constraints);		    gridbag.setConstraints(label6, constraints);
    add(label6);						    add(label6);
    								    
    //adding Checkboxes						    //adding Checkboxes
    Method = new CheckboxGroup();				    Method = new CheckboxGroup();
    direct = new Checkbox("Direct", Method,true);		    direct = new Checkbox("Direct", Method,true);
    full = new Checkbox("Fully Associative", Method, false);	    full = new Checkbox("Fully Associative", Method, false);
    								    
    buildConstraints(constraints,3,1,2,1,0,100);		    buildConstraints(constraints,3,1,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(direct, constraints);		    gridbag.setConstraints(direct, constraints);
    add(direct);						    add(direct);
    								    
    buildConstraints(constraints,3,2,2,1,0,100);		    buildConstraints(constraints,3,2,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(full, constraints);			    gridbag.setConstraints(full, constraints);
    add(full);							    add(full);
    								    
    buildConstraints(constraints,3,3,1,2,0,100);		    buildConstraints(constraints,3,3,1,2,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    Label label9 = new Label("Cache Size : ",Label.LEFT);	    Label label9 = new Label("Cache Size : ",Label.LEFT);
    gridbag.setConstraints(label9, constraints);		    gridbag.setConstraints(label9, constraints);
    add(label9);						    add(label9);
    								    
    //creating,filling and adding choice buttons		    //creating,filling and adding choice buttons
    CacheSize = new Choice();					    CacheSize = new Choice();
    for (int i = 0; i<Table_of_Cache_Sizes.length; i++){	    for (int i = 0; i<Table_of_Cache_Sizes.length; i++){
      CacheSize.addItem(Table_of_Cache_Sizes[i]+" blocks");	      CacheSize.addItem(Table_of_Cache_Sizes[i]+" blocks");
    }								    }
    								    
    buildConstraints(constraints,4,3,1,2,0,100);		    buildConstraints(constraints,4,3,1,2,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(CacheSize, constraints);		    gridbag.setConstraints(CacheSize, constraints);
    add(CacheSize);						    add(CacheSize);
    								    
    buildConstraints(constraints,0,5,1,1,0,100);		    buildConstraints(constraints,0,5,1,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    Label label11 = new Label("String :",Label.LEFT);		    Label label11 = new Label("String :",Label.LEFT);
    gridbag.setConstraints(label11, constraints);		    gridbag.setConstraints(label11, constraints);
    add(label11);						    add(label11);
    								    
    t_ref_str=new TextField(30);				    t_ref_str=new TextField(30);
    t_ref_str.setText(default_ref_str);				    t_ref_str.setText(default_ref_str);
    								    
    buildConstraints(constraints,1,5,3,1,0,100);		    buildConstraints(constraints,1,5,3,1,0,100);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    gridbag.setConstraints(t_ref_str, constraints);		    gridbag.setConstraints(t_ref_str, constraints);
    add(t_ref_str);						    add(t_ref_str);
    								    
    buildConstraints(constraints,4,5,1,1,0,100);		    buildConstraints(constraints,4,5,1,1,0,100);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    Enter = new Button("Enter");				    Enter = new Button("Enter");
    gridbag.setConstraints(Enter, constraints);			    gridbag.setConstraints(Enter, constraints);
    add(Enter);							    add(Enter);
    								    
    buildConstraints(constraints,4,6,1,1,0,150);		    buildConstraints(constraints,4,6,1,1,0,150);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    Reset = new Button("Default");				    Reset = new Button("Default");
    gridbag.setConstraints(Reset, constraints);			    gridbag.setConstraints(Reset, constraints);
    add(Reset);							    add(Reset);
    								    
    buildConstraints(constraints,4,7,1,1,0,150);		    buildConstraints(constraints,4,7,1,1,0,150);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    Start = new Button("Start");				    Start = new Button("Start");
    gridbag.setConstraints(Start, constraints);			    gridbag.setConstraints(Start, constraints);
    add(Start);							    add(Start);
    								    
    buildConstraints(constraints,4,8,1,1,0,150);		    buildConstraints(constraints,4,8,1,1,0,150);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    Suspend = new Button("Suspend");				    Suspend = new Button("Suspend");
    gridbag.setConstraints(Suspend, constraints);		    gridbag.setConstraints(Suspend, constraints);
    add(Suspend);						    add(Suspend);
    								    
    buildConstraints(constraints,4,9,1,1,0,150);		    buildConstraints(constraints,4,9,1,1,0,150);
    constraints.fill = GridBagConstraints.HORIZONTAL;		    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    Continue = new Button("Resume");				    Continue = new Button("Resume");
    gridbag.setConstraints(Continue, constraints);		    gridbag.setConstraints(Continue, constraints);
    add(Continue);						    add(Continue);
    								    
    if (direct.getState()==true){				    if (direct.getState()==true){
        methodStr = "DIRECT";					        methodStr = "DIRECT";
      }								      }
      else if (full.getState() == true){			      else if (full.getState() == true){
        methodStr = "FULL";					        methodStr = "FULL";
      }								      }

      //policy							      //policy
      if (random.getState()==true){				      if (random.getState()==true){
        policyStr = "RANDOM";					        policyStr = "RANDOM";
      }								      }
      else if (fifo.getState() == true){			      else if (fifo.getState() == true){
        policyStr = "FIFO";					        policyStr = "FIFO";
      }								      }
      else if (lru.getState() == true){				      else if (lru.getState() == true){
	 policyStr = "LRU";						 policyStr = "LRU";
      }								      }
      else if (mru.getState() == true){				      else if (mru.getState() == true){
	 policyStr = "MRU";						 policyStr = "MRU";
      }								      }
    								    
    r =new ReplaceCanvas(default_ref_str,			    r =new ReplaceCanvas(default_ref_str,
			  policyStr,							  policyStr,
			  methodStr,							  methodStr,
			 cache_size );							 cache_size );

    //r.resize(500,200);					    //r.resize(500,200);
    								    
    buildConstraints(constraints,0,6,4,4,0,100);		    buildConstraints(constraints,0,6,4,4,0,100);
    constraints.fill = GridBagConstraints.BOTH;			    constraints.fill = GridBagConstraints.BOTH;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    gridbag.setConstraints(r, constraints);			    gridbag.setConstraints(r, constraints);
    add(r);							    add(r);
    								    
    Exp_Ar = new TextArea(7,10);				    Exp_Ar = new TextArea(7,10);
    Exp_Ar.setEditable(false);					    Exp_Ar.setEditable(false);
    								    
    buildConstraints(constraints,0,10,3,4,0,100);		    buildConstraints(constraints,0,10,3,4,0,100);
    constraints.fill = GridBagConstraints.BOTH;			    constraints.fill = GridBagConstraints.BOTH;
    constraints.anchor = GridBagConstraints.CENTER;		    constraints.anchor = GridBagConstraints.CENTER;
    								    
    gridbag.setConstraints(Exp_Ar, constraints);		    gridbag.setConstraints(Exp_Ar, constraints);
    add(Exp_Ar );						    add(Exp_Ar );
    								    
    buildConstraints(constraints,3,10,1,1,0,80);		    buildConstraints(constraints,3,10,1,1,0,80);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;		    constraints.anchor = GridBagConstraints.EAST;
    								    
    Label label20 = new Label("References:");			    Label label20 = new Label("References:");
    gridbag.setConstraints(label20, constraints);		    gridbag.setConstraints(label20, constraints);
    add(label20);						    add(label20);
    								    
    buildConstraints(constraints,3,11,1,1,0,80);		    buildConstraints(constraints,3,11,1,1,0,80);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;		    constraints.anchor = GridBagConstraints.EAST;
    								    
    Label label21 = new Label("Hits:");				    Label label21 = new Label("Hits:");
    gridbag.setConstraints(label21, constraints);		    gridbag.setConstraints(label21, constraints);
    add(label21);						    add(label21);
    								    
    buildConstraints(constraints,3,12,1,1,0,80);		    buildConstraints(constraints,3,12,1,1,0,80);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;		    constraints.anchor = GridBagConstraints.EAST;
    								    
    Label label22 = new Label("Misses:");			    Label label22 = new Label("Misses:");
    gridbag.setConstraints(label22, constraints);		    gridbag.setConstraints(label22, constraints);
    add(label22);						    add(label22);

    t_num_ref = new TextField(3);				    t_num_ref = new TextField(3);
    t_num_ref.setText(count_num_ref+"");			    t_num_ref.setText(count_num_ref+"");
    t_num_ref.setEditable(false);				    t_num_ref.setEditable(false);
    								    
    buildConstraints(constraints,4,10,1,1,0,100);		    buildConstraints(constraints,4,10,1,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(t_num_ref, constraints);		    gridbag.setConstraints(t_num_ref, constraints);
    add(t_num_ref);						    add(t_num_ref);
    								    
    t_num_hit = new TextField(3);				    t_num_hit = new TextField(3);
    //get count_num_hit?					    //get count_num_hit?
    System.out.println("got hits: "+r.getHits() );		    System.out.println("got hits: "+r.getHits() );
    t_num_hit.setText(r.getHits()+"");				    t_num_hit.setText(r.getHits()+"");
    t_num_hit.setEditable(false);				    t_num_hit.setEditable(false);
    								    
    buildConstraints(constraints,4,11,1,1,0,100);		    buildConstraints(constraints,4,11,1,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(t_num_hit, constraints);		    gridbag.setConstraints(t_num_hit, constraints);
    add(t_num_hit);						    add(t_num_hit);
    								    
    t_num_miss = new TextField(3);				    t_num_miss = new TextField(3);
    //get count_num_miss?					    //get count_num_miss?
    System.out.println("got misses: "+r.getMisses() );		    System.out.println("got misses: "+r.getMisses() );
    t_num_miss.setText(r.getMisses()+"");			    t_num_miss.setText(r.getMisses()+"");
    t_num_miss.setEditable(false);				    t_num_miss.setEditable(false);
    								    
    buildConstraints(constraints,4,12,1,1,0,100);		    buildConstraints(constraints,4,12,1,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    								    
    gridbag.setConstraints(t_num_miss, constraints);		    gridbag.setConstraints(t_num_miss, constraints);
    add(t_num_miss);						    add(t_num_miss);

    buildConstraints(constraints,3,13,2,1,0,100);		    buildConstraints(constraints,3,13,2,1,0,100);
    constraints.fill = GridBagConstraints.NONE;			    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.WEST;		    constraints.anchor = GridBagConstraints.WEST;
    Label L = new Label("");					    Label L = new Label("");
    gridbag.setConstraints(L, constraints);			    gridbag.setConstraints(L, constraints);
    add(L);							    add(L);

  }								  }

//***********************************************************	//***********************************************************
  public void start(){						  public void start(){
      System.out.println("applet started");			      System.out.println("applet started");
      r.Modify();						      r.Modify();
      r.setStr(cur_ref_str);					      r.setStr(cur_ref_str);

      //*    Animation_thread = new Thread(r, "Animation_thre	      //*    Animation_thread = new Thread(r, "Animation_thre
      //*    Animation_thread.start();				      //*    Animation_thread.start();
  }								  }

  //****************************************************	  //****************************************************
  public void stop(){						  public void stop(){
    System.out.println("applet stopped");			    System.out.println("applet stopped");
    if (Animation_thread != null)				    if (Animation_thread != null)
      Animation_thread.stop();					      Animation_thread.stop();
  } 								  } 
  								  
  //****************************************************	  //****************************************************
  public void paint(Graphics g){				  public void paint(Graphics g){
      System.out.println("applet painting");			      System.out.println("applet painting");
      r.Modify();						      r.Modify();
      r.setStr(cur_ref_str);					      r.setStr(cur_ref_str);
      //previous thread.stop					      //previous thread.stop
      if (    Animation_thread != null)				      if (    Animation_thread != null)
           Animation_thread.stop();				           Animation_thread.stop();

      //new thread.start					      //new thread.start
      //*      Animation_thread = new Thread(r, "Animation_th	      //*      Animation_thread = new Thread(r, "Animation_th
      //*Animation_thread.start();				      //*Animation_thread.start();
  }  								  }  
  								  
  //**************************************************		  //**************************************************
  public boolean action(Event e, Object o){			  public boolean action(Event e, Object o){
    								    
    if (e.target == Enter ){					    if (e.target == Enter ){
      cur_ref_str = t_ref_str.getText();			      cur_ref_str = t_ref_str.getText();
	  Exp_Ar.appendText("---------" + cur_ref_str + "---- <

      r.Modify();						      r.Modify();
      r.setStr(cur_ref_str);					      r.setStr(cur_ref_str);

      count_num_ref = getNumEl(cur_ref_str);			      count_num_ref = getNumEl(cur_ref_str);
      t_num_ref.setText(count_num_ref+"");			      t_num_ref.setText(count_num_ref+"");
    }								    }

    if (e.target == CacheSize){					    if (e.target == CacheSize){
      cache_size = Integer.parseInt(((String)e.arg).substring	      cache_size = Integer.parseInt(((String)e.arg).substring
      r.Modify();						      r.Modify();
      r.setCacheSize(cache_size);				      r.setCacheSize(cache_size);
    }								    }
    								    
    if (e.target == Reset){					    if (e.target == Reset){
      cur_ref_str = default_ref_str ;				      cur_ref_str = default_ref_str ;
      t_ref_str.setText(cur_ref_str);				      t_ref_str.setText(cur_ref_str);
      r.Modify();						      r.Modify();
      r.setStr(cur_ref_str);					      r.setStr(cur_ref_str);
      count_num_ref = getNumEl(cur_ref_str);			      count_num_ref = getNumEl(cur_ref_str);
      t_num_ref.setText(count_num_ref+"");			      t_num_ref.setText(count_num_ref+"");

      //previous thread.stop					      //previous thread.stop
      if (    Animation_thread != null)				      if (    Animation_thread != null)
           Animation_thread.stop();				           Animation_thread.stop();

      //new thread.start					      //new thread.start
      Animation_thread = new Thread(r, "Animation_thread");	      Animation_thread = new Thread(r, "Animation_thread");
      Animation_thread.start();					      Animation_thread.start();
    }								    }
    								    
    if (e.target instanceof Checkbox){				    if (e.target instanceof Checkbox){
      //methods							      //methods
      r.Modify();						      r.Modify();

      if (direct.getState()==true){				      if (direct.getState()==true){
        methodStr = "DIRECT";					        methodStr = "DIRECT";
      }								      }
      else if (full.getState() == true){			      else if (full.getState() == true){
        methodStr = "FULL";					        methodStr = "FULL";
      }								      }
      								      
      //policy							      //policy
      r.Modify();						      r.Modify();

      if (random.getState()==true){				      if (random.getState()==true){
        policyStr = "RANDOM";					        policyStr = "RANDOM";
      }								      }
      else if (fifo.getState() == true){			      else if (fifo.getState() == true){
        policyStr = "FIFO";					        policyStr = "FIFO";
      }								      }
      else if (lru.getState() == true){				      else if (lru.getState() == true){
	policyStr = "LRU";						policyStr = "LRU";
      }								      }
      else if (mru.getState() == true){				      else if (mru.getState() == true){
	policyStr = "MRU";						policyStr = "MRU";
      }								      }

       r.setMethod(methodStr);					       r.setMethod(methodStr);
       r.setPolicy( policyStr);					       r.setPolicy( policyStr);
    }								    }

    if (e.target == Suspend){					    if (e.target == Suspend){
      //thread.suspend     					      //thread.suspend     
       if (    Animation_thread != null)			       if (    Animation_thread != null)
             Animation_thread.suspend();			             Animation_thread.suspend();
    }								    }

    if (e.target == Start){					    if (e.target == Start){
      //clear Cache every time					      //clear Cache every time
            r.Modify();						            r.Modify();
            r.setCacheSize(cache_size);				            r.setCacheSize(cache_size);

      //previous thread.stop					      //previous thread.stop
    if (    Animation_thread != null)				    if (    Animation_thread != null)
           Animation_thread.stop();				           Animation_thread.stop();

      //new thread.start					      //new thread.start
    Animation_thread = new Thread(r, "Animation_thread");	    Animation_thread = new Thread(r, "Animation_thread");
    Animation_thread.start();					    Animation_thread.start();
    }								    }

    if (e.target == Continue){					    if (e.target == Continue){
      //thread.resume						      //thread.resume
      if (    Animation_thread != null)				      if (    Animation_thread != null)
             Animation_thread.resume();				             Animation_thread.resume();
    }								    }

    return true;						    return true;
  }								  }

  //******************************************			  //******************************************
  public static void setNumHitsMisses(int h, int m){		  public static void setNumHitsMisses(int h, int m){
    t_num_hit.setText(h+"");					    t_num_hit.setText(h+"");
    t_num_miss.setText(m+"");					    t_num_miss.setText(m+"");
  }								  }
  								  
  //******************************************			  //******************************************
  public static void appendString(String str){			  public static void appendString(String str){
    Exp_Ar.appendText(str);					    Exp_Ar.appendText(str);
  }								  }
  								  
  //**********************************				  //**********************************
  private void buildConstraints(GridBagConstraints gbc, 	  private void buildConstraints(GridBagConstraints gbc, 
			int gx,								int gx,
			int gy,								int gy,
			int gw, 							int gw, 
			int gh,								int gh,
			int wx,								int wx,
			int wy){							int wy){
    gbc.gridx = gx;						    gbc.gridx = gx;
    gbc.gridy = gy;						    gbc.gridy = gy;
    gbc.gridwidth = gw;						    gbc.gridwidth = gw;
    gbc.gridheight = gh;					    gbc.gridheight = gh;
    gbc.weightx = wx;						    gbc.weightx = wx;
    gbc.weighty = wy;						    gbc.weighty = wy;
  }								  }

  //************************************************		  //************************************************
  private int getNumEl(String s){				  private int getNumEl(String s){
    String my_s = new String(s);				    String my_s = new String(s);
    String temp = my_s;						    String temp = my_s;
    String temp_short;						    String temp_short;
    int count = 0;						    int count = 0;
    int j = 1;							    int j = 1;
    								    
    while ((j != -1)||(temp == null)){				    while ((j != -1)||(temp == null)){
      j = my_s.indexOf((int)' ');				      j = my_s.indexOf((int)' ');
      if (j == -1) {						      if (j == -1) {
	temp_short = my_s;						temp_short = my_s;
      }else{							      }else{
	temp = my_s.substring(j+1);					temp = my_s.substring(j+1);
	temp_short = my_s.substring(0,j);				temp_short = my_s.substring(0,j);
      }								      }
      my_s=temp;						      my_s=temp;
      count++; 							      count++; 
    }								    }
    return count;						    return count;
  } //end getNumEl						  } //end getNumEl
}								}
//************* END ********************			//************* END ********************