Tanl Linguistic Pipeline

search/ixe/Common/ThreadPool.h

/*
**      IXE C++ Library
**      server/ThreadPool.h
** ----------------------------------------------------------------------
**      Copyright (c) 2002  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_ThreadPool_H
#define IXE_ThreadPool_H

// Settings
#include "platform.h"

// standard
#include <queue>
#include <set>

// local
#include "include/ixe.h"
#include "Common/Lock.h"

namespace IXE {

#ifdef _WIN32

#define TRESULT         unsigned int __stdcall

#else // !_WIN32

#define TRESULT         void*

extern pthread_key_t jmpbuf_key;
#endif // _WIN32


extern "C" TRESULT ThreadMain(void*);

class ThreadPool
{
public:

  class Thread {

  public:
    union TaskDescr {
      //
      // This should be a template parameter type.
      // As an approximation, we define TaskDescr to be
      // either a simple integer or a pointer.
      // The pointer can be used to pass any object to the thread.
      //
      TaskDescr(long  a) : i(a) { }
      TaskDescr(void* a) : p(a) { }
      long      i;
      void*     p;
    };

    void                Start();

  protected:
    Thread(ThreadPool&);
    virtual ~Thread();          // only allowed from ThreadPool

    virtual Thread*     clone(ThreadPool&) const = 0;

    virtual void        Run(TaskDescr) = 0;

    static TRESULT      Main(void*);
    static void         Destroy(void *p);

                        Thread(Thread const&); 
    Thread&             operator =(Thread const&); 

#   ifdef _WIN32
    HANDLE              thread;                 
#   else
    pthread_t           thread;                 
#   endif
    ThreadPool&         pool;                   
    bool                destroying;             

    friend class        ThreadPool;
  };

  //    Constructor/Destructors

                        ThreadPool(char const* process_name,
                                   int min_threads, int max_threads,
                                   int timeout);

                        ThreadPool(char const* process_name,
                                   Thread const* prototype,
                                   int min_threads, int max_threads,
                                   int timeout);

                        ~ThreadPool();

  //    Methods

  void                  AddTask(Thread::TaskDescr);

  void                  init(Thread const* prototype);

private:

  typedef std::set<Thread*> ThreadSet;
  typedef std::queue<Thread::TaskDescr> TaskQueue;

  Locked<ThreadSet>     threads;
  Locked<TaskQueue>     tasks;

  Count const           minThreads, maxThreads; 
  Locked<Count>         busyThreads;            
  Locked<bool>          destructing;            

  Condition             idle_thread;            
  Condition             task_available;         

  int const             timeout;
  char const*           process_name; 

  friend class          Thread;

public:
  void Run(int socket_port, int socket_queue_size,
                     unsigned socket_timeout);
};

} // namespace IXE

#endif  /* IXE_ThreadPool_H */

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.