I'm curious about this.
I wanted to check which function was faster, so I create a little code and I executed a lot of times.
public static void main(String[] args) {
long ts;
String c = "sgfrt34tdfg34";
ts = System.currentTimeMillis();
for (int k = 0; k < 10000000; k++) {
c.getBytes();
}
System.out.println("t1->" + (System.currentTimeMillis() - ts));
ts = System.currentTimeMillis();
for (int i = 0; i < 10000000; i++) {
Bytes.toBytes(c);
}
System.out.println("t2->" + (System.currentTimeMillis() - ts));
}
The "second" loop is faster, so, I thought that Bytes class from hadoop was faster than the function from String class. Then, I changed the order of the loops and then c.getBytes() got faster. I executed many times, and my conclusion was, I don't know why, but something happen in my VM after the first code execute so that the results become faster for the second loop.
This is a classic java benchmarking issue. Hotspot/JIT/etc will compile your code as you use it, so it gets faster during the run.
Run around the loop at least 3000 times (10000 on a server or on 64 bit) first - then do your measurements.
You know there's something wrong, because Bytes.toBytes calls c.getBytes internally:
public static byte[] toBytes(String s) {
try {
return s.getBytes(HConstants.UTF8_ENCODING);
} catch (UnsupportedEncodingException e) {
LOG.error("UTF-8 not supported?", e);
return null;
}
}
The source is taken from here. This tells you that the call cannot possibly be faster than the direct call - at the very best (i.e. if it gets inlined) it would have the same timing. Generally, though, you'd expect it to be a little slower, because of the small overhead in calling a function.
This is the classic problem with micro-benchmarking in interpreted, garbage-collected environments with components that run at arbitrary time, such as garbage collectors. On top of that, there are hardware optimizations, such as caching, that skew the picture. As the result, the best way to see what is going on is often to look at the source.
The "second" loop is faster, so,
When you execute a method at least 10000 times, it triggers the whole method to be compiled. This means that your second loop can be
faster as it is already compiled the first time you run it.
slower because when optimised it doesn't have good information/counters on how the code is executed.
The best solution is to place each loop in a separate method so one loop doesn't optimise the other AND run this a few times, ignoring the first run.
e.g.
for(int i = 0; i < 3; i++) {
long time1 = doTest1(); // timed using System.nanoTime();
long time2 = doTest2();
System.out.printf("Test1 took %,d on average, Test2 took %,d on average%n",
time1/RUNS, time2/RUNS);
}
Most likely, the code was still compiling or not yet compiled at the time the first loop ran.
Wrap the entire method in an outer loop so you can run the benchmarks a few times, and you should see more stable results.
Read: Dynamic compilation and performance measurement.
It simply might be the case that you allocate so much space for objects with your calls to getBytes(), that the JVM Garbage Collector starts and cleans up the unused references (bringing out the trash).
Few more observations
As pointed by #dasblinkenlight above, Hadoop's Bytes.toBytes(c); internally calls the String.getBytes("UTF-8")
The variant method String.getBytes() which takes Character Set as input is faster than the one that does not take any character set. So for a given string, getBytes("UTF-8") would be faster than getBytes(). I have tested this on my machine (Windows8, JDK 7). Run the two loops one with getBytes("UTF-8") and other with getBytes() in sequence in equal iterations.
long ts;
String c = "sgfrt34tdfg34";
ts = System.currentTimeMillis();
for (int k = 0; k < 10000000; k++) {
c.getBytes("UTF-8");
}
System.out.println("t1->" + (System.currentTimeMillis() - ts));
ts = System.currentTimeMillis();
for (int i = 0; i < 10000000; i++) {
c.getBytes();
}
System.out.println("t2->" + (System.currentTimeMillis() - ts));
this gives:
t1->1970
t2->2541
and the results are same even if you change order of executions of loop. To discount any JIT optimizations, I would suggest run the tests in separate methods to confirm this (as suggested by #Peter Lawrey above)
So, Bytes.toBytes(c) should always be faster than String.getBytes()
Related
I'm trying to get a precise clock that is not influenced by other processes inside the app.
I currently use System.nanoTime() like below inside a thread.
I use to calculate the timing of each of the sixteen step.
Currently timed operations have sometime a perceptible delay that i try to fix.
I would like to know if there is a more precise way to obtaining timed operations, maybe by check the internal soundcard clock and use it to generate the timing i need.
I need it to send midi notes from android device to external audio sinthetizers and for audio i need precise timing
Is there anyone who can help me improve this aspect?
Thanks
cellLength = (long)(0.115*1000000000L);
for ( int x = 0; x < 16; x++ ) {
noteStartTimes[x] = x*cellLength ;
}
long startTime = System.nanoTime();
index = 0;
while (isPlaying) {
if (noteStartTimes[index] < System.nanoTime() - startTime) {
index++ ;
if (index == 16) { //reset things
startTime = System.nanoTime() + cellLength;
index = 0 ;
}
}
}
For any messages that you receive, the onSend callback gives you a timestamp.
For any messages that you send, you can provide a timestamp.
These timestamps are based on System.nanoTime(), so your own code should use this as well.
If your code is delayed (by its own processing, or by other apps, or by background services), System.nanoTime() will accurately report the delay. But no timer will function can make your code run earlier.
I'm getting a very peculiar issue with my audio callbacks in my Android app (that's using NDK/OpenSL ES). I'm streaming audio output at 44.1 kHz and 512 frames (which gives me a callback time of 11.6 ms). In the callback, I'm synthesizing a couple of waveforms, filters, etc (like a synthesizer). Due to optimization I never reach over 5 ms of the callback time. However, when I turn on a specific effect (digital delay line), it starts to take a radically longer time in the callback. The digital delay line will jump from 7.5 ms (after all voices/filters have been processed) and jump up to 100 to 350 ms.
This is the most confusing part; after maybe 1 or 2 seconds, the digital delay execution time will jump from the extremely high time to 0.2 ms completion time per callback.
Why would the Android app take a long time to complete my digital delay processing code the first few callbacks and then die down to a very short and audio-happy time? I'm kind of at a loss right now and not sure how to fix this. To confirm, this only happens with the delay processing method. It's just a standard digital delay line (you can find some on github) and I feel like the algorithm isn't the problem here...
Kind of a pseudocode/rough sketch of what my audio callback code looks like:
static bool myAudioCallback(void *userData, short int *audIO, int numSamples, int srate) {
AudioData *data = (AudioData *)userData;
// Resets pointer array values to 0
for (int i = 0; i < numSamples; i++) data->buffer[i] = 0;
// Voice Generation Block
for (int voice = 0; voice < data->numVoices; voice++) {
// Reset voice buffers:
for (int i = 0; i < numSamples; i++) data->voiceBuffer[i] = 0;
// Generate Voice
data->voiceManager[voice]->generateVoiceBlock(data->voiceBuffer, numSamples);
// Sum voices
for (int i = 0; i < numSamples; i++) data->buffer[i] += data->voiceBuffer[i]];
}
// When app first starts, delayEnabled = false so user must click on a
// button on the UI to enable it.
// Trouble is that when we enable processDelay(double *buffer, in frames) the
// first time, we get a long execution time.
if (data->delayEnabled) {
data->delay->processDelay(data->buffer, numSamples);
}
// Conversion loop
for (int i = 0; i < numSamples; i++) {
double sample = clipOutput(data->buffer[i]);
audIO[2*i] = audIO[(2*i)+1] = CONV_FLT_TO_16BIT(sample * data->volume);
}
}
Thanks!
Not a great answer to the solution but this is what I did:
Before the user is able to do anything on the app, I turned on the delay and let it run its course for like 2 seconds before switching it off. This allows the callback to do its weird long 300 ms execution time while not destroying the audio.
Obviously this is not a great answer and if anyone can figure out a more logical explanation I would be more than happy to mark that as the answer.
I'm trying to compare "Cross platform mobile application development tools" vs "Android Native development" from a performance perspective. In order to do that I developed an application which makes a calculation of a serie. Below I transcript Android and Phonegap code.
Android
double serie;
long t1 = System.currentTimeMillis();
serie = 0;
for (int j = 1; j <= 5; j++) {
for (int k = 1; k <= 100000; k++) {
serie = serie + Math.log(k) / Math.log(2) + (3 * k / (2 * j)) + Math.sqrt(k) + Math.pow(k, j - 1);
}
}
long duration = System.currentTimeMillis() - t1;
Phonegap
var start = new Date().getTime();
var serie = 0;
for ( var j=1; j <= 5; j++ ){
for ( var k=1; k <= 100000; k++ ){
serie = serie + ( Math.log(k)/Math.LN2 ) + (3*k/2*j) + Math.sqrt(k) + Math.pow(k, j-1);
}
}
var end = new Date().getTime();
var duration = end - start;
Each timing was taken thirty times and the results were averaged.
Results
Android average time = 532.93ms
Phonegap average time = 230.33ms
The results are far from what I expected. I don't understand why Android performance is worse than Phonegap's. Both applications are run as release versions.
The device is a Moto G2 (Android 4.4)
Am I missing something?
I am not sure if this performance comparison makes any sense. You simply perform some computation in Java and then in JavaScript. After that, you measure computation time. It doesn't prove anything.
The only conclusion you could have is the fact that JavaScript performed this particular computation faster than Java for some reason. Maybe JavaScript optimized something under the hood. As it's dynamically typed language, you should check if Java and JavaScript code returned the same result, because I'm not sure about that. Moreover, you are measuring time in a different ways in two tests. Maybe System.currentTimeMillis(); simply takes more time than new Date().getTime(); ?
In real life, you put non-deterministic and long operations to a separate thread different than UI thread. When operation is done, you can pass the result to the UI thread. Bad project structure and bad programming practices can slow down your application. With cross-platform tools like Phonegap, you have no control over Java code and you have very limited access to low level optimization techniques and multi-threading. You also have no direct access to Android SDK.
If you really want to analyze performance, you should prepare more realistic instrumentation test. For example, create application (in two versions: Android & Phone Gap), which reads some data from a file and images from disk and then displays it on the list and with instrumentation test, you can scroll the list down to the bottom. Afterwards, you can measure time of whole instrumentation test in both cases. Having something like that, you can make some assumptions.
I've been using this tutorial to create a game loop.
In the section marked "FPS dependent on Constant Game Speed" there is some example code that includes a Sleep command
I googled the equivalent in java and found it is
Thread.sleep();
but it returns an error in eclipse
Unhandled exception type InterruptedException
What on earth does that mean.
And also I was wondering what the
update_game();
display_game();
methods may contain in an opengl-es game (ie: where is the renderer updated and what sort of things go on in display_game();
I am currently using a system that uses the GLSurfaceView and GLSurfaceRenderer features
Here is my adaptation of the code in the tutorial
public Input(Context context){
super(context);
glSurfaceRenderer = new GLSurfaceRenderer();
checkcollisions = new Collisions();
while (gameisrunning) {
setRenderer(glSurfaceRenderer);
nextGameTick += skipTicks;
sleepTime = nextGameTick - SystemClock.uptimeMillis();
if(sleepTime >= 0) {
Thread.sleep(sleepTime);
}else{
//S*** we're behind
}
}
This is called in my GLSurfaceView although I'm not sure whether this is the right place to implement this.
Looks like you need to go through a couple of tutorials on Java before trying to tackle android game development. Then read some tutorials on Android development, then some more general game development tutorials. (Programming is a lot of reading.)
Thread is throwing an exception when it gets interrupted. You have to tell Java how to deal with that.
To answer your question directly, though, here's a method that sleeps till a specific time:
private void waitUntil(long time) {
long sleepTime = time - new Date().getTime();
while (sleepTime >= 0) {
try {
Thread.sleep(sleepTime);
} catch (InterruptedException e) {
// Interrupted. sleepTime will be positive, so we'll do it again.
}
sleepTime = time - new Date().getTime();
}
}
You should understand at least this method before continuing on game development.
Ironically, Ron Romero's code doesn't work. There are two issues with it: the while loop and the sleeptime variable.
The sleepTime variable is set based off of a specified time (in milliseconds) to sleep. It takes the time and subtracts it from current millisecond time. The problem with this is that the current millisecond time is a huge number (hence the long variable type), which provides a NEGATIVE sleepTime number. You'll never enter the while loop with this code.
The second thing that's wrong is the while loop check itself. Utilizing the sleep function in java, you don't need to do a loop like this. All you have to do is pass the sleepTime that you want to sleep for in milliseconds to the sleep function and it will work just fine.
private void waitUntil(long time) {
try {
Thread.sleep(time);
}
catch (InterruptedException e) {
//This is just here to handle an error without crashing
}
}
Java performs compile-time checking of checked exceptions.
I developed an auto-call application. The app reads a text file that includes a phone number list and calls for a few second, ends the call and then repeats.
My problem is that the app does not send calls after 10~16 hours. I don't know the reason exactly, but I guess that the problem is the CPU usage. My app's CPU usage is almost 50%! How do I reduce CPU usage?
Here is part of source code:
if(r_count.compareTo("0")!=0) {
while(index < repeat_count) {
count = 1;
time_count = 2;
while(count < map.length) {
performDial(); //start call
reject(); //end call
finishActivity(1);
TimeDelay("60"); // wait for 60sec
count = count + 2;
time_count = time_count + 2;
onBackPressed(); // press back button for calling next number
showCallLog();
finishActivity(0);
}
index++;
}
This is the TimeDelay() method source:
public void TimeDelay(String delayTime) {
saveTime = System.currentTimeMillis()/1000;
currentTime = 0;
dTime = Integer.parseInt(delayTime);
while(currentTime - saveTime < dTime) {
currentTime = System.currentTimeMillis()/1000;
}
}
TimeDelay() repeats in the while loop for a few times.
The reason it's using 50% of your CPU is that Android apparently won't let it use 100% of the CPU, which a loop like the one in your TimeDelay() ordinarily would. (Or else you have two CPUs and it is in fact using 100% of one CPU.) What you're doing is called a busy wait and it should be obvious why continually checking a condition will use lots of CPU. So don't do that. Use Thread.sleep() instead. Your app will then use no CPU at all during the wait.
Also, for God's sake, why are you passing a string and then parseInting it, rather than just passing an Integer in the first place? :-)
If your method take a long time to finish , especially the while loop. You should put Thread.sleep(50) inside your loop. This makes you processor be able to handle other processes.
Your CPU will be reduced. Not sure but you should try.
Hope you get good result.