Package oshi.hardware.common

Class AbstractCentralProcessor

java.lang.Object
oshi.hardware.common.AbstractCentralProcessor
All Implemented Interfaces:
CentralProcessor
Direct Known Subclasses:
OpenBsdCentralProcessor
@ThreadSafe public abstract class AbstractCentralProcessor extends Object implements CentralProcessor
A CPU.

  • Constructor Details

    • AbstractCentralProcessor

      protected AbstractCentralProcessor()
      Create a Processor

  • Method Details

    • initProcessorCounts

      protected abstract Quartet<List<CentralProcessor.LogicalProcessor>,List<CentralProcessor.PhysicalProcessor>,List<CentralProcessor.ProcessorCache>,List<String>> initProcessorCounts()
      Initializes logical and physical processor lists and feature flags.
      Returns:
      Lists of initialized Logical Processors, Physical Processors, Processor Caches, and Feature Flags.

    • queryProcessorId

      protected abstract CentralProcessor.ProcessorIdentifier queryProcessorId()
      Updates logical and physical processor counts and arrays
      Returns:
      An array of initialized Logical Processors

    • getProcessorIdentifier

      public CentralProcessor.ProcessorIdentifier getProcessorIdentifier()
      Description copied from interface: CentralProcessor
      The CPU's identifier strings ,including name, vendor, stepping, model, and family information (also called the signature of a CPU).

      The Processor Identifier is primarily associated with Intel-based chips. Attempts are made to provide comparable values for other chip manufacturers.

      Specified by:
      getProcessorIdentifier in interface CentralProcessor
      Returns:
      a CentralProcessor.ProcessorIdentifier object encapsulating CPU identifier information.

    • getMaxFreq

      public long getMaxFreq()
      Description copied from interface: CentralProcessor
      Maximum frequeny (in Hz), of the logical processors on this CPU.
      Specified by:
      getMaxFreq in interface CentralProcessor
      Returns:
      The max frequency or -1 if unknown.

    • queryMaxFreq

      protected long queryMaxFreq()
      Get processor max frequency.
      Returns:
      The max frequency.

    • getCurrentFreq

      public long[] getCurrentFreq()
      Description copied from interface: CentralProcessor
      Attempts to return the current frequency (in Hz), of the logical processors on this CPU.

      May not be implemented on all Operating Systems.

      On Windows, returns an estimate based on the percent of maximum frequency. On Windows systems with more than 64 logical processors, may only return frequencies for the current processor group in the first portion of the array.

      Specified by:
      getCurrentFreq in interface CentralProcessor
      Returns:
      An array of processor frequencies for each logical processor on the system. Use the CentralProcessor.getLogicalProcessors() to correlate these frequencies with physical packages and processors.

    • queryCurrentFreq

      protected abstract long[] queryCurrentFreq()
      Get processor current frequency.
      Returns:
      The current frequency.

    • getContextSwitches

      public long getContextSwitches()
      Description copied from interface: CentralProcessor
      Get the number of system-wide context switches which have occurred.

      Not available system-wide on macOS. Process- and Thread-level context switches are available from OSProcess.getContextSwitches() and OSThread.getContextSwitches().

      Specified by:
      getContextSwitches in interface CentralProcessor
      Returns:
      The number of context switches, if this information is available; 0 otherwise.

    • queryContextSwitches

      protected abstract long queryContextSwitches()
      Get number of context switches
      Returns:
      The context switches

    • getInterrupts

      public long getInterrupts()
      Description copied from interface: CentralProcessor
      Get the number of system-wide interrupts which have occurred.

      Not available system-wide on macOS.

      Specified by:
      getInterrupts in interface CentralProcessor
      Returns:
      The number of interrupts, if this information is available; 0 otherwise.

    • queryInterrupts

      protected abstract long queryInterrupts()
      Get number of interrupts
      Returns:
      The interrupts

    • getLogicalProcessors

      public List<CentralProcessor.LogicalProcessor> getLogicalProcessors()
      Description copied from interface: CentralProcessor
      Returns an UnmodifiableList of the CPU's logical processors. The list will be sorted in order of increasing NUMA node number, and then processor number. This order is (usually) consistent with other methods providing per-processor results.

      On some operating systems with variable numbers of logical processors, the size of this array could change and may not align with other per-processor methods.

      Specified by:
      getLogicalProcessors in interface CentralProcessor
      Returns:
      An UnmodifiabeList of logical processors.

    • getPhysicalProcessors

      public List<CentralProcessor.PhysicalProcessor> getPhysicalProcessors()
      Description copied from interface: CentralProcessor
      Returns an UnmodifiableList of the CPU's physical processors. The list will be sorted in order of increasing core ID.
      Specified by:
      getPhysicalProcessors in interface CentralProcessor
      Returns:
      An UnmodifiabeList of physical processors.

    • getProcessorCaches

      public List<CentralProcessor.ProcessorCache> getProcessorCaches()
      Description copied from interface: CentralProcessor
      Makes a best-effort attempt to identify the CPU's processor caches. For hybrid processors, both performance and efficiency core caches are shown. Only one instance of per-core caches is shown.

      Values are unreliable in virtual machines and rely in information made available by the VM or hypervisor. Callers should conduct sanity checking of the returned objects. Not all values are available on all operating systems or architectures.

      Not available on Solaris.

      Specified by:
      getProcessorCaches in interface CentralProcessor
      Returns:
      An UnmodifiabeList of processor caches.

    • getFeatureFlags

      public List<String> getFeatureFlags()
      Description copied from interface: CentralProcessor
      Returns a list of platform-specific strings which identify CPU Feature Flags. This string requires user parsing to obtain meaningful information.
      Specified by:
      getFeatureFlags in interface CentralProcessor
      Returns:
      On Windows, returns a list of values for which the IsProcessorFeaturePresent() function evaluates to true.

      On macOS x86, returns relevant sysctl.machdep.feature values. On Apple Silicon, returns relevant sysctl hw.optional.arm.FEAT values.

      On Linux, returns the flags and/or features fields from /proc/cpuinfo.

      On OpenBSD, FreeBSD, and Solaris, returns dmesg output containing the word Feature.

      For unimplemented operating systems, returns an empty list.

    • getSystemCpuLoadTicks

      public long[] getSystemCpuLoadTicks()
      Description copied from interface: CentralProcessor
      Get System-wide CPU Load tick counters. Returns an array with eight elements representing milliseconds spent in User (0), Nice (1), System (2), Idle (3), IOwait (4), Hardware interrupts (IRQ) (5), Software interrupts/DPC (SoftIRQ) (6), or Steal (7) states. Use CentralProcessor.TickType.getIndex() to retrieve the appropriate index. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated.

      On some operating systems with variable numbers of logical processors, the size of this array could change and may not align with other per-processor methods.

      Note that while tick counters are in units of milliseconds, they may advance in larger increments along with (platform dependent) clock ticks. For example, by default Windows clock ticks are 1/64 of a second (about 15 or 16 milliseconds) and Linux ticks are distribution and configuration dependent but usually 1/100 of a second (10 milliseconds).

      Nice and IOWait information is not available on Windows, and IOwait and IRQ information is not available on macOS, so these ticks will always be zero.

      To calculate overall Idle time using this method, include both Idle and IOWait ticks. Similarly, IRQ, SoftIRQ, and Steal ticks should be added to the System value to get the total. System ticks also include time executing other virtual hosts (steal).

      Specified by:
      getSystemCpuLoadTicks in interface CentralProcessor
      Returns:
      An array of 8 long values representing time spent in User, Nice, System, Idle, IOwait, IRQ, SoftIRQ, and Steal states.

    • querySystemCpuLoadTicks

      protected abstract long[] querySystemCpuLoadTicks()
      Get the system CPU load ticks
      Returns:
      The system CPU load ticks

    • getProcessorCpuLoadTicks

      public long[][] getProcessorCpuLoadTicks()
      Description copied from interface: CentralProcessor
      Get Processor CPU Load tick counters. Returns a two dimensional array, with CentralProcessor.getLogicalProcessorCount() arrays, each containing seven elements representing milliseconds spent in User (0), Nice (1), System (2), Idle (3), IOwait (4), Hardware interrupts (IRQ) (5), Software interrupts/DPC (SoftIRQ) (6), or Steal (7) states. Use CentralProcessor.TickType.getIndex() to retrieve the appropriate index. By measuring the difference between ticks across a time interval, CPU load over that interval may be calculated.

      Note that while tick counters are in units of milliseconds, they may advance in larger increments along with (platform dependent) clock ticks. For example, by default Windows clock ticks are 1/64 of a second (about 15 or 16 milliseconds) and Linux ticks are distribution and configuration dependent but usually 1/100 of a second (10 milliseconds).

      Nice and IOwait per processor information is not available on Windows, and IOwait and IRQ information is not available on macOS, so these ticks will always be zero.

      To calculate overall Idle time using this method, include both Idle and IOWait ticks. Similarly, IRQ, SoftIRQ and Steal ticks should be added to the System value to get the total. System ticks also include time executing other virtual hosts (steal).

      Specified by:
      getProcessorCpuLoadTicks in interface CentralProcessor
      Returns:
      A 2D array of logicalProcessorCount x 7 long values representing time spent in User, Nice, System, Idle, IOwait, IRQ, SoftIRQ, and Steal states.

    • queryProcessorCpuLoadTicks

      protected abstract long[][] queryProcessorCpuLoadTicks()
      Get the processor CPU load ticks
      Returns:
      The processor CPU load ticks

    • getSystemCpuLoadBetweenTicks

      public double getSystemCpuLoadBetweenTicks(long[] oldTicks)
      Description copied from interface: CentralProcessor
      Returns the "recent cpu usage" for the whole system by counting ticks from CentralProcessor.getSystemCpuLoadTicks() between the user-provided value from a previous call.

      On some operating systems with variable numbers of logical processors, the size of the array returned from a previous call to CentralProcessor.getSystemCpuLoadTicks() could change and will throw an IllegalArgumentException. Calling code on these operating systems should handle this exception.

      Specified by:
      getSystemCpuLoadBetweenTicks in interface CentralProcessor
      Parameters:
      oldTicks - A tick array from a previous call to CentralProcessor.getSystemCpuLoadTicks()
      Returns:
      CPU load between 0 and 1 (100%)

    • getProcessorCpuLoadBetweenTicks

      public double[] getProcessorCpuLoadBetweenTicks(long[][] oldTicks)
      Description copied from interface: CentralProcessor
      Returns the "recent cpu usage" for all logical processors by counting ticks from CentralProcessor.getProcessorCpuLoadTicks() between the user-provided value from a previous call.

      On some operating systems with variable numbers of logical processors, the size of the array returned from the two calls could change and will throw an IllegalArgumentException. Calling code on these operating systems should handle this exception.

      Specified by:
      getProcessorCpuLoadBetweenTicks in interface CentralProcessor
      Parameters:
      oldTicks - A tick array from a previous call to CentralProcessor.getProcessorCpuLoadTicks()
      Returns:
      array of CPU load between 0 and 1 (100%) for each logical processor

    • getLogicalProcessorCount

      public int getLogicalProcessorCount()
      Description copied from interface: CentralProcessor
      Get the number of logical CPUs available for processing. This value may be higher than physical CPUs if hyperthreading is enabled.

      On some operating systems with variable numbers of logical processors, may return a max value.

      Specified by:
      getLogicalProcessorCount in interface CentralProcessor
      Returns:
      The number of logical CPUs available.

    • getPhysicalProcessorCount

      public int getPhysicalProcessorCount()
      Description copied from interface: CentralProcessor
      Get the number of physical CPUs/cores available for processing.

      On some operating systems with variable numbers of physical processors available to the OS, may return a max value.

      Specified by:
      getPhysicalProcessorCount in interface CentralProcessor
      Returns:
      The number of physical CPUs available.

    • getPhysicalPackageCount

      public int getPhysicalPackageCount()
      Description copied from interface: CentralProcessor
      Get the number of packages/sockets in the system. A single package may contain multiple cores.
      Specified by:
      getPhysicalPackageCount in interface CentralProcessor
      Returns:
      The number of physical packages available.

    • createProcessorID

      protected static String createProcessorID(String stepping, String model, String family, String[] flags)
      Creates a Processor ID by encoding the stepping, model, family, and feature flags.
      Parameters:
      stepping - The CPU stepping
      model - The CPU model
      family - The CPU family
      flags - A space-delimited list of CPU feature flags
      Returns:
      The Processor ID string

    • createProcListFromDmesg

      protected List<CentralProcessor.PhysicalProcessor> createProcListFromDmesg(List<CentralProcessor.LogicalProcessor> logProcs, Map<Integer,String> dmesg)

    • orderedProcCaches

      public static List<CentralProcessor.ProcessorCache> orderedProcCaches(Set<CentralProcessor.ProcessorCache> caches)
      Filters a set of processor caches to an ordered list
      Parameters:
      caches - A set of unique caches.
      Returns:
      A list sorted by level (desc), type, and size (desc)

    • toString

      public String toString()
      Overrides:
      toString in class Object