package org.jgroups.demos;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.jgroups.JChannel;
import org.jgroups.blocks.executor.ExecutionCompletionService;
import org.jgroups.blocks.executor.ExecutionRunner;
import org.jgroups.blocks.executor.ExecutionService;
import org.jgroups.jmx.JmxConfigurator;
import org.jgroups.util.Streamable;
import org.jgroups.util.Util;
public class ExecutionServiceDemo {
protected String props;
protected JChannel ch;
protected ExecutionService execution_service;
protected String name;
protected ExecutionRunner runner;
protected int size;
protected boolean printValues;
protected Random random;
protected ExecutorService executor;
protected Queue<Future<?>> queue;
public ExecutionServiceDemo(String props, String name, int size) {
this.props=props;
this.name=name;
queue=new ArrayDeque<Future<?>>();
executor = Executors.newCachedThreadPool(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
Thread thread = new Thread(r, "Consumer-" +
poolNumber.getAndIncrement());
thread.setDaemon(true);
return thread;
}
AtomicInteger poolNumber = new AtomicInteger();
});
this.size=size;
}
public static void main(String[] args) throws Exception {
String props=null;
String name=null;
String size="1000";
for(int i=0; i < args.length; i++) {
if(args[i].equals("-props")) {
props=args[++i];
continue;
}
if(args[i].equals("-name")) {
name=args[++i];
continue;
}
help();
return;
}
ExecutionServiceDemo demo=new ExecutionServiceDemo(props, name,
Integer.valueOf(size));
demo.start();
}
protected static class ByteBufferStreamable implements Streamable {
protected ByteBuffer buffer;
public ByteBufferStreamable() {
}
protected ByteBufferStreamable(ByteBuffer buffer) {
this.buffer = buffer;
}
@Override
public void writeTo(DataOutputStream out) throws IOException {
int size = buffer.limit() - buffer.position();
out.writeInt(size);
out.write(buffer.array(), buffer.position(), size);
}
@Override
public void readFrom(DataInputStream in) throws IOException,
IllegalAccessException, InstantiationException {
buffer = ByteBuffer.allocate(in.readInt());
in.readFully(buffer.array());
}
}
public void start() throws Exception {
ch=new JChannel(props);
if(name != null)
ch.setName(name);
execution_service=new ExecutionService(ch);
runner=new ExecutionRunner(ch);
ch.connect("executing-cluster");
JmxConfigurator.registerChannel(ch, Util.getMBeanServer(),
"execution-service", ch.getClusterName(), true);
// Start a consumer
queue.add(executor.submit(runner));
random = new Random();
printValues = false;
try {
loop();
}
catch(Exception e) {
e.printStackTrace();
}
finally {
Util.close(ch);
}
}
public static class SortingByteCallable implements Callable<ByteBufferStreamable>, Streamable {
public SortingByteCallable() {
}
public SortingByteCallable(byte[] bytes, int offset, int size) {
buffer = ByteBuffer.wrap(bytes, offset, size);
}
@Override
public ByteBufferStreamable call() throws Exception {
Arrays.sort(buffer.array(), buffer.position(), buffer.limit());
return new ByteBufferStreamable(buffer);
}
protected ByteBuffer buffer;
// We copy over as a single array with no offset
@Override
public void writeTo(DataOutputStream out) throws IOException {
Util.writeStreamable(new ByteBufferStreamable(buffer), out);
}
@Override
public void readFrom(DataInputStream in) throws IOException,
IllegalAccessException, InstantiationException {
buffer = ((ByteBufferStreamable)Util.readStreamable(
ByteBufferStreamable.class, in)).buffer;
}
}
/**
* Sorts 2 byte arrys into a larger byte array
*
* @author wburns
*/
public static class SortingTwoByteCallable implements Callable<ByteBufferStreamable>, Streamable {
protected ByteBuffer bytes1;
protected ByteBuffer bytes2;
public SortingTwoByteCallable() {
}
public SortingTwoByteCallable(ByteBufferStreamable bytes1, ByteBufferStreamable bytes2) {
this.bytes1=bytes1.buffer;
this.bytes2=bytes2.buffer;
}
@Override
public ByteBufferStreamable call() throws Exception {
ByteBuffer results = ByteBuffer.allocate(bytes1.remaining() +
bytes2.remaining());
int i = bytes1.position();
int j = bytes2.position();
byte[] byteArray1 = bytes1.array();
byte[] byteArray2 = bytes2.array();
int byte1Max = bytes1.limit();
int byte2Max = bytes2.limit();
while (i < byte1Max && j < byte2Max) {
if (byteArray1[i] < byteArray2[j]) {
results.put(byteArray1[i++]);
}
else {
results.put(byteArray2[j++]);
}
}
if (i < byte1Max) {
results.put(byteArray1, i, byte1Max - i);
}
else if (j < byte2Max) {
results.put(byteArray2, j, byte2Max - j);
}
results.flip();
return new ByteBufferStreamable(results);
}
@Override
public void writeTo(DataOutputStream out) throws IOException {
Util.writeStreamable(new ByteBufferStreamable(bytes1), out);
Util.writeStreamable(new ByteBufferStreamable(bytes2), out);
}
@Override
public void readFrom(DataInputStream in) throws IOException,
IllegalAccessException, InstantiationException {
bytes1 = ((ByteBufferStreamable)Util.readStreamable(
ByteBufferStreamable.class, in)).buffer;
bytes2 = ((ByteBufferStreamable)Util.readStreamable(
ByteBufferStreamable.class, in)).buffer;
}
}
protected void loop() throws Exception {
while(ch.isConnected()) {
String line=Util.readStringFromStdin(": ");
if(line.startsWith("quit") || line.startsWith("exit"))
break;
if(line.startsWith("submit")) {
int randomNumbers = Integer.parseInt(line.substring("submit".length()).trim());
// Parse numbers and break into parts
byte[] numbers = new byte[randomNumbers];
for (int i = 0; i < randomNumbers; ++i) {
numbers[i] = (byte)random.nextInt(256);
}
if (printValues)
System.out.println("Original Numbers: " +
Arrays.toString(numbers));
ExecutionCompletionService<ByteBufferStreamable> completion =
new ExecutionCompletionService<ByteBufferStreamable>(execution_service);
long beginDistributed = System.nanoTime();
int chunks = numbers.length / size;
for (int i = 0; i < chunks; ++i) {
completion.submit(new SortingByteCallable(numbers, size * i, size));
}
int futureNumber = chunks;
int leftOver = numbers.length % size;
if (leftOver != 0) {
completion.submit(new SortingByteCallable(numbers, numbers.length - leftOver, leftOver));
futureNumber++;
}
Future<ByteBufferStreamable> finalValue;
if (futureNumber > 1) {
Future<ByteBufferStreamable> result = null;
while (true) {
result = completion.take();
if (--futureNumber >= 1) {
Future<ByteBufferStreamable> result2 = completion.take();
completion.submit(new SortingTwoByteCallable(result.get(), result2.get()));
}
else {
break;
}
}
finalValue = result;
}
else {
finalValue = completion.take();
}
ByteBufferStreamable results = finalValue.get();
long totalDistributed = System.nanoTime() - beginDistributed;
if (printValues) {
System.out.println("Sorted values: " + Arrays.toString(
results.buffer.array()));
}
System.out.println("Distributed Sort Took: " + Util.printTime(totalDistributed, TimeUnit.NANOSECONDS));
long beginLocal = System.nanoTime();
Arrays.sort(numbers);
System.out.println(" Local Sort Took: " + Util.printTime((System.nanoTime() - beginLocal), TimeUnit.NANOSECONDS));
}
else if(line.startsWith("consumer")) {
// Parse stop start and add or remove
if (line.contains("start")) {
queue.add(executor.submit(runner));
System.out.println("Started Consumer - running " + queue.size() + " consumers");
}
else if (line.contains("stop")) {
queue.remove().cancel(true);
System.out.println("Stopped Consumer - running " + queue.size() + " consumers");
}
else {
System.out.println("Consumers Running Locally: " + queue.size());
}
}
else if(line.startsWith("size")) {
String thresholdSize = line.substring("size".length()).trim();
if (thresholdSize.length() > 0) {
int size = Integer.parseInt(thresholdSize);
this.size = size;
System.out.println("Changed sort threshold size to " + size);
}
else {
System.out.println("Threshold Size: " + size);
}
}
else if(line.startsWith("print")) {
printValues = !printValues;
System.out.println("Print Arrays: " + printValues);
}
else if(line.startsWith("view"))
System.out.println("View: " + ch.getView());
else if(line.startsWith("help"))
help();
}
}
protected static void help() {
System.out.println("\nExecutionServiceDemo [-props properties] [-name name]\n" +
"Default Values:\n\n" +
"One Consumer\n" +
"Threshold size: 1000\n" +
"Print disabled\n\n" +
"Valid commands:\n\n" +
"submit (amount of numbers to generate)\n" +
"consumer (start) | (stop)\n" +
"size (value)\n" +
"print");
System.out.println("\nExample:\nsubmit 2000000\nconsumer start\nconsumer stop\nsize 1000000\nprint");
}
}