Condividi tramite


Procedura: creare agenti che utilizzano criteri dell'utilità di pianificazione specifici

Un agente è un componente dell'applicazione che funziona in modo asincrono con gli altri componenti per risolvere le attività di elaborazione più grandi.Un agente in genere ha un ciclo di vita stabilito e mantiene lo stato.

Ogni agente può avere requisiti dell'applicazione univoci.Un agente che consente l'interazione dell'utente, recuperando l'input o visualizzando l'output, potrebbe, ad esempio, richiedere l'accesso alle risorse di elaborazione con priorità più alta.I criteri dell'utilità di pianificazione consentono di controllare la strategia utilizzata dall'utilità di pianificazione quando vengono gestite le attività.In questo argomento viene illustrato come creare agenti che utilizzano criteri dell'utilità di pianificazione specifici.

Per un esempio di base in cui vengono utilizzati insieme criteri dell'utilità di pianificazione personalizzati e blocchi dei messaggi asincroni, vedere Procedura: specificare criteri dell'utilità di pianificazione specifici.

In questo argomento viene utilizzata la funzionalità della libreria di agenti asincroni, ad esempio agenti, blocchi dei messaggi e funzioni di passaggio dei messaggi, per eseguire il lavoro.Per ulteriori informazioni sulla libreria di agenti asincroni, vedere Libreria di agenti asincroni.

Esempio

Nell'esempio seguente definisce due classi che derivano da concurrency::agent: permutor e printer.La classe permutor calcola tutte le permutazioni di una stringa di input specificata.La classe printer visualizza i messaggi di stato sulla console.La classe permutor esegue un'operazione più complessa dal punto di vista dell'elaborazione che potrebbe utilizzare tutte le risorse di elaborazione disponibili.Per essere utile, la classe printer deve visualizzare ogni messaggio di stato in modo tempestivo.

Per consentire alla classe printer un accesso corretto alle risorse di elaborazione, in questo esempio vengono utilizzati i passaggi descritti in Procedura: gestire un'istanza dell'utilità di pianificazione per creare un'istanza dell'utilità di pianificazione con criteri personalizzati.I criteri personalizzati specificano che per la priorità del thread deve essere utilizzata la classe con priorità più elevata.

Per illustrare i vantaggi dell'utilizzo di un'utilità di pianificazione con criteri personalizzati, in questo esempio l'attività complessiva viene eseguita due volte.Nell'esempio viene innanzitutto utilizzata l'utilità di pianificazione predefinita per pianificare entrambe le attività.Viene quindi utilizzata l'utilità di pianificazione predefinita per pianificare l'oggetto permutor e un'utilità di pianificazione con criteri personalizzati per pianificare l'oggetto printer.

// permute-strings.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <agents.h>
#include <iostream>
#include <sstream>

using namespace concurrency;
using namespace std;

// Computes all permutations of a given input string.
class permutor : public agent
{
public:
   explicit permutor(ISource<wstring>& source,
      ITarget<unsigned int>& progress)
      : _source(source)
      , _progress(progress)
   {
   }

   explicit permutor(ISource<wstring>& source,
      ITarget<unsigned int>& progress,
      Scheduler& scheduler)
      : agent(scheduler)
      , _source(source)
      , _progress(progress)
   {
   }

   explicit permutor(ISource<wstring>& source,
      ITarget<unsigned int>& progress,
      ScheduleGroup& group)
      : agent(group)       
      , _source(source)
      , _progress(progress)
   {
   }

protected:
   // Performs the work of the agent.
   void run()
   {
      // Read the source string from the buffer.
      wstring s = receive(_source);

      // Compute all permutations.
      permute(s);

      // Set the status of the agent to agent_done.
      done();
   }

   // Computes the factorial of the given value.
   unsigned int factorial(unsigned int n)
   {
      if (n == 0)
         return 0;
      if (n == 1)
         return 1;
      return n * factorial(n - 1);
   }

   // Computes the nth permutation of the given wstring.
   wstring permutation(int n, const wstring& s) 
   {
      wstring t(s);

      size_t len = t.length();
      for (unsigned int i = 2; i < len; ++i)
      {
         swap(t[n % i], t[i]);
         n = n / i;
      }
      return t;
   }

   // Computes all permutations of the given string.
   void permute(const wstring& s)
   {      
      // The factorial gives us the number of permutations.
      unsigned int permutation_count = factorial(s.length());

      // The number of computed permutations.
      LONG count = 0L;      

      // Tracks the previous percentage so that we only send the percentage
      // when it changes.
      unsigned int previous_percent = 0u;

      // Send initial progress message.
      send(_progress, previous_percent);

      // Compute all permutations in parallel.
      parallel_for (0u, permutation_count, [&](unsigned int i) {
         // Compute the permutation.
         permutation(i, s);

         // Send the updated status to the progress reader.
         unsigned int percent = 100 * InterlockedIncrement(&count) / permutation_count;
         if (percent > previous_percent)
         {
             send(_progress, percent);
             previous_percent = percent;
         }
      });

      // Send final progress message.
      send(_progress, 100u);
   }

private:
   // The buffer that contains the source string to permute.
   ISource<wstring>& _source;

   // The buffer to write progress status to.
   ITarget<unsigned int>& _progress;
};

// Prints progress messages to the console.
class printer : public agent
{
public:
   explicit printer(ISource<wstring>& source,
      ISource<unsigned int>& progress)
      : _source(source)
      , _progress(progress)
   {
   }

   explicit printer(ISource<wstring>& source,
      ISource<unsigned int>& progress, Scheduler& scheduler)
      : agent(scheduler)
      , _source(source)
      , _progress(progress)
   {
   }

   explicit printer(ISource<wstring>& source,
      ISource<unsigned int>& progress, ScheduleGroup& group)
      : agent(group)       
      , _source(source)
      , _progress(progress)
   {
   }

protected:
   // Performs the work of the agent.
   void run()
   {
      // Read the source string from the buffer and print a message.
      wstringstream ss;
      ss << L"Computing all permutations of '" << receive(_source) << L"'..." << endl;
      wcout << ss.str();

      // Print each progress message.
      unsigned int previous_progress = 0u;
      while (true)
      {         
         unsigned int progress = receive(_progress);

         if (progress > previous_progress || progress == 0u)
         { 
            wstringstream ss;
            ss << L'\r' << progress << L"% complete...";
            wcout << ss.str();
            previous_progress = progress;
         }

         if (progress == 100)
            break;
      }
      wcout << endl;

      // Set the status of the agent to agent_done.
      done();
   }

private:
   // The buffer that contains the source string to permute.
   ISource<wstring>& _source;

   // The buffer that contains progress status.
   ISource<unsigned int>& _progress;
};

// Computes all permutations of the given string. 
void permute_string(const wstring& source,
   Scheduler& permutor_scheduler, Scheduler& printer_scheduler)
{  
   // Message buffer that contains the source string.
   // The permutor and printer agents both read from this buffer.
   single_assignment<wstring> source_string;

   // Message buffer that contains the progress status.
   // The permutor agent writes to this buffer and the printer agent reads
   // from this buffer.
   unbounded_buffer<unsigned int> progress;

   // Create the agents with the appropriate schedulers.
   permutor agent1(source_string, progress, permutor_scheduler);
   printer agent2(source_string, progress, printer_scheduler);

   // Start the agents.
   agent1.start();
   agent2.start();

   // Write the source string to the message buffer. This will unblock the agents.
   send(source_string, source);

   // Wait for both agents to finish.
   agent::wait(&agent1);
   agent::wait(&agent2);
}

int wmain()
{
   const wstring source(L"Grapefruit");

   // Compute all permutations on the default scheduler.

   Scheduler* default_scheduler = CurrentScheduler::Get();

   wcout << L"With default scheduler: " << endl;
   permute_string(source, *default_scheduler, *default_scheduler);
   wcout << endl;

   // Compute all permutations again. This time, provide a scheduler that
   // has higher context priority to the printer agent.

   SchedulerPolicy printer_policy(1, ContextPriority, THREAD_PRIORITY_HIGHEST);
   Scheduler* printer_scheduler = Scheduler::Create(printer_policy);

   // Register to be notified when the scheduler shuts down.
   HANDLE hShutdownEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
   printer_scheduler->RegisterShutdownEvent(hShutdownEvent);

   wcout << L"With higher context priority: " << endl;
   permute_string(source, *default_scheduler, *printer_scheduler);
   wcout << endl; 

   // Release the printer scheduler.
   printer_scheduler->Release();

   // Wait for the scheduler to shut down and destroy itself.
   WaitForSingleObject(hShutdownEvent, INFINITE);

   // Close the event handle.
   CloseHandle(hShutdownEvent);
}

Questo esempio produce l'output che segue.

With default scheduler:
Computing all permutations of 'Grapefruit'...
100% complete...

With higher context priority:
Computing all permutations of 'Grapefruit'...
100% complete...

Sebbene entrambi i set di attività producano lo stesso risultato, la versione che utilizza i criteri personalizzati consente all'oggetto printer di essere eseguito con una priorità maggiore in modo da presentare un comportamento più rispondente.

Compilazione del codice

Copiare il codice di esempio e incollarlo in un progetto di Visual Studio o incollarlo in un file denominato strings.cpp permute e quindi eseguire il comando riportato di seguito in una finestra del prompt dei comandi di Visual Studio.

cl.exe /EHsc permute-strings.cpp

Vedere anche

Riferimenti

How-to: Specify Specific Scheduler Policies

Concetti

Criteri dell'utilità di pianificazione

Agenti asincroni