/* (non-Javadoc)
* @see chu.engine.Game#loop()
*/
@Override
public void loop() {
while (!Display.isCloseRequested()) {
final long time = System.nanoTime();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glClearDepth(1.0f);
getInput();
final ArrayList<Message> messages = new ArrayList<>();
if (client != null) {
synchronized (client.messagesLock) {
messages.addAll(client.messages);
for (Message m : messages) client.messages.remove(m);
}
}
SoundStore.get().poll(0);
glPushMatrix();
// Global resolution scale
// Renderer.scale(scaleX, scaleY);
currentStage.beginStep(messages);
currentStage.onStep();
currentStage.processAddStack();
currentStage.processRemoveStack();
currentStage.render();
// FEResources.getBitmapFont("stat_numbers").render(
// (int)(1.0f/getDeltaSeconds())+"", 440f, 0f, 0f);
currentStage.endStep();
glPopMatrix();
Display.update();
timeDelta = System.nanoTime() - time;
}
AL.destroy();
Display.destroy();
if (client != null && client.isOpen()) client.quit();
}
private static void runJaversionTree(Integer[] data) {
out.println("Javersion PersistentTreeMap");
@SuppressWarnings("unchecked")
PersistentTreeMap<Integer, Integer> jmap = PersistentTreeMap.EMPTY;
// warmup
for (Integer v : data) {
jmap = jmap.assoc(v, v);
}
jmap = null;
// System.gc();
long begin = System.nanoTime();
for (int i = 1; i <= data.length; i++) {
start();
jmap = PersistentTreeMap.EMPTY;
for (int j = 0; j < i; j++) {
jmap = jmap.assoc(data[j], data[j]);
}
for (int j = 0; j < i; j++) {
jmap = jmap.dissoc(data[j]);
}
out.println(end());
}
out.println(String.format("\nJaversion total time: %s", System.nanoTime() - begin));
}
private static void runClojure(Integer[] data) {
out.println("Clojure PersistentHashMap");
clojure.lang.PersistentHashMap cmap = clojure.lang.PersistentHashMap.EMPTY;
// warmup
for (Integer v : data) {
cmap = (clojure.lang.PersistentHashMap) cmap.assoc(v, v);
}
cmap = null;
System.gc();
long begin = System.nanoTime();
for (int i = 1; i <= data.length; i++) {
start();
cmap = clojure.lang.PersistentHashMap.EMPTY;
for (int j = 0; j < i; j++) {
cmap = (clojure.lang.PersistentHashMap) cmap.assoc(data[j], data[j]);
}
for (int j = 0; j < i; j++) {
cmap = (clojure.lang.PersistentHashMap) cmap.without(data[j]);
}
out.println(end());
}
out.println(String.format("\n%s", System.nanoTime() - begin));
}
/**
* Returns object of class ‘"proc_time"’ which is a numeric vector of length 5, containing the
* user, system, and total elapsed times for the currently running R process, and the cumulative
* sum of user and system times of any child processes spawned by it on which it has waited.
*
* <p>_The ‘user time’ is the CPU time charged for the execution of user instructions of the
* calling process. The ‘system time’ is the CPU time charged for execution by the system on
* behalf of the calling process._
*/
@Builtin("proc.time")
public static DoubleVector procTime() {
DoubleArrayVector.Builder result = new DoubleArrayVector.Builder();
StringVector.Builder names = new StringVector.Builder();
long totalCPUTime;
long userCPUTime;
long elapsedTime;
// There doesn't seem to be any platform-independent way of accessing
// CPU use for the whole JVM process, so we'll have to make do
// with the timings for the thread we're running on.
//
// Additionally, the MX Beans may not be available in all environments,
// so we need to fallback to app
try {
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
totalCPUTime = threadMXBean.getCurrentThreadCpuTime();
userCPUTime = threadMXBean.getCurrentThreadUserTime();
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
elapsedTime = runtimeMXBean.getUptime();
} catch (Error e) {
// ThreadMXBean is not available in all environments
// Specifically, AppEngine will throw variously SecurityErrors or
// ClassNotFoundErrors if we try to access these classes
userCPUTime = totalCPUTime = java.lang.System.nanoTime();
elapsedTime = new Date().getTime();
}
// user.self
names.add("user.self");
result.add(userCPUTime / NANOSECONDS_PER_SECOND);
// sys.self
names.add("sys.self");
result.add((totalCPUTime - userCPUTime) / NANOSECONDS_PER_SECOND);
// elapsed
// (wall clock time)
names.add("elapsed");
result.add(elapsedTime);
// AFAIK, we don't have any platform independent way of accessing
// this info.
// user.child
names.add("user.child");
result.add(0);
// sys.child
names.add("sys.child");
result.add(0);
result.setAttribute(Symbols.NAMES, names.build());
result.setAttribute(Symbols.CLASS, StringVector.valueOf("proc_time"));
return result.build();
}
/**
* Blocks the current Thread (<code>Thread.currentThread()</code>) until the receiver finishes its
* execution and dies or the specified timeout expires, whatever happens first.
*
* @param millis The maximum time to wait (in milliseconds).
* @param nanos Extra nanosecond precision
* @throws InterruptedException if <code>interrupt()</code> was called for the receiver while it
* was in the <code>join()</code> call
* @see Object#notifyAll
* @see java.lang.ThreadDeath
*/
public final void join(long millis, int nanos) throws InterruptedException {
if (millis < 0 || nanos < 0 || nanos >= NANOS_PER_MILLI) {
throw new IllegalArgumentException("bad timeout: millis=" + millis + ",nanos=" + nanos);
}
// avoid overflow: if total > 292,277 years, just wait forever
boolean overflow = millis >= (Long.MAX_VALUE - nanos) / NANOS_PER_MILLI;
boolean forever = (millis | nanos) == 0;
if (forever | overflow) {
join();
return;
}
VMThread t = vmThread;
if (t == null) {
return;
}
synchronized (t) {
if (!isAlive()) {
return;
}
// guaranteed not to overflow
long nanosToWait = millis * NANOS_PER_MILLI + nanos;
// wait until this thread completes or the timeout has elapsed
long start = System.nanoTime();
while (true) {
t.wait(millis, nanos);
if (!isAlive()) {
break;
}
long nanosElapsed = System.nanoTime() - start;
long nanosRemaining = nanosToWait - nanosElapsed;
if (nanosRemaining <= 0) {
break;
}
millis = nanosRemaining / NANOS_PER_MILLI;
nanos = (int) (nanosRemaining - millis * NANOS_PER_MILLI);
}
}
}
public void sortBubbleClassic() {
int currentPosition;
int maxPosition;
int temp;
switchCount = 0;
compareCount = 0;
timeAmount = System.nanoTime();
for (maxPosition = array.length - 1; maxPosition >= 0; maxPosition--) {
for (currentPosition = 0; currentPosition < maxPosition; currentPosition++) {
compareCount++;
if (array[currentPosition] > array[currentPosition + 1]) {
temp = array[currentPosition];
array[currentPosition] = array[currentPosition + 1];
array[currentPosition + 1] = temp;
switchCount++;
}
}
}
timeAmount = System.nanoTime() - timeAmount;
assert (validate());
return;
}
public static void performTest(final Map<String, Integer> m) throws Exception {
out.println("Test started for: " + m.getClass());
long avgTime = 0;
for (int i = 0; i < 5; i++) {
long startTime = System.nanoTime();
ExecutorService exService = Executors.newFixedThreadPool(POOL_SIZE);
for (int j = 0; j < POOL_SIZE; j++) {
exService.execute(
new Runnable() {
@SuppressWarnings("unused")
public void run() {
for (int i = 0; i < 500000; i++) {
Integer randomNum = (int) Math.ceil(Math.random() * 550000);
// Retrieve value. We are not using it anywhere
Integer value = m.get(String.valueOf(randomNum));
// Put value
m.put(String.valueOf(randomNum), randomNum);
}
}
});
}
// Make sure executor stops
exService.shutdown();
// Blocks until all tasks have completed execution after a shutdown request
exService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
long entTime = System.nanoTime();
long totalTime = (entTime - startTime) / 1000000L;
avgTime += totalTime;
out.println("500K entried added/retrieved in " + totalTime + " ms");
}
out.println("For " + m.getClass() + " the average time is " + avgTime / 5 + " ms\n");
}
@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_URGENT_AUDIO);
Logging.d(TAG, "AudioRecordThread" + WebRtcAudioUtils.getThreadInfo());
assertTrue(audioRecord.getRecordingState() == AudioRecord.RECORDSTATE_RECORDING);
long lastTime = System.nanoTime();
while (keepAlive) {
int bytesRead = audioRecord.read(byteBuffer, byteBuffer.capacity());
if (bytesRead == byteBuffer.capacity()) {
if (microphoneMute) {
byteBuffer.clear();
byteBuffer.put(emptyBytes);
}
nativeDataIsRecorded(bytesRead, nativeAudioRecord);
} else {
Logging.e(TAG, "AudioRecord.read failed: " + bytesRead);
if (bytesRead == AudioRecord.ERROR_INVALID_OPERATION) {
keepAlive = false;
}
}
if (DEBUG) {
long nowTime = System.nanoTime();
long durationInMs = TimeUnit.NANOSECONDS.toMillis((nowTime - lastTime));
lastTime = nowTime;
Logging.d(TAG, "bytesRead[" + durationInMs + "] " + bytesRead);
}
}
try {
if (audioRecord != null) {
audioRecord.stop();
}
} catch (IllegalStateException e) {
Logging.e(TAG, "AudioRecord.stop failed: " + e.getMessage());
}
}
private static void runJaversion(Integer[] data) {
out.println("Javersion PersistentHashMap");
PersistentHashMap<Integer, Integer> jmap = PersistentHashMap.empty();
// warmup
for (Integer v : data) {
jmap = jmap.assoc(v, v);
}
jmap = null;
System.gc();
long begin = System.nanoTime();
for (int i = 1; i <= data.length; i++) {
start();
jmap = PersistentHashMap.empty();
for (int j = 0; j < i; j++) {
jmap = jmap.assoc(data[j], data[j]);
}
for (int j = 0; j < i; j++) {
jmap = jmap.dissoc(data[j]);
}
out.println(end());
}
out.println(String.format("\n%s", System.nanoTime() - begin));
}
private static void runJavaTree(Integer[] data) {
out.println("Java TreeMap");
TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>();
// warmup
for (Integer v : data) {
map.put(v, v);
}
map = null;
// System.gc();
long begin = System.nanoTime();
for (int i = 1; i <= data.length; i++) {
start();
map = new TreeMap<Integer, Integer>();
for (int j = 0; j < i; j++) {
map.put(data[j], data[j]);
}
for (int j = 0; j < i; j++) {
map.remove(data[j]);
}
out.println(end());
}
out.println(String.format("\n%s", System.nanoTime() - begin));
}
private void sleepFor(long startNanos, long durationNanos) {
while (true) {
long elapsedNanos = System.nanoTime() - startNanos;
long sleepNanos = durationNanos - elapsedNanos;
long sleepMills = sleepNanos / NANOS_PER_MILLI;
if (sleepMills <= 0) {
return;
}
try {
Thread.sleep(sleepMills);
} catch (InterruptedException e) {
if (!isRunning()) {
return;
}
}
}
}
@FindBugsSuppressWarnings("FI_EXPLICIT_INVOCATION")
private void doFinalize(FinalizerReference<?> reference) {
FinalizerReference.remove(reference);
Object object = reference.get();
reference.clear();
try {
finalizingStartedNanos = System.nanoTime();
finalizingObject = object;
synchronized (FinalizerWatchdogDaemon.INSTANCE) {
FinalizerWatchdogDaemon.INSTANCE.notify();
}
object.finalize();
} catch (Throwable ex) {
// The RI silently swallows these, but Android has always logged.
System.logE("Uncaught exception thrown by finalizer", ex);
} finally {
finalizingObject = null;
}
}
public static void main(String args[]) throws InterruptedException, IOException {
int i, j;
String serverInetAddress = "localhost";
String server1AddressString = "10.10.1.1";
InetAddress server1Address = InetAddress.getByName(server1AddressString);
String server2AddressString = "10.10.2.2";
InetAddress server2Address = InetAddress.getByName(server2AddressString);
String server3AddressString = "10.10.3.2";
InetAddress server3Address = InetAddress.getByName(server3AddressString);
String server4AddressString = "localhost";
InetAddress server4Address = InetAddress.getByName(server4AddressString);
DatagramSocket skt;
{
skt = new DatagramSocket(PORT_NUMBER_CLIENT); // socket used to listen and write
InetAddress host = InetAddress.getByName(serverInetAddress);
int serversocket = S1.PORT_NUMBER_SERVER;
String msg = "Send file size";
byte[] b = msg.getBytes();
// dummy assignments - not used anywhere
int filesize = 1;
DatagramPacket reply, request;
reply = new DatagramPacket(b, b.length, host, serversocket);
request = new DatagramPacket(b, b.length, host, serversocket);
for (i = 1; i <= 3; i++) {
// defining a packet called request with parameters b(msg in bytes), b.length, host Internet
// address and socket number
if (i == 1) {
host = server1Address;
} else if (i == 2) {
host = server2Address;
} else if (i == 3) {
host = server3Address;
}
request = new DatagramPacket(b, b.length, host, serversocket);
// System.out.println("request sent from client to server");
Thread.sleep(S1.PAUSE_DURATION); // for error checks
// Sending the packet- for getting the file size
skt.send(request);
// getting reply from
// server........................................................................................
byte[] buffer =
new byte
[S1.PACKET_SIZE]; // apparently the size of data packet at the receiving side needs
// to be bigger than the size of incoming datapacket
reply = new DatagramPacket(buffer, buffer.length);
// receiving packet from server - contatining filesize
skt.receive(reply);
// System.out.println("Response Received from server");
// System.out.println("on Client: - filesize= "+new String(reply.getData()));
filesize = Integer.parseInt(new String(reply.getData()).trim());
// System.out.println("on Client: - filesize= "+filesize);
Thread.sleep(S1.PAUSE_DURATION);
}
// here the client know the size of the file
// Find the number of times it must make iterations - dividing filesize by packet_size
// Request that many packets from server
String[] buffer_string = new String[BUFFER_SIZE_CLIENT];
float delay[] = new float[filesize / S1.PACKET_SIZE];
System.out.println(filesize);
System.out.println(S1.PACKET_SIZE);
System.out.println(filesize / S1.PACKET_SIZE);
Thread.sleep(2000);
byte[] buffer = new byte[S1.PACKET_SIZE];
for (i = 0; i < filesize / S1.PACKET_SIZE; i++) {
if (i % 100 != 0) {
// System.out.print(" "+i);
} else {
System.out.println(" " + i);
}
msg = String.valueOf(i);
b = msg.getBytes();
if (i % 3 == 0) {
host = server1Address;
} else if (i % 3 == 1) {
host = server2Address;
} else if (i % 3 == 2) {
host = server3Address;
}
request = new DatagramPacket(b, b.length, host, serversocket);
skt.send(request);
delay[i] = System.nanoTime();
Thread.sleep(10);
skt.receive(reply);
delay[i] = System.nanoTime() - delay[i];
delay[i] = delay[i] / (1000000);
/*
if(empty_index<BUFFER_SIZE_CLIENT)
{
buffer_string[empty_index]=new String(reply.getData());
empty_index++;
}
else
{
for(j=0;j<BUFFER_SIZE_CLIENT-1;j++)
{
buffer_string[j]=buffer_string[j+1];
}
buffer_string[BUFFER_SIZE_CLIENT-1]=new String(reply.getData());
}*/
// display_buffer(buffer_string);
}
Arrays.sort(delay);
float delay2[] = new float[filesize / S1.PACKET_SIZE];
for (i = 0; i < delay2.length; i++) {
delay2[i] = delay[delay.length - i - 1];
}
// delay2 stores the array in descending values
float[] Sk = new float[filesize / S1.PACKET_SIZE];
Sk[0] = (float) 0.0;
for (i = 1; i < filesize / S1.PACKET_SIZE; i++) {
for (j = 1; j <= i; j++) {
Sk[i] = Sk[i] + delay2[j];
}
Sk[i] = Sk[i] / (10 * i);
}
make_output(Sk);
System.out.format(
"Sk at 2=%f\n,10=%f\n,20=%f\n,100=%f\n and 30000=%f\n ",
Sk[1], Sk[9], Sk[19], Sk[99], Sk[29999]);
// display_buffer(buffer_string);
skt.close();
}
}
private static long end() {
return System.nanoTime() - start;
}
private static void start() {
start = System.nanoTime();
}
