public void trackUUID(final UUID uuid, final String name, boolean replace) { if (uuid != null) { keys.add(uuid); if (name != null && name.length() > 0) { final String keyName = StringUtil.safeString(name); if (!names.containsKey(keyName)) { names.put(keyName, uuid); uuidMap.writeUUIDMap(); } else if (!names.get(keyName).equals(uuid)) { if (replace) { ess.getLogger() .info( "Found new UUID for " + name + ". Replacing " + names.get(keyName).toString() + " with " + uuid.toString()); names.put(keyName, uuid); uuidMap.writeUUIDMap(); } else { if (ess.getSettings().isDebug()) { ess.getLogger() .info( "Found old UUID for " + name + " (" + uuid.toString() + "). Not adding to usermap."); } } } } } }
protected SymbolEvents constructEvent( String eventListName, ScreeningSupplementedStock screenedStock, EventDefinition eventDefinition, Integer rank, Integer previousRank, EventType eventType, String message, Date eventDate) { ConcurrentSkipListMap<EventKey, EventValue> eventMap = new ConcurrentSkipListMap<EventKey, EventValue>(); EventKey key = new StandardEventKey(eventDate, eventDefinition, eventType); message = message + ". Rank is : --" + rank + "--"; if (previousRank != null) message = message + " and was " + previousRank; EventValue value = new AlertEventValue(eventDate, eventType, eventDefinition, message, eventListName); eventMap.put(key, value); SymbolEvents symbolEvents = new SymbolEvents( screenedStock.getStock(), eventMap, EventDefinition.loadMaxPassPrefsEventInfo(), EventState.STATE_TERMINATED); return symbolEvents; }
/** Test of paintComponent method, of class GraphPanelChart. */ @Test public void testPaintComponent() { System.out.println("paintComponent"); Graphics g = new TestGraphics(); GraphPanelChart instance = new GraphPanelChart(); instance.setSize(500, 500); instance.getChartSettings().setDrawFinalZeroingLines(true); instance.getChartSettings().setDrawCurrentX(true); instance.getChartSettings().setExpendRows(true); final ConcurrentSkipListMap<String, AbstractGraphRow> rows = new ConcurrentSkipListMap<String, AbstractGraphRow>(); instance.setRows(rows); final GraphRowAverages row1 = new GraphRowAverages(); row1.setDrawThickLines(true); row1.setDrawLine(true); row1.setDrawBar(true); row1.setDrawValueLabel(true); row1.setMarkerSize(AbstractGraphRow.MARKER_SIZE_BIG); rows.put("test 1", row1); row1.add(System.currentTimeMillis(), 20); instance.paintComponent(g); row1.add(System.currentTimeMillis(), 540); instance.setxAxisLabelRenderer(new DateTimeRenderer("HH:mm:ss")); instance.paintComponent(g); row1.add(System.currentTimeMillis(), 8530); instance.paintComponent(g); }
synchronized void save() { Long lastKey = this.lastSyncKey; Set<Entry<Long, RedoLogValue>> entrySet = lastKey == null ? skipListMap.entrySet() : skipListMap.tailMap(lastKey, false).entrySet(); if (!entrySet.isEmpty()) { WriteBuffer buff = WriteBufferPool.poll(); try { for (Entry<Long, RedoLogValue> e : entrySet) { lastKey = e.getKey(); keyType.write(buff, lastKey); valueType.write(buff, e.getValue()); } int chunkLength = buff.position(); if (chunkLength > 0) { buff.limit(chunkLength); buff.position(0); fileStorage.writeFully(pos, buff.getBuffer()); pos += chunkLength; fileStorage.sync(); } this.lastSyncKey = lastKey; } finally { WriteBufferPool.offer(buff); } } }
/** * Adds an old value with a fixed timestamp to the sample. * * @param value the value to be added * @param timestamp the epoch timestamp of {@code value} in seconds */ public void update(long value, long timestamp) { lockForRegularUsage(); try { final double priority = weight(timestamp - startTime) / random(); final long newCount = count.incrementAndGet(); if (newCount <= reservoirSize) { values.put(priority, value); } else { Double first = values.firstKey(); if (first < priority) { if (values.putIfAbsent(priority, value) == null) { // ensure we always remove an item while (values.remove(first) == null) { first = values.firstKey(); } } } } } finally { unlockForRegularUsage(); } final long now = System.nanoTime(); final long next = nextScaleTime.get(); if (now >= next) { rescale(now, next); } }
public void fetch() throws IOException { long start = System.currentTimeMillis(); LOG.info("Processing " + file); int cnt = 0; try { BufferedReader data = new BufferedReader(new InputStreamReader(new FileInputStream(file))); String line; while ((line = data.readLine()) != null) { String[] arr = line.split("\t"); long id = Long.parseLong(arr[0]); String username = (arr.length > 1) ? arr[1] : "a"; String url = getUrl(id, username); connections.incrementAndGet(); crawlURL(url, new TweetFetcherHandler(id, username, url, 0, !this.noFollow)); cnt++; if (cnt % TWEET_BLOCK_SIZE == 0) { LOG.info(cnt + " requests submitted"); } } } catch (IOException e) { e.printStackTrace(); } // Wait for the last requests to complete. LOG.info("Waiting for remaining requests (" + connections.get() + ") to finish!"); while (connections.get() > 0) { try { Thread.sleep(1000); } catch (Exception e) { e.printStackTrace(); } } asyncHttpClient.close(); long end = System.currentTimeMillis(); long duration = end - start; LOG.info("Total request submitted: " + cnt); LOG.info(crawl.size() + " tweets fetched in " + duration + "ms"); LOG.info("Writing tweets..."); int written = 0; Configuration conf = new Configuration(); OutputStreamWriter out = new OutputStreamWriter(new GZIPOutputStream(new FileOutputStream(output))); for (Map.Entry<Long, String> entry : crawl.entrySet()) { written++; out.write(entry.getValue() + "\n"); } out.close(); LOG.info(written + " statuses written."); LOG.info("Done!"); }
protected void _run() { ConcurrentNavigableMap<Long, Entry> head_map; // head_map = entries which are <= curr time (ready to be executed) if (!(head_map = tasks.headMap(System.currentTimeMillis(), true)).isEmpty()) { final List<Long> keys = new LinkedList<Long>(); for (Map.Entry<Long, Entry> entry : head_map.entrySet()) { final Long key = entry.getKey(); final Entry val = entry.getValue(); pool.execute( new Runnable() { public void run() { val.execute(); } }); keys.add(key); } tasks.keySet().removeAll(keys); } if (tasks.isEmpty()) { no_tasks.compareAndSet(false, true); waitFor(); // sleeps until time elapses, or a task with a lower execution time is added } else waitUntilNextExecution(); // waits until next execution, or a task with a lower execution time // is added }
/* Receive a response. * Because only one receiver, so no synchronization on in. */ protected void receiveResponse() { if (shouldCloseConnection.get()) { return; } touch(); try { // See HBaseServer.Call.setResponse for where we write out the response. // It writes the call.id (int), a flag byte, then optionally the length // of the response (int) followed by data. // Read the call id. int id = in.readInt(); if (LOG.isDebugEnabled()) LOG.debug(getName() + " got value #" + id); Call call = calls.get(id); // Read the flag byte byte flag = in.readByte(); boolean isError = ResponseFlag.isError(flag); if (ResponseFlag.isLength(flag)) { // Currently length if present is unused. in.readInt(); } int state = in.readInt(); // Read the state. Currently unused. if (isError) { if (call != null) { //noinspection ThrowableInstanceNeverThrown call.setException( new RemoteException(WritableUtils.readString(in), WritableUtils.readString(in))); } } else { Writable value = ReflectionUtils.newInstance(valueClass, conf); value.readFields(in); // read value // it's possible that this call may have been cleaned up due to a RPC // timeout, so check if it still exists before setting the value. if (call != null) { call.setValue(value); } } calls.remove(id); } catch (IOException e) { if (e instanceof SocketTimeoutException && remoteId.rpcTimeout > 0) { // Clean up open calls but don't treat this as a fatal condition, // since we expect certain responses to not make it by the specified // {@link ConnectionId#rpcTimeout}. closeException = e; } else { // Since the server did not respond within the default ping interval // time, treat this as a fatal condition and close this connection markClosed(e); } } finally { if (remoteId.rpcTimeout > 0) { cleanupCalls(remoteId.rpcTimeout); } } }
public void open(Serializable e) throws Exception { Properties jobParameters = BatchRuntime.getJobOperator().getParameters(jobContext.getExecutionId()); ConcurrentSkipListMap<Integer, PayrollInputRecord> records = dataBean.getPayrollInputRecords((String) jobParameters.get("monthYear")); Integer fromKey = (Integer) jobParameters.get("startEmpID"); Integer toKey = (Integer) jobParameters.get("endEmpID"); payrollInputRecords = records.subMap(fromKey, true, toKey, false).values().iterator(); }
public void offer(int sid, int trunkId, int segId, Object data) { TrunkSegmentIdentifier id = new TrunkSegmentIdentifier(msgId, sid, trunkId, segId); while (!cacheQueue.containsKey(id) && cacheQueue.size() > maxQueueItems) { try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } } cacheQueue.put(id, data); msgId++; }
public void removeUser(final String name) { if (names == null) { ess.getLogger().warning("Name collection is null, cannot remove user."); return; } UUID uuid = names.get(name); if (uuid != null) { keys.remove(uuid); users.invalidate(uuid); } names.remove(name); names.remove(StringUtil.safeString(name)); }
public OCachePointer load(long fileId, long pageIndex) throws IOException { synchronized (syncObject) { final GroupKey groupKey = new GroupKey(fileId, pageIndex >>> 4); lockManager.acquireLock(Thread.currentThread(), groupKey, OLockManager.LOCK.SHARED); try { final WriteGroup writeGroup = writeGroups.get(groupKey); OCachePointer pagePointer; if (writeGroup == null) { pagePointer = cacheFileContent(fileId, pageIndex); pagePointer.incrementReferrer(); return pagePointer; } final int entryIndex = (int) (pageIndex & 15); pagePointer = writeGroup.pages[entryIndex]; if (pagePointer == null) pagePointer = cacheFileContent(fileId, pageIndex); pagePointer.incrementReferrer(); return pagePointer; } finally { lockManager.releaseLock(Thread.currentThread(), groupKey, OLockManager.LOCK.SHARED); } } }
/* "A common feature of the above techniques—indeed, the key technique that * allows us to track the decayed weights efficiently—is that they maintain * counts and other quantities based on g(ti − L), and only scale by g(t − L) * at query time. But while g(ti −L)/g(t−L) is guaranteed to lie between zero * and one, the intermediate values of g(ti − L) could become very large. For * polynomial functions, these values should not grow too large, and should be * effectively represented in practice by floating point values without loss of * precision. For exponential functions, these values could grow quite large as * new values of (ti − L) become large, and potentially exceed the capacity of * common floating point types. However, since the values stored by the * algorithms are linear combinations of g values (scaled sums), they can be * rescaled relative to a new landmark. That is, by the analysis of exponential * decay in Section III-A, the choice of L does not affect the final result. We * can therefore multiply each value based on L by a factor of exp(−α(L′ − L)), * and obtain the correct value as if we had instead computed relative to a new * landmark L′ (and then use this new L′ at query time). This can be done with * a linear pass over whatever data structure is being used." */ private void rescale(long now, long next) { if (nextScaleTime.compareAndSet(next, now + RESCALE_THRESHOLD)) { lockForRescale(); try { final long oldStartTime = startTime; this.startTime = tick(); final ArrayList<Double> keys = new ArrayList<Double>(values.keySet()); for (Double key : keys) { final Long value = values.remove(key); values.put(key * exp(-alpha * (startTime - oldStartTime)), value); } } finally { unlockForRescale(); } } }
public HistoryFileInfo remove(JobId key) { HistoryFileInfo ret = cache.remove(key); if (ret != null) { mapSize.decrementAndGet(); } return ret; }
public String dumpTimerTasks() { StringBuilder sb = new StringBuilder(); for (Entry entry : tasks.values()) { sb.append(entry.dump()).append("\n"); } return sb.toString(); }
public HistoryFileInfo putIfAbsent(JobId key, HistoryFileInfo value) { HistoryFileInfo ret = cache.putIfAbsent(key, value); if (ret == null) { mapSize.incrementAndGet(); } return ret; }
Long lastKey() { try { return skipListMap.lastKey(); } catch (NoSuchElementException e) { return null; } }
public List<Cluster> getAllCluster() { List<Cluster> cl = new ArrayList<Cluster>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.CLUSTER_PATH_S, true, PathUtil.CLUSTER_PATH_E, true).entrySet()) { cl.add((Cluster) e.getValue()); } return cl; }
public List<Long> values() { lockForRegularUsage(); try { return new ArrayList<Long>(values.values()); } finally { unlockForRegularUsage(); } }
public Object pop() { Map.Entry e = cacheQueue.pollFirstEntry(); if (e != null) { return e.getValue(); } else { return null; } }
public List<PhysicalMachine> getAllPm() { List<PhysicalMachine> pml = new ArrayList<PhysicalMachine>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.PM_PATH_S, true, PathUtil.PM_PATH_E, true).entrySet()) { pml.add((PhysicalMachine) e.getValue()); } return pml; }
synchronized void write(Source source) { if (source == null) return; // StringBuilder builder = new StringBuilder(source.getName()).append('.'); // builder.append(source.getGroup()).append('.').append(source.getCategory()); int hashCode = trackerService.hashCode(source); // System.out.println(hashCode+ " : " + Calendar.getInstance().getTimeInMillis()); codes.put(hashCode, Calendar.getInstance().getTimeInMillis()); }
public List<PartitionGroupServer> getPgsList(String clusterName) { List<PartitionGroupServer> pgsl = new ArrayList<PartitionGroupServer>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.PGS_PATH_S(clusterName), true, PathUtil.PGS_PATH_E(clusterName), true) .entrySet()) { pgsl.add((PartitionGroupServer) e.getValue()); } return pgsl; }
private void read() { ByteBuffer buffer = fileStorage.readFully(0, (int) pos); while (buffer.remaining() > 0) { Long k = (Long) keyType.read(buffer); RedoLogValue v = (RedoLogValue) valueType.read(buffer); skipListMap.put(k, v); lastSyncKey = k; } }
@Override public Snapshot getSnapshot() { lockForRegularUsage(); try { return new WeightedSnapshot(values.values()); } finally { unlockForRegularUsage(); } }
public List<PhysicalMachineCluster> getPmcList(String pmName) { List<PhysicalMachineCluster> pmcl = new ArrayList<PhysicalMachineCluster>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.PMC_PATH_S(pmName), true, PathUtil.PMC_PATH_E(pmName), true) .entrySet()) { pmcl.add((PhysicalMachineCluster) e.getValue()); } return pmcl; }
public List<Gateway> getGwList(String clusterName) { List<Gateway> gwl = new ArrayList<Gateway>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.GW_PATH_S(clusterName), true, PathUtil.GW_PATH_E(clusterName), true) .entrySet()) { gwl.add((Gateway) e.getValue()); } return gwl; }
public List<RedisServer> getRsList(String clusterName) { List<RedisServer> rsl = new ArrayList<RedisServer>(); for (Entry<String, ClusterComponent> e : map.subMap(PathUtil.RS_PATH_S(clusterName), true, PathUtil.RS_PATH_E(clusterName), true) .entrySet()) { rsl.add((RedisServer) e.getValue()); } return rsl; }
protected void cleanupCalls(long rpcTimeout) { Iterator<Entry<Integer, Call>> itor = calls.entrySet().iterator(); while (itor.hasNext()) { Call c = itor.next().getValue(); long waitTime = System.currentTimeMillis() - c.getStartTime(); if (waitTime >= rpcTimeout) { if (this.closeException == null) { // There may be no exception in the case that there are many calls // being multiplexed over this connection and these are succeeding // fine while this Call object is taking a long time to finish // over on the server; e.g. I just asked the regionserver to bulk // open 3k regions or its a big fat multiput into a heavily-loaded // server (Perhaps this only happens at the extremes?) this.closeException = new CallTimeoutException( "Call id=" + c.id + ", waitTime=" + waitTime + ", rpcTimetout=" + rpcTimeout); } c.setException(this.closeException); synchronized (c) { c.notifyAll(); } itor.remove(); } else { break; } } try { if (!calls.isEmpty()) { Call firstCall = calls.get(calls.firstKey()); long maxWaitTime = System.currentTimeMillis() - firstCall.getStartTime(); if (maxWaitTime < rpcTimeout) { rpcTimeout -= maxWaitTime; } } if (!shouldCloseConnection.get()) { closeException = null; if (socket != null) { socket.setSoTimeout((int) rpcTimeout); } } } catch (SocketException e) { LOG.debug("Couldn't lower timeout, which may result in longer than expected calls"); } }
/** Create a map from Integers -5 to -1 to Strings "A"-"E". */ private static ConcurrentNavigableMap dmap5() { ConcurrentSkipListMap map = new ConcurrentSkipListMap(); assertTrue(map.isEmpty()); map.put(m1, "A"); map.put(m5, "E"); map.put(m3, "C"); map.put(m2, "B"); map.put(m4, "D"); assertFalse(map.isEmpty()); assertEquals(5, map.size()); return map.descendingMap(); }