Question: I need to constantly perform 20 repetitive, CPU intensive calculations as fast as possible. So there is 20 tasks which contain looped methods in :

```
while(!token.IsCancellationRequested) 

```

to repeat them as fast as possible. All calculations are performed at the same time. Unfortunatelly this makes the program unresponsive, so added :

```
await Task.Delay(15); 

```

At this point program doesn't hang but adding Delay is not correct approach and it unnecessarily slows down the speed of calculations. It is WPF program without MVVM. What approach would you suggest to keep all 20 tasks working at the same time? Each of them will be constantly repeated as soon as it finished. I would like to keep CPU (all cores) utilisation at max values (or near) to ensure best efficiency. 

**EDIT**:
There is 20 controls in which user adjusts some parameters. Calculations are done in:

```
private async Task Calculate()
{
   Task task001 = null;
   task001 = Task.Run(async () => 
   {
      while (!CTSFor_task001.IsCancellationRequested)
      {
          await Task.Delay(15);
          await CPUIntensiveMethod();
      }
   }, CTSFor_task001.Token);
}

```

Each control is independent. Calcullations are 100% CPU-bound, no I/O activity. (All values come from variables) During calculations values of some UI items are changed:

```
 this.Dispatcher.BeginInvoke(new Action(() =>
     {
          this.lbl_001.Content = "someString";
     }));

```

Answer: 
So what you actually seek is a clarification of a good practice to maximize performance while keeping the UI responsive. As Luaan clarified, the `async` and `await` sections in your proposal will not benefit your problem, and `Task.Run` is not suited for your work; using threads is a better approach.

Define an array of Threads to run one on each logical processor. Distribute your task data between them and control your 20 repetitive calculations via [`BufferBlock`](http://msdn.microsoft.com/en-us/library/hh160414%28v=vs.110%29.aspx) provided in [`TPL DataFlow library`](http://msdn.microsoft.com/en-us/library/hh228603%28v=vs.110%29.aspx).

To keep UI responsive, I suggest two approaches:

1. Your calculations demand many frequent UI updates: Put their required update information in a queue and update them in Timer event.
2. Your calculations demand scarce UI updates: Update UI with an invocation method like `Control.BeginInvoke`
As @Luaan says, I would strongly recommend reading up on `async`/`await`, the key point being it doesn't introduce any parallelism. 

I *think* what you're trying to do is something like the simple example below, where you kick off `CPUIntensiveMethod` on the thread pool and await its completion. `await` returns control from the `Calculate` method (allowing the UI thread to continue working) until the task completes, at which point it continues with the `while` loop.

```
private async Task Calculate()
{
   while (!CTSFor_task001.IsCancellationRequested)
   {
       await Task.Run(CPUIntensiveMethod);
   }   
}

```