Exemplo n.º 1
0
  public List<TravelQuote> getRankedTravelQuotes(
      TravelInfo travelInfo,
      Set<TravelCompany> companies,
      Comparator<TravelQuote> ranking,
      long time,
      TimeUnit unit)
      throws InterruptedException {
    List<QuoteTask> tasks = new ArrayList<QuoteTask>();
    for (TravelCompany company : companies) tasks.add(new QuoteTask(company, travelInfo));

    List<Future<TravelQuote>> futures = exec.invokeAll(tasks, time, unit);

    List<TravelQuote> quotes = new ArrayList<TravelQuote>(tasks.size());
    Iterator<QuoteTask> taskIter = tasks.iterator();
    for (Future<TravelQuote> f : futures) {
      QuoteTask task = taskIter.next();
      try {
        quotes.add(f.get());
      } catch (ExecutionException e) {
        quotes.add(task.getFailureQuote(e.getCause()));
      } catch (CancellationException e) {
        quotes.add(task.getTimeoutQuote(e));
      }
    }

    Collections.sort(quotes, ranking);
    return quotes;
  }
Exemplo n.º 2
0
  public static void main(String[] args) {
    Date start = new Date();
    if (args.length < 3) {
      System.out.println("Wrong number of arguments:\n" + USAGE);
      return;
    }

    // get # threads
    int tc = Integer.parseInt(args[0]);
    String outfile = args[1];

    // make a threadsafe queue of all files to process
    ConcurrentLinkedQueue<String> files = new ConcurrentLinkedQueue<String>();
    for (int i = 2; i < args.length; i++) {
      files.add(args[i]);
    }

    // hastable for results
    Hashtable<String, Integer> results = new Hashtable<String, Integer>(HASH_SIZE, LF);

    // spin up the threads
    Thread[] workers = new Thread[tc];
    for (int i = 0; i < tc; i++) {
      workers[i] = new Worker(files, results);
      workers[i].start();
    }

    // wait for them to finish
    try {
      for (int i = 0; i < tc; i++) {
        workers[i].join();
      }
    } catch (Exception e) {
      System.out.println("Caught Exception: " + e.getMessage());
    }

    // terminal output
    Date end = new Date();
    System.out.println(end.getTime() - start.getTime() + " total milliseconds");
    System.out.println(results.size() + " unique words");

    // sort results for easy comparison/verification
    List<Map.Entry<String, Integer>> sorted_results =
        new ArrayList<Map.Entry<String, Integer>>(results.entrySet());
    Collections.sort(sorted_results, new KeyComp());
    // file output
    try {
      PrintStream out = new PrintStream(outfile);
      for (int i = 0; i < sorted_results.size(); i++) {
        out.println(sorted_results.get(i).getKey() + "\t" + sorted_results.get(i).getValue());
      }
    } catch (Exception e) {
      System.out.println("Caught Exception: " + e.getMessage());
    }
  }
Exemplo n.º 3
0
 /**
  * Returns all supported capture sizes.
  *
  * @return an array of capture sizes, in bytes, never <code>null</code>.
  */
 public Integer[] getCaptureSizes() {
   final String rawValue = this.properties.get(DEVICE_CAPTURESIZES);
   final String[] values = rawValue.split(",\\s*");
   final List<Integer> result = new ArrayList<Integer>();
   for (String value : values) {
     result.add(Integer.valueOf(value.trim()));
   }
   Collections.sort(
       result, NumberUtils.<Integer>createNumberComparator(false /* aSortAscending */));
   return result.toArray(new Integer[result.size()]);
 }
Exemplo n.º 4
0
  public List<LoopEx> outterFirst() {
    ArrayList<LoopEx> loops = new ArrayList<>(loops());
    Collections.sort(
        loops,
        new Comparator<LoopEx>() {

          @Override
          public int compare(LoopEx o1, LoopEx o2) {
            return o1.lirLoop().depth - o2.lirLoop().depth;
          }
        });
    return loops;
  }
Exemplo n.º 5
0
 public Void call() {
   final List<RolapStar> starList = CacheControlImpl.getStarList(region);
   Collections.sort(
       starList,
       new Comparator<RolapStar>() {
         public int compare(RolapStar o1, RolapStar o2) {
           return o1.getFactTable().getAlias().compareTo(o2.getFactTable().getAlias());
         }
       });
   for (RolapStar star : starList) {
     indexRegistry.getIndex(star).printCacheState(pw);
   }
   return null;
 }
Exemplo n.º 6
0
  /**
   * @param fld Folder with files to match.
   * @param ptrn Pattern to match against file name.
   * @return Collection of matched files.
   */
  public static List<VisorLogFile> matchedFiles(File fld, final String ptrn) {
    List<VisorLogFile> files =
        fileTree(
            fld,
            MAX_FOLDER_DEPTH,
            new FileFilter() {
              @Override
              public boolean accept(File f) {
                return !f.isHidden()
                    && (f.isDirectory() || f.isFile() && f.getName().matches(ptrn));
              }
            });

    Collections.sort(files, LAST_MODIFIED);

    return files;
  }
Exemplo n.º 7
0
  /** Load all the deployment units out of the store. Called on start-up. */
  public void loadAll() {
    final ArrayList<ProcessConfImpl> loaded = new ArrayList<ProcessConfImpl>();
    exec(
        new Callable<Object>() {
          public Object call(ConfStoreConnection conn) {
            Collection<DeploymentUnitDAO> dus = conn.getDeploymentUnits();
            for (DeploymentUnitDAO du : dus)
              try {
                loaded.addAll(load(du));
              } catch (Exception ex) {
                __log.error("Error loading DU from store: " + du.getName(), ex);
              }
            return null;
          }
        });

    // Dispatch DISABLED, RETIRED and ACTIVE events in that order
    Collections.sort(
        loaded,
        new Comparator<ProcessConf>() {
          public int compare(ProcessConf o1, ProcessConf o2) {
            return stateValue(o1.getState()) - stateValue(o2.getState());
          }

          int stateValue(ProcessState state) {
            if (ProcessState.DISABLED.equals(state)) return 0;
            if (ProcessState.RETIRED.equals(state)) return 1;
            if (ProcessState.ACTIVE.equals(state)) return 2;
            throw new IllegalStateException("Unexpected process state: " + state);
          }
        });
    for (ProcessConfImpl p : loaded) {
      try {
        fireStateChange(p.getProcessId(), p.getState(), p.getDeploymentUnit().getName());
      } catch (Exception except) {
        __log.error(
            "Error while activating process: pid="
                + p.getProcessId()
                + " package="
                + p.getDeploymentUnit().getName(),
            except);
      }
    }
  }
  private void getServersFile() throws Exception {
    InputStream is = this.getClass().getResourceAsStream("/servers");
    if (is == null) throw new IOException("Cannot find servers file");

    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    configuredServers.clear();
    String line;
    while ((line = br.readLine()) != null) {
      configuredServers.add(line);
    }

    Collections.sort(configuredServers);

    if (configuredServers.size() < 1) throw new IOException("No entries found in servers file");

    int lnum = 1;
    for (int i = 0; i < configuredServers.size(); i++) {
      LOG.debug("servers file line " + lnum + " [" + configuredServers.get(i) + "]");
      lnum++;
    }
  }
  public int reduce(Optimizer optimizer, int expMinCluster, int expMaxCluster)
      throws ExecutionException, InterruptedException {
    // 1.start with min, max provided, what is oom
    int mag = computeMagnitude(expMaxCluster - expMinCluster + 1);
    // 2. setting search range. if oom is 0, set initial range to 1;
    int hop = mag == 0 ? 1 : (int) Math.pow(10.0, mag);
    // 3. find the meaning range, i.e., real min cluster and real max cluster numbers where a real
    // numbered optimisation score
    // can be computed
    int[] range = computeClusterNumberRange(expMinCluster, expMaxCluster, hop, optimizer);
    if (range[0] == -1 && range[1] != -1) {
      System.err.println(
          "[!]No meaningful lower range. Only 1 possible cluster number:" + range[1]);
      return range[1];
    } else if (range[1] == -1 && range[0] != -1) {
      System.err.println(
          "[!]No meaningful upper range. Only 1 possible cluster number:" + range[0]);
      return range[0];
    } else if (range[0] == -1 && range[1] == -1) {
      System.err.println("[!]No meaningful cluster number, cannot cluster");
      return -1;
    }
    System.out.println(
        "[]Input range:"
            + expMinCluster
            + "-"
            + expMaxCluster
            + ", Real range:"
            + range[0]
            + "-"
            + range[1]);
    expMinCluster = range[0] < range[1] ? range[0] : range[1];
    expMaxCluster = range[1] > range[0] ? range[1] : range[0];
    // 4. reset hop based on new range
    mag = computeMagnitude(expMaxCluster - expMinCluster + 1);
    hop = mag == 0 ? 1 : (int) Math.pow(10.0, mag);
    double currentMaxOptimizationScore = 0;
    int current_iteration =
        0; // todo: for location, why min > max; select range based on best interval, is it correct?
    while (current_iteration < maxIteration) {
      current_iteration++;
      currentMaxOptimizationScore = 0;
      // 5. compute optimization scores based on the search space defined by expMinCluster,
      // expMaxCluster, and range
      Map<Integer, Double> triedSplitsAndScores =
          computeOptimizationScores(expMinCluster, expMaxCluster, hop, optimizer);
      if (triedSplitsAndScores
          != null) { // already using minimum hop, but no meaningful optimisation score can be
                     // computed
        // within the range (TODO can this really happen?)
        // what is the real hop, max score?
        List<Integer> intervals = new ArrayList<>(triedSplitsAndScores.keySet());
        Collections.sort(intervals);
        int realHop = -1, lowerInterval = -1;
        for (int i : intervals) {
          if (lowerInterval != -1 && realHop == -1) realHop = Math.abs(i - lowerInterval);
          lowerInterval = i;
          Double score = triedSplitsAndScores.get(i);
          if (!Double.isInfinite(score)
              && !Double.isNaN(score)
              && score != Double.MAX_VALUE
              && score > currentMaxOptimizationScore) currentMaxOptimizationScore = score;
        }

        double global_max = 0.0;
        for (Double d : scores.values()) {
          if (!Double.isInfinite(d) && !Double.isNaN(d) && d > global_max) global_max = d;
        }

        if (stop(realHop, currentMaxOptimizationScore, global_max)) break;
        if (currentMaxOptimizationScore
            > global_max) // found a new max score, reset iterations to try
        current_iteration = 0;

        int newHop = reduceHop(realHop);
        hop = newHop;
      } else break;
    }

    int bestSplit = -1;
    double maxScore = 0;
    for (Map.Entry<Integer, Double> entry : scores.entrySet()) {
      Double score = entry.getValue();
      if (!score.isNaN() && !score.isInfinite() && score > maxScore) {
        maxScore = score;
        bestSplit = entry.getKey();
      }
    }
    System.out.println("[]Final Best=" + bestSplit + ", footprint:" + scores);
    return bestSplit;
  }
 private List<String> getChildren(String znode, Watcher watcher) throws Exception {
   List<String> children = null;
   children = zkc.getChildren(znode, watcher);
   if (!children.isEmpty()) Collections.sort(children);
   return children;
 }
  /**
   * @param updateSeq Update sequence.
   * @return Checks if any of the local partitions need to be evicted.
   */
  private boolean checkEvictions(long updateSeq) {
    assert lock.isWriteLockedByCurrentThread();

    boolean changed = false;

    UUID locId = cctx.nodeId();

    for (GridDhtLocalPartition part : locParts.values()) {
      GridDhtPartitionState state = part.state();

      if (state.active()) {
        int p = part.id();

        List<ClusterNode> affNodes = cctx.affinity().nodes(p, topVer);

        if (!affNodes.contains(cctx.localNode())) {
          Collection<UUID> nodeIds = F.nodeIds(nodes(p, topVer, OWNING));

          // If all affinity nodes are owners, then evict partition from local node.
          if (nodeIds.containsAll(F.nodeIds(affNodes))) {
            part.rent(false);

            updateLocal(part.id(), locId, part.state(), updateSeq);

            changed = true;

            if (log.isDebugEnabled())
              log.debug("Evicted local partition (all affinity nodes are owners): " + part);
          } else {
            int ownerCnt = nodeIds.size();
            int affCnt = affNodes.size();

            if (ownerCnt > affCnt) {
              List<ClusterNode> sorted = new ArrayList<>(cctx.discovery().nodes(nodeIds));

              // Sort by node orders in ascending order.
              Collections.sort(sorted, CU.nodeComparator(true));

              int diff = sorted.size() - affCnt;

              for (int i = 0; i < diff; i++) {
                ClusterNode n = sorted.get(i);

                if (locId.equals(n.id())) {
                  part.rent(false);

                  updateLocal(part.id(), locId, part.state(), updateSeq);

                  changed = true;

                  if (log.isDebugEnabled())
                    log.debug(
                        "Evicted local partition (this node is oldest non-affinity node): " + part);

                  break;
                }
              }
            }
          }
        }
      }
    }

    return changed;
  }