Question

I need to allocate a workload on different processes, depending on the number of logical cores of the user’s PC.
The workload is done by the following code :

static void work()
{
    WorkData myData = new WorkData();
    Worker myWorker = new Worker(myData);
    MyWorker.doWork()
}

I count the logical cores with this code :

int nbProcessors = 1;
foreach (var item in new System.Management.ManagementObjectSearcher("Select *  from Win32_ComputerSystem").Get())
{
    nbProcessors = Convert.ToInt32(item["NumberOfLogicalProcessors"]);
}

Now, I have to do my work() 10000 times, by sharing the work on the logical cores, so in the case of my pc it would mean starting 8 processes with 1250 iterations of work() each.
I also need each process to have its own data, so that I don’t get conflicts.

How can I do that?

Answer 1

I think you should review Parallel methods and ThreadPool methods.
Both of this classes are counting on current workstation configuration, so you can easily use them for your task.

Example of Parrallel usage:

Parallel Loops:

int n = 10 000;
Parallel.For(0, n, (i, loopState) =>
{
  // ... 
  if (/* stopping condition is true */)
  {
    loopState.Break();
    return;   
  }
});

Thread Pool task-oriented example:

public void DoWork()
{
    // Queue a task.
    System.Threading.ThreadPool.QueueUserWorkItem(
        new System.Threading.WaitCallback(SomeLongTask));
    // Queue another task.
    System.Threading.ThreadPool.QueueUserWorkItem(
        new System.Threading.WaitCallback(AnotherLongTask));
}

private void SomeLongTask(Object state)
{
    // Insert code to perform a long task.
}

private void AnotherLongTask(Object state)
{
    // Insert code to perform a long task.
}

Update from comments:

Task Parallel Library (Parralel class) internally uses Threading.Tasks namespace, with some process managing:

the scheduling of threads on the ThreadPool

Two another links about: Task Parallelism and Data Parallelism. I think second link can help you with balancing the work for your data.

When possible, the scheduler redistributes work among multiple threads and processors if the workload becomes unbalanced.