i'm trying to test my ionic app on genymotion but it's very slow (animations take up to 2 seconds to play, transitions are laggy)
I could not find a solution so i tried creating a test project from scratch to see if it worked smoothly on genymotion. I tried just running these commands on the command line to build a new example project.
ionic start myApp tabs
ionic platform android
ionic run android
after that the example app gets started on genymotion, but it's still very slow. is this normal?
I'm answering my own question hoping that it will be helpful to someone in the future.
After testing on a real device I discovered that apparently genymotion does not work well when emulating cordova apps (this might have something to do with the webview version genymotion uses, but i dont know), and android's SDK emulator is just horrible and unusable.
I tested my app on a real device and it works OK, so the emulation was not representative of the actual performance, not even using genymotion that has been known to be very fast, at least for hybrid apps in the current version
In the end testing on a real device seems to be the only way to be sure.
The best solution I've found is the following
Install "Google APIs Intel x86 Atom System Image" for your preferred SDK version (I'm using 6.0.0)
Create a new AVD with the following settings:
Target -> Google APIs (Google Inc.) - API Level 23
CPU/ABI -> Google APIs Intel Atom (x86)
Memory Option -> RAM -> 1024 (too much ram causes the emulator not to start)
Emulation Options -> Use Host GPU -> Checked
From my experience, this was the best performing emulator. Hope this helps.
You can use sdk version 4.2 , it is still better than 4.4 for now to run ionic in genymotion.
https://github.com/driftyco/ionic/issues/3619
So I am a beginner to Android development and decided I would start learning based on the Android site itself how to make android apps. I thought a good place to start would be making my first emulator and running a minimal hello world program.
Using the Android Guide:
http://developer.android.com/tools/devices/managing-avds.html
It instructs how to make an emulator but the appearance of my AVD is radically different than the one they are using and I have encountered an error with it which I cannot find online literature to fix:
Specifically the process they give to make a new virtual device is hit "new" (in my case I am guessing that is the same thing as "create" since there is no "new "button on the most recent version of AVD manager)
And after that a form appears, I am supposed to fill up the form with relevant Virtual Device information and hit "ok" to create the device.
Except... after filling all the information I still cannot hit "ok". The button is greyed out, and I have done everything exactly as the android guide told me. What should I do to fix this? I have the form displayed below notice the greyed out ok button on the bottom right corner.
The problem is in the field: "CPU/ABI: No System images installed for this target". To rectify, open up the Android SDK Manager and download/install a System Image.
For example, when I open the Android SDK Manager, I expand the Android 4.4.2 (API 19) and install the ARM EABI v7a System Image (and for giggles, I might install the Intel image as well).
Whilst there, make sure you have other bits you might need for development (but not necessarily for the emulator) like the SDK and I'd definitely recommend downloading the sources, samples, SDK Tools, SDK Platform-tools and SDK Build-Tools.
You can use a later API version if you like, but API 19 has been released into production at the time of writing.
After which, you can restart the AVD and you'll be able to select the a CPU and create the emulator.
I suggest you should add all the "Android System Images" to your Android SDK Manager.
For that,
Open your SDK Manager from Windows -> Android SDK Manager.
Now expand each Android API versions then check Google and Intel X86 both system images and also check Intel HAXM Installer in the Extras.
Download and install them.
After successful install, the status changes to be as "Installed".
Try this also:
Now if your system have a Processor that have a feature called as Intel Virtualization Technology, then Intel X86 images will be huge benefit for you. because it supports Intel® Hardware Accelerated Execution Manager (Intel® HAXM).
To check that your processor support HAXM or not : Click Here
You need to manually install the Intel HAXM in your system. Follow these steps for that.
First of all go to - adt -> extras -> intel -> Hardware_Accelerated_Execution_Manager
Make sure that Intel Virtualization is enabled from BIOS Settings.
Now install Intel HAXM in your system and select amount of memory(i prefer to set it as default value).
After installation create new AVD which should have a Target of API Level xx
Now set the CPU/ABI as Intel Atom(x86).
If you are on Windows then do not set RAM value more than 768 MB while setting up an emulator.
Run the emulator. It will be blazing fast then ordinary one.
Hope it will be helpful for you. :)
Want to improve this post? Provide detailed answers to this question, including citations and an explanation of why your answer is correct. Answers without enough detail may be edited or deleted.
Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 4 years ago.
The community reviewed whether to reopen this question 1 year ago and left it closed:
Original close reason(s) were not resolved
Improve this question
I have got a 2.67 GHz Celeron processor, and 1.21 GB of RAM on a x86 Windows XP Professional machine.
My understanding is that the Android Emulator should start fairly quickly on such a machine, but for me, it doesn't. I have followed all the instructions in setting up the IDE, SDKs, JDKs and such and have had some success in starting the emulator quickly, but that is very rare. How can I, if possible, fix this problem?
Even if it starts and loads the home screen, it is very sluggish. I have tried the Eclipse IDE in version 3.5 (Galileo) and 3.4 (Ganymede).
Update
You can now enable the Quick Boot option for Android Emulator. That will save emulator state, and it will start the emulator quickly on the next boot.
Click on Emulator edit button, then click Show Advanced Setting. Then enable Quick Boot like below screenshot.
Android Development Tools (ADT) 9.0.0 (or later) has a feature that allows you to save state of the AVD (emulator), and you can start your emulator instantly. You have to enable this feature while creating a new AVD or you can just create it later by editing the AVD.
Also I have increased the Device RAM Size to 1024 which results in a very fast emulator.
Refer to the given below screenshots for more information.
Creating a new AVD with the save snapshot feature.
Launching the emulator from the snapshot.
And for speeding up your emulator you can refer to Speed up your Android Emulator!:
Using ssd hard drive has too much impact and I recommend to use more suitable ram (8 or higher)
IMPORTANT NOTE: Please first refer to the Intel list about VT to make sure your CPU supports Intel VT.
HAXM Speeds Up the Slow Android Emulator
HAXM stands for - "Intel Hardware Accelerated Execution Manager"
Currently, it supports only Intel® VT (Intel Virtualization Technology).
The Android emulator is based on QEMU. The interface between QEMU and the HAXM driver on the host system is designed to be vendor-agnostic.
Steps for Configuring Your Android Development Environment for HAXM
Update Eclipse:
Make sure your Eclipse installation and the ADT plug-in are fully up-to-date.
Update your Android Tools:
After each Eclipse plug-in update, it is important to update your Android SDK Tools. To do this, launch the Android SDK Manager and update all the Android SDK components. To take advantage of HAXM, you must be on at least release version 17.
Download the x86 Atom System Images and the Intel Hardware Accelerated Execution Manager Driver. Follow the image below:
Install the HAXM Driver by running "IntelHaxm.exe". It will be located in one of the following locations:
C:\Program
Files\Android\android-sdk\extras\intel\Hardware_Accelerated_Execution_Manager
C:\Users\<user>\adt-bundle-windows-x86_64\sdk\extras\intel\Hardware_Accelerated_Execution_Manager
If the installer fails with the message that Intel VT must be turned on, you need to enable this in the BIOS. See the description for how to do this in Enabling Intel VT (Virtualization Technology) .
Create a new x86 AVD: Follow the image below:
Or as for new SDK,
Try Android x86. It's much faster than the Google Android emulator. Follow these steps:
Install VirtualBox.
Download the ISO file that you need.
Create a virtual machine as Linux 2.6/Other Linux, 512 MB RAM, HD 2 GB. Network: PCnet-Fast III, attached to NAT. You can also use a bridged adapter, but you need a DHCP server in your environment.
Install Android x86 on the emulator, run it.
Press Alt+F1, type netcfg, remember the IP address, press Alt+F7.
Run cmd on your Windows XP system, change the directory to your Android tools directory, type adb connect <virtual_machine_IP>.
Start Eclipse, open the ADT plugin, find the device, and enjoy!
UPDATE: The latest version of Android studio (2.x) made major improvements to the bundled emulator. It's responsive and has a whole bunch of features.
For those still interested:
Try using Genymotion. You can download a version for Windows/Mac OS X/Linux after registering. A plugin for Eclipse is also available:
The installation of the plugin can be done by launching Eclipse and going to "Help / Install New Software" menu, then just add a new Update Site with the following URL: http://plugins.genymotion.com/eclipse. Follow the steps indicated by Eclipse.
This emulator is fast and responsive.
GenyMotion allows you to control various sensors of your device including the battery level, signal strength, and GPS. The latest version now also contains camera tools.
The emulator included in your (old) version of Eclipse is very slow.
Recent emulators are faster than they use to be in 2010. Update your SDK/IDE.
Personally, I use a real phone to do my tests. It is faster and tests are more realistic. But if you want to test your application on a lot of different Android versions and don't want to buy several phones, you will have to use the emulator from time to time.
The startup of the emulator is very slow. The good thing is that you only need to start the emulator once. If the emulator is already running and you run your app again, the emulator reinstalls the app relatively quickly. Of course, if you want to know how fast it will run on a phone, it is best to test it on a real phone.
Intel released recommended installation instructions for the ICS emulator on May 15, 2012. This worked for me. The emulator is now fast and the UI is smooth.
The first half of the instructions are detailed enough, so I will assume you were able to install the Intel x86 Atom System Image(s) using the Android SDK manager, as well as Intel HAXM.
Now to ensure that everything else is set up so you can enjoy a highly performing emulator:
Install Intel Hardware Accelerated Execution Manager (HAXM)
And start it:
sudo kextload -b com.intel.kext.intelhaxm (mac)
If HAXM is working properly, you may see this message when launching the emulator:
HAX is working and emulator runs in fast virtual mode
Otherwise, you may see this error:
HAX is not working and the emulator runs in emulation mode emulator:
Failed to open the hax module
Use GPU emulation. You cannot use the Snapshot option when using GPU emulation as of this writing. Ensure that GPU emulation is set to "yes".
Set the device memory to 1024 MB or more, but not more than the Intel HAXM setting. I use 1024 MB per device and 2048 for HAXM.
Always double-check the settings after saving! The emulator is very picky about what it allows you to set, and it will revert configurations without telling you.
With these settings the software keyboard no longer appears, nor do the on-screen back, menu, and recent keys. This appears to be a limitation of the current ICS Intel x86 system image. You will need to use the keyboard shortcuts.
On Mac OS you will need to hold fn + control for the F1 - F12 keys to work. Page up/down/left/right can be performed using control + arrow keys.
You can create emulator.bat with following command to start the emulator. It will start faster.
emulator.exe -cpu-delay 0 -no-boot-anim #<avd name>
Or on Unix (Mac or Linux flavors):
emulator -cpu-delay 0 -no-boot-anim #<avd name>
I've noticed that the emulator starts much faster if there's no Dalvik Debug Monitor Server (DDMS) connected. So if you start the emulator from Virtual Device Manager "SDK Setup.exe" and Eclipse is not started, the emulator works faster.
If you start the emulator from Eclipse: DDMS is there, so sometimes the emulator is extremely slow, but sometimes it's faster.
Emulators are slow. There's really nothing you can do about it, but there are alternatives to the emulator.
Genymotion - Preferred
VirtualBox
BlueStacks
YouWave
Windows Android Emulator
Jar of Beans
Andy
To make your emulator faster, you can host a GPU and use a lighter Android version (Android 2.3 (Gingerbread)).
Developing on a Mac would be better. Why use an emulator, BTW? Using a real phone makes more sense.
As of Revision 17 of Android SDK Tools, the emulator can use graphic acceleration and CPU-provided extensions for better efficiency. The prerequisites and full configuration and user notes are at:
http://developer.android.com/guide/developing/devices/emulator.html#acceleration
For enabling GPU aceleration, run the emulator from the command line or add "-gpu on" to the additional emulator command line options in the AVD configuration.
emulator -avd <avd_name> -gpu on
For using the CPU machine extensions, you have to install the driver (caution because it can conflict with existing VirtualBox or VMware drivers). Once it's installed it will be used automatically whenever you use an x86-based AVD.
Try to disable your antivirus. Maybe it will make emulator a little bit faster.
Android SDK rev. 17 supports Virtual Machine Acceleration using AMD and Intel virtualization technologies.
This feature can improve the emulator performance a lot!
See the following section in the Android emulator documentation for more details: Configuring Virtual Machine Acceleration
Don't forget to install the appropriate driver for your operating system:
Configuring VM Acceleration on Windows
Configuring VM Acceleration on Mac
Configuring VM Acceleration on Linux
After you have installed the drivers and downloaded an Android X86 system image (as described in the documentation) you should be able to create a new AVD using the x86 image:
For example:
Target: Intel Atom x86 System Image - API Level 10
CPU/ABI: Intel Atom (x86)
The option -cpu-delay <delay> described in Emulator Startup Options can help.
The emulator seems to slow itself down when idle. This is made apparent by rapidly mousing over the keys on the side and observing the light-up responses. As a workaround, I pass -icount auto to QEMU when starting the emulator. You can make a batch file called my_avd.bat to do it for you:
emulator #my_avd -no-boot-anim -qemu -icount auto
#my_avd -- launch a virtual device named 'my_avd'
-no-boot-anim -- disable animation for faster boot
-qemu args... -- pass arguments to qemu
-icount [N|auto] -- enable virtual instruction counter with 2^N clock ticks per instruction
This made animations buttery smooth and sped up adb install tenfold.
Android emulator release 9 has a new "snapshot" feature. You can save the state of the emulator (make an image of the emulator) and avoid booting when you start the emulator.
You can review the emulator issues on the Google I/O 2011: Android Development Tools talk, starting a 0:40:20.
The emulator runs slowly because the complete Android environment is running on emulated hardware and the instructions are executed on an emulated ARM processor as well.
The main choking point is rendering since it's not running on any dedicated hardware but it's actually being performed through software rendering. Lowering the screen size will drastically improve emulator performance. Getting more/faster memory isn't going to help.
They've mentioned, at the time, that they're developing an interface that would allow the emulator to pipe certain instructions through the host hardware, so eventually, you'll be able to leverage emulator performances with the raw power of desktop hardware.
The current (May 2011) version of the emulator is slow particularly with Android 3.0 (Honeycomb) primarily because the emulator does not support hardware GL -- this means that the GL code gets translated into software (ARM software, in fact) which then gets emulated in software in QEMU. This is crazy-slow. They're working on this problem and have it partially solved, but not with any sort of release quality.
Check out the video Google I/O 2011: Android Development Tools to see it in action -- jump to about 44 minutes.
Use the Intel x86 Emulator Accelerator
First, install the Intel x86 Emulator Accelerator (HAXM). This can be downloaded directly from Intel or using Android SDK Manager. In the SDK Manager, it's located under Extras.
In the version of Android Studio I used (0.8.9), Android SDK Manager downloads HAXM but doesn't actually run the installer (I assume this will be fixed in later releases). To run the installer I had to go to C:\Program Files (x86)\Android\android-studio\sdk\extras\intel\Hardware_Accelerated_Execution_Manager and manually launch intelhaxm.exe.
HAXM works with Intel devices, so created a new Emulator with Intel CPU.
Create a new AVD using Intel Atom x86
This improved things considerably, but the emulator was still feeling a bit sluggish. The final step was selecting Use Host GPU in Android Virtual Device Manager (AVD).
After these changes, Android Emulator was launching in 5-10 seconds and running without any noticeable lag.
Be aware that these features are hardware dependent (CPU/GPU) and may not work on some systems.
Try Genymotion for Android Studio. Blazing fast! Just needs one time installation. No more AVD pain.
To add further information to this.
I have recently upgraded my Ubuntu installation to Ubuntu 10.04 LTS (Lucid Lynx) which in turn updated my Java version to:
Java version "1.6.0_20"
Java(TM) SE Runtime Environment (build 1.6.0_20-b02)
Java HotSpot(TM) 64-Bit Server VM (build 16.3-b01, mixed mode)
And now the emulator (although takes a while to start) seems to be running faster than previously.
It might be worth people upgrading their JVM.
A new option is the Visual Studio Emulator for Android--it's fast, Hyper-V, x86, and free to download even without VS.
Here's what I noticed nobody mentioned it at all.
Assign all available processors to the emulator
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. I 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.
After developing for a while, my emulator became brutally slow. I chose wipe user data, and it was much much better. I am guessing that it takes time to load up each APK file you've deployed.
Well, since somebody suggested Android x86 as an alternative testing emulator, I'll also present my favorite. This might not be an alternative for everyone, but for me it's perfect!
Use the Bluestacks Player. It runs Android 2.3.4 and is very fluid and fast. Sometimes it is even faster than a normal device. The only downside is, that you can just test apps on the API Level 10 and just on one screen size, but it's perfect just for testing if it's working or not. Just connect the Player with the adb by running
adb connect 127.0.0.1
After compiling, it installs instantly. It is very impressive, considering I have rather an average computer hardware (dual core with 4 GB of RAM).
I had intermittent slow emulator (SDK v8.0) load times, up to three minutes on Intel Core i7 920 2.67 GHz CPU running on Xubuntu 10.04 VirtualBox 3.2.12 guest with Eclipse (3.6.1) loaded. I changed the VirtualBox guest memory from 1024 MB to 2048 MB and from that point on, I never experienced the slowness again (load times consistent at 33 seconds, CPU load consistent at 20%). Both Eclipse and the emulator are memory hogs.
Android emulator is dead slow. It takes 800MB memory while running.
If you are on Windows, You can use Microsoft Android Emulator. It is superb, provides you functionalities more than Android Studio Emulator. And most important it is fast ( consumes 13MB only).
It comes with Visual Studio 2015 Technical Preview. I am using it and happy with it. I downloaded and installed entire VS pack, I need to look how we can install VS Emulator only.
Visual Studio Emulator for Android
EDIT:
Try https://www.visualstudio.com/vs/msft-android-emulator/
I noticed that the my emulator (Eclipse plugin) was significantly slowed by my Nvidia graphics card anti-aliasing settings. Removing 2x anti aliasing from the graphics menu and changing it to application controlled made it more responsive. It is still slow, but better than it used to be.
To reduce your emulator start-up time you need to check the "Disable Boot Animation" before starting the emulator. Refer to the Android documentation.
If in case you don't know, you do not need to close the emulator every-time you run/debug your app. If you click run/debug when it's already open, your APK file will get uploaded to the emulator and start pretty much immediately. Emulator takes annoyingly long time only when it started the first time.
Here are some tips to speed up the Android emulator: How to speed up the Android Emulator by up to 400%.
Good way to speed up Android Emulator and app testing is Install or Upgrade your Android Studio to Android Studio 2.0 version and then go to app open Settings/Preferences, the go to Build, Execution, Deployment → Instant Run. Click on Enable Instant Run. And After That This will ensure you have the correct gradle plugin for your project to work with Instant Run.
And Instant run will look like this
However Android Studio is right now in Preview you can try it now.
The Android emulator is a bit sluggish. For some devices, like the Motorola Droid and the Nexus One, the app runs faster in the actual device than the emulator. This is a problem when testing games and visual effects.
How do you make the emulator run as fast as possible? I've been toying with its parameters but haven't found a configuration that shows a noticeable improvement yet.
Official web page
~50% faster
Windows:
Install "Intel x86 Emulator Accelerator (HAXM)" => SDK-Manager/Extras
Install "Intel x86 Atom System Images" => SDK-Manager/Android 2.3.3
Go to the Android SDK root folder and navigate to extras\intel\Hardware_Accelerated_Execution_Manager. Execute file IntelHaxm.exe to install. (in Android Studio you can navigate to: Settings -> Android SDK -> SDK Tools -> Intel x86 Emulator Accelerator (HAXM installer))
Create AVD with "Intel atom x86" CPU/ABI
Run emulator and check in console that HAXM running (open a Command Prompt window and execute the command: sc query intelhaxm)
Also don't forget install this one
P.S. during AVD creation add emulation memory: Hardware/New/Device ram size/set up value 512 or more
Linux:
Install KVM: open GOOGLE, write "kvm installation "
Create AVD with "Intel atom x86" CPU/ABI
Run from command line: emulator -avd avd_name -qemu -m 512 -enable-kvm
Or run from Eclipse: Run/Run Configurations/Tab "Target" - > check Intel x86 AVD and in "Additional Emulator Command Line Options" window add: -qemu -m 512 -enable-kvm (click Run)
P.S. For Fedora, for Ubuntu
OS-X:
In Android SDK Manager, install Intel x86 Atom System Image
In Android SDK Manager, install Intel x86 Emulator Accelerator (HAXM)
In finder, go to the install location of the Intel Emulator Accelerator and install IntelHAXM (open the dmg and run the installation). You can find the location by placing your mouse over the Emulator Accelerator entry in the SDK Manager.
Create or update an AVD and specify Intel Atom x86 as the CPU.
P.S: Check this tool, very convenient even trial
UPDATE: Now that an Intel x86 image is available, the best answer is by zest above.
As CommonsWare has correctly pointed out, the emulator is slow because it emulates an ARM CPU, which requires translation to Intel opcodes. This virtualization chews up CPU.
To make the emulator faster, you have to give it more CPU. Start with a fast CPU or upgrade if you can.
Then, give the emulator more of the CPU you have:
Disable Hyperthreading - Since the emulator doesn't appear to utilize more than one core, hyperthreading actually reduces the amount of overall CPU time the emulator will get. Disabling HT will slow down apps that take advantage of multiple CPUs. Hyperthreading must be disabled in your BIOS.
Make the emulator run on a CPU other than CPU 0 - This has a much smaller impact than turning off HT, but it helps some. On Windows, you can specify which CPU a process will run on. Many apps will chew up CPU 0, and by default the emulator runs on CPU 0. I change the emulator to run on the last one. Note that on OS X you cannot set affinity (see: https://superuser.com/questions/149312/how-to-set-processor-affinity-on-a-mac).
I'm seeing somewhere around a 50% improvement with these two changes in place.
To set processor affinity on Windows 7:
Open Task Manager
Click View All Processes (to run as administrator, otherwise you can't set processor affinity)
Right click on emulator.exe and choose Set Affinity...
On the Set Affinity dialog, select just the last CPU
Note: When you change affinity in this way, it's only changed for the lifetime of the process. Next start, you have to do it again.
I would like to suggest giving Genymotion a spin. It runs in Oracle's VirtualBox, and will legitimately hit 60 fps on a moderate system.
Here's a screencap from one of my workshops, running on a low-end 2012 model MacBook Air:
If you can't read the text, it's a Nexus 7 emulator running at 56.6 fps. The additional (big!) bonus is that Google Play and Google Play Services come packaged with the virtual machines.
(The source of the demoed animation can be found here.)
Enable GPU Hardware Acceleration (in addition to Intel's HAXM), if you are using API 15 v3 or newer and SDK Tools v17+. Graphics acceleration for the emulator takes advantage of your development computer's graphics hardware, specifically its graphics processing unit (GPU), to make screen drawing faster. This gives a noticeable boost in speed.
To enable graphics acceleration enabled by default on your emulator: when creating the AVD, in the Hardware section, click New, select GPU emulation and set the value to Yes.
To enable acceleration only at runtime: use the -gpu flag while starting the emulator like this:
emulator -avd <avd_name> -gpu on
Source: Google's Using the Emulator tutorial.
Edit Although using the Intel images gets some performance gains, the performance gained by using Genymotion is much greater. See Paul Lammertsma's answer.
Previous Answer
With ADT rev 17 the emulator supports running x86 system images in virtualization mode on Windows and Mac OS X. This has a noticeable impact on performance.
ADT rev 17 notes:
http://android-developers.blogspot.jp/2012/03/updated-sdk-tools-and-adt-revision-17.html
Configuring Virtual Machine Acceleration:
http://developer.android.com/guide/developing/devices/emulator.html#accel-vm
I recently switched from a core 2 # 2.5 with 3gb of ram to an i7 # 1.73 with 8gb ram (both systems ran Ubuntu 10.10) and the emulator runs at least twice as fast now. Throwing more hardware at it certainly does help.
Just wanted to say that after I installed the Intel HAXM accelerator and use the Intel Atom image the emulator seems to run 50 times faster. The difference is amazing, check it out!
http://www.developer.com/ws/android/development-tools/haxm-speeds-up-the-android-emulator.html
I noticed that the emulator defaults to only Core 0, where most Windows applications will default to "any" core. Also, if you put it on another core (like the last core), it may make the emulator go crazy. If you can, you can try putting your heavy-CPU usage applications on the other CPU cores for a boost in speed.
Hardware-wise, get the fastest CPU you can get that works for single-core applications. More than 2 cores might not experience a huge difference in terms of emulator performance.
Eclipse + the Android emulator together eat up a ton of RAM. I would recommend 3 gigs of RAM at least because I used a system with 2 gigs of RAM, and it slowed down because the system ran out of RAM and started to use the page file.
I feel that the best CPUs for it will probably have a high clock (only use clock as a measure for CPUs in the same series btw), handle non-SIMD operations well, and have a turbo boost mechanism. There aren't many Java-based benchmarks, but overall look for application benchmarks like compression and office. Don't look at gaming or media since those are affected greatly by SIMD. If you find a Java one, even better.
On this year google I/O (2011), Google demonstrated a faster emulator. The problem is not so much on the byte code between ARM and x86 but the software rendering performed by QEMU. They bypass the rendering of QEMU and send the rendering directly to an X server I believe. They showed a car game with really good performace and fps.
I wonder when that will be available for developers...
Google recently announced a new emulator for Android. It's a much faster and better than the old one. You can find more info about it here.
choose a low resolution emulator (eg: Nexus S) if you don't have a good graphic card (like me)
I think it is because clr virtual machine uses cpu directly without code opcode translation.
It may be optimization for clr application or may be windows mobile/window phone 7 started on INTEL proccessor.
Android platform based on linux and theoretically you can start android on virtual machine in i686 environment. In this case virtual machines such as vmware could execute some opcodes direcly. But this option will be allowed only if you write on the Java. Because the Java interpret their byte-code or precompile it before execution.
see:
http://www.taranfx.com/how-to-run-google-android-in-virtualbox-vmware-on-netbooks
Thank you #zest! Worked like a charm. Some things of note: Need to apply Intel's hotfix for the HAXM to deal with kernel panic issue: http://software.intel.com/en-us/android/articles/intel-hardware-accelerated-execution-manager
Also, note, if you have more than one abi, you need to uninstall one due to a bug in the latest version of the Android API (r19): https://code.google.com/p/android/issues/detail?id=66740 (remove armeabi-v7a in this case, since you want the x86 abi). Other than the 45-minutes it took me to resolve these, it was an very rewarding exercise in terms of the increased performance of the emulator.
You could also try the Visual Studio Android Emulator, which can also be installed as a standalone emulator (you don't need Visual Studio). Please note, that it can be installed only on Windows Pro or higher systems.
Use Genymotion instead of emulator. Genymotion has better performance
https://www.genymotion.com
Enabling this option worked for me.
AVD Manager -> Select device and click Edit-> Enable the option 'Use Host GPU'
I've been using the Intel(86) CPU/ABI. I created another emulator using the ARM(armeabi-v7a) and i found quite an improvement with the speed. I'm using platform 4.1.2 API level 16
Update your current Android Studio to Android Studio 2.0 And also update system images.
Android Studio 2.0 emulator runs ~3x faster than Android’s previous emulator, and with ADB enhancements you can now push apps and data 10x faster to the emulator than to a physical device. Like a physical device, the official Android emulator also includes Google Play Services built-in, so you can test out more API functionality. Finally, the new emulator has rich new features to manage calls, battery, network, GPS, and more.
Well question is from 2011 and I am answering in 2022 the best answer in my experience is to start emulator from command in that way the emulator starts a dedicated process and not a sub process of android studio. If the process is independent then it will be able to use the GPU properly and can utilize all resources unlike starting emulator from device manager.
You can create AVD from device manager and start is from the avd folder below is the way to start the emulator independently.
How to open emulator command line