.NET and .NET Core missing Processor Group on Process.Start

[nick2893]

Here:
corefx/src/Common/src/Interop/Windows/Kernel32/Interop.CreateProcess.cs

https://github.com/dotnet/corefx/blob/8c5260061b11323dfd97fbab614d54402405513f/src/Common/src/Interop/Windows/Kernel32/Interop.CreateProcess.cs

And here:

https://referencesource.microsoft.com/#System/services/monitoring/system/diagnosticts/Process.cs,c50d8ac0eb7bc0d6,references

system/diagnosticts/Process.cs - StartWithCreateProcess

I have a problem because I spent a lot of money on machines with a lot of CPUs. Specifically, I have more than 1 NUMA Processor group. In C++ I was able to deal with this as,

GROUP_AFFINITY aff;
RtlZeroMemory(&aff, sizeof(GROUP_AFFINITY));
aff.Group = iProcessorGroup;
aff.Mask = 0xffffffff;
LPPROC_THREAD_ATTRIBUTE_LIST lpAttributeList;
lpAttributeList = reinterpret_cast<LPPROC_THREAD_ATTRIBUTE_LIST>
(HeapAlloc(GetProcessHeap(), 0, size));
fSuccess = InitializeProcThreadAttributeList(lpAttributeList, 1, 0, &size);
fSuccess = UpdateProcThreadAttribute(lpAttributeList,
0, PROC_THREAD_ATTRIBUTE_PREFERRED_NODE, &aff.Group, sizeof(aff.Group), NULL, NULL);
STARTUPINFOEX info;
ZeroMemory(&info, sizeof(info));
ZeroMemory(&info.StartupInfo, sizeof(STARTUPINFO));
info.StartupInfo.cb = sizeof(info);
info.lpAttributeList = lpAttributeList;

And then, when calling CreateProcess with &info.StartupInfo - it would correctly start on the processor group where I want it to start. However, in .NET, this cannot be done, I cannot specify on which NUMA node / processor group to start my process. (Sometimes I use round-robin, sometimes the least utilized group, sometimes whatever the GUI provides). However, in .NET 4.8 or Core, this option doesn't exist.

Can we add STARTUPINFOEX to CreateProcess so that I'm not wasting CPU (groups) or running through piles of Win32 API code to start a .NET Process?

[adamsitnik]

Hi @nick2893

Thank you for your valuable suggestion!

We should add two new APIs that would allow for:

• specifying Processor Group and Affinity when starting a new process
• specifying Processor Group when setting Affinity of a process that is already running

If possible, the new APIs should support 1 Processor Group with more than 64 CPUs.

This would make .NET definitely more Numa-friendly (cc @DamianEdwards )

running through piles of Win32 API code to start a .NET Process

As a workaround, you can try to use the start /NODE $x /AFFINITY $y $program $args command:

start /?

Starts a separate window to run a specified program or command.

START ["title"] [/D path] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
      [/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
      [/NODE <NUMA node>] [/AFFINITY <hex affinity mask>] [/WAIT] [/B]
      [command/program] [parameters]

    "title"     Title to display in window title bar.
    path        Starting directory.
    B           Start application without creating a new window. The
                application has ^C handling ignored. Unless the application
                enables ^C processing, ^Break is the only way to interrupt
                the application.
    I           The new environment will be the original environment passed
                to the cmd.exe and not the current environment.
    MIN         Start window minimized.
    MAX         Start window maximized.
    SEPARATE    Start 16-bit Windows program in separate memory space.
    SHARED      Start 16-bit Windows program in shared memory space.
    LOW         Start application in the IDLE priority class.
    NORMAL      Start application in the NORMAL priority class.
    HIGH        Start application in the HIGH priority class.
    REALTIME    Start application in the REALTIME priority class.
    ABOVENORMAL Start application in the ABOVENORMAL priority class.
    BELOWNORMAL Start application in the BELOWNORMAL priority class.
    NODE        Specifies the preferred Non-Uniform Memory Architecture (NUMA)
                node as a decimal integer.
    AFFINITY    Specifies the processor affinity mask as a hexadecimal number.
                The process is restricted to running on these processors.

                The affinity mask is interpreted differently when /AFFINITY and
                /NODE are combined.  Specify the affinity mask as if the NUMA
                node's processor mask is right shifted to begin at bit zero.
                The process is restricted to running on those processors in
                common between the specified affinity mask and the NUMA node.
                If no processors are in common, the process is restricted to
                running on the specified NUMA node.
    WAIT        Start application and wait for it to terminate.
    command/program
                If it is an internal cmd command or a batch file then
                the command processor is run with the /K switch to cmd.exe.
                This means that the window will remain after the command
                has been run.

                If it is not an internal cmd command or batch file then
                it is a program and will run as either a windowed application
                or a console application.

    parameters  These are the parameters passed to the command/program.

A sample .NET Core code (works on Windows only):

static ProcessStartInfo GetProcessStartInfo(string fileName, uint group, uint mask, params string[] arguments)
{
    var startInfo = new ProcessStartInfo("cmd.exe");

    startInfo.ArgumentList.Add("/c");
    startInfo.ArgumentList.Add("start");
    startInfo.ArgumentList.Add("/NODE");
    startInfo.ArgumentList.Add(group.ToString());
    startInfo.ArgumentList.Add("/AFFINITY");
    startInfo.ArgumentList.Add(mask.ToString("X2"));
    startInfo.ArgumentList.Add(fileName);

    foreach (var argument in arguments)
    {
        startInfo.ArgumentList.Add(argument);
    }

    return startInfo;
}

[dotnet-policy-service]

This issue will now be closed since it had been marked no-recent-activity but received no further activity in the past 14 days. It is still possible to reopen or comment on the issue, but please note that the issue will be locked if it remains inactive for another 30 days.