Example #1
0
  /**
   * Trigger a page of all the destinations.
   *
   * @param inbound The inbound Leg (audio from here goes to all destinations)
   * @param inboundRtp The destination to send RTP packets so the inbound caller can hear.
   * @param alertInfoKey The magic key needed for Polycom Auto-Answer
   * @return
   */
  public boolean page(Leg inbound, InetSocketAddress inboundRtp, String alertInfoKey) {
    if (busy == false) {
      LOG.debug("PageGroup::page starting");
      busy = true;
      this.inbound = inbound;
      this.inboundRtp = inboundRtp;

      // Spin up the RTP forker
      rtpFork.start();
      try {
        // Get the originator for the Page.
        InboundLeg origLeg = (InboundLeg) inbound;
        String pageOriginatorAddress;
        pageOriginatorAddress = origLeg.getAddress();

        // Answer the inbound call.
        inbound.acceptCall(rtpPort);

        // Start the timers
        if (maximumDuration > 0) {
          // Start the maximumDuration timer if it is greater than 0
          Timers.addTimer(
              "maximum_duration", maximumDuration, this); // End this page after this many mS
        }
        Timers.addTimer("beep_start", 1000, this); // Start the beep after this much time

        // Place a call to each destination
        for (String destination : destinations) {
          // Compare the originator with the destination.  Only place an outbound call
          // if they aren't the same.  We don't make a call to the same destination that
          // is initiating the page.
          if (destination.compareToIgnoreCase(pageOriginatorAddress) != 0) {
            Leg outbound =
                placeCall(inbound.getDisplayName(), origLeg.getCallId(), destination, alertInfoKey);
            if (outbound != null) {
              // Keep track of them!
              outbounds.add(outbound);
            }
          } else {
            LOG.info(
                String.format("Skipping %s as it is the page originator.", pageOriginatorAddress));
          }
        }
        return true;
      } catch (Throwable t) {
        LOG.warn("PageGroup::page", t);
        end();
      }
    }
    LOG.debug("PageGroup::page failed");
    return false;
  }
  /**
   * Traverse the statements in the given body, looking for aggregation possibilities; that is,
   * given a def d and a use u, d has no other uses, u has no other defs, collapse d and u.
   *
   * <p>option: only-stack-locals; if this is true, only aggregate variables starting with $
   */
  protected void internalTransform(Body b, String phaseName, Map<String, String> options) {
    StmtBody body = (StmtBody) b;
    boolean onlyStackVars = PhaseOptions.getBoolean(options, "only-stack-locals");

    int aggregateCount = 1;

    if (Options.v().time()) Timers.v().aggregationTimer.start();
    boolean changed = false;

    Map<ValueBox, Zone> boxToZone =
        new HashMap<ValueBox, Zone>(body.getUnits().size() * 2 + 1, 0.7f);

    // Determine the zone of every box
    {
      Zonation zonation = new Zonation(body);

      for (Unit u : body.getUnits()) {
        Zone zone = zonation.getZoneOf(u);

        for (ValueBox box : u.getUseBoxes()) {
          boxToZone.put(box, zone);
        }

        for (ValueBox box : u.getDefBoxes()) {
          boxToZone.put(box, zone);
        }
      }
    }

    do {
      if (Options.v().verbose())
        G.v()
            .out
            .println(
                "["
                    + body.getMethod().getName()
                    + "] Aggregating iteration "
                    + aggregateCount
                    + "...");

      // body.printTo(new java.io.PrintWriter(G.v().out, true));

      changed = internalAggregate(body, boxToZone, onlyStackVars);

      aggregateCount++;
    } while (changed);

    if (Options.v().time()) Timers.v().aggregationTimer.end();
  }
Example #3
0
  /**
   * Constructs a BriefUnitGraph given a Body instance.
   *
   * @param body The underlying body we want to make a graph for.
   */
  public BriefUnitGraph(Body body) {
    super(body);
    int size = unitChain.size();

    if (Options.v().time()) Timers.v().graphTimer.start();

    unitToSuccs = new HashMap(size * 2 + 1, 0.7f);
    unitToPreds = new HashMap(size * 2 + 1, 0.7f);
    buildUnexceptionalEdges(unitToSuccs, unitToPreds);
    makeMappedListsUnmodifiable(unitToSuccs);
    makeMappedListsUnmodifiable(unitToPreds);

    buildHeadsAndTails();

    if (Options.v().time()) Timers.v().graphTimer.end();
  }
Example #4
0
  /**
   * End this page, by clearing up all timers, outbound calls, the inbound call, and the RTP forker.
   *
   * <p>synchronized so multiple calls are serialized. Only the first should be needed.
   */
  public synchronized void end() {
    // Remove all timers associated with me
    Timers.removeTimer(this);

    // Hangup on all outbound calls.
    for (Leg outbound : outbounds) {
      try {
        outbound.destroyLeg();
      } catch (Exception e) {
        LOG.error("PageGroup::end outbound", e);
      }
    }
    outbounds.removeAllElements();

    // Stop the RTP processing.
    rtpFork.stop();
    rtpFork.removeAllDestinations();

    // Hangup on the inbound call
    if (inbound != null) {
      try {
        inbound.destroyLeg();
      } catch (Exception e) {

        LOG.error("PageGroup::end inbound", e);
      }
      inbound = null;
    }
    busy = false;
  }
Example #5
0
  // This method is deprecated. Use soot.util.JasminOutputStream instead.
  public void writeXXXDeprecated(SootClass cl, String outputDir) {
    String outputDirWithSep = "";

    if (!outputDir.equals("")) outputDirWithSep = outputDir + fileSeparator;

    try {
      File tempFile = new File(outputDirWithSep + cl.getName() + ".jasmin");

      FileOutputStream streamOut = new FileOutputStream(tempFile);

      PrintWriter writerOut = new PrintWriter(new EscapedWriter(new OutputStreamWriter(streamOut)));

      if (cl.containsBafBody()) new soot.baf.JasminClass(cl).print(writerOut);
      else new soot.jimple.JasminClass(cl).print(writerOut);

      writerOut.close();

      if (Options.v().time()) Timers.v().assembleJasminTimer.start();

      // Invoke jasmin
      {
        String[] args;

        if (outputDir.equals("")) {
          args = new String[1];

          args[0] = cl.getName() + ".jasmin";
        } else {
          args = new String[3];

          args[0] = "-d";
          args[1] = outputDir;
          args[2] = outputDirWithSep + cl.getName() + ".jasmin";
        }

        jasmin.Main.main(args);
      }

      tempFile.delete();

      if (Options.v().time()) Timers.v().assembleJasminTimer.end();

    } catch (IOException e) {
      throw new RuntimeException("Could not produce new classfile! (" + e + ")");
    }
  }
Example #6
0
 public void onEnable() {
   final Plugin ccapi = Bukkit.getPluginManager().getPlugin("CodCraftAPI");
   if (ccapi == null) {
     getServer().getPluginManager().disablePlugin(this);
   }
   this.api = (CCAPI) ccapi;
   getServer().getPluginManager().registerEvents(new GameListener(this), this);
   LoadSpawns();
   LoadSpawns2();
   timers = new Timers(this);
   timers.GunTimer();
 }
  /**
   * Computes the analysis given a UnitGraph computed from a method body. It is recommended that a
   * ExceptionalUnitGraph (or similar) be provided for correct results in the case of exceptional
   * control flow.
   *
   * @param g a graph on which to compute the analysis.
   * @see ExceptionalUnitGraph
   */
  public SimpleLiveLocals(UnitGraph graph) {
    if (Options.v().time()) Timers.v().liveTimer.start();

    if (Options.v().verbose())
      G.v()
          .out
          .println(
              "["
                  + graph.getBody().getMethod().getName()
                  + "]     Constructing SimpleLiveLocals...");

    SimpleLiveLocalsAnalysis analysis = new SimpleLiveLocalsAnalysis(graph);

    if (Options.v().time()) Timers.v().livePostTimer.start();

    // Build unitToLocals map
    {
      unitToLocalsAfter = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f);
      unitToLocalsBefore = new HashMap<Unit, List>(graph.size() * 2 + 1, 0.7f);

      Iterator unitIt = graph.iterator();

      while (unitIt.hasNext()) {
        Unit s = (Unit) unitIt.next();

        FlowSet set = (FlowSet) analysis.getFlowBefore(s);
        unitToLocalsBefore.put(s, Collections.unmodifiableList(set.toList()));

        set = (FlowSet) analysis.getFlowAfter(s);
        unitToLocalsAfter.put(s, Collections.unmodifiableList(set.toList()));
      }
    }

    if (Options.v().time()) Timers.v().livePostTimer.end();

    if (Options.v().time()) Timers.v().liveTimer.end();
  }
  SimpleLiveLocalsAnalysis(UnitGraph g) {
    super(g);

    if (Options.v().time()) Timers.v().liveSetupTimer.start();

    emptySet = new ArraySparseSet();

    // Create kill sets.
    {
      unitToKillSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f);

      Iterator unitIt = g.iterator();

      while (unitIt.hasNext()) {
        Unit s = (Unit) unitIt.next();

        FlowSet killSet = emptySet.clone();

        Iterator boxIt = s.getDefBoxes().iterator();

        while (boxIt.hasNext()) {
          ValueBox box = (ValueBox) boxIt.next();

          if (box.getValue() instanceof Local) killSet.add(box.getValue(), killSet);
        }

        unitToKillSet.put(s, killSet);
      }
    }

    // Create generate sets
    {
      unitToGenerateSet = new HashMap<Unit, FlowSet>(g.size() * 2 + 1, 0.7f);

      Iterator unitIt = g.iterator();

      while (unitIt.hasNext()) {
        Unit s = (Unit) unitIt.next();

        FlowSet genSet = emptySet.clone();

        Iterator boxIt = s.getUseBoxes().iterator();

        while (boxIt.hasNext()) {
          ValueBox box = (ValueBox) boxIt.next();

          if (box.getValue() instanceof Local) genSet.add(box.getValue(), genSet);
        }

        unitToGenerateSet.put(s, genSet);
      }
    }

    if (Options.v().time()) Timers.v().liveSetupTimer.end();

    if (Options.v().time()) Timers.v().liveAnalysisTimer.start();

    doAnalysis();

    if (Options.v().time()) Timers.v().liveAnalysisTimer.end();
  }
Example #9
0
  public static void main(String args[]) {
    Timers timer = new Timers();
    try {
      // Get the data set path.
      String referenceFile = Utils.getOption('r', args);
      String queryFile = Utils.getOption('q', args);
      if (referenceFile.length() == 0)
        throw new IllegalArgumentException(
            "Required option: File containing" + "the reference dataset.");

      // Load input dataset.
      DataSource source = new DataSource(referenceFile);
      Instances referenceData = source.getDataSet();

      Instances queryData = null;
      if (queryFile.length() != 0) {
        source = new DataSource(queryFile);
        queryData = source.getDataSet();
      }

      timer.StartTimer("total_time");

      // Get all the parameters.
      String leafSize = Utils.getOption('l', args);
      String neighbors = Utils.getOption('k', args);

      // Validate options.
      int k = 0;
      if (neighbors.length() == 0) {
        throw new IllegalArgumentException(
            "Required option: Number of " + "furthest neighbors to find.");
      } else {
        k = Integer.parseInt(neighbors);
        if (k < 1 || k > referenceData.numInstances())
          throw new IllegalArgumentException("[Fatal] Invalid k");
      }

      int l = 20;
      if (leafSize.length() != 0) l = Integer.parseInt(leafSize);

      // Create KDTree.
      KDTree tree = new KDTree();
      tree.setMaxInstInLeaf(l);
      tree.setInstances(referenceData);

      // Perform All K-Nearest-Neighbors.
      if (queryFile.length() != 0) {
        for (int i = 0; i < queryData.numInstances(); i++) {
          Instances out = tree.kNearestNeighbours(queryData.instance(i), k);
        }
      } else {
        for (int i = 0; i < referenceData.numInstances(); i++) {
          Instances out = tree.kNearestNeighbours(referenceData.instance(i), k);
        }
      }

      timer.StopTimer("total_time");
      timer.PrintTimer("total_time");
    } catch (IOException e) {
      System.err.println(USAGE);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Example #10
0
  protected void doAnalysis() {
    LinkedList<Object> changedUnits = new LinkedList<Object>();
    HashSet<Object> changedUnitsSet = new HashSet<Object>();

    int numNodes = graph.size();
    int numComputations = 0;

    // Set initial values and nodes to visit.

    createWorkList(changedUnits, changedUnitsSet);

    // testWorkList(changedUnits);

    // Set initial values for entry points
    {
      Iterator it = graph.getHeads().iterator();

      while (it.hasNext()) {
        Object s = it.next();

        // unitToBeforeFlow.put(s, entryInitialFlow());
        nodes.add(s);
        valueBefore.add(entryInitialFlow());
      }
    }

    // Perform fixed point flow analysis
    {
      Object previousAfterFlow = newInitialFlow();

      while (!changedUnits.isEmpty()) {
        Object beforeFlow;
        Object afterFlow;

        Object s = changedUnits.removeFirst();
        Tag tag = (Tag) ((JPegStmt) s).getTags().get(0);
        // System.out.println("===unit is: "+tag+" "+s);
        changedUnitsSet.remove(s);

        // copy(unitToAfterFlow.get(s), previousAfterFlow);
        // add for debug april 6
        int pos = nodes.indexOf(s);
        copy(valueAfter.elementAt(pos), previousAfterFlow);
        // end add for debug april
        // Compute and store beforeFlow
        {
          List preds = graph.getPredsOf(s);

          // beforeFlow = unitToBeforeFlow.get(s);

          beforeFlow = valueBefore.elementAt(pos);

          if (preds.size() == 1) {
            // copy(unitToAfterFlow.get(preds.get(0)), beforeFlow);
            copy(valueAfter.elementAt(nodes.indexOf(preds.get(0))), beforeFlow);
          } else if (preds.size() != 0) {
            Iterator predIt = preds.iterator();
            Object obj = predIt.next();

            // copy(unitToAfterFlow.get(obj), beforeFlow);
            copy(valueAfter.elementAt(nodes.indexOf(obj)), beforeFlow);

            while (predIt.hasNext()) {
              JPegStmt stmt = (JPegStmt) predIt.next();
              if (stmt.equals(obj)) {
                // System.out.println("!!!same object!!!");
                continue;
              }
              Tag tag1 = (Tag) stmt.getTags().get(0);
              // System.out.println("pred: "+tag1+" "+stmt);

              // Object otherBranchFlow = unitToAfterFlow.get(stmt);
              if (nodes.indexOf(stmt) >= 0) // RLH
              {
                Object otherBranchFlow = valueAfter.elementAt(nodes.indexOf(stmt));

                merge(beforeFlow, otherBranchFlow, beforeFlow);
              }
            }
          }
        }

        // Compute afterFlow and store it.
        {
          // afterFlow = unitToAfterFlow.get(s);
          afterFlow = valueAfter.elementAt(nodes.indexOf(s));
          flowThrough(beforeFlow, s, afterFlow);

          // unitToAfterFlow.put(s, afterFlow);
          valueAfter.set(nodes.indexOf(s), afterFlow);
          // System.out.println("update afterFlow nodes: "+s);
          // System.out.println("afterFlow: "+afterFlow);
          // ((MonitorSet)unitToAfterFlow.get(s)).test();

          numComputations++;
        }

        // Update queue appropriately

        if (!afterFlow.equals(previousAfterFlow)) {

          Iterator succIt = graph.getSuccsOf(s).iterator();

          while (succIt.hasNext()) {
            Object succ = succIt.next();

            if (!changedUnitsSet.contains(succ)) {
              changedUnits.addLast(succ);
              changedUnitsSet.add(succ);
              /*if (succ instanceof JPegStmt){
              Tag tag1 = (Tag)((JPegStmt)succ).getTags().get(0);

              System.out.println("add to worklist: "+tag1+" "+succ);
              }
              else
              System.out.println("add to worklist: "+succ);
              */
            }
          }
        }
      }
    }

    // G.v().out.println(graph.getBody().getMethod().getSignature() + " numNodes: " + numNodes +
    //    " numComputations: " + numComputations + " avg: " + Main.truncatedOf((double)
    // numComputations / numNodes, 2));

    Timers.v().totalFlowNodes += numNodes;
    Timers.v().totalFlowComputations += numComputations;
  }