Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
No Concurrency Runtime, a ordem na qual as tarefas são agendadas não é determinística. No entanto, você pode usar políticas de agendamento para influenciar a ordem em que as tarefas são executadas. Este tópico mostra como usar grupos de agendamento juntamente com a política de agendador concurrency::SchedulingProtocol para influenciar a ordem em que as tarefas são executadas.
O exemplo executa um conjunto de tarefas duas vezes, cada uma com uma política de agendamento diferente. Ambas as políticas limitam o número máximo de recursos de processamento a dois. A primeira execução usa a EnhanceScheduleGroupLocality política, que é o padrão, e a segunda execução usa a EnhanceForwardProgress política. De acordo com a EnhanceScheduleGroupLocality política, o agendador executa todas as tarefas em um grupo de agendas até que cada tarefa seja concluída ou produza. De acordo com a EnhanceForwardProgress política, o agendador move-se para o próximo grupo de agendamento de forma round-robin após uma única tarefa terminar ou ceder.
Quando cada grupo de agendamento contém tarefas relacionadas, a política tipicamente resulta em um desempenho melhorado porque a localidade de cache é preservada entre as tarefas. A EnhanceForwardProgress política permite que as tarefas avancem e é útil quando você precisa de equidade de agendamento entre grupos de agendamento.
Exemplo
Este exemplo define a classe, que deriva work_yield_agent de concurrency::agent. A work_yield_agent classe executa uma unidade de trabalho, produz o contexto atual e, em seguida, executa outra unidade de trabalho. O agente usa a função concurrency::wait para produzir cooperativamente o contexto atual para que outros contextos possam ser executados.
Este exemplo cria quatro work_yield_agent objetos. Para ilustrar como definir políticas do agendador para afetar a ordem em que os agentes são executados, o exemplo associa os dois primeiros agentes a um grupo de agendamento e os outros dois agentes a outro grupo de agendamento. O exemplo usa o método concurrency::CurrentScheduler::CreateScheduleGroup para criar os objetos concurrency::ScheduleGroup . O exemplo executa os quatro agentes duas vezes, cada vez com uma política de agendamento distinta.
// scheduling-protocol.cpp
// compile with: /EHsc
#include <agents.h>
#include <vector>
#include <algorithm>
#include <iostream>
#include <sstream>
using namespace concurrency;
using namespace std;
#pragma optimize( "", off )
// Simulates work by performing a long spin loop.
void spin_loop()
{
for (int i = 0; i < 500000000; ++i)
{
}
}
#pragma optimize( "", on )
// Agent that performs some work and then yields the current context.
class work_yield_agent : public agent
{
public:
explicit work_yield_agent(
unsigned int group_number, unsigned int task_number)
: _group_number(group_number)
, _task_number(task_number)
{
}
explicit work_yield_agent(Scheduler& scheduler,
unsigned int group_number, unsigned int task_number)
: agent(scheduler)
, _group_number(group_number)
, _task_number(task_number)
{
}
explicit work_yield_agent(ScheduleGroup& group,
unsigned int group_number, unsigned int task_number)
: agent(group)
, _group_number(group_number)
, _task_number(task_number)
{
}
protected:
// Performs the work of the agent.
void run()
{
wstringstream header, ss;
// Create a string that is prepended to each message.
header << L"group " << _group_number
<< L",task " << _task_number << L": ";
// Perform work.
ss << header.str() << L"first loop..." << endl;
wcout << ss.str();
spin_loop();
// Cooperatively yield the current context.
// The task scheduler will then run all blocked contexts.
ss = wstringstream();
ss << header.str() << L"waiting..." << endl;
wcout << ss.str();
concurrency::wait(0);
// Perform more work.
ss = wstringstream();
ss << header.str() << L"second loop..." << endl;
wcout << ss.str();
spin_loop();
// Print a final message and then set the agent to the
// finished state.
ss = wstringstream();
ss << header.str() << L"finished..." << endl;
wcout << ss.str();
done();
}
private:
// The group number that the agent belongs to.
unsigned int _group_number;
// A task number that is associated with the agent.
unsigned int _task_number;
};
// Creates and runs several groups of agents. Each group of agents is associated
// with a different schedule group.
void run_agents()
{
// The number of schedule groups to create.
const unsigned int group_count = 2;
// The number of agent to create per schedule group.
const unsigned int tasks_per_group = 2;
// A collection of schedule groups.
vector<ScheduleGroup*> groups;
// A collection of agents.
vector<agent*> agents;
// Create a series of schedule groups.
for (unsigned int group = 0; group < group_count; ++group)
{
groups.push_back(CurrentScheduler::CreateScheduleGroup());
// For each schedule group, create a series of agents.
for (unsigned int task = 0; task < tasks_per_group; ++task)
{
// Add an agent to the collection. Pass the current schedule
// group to the work_yield_agent constructor to schedule the agent
// in this group.
agents.push_back(new work_yield_agent(*groups.back(), group, task));
}
}
// Start each agent.
for_each(begin(agents), end(agents), [](agent* a) {
a->start();
});
// Wait for all agents to finsih.
agent::wait_for_all(agents.size(), &agents[0]);
// Free the memory that was allocated for each agent.
for_each(begin(agents), end(agents), [](agent* a) {
delete a;
});
// Release each schedule group.
for_each(begin(groups), end(groups), [](ScheduleGroup* group) {
group->Release();
});
}
int wmain()
{
// Run the agents two times. Each run uses a scheduler
// policy that limits the maximum number of processing resources to two.
// The first run uses the EnhanceScheduleGroupLocality
// scheduling protocol.
wcout << L"Using EnhanceScheduleGroupLocality..." << endl;
CurrentScheduler::Create(SchedulerPolicy(3,
MinConcurrency, 1,
MaxConcurrency, 2,
SchedulingProtocol, EnhanceScheduleGroupLocality));
run_agents();
CurrentScheduler::Detach();
wcout << endl << endl;
// The second run uses the EnhanceForwardProgress
// scheduling protocol.
wcout << L"Using EnhanceForwardProgress..." << endl;
CurrentScheduler::Create(SchedulerPolicy(3,
MinConcurrency, 1,
MaxConcurrency, 2,
SchedulingProtocol, EnhanceForwardProgress));
run_agents();
CurrentScheduler::Detach();
}
Este exemplo produz o seguinte resultado.
Using EnhanceScheduleGroupLocality...
group 0,
task 0: first loop...
group 0,
task 1: first loop...
group 0,
task 0: waiting...
group 1,
task 0: first loop...
group 0,
task 1: waiting...
group 1,
task 1: first loop...
group 1,
task 0: waiting...
group 0,
task 0: second loop...
group 1,
task 1: waiting...
group 0,
task 1: second loop...
group 0,
task 0: finished...
group 1,
task 0: second loop...
group 0,
task 1: finished...
group 1,
task 1: second loop...
group 1,
task 0: finished...
group 1,
task 1: finished...
Using EnhanceForwardProgress...
group 0,
task 0: first loop...
group 1,
task 0: first loop...
group 0,
task 0: waiting...
group 0,
task 1: first loop...
group 1,
task 0: waiting...
group 1,
task 1: first loop...
group 0,
task 1: waiting...
group 0,
task 0: second loop...
group 1,
task 1: waiting...
group 1,
task 0: second loop...
group 0,
task 0: finished...
group 0,
task 1: second loop...
group 1,
task 0: finished...
group 1,
task 1: second loop...
group 0,
task 1: finished...
group 1,
task 1: finished...
Ambas as políticas produzem a mesma sequência de eventos. No entanto, a política que usa EnhanceScheduleGroupLocality inicia os dois agentes que fazem parte do primeiro grupo de agendamento antes de iniciar os agentes que fazem parte do segundo grupo. A política que usa EnhanceForwardProgress inicia um agente do primeiro grupo e, em seguida, inicia o primeiro agente no segundo grupo.
Compilando o código
Copie o código de exemplo e cole-o em um projeto do Visual Studio ou cole-o em um arquivo chamado scheduling-protocol.cpp e, em seguida, execute o seguinte comando em uma janela do prompt de comando do Visual Studio.
cl.exe /EHsc scheduling-protocol.cpp