area.c.svn-base

模拟多核状态下龙芯处理器的功能

  conservative_NSER = 0;

  //Added by Shyam to make area model sensitive to "change tag" feature

  if(!force_tag) {
	    //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
        //the final int value is the correct one 
		//Tagbits = ADDRESS_BITS + EXTRA_TAG_BITS-(int)logtwo((double)C)+(int)logtwo((double)A)-(int)(logtwo(NSubbanks));
		Tagbits = (int) (ADDRESS_BITS + EXTRA_TAG_BITS-(int)logtwo((double)C)+(int)logtwo((double)A)-(int)(logtwo(NSubbanks)) + EPSILON);
  }
  else {
	    Tagbits = force_tag_size;
	}
 
  //Commented by Shyam Tagbits =
    //baddr - (int) (logtwo_area ((double) (C))) +
    //(int) (logtwo_area ((double) (A))) + 2 - (int) (logtwo_area (NSubbanks));

  noof_rows = (C / (B * A * Ntdbl * Ntspd));
  noof_colns = (Tagbits * A * Ntspd / Ntdwl);
  tagarea.height = ceil((double)(noof_rows)/16.0)*stitch_ramv+(BitHeight1x1+Widthtrack*2*(RWP+ERP+EWP-1))*noof_rows;
  tagarea.width  = noof_colns*(BitWidth1x1+(Widthtrack*2*(RWP+(ERP-conservative_NSER)+EWP-1)+Widthtrack*conservative_NSER));
  /*
  was:
  tagarea.height = ceil((double)(noof_rows)/16.0)*stitch_ramv+(BitHeight16x2+2*Widthtrack*2*(RWP+ERP+EWP-1))*ceil((double)(noof_rows)/2.0);
  tagarea.width = ceil((double)(noof_colns)/16.0)*(BitWidth16x2+16*(Widthtrack*2*(RWP+(ERP-conservative_NSER)+EWP-1)+Widthtrack*conservative_NSER));
  now:
  using single cell for width and height
  */

  //area_all_tagramcells =
    //Ntdwl * Ntdbl * calculate_area (tagarea,
				    //techscaling_factor) * CONVERT_TO_MMSQUARE;
  area_all_tagramcells =  Ntdwl * Ntdbl * tagarea.height *tagarea.width * CONVERT_TO_MMSQUARE;
  return (tagarea);
}

area_type
decodetag_row (int baddr,int C,int B,int A,int Ntdbl,int Ntspd,int Ntdwl,double NSubbanks,int RWP,int ERP,int EWP)	/* returns area of post decode */
{
  int numstack, Tagbits;
  double decodeNORwidth;
  area_type decinv, worddriveinv, postdecodearea;

  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
  //the final int value is the correct one 
  //Tagbits =
    //baddr - logtwo_area ((double) (C)) + logtwo_area ((double) (A)) + 2 -
    //logtwo_area ((double) (NSubbanks));
  Tagbits = (int) (baddr - logtwo_area ((double) (C)) + logtwo_area ((double) (A)) + 2 -
    logtwo_area ((double) (NSubbanks)) + EPSILON);

  //v4.1: using integer casting below 
  //numstack =
    //ceil ((1.0 / 3.0) *
	  //logtwo_area ((double)
		       //((double) C / (double) (B * A * Ntdbl * Ntspd))));
  numstack =
    (int) (ceil ((1.0 / 3.0) *
	  logtwo_area ((double)
		       ((double) C / (double) (B * A * Ntdbl * Ntspd)))));
  if (numstack == 0)
    numstack = 1;
  if (numstack > 5)
    numstack = 5;
  switch (numstack)
    {
    case 1:
      decodeNORwidth = WidthNOR1;
      break;
    case 2:
      decodeNORwidth = WidthNOR2;
      break;
    case 3:
      decodeNORwidth = WidthNOR3;
      break;
    case 4:
      decodeNORwidth = WidthNOR4;
      break;
    case 5:
      decodeNORwidth = WidthNOR4;
      break;
    default:
      printf ("error:numstack=%d\n", numstack);
      printf ("Cacti does not support a series stack of %d transistors !\n",
	      numstack);
      exit (0);
      break;

    }
  decinv = inverter_area (Wdecinvp, Wdecinvn);
  worddriveinv = inverter_area (Wdecinvp, Wdecinvn);
  /*
  postdecodearea.height = (BitHeight16x2+2*Widthtrack*2*(RWP+ERP+EWP-1));
  */
  postdecodearea.height = (2*BitHeight1x1+2*Widthtrack*2*(RWP+ERP+EWP-1));
  postdecodearea.width =
    (decodeNORwidth + decinv.height + worddriveinv.height) * (RWP + ERP +
							      EWP);
  return (postdecodearea);
}

area_type
comparatorbit (int RWP,int ERP,int EWP)
{
  area_type compbit_area;
  compbit_area.width = 3 * Widthcontact + 2 * (3 * Wpoly + 2 * ptocontact);
  compbit_area.height = (Wcompn + 2 * (2 * Widthcontact + 1 / FUDGEFACTOR)) * (RWP + ERP);
  return (compbit_area);
}

area_type
muxdriverdecode (int B,int b0,int RWP,int ERP,int EWP)
{
  int noof_rows;
  area_type muxdrvdecode_area, predecode, postdecode;
  noof_rows = (8 * B) / b0;
  predecode = predecode_area (noof_rows, RWP, ERP, EWP);
  postdecode = postdecode_area (noof_rows, RWP, ERP, EWP);
  muxdrvdecode_area.width =
    predecode.height + postdecode.width + noof_rows * Widthtrack * (RWP +
								    ERP +
								    EWP);
  muxdrvdecode_area.height = MAX (predecode.width, postdecode.height);
  return (muxdrvdecode_area);
}

area_type
muxdrvsig (int A,int B,int b0)		/* generates the 8B/b0*A signals */
{
  int noof_rows;
  area_type outdrvsig_area;
  area_type muxdrvsig_area;
  noof_rows = (8 * B) / b0;
  //debug
  muxdrvsig_area.height = 0;
  muxdrvsig_area.width = 0;

  outdrvsig_area.height =
    0.5 * (WmuxdrvNORn + WmuxdrvNORp) + 9 * Widthcontact + 0.5 * (Wmuxdrv3n +
								  Wmuxdrv3p) +
    Widthptondiff + 3 * Widthcontact; 
  outdrvsig_area.width =
    (3 * Widthcontact + 2 * (3 * Wpoly + 2 * ptocontact)) * noof_rows;
  switch (A)
    {
    case 1:
      muxdrvsig_area.height =
	outdrvsig_area.height + noof_rows * Widthtrack * 2 + A * Widthtrack;
      muxdrvsig_area.width =
	outdrvsig_area.width + noof_rows * Widthtrack + A * Widthtrack;
      break;
    case 2:
      muxdrvsig_area.height =
	outdrvsig_area.height * 2 + noof_rows * Widthtrack * 3 +
	A * Widthtrack;
      muxdrvsig_area.width =
	outdrvsig_area.width + noof_rows * Widthtrack + A * Widthtrack;
      break;
    case 4:
      muxdrvsig_area.height =
	outdrvsig_area.height * 2 + noof_rows * Widthtrack * 5 +
	A * Widthtrack;
      muxdrvsig_area.width =
	outdrvsig_area.width * 2 + noof_rows * Widthtrack + A * Widthtrack;
      break;
    case 8:
      muxdrvsig_area.height =
	outdrvsig_area.height * 2 + noof_rows * Widthtrack * 9 +
	A * Widthtrack;
      muxdrvsig_area.width =
	outdrvsig_area.width * 4 + noof_rows * Widthtrack + A * Widthtrack;
      break;
    case 16:
      muxdrvsig_area.height =
	outdrvsig_area.height * 4 + noof_rows * Widthtrack * 18 +
	A * Widthtrack;
      muxdrvsig_area.width =
	outdrvsig_area.width * 4 + noof_rows * Widthtrack + A * Widthtrack;
      break;
    case 32:
      muxdrvsig_area.height =
	outdrvsig_area.height * 4 + noof_rows * Widthtrack * 35 +
	2 * A * Widthtrack;
      muxdrvsig_area.width =
	2 * (outdrvsig_area.width * 4 + noof_rows * Widthtrack +
	     A * Widthtrack);
      break;
    default:
      printf ("error:Associativity=%d\n", A);
    }

  return (muxdrvsig_area);
}


area_type
datasubarray (int C,int B,int A,int Ndbl,int Ndwl,double Nspd,int RWP,int ERP,int EWP,int NSER,
	      double techscaling_factor)
{

  //area_type datasubarray_area, mem_area, postdecode_area, colmux_area,
    //precharge_area, senseamp_area, outdrv_area;
  area_type datasubarray_area, mem_area, postdecode_area, colmux_area,
    precharge_area, senseamp_area;
  mem_area =
    subarraymem_area (C, B, A, Ndbl, Ndwl, Nspd, RWP, ERP, EWP, NSER,
		      techscaling_factor);
  postdecode_area = decodemem_row (C, B, A, Ndbl, Nspd, Ndwl, RWP, ERP, EWP);
  colmux_area = colmux (Ndbl, Nspd, RWP, ERP, EWP, NSER);
  precharge_area = precharge (Ndbl, Nspd, RWP, ERP, EWP, NSER);
  senseamp_area = senseamp (Ndbl, Nspd, RWP, ERP, EWP, NSER);
  datasubarray_area.height =
    mem_area.height + colmux_area.height + precharge_area.height +
    senseamp_area.height + DatainvHeight * (RWP + EWP) +
    OutdriveHeight * (RWP + ERP);
  datasubarray_area.width = mem_area.width + postdecode_area.width;

  return (datasubarray_area);
}

area_type
datasubblock (int C,int B,int A,int Ndbl,int Ndwl,double Nspd,int SB,int b0,int RWP,int ERP,int EWP,int NSER,
	      double techscaling_factor)
{
  int N3to8;
  int colmuxtracks_rem, outrdrvtracks_rem, writeseltracks_rem;
  int SB_;
  double tracks_h, tracks_w;
  area_type datasubarray_area, datasubblock_area;
  SB_ = SB;
  if (SB_ == 0)
    {
      SB_ = 1;
    }
  colmuxtracks_rem =
    (Ndbl * Nspd >
     tracks_precharge_p) ? (Ndbl * Nspd - tracks_precharge_p) : 0;
  outrdrvtracks_rem =
    ((2 * B * A) / (b0) >
     tracks_outdrvselinv_p) ? ((2 * B * A) / (b0) -
			       tracks_outdrvselinv_p) : 0;
  writeseltracks_rem =
    ((2 * B * A) / (b0) >
     tracks_precharge_nx2) ? ((2 * B * A) / (b0) - tracks_precharge_nx2) : 0;
 //v4.1: using integer casting below 
  //N3to8 =
    //ceil ((1.0 / 3.0) * logtwo_area ((double) (C / (B * A * Ndbl * Nspd))));
 N3to8 =
    (int) (ceil ((1.0 / 3.0) * logtwo_area ((double) (C / (B * A * Ndbl * Nspd)))));
  if (N3to8 == 0)
    {
      N3to8 = 1;
    }

  tracks_h =
    Widthtrack * (N3to8 * 8 * (RWP + ERP + EWP) +
		  (RWP + EWP) * colmuxtracks_rem + Ndbl * Nspd * ERP +
		  4 * outrdrvtracks_rem * (RWP + ERP) +
		  4 * writeseltracks_rem * (RWP + EWP) + (RWP + ERP +
							  EWP) * b0 / SB_);
  tracks_w = Widthtrack * (N3to8 * 8) * (RWP + ERP + EWP);
  datasubarray_area =
    datasubarray (C, B, A, Ndbl, Ndwl, Nspd, RWP, ERP, EWP, NSER,
		  techscaling_factor);
  datasubblock_area.height = 2 * datasubarray_area.height + tracks_h;
  datasubblock_area.width = 2 * datasubarray_area.width + tracks_w;

  return (datasubblock_area);
}

area_type
dataarray (int C,int B,int A,int Ndbl,int Ndwl,double Nspd,int b0,int RWP,int ERP,int EWP,int NSER,
	   double techscaling_factor)
{
  int SB, N3to8;
  area_type dataarray_area, datasubarray_area, datasubblock_area;
  area_type temp;
  double temp_aspect;
  double fixed_tracks_internal, fixed_tracks_external, variable_tracks;
  double data, driver_select, colmux, predecode, addresslines;
  int blocks, htree, htree_half, i, multiplier, iter_height;
  double inter_height, inter_width, total_height, total_width;

  SB = Ndwl * Ndbl / 4;
  //v4.1: using integer casting below 
  //N3to8 =
    //ceil ((1.0 / 3.0) * logtwo_area ((double) (C / (B * A * Ndbl * Nspd))));
  N3to8 =
    (int) (ceil ((1.0 / 3.0) * logtwo_area ((double) (C / (B * A * Ndbl * Nspd)))));
  if (N3to8 == 0)
    {
      N3to8 = 1;
    }

  data = b0 * (RWP + ERP + EWP) * Widthtrack;
  driver_select = (2 * RWP + ERP + EWP) * 8 * B * A / b0 * Widthtrack;
  colmux = Ndbl * Nspd * (RWP + EWP + ERP) * Widthtrack;
  predecode = (RWP + ERP + EWP) * N3to8 * 8 * Widthtrack;
  addresslines = ADDRESS_BITS * (RWP + ERP + EWP) * Widthtrack;

  fixed_tracks_internal = colmux + predecode + driver_select;
  fixed_tracks_external = colmux + driver_select + addresslines;
  variable_tracks = data;

  datasubarray_area =
    datasubarray (C, B, A, Ndbl, Ndwl, Nspd, RWP, ERP, EWP, NSER,
		  techscaling_factor);
  datasubblock_area =
    datasubblock (C, B, A, Ndbl, Ndwl, Nspd, SB, b0, RWP, ERP, EWP, NSER,
		  techscaling_factor);
  //area_all_datasubarrays =
    //Ndbl * Ndwl * calculate_area (datasubarray_area,
				  //techscaling_factor) * CONVERT_TO_MMSQUARE;
  area_all_datasubarrays = Ndbl * Ndwl * datasubarray_area.height * datasubarray_area.width * CONVERT_TO_MMSQUARE;


  if (SB == 0)
    {
      if (Ndbl * Ndwl == 1)
	{
	  total_height =
	    datasubarray_area.height + fixed_tracks_external + data;
	  total_width = datasubarray_area.width + predecode;
	}
      else
	{
	  total_height =
	    2 * datasubarray_area.height + fixed_tracks_external + data;
	  total_width = datasubarray_area.width + predecode;
	}
    }
  else if (SB == 1)
    {
      total_height = datasubblock_area.height;
      total_width = datasubblock_area.width;
    }
  else if (SB == 2)
    {
      total_height = datasubblock_area.height;
      total_width =
	2 * datasubblock_area.width + fixed_tracks_external + data;
    }
  else if (SB == 4)
    {
      total_height =
	2 * datasubblock_area.height + fixed_tracks_external + data;
      total_width =
	2 * datasubblock_area.width + fixed_tracks_internal +
	variable_tracks / 2;
    }
  else if (SB == 8)
    {
      total_height =
	2 * datasubblock_area.height + fixed_tracks_internal +
	variable_tracks / 2;
      total_width =
	2 * (2 * datasubblock_area.width + variable_tracks / 4) +
	fixed_tracks_external + data;
    }

  else if (SB > 8)
    {
      blocks = SB / 4;
	  //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
      //the final int value is the correct one 
      //htree = (int) (logtwo_area ((double) (blocks)));
	  htree = (int) (logtwo_area ((double) (blocks)) + EPSILON);
      inter_height = datasubblock_area.height;
      inter_width = datasubblock_area.width;
      multiplier = 1;

      if (htree % 2 == 0)
	{
	  iter_height = htree / 2;
	}

      if (htree % 2 == 0)
	{
	  for (i = 0; i <= iter_height; i++)
	    {