示例#1
0
  /**
   * histogram
   *
   * <p>Histogram overlap score worst-case = 0.0 and best-case = 1.0
   */
  public static void evaluateCircuitHistogramOverlap(
      LogicCircuit lc, GateLibrary gate_library, Args options) { // output gate _score (average)

    refreshGateAttributes(lc, gate_library);

    // if sequential
    if (options.get_circuit_type() == DNACompiler.CircuitType.sequential) {

      // set initial
      SequentialHelper.setInitialHistogramREUs(lc, gate_library);

      // track
      HashMap<String, ArrayList<ArrayList<double[]>>> track_reus = new HashMap<>();
      for (Gate g : lc.get_Gates()) {
        track_reus.put(g.Name, new ArrayList<ArrayList<double[]>>());
        ArrayList<double[]> copy_hist_reus = new ArrayList<double[]>(g.get_histogram_reus());
        track_reus.get(g.Name).add(copy_hist_reus);
        track_reus.get(g.Name).add(copy_hist_reus); // looks for i-1
      }

      // converge
      SequentialHelper.convergeHistogramREUs(lc, gate_library, options, track_reus);
    }

    // if combinational
    else if (options.get_circuit_type() == DNACompiler.CircuitType.combinational) {
      Evaluate.simulateHistogramREU(lc, gate_library, options);
    }

    double worst_out = Double.MAX_VALUE;

    for (int out = 0; out < lc.get_output_gates().size(); ++out) {
      Gate output = lc.get_output_gates().get(out);
      evaluateGateHistogramOverlap(output);

      if (output.get_scores().get_conv_overlap() < worst_out) {
        worst_out = output.get_scores().get_conv_overlap();
      }
    }

    lc.get_scores().set_conv_overlap(worst_out);
  }
示例#2
0
  /**
   * *********************************************************************
   *
   * <p>Synopsis [ ]
   *
   * <p>*********************************************************************
   */
  public static void simulateHistogramREU(Gate g, GateLibrary gate_library, Args options) {

    if (g.is_unvisited()) {

      g.set_unvisited(false);

      ArrayList<Gate> children = g.getChildren();
      for (Gate child : children) {
        if (child.is_unvisited()) {
          simulateHistogramREU(child, gate_library, options);
        }
      }

      // initialize
      g.get_histogram_reus().clear();
      for (int i = 0; i < g.get_logics().size(); ++i) { // rows in truth table

        g.get_histogram_reus().add(new double[g.get_histogram_bins().get_NBINS()]);
        for (int j = 0; j < g.get_histogram_bins().get_NBINS(); ++j) {
          g.get_histogram_reus().get(i)[j] = 0.0;
        }
      }

      if (g.Type == GateType.OUTPUT_OR || g.Type == GateType.OUTPUT) {
        g.set_histogram_reus(GateUtil.getSumOfGateInputHistograms(g, gate_library, options));
      } else if (g.Type == GateType.AND) {
        g.set_histogram_reus(GateUtil.getANDOfGateInputHistograms(g));
      } else if (g.Type == GateType.NOT || g.Type == GateType.NOR) {
        // 2. For each row: for each bin: for each output bin: add normalizeToValue
        ArrayList<double[]> input_convreus =
            GateUtil.getSumOfGateInputHistograms(g, gate_library, options);
        g.set_in_histogram_reus(input_convreus);

        for (int i = 0; i < input_convreus.size(); ++i) {

          /*if(Args.dontcare_rows.contains(i)) {
              for(int bin=0; bin< g.get_histogram_reus().get(i).length; ++bin) {
                  g.get_histogram_reus().get(i)[bin] = 0.0;
              }
              continue;
          }*/

          double[] convhist = input_convreus.get(i);

          for (int bin = 0; bin < g.get_histogram_bins().get_NBINS(); ++bin) {
            double fractional_counts = convhist[bin];
            double[] xslice = g.get_xfer_hist().get_xfer_interp().get(bin);

            for (int xslice_bin = 0;
                xslice_bin < g.get_histogram_bins().get_NBINS();
                ++xslice_bin) {
              g.get_histogram_reus().get(i)[xslice_bin] += xslice[xslice_bin] * fractional_counts;
            }
          }
        }
      }

      // evaluateGateHistogramOverlap(g); //to compute gate scores

    }
  }
示例#3
0
  /**
   * score = 1 - penalty of histogram overlap score all ON:OFF pairs and report the worst score
   *
   * <p>overlap penalty: for each bin, compute geometric mean of two ON:OFF histogram values, add
   * add bin penalty to total penalty alternative is to penalize the min of the two ON:OFF histogram
   * values
   */
  public static void evaluateGateHistogramOverlap(Gate g) {

    ArrayList<Double> scores_conv_overlap = new ArrayList<Double>();
    ArrayList<Integer> ons = new ArrayList<Integer>();
    ArrayList<Integer> offs = new ArrayList<Integer>();

    // get ons and offs
    for (int i = 0; i < g.get_logics().size(); ++i) {
      if (g.get_logics().get(i) == 1) {
        ons.add(i);
      } else if (g.get_logics().get(i) == 0) {
        offs.add(i);
      }
    }

    // compute scores of all on-off pairs
    for (int on = 0; on < ons.size(); ++on) {
      for (int off = 0; off < offs.size(); ++off) {

        // if(!Args.dontcare_rows.contains(on) && !Args.dontcare_rows.contains(off)) {

        double median_on =
            Math.pow(
                Math.E,
                HistogramUtil.median(
                    g.get_histogram_reus().get(ons.get(on)), g.get_histogram_bins()));
        double median_off =
            Math.pow(
                Math.E,
                HistogramUtil.median(
                    g.get_histogram_reus().get(offs.get(off)), g.get_histogram_bins()));
        double score = 1 - median_off / median_on;
        double overlap_penalty = 0.0;

        // if ON histogram is lower than OFF histogram, broken circuit
        if (score < 0) {
          scores_conv_overlap.add(0.0);
          continue;
        } else {
          double[] on_norm = HistogramUtil.normalize(g.get_histogram_reus().get(ons.get(on)));
          double[] off_norm = HistogramUtil.normalize(g.get_histogram_reus().get(offs.get(off)));

          // penalty is sum of geometric means for each bin
          // total counts have been normalized to 1
          for (int bin = 0; bin < g.get_histogram_bins().get_NBINS(); ++bin) {
            overlap_penalty += Math.sqrt(on_norm[bin] * off_norm[bin]); // geometric mean
            // overlap_penalty += Math.min( on_norm[bin] , off_norm[bin]); //min of the two bin
            // counts
          }
        }
        score = 1 - overlap_penalty;

        scores_conv_overlap.add(score);

        // }
      }
    }

    Collections.sort(scores_conv_overlap);

    g.get_scores().set_conv_overlap(scores_conv_overlap.get(0)); // worst
  }