/* ------------------------------------------------------------ */
public boolean isLowOnThreads() {
if (_executor instanceof ThreadPoolExecutor) {
final ThreadPoolExecutor tpe = (ThreadPoolExecutor) _executor;
// getActiveCount() locks the thread pool, so execute it last
return tpe.getPoolSize() == tpe.getMaximumPoolSize()
&& tpe.getQueue().size() >= tpe.getPoolSize() - tpe.getActiveCount();
}
return false;
}
public ThreadPoolStats stats() {
List<ThreadPoolStats.Stats> stats = new ArrayList<ThreadPoolStats.Stats>();
for (ExecutorHolder holder : executors.values()) {
String name = holder.info.getName();
// no need to have info on "same" thread pool
if ("same".equals(name)) {
continue;
}
int threads = -1;
int queue = -1;
int active = -1;
long rejected = -1;
int largest = -1;
long completed = -1;
if (holder.executor instanceof ThreadPoolExecutor) {
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) holder.executor;
threads = threadPoolExecutor.getPoolSize();
queue = threadPoolExecutor.getQueue().size();
active = threadPoolExecutor.getActiveCount();
largest = threadPoolExecutor.getLargestPoolSize();
completed = threadPoolExecutor.getCompletedTaskCount();
RejectedExecutionHandler rejectedExecutionHandler =
threadPoolExecutor.getRejectedExecutionHandler();
if (rejectedExecutionHandler instanceof XRejectedExecutionHandler) {
rejected = ((XRejectedExecutionHandler) rejectedExecutionHandler).rejected();
}
}
stats.add(
new ThreadPoolStats.Stats(name, threads, queue, active, rejected, largest, completed));
}
return new ThreadPoolStats(stats);
}
private static void realMain(String[] args) throws Throwable {
final int n = 4;
final CyclicBarrier barrier = new CyclicBarrier(2 * n + 1);
final ThreadPoolExecutor pool =
new ThreadPoolExecutor(
n, 2 * n, KEEPALIVE_MS, MILLISECONDS, new SynchronousQueue<Runnable>());
final Runnable r =
new Runnable() {
public void run() {
try {
barrier.await();
barrier.await();
} catch (Throwable t) {
unexpected(t);
}
}
};
for (int i = 0; i < 2 * n; i++) pool.execute(r);
barrier.await();
checkPoolSizes(pool, 2 * n, n, 2 * n);
barrier.await();
long nap = KEEPALIVE_MS + (KEEPALIVE_MS >> 2);
for (long sleepyTime = 0L; pool.getPoolSize() > n; ) {
check((sleepyTime += nap) <= LONG_DELAY_MS);
Thread.sleep(nap);
}
checkPoolSizes(pool, n, n, 2 * n);
Thread.sleep(nap);
checkPoolSizes(pool, n, n, 2 * n);
pool.shutdown();
check(pool.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
}
/* ------------------------------------------------------------ */
public int getThreads() {
if (_executor instanceof ThreadPoolExecutor) {
final ThreadPoolExecutor tpe = (ThreadPoolExecutor) _executor;
return tpe.getPoolSize();
}
return -1;
}
/* ------------------------------------------------------------ */
public int getIdleThreads() {
if (_executor instanceof ThreadPoolExecutor) {
final ThreadPoolExecutor tpe = (ThreadPoolExecutor) _executor;
return tpe.getPoolSize() - tpe.getActiveCount();
}
return -1;
}
@Override
public Map<String, String> handleProbe(String... keys) {
if (keys == null || keys.length == 0) {
return null;
}
ThreadPoolExecutor exec = extract(executor);
if (exec == null) {
return null;
}
Map<String, String> map = new HashMap<>();
for (String key : keys) {
switch (key) {
case KEY:
map.put("active-thread", String.valueOf(exec.getActiveCount()));
map.put("min-thread", String.valueOf(exec.getCorePoolSize()));
map.put("max-thread", String.valueOf(exec.getMaximumPoolSize()));
map.put("current-pool-size", String.valueOf(exec.getPoolSize()));
map.put("largest-pool-size", String.valueOf(exec.getLargestPoolSize()));
map.put("keep-alive", String.valueOf(exec.getKeepAliveTime(TimeUnit.MILLISECONDS)));
map.put("queue-size", String.valueOf(exec.getQueue().size()));
break;
}
}
return map.isEmpty() ? null : map;
}
public boolean offer(Runnable o) {
// we can't do any checks
if (parent == null) return super.offer(o);
int poolSize = parent.getPoolSize();
// we are maxed out on threads, simply queue the object
if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
// we have idle threads, just add it to the queue
// note that we don't use getActiveCount(), see BZ 49730
AtomicInteger submittedTasksCount = StandardThreadExecutor.this.submittedTasksCount;
if (submittedTasksCount != null) {
if (submittedTasksCount.get() <= poolSize) return super.offer(o);
}
// if we have less threads than maximum force creation of a new thread
if (poolSize < parent.getMaximumPoolSize()) return false;
// if we reached here, we need to add it to the queue
return super.offer(o);
}
public void executeTask(Task task) {
System.out.printf("Server: A new task has arrived\n");
executor.execute(task);
System.out.printf("Server: Task count: %d \n", executor.getTaskCount());
System.out.printf("Server: Pool size: %d \n", executor.getPoolSize());
System.out.printf("Server: Active count: %d \n", executor.getActiveCount());
System.out.printf("Server: Compeleted task : %d \n", executor.getCompletedTaskCount());
}
public Future executeTask(Task task) {
System.out.println("Server: new task has arrived \n");
Future future = (Future) executor.submit(task);
System.out.printf("Server:%s Pool Size \n", executor.getPoolSize());
System.out.printf("Server:%s Active thread \n", executor.getActiveCount());
System.out.printf("Server:%s Completed Tasks \n", executor.getCompletedTaskCount());
return future;
}
@Test
public void testScaleDown() throws Exception {
final int min = between(1, 3);
final int max = between(min + 1, 6);
final ThreadBarrier barrier = new ThreadBarrier(max + 1);
final ThreadPoolExecutor pool =
EsExecutors.newScaling(
min,
max,
between(1, 100),
TimeUnit.MILLISECONDS,
EsExecutors.daemonThreadFactory("test"));
assertThat("Min property", pool.getCorePoolSize(), equalTo(min));
assertThat("Max property", pool.getMaximumPoolSize(), equalTo(max));
for (int i = 0; i < max; ++i) {
final CountDownLatch latch = new CountDownLatch(1);
pool.execute(
new Runnable() {
@Override
public void run() {
latch.countDown();
try {
barrier.await();
barrier.await();
} catch (Throwable e) {
barrier.reset(e);
}
}
});
// wait until thread executes this task
// otherwise, a task might be queued
latch.await();
}
barrier.await();
assertThat("wrong pool size", pool.getPoolSize(), equalTo(max));
assertThat("wrong active size", pool.getActiveCount(), equalTo(max));
barrier.await();
assertBusy(
new Runnable() {
@Override
public void run() {
assertThat("wrong active count", pool.getActiveCount(), equalTo(0));
assertThat(
"idle threads didn't shrink below max. (" + pool.getPoolSize() + ")",
pool.getPoolSize(),
lessThan(max));
}
});
terminate(pool);
}
@Override
public final void messageReceived(
final ChannelHandlerContext ctx, final MessageEvent messageEvent)
throws InvalidProtocolBufferException {
final Messages.Msg message = (Messages.Msg) messageEvent.getMessage();
if (WSNApp.MSG_TYPE_LISTENER_MESSAGE.equals(message.getMsgType())) {
final WSNAppMessages.Message wsnAppMessage =
WSNAppMessages.Message.parseFrom(message.getPayload());
parse(wsnAppMessage.toString());
messageCounter++;
if (messageCounter == REPORT_LIMIT) {
final long milliseconds = System.currentTimeMillis() - lastTime;
final double stat = messageCounter / (milliseconds / (double) REPORT_LIMIT);
LOGGER.info("MessageRate : " + stat + " messages/sec");
final ThreadPoolExecutor pool = (ThreadPoolExecutor) executorService;
LOGGER.info("PoolSize : " + pool.getPoolSize() + " Active :" + pool.getActiveCount());
LOGGER.info("Peak : " + pool.getLargestPoolSize());
final NodeReading nodeReading = new NodeReading();
nodeReading.setTestbedId("3");
nodeReading.setNodeId("urn:ctinetwork:uberdust");
nodeReading.setCapabilityName("urn:ctinetwork:testbedlistener:poolSize");
nodeReading.setReading(String.valueOf(pool.getPoolSize()));
nodeReading.setTimestamp(String.valueOf((new Date()).getTime()));
new WsCommiter(nodeReading);
nodeReading.setCapabilityName("urn:ctinetwork:testbedlistener:activeThreads");
nodeReading.setReading(String.valueOf(pool.getActiveCount()));
new WsCommiter(nodeReading);
nodeReading.setCapabilityName("urn:ctinetwork:testbedlistener:messageRate");
nodeReading.setReading(String.valueOf(stat));
new WsCommiter(nodeReading);
lastTime = System.currentTimeMillis();
messageCounter = 0;
}
} else {
LOGGER.error("got a message of type " + message.getMsgType());
}
}
public void run() {
AtomCache cache = new AtomCache(config);
StructureAlignment algorithm = null;
if (parent != null) algorithm = parent.getStructureAlignment();
else {
algorithm = customAlgorithm;
}
String serverLocation = FarmJobParameters.DEFAULT_SERVER_URL;
if (representatives == null) {
SortedSet<String> repre = JFatCatClient.getRepresentatives(serverLocation, 40);
System.out.println("got " + repre.size() + " representatives for comparison");
representatives = repre;
}
String header = "# algorithm:" + algorithm.getAlgorithmName();
String legend =
"# name1\tname2\tscore\tprobability\trmsd\tlen1\tlen2\tcov1\tcov2\t%ID\tDescription\t ";
if (algorithm.getAlgorithmName().equalsIgnoreCase(CeMain.algorithmName)
|| algorithm.getAlgorithmName().equalsIgnoreCase(CeSideChainMain.algorithmName)) {
legend = "# name1\tname2\tscore\tz-score\trmsd\tlen1\tlen2\tcov1\tcov2\t%ID\tDescription\t ";
}
File outFileF = new File(outFile);
if (!outFileF.isDirectory()) {
System.err.println(
outFileF.getAbsolutePath()
+ " is not a directory, can't create result files in there... ");
interrupt();
cleanup();
}
if (name1 == null) name1 = "CUSTOM";
SynchronizedOutFile out;
resultList = new File(outFileF, "results_" + name1 + ".out");
try {
out = new SynchronizedOutFile(resultList);
out.write(header);
out.write(AFPChain.newline);
out.write(legend);
out.write(AFPChain.newline);
if (name1.equals("CUSTOM")) {
String config1 = "#param:file1=" + parent.getDBSearch().getPDBUploadPanel().getFilePath1();
out.write(config1);
out.write(AFPChain.newline);
String config2 = "#param:chain1=" + parent.getDBSearch().getPDBUploadPanel().getChain1();
out.write(config2);
out.write(AFPChain.newline);
}
if (algorithm.getAlgorithmName().startsWith("jCE")) {
ConfigStrucAligParams params = algorithm.getParameters();
if (params instanceof CeParameters) {
CeParameters ceParams = (CeParameters) params;
if (ceParams.getScoringStrategy() != CeParameters.DEFAULT_SCORING_STRATEGY) {
String scoring = "#param:scoring=" + ceParams.getScoringStrategy();
out.write(scoring);
out.write(AFPChain.newline);
}
}
}
} catch (Exception e) {
System.err.println("Error while loading representative structure " + name1);
e.printStackTrace();
interrupt();
cleanup();
return;
}
DomainProvider domainProvider = DomainProviderFactory.getDomainProvider();
ConcurrencyTools.setThreadPoolSize(nrCPUs);
Atom[] ca1 = StructureTools.getAtomCAArray(structure1);
int nrJobs = 0;
for (String repre : representatives) {
if (domainSplit) {
SortedSet<String> domainNames = domainProvider.getDomainNames(repre);
// System.out.println(repre +" got domains: " +domainNames);
if (domainNames == null || domainNames.size() == 0) {
// no domains found, use whole chain.
submit(name1, repre, ca1, algorithm, outFileF, out, cache);
nrJobs++;
continue;
}
// System.out.println("got " + domainNames.size() + " for " + repre);
for (String domain : domainNames) {
submit(name1, domain, ca1, algorithm, outFileF, out, cache);
nrJobs++;
}
} else {
submit(name1, repre, ca1, algorithm, outFileF, out, cache);
nrJobs++;
}
}
ThreadPoolExecutor pool = ConcurrencyTools.getThreadPool();
System.out.println(pool.getPoolSize());
long startTime = System.currentTimeMillis();
try {
while (pool.getCompletedTaskCount() < nrJobs - 1) {
// long now = System.currentTimeMillis();
// System.out.println( pool.getCompletedTaskCount() + " " + (now-startTime)/1000 + " " +
// pool.getPoolSize() + " " + pool.getActiveCount() + " " + pool.getTaskCount() );
// if ((now-startTime)/1000 > 60) {
//
// interrupt();
// System.out.println("completed: " + pool.getCompletedTaskCount());
// }
if (interrupted.get()) break;
Thread.sleep(2000);
}
out.close();
} catch (Exception e) {
e.printStackTrace();
interrupt();
cleanup();
}
if (domainProvider instanceof RemoteDomainProvider) {
RemoteDomainProvider remote = (RemoteDomainProvider) domainProvider;
remote.flushCache();
}
long now = System.currentTimeMillis();
System.out.println("Calculation took : " + (now - startTime) / 1000 + " sec.");
System.out.println(
pool.getCompletedTaskCount()
+ " "
+ pool.getPoolSize()
+ " "
+ pool.getActiveCount()
+ " "
+ pool.getTaskCount());
// if ((now-startTime)/1000 > 30) {
// try {
// out.flush();
// out.close();
// } catch (Exception e) {
// e.printStackTrace();
// }
if (parent != null) {
parent.notifyCalcFinished();
DBResultTable table = new DBResultTable();
table.show(resultList, config);
}
}
public void ejecutarTarea(Tarea tarea) {
ejecutor.execute(tarea);
System.out.printf("Servidor -> Tamaño Grupo: %d\n", ejecutor.getPoolSize());
System.out.printf("Servidor -> Hilos activos: %d\n", ejecutor.getActiveCount());
}
static void checkPoolSizes(ThreadPoolExecutor pool, int size, int core, int max) {
equal(pool.getPoolSize(), size);
equal(pool.getCorePoolSize(), core);
equal(pool.getMaximumPoolSize(), max);
}
public String[] getStats() {
return new String[] {
"STP:",
" + Effects:",
" |- ActiveThreads: " + _effectsScheduledThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _effectsScheduledThreadPool.getCorePoolSize(),
" |- PoolSize: " + _effectsScheduledThreadPool.getPoolSize(),
" |- MaximumPoolSize: " + _effectsScheduledThreadPool.getMaximumPoolSize(),
" |- CompletedTasks: " + _effectsScheduledThreadPool.getCompletedTaskCount(),
" |- ScheduledTasks: "
+ (_effectsScheduledThreadPool.getTaskCount()
- _effectsScheduledThreadPool.getCompletedTaskCount()),
" | -------",
" + General:",
" |- ActiveThreads: " + _generalScheduledThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _generalScheduledThreadPool.getCorePoolSize(),
" |- PoolSize: " + _generalScheduledThreadPool.getPoolSize(),
" |- MaximumPoolSize: " + _generalScheduledThreadPool.getMaximumPoolSize(),
" |- CompletedTasks: " + _generalScheduledThreadPool.getCompletedTaskCount(),
" |- ScheduledTasks: "
+ (_generalScheduledThreadPool.getTaskCount()
- _generalScheduledThreadPool.getCompletedTaskCount()),
" | -------",
" + AI:",
" |- ActiveThreads: " + _aiScheduledThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _aiScheduledThreadPool.getCorePoolSize(),
" |- PoolSize: " + _aiScheduledThreadPool.getPoolSize(),
" |- MaximumPoolSize: " + _aiScheduledThreadPool.getMaximumPoolSize(),
" |- CompletedTasks: " + _aiScheduledThreadPool.getCompletedTaskCount(),
" |- ScheduledTasks: "
+ (_aiScheduledThreadPool.getTaskCount()
- _aiScheduledThreadPool.getCompletedTaskCount()),
"TP:",
" + Packets:",
" |- ActiveThreads: " + _generalPacketsThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _generalPacketsThreadPool.getCorePoolSize(),
" |- MaximumPoolSize: " + _generalPacketsThreadPool.getMaximumPoolSize(),
" |- LargestPoolSize: " + _generalPacketsThreadPool.getLargestPoolSize(),
" |- PoolSize: " + _generalPacketsThreadPool.getPoolSize(),
" |- CompletedTasks: " + _generalPacketsThreadPool.getCompletedTaskCount(),
" |- QueuedTasks: " + _generalPacketsThreadPool.getQueue().size(),
" | -------",
" + I/O Packets:",
" |- ActiveThreads: " + _ioPacketsThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _ioPacketsThreadPool.getCorePoolSize(),
" |- MaximumPoolSize: " + _ioPacketsThreadPool.getMaximumPoolSize(),
" |- LargestPoolSize: " + _ioPacketsThreadPool.getLargestPoolSize(),
" |- PoolSize: " + _ioPacketsThreadPool.getPoolSize(),
" |- CompletedTasks: " + _ioPacketsThreadPool.getCompletedTaskCount(),
" |- QueuedTasks: " + _ioPacketsThreadPool.getQueue().size(),
" | -------",
" + General Tasks:",
" |- ActiveThreads: " + _generalThreadPool.getActiveCount(),
" |- getCorePoolSize: " + _generalThreadPool.getCorePoolSize(),
" |- MaximumPoolSize: " + _generalThreadPool.getMaximumPoolSize(),
" |- LargestPoolSize: " + _generalThreadPool.getLargestPoolSize(),
" |- PoolSize: " + _generalThreadPool.getPoolSize(),
" |- CompletedTasks: " + _generalThreadPool.getCompletedTaskCount(),
" |- QueuedTasks: " + _generalThreadPool.getQueue().size(),
" | -------",
" + Javolution stats:",
" |- FastList: " + FastList.report(),
" |- FastMap: " + FastMap.report(),
" |- FastSet: " + FastSet.report(),
" | -------"
};
}
public int getThreads() {
return executor.getPoolSize();
}
public int getIdleThreads() {
return executor.getPoolSize() - executor.getActiveCount();
}
public int getPoolActiveThreadCount() {
if (pool != null) {
return pool.getPoolSize();
}
return -1;
} // getPoolActiveThreadCount
public int getCurrentThreads() {
return pool.getPoolSize();
}
public int getPoolSize() {
return (executor != null) ? executor.getPoolSize() : 0;
}
