I am working on an application that has a real-time thread running.
My computer is slow, and the emulator runs very slowly on it. When I'm testing my app it seems as if the SystemClock.uptimeMillis() call is returning real-time values from the actual computer clock, meaning that time in the emulator is not running slowly even though the emulator is.
Is this hunch correct? That the emulator clock is tied to the real computer system clock (as opposed to being itself emulated and subject to fluctuation based on the CPU load of the host computer)? Seems like an obvious question, but I couldn't find it up on the internet.
It would make sense if this is the case. I need to know for sure because I need to know if my thread being unable to keep up is simply a symptom of the emulator slowness or if I actually need to redesign things. (Can't test on a real phone because I don't have one yet).
I believe to have determined that my hunch is correct.
I ran some simple tests, e.g:
long start = SystemClock.uptimeMillis();
Log.d("blah", "start");
while (SystemClock.uptimeMillis() < start + 10000)
{
// do some work-intensive stuff here
}
Log.d("blah", "finish");
...regardless of what I did in the intervening 10 seconds (inside the code loop and/or intentionally using my computer to do other stuff to load the CPU) the thread always reports back exactly 10 seconds after it starts (+10ms, overhead I assume), judging by both the LogCat timestamps and a stopwatch, which says to me that a loaded host CPU doesn't dilate the sense of time in the emulator at all, as would be expected.
To change this behavior, I believe that I want to pass an option to the QEMU layer:
$ emulator -avd my_avd -qemu -clock vm
But that may actually just have to do with setting the time when starting the VM (which QEMU apparently does do independently of managing the results of currentTimeMillis(), uptimeMillis(), and nanoTime()). Not sure (documentation for QEMU is pretty rough.) Regardless, the Android QEMU seems to lack the "vm" clock, so the above does not work. Note:
$ emulator -avd my_avd -qemu -clock ?
Available alarm timers, in order of precedence:
unix
But at least I've gathered enough evidence to suspect that my little theory is correct. :-) I don't see how emulated apps could play audio or execute UI transition effects or the like without a link to a real clock, so it makes sense. But it would be nice to have the option of emulating the clock.
Related
I am using the Android version 4.0.3 on a Windows system. My emulator was working pretty well, however all of sudden it became very slow.
It is taking too much time in launching so most of the time launch gets cancelled or I have to start the emulator ahead of time.
If you are having long times in emulator startup, you can configure AVD to save a snapshot of emulator. This significantly improves startup time, although the shutdown time will increase due to the saving of snapshot.
If you are having a slow emulator in general (booting and running programs), and, if you are using a Intel x86 processor you can install Intel Hardware Accelerated Execution Manager from android SDK. This will improve emulator speed by more then 10 times compared to the standard emulator. It even faster then a mid range real device.
good luck.
The emulators, all of them, on every platform, are infamous for slow startups. Typically you start the emulator, wait 'til it is all the way up, and then run your program. Debugging on a real device is infinitely preferable.
Leaving the emulator open between program runs is a necessity.
One of my professors gave up and spent several thousand dollars on a new computer with a huge solid-state drive because he could not get an emulator window up in less than five minutes, and it was impacting his ability to teach courses based on the platform. I went the cheaper route and dropped $200 on a tablet. Either way, hardware is the real answer here.
I went through the simple hello world application on the android developers forums to an absolute T. But, when I start the emulator all it comes up with is a large black screen that just says ANDROID_. The '_' is flashing. Does anyone know what may have caused this or why it is not working.
It can take a while to start. Remember it is emulating an ARM processor so that can take a while depending on the specs of your machine. Start it and give it 5 min. If it hasn't come up by then you may want to close and restart. While it is starting up, if you open ddms you can follow what is going on in logcat.
Good news is that if you enable snapshots, once you get it started and saved (it does this on its own). Subsequent starts should be pretty quick.
For some reasons, the android emulator does not work properly on any of the laptop's i have. It lags even on my high end laptop with 4 gb Ram, i5 processor and 1 gig graphics processor, so i connect my phone using usb cable, enable debugging mode and run the app on the phone from eclipse. You will need a working adb connection as stated on android developer website though. It works pretty good and is way better than using an emulator. :)
It takes about 3 mins for the emulator to load on a laptop. Wait for about 5-6 mins if not. close it.
In case when you restart still you get the same, go to AVD Manager delete the image and create a new one.
As the others have said, the emulator is very, very slow to start up. It can get wedged on startup for me, every now and again, but shutting it down and trying a second time almost always works. And yes, you can leave it running the whole time, but note that Eclipse and/or ADB can get wedged as well. You'll see logcat stop updating inside of Eclipse. I can usually get it restarted by doing
adb kill-server
adb start-server
Sometimes, just doing an adb logcat on a command line will get things moving again. Good luck.
I read on many other topics that the Android emulator starts really slow. Indeed, it takes +15 mins to start. However, on my machine is slow even after that.
The 'phone' responds with a 3-4 seconds delay and everything has a huge lag.
Is there any way to improve the performance of my laptop (Asus 1201N) is too rusty for the Android emulator?
PS: Tried in different emulator resolutions and the result is the same
Edit: My laptop has 2 cores with HyperThreading. And it shows as 4 CPU in Device Manager. However, when using the emulator, just one of the graphs is at 100%. Can I do something to make it work multi core?
Do you have "Disable Boot Animation" checked?
Also, if that doesn't fix it, one thing that helps is that you never actually have to close the emulator screen while you're coding. If you click debug when it's already open, your APK will get uploaded to the emulator and start pretty much immediately. For some reason it took me a while to figure out that I didn't have to manually close the emulator.
One thing I learned that helped me is that once the emulator is open from your first debug run you DO NOT have to close it. Leave it open, and on your next debug run it will be ready to go without any load up time like when you first open it.
In regards to your slowness after startup I suspect it's just your computer. It runs very fast for me. It starts up in about 20 seconds or less, and once it's open my subsequent debugs load very fast.
I hope at least my first tip helps to save some of your sanity.
Here's what you can try. It does speed up the emulator for me, especially during loading time.
I noticed the emulator is only using a single core of the available CPU. What I did is to set it to use all available processors.
I'm using Windows 7.
When the android emulator is starting, open up the Task Manager, look under the Process tab, look for "emulator-arm.exe" or "emulator-arm.exe *32" ...right click on it, select Processor Affinity and assign as much processor as you like to the emulator.
I think there is few ways to improve the performance of your Android Emulator like
Use Snapshot, this will improve the boot time for consecutive application running
Use x86 Intel Hardware Accelerator
Use 3rd Party Emulator like BlueStacks
Hopefully it will help you to improve the performance and resolve your problems.
Thanks
I had the same problem and in order to solve it I just disabled all the transition animation effects that are enabled under Spare Parts.
it is way too slow for me too.
(slow on both my Pentium 4 (ubuntu) and my dual core 64 laptop (Windows 7)
apparently it uses QEMU - could I perhaps look for the image file and try a different version of qemu?
Another thing I tried is this: http://www.android-x86.org/ (in vmware)
this seems MUCH faster but I can't get it to see the network!
(right now I just want to test some websites in the brower so seeing the network is a must - I'm not doing native apps just yet)
I discovered that instead of running the 'Debug' target, I just run the 'Run' target. The emulator runs a lot smoother when doing so. I only jump into debug mode if I really need it.
To connect to network from android-x86, you neek to manual setup ip manual by use this command in console mode (Alt + F1):
ifconfig eth0 netmask 255.255.255.0 up
after do that, you can check it by type : netcfg in console and you can see this ip is set at your local wmware
you can check it success by ping ip you had been set in command prompt, and after that, you can use adb connect to connect debugger to your virtual android
On my system, i am using eclipse ganymede version along the Android SDK and ADT plugin installed. I have created an android AVD (target android 1.5) with 512MB of memory. Its quite frustrating to see the slow boot up of it. It takes around 4-5 mins to complete its boot-up. Is there any way or tweak to speed up this boot up process.
PC config:
P4 2.4 Ghz with 1 GB ram.
You can use the -no-boot-anim command line option which speeds up the boot process by not showing the boot animation while the emulator starts up. It makes an noticeable difference on my system reducing start up time from around 55 seconds to nearer 45 seconds. (In case you're interested this is on a laptop with a Mobile Core 2 Duo L9400 and 3GB of RAM.)
Use a command line like this to start the emulator:
emulator -no-boot-anim #YourAvdName
where YourAvdName is the name of the Android Virtual Device (AVD) image that you want to start.
There is now way of to speed up the boot process. This is the downside of having a real emulator not just a simulator like the Iphone kit offers.
You don't have to quit the emulator after a test run. Just start the emulator at the beginning of your work and close it after you are finished. If you want to test something very quick I often find it easier to just connect my actual device and run my app on the real device, without waiting for the emulator to start up.
There's no real way to cut the time down significantly, and it performs so poorly as a tablet device, it's barely usable. Bottom line, you need a real device to produce production apps. It's good for learning though.
The "emulator" is widely known for being a simulator. It does not:
come with device roms or known emulation for real world devices
off phone or SMS support
have the ability to open listening sockets for incoming requests
etc etc. It is not an emulator like mame. It's a simulator like the iPhone/iPad simulator.
i started off with the default settings on the AVD manager to create a new AVD and it started up kind of ok, about 1-2 mins. later i deleted that and created a new AVD with 8GB internal memory (like the real device i'm using) and startup didn't! i waited 30 mins but still nothing
so i reverted to the default memory (512MB) and it seems to start ok
but i also noticed, its a bad idea to unclick the hardware buttons options, that causes it to load slow too
install virtualbox and use androVM
much better than the emulator
The option that I select so far is to buy a cheap mobile from Kogan.com and use this is your app tester.
Otherwise you can also go and install Genymotion, which is definitely a ++ tool over AVD through Android Studio.
It is fast as well. However, keep in mind that there are many features that will be missing such as google play services. Thus, it is advisable that you buy a device. With Android supported mobile, you could basically do everything and simulate every events such as swipe shake etc...
I am using the android emulator to run my programs.
But its really slow.
It takes around 90 seconds to startup and show the home screen.
Can I tweak it so that I can reduce this time considerably?
Thanks
I was having a similar problem (thread here). However, mine was taking 10-15 mins. 90 seconds is blazing fast considering a lot of threads in the Android discussion groups. The emulator is slow by nature and the only recommendation I read was to keep the emulator open instead of closing it and rerunning it. However, as mentioned in my thread, if you have a physical Android device, you can just run it on that. It's what I'm doing at the moment and it was top-notch advice. No long waiting time. If you don't have a physical device, then I can only suggest you don't close the emulator between code changes, as the system will recognise the change.
use those 3 options.
emulator --cpu-delay 0 --no-boot-anim --cache ./cache --avd avd_name
the first two are obvious. the third one will make the memory of the emulator kind of persistent. you can point it to any file that does not get destroyed by boot (such happens with /tmp) it's like a always-on hibernating device.
If you absolutely cannot use a physical Android device, what you can do is run the Android OS on Virtualbox, and then get the IP address of the emulated Android. Then you'd connect ADB to the emulator using that IP address. That's the jist of it. I've written a more detailed guide to this approach on my blog. http://www.bobbychanblog.com/2011/07/faster-android-emulator-alternative-using-virtualbox/
The -no-boot-anim parameter is good.
Don't turn the emulator off, just re-launch your app.
For further speedups, try the new snapshot feature, which is described here.
Scaling the emulator down made my emulator load faster...
emulator -cpu-delay 0 -no-boot-anim -cache ./cache -scale 0.8 -avd avd_name
actually these are all great answers, but have u thought of changing the ram from the default 96mb to something like 512? works for me :)
If you have the mobile device with you, it's much quicker (and more reliable) to compile it via USB to the device. It takes around 5 seconds to compile and install on your phone, I never use the emulator anymore - it's just to slow.
Not only is it slow but anything other than static widgets (animation) will struggle to run on the emulator and you will notice lag.
I recommend you to use Genymotion . It's a very fast emulator (less than 10 seconds to run in my case)
It has Google Apps installed also including Google Play App which give the chance to download any app. This is a good feature for testing apps with Maps Api.
You need to install Intel HAXM
open you SDK and install
Create a new AVD
Now when run it you should get this
if not then you will need to install Accelerated Execution Manager
See this Running the new Intel emulator for Android on how can you do this
see how much faster do you get Video
While developing my game, Elastic World, I was suffering from the same problem. After waiting minutes for the emulator to startup, the game was running at 20 FPS maximum. Even on low end android devices I could easily get 60 FPS.
So I moved to a VMWare Android machine, following the instructions from this site: http://www.android-x86.org/documents/installhowto/
The same game loop now runs at 250 FPS. (it's not playable at this speed and I have the game limited to max 60 FPS, but overriding this limitation it gives 250 FPS)
Try to use a smaller resolution for your emulator as for example HVGA. The emulator gets slower the more pixels its needs to render as it is using software rendering.
Also if you have sufficient memory on your computer, add at least 1 GB of memory to your emulator. This is the value "Device ram size" during the creation of the AVD.
Also set the flag "Enabled" for Snapshots. This will save the state of the emulator and let it start much faster.
Just enable "Snapshot" checkbox in your AVD Manager. It will save the state of your AVD when you close it. So, once you run the emulator again, that saved state will be loaded. Hence the boot up time of your AVD will be considerably reduced.
First I follow this introduction
Run emulation with command : emulator -cpu-delay 0 -no-boot-anim -cache ./cache -avd <adv-name> -gpu on (follow link and link)
results is run ~2-3x faster