How to: Select Among Completed Tasks
This example shows how to use the concurrency::choice and concurrency::join classes to select the first task to complete a search algorithm.
Example
The following example performs two search algorithms in parallel and selects the first algorithm to complete. This example defines the employee type, which holds a numeric identifier and a salary for an employee. The find_employee function finds the first employee that has the provided identifier or the provided salary. The find_employee function also handles the case where no employee has the provided identifier or salary. The wmain function creates an array of employee objects and searches for several identifier and salary values.
The example uses a choice object to select among the following cases:
An employee who has the provided identifier exists.
An employee who has the provided salary exists.
No employee who has the provided identifier or salary exists.
For the first two cases, the example uses a concurrency::single_assignment object to hold the identifier and another single_assignment object to hold the salary. The example uses a join object for the third case. The join object is composed of two additional single_assignment objects, one for the case where no employee who has the provided identifier exists, and one for the case where no employee who has the provided salary exists. The join object sends a message when each of its members receives a message. In this example, the join object sends a message when no employee who has the provided identifier or salary exists.
The example uses a concurrency::structured_task_group object to run both search algorithms in parallel. Each search task writes to one of the single_assignment objects to indicate whether the given employee exists. The example uses the concurrency::receive function to obtain the index of the first buffer that contains a message and a switch block to print the result.
// find-employee.cpp
// compile with: /EHsc
#include <agents.h>
#include <ppl.h>
#include <array>
#include <iostream>
#include <random>
using namespace concurrency;
using namespace std;
// Contains information about an employee.
struct employee
{
int id;
float salary;
};
// Finds the first employee that has the provided id or salary.
template <typename T>
void find_employee(const T& employees, int id, float salary)
{
// Holds the salary for the employee with the provided id.
single_assignment<float> find_id_result;
// Holds the id for the employee with the provided salary.
single_assignment<int> find_salary_result;
// Holds a message if no employee with the provided id exists.
single_assignment<bool> id_not_found;
// Holds a message if no employee with the provided salary exists.
single_assignment<bool> salary_not_found;
// Create a join object for the "not found" buffers.
// This join object sends a message when both its members holds a message
// (in other words, no employee with the provided id or salary exists).
auto not_found = make_join(&id_not_found, &salary_not_found);
// Create a choice object to select among the following cases:
// 1. An employee with the provided id exists.
// 2. An employee with the provided salary exists.
// 3. No employee with the provided id or salary exists.
auto selector = make_choice(&find_id_result, &find_salary_result, ¬_found);
// Create a task that searches for the employee with the provided id.
auto search_id_task = make_task([&]{
auto result = find_if(begin(employees), end(employees),
[&](const employee& e) { return e.id == id; });
if (result != end(employees))
{
// The id was found, send the salary to the result buffer.
send(find_id_result, result->salary);
}
else
{
// The id was not found.
send(id_not_found, true);
}
});
// Create a task that searches for the employee with the provided salary.
auto search_salary_task = make_task([&]{
auto result = find_if(begin(employees), end(employees),
[&](const employee& e) { return e.salary == salary; });
if (result != end(employees))
{
// The salary was found, send the id to the result buffer.
send(find_salary_result, result->id);
}
else
{
// The salary was not found.
send(salary_not_found, true);
}
});
// Use a structured_task_group object to run both tasks.
structured_task_group tasks;
tasks.run(search_id_task);
tasks.run(search_salary_task);
wcout.setf(ios::fixed, ios::fixed);
wcout.precision(2);
// Receive the first object that holds a message and print a message.
int index = receive(selector);
switch (index)
{
case 0:
wcout << L"Employee with id " << id << L" has salary "
<< receive(find_id_result);
break;
case 1:
wcout << L"Employee with salary " << salary << L" has id "
<< receive(find_salary_result);
break;
case 2:
wcout << L"No employee has id " << id << L" or salary " << salary;
break;
default:
__assume(0);
}
wcout << L'.' << endl;
// Cancel any active tasks and wait for the task group to finish.
tasks.cancel();
tasks.wait();
}
int wmain()
{
// Create an array of employees and assign each one a
// random id and salary.
array<employee, 10000> employees;
mt19937 gen(15);
const float base_salary = 25000.0f;
for (int i = 0; i < employees.size(); ++i)
{
employees[i].id = gen()%100000;
float bonus = static_cast<float>(gen()%5000);
employees[i].salary = base_salary + bonus;
}
// Search for several id and salary values.
find_employee(employees, 14758, 30210.00);
find_employee(employees, 340, 29150.00);
find_employee(employees, 61935, 29255.90);
find_employee(employees, 899, 31223.00);
}
This example produces the following output.
Employee with id 14758 has salary 27780.00. Employee with salary 29150.00 has id 84345. Employee with id 61935 has salary 29905.00. No employee has id 899 or salary 31223.00.
This example uses the concurrency::make_choice helper function to create choice objects and the concurrency::make_join helper function to create join objects.
Compiling the Code
Copy the example code and paste it in a Visual Studio project, or paste it in a file that is named find-employee.cpp and then run the following command in a Visual Studio Command Prompt window.
cl.exe /EHsc find-employee.cpp