Пример #1
0
  private int recombine_partitions() {

    int result = 0;

    int last_cut = -1;
    int curr_cut = 0;

    for (curr_cut = 0; curr_cut < cont.size() - 2; curr_cut++) {
      if (greedyCuts[curr_cut]) {
        break;
      }
    }

    for (int i = curr_cut + 1; i < cont.size() - 2; i++) {

      if (greedyCuts[i]) {

        // last_cut + 1 ... curr_cut
        // curr_cut + 1 ... i

        FusionInfo f_all = getFusionInfo(last_cut + 1, i);

        if (f_all.getCost().getCost() <= f_all.getWorkEstimateNoPenalty()
            && !does_peek(curr_cut + 1)) {

          greedyCuts[curr_cut] = false;
          // System.out.println("recombining adjacent partitions!");
          // System.out.println("recomb: ["+(last_cut+1)+
          //                   ","+curr_cut+","+i+"]");

          curr_cut = i;
          result--;

        } else {

          last_cut = curr_cut;
          curr_cut = i;
        }
      }
    }

    FusionInfo f_all = getFusionInfo(last_cut + 1, cont.size() - 1);

    if (f_all.getCost().getCost() <= f_all.getWorkEstimateNoPenalty() && !does_peek(curr_cut + 1)) {
      greedyCuts[curr_cut] = false;

      // System.out.println("recombining adjacent partitions!");
      // System.out.println("recomb: ["+(last_cut+1)+
      //                   ","+curr_cut+","+(cont.size()-1)+"]");

      result--;
    }

    return result;
  }
Пример #2
0
  public FusionInfo getFusionInfo(int from, int to) {

    // check if we have precomputed
    if (fusion_info[from][to] != null) return fusion_info[from][to];

    long work = 0;
    long work_no_penalty = 0;
    int code = 0;
    int data = 0;

    int mult[] = new int[cont.size()];
    mult[from] = 1; // init mult. of first item to 1

    for (int i = from; i < to; i++) {
      int push = childConfig(i).getFusionInfo().getPushInt() * mult[i];
      int pop = childConfig(i + 1).getFusionInfo().getPopInt();

      int common = gcd(push, pop);
      int xtra = pop / common;

      if (xtra > 1) {
        for (int a = from; a <= i; a++) {
          mult[a] = mult[a] * xtra;
        }
      }

      mult[i + 1] = (push * xtra) / pop;
    }

    for (int i = from; i <= to; i++) {
      CConfig child = childConfig(i);

      FusionInfo fi = child.getFusionInfo();
      work += fi.getWorkEstimate();
      work_no_penalty += fi.getWorkEstimateNoPenalty();

      code += fi.getCodeSize() * mult[i];
      data += fi.getDataSize(); // * mult[i]; // removed Nov-15-2004

      // removed Nov-15-2004
      // if (i < to) data += fi.getOutputSize() * fi.getPushInt() * mult[i] * 2;

      // add impossible unroll penalty
      if (KjcOptions.unroll < mult[i]) work += fi.getWorkEstimate() / 2;

      // If peek ratio is 1024 add fusion peek overhead!
      if (KjcOptions.peekratio >= 1024) {
        if (i > from && child instanceof CConfigFilter) {
          CConfigFilter fc = (CConfigFilter) child;
          SIRFilter filter = (SIRFilter) fc.getStream();

          int f_pop = filter.getPopInt();
          int f_peek = filter.getPeekInt();
          int f_extra = f_peek - f_pop;

          if (f_extra > 0) { // peek > pop

            // only penalize if peek rate < 25% of (peek-pop)

            // System.out.print("[ extra:"+f_extra+"("+(f_pop * mult[i] * 4)+") pop:"+f_pop+"
            // m:"+mult[i]+" ]");

            if (f_extra > f_pop * mult[i] * 4) {
              // work += fi.getWorkEstimate()/2;
              // work += 1500;
              // System.out.print("penalty!!");
            }

            // System.out.println();

          }
        }

        if (i > from && child instanceof CConfigSplitJoin) {
          CConfigSplitJoin sj = (CConfigSplitJoin) child;
          if (sj.getPeek()) {
            // work += fi.getWorkEstimate()/2;
            // work += 1500;
          }
        }
      }
    }

    int to_push = childConfig(to).getFusionInfo().getPushInt();
    int from_pop = childConfig(from).getFusionInfo().getPopInt();
    int from_peek = childConfig(from).getFusionInfo().getPeekInt();

    fusion_info[from][to] =
        new FusionInfo(
            work,
            work_no_penalty,
            code,
            data,
            from_pop * mult[from],
            from_pop * mult[from] + (from_peek - from_pop),
            to_push * mult[to],
            childConfig(from).getFusionInfo().getInputSize(),
            childConfig(to).getFusionInfo().getOutputSize());

    return fusion_info[from][to];
  }
Пример #3
0
  private int numberOfTiles(int from, int to) {

    // System.out.println("Pipeline.numberOfTiles("+from+","+to+")");

    if (from > to) return 0;
    if (from == to) return childConfig(from).numberOfTiles();

    for (int i = from; i <= to; i++) {
      int child_tiles = childConfig(i).numberOfTiles();
      if (child_tiles > 1) {
        int left = numberOfTiles(from, i - 1);
        int right = numberOfTiles(i + 1, to);

        if (i > 0) greedyCuts[i - 1] = true;
        if (i < cont.size() - 1) greedyCuts[i] = true;

        return left + child_tiles + right;
      }
    }

    // all children fit into one tile each

    // first try fusing everything

    FusionInfo f_all = getFusionInfo(from, to);

    // System.out.println("try one tile
    // ["+f_all.getCost().getCost()+","+f_all.getWorkEstimateNoPenalty()+"]");

    if (f_all.getCost().getCost() <= f_all.getWorkEstimateNoPenalty()) {

      // System.out.println("pipeline segnemt fits into one tile!");
      return 1;
    }

    // find multiplicity of filters

    int mult[] = new int[cont.size()];
    mult[from] = 1; // init mult. of first item to 1

    for (int i = from; i < to; i++) {
      int push = childConfig(i).getFusionInfo().getPushInt() * mult[i];
      int pop = childConfig(i + 1).getFusionInfo().getPopInt();

      int common = gcd(push, pop);
      int xtra = pop / common;

      if (xtra > 1) {
        for (int a = from; a <= i; a++) {
          mult[a] = mult[a] * xtra;
        }
      }

      mult[i + 1] = (push * xtra) / pop;
    }

    // find max bandwidth connection

    int max_size = 0;
    int max_loc = 0;

    for (int i = from; i < to; i++) {

      int size = childConfig(i).getFusionInfo().getPushInt() * mult[i];
      if (size > max_size) {
        max_size = size;
        max_loc = i;
      }
    }

    // System.out.println("max_size: "+max_size+" max_loc: "+max_loc);

    int f_start = max_loc;
    int f_end = max_loc + 1;

    FusionInfo _fi = getFusionInfo(f_start, f_end);

    if (_fi.getCost().getCost() > _fi.getWorkEstimateNoPenalty()) {

      // can not fuse f_start and f_end
      // make cut between f_start and f_end

      int left = numberOfTiles(from, f_start);
      int right = numberOfTiles(f_end, to);

      greedyCuts[f_start] = true;

      return left + right;
    }

    // fuse up and down starting with (max_loc, max_loc + 1) while cant fuse

    boolean can_fuse_up = true, can_fuse_down = true;

    for (; ; ) {

      // check if still can fuse up
      if (can_fuse_up) {
        if (f_start == from) {
          can_fuse_up = false;
        } else {
          FusionInfo fi = getFusionInfo(f_start - 1, f_end);
          if (fi.getCost().getCost() > fi.getWorkEstimateNoPenalty()) {
            can_fuse_up = false;
          }
        }
      }

      // check if still can fuse down
      if (can_fuse_down) {
        if (f_end == to) {
          can_fuse_down = false;
        } else {
          FusionInfo fi = getFusionInfo(f_start, f_end + 1);
          if (fi.getCost().getCost() > fi.getWorkEstimateNoPenalty()) {
            can_fuse_down = false;
          }
        }
      }

      if (can_fuse_up && can_fuse_down) {
        f_start -= 1;
      }
      if (can_fuse_up && !can_fuse_down) {
        f_start -= 1;
      }
      if (!can_fuse_up && can_fuse_down) {
        f_end += 1;
      }

      if (!can_fuse_up && !can_fuse_down) {

        // System.out.println("done fusing ["+f_start+","+f_end+"]");

        int left = numberOfTiles(from, f_start - 1);
        int right = numberOfTiles(f_end + 1, to);

        if (f_start > 0) greedyCuts[f_start - 1] = true;
        if (f_end < cont.size() - 1) greedyCuts[f_end] = true;

        return left + right + 1;
      }
    }
  }