FXThreadPool.h

/********************************************************************************
*                                                                               *
*                             T h r e a d   P o o l                             *
*                                                                               *
*********************************************************************************
* Copyright (C) 2006,2024 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* This library is free software; you can redistribute it and/or modify          *
* it under the terms of the GNU Lesser General Public License as published by   *
* the Free Software Foundation; either version 3 of the License, or             *
* (at your option) any later version.                                           *
*                                                                               *
* This library 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 Lesser General Public License for more details.                           *
*                                                                               *
* You should have received a copy of the GNU Lesser General Public License      *
* along with this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXTHREADPOOL_H
#define FXTHREADPOOL_H

#ifndef FXRUNNABLE_H
#include "FXRunnable.h"
#endif

namespace FX {


class FXWorker;

typedef FXLFQueueOf<FXRunnable> FXTaskQueue;


class FXAPI FXThreadPool : public FXRunnable {
private:
  FXTaskQueue     queue;        // Task queue
  FXCompletion    tasks;        // Active tasks
  FXCompletion    threads;      // Active threads
  FXSemaphore     freeslots;    // Free slots in queue
  FXSemaphore     usedslots;    // Used slots in queue
  FXuval          stacksize;    // Stack size
  FXTime          expiration;   // Quit if no task within this time
  volatile FXuint maximum;      // Maximum threads
  volatile FXuint minimum;      // Minimum threads
  volatile FXuint workers;      // Working threads
  volatile FXuint running;      // Context is running
private:
  static FXAutoThreadStorageKey reference;
private:
  FXbool startWorker();
  void runWhile(FXCompletion& comp,FXTime timeout);
  virtual FXint run();
private:
  FXThreadPool(const FXThreadPool&);
  FXThreadPool &operator=(const FXThreadPool&);
public:

  FXThreadPool(FXuint sz=256);

  FXbool active() const { return running==1; }

  FXbool setSize(FXuint sz);

  FXuint getSize() const { return queue.getSize(); }

  FXuint getRunningTasks() const { return tasks.count(); }

  FXuint getRunningThreads() const { return threads.count(); }

  FXbool setMinimumThreads(FXuint n);

  FXuint getMinimumThreads() const { return minimum; }

  FXbool setMaximumThreads(FXuint n);

  FXuint getMaximumThreads() const { return maximum; }

  FXbool setExpiration(FXTime ns=forever);

  FXTime getExpiration() const { return expiration; }

  FXbool setStackSize(FXuval sz);

  FXuval getStackSize() const { return stacksize; }

  static FXThreadPool* instance();

  static void instance(FXThreadPool *pool);

  FXuint start(FXuint count=0);

  FXbool execute(FXRunnable* task,FXTime blocking=forever);

  FXbool executeAndWait(FXRunnable* task,FXTime blocking=forever);

  FXbool executeAndWaitFor(FXRunnable* task,FXCompletion& comp,FXTime blocking=forever);

  FXbool wait();

  FXbool waitFor(FXCompletion& comp);

  FXbool stop();

  virtual ~FXThreadPool();
  };


}

#endif