I have a million elements in a List to process.  

Dropping them crudely into a *Parallel.ForEach* would just saturate the CPU.  

Instead I split the Elements Master Lists into pieces and drop the Sublists into a parallel loop.

```
List<Element> MasterList = new List<Element>();
Populate(MasterList); // puts a Million elements into list;

//Split Master List into 100 Lists of 10.0000 elements each
List<List<Element>> ListOfSubLists = Split(MasterList,100);

foreach (List<Element> EL in ListOfSubLists )
{
   Parallel.ForEach(EL, E =>
   {
     // Do Stuff
   }

  //wait for all parallel iterations to end before continuing   
}    

```

What is the best way for waiting for all parallel iteration to end before continuing to next iteration of the upper loop ?

**Edit :**   

as some answers stated, "saturate the CPU" is not an accurate expression.   

Actually I just want to limit the CPU usage, and avoid excessive load on it coming from this processing.