Ejemplo n.º 1
0
  /**
   * This method will modify the existing transfers. It will only modify those who are taking more
   * than their fairshare. It will modify them proportional to their bandwidth, i.e. the more share
   * they have, the more they will be cut.
   *
   * @invariant availableBandwidthInBPS >= bps
   * @param bps the target bandwidth
   * @throws Exception
   */
  private void makeRoomFor(final double bps) throws Exception {
    double fairShare = totalBandwidthInBPS / (double) (transfers.size() + 1);

    // assert less than fair  share
    // A.ssert(bps <=  getNextTransferBandwidth());

    ArrayList<Transfer> trespassingTransfers = new ArrayList<Transfer>();

    sanityCheck();

    // this will only be true if the fair share is larger than the available bandwidth
    if (bps > availableInBPS) // if this is true, then there is trespassing transfers
    {
      final double amountToReclaim = bps - availableInBPS;
      double actualReclaimed = 0;

      double total = 0;
      for (Transfer t : transfers) {
        if (t.bandwidthInBPS > fairShare) {
          trespassingTransfers.add(t);
          total += t.bandwidthInBPS;
        }
      }

      // sort them ascending by bandwidth
      Collections.sort(
          trespassingTransfers,
          new Comparator<Transfer>() {
            public int compare(Transfer o1, Transfer o2) {
              return (int) (o1.bandwidthInBPS - o2.bandwidthInBPS);
            }
          });

      double extra = 0;

      for (Transfer t : trespassingTransfers) {
        double deduction = amountToReclaim * t.bandwidthInBPS / total;

        deduction = Math.ceil(deduction); // to prevent future rounding errors, avoid fractions

        if (t.bandwidthInBPS - deduction < fairShare) {
          double oldDeduction = deduction;
          deduction = t.bandwidthInBPS - fairShare;
          extra += oldDeduction - deduction;
        } else if (t.bandwidthInBPS - deduction > fairShare && extra > 0) {
          // take from extra
          double oldDeduction = deduction;
          double newBW = t.bandwidthInBPS - deduction;
          double diffFromFairShare = newBW - fairShare;
          if (diffFromFairShare > extra) {
            double takeFromExtra = extra;
            deduction += takeFromExtra;
          } else // diff <= extra
          {
            double takeFromExtra = diffFromFairShare;
            deduction += takeFromExtra;
          }
          extra -= oldDeduction - deduction;
        }

        deduction = Math.ceil(deduction);

        actualReclaimed += deduction;

        BandwidthManager remoteBwm = t.getOtherBandwidthManagerThan(this);
        A.ssert(remoteBwm != this);
        // remoteBwm.sanityCheck();

        if (deduction < BANDWIDTH_TOL) continue;

        double newBw = t.bandwidthInBPS - deduction;
        t.setNextEpochBW(newBw);
      }

      HashSet<BandwidthManager> candidates = new HashSet<BandwidthManager>();

      for (Transfer t : trespassingTransfers) {
        if (t.getNextEpochBW() < 0) continue;

        double deducted = t.bandwidthInBPS - t.getNextEpochBW();

        t.applyNextEpochBW();

        BandwidthManager remoteBWM = t.getOtherBandwidthManagerThan(this);

        remoteBWM.availableInBPS += deducted;

        candidates.add(remoteBWM);
      }

      availableInBPS += actualReclaimed;
      A.ssert(availableInBPS > bps || Math.abs(availableInBPS - bps) < BANDWIDTH_TOL);

      // we are going to lie about our available bandwidth cuz we are reserving bps of them.
      // availableInBPS -= bps;
      double oldVal = availableInBPS;
      availableInBPS = 0;
      for (BandwidthManager bwm : candidates) bwm.boostLocalTransfers();
      // availableInBPS += bps;
      availableInBPS = oldVal;
    }

    A.ssert(availableInBPS > bps || Math.abs(availableInBPS - bps) < BANDWIDTH_TOL);
  }
Ejemplo n.º 2
0
  /**
   * This method does bandwidth allocation. This method should be used only for upload bandwidth
   * managers.
   *
   * @param remoteNodeId
   * @param message
   * @param bytes
   * @throws Exception
   */
  public Transfer sendBytes(int remoteNodeId, Message message, long bytes) throws Exception {
    // System.out.print("Send Bytes: ");

    // the delay is only used as a minimum possible delay in case the bandwidth delay is less that
    // it
    // in other words, the final delay will not be less that 'delay'.
    long delay = 0; // delayManager.getDelay(this.nodeId, remoteNodeId);

    BandwidthManager remoteBandwidthManager = network.get(remoteNodeId).getDownBandwidthManager();

    sanityCheck();
    remoteBandwidthManager.sanityCheck();

    double bandwidthInBPS =
        Math.min(getNextTransferBandwidth(), remoteBandwidthManager.getNextTransferBandwidth());

    bandwidthInBPS =
        Math.floor(bandwidthInBPS); // to prevent future rounding errors, prevent fractions

    // ms =  b/(b/ms)
    long timeInMilliSec =
        Math.max((long) UnitConversion.secToMilliSec(bytes / (bandwidthInBPS)), /*delay*/ 0);

    long now = scheduler.now;

    message.setDest(remoteNodeId);
    message.setSource(this.nodeId);
    message.setBytes(bytes);

    MessageDeliveryEvent evt = new MessageDeliveryEvent(now + timeInMilliSec, message);

    Transfer trns = new Transfer(bandwidthInBPS, this, remoteBandwidthManager, bytes, evt);
    message.setTransfer(trns);
    trns.setMessage(message); // for debug purposes only

    sanityCheck();
    remoteBandwidthManager.sanityCheck();

    this.makeRoomFor(bandwidthInBPS);
    this.availableInBPS -= bandwidthInBPS;

    remoteBandwidthManager.makeRoomFor(bandwidthInBPS);
    remoteBandwidthManager.availableInBPS -= bandwidthInBPS;

    // this must not be done before we call makeRoomFor,
    // cuz that function depend on the old size of the transfers array List
    // and it depends on the old availableInBPS
    transfers.add(trns);
    remoteBandwidthManager.transfers.add(trns);

    sanityCheck();
    remoteBandwidthManager.sanityCheck();

    scheduler.enqueue(evt);

    P.rint(
        "t( "
            + scheduler.now
            + " ) SEND BYTES ("
            + message.getSource()
            + "->"
            + message.getDest()
            + ") "
            + "["
            + bytes
            + " b] , alloc_bw = "
            + bandwidthInBPS
            + " BPS of "
            + totalBandwidthInBPS
            + ", curr_trans = "
            + transfers.size()
            + "/ "
            + remoteBandwidthManager.transfers.size()
            + ", time_est. = "
            + timeInMilliSec
            + " ms, delvr = "
            + evt.getTime()
            + ", "
            + message.toString());

    return trns;
  }