Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Assign Logical Processors to NUMA nodes #794

Merged
merged 3 commits into from
Feb 4, 2019
Merged

Assign Logical Processors to NUMA nodes #794

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
ef66d3f
Windows NumaNodes
dbwiddis Feb 3, 2019
be059d0
Linux numa nodes
dbwiddis Feb 3, 2019
3ffb944
Solaris NUMA nodes
dbwiddis Feb 3, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Next Next commit
Windows NumaNodes
  • Loading branch information
@dbwiddis
dbwiddis committed Feb 3, 2019
commit ef66d3fd9993e892b9fa89d17281113bdd7dd74c
2 changes: 2 additions & 0 deletions oshi-core/src/main/java/oshi/data/windows/PerfCounterQuery.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -62,7 +62,9 @@ public class PerfCounterQuery<T extends Enum<T>> {
* Multiple classes use these constants
*/
public static final String TOTAL_INSTANCE = "_Total";
public static final String TOTAL_INSTANCES = "*_Total";
public static final String NOT_TOTAL_INSTANCE = "^" + TOTAL_INSTANCE;
public static final String NOT_TOTAL_INSTANCES = "^" + TOTAL_INSTANCES;

/**
* Construct a new object to hold performance counter data source and
Expand Down
15 changes: 7 additions & 8 deletions oshi-core/src/main/java/oshi/hardware/CentralProcessor.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -352,6 +352,13 @@ public int getIndex() {
* topology.
*/
class LogicalProcessor implements Serializable {
private static final long serialVersionUID = 1L;

private int processorNumber;
private int physicalProcessorNumber;
private int physicalPackageNumber;
private int numaNode;
private int processorGroup;

/**
* @param processorNumber
Expand Down Expand Up @@ -401,14 +408,6 @@ public LogicalProcessor(int processorNumber, int physicalProcessorNumber, int ph
this.processorGroup = processorGroup;
}

private static final long serialVersionUID = 1L;

private int processorNumber;
private int physicalProcessorNumber;
private int physicalPackageNumber;
private int numaNode;
private int processorGroup;

/**
* The Logical Processor number as seen by the Operating System. Used
* for assigning process affinity and reporting CPU usage and other
Expand Down
151 changes: 97 additions & 54 deletions oshi-core/src/main/java/oshi/hardware/platform/windows/WindowsCentralProcessor.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

Expand All @@ -36,6 +37,7 @@
import com.sun.jna.platform.win32.Advapi32Util;
import com.sun.jna.platform.win32.WinBase;
import com.sun.jna.platform.win32.WinBase.SYSTEM_INFO;
import com.sun.jna.platform.win32.WinNT.LOGICAL_PROCESSOR_RELATIONSHIP;
import com.sun.jna.platform.win32.WinNT.SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
import com.sun.jna.platform.win32.WinReg;
import com.sun.jna.platform.win32.COM.WbemcliUtil.WmiQuery;
Expand All @@ -53,6 +55,8 @@
import oshi.jna.platform.windows.VersionHelpers;
import oshi.jna.platform.windows.WinNT;
import oshi.jna.platform.windows.WinNT.GROUP_AFFINITY;
import oshi.jna.platform.windows.WinNT.NUMA_NODE_RELATIONSHIP;
import oshi.jna.platform.windows.WinNT.PROCESSOR_RELATIONSHIP;
import oshi.jna.platform.windows.WinNT.SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;
import oshi.util.ParseUtil;
import oshi.util.platform.windows.WmiQueryHandler;
Expand All @@ -72,6 +76,8 @@ public class WindowsCentralProcessor extends AbstractCentralProcessor {

private static final String PROCESSOR = "Processor";

private Map<String, Integer> numaNodeProcToLogicalProcMap;

enum ProcessorProperty {
PROCESSORID;
}
Expand All @@ -81,7 +87,7 @@ enum ProcessorProperty {
*/
enum ProcessorTickCountProperty implements PdhCounterWildcardProperty {
// First element defines WMI instance name field and PDH instance filter
NAME(PerfCounterQuery.NOT_TOTAL_INSTANCE),
NAME(PerfCounterQuery.NOT_TOTAL_INSTANCES),
// Remaining elements define counters
PERCENTDPCTIME("% DPC Time"), //
PERCENTINTERRUPTTIME("% Interrupt Time"), //
Expand All @@ -104,9 +110,18 @@ public String getCounter() {
}
}

private final transient PerfCounterWildcardQuery<ProcessorTickCountProperty> processorTickPerfCounters = new PerfCounterWildcardQuery<>(
ProcessorTickCountProperty.class, PROCESSOR, "Win32_PerfRawData_PerfOS_Processor WHERE NOT Name=\"_Total\"",
"Processor Tick Count");
private final transient PerfCounterWildcardQuery<ProcessorTickCountProperty> processorTickPerfCounters =
VersionHelpers.IsWindows7OrGreater() ?
new PerfCounterWildcardQuery<>(
ProcessorTickCountProperty.class, PROCESSOR,
// NAME field includes NUMA nodes
"Win32_PerfRawData_Counters_ProcessorInformation WHERE NOT Name LIKE\"%_Total\"",
"Processor Tick Count")
: new PerfCounterWildcardQuery<>(
ProcessorTickCountProperty.class, PROCESSOR,
// Older systems just have processor # in name
"Win32_PerfRawData_PerfOS_Processor WHERE NOT Name=\"_Total\"",
"Processor Tick Count");

enum SystemTickCountProperty implements PdhCounterProperty {
PERCENTDPCTIME(PerfCounterQuery.TOTAL_INSTANCE, "% DPC Time"), //
Expand Down Expand Up @@ -212,6 +227,7 @@ public String getCounter() {
*/
public WindowsCentralProcessor() {
super();

// Initialize class variables
initVars();

Expand Down Expand Up @@ -264,49 +280,97 @@ protected LogicalProcessor[] initProcessorCounts() {
private LogicalProcessor[] getLogicalProcessorInformationEx() {
// Collect a list of logical processors on each physical core and
// package. These will be 64-bit bitmasks.
List<GROUP_AFFINITY[]> packageMaskList = new ArrayList<>();
List<GROUP_AFFINITY> coreMaskList = new ArrayList<>();
SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX[] processors = Kernel32Util
SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX[] procInfo = Kernel32Util
.getLogicalProcessorInformationEx(WinNT.LOGICAL_PROCESSOR_RELATIONSHIP.RelationAll);
for (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX proc : processors) {
if (proc.relationship == WinNT.LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorPackage) {
// Package may be on multiple processor groups
packageMaskList.add(((WinNT.PROCESSOR_RELATIONSHIP)proc).groupMask);
} else if (proc.relationship == WinNT.LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore) {
// Exactly one element for the ProcessorCore relationship
coreMaskList.add(((WinNT.PROCESSOR_RELATIONSHIP)proc).groupMask[0]);
List<GROUP_AFFINITY[]> packages = new ArrayList<>();
List<NUMA_NODE_RELATIONSHIP> numaNodes = new ArrayList<>();
List<GROUP_AFFINITY> cores = new ArrayList<>();

for (int i = 0; i < procInfo.length; i++) {
switch (procInfo[i].relationship) {
case LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorPackage:
packages.add(((PROCESSOR_RELATIONSHIP) procInfo[i]).groupMask);
break;
case LOGICAL_PROCESSOR_RELATIONSHIP.RelationNumaNode:
numaNodes.add((NUMA_NODE_RELATIONSHIP) procInfo[i]);
break;
case LOGICAL_PROCESSOR_RELATIONSHIP.RelationProcessorCore:
cores.add(((PROCESSOR_RELATIONSHIP) procInfo[i]).groupMask[0]);
break;
default:
// Ignore Group and Cache info
break;
}
}
this.physicalProcessorCount = coreMaskList.size();
this.physicalPackageCount = packageMaskList.size();
// Sort the list so core and package numbers
// increment as expected
coreMaskList.sort(Comparator.comparing(c -> c.group * 64L + c.mask.longValue()));
packageMaskList.sort(Comparator.comparing(p -> p[0].group * 64L + p[0].mask.longValue()));

// Assign logical processors to cores and packages
// Windows doesn't define core and package numbers, so we sort the lists
// so core and package numbers increment consistently with processor
// numbers/bitmasks, ordered in groups
cores.sort(Comparator.comparing(c -> c.group * 64L + c.mask.longValue()));
packages.sort(Comparator.comparing(p -> p[0].group * 64L + p[0].mask.longValue()));

// Iterate Logical Processors and use bitmasks to match packages, cores,
// and NUMA nodes
List<LogicalProcessor> logProcs = new ArrayList<>();
for (int core = 0; core < this.physicalProcessorCount; core++) {
GROUP_AFFINITY coreMask = coreMaskList.get(core);
for (GROUP_AFFINITY coreMask : cores) {
int group = coreMask.group;
long mask = coreMask.mask.longValue();
// Lowest and Highest set bits, indexing from 0
// Iterate mask for logical processor numbers
int lowBit = Long.numberOfTrailingZeros(mask);
int hiBit = 63 - Long.numberOfLeadingZeros(mask);
// Create logical processors for this core
for (int i = lowBit; i <= hiBit; i++) {
if ((mask & (1L << i)) > 0) {
int numaNode = 0; // TODO fetch
LogicalProcessor logProc = new LogicalProcessor(i, core,
getBitMatchingPackageNumber(packageMaskList, i, group), numaNode, group);
for (int lp = lowBit; lp <= hiBit; lp++) {
if ((mask & (1L << lp)) > 0) {
LogicalProcessor logProc = new LogicalProcessor(lp, getMatchingCore(cores, group, lp),
getMatchingPackage(packages, group, lp), getMatchingNumaNode(numaNodes, group, lp), group);
logProcs.add(logProc);
}
}
}
// Sort by numaNode and then logical processor number to match
// PerfCounter/WMI ordering
logProcs.sort(Comparator.comparing(LogicalProcessor::getNumaNode)
.thenComparing(LogicalProcessor::getProcessorNumber));
// Save numaNode,Processor lookup for future PerfCounter instance lookup
int lp = 0;
this.numaNodeProcToLogicalProcMap = new HashMap<>();
for (LogicalProcessor logProc : logProcs) {
numaNodeProcToLogicalProcMap
.put(String.format("%d,%d", logProc.getNumaNode(), logProc.getProcessorNumber()), lp++);
}
this.logicalProcessorCount = logProcs.size();
this.physicalProcessorCount = cores.size();
this.physicalPackageCount = packages.size();
return logProcs.toArray(new LogicalProcessor[0]);
}

private static int getMatchingPackage(List<GROUP_AFFINITY[]> packages, int g, int lp) {
for (int i = 0; i < packages.size(); i++) {
for (int j = 0; j < packages.get(i).length; j++) {
if ((packages.get(i)[j].mask.longValue() & (1L << lp)) > 0 && packages.get(i)[j].group == g) {
return i;
}
}
}
return 0;
}

private static int getMatchingNumaNode(List<NUMA_NODE_RELATIONSHIP> numaNodes, int g, int lp) {
for (int j = 0; j < numaNodes.size(); j++) {
if ((numaNodes.get(j).groupMask.mask.longValue() & (1L << lp)) > 0
&& numaNodes.get(j).groupMask.group == g) {
return numaNodes.get(j).nodeNumber;
}
}
return 0;
}

private static int getMatchingCore(List<GROUP_AFFINITY> cores, int g, int lp) {
for (int j = 0; j < cores.size(); j++) {
if ((cores.get(j).mask.longValue() & (1L << lp)) > 0 && cores.get(j).group == g) {
return j;
}
}
return 0;
}
private LogicalProcessor[] getLogicalProcessorInformation() {
// Collect a list of logical processors on each physical core and
// package. These will be 64-bit bitmasks.
Expand Down Expand Up @@ -365,28 +429,6 @@ private int getBitMatchingPackageNumber(List<Long> packageMaskList, int logProc)
return 0;
}

/**
* Iterate over the package mask list and find a matching mask index
*
* @param packageMaskList
* The list of bitmasks to iterate
* @param logProc
* The bit to find matching mask
* @param group
* The processor group to match
* @return The index of the list which matched the bit
*/
private int getBitMatchingPackageNumber(List<GROUP_AFFINITY[]> packageMaskList, int logProc, int group) {
for (int i = 0; i < packageMaskList.size(); i++) {
for (int j = 0; j < packageMaskList.get(i).length; j++) {
if ((packageMaskList.get(i)[j].mask.longValue() & (1L << logProc)) > 0
&& packageMaskList.get(i)[j].group == group) {
return i;
}
}
}
return 0;
}

/**
* {@inheritDoc}
Expand Down Expand Up @@ -507,7 +549,8 @@ public long[][] queryProcessorCpuLoadTicks() {
return ticks;
}
for (int p = 0; p < instances.size(); p++) {
int cpu = ParseUtil.parseIntOrDefault(instances.get(p), 0);
int cpu = instances.get(p).contains(",") ? numaNodeProcToLogicalProcMap.getOrDefault(instances.get(p), 0)
: ParseUtil.parseIntOrDefault(instances.get(p), 0);
if (cpu >= this.logicalProcessorCount) {
continue;
}
Expand Down