ACE/apps/JAWS/server/JAWS_Concurrency.h

   1 /* -*- c++ -*- */
   2 #ifndef JAWS_CONCURRENCY_H
   3 #define JAWS_CONCURRENCY_H
   4
   5 #include "ace/config-all.h"
   6
   7 #if !defined (ACE_LACKS_PRAGMA_ONCE)
   8 # pragma once
   9 #endif /* ACE_LACKS_PRAGMA_ONCE */
  10
  11 #include "ace/Task.h"
  12 #include "JAWS_IO.h"
  13
  14 class JAWS_Concurrency_Base : public ACE_Task<ACE_SYNCH>
  15   // = TITLE
  16   //     Base class for different concurrency models
  17   //
  18   // = DESCRIPTION
  19   //     Provides a default implementaion of the virtual put() method
  20   //     which calls putq(), but can be overloaded to do something
  21   //     synchronously, such as call put_next().
  22
  23 {
  24 public:
  25   JAWS_Concurrency_Base ();
  26   virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
  27   virtual int svc ();
  28 };
  29
  30 class JAWS_Dispatch_Policy
  31   // = TITLE
  32   //     Policy mechanism for choosing different concurrency models.
  33   //
  34   // = DESCRIPTION
  35   //     Given some (unspecified) state, decides what the concurrency
  36   //     model should be.  (For now, we always return the same model.)
  37 {
  38 public:
  39   JAWS_Dispatch_Policy ();
  40   virtual ~JAWS_Dispatch_Policy ();
  41   virtual JAWS_Concurrency_Base * update (void *state = 0) = 0;
  42 };
  43
  44 class JAWS_Dispatcher
  45   // = TITLE
  46   //     The class that is responsible to delivering events to the
  47   //     appropriate concurrency mechanism.
  48   //
  49   // = DESCRIPTION
  50   //     JAWS_IO_Handler calls into the dispatcher so that the completed
  51   //     IO can find a thread to take care of it.
  52 {
  53 public:
  54   JAWS_Dispatcher (JAWS_Dispatch_Policy *policy);
  55
  56   int dispatch (JAWS_IO_Handler *ioh);
  57
  58 private:
  59   JAWS_Dispatch_Policy *policy_;
  60 };
  61
  62 class JAWS_Thread_Pool_Task : public JAWS_Concurrency_Base
  63   // = TITLE
  64   //     Used to implement Thread Pool Concurrency Strategy
  65   //
  66   // = DESCRIPTION
  67   //     This task is created to hold a pool of threads that receive
  68   //     requests through the message queue.
  69 {
  70 public:
  71   JAWS_Thread_Pool_Task (long flags = THR_NEW_LWP,
  72                          int nthreads = 5,
  73                          int maxthreads = 20);
  74
  75 private:
  76   int nthreads_;
  77   int maxthreads_;
  78 };
  79
  80 class JAWS_Thread_Per_Task : public JAWS_Concurrency_Base
  81   // = TITLE
  82   //     Used to implement Thread Per Request Concurrency Strategy
  83   //
  84   // = DESCRIPTION
  85   //     As each new message arrives from the queue, a new thread is
  86   //     spawned to handle it.  This is done by overloading put to call
  87   //     activate.
  88 {
  89 public:
  90   JAWS_Thread_Per_Task (long flags = THR_NEW_LWP, int maxthreads = 20);
  91
  92   virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
  93
  94 private:
  95   long flags_;
  96   int maxthreads_;
  97 };
  98
  99 #endif /* !defined (JAWS_CONCURRENCY_H) */