How can you detect a dual-core cpu on an Android device from code?

Question

I\'ve run into a problem that appears to affect only dual-core Android devices running Android 2.3 (Gingerbread or greater. I\'d like to give a di

Answer 1

This is pretty simple.

int numberOfProcessors = Runtime.getRuntime().availableProcessors();

Typically it would return 1 or 2. 2 would be in a dual-core CPU.

Answer 2

I use a combination of both available solutions:

fun getCPUCoreNum(): Int {
  val pattern = Pattern.compile("cpu[0-9]+")
  return Math.max(
    File("/sys/devices/system/cpu/")
      .walk()
      .maxDepth(1)
      .count { pattern.matcher(it.name).matches() },
    Runtime.getRuntime().availableProcessors()
  )
}

Answer 3

Here's my solution, in Kotlin, based on this one:

        /**
         * return the number of cores of the device.
         * based on : http://stackoverflow.com/a/10377934/878126
         */
        private var coresCount: Int = 0
            get() {
                if (field > 0)
                    return field
                class CpuFilter : FileFilter {
                    override fun accept(pathname: File): Boolean {
                        return Pattern.matches("cpu[0-9]+", pathname.name)
                    }
                }
                try {
                    val dir = File("/sys/devices/system/cpu/")
                    val files = dir.listFiles(CpuFilter())
                    if (files != null) {
                        field = files.size
                        return field
                    }
                } catch (ignored: Exception) {
                }
                field = max(1, Runtime.getRuntime().availableProcessors())
                return field
            }

Answer 4

If you're working with a native application, you should try this:

#include <unistd.h>
int GetNumberOfProcessor()
{
    return sysconf(_SC_NPROCESSORS_CONF);
}

It work on my i9100 (which availableProcessors() returned 1).

Answer 5

Unfortunately for most Android devices, the availableProcessors() method doesn't work correctly. Even /proc/stat doesn't always show the correct number of CPUs.

The only reliable method I've found to determine the number of CPUs is to enumerate the list of virtual CPUs at /sys/devices/system/cpu/ as described in this forum post. The code:

/**
 * Gets the number of cores available in this device, across all processors.
 * Requires: Ability to peruse the filesystem at "/sys/devices/system/cpu"
 * @return The number of cores, or 1 if failed to get result
 */
private int getNumCores() {
    //Private Class to display only CPU devices in the directory listing
    class CpuFilter implements FileFilter {
        @Override
        public boolean accept(File pathname) {
            //Check if filename is "cpu", followed by one or more digits
            if(Pattern.matches("cpu[0-9]+", pathname.getName())) {
                return true;
            }
            return false;
        }      
    }

    try {
        //Get directory containing CPU info
        File dir = new File("/sys/devices/system/cpu/");
        //Filter to only list the devices we care about
        File[] files = dir.listFiles(new CpuFilter());
        //Return the number of cores (virtual CPU devices)
        return files.length;
    } catch(Exception e) {
        //Default to return 1 core
        return 1;
    }
}

This Java code should work in any Android application, even without root.

Answer 6

You can try using Runtime.availableProcessors() as is suggested in this answer

Is there any API that tells whether an Android device is dual-core or not?

---edit---

A more detailed description is given at Oracle's site

availableProcessors

public int availableProcessors()

Returns the number of processors available to the Java virtual machine.

This value may change during a particular invocation of the virtual machine. Applications that are sensitive to the number of available processors should therefore occasionally poll this property and adjust their resource usage appropriately.

Returns:

the maximum number of processors available to the virtual machine; never smaller than one

Since:

  1.4