time.c.svn-base

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

  power->readOp.dynamic *= val;
  power->readOp.leakage *= val;

  power->writeOp.dynamic *= val;
  power->writeOp.leakage *= val;
}
void mac_powerDef(powerDef *sum,powerDef *mult, int val) {
  sum->readOp.dynamic += mult->readOp.dynamic*val;
  sum->readOp.leakage += mult->readOp.leakage*val;

  sum->writeOp.dynamic += mult->writeOp.dynamic*val;
  sum->writeOp.leakage += mult->writeOp.leakage*val;
}
void copy_powerDef(powerDef *dest, powerDef source) {
  dest->readOp.dynamic = source.readOp.dynamic;
  dest->readOp.leakage = source.readOp.leakage;

  dest->writeOp.dynamic = source.writeOp.dynamic;
  dest->writeOp.leakage = source.writeOp.leakage;
}
void copy_and_div_powerDef(powerDef *dest, powerDef source, double val) {

  // only dynamic power needs to be scaled.
  dest->readOp.dynamic = source.readOp.dynamic / val;
  dest->readOp.leakage = source.readOp.leakage;

  dest->writeOp.dynamic = source.writeOp.dynamic / val;
  dest->writeOp.leakage = source.writeOp.leakage;
}

void add_powerDef(powerDef *sum, powerDef a, powerDef b) {

  sum->readOp.dynamic = a.readOp.dynamic + b.readOp.dynamic;
  sum->readOp.leakage = a.readOp.leakage + b.readOp.leakage;

  sum->writeOp.dynamic = a.writeOp.dynamic + b.writeOp.dynamic;
  sum->writeOp.leakage = a.writeOp.leakage + b.writeOp.leakage;
}

double objective_function(double delay_weight, double area_weight, double power_weight,
    double delay,double area,double power)
{
  return
    (double)(area_weight*area + delay_weight*delay + power_weight*power);
}



/*======================================================================*/



/* 
 * This part of the code contains routines for each section as
 * described in the tech report.  See the tech report for more details
 * and explanations */

/*----------------------------------------------------------------------*/

void subbank_routing_length (int C,int B,int A,
    char fullyassoc,
    int Ndbl,double Nspd,int Ndwl,int Ntbl,int Ntwl,int Ntspd,
    double NSubbanks,
    double *subbank_v,double *subbank_h)
{
  double htree;
  int htree_int, tagbits;
  int cols_data_subarray, rows_data_subarray, cols_tag_subarray,
  rows_tag_subarray;
  double inter_v, inter_h, sub_h, sub_v;
  int inter_subbanks;
  int cols_fa_subarray, rows_fa_subarray;

  if (!fullyassoc)
  {

    //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
    //the final int value is the correct one 
    //cols_data_subarray = (8 * B * A * Nspd / Ndwl);
    //rows_data_subarray = (C / (B * A * Ndbl * Nspd));
    cols_data_subarray = (int) ((8 * B * A * Nspd / Ndwl) + EPSILON);
    rows_data_subarray = (int) (C / (B * A * Ndbl * Nspd) + EPSILON);

    if (Ndwl * Ndbl == 1)
    {
      sub_v = rows_data_subarray;
      sub_h = cols_data_subarray;
    }
    else if (Ndwl * Ndbl == 2)
    {
      sub_v = rows_data_subarray;
      sub_h = 2 * cols_data_subarray;
    }
    else if (Ndwl * Ndbl > 2)
    {
      htree = logtwo ((double) (Ndwl * Ndbl));
      //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 = (int) htree;
      htree_int = (int) (htree + EPSILON);
      if (htree_int % 2 == 0)
      {
        sub_v = sqrt (Ndwl * Ndbl) * rows_data_subarray;
        sub_h = sqrt (Ndwl * Ndbl) * cols_data_subarray;
      }
      else
      {
        sub_v = sqrt (Ndwl * Ndbl / 2) * rows_data_subarray;
        sub_h = 2 * sqrt (Ndwl * Ndbl / 2) * cols_data_subarray;
      }
    }
    inter_v = sub_v;
    inter_h = sub_h;

    rows_tag_subarray = C / (B * A * Ntbl * Ntspd);
    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;
    }

    cols_tag_subarray = tagbits * A * Ntspd / Ntwl;

    if (Ntwl * Ntbl == 1)
    {
      sub_v = rows_tag_subarray;
      sub_h = cols_tag_subarray;
    }
    if (Ntwl * Ntbl == 2)
    {
      sub_v = rows_tag_subarray;
      sub_h = 2 * cols_tag_subarray;
    }

    if (Ntwl * Ntbl > 2)
    {
      htree = logtwo ((double) (Ntwl * Ntbl));
      //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 = (int) htree;
      htree_int = (int) (htree + EPSILON);
      if (htree_int % 2 == 0)
      {
        sub_v = sqrt (Ntwl * Ntbl) * rows_tag_subarray;
        sub_h = sqrt (Ntwl * Ntbl) * cols_tag_subarray;
      }
      else
      {
        sub_v = sqrt (Ntwl * Ntbl / 2) * rows_tag_subarray;
        sub_h = 2 * sqrt (Ntwl * Ntbl / 2) * cols_tag_subarray;
      }
    }


    inter_v = MAX (sub_v, inter_v);
    inter_h += sub_h;

    sub_v = 0;
    sub_h = 0;

    if (NSubbanks == 1.0 || NSubbanks == 2.0)
    {
      sub_h = 0;
      sub_v = 0;
    }
    if (NSubbanks == 4.0)
    {
      sub_h = 0;
      sub_v = inter_v;
    }

    inter_subbanks = (int)NSubbanks;

    while ((inter_subbanks > 2) && (NSubbanks > 4))
    {

      sub_v += inter_v;
      sub_h += inter_h;

      inter_v = 2 * inter_v;
      inter_h = 2 * inter_h;
      inter_subbanks = inter_subbanks / 4;

      if (inter_subbanks == 4.0)
      {
        inter_h = 0;
      }

    }
    *subbank_v = sub_v;
    *subbank_h = sub_h;
  }
  else
  {
    rows_fa_subarray = (C / (B * Ndbl));
    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) B);
      tagbits = ADDRESS_BITS + EXTRA_TAG_BITS - (int) (logtwo ((double) B) + EPSILON);
    }
    else {
      tagbits = force_tag_size;
    }
    cols_fa_subarray = (8 * B) + tagbits;

    if (Ndbl == 1)
    {
      sub_v = rows_fa_subarray;
      sub_h = cols_fa_subarray;
    }
    if (Ndbl == 2)
    {
      sub_v = rows_fa_subarray;
      sub_h = 2 * cols_fa_subarray;
    }

    if (Ndbl > 2)
    {
      htree = logtwo ((double) (Ndbl));
      //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 = (int) htree;
      htree_int = (int) (htree + EPSILON);
      if (htree_int % 2 == 0)
      {
        sub_v = sqrt (Ndbl) * rows_fa_subarray;
        sub_h = sqrt (Ndbl) * cols_fa_subarray;
      }
      else
      {
        sub_v = sqrt (Ndbl / 2) * rows_fa_subarray;
        sub_h = 2 * sqrt (Ndbl / 2) * cols_fa_subarray;
      }
    }
    inter_v = sub_v;
    inter_h = sub_h;

    sub_v = 0;
    sub_h = 0;

    if (NSubbanks == 1.0 || NSubbanks == 2.0)
    {
      sub_h = 0;
      sub_v = 0;
    }
    if (NSubbanks == 4.0)
    {
      sub_h = 0;
      sub_v = inter_v;
    }

    inter_subbanks = (int)NSubbanks;

    while ((inter_subbanks > 2) && (NSubbanks > 4))
    {

      sub_v += inter_v;
      sub_h += inter_h;

      inter_v = 2 * inter_v;
      inter_h = 2 * inter_h;
      inter_subbanks = inter_subbanks / 4;

      if (inter_subbanks == 4.0)
      {
        inter_h = 0;
      }

    }
    *subbank_v = sub_v;
    *subbank_h = sub_h;
  }
}

void subbank_dim (int C,int B,int A,
    char fullyassoc,
    int Ndbl,int Ndwl,double Nspd,int Ntbl,int Ntwl,int Ntspd,
    double NSubbanks,
    double *subbank_h,double *subbank_v)
{
  double htree;
  int htree_int, tagbits;
  int cols_data_subarray, rows_data_subarray, cols_tag_subarray,
  rows_tag_subarray;
  double sub_h, sub_v, inter_v, inter_h;
  int cols_fa_subarray, rows_fa_subarray;

  if (!fullyassoc)
  {

    /* calculation of subbank dimensions */
    //v4.1: Fixing double->int type conversion problems. EPSILON is added below to make sure
    //the final int value is the correct one 
    //cols_data_subarray = (8 * B * A * Nspd / Ndwl);
    //rows_data_subarray = (C / (B * A * Ndbl * Nspd));
    cols_data_subarray = (int)(8 * B * A * Nspd / Ndwl + EPSILON);
    rows_data_subarray = (int) (C / (B * A * Ndbl * Nspd) + EPSILON);

    if (Ndwl * Ndbl == 1)
    {
      sub_v = rows_data_subarray;
      sub_h = cols_data_subarray;
    }
    if (Ndwl * Ndbl == 2)
    {
      sub_v = rows_data_subarray;
      sub_h = 2 * cols_data_subarray;
    }
    if (Ndwl * Ndbl > 2)
    {
      htree = logtwo ((double) (Ndwl * Ndbl));
      //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 = (int) htree;
      htree_int = (int) (htree + EPSILON);
      if (htree_int % 2 == 0)
      {
        sub_v = sqrt (Ndwl * Ndbl) * rows_data_subarray;
        sub_h = sqrt (Ndwl * Ndbl) * cols_data_subarray;
      }
      else
      {
        sub_v = sqrt (Ndwl * Ndbl / 2) * rows_data_subarray;
        sub_h = 2 * sqrt (Ndwl * Ndbl / 2) * cols_data_subarray;
      }
    }
    inter_v = sub_v;
    inter_h = sub_h;

    rows_tag_subarray = C / (B * A * Ntbl * Ntspd);

    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;
    }
    cols_tag_subarray = tagbits * A * Ntspd / Ntwl;

    if (Ntwl * Ntbl == 1)
    {
      sub_v = rows_tag_subarray;
      sub_h = cols_tag_subarray;
    }
    if (Ntwl * Ntbl == 2)
    {
      sub_v = rows_tag_subarray;
      sub_h = 2 * cols_tag_subarray;
    }

    if (Ntwl * Ntbl > 2)
    {
      htree = logtwo ((double) (Ntwl * Ntbl));