Class AbstractCentralProcessor

    • Field Detail

      • LOG

        private static final org.slf4j.Logger LOG
      • maxFreq

        private final java.util.function.Supplier<java.lang.Long> maxFreq
      • currentFreq

        private final java.util.function.Supplier<long[]> currentFreq
      • contextSwitches

        private final java.util.function.Supplier<java.lang.Long> contextSwitches
      • interrupts

        private final java.util.function.Supplier<java.lang.Long> interrupts
      • systemCpuLoadTicks

        private final java.util.function.Supplier<long[]> systemCpuLoadTicks
      • processorCpuLoadTicks

        private final java.util.function.Supplier<long[][]> processorCpuLoadTicks
      • physicalPackageCount

        private final int physicalPackageCount
      • physicalProcessorCount

        private final int physicalProcessorCount
      • logicalProcessorCount

        private final int logicalProcessorCount
      • featureFlags

        private final java.util.List<java.lang.String> featureFlags
    • Constructor Detail

      • AbstractCentralProcessor

        protected AbstractCentralProcessor()
        Create a Processor
    • Method Detail

      • queryProcessorId

        protected abstract CentralProcessor.ProcessorIdentifier queryProcessorId()
        Updates logical and physical processor counts and arrays
        Returns:
        An array of initialized Logical Processors
      • 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.
      • 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 java.util.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.
      • getProcessorCaches

        public java.util.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 java.util.List<java.lang.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
      • 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 java.lang.String createProcessorID​(java.lang.String stepping,
                                                            java.lang.String model,
                                                            java.lang.String family,
                                                            java.lang.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
      • orderedProcCaches

        public static java.util.List<CentralProcessor.ProcessorCache> orderedProcCaches​(java.util.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 java.lang.String toString()
        Overrides:
        toString in class java.lang.Object