Repo restructuring

1 files changed, 132 insertions, 0 deletions

diff --git a/ACE/apps/JAWS2/JAWS/Concurrency.h b/ACE/apps/JAWS2/JAWS/Concurrency.h
new file mode 100644
index 00000000000..c88d75c4dbe
--- /dev/null
+++ b/ACE/apps/JAWS2/JAWS/Concurrency.h
@@ -0,0 +1,132 @@
+/* -*- c++ -*- */
+// $Id$
+
+#ifndef JAWS_CONCURRENCY_H
+#define JAWS_CONCURRENCY_H
+
+#include "ace/Singleton.h"
+
+#if !defined (ACE_LACKS_PRAGMA_ONCE)
+# pragma once
+#endif /* ACE_LACKS_PRAGMA_ONCE */
+
+#include "ace/Task.h"
+#include "ace/Synch_Traits.h"
+
+#include "JAWS/Export.h"
+#include "JAWS/IO.h"
+
+class JAWS_Data_Block;
+class JAWS_Dispatch_Policy;
+class JAWS_Reaper;
+
+class JAWS_Export JAWS_Concurrency_Base : public ACE_Task<ACE_SYNCH>
+  // = TITLE
+  //     Base class for different concurrency models
+  //
+  // = DESCRIPTION
+  //     Provides a default implementaion of the virtual put() method
+  //     which calls putq(), but can be overloaded to do something
+  //     synchronously, such as call put_next().
+
+{
+public:
+  JAWS_Concurrency_Base (void);
+  ~JAWS_Concurrency_Base (void);
+
+  virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
+  virtual int svc (void);
+
+  virtual int svc_loop (JAWS_Data_Block *db);
+  // in thread pool, this is an infinite loop
+  // in thread per request, it is a single iteration
+
+  virtual int svc_hook (JAWS_Data_Block *db);
+  // does the work of following the pipeline tasks
+
+  virtual int activate_hook (void);
+  // callback for IO_Handler when accept completes
+
+  virtual ACE_Message_Block *singleton_mb (void);
+
+protected:
+  int mb_acquired_;
+  ACE_Message_Block *mb_;
+  JAWS_Reaper *reaper_;
+  ACE_SYNCH_MUTEX lock_;
+};
+
+class JAWS_Export JAWS_Dispatcher
+  // = TITLE
+  //     The class that is responsible to delivering events to the
+  //     appropriate concurrency mechanism.
+  //
+  // = DESCRIPTION
+  //     JAWS_IO_Handler calls into the dispatcher so that the completed
+  //     IO can find a thread to take care of it.
+{
+public:
+  JAWS_Dispatcher (void);
+
+  int dispatch (ACE_Message_Block *mb);
+  JAWS_Dispatch_Policy *policy (void);
+  JAWS_Dispatch_Policy *policy (JAWS_Dispatch_Policy *p);
+
+private:
+  JAWS_Dispatch_Policy *policy_;
+};
+
+class JAWS_Export JAWS_Thread_Pool_Task : public JAWS_Concurrency_Base
+  // = TITLE
+  //     Used to implement Thread Pool Concurrency Strategy
+  //
+  // = DESCRIPTION
+  //     This task is created to hold a pool of threads that receive
+  //     requests through the message queue.
+{
+public:
+  virtual int make (long flags, int nthreads, int maxthreads);
+  // Initiate the thread_pool task
+
+private:
+  long flags_;
+  int nthreads_;
+  int maxthreads_;
+};
+
+class JAWS_Export JAWS_Thread_Per_Task : public JAWS_Concurrency_Base
+  // = TITLE
+  //     Used to implement Thread Per Request Concurrency Strategy
+  //
+  // = DESCRIPTION
+  //     As each new message arrives from the queue, a new thread is
+  //     spawned to handle it.  This is done by overloading put to call
+  //     activate.
+{
+public:
+  virtual int make (long flags, int maxthreads);
+  // Initiate the thread_per task
+
+  virtual int put (ACE_Message_Block *mb, ACE_Time_Value *tv = 0);
+
+  virtual int svc_loop (JAWS_Data_Block *db);
+  // a single iteration
+
+  virtual int activate_hook (void);
+  // callback for IO_Handler when accept completes
+
+private:
+  long flags_;
+  int maxthreads_;
+};
+
+typedef ACE_Singleton<JAWS_Dispatcher, ACE_SYNCH_MUTEX>
+        JAWS_Dispatcher_Singleton;
+
+typedef ACE_Singleton<JAWS_Thread_Pool_Task, ACE_SYNCH_MUTEX>
+        JAWS_Thread_Pool_Singleton;
+
+typedef ACE_Singleton<JAWS_Thread_Per_Task, ACE_SYNCH_MUTEX>
+        JAWS_Thread_Per_Singleton;
+
+#endif /* !defined (JAWS_CONCURRENCY_H) */