CbcThread.hpp

Go to the documentation of this file.

/* $Id$ */
// Copyright (C) 2009, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#ifndef CbcThread_H
#define CbcThread_H
 
#include "CbcModel.hpp"
#include "CbcNode.hpp"
class OsiObject;
class OsiCuts;
#ifdef CBC_THREAD
class CbcThread;
// Use pthreads
#define CBC_PTHREAD
#ifdef CBC_PTHREAD
#include <pthread.h>
typedef struct {
  pthread_t thr;
  long status;
} Coin_pthread_t;
#endif
//#define THREAD_DEBUG 1
class CbcSpecificThread {
public:
  // Default Constructor
  CbcSpecificThread();
 
  // Useful Constructor
  CbcSpecificThread(CbcSpecificThread *master, pthread_mutex_t *masterMutex);
 
  virtual ~CbcSpecificThread();
 
  // Useful stuff
  void setUsefulStuff(CbcSpecificThread *master,
    void *&masterMutex);
  void lockThread();
  void unlockThread();
  void lockThread2(bool doAnyway = false);
  void unlockThread2(bool doAnyway = false);
  void signal();
  void timedWait(int time);
  void startThread(void *(*routine)(void *), CbcThread *thread);
  int exit();
  void exitThread();
  int status() const;
  void setStatus(int value);
  //}
 
public: // private:
  CbcSpecificThread *basePointer_; // for getting main mutex and threadid of base
#ifdef CBC_PTHREAD
  pthread_mutex_t *masterMutex_; // for synchronizing
  pthread_mutex_t mutex2_; // for waking up threads
  pthread_cond_t condition2_; // for waking up thread
  Coin_pthread_t threadId_;
#endif
  bool locked_; // For mutex2
};
class CbcThread {
private:
  void gutsOfDelete();
  void gutsOfCopy(const CbcThread &rhs);
 
public:
  // Default Constructor
  CbcThread();
 
  virtual ~CbcThread();
 
  void setUsefulStuff(CbcModel *model, int deterministic,
    CbcModel *baseModel,
    CbcThread *master,
    void *&masterMutex);
  void lockThread();
  void unlockThread();
 
  inline bool isLocked() const
  {
    return locked_;
  }
  bool wait(int type, int currentCode);
  void waitNano(int time);
  void signal();
  void lockFromMaster();
  void unlockFromMaster();
  void lockFromThread();
  void unlockFromThread();
  int exit();
  void exitThread();
  void waitThread();
  inline int status() const
  {
    return threadStuff_.status();
  }
  inline void setStatus(int value)
  {
    threadStuff_.setStatus(value);
  }
  inline int returnCode() const
  {
    return returnCode_;
  }
  inline void setReturnCode(int value)
  {
    returnCode_ = value;
  }
  inline CbcModel *baseModel() const
  {
    return baseModel_;
  }
  inline CbcModel *thisModel() const
  {
    return thisModel_;
  }
  inline CbcNode *node() const
  {
    return node_;
  }
  inline void setNode(CbcNode *node)
  {
    node_ = node;
  }
  inline CbcNode *createdNode() const
  {
    return createdNode_;
  }
  inline void setCreatedNode(CbcNode *node)
  {
    createdNode_ = node;
  }
  inline int dantzigState() const
  {
    return dantzigState_;
  }
  inline void setDantzigState(int value)
  {
    dantzigState_ = value;
  }
  inline double timeInThread() const
  {
    return timeInThread_;
  }
  inline void incrementTimeInThread(double value)
  {
    timeInThread_ += value;
  }
  inline double timeWaitingToStart() const
  {
    return timeWaitingToStart_;
  }
  inline void incrementTimeWaitingToStart(double value)
  {
    timeWaitingToStart_ += value;
  }
  inline double timeLocked() const
  {
    return timeLocked_;
  }
  inline void incrementTimeLocked(double value)
  {
    timeLocked_ += value;
  }
  inline double timeWaitingToLock() const
  {
    return timeWaitingToLock_;
  }
  inline void incrementTimeWaitingToLock(double value)
  {
    timeWaitingToLock_ += value;
  }
  inline int deterministic() const
  {
    return deterministic_;
  }
  inline int maxDeleteNode() const
  {
    return maxDeleteNode_;
  }
  inline void setMaxDeleteNode(int value)
  {
    maxDeleteNode_ = value;
  }
  inline int nDeleteNode() const
  {
    return nDeleteNode_;
  }
  inline void setNDeleteNode(int value)
  {
    nDeleteNode_ = value;
  }
  inline void clearDelNode()
  {
    delete delNode_;
    delNode_ = NULL;
  }
  inline void fakeDelNode(CbcNode **delNode)
  {
    delNode_ = delNode;
  }
  inline CbcNode **delNode() const
  {
    return delNode_;
  }
  inline void setDelNode(CbcNode **delNode)
  {
    delNode_ = delNode;
  }
  inline int numberTimesLocked() const
  {
    return numberTimesLocked_;
  }
  inline int numberTimesUnlocked() const
  {
    return numberTimesUnlocked_;
  }
  inline int nodesThisTime() const
  {
    return nodesThisTime_;
  }
  inline void setNodesThisTime(int value)
  {
    nodesThisTime_ = value;
  }
  inline int iterationsThisTime() const
  {
    return iterationsThisTime_;
  }
  inline void setIterationsThisTime(int value)
  {
    iterationsThisTime_ = value;
  }
  inline int *saveStuff()
  {
    return saveStuff_;
  }
  inline bool locked() const
  {
    return locked_;
  }
 
public: // private:
  CbcSpecificThread threadStuff_;
  CbcModel *baseModel_;
  CbcModel *thisModel_;
  CbcNode *node_; // filled in every time
  CbcNode *createdNode_; // filled in every time on return
  CbcThread *master_; // points back to master thread
  int returnCode_; // -1 available, 0 busy, 1 finished , 2??
  double timeLocked_;
  double timeWaitingToLock_;
  double timeWaitingToStart_;
  double timeInThread_;
  double timeWhenLocked_; // time when thread got lock (in seconds)
  int numberTimesLocked_;
  int numberTimesUnlocked_;
  int numberTimesWaitingToStart_;
  int saveStuff_[2];
  int dantzigState_; // 0 unset, -1 waiting to be set, 1 set
  bool locked_;
  int nDeleteNode_;
  CbcNode **delNode_;
  int maxDeleteNode_;
  int nodesThisTime_;
  int iterationsThisTime_;
  int deterministic_;
#ifdef THREAD_DEBUG
public:
  int threadNumber_;
  int lockCount_;
#endif
};
class CbcBaseModel {
public:
  // Default Constructor
  CbcBaseModel();
 
  CbcBaseModel(CbcModel &model, int type);
 
  virtual ~CbcBaseModel();
 
  void stopThreads(int type);
 
  int waitForThreadsInTree(int type);
 
  void waitForThreadsInCuts(int type, OsiCuts *eachCuts, int whichGenerator);
 
  void deterministicParallel();
  inline void lockThread()
  {
    children_[numberThreads_].lockThread();
  }
  inline void unlockThread()
  {
    children_[numberThreads_].unlockThread();
  }
 
  inline bool isLocked() const
  {
    return children_[numberThreads_].locked();
  }
 
  CbcThread *masterThread() const;
 
  inline CbcModel *model(int i) const
  {
    return threadModel_[i];
  }
 
  inline CbcThread *child(int thread) const
  {
    return children_ + thread;
  }
 
  inline int numberThreads() const
  {
    return numberThreads_;
  }
 
  void setDantzigState();
 
private:
  int numberThreads_;
  CbcThread *children_;
  int type_;
  int *threadCount_;
  CbcModel **threadModel_;
  int numberObjects_;
  OsiObject **saveObjects_;
  int threadStats_[6];
  int defaultParallelIterations_;
  int defaultParallelNodes_;
};
#else
// Dummy threads
class CbcThread {
public:
  // Default Constructor
  CbcThread() {}
 
  virtual ~CbcThread() {}
};
class CbcBaseModel {
public:
  // Default Constructor (not declared here so that CbcThread.cpp not empty)
  CbcBaseModel();
 
  virtual ~CbcBaseModel() {}
};
#endif
 
#endif
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/