oneprint.c

spice中支持多层次元件模型仿真的可单独运行的插件源码

      data[numVars++] = pNode->netConc * NNorm;
    }
    if (output->OUTPnConc) {
      data[numVars++] = pNode->nConc * NNorm;
    }
    if (output->OUTPpConc) {
      data[numVars++] = pNode->pConc * NNorm;
    }
    if (output->OUTPeField) {
      data[numVars++] = eField * ENorm;
    }
    if (output->OUTPjc) {
      data[numVars++] = jc * JNorm;
    }
    if (output->OUTPjd) {
      data[numVars++] = jd * JNorm;
    }
    if (output->OUTPjn) {
      data[numVars++] = jn * JNorm;
    }
    if (output->OUTPjp) {
      data[numVars++] = jp * JNorm;
    }
    if (output->OUTPjt) {
      data[numVars++] = jt * JNorm;
    }
    if (output->OUTPuNet) {
      data[numVars++] = pNode->uNet * NNorm / TNorm;
    }
    if (output->OUTPmun) {
      data[numVars++] = mun;
    }
    if (output->OUTPmup) {
      data[numVars++] = mup;
    }
    fwrite((char *) data, sizeof(double), numVars, file);
  }
  FREE(nodeArray);
}

/*
 * XXX This is what the SPARSE element structure looks like. We can't take it
 * from its definition because the include file redefines all sorts of
 * things.  Note that we are violating data encapsulation to find out the
 * size of this thing.
 */
struct MatrixElement {
  spREAL Real;
  spREAL Imag;
  int Row;
  int Col;
  struct MatrixElement *NextInRow;
  struct MatrixElement *NextInCol;
};

void
ONEmemStats(file, pDevice)
  FILE *file;
  ONEdevice *pDevice;
{
  static char *memFormat = "%-20s%10d%10d\n";
  static char *sumFormat = "%20s          %-10d\n";
  unsigned int size;
  unsigned int memory;
  ONEmaterial *pMaterial;
  ONEcontact *pContact;
  int numContactNodes;

  fprintf(file, "----------------------------------------\n");
  fprintf(file, "Device %s Memory Usage:\n", pDevice->name);
  fprintf(file, "Item                     Count     Bytes\n");
  fprintf(file, "----------------------------------------\n");

  size = 1;
  memory = size * sizeof(ONEdevice);
  fprintf(file, memFormat, "Device", size, memory);
  size = pDevice->numNodes - 1;
  memory = size * sizeof(ONEelem);
  fprintf(file, memFormat, "Elements", size, memory);
  size = pDevice->numNodes;
  memory = size * sizeof(ONEnode);
  fprintf(file, memFormat, "Nodes", size, memory);
  size = pDevice->numNodes - 1;
  memory = size * sizeof(ONEedge);
  fprintf(file, memFormat, "Edges", size, memory);

  size = pDevice->numNodes;
  memory = size * sizeof(ONEelem *);
  size = 0;
  for (pMaterial = pDevice->pMaterials; pMaterial; pMaterial = pMaterial->next)
    size++;
  memory += size * sizeof(ONEmaterial);
  size = numContactNodes = 0;
  for (pContact = pDevice->pFirstContact; pContact; pContact = pContact->next) {
    numContactNodes += pContact->numNodes;
    size++;
  }
  memory += size * sizeof(ONEcontact);
  size = numContactNodes;
  memory += size * sizeof(ONEnode *);
  size = 0;
  fprintf(file, "%-20s%10s%10d\n", "Misc Mesh", "n/a", memory);

  size = pDevice->numOrigEquil;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Equil Orig NZ", size, memory);
  size = pDevice->numFillEquil;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Equil Fill NZ", size, memory);
  size = pDevice->numOrigEquil + pDevice->numFillEquil;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Equil Tot  NZ", size, memory);
  size = pDevice->dimEquil;
  memory = size * 4 * sizeof(double);
  fprintf(file, memFormat, "Equil Vectors", size, memory);

  size = pDevice->numOrigBias;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Bias Orig NZ", size, memory);
  size = pDevice->numFillBias;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Bias Fill NZ", size, memory);
  size = pDevice->numOrigBias + pDevice->numFillBias;
  memory = size * sizeof(struct MatrixElement);
  fprintf(file, memFormat, "Bias Tot  NZ", size, memory);
  size = pDevice->dimBias;
  memory = size * 5 * sizeof(double);
  fprintf(file, memFormat, "Bias Vectors", size, memory);

  size = (pDevice->numNodes - 1) * ONEnumEdgeStates +
      pDevice->numNodes * ONEnumNodeStates;
  memory = size * sizeof(double);
  fprintf(file, memFormat, "State Vector", size, memory);
}

void
ONEcpuStats(file, pDevice)
  FILE *file;
  ONEdevice *pDevice;
{
  static char *cpuFormat = "%-20s%10g%10g%10g%10g%10g\n";
  ONEstats *pStats = pDevice->pStats;
  double total;
  int iTotal;

  fprintf(file,
      "----------------------------------------------------------------------\n");
  fprintf(file,
      "Device %s Time Usage:\n", pDevice->name);
  fprintf(file,
      "Item                     SETUP        DC      TRAN        AC     TOTAL\n");
  fprintf(file,
      "----------------------------------------------------------------------\n");

  total = pStats->setupTime[STAT_SETUP] +
      pStats->setupTime[STAT_DC] +
      pStats->setupTime[STAT_TRAN] +
      pStats->setupTime[STAT_AC];
  fprintf(file, cpuFormat, "Setup Time",
      pStats->setupTime[STAT_SETUP],
      pStats->setupTime[STAT_DC],
      pStats->setupTime[STAT_TRAN],
      pStats->setupTime[STAT_AC],
      total);

  total = pStats->loadTime[STAT_SETUP] +
      pStats->loadTime[STAT_DC] +
      pStats->loadTime[STAT_TRAN] +
      pStats->loadTime[STAT_AC];
  fprintf(file, cpuFormat, "Load Time",
      pStats->loadTime[STAT_SETUP],
      pStats->loadTime[STAT_DC],
      pStats->loadTime[STAT_TRAN],
      pStats->loadTime[STAT_AC],
      total);

  total = pStats->orderTime[STAT_SETUP] +
      pStats->orderTime[STAT_DC] +
      pStats->orderTime[STAT_TRAN] +
      pStats->orderTime[STAT_AC];
  fprintf(file, cpuFormat, "Order Time",
      pStats->orderTime[STAT_SETUP],
      pStats->orderTime[STAT_DC],
      pStats->orderTime[STAT_TRAN],
      pStats->orderTime[STAT_AC],
      total);

  total = pStats->factorTime[STAT_SETUP] +
      pStats->factorTime[STAT_DC] +
      pStats->factorTime[STAT_TRAN] +
      pStats->factorTime[STAT_AC];
  fprintf(file, cpuFormat, "Factor Time",
      pStats->factorTime[STAT_SETUP],
      pStats->factorTime[STAT_DC],
      pStats->factorTime[STAT_TRAN],
      pStats->factorTime[STAT_AC],
      total);

  total = pStats->solveTime[STAT_SETUP] +
      pStats->solveTime[STAT_DC] +
      pStats->solveTime[STAT_TRAN] +
      pStats->solveTime[STAT_AC];
  fprintf(file, cpuFormat, "Solve Time",
      pStats->solveTime[STAT_SETUP],
      pStats->solveTime[STAT_DC],
      pStats->solveTime[STAT_TRAN],
      pStats->solveTime[STAT_AC],
      total);

  total = pStats->updateTime[STAT_SETUP] +
      pStats->updateTime[STAT_DC] +
      pStats->updateTime[STAT_TRAN] +
      pStats->updateTime[STAT_AC];
  fprintf(file, cpuFormat, "Update Time",
      pStats->updateTime[STAT_SETUP],
      pStats->updateTime[STAT_DC],
      pStats->updateTime[STAT_TRAN],
      pStats->updateTime[STAT_AC],
      total);

  total = pStats->checkTime[STAT_SETUP] +
      pStats->checkTime[STAT_DC] +
      pStats->checkTime[STAT_TRAN] +
      pStats->checkTime[STAT_AC];
  fprintf(file, cpuFormat, "Check Time",
      pStats->checkTime[STAT_SETUP],
      pStats->checkTime[STAT_DC],
      pStats->checkTime[STAT_TRAN],
      pStats->checkTime[STAT_AC],
      total);

  total = pStats->setupTime[STAT_SETUP] +
      pStats->setupTime[STAT_DC] +
      pStats->setupTime[STAT_TRAN] +
      pStats->setupTime[STAT_AC];
  fprintf(file, cpuFormat, "Misc Time",
      pStats->miscTime[STAT_SETUP],
      pStats->miscTime[STAT_DC],
      pStats->miscTime[STAT_TRAN],
      pStats->miscTime[STAT_AC],
      total);

  fprintf(file, "%-40s%10g%10s%10g\n", "LTE Time",
      pStats->lteTime,
      "", pStats->lteTime);

  total = pStats->totalTime[STAT_SETUP] +
      pStats->totalTime[STAT_DC] +
      pStats->totalTime[STAT_TRAN] +
      pStats->totalTime[STAT_AC];
  fprintf(file, cpuFormat, "Total Time",
      pStats->totalTime[STAT_SETUP],
      pStats->totalTime[STAT_DC],
      pStats->totalTime[STAT_TRAN],
      pStats->totalTime[STAT_AC],
      total);

  iTotal = pStats->numIters[STAT_SETUP] +
      pStats->numIters[STAT_DC] +
      pStats->numIters[STAT_TRAN] +
      pStats->numIters[STAT_AC];
  fprintf(file, "%-20s%10d%10d%10d%10d%10d\n", "Iterations",
      pStats->numIters[STAT_SETUP],
      pStats->numIters[STAT_DC],
      pStats->numIters[STAT_TRAN],
      pStats->numIters[STAT_AC],
      iTotal);
}