Concurrency Runtime in Visual C++ 2010

MSDN page
Good Article

Parallel Patterns Library

The header file for parallel algorithms is <ppl.h>

• Parallel Algorithms:
  • parallel_for
  • parallel_for_each
  • parallel_invoke
• Parallel Containers and Objects:
  • concurrent_vector Class
  • concurrent_queue Class
  • combinable Class
• Task Parallelism:
  • Structured
  • Unstructured

Asynchronous Agents Library

The header file is <agents.h>

• Asynchronous Message Blocks
• Message Passing Functions
• Asynchronous Agents

 
1. basic examples:

#include <iostream>
#include <ppl.h>

int main()
{
    using namespace Concurrency;
    int nSum=0;
    
    parallel_for(1, 100001, [&](int n) 
    {
        nSum += n;        
    });

    std::wcout << "Sum: " << nSum ;
}

2. copy file example:

#include <string>
#include <vector>
#include <fstream>
#include <iostream>
#include <future>
using namespace std; 
 
vector readFile(const string& inPath) 
{ 
    ifstream file(inPath, ios::binary | ios::ate); 
    size_t length = (size_t)file.tellg(); 
    vector<char> buffer(length); 
    file.seekg(0, std::ios::beg); 
    file.read(&buffer[0], length); 
    return buffer; 
} 
 
size_t writeFile(const vector& buffer, const string& outPath) 
{ 
    ofstream file(outPath, ios::binary); 
    file.write(&buffer[0], buffer.size()); 
    return (size_t)file.tellp(); 
} 

// basic:
size_t ppl_copyFile(const string& inFile, const string& outFile) 
{ 
    Concurrency::task<vector<char>> tsk1 = Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }); 
    Concurrency::task<size_t> tsk2 = Concurrency::create_task([&tsk1, outFile]() { 
        return writeFile(tsk1.get(), outFile); 
    }); 
    return tsk2.get(); 
} 

// task continuation:
size_t ppl_then_copyFile(const string& inFile, const string& outFile) 
{ 
    Concurrency::task<size_t> result =  
    Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }).then([outFile](const vector<char>& buffer) { 
        return writeFile(buffer, outFile); 
    }); 
  
    return result.get(); 
} 
//...or
Concurrency::task ppl_create_copyFile_task(const string& inFile, const & outFile) 
{ 
    return Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }).then([outFile](const vector<char>& buffer) { 
        return writeFile(buffer, outFile); 
    }); 
} 
... 
auto tCopy = ppl_create_copyFile_task(inFile, outFile).then([](size_t written) { 
    cout << written << endl; 
}); 
... 
tCopy.wait();