Trying to solve a core affinity problem results in UI stalling under heavy CPU load

Question

I have literally no experience in threading, so bear with me, please. I'm making a monitoring/testing tool, that monitors hardware sensors and uses affinity masks and for loop to cycle through the cores one by one running a full-load single-core stress test. The problem is, that when the user starts the test, and affinity is set, instead of assigning just the test method to that core, it assigns the entire program, which means UI can run only on the core that is currently tested and is under full load. I guess it's clear that UI is just stalling during the test, and labels that output monitoring data are frozen, while it's crucial to have relevant readings during the test because this is the main purpose of this program.

After some research, I figured that I need to use threading but I never worked with it before. Here is my shortened code. The problem is, that when I use threading on any method that contains labels, it throws the error "Cross-thread operation not valid: Control 'CPUTempTDie' accessed from a thread other than the thread it was created on". I tried to start Report sensors in a new thread, but it doesn't help. I literally tried to start in a new thread every method and label that is involved, but it's either doesn't help or control score (score - is a result returned by TestMethod to compare it with the correct number to confirm stability) or the program just skips some part of the code and just says "Done".

The question is: Is it possible to set just a TestingMethod to a particular core, allowing the rest of the program (including UI) to use any other free core, and if not, what exactly should I start in a new thread to let UI update under the load?

//the method below updates labels and calls ReportSensors method that reads
//sensors on a timer tick

private void Monitoring()
{  
    sensor.ReportSensors(); //calls Method that reads sensors

    //Two labels below are stalling when TestingMethod runs

    CPUTempTDie.Value = (int)sensor.CpuTemp;
    FrequencyLabel.Text = sensor.CoreFrequency.ToString("0") + "MHz";  
}

private int TestingMethod()
{
    while (true)
    {
        //Performs calculations to generate load, returns the "score"
    }

    if (timer.Elapsed.TotalSeconds > 60)
    {
        break;
    }

    return score;
}


private async void PerCoreTest()
{
    try
    {
        await Task.Delay(3000);

        for (int i = 0; i < (numberOfCores); i++)
        {
            coreCounter++;

            Thread.BeginThreadAffinity();
            SetThreadAffinityMask(GetCurrentThread(), new IntPtr(intptrVal));

 //TestingMethod below being called twice, and results from both runs
            //are later compared for consistency. 

            TestingMethod();
            iter1 = score / 10000;

            TestingMethod();
            iter2 = score / 10000;


            maxScore = Math.Max(iter1, iter2);

            await Task.Delay(1000);

            TestLabel.Text = score.ToString();

            //Switches to the next thread mask
        }
    }
    finally
    {
        Thread.EndThreadAffinity();
    }
}



private void TestButton_Click(object sender, EventArgs e)
{
    using (Process p = Process.GetCurrentProcess())
        p.PriorityClass = ProcessPriorityClass.High;

    PerCoreTest();

    using (Process p = Process.GetCurrentProcess())
        p.PriorityClass = ProcessPriorityClass.Normal;
}

---

Clarification: My question was closed as a duplicate despite the linked thread doesn't answer my question. I ask to reopen it because:

1. While "a large number of Remote Calls around 2000 - 3000 calls" mentioned in a linked thread might be heavy on some hardware, it's not the same as hammering the CPU with calculations in the while(true) loop, which squeeze all performance from any kind of hardware living nothing for UI if UI sits on the same core.

2. Suggested solution in the thread that I allegedly duplicated doesn't resolve the issue, and my original question is completely different: I can not figure out what exactly must be put in a task to make UI run smoothly under the load.

3. Suggestions from the comments under my thread don't answer the question too. I tried the solution from Panagiotis Kanavos (see below) but the problem persists:

while (true)
{
    await Task.Delay(500);
    await Task.Run(() => sesnor.ReportSensors()); 
}

After researching similar topics it seems like none of them address my particular issue.

Answer 1

You're setting the CPU affinity for the UI thread, then running the test routine on the same thread so it makes sense your UI is hanging during the test. Simplify things and ensure your UI/threading is working properly before you jump into actually performing your test routine.

private int TestingMethod()
{
    // set affinity for current thread here when ready

    // mock a busy thread by sleeping
    System.Threading.Thread.Sleep( 15 * 1000 );

    return 42;
}

// don't use `async void`
private async Task PerCoreTest()
{
    TestLabel.Text = "Running...";

    // we're in the UI thread, so we want to run
    // the test in another thread.  run a new
    // task to do so, await result so the continuation
    // will execute back in the UI thread
    var score = await Task.Run(() => TestingMethod());

    TestLabel.Text = score.ToString();
}

private async Task TestButton_Click(object sender, EventArgs e)
{
    await PerCoreTest();
}

Nice and simple. Add something else to the form that updates every second or so or a button you can click to verify the UI is updating properly as the test routine is running.

Once you've verified that the UI isn't locking up, then you may begin adding substance to your test routine. I suggest just getting a working test routine without processor affinity first.

private int TestingMethod()
{
    var score = 0;

    // set affinity for current thread here when ready

    do
    {
        // your cpu-frying logic
    }
    while( /* sentinel condition */ )

    return score;
}

Again, verify the UI is responsive during the test and you can also verify one of your cores is getting abused. Once all that is verified, you may then set the thread affinity INSIDE the TestingMethod() method's implementation (abstracting it to another method call is fine as well as long as it's called from within the TestingMethod's body and isn't run in a Task or another thread. You can pass the mask into TestingMethod as a parameter from the PerCoreTest method.

This should get you on the right track to doing what you want to do. I suggest you spend some quality time reading about multithreading in general and .NET's threading/asynchronous programming model if you plan on continuing with it in the future.