ThreadPauser.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  ThreadPauser.h Structure allowing a thread to pause another
  Copyright (C) 2014 The Regents of the University of New Mexico.  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 2.1 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 General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef THREAD_PAUSER_H
#define THREAD_PAUSER_H

#include "Mutex.h"
#include "Logger.h"

namespace MFM
{
  enum ThreadState
  {
    THREADSTATE_PAUSED,

    THREADSTATE_RUN_REQUESTED,

    THREADSTATE_RUN_READY,

    THREADSTATE_RUNNING,

    THREADSTATE_PAUSE_REQUESTED,

    THREADSTATE_PAUSE_READY

  };

  class ThreadPauser
  {
   private:

    Mutex m_mutex;

    ThreadState m_threadState;

    ThreadState m_threadStatePrevious;

    bool m_threadStatePreviousOuter;

    pthread_t m_threadStatePreviousThreadId;

    bool m_ignoreThreadingProblems;

    struct StateIsRunRequested : public Mutex::Predicate
    {
      ThreadPauser & m_threadPauser;
      StateIsRunRequested(ThreadPauser & tp) :
        Predicate(tp.m_mutex),
        m_threadPauser(tp)
      { }

      virtual bool EvaluatePrecondition()
      {
        bool ret = m_threadPauser.m_threadState == THREADSTATE_PAUSED;
        if (!ret)
        {
          LOG.Error("PAUSED precondition failed");
          m_threadPauser.ReportThreadPauserStatus(Logger::ERROR);
        }
        return ret;
      }

      virtual bool EvaluatePredicate()
      {
        return m_threadPauser.m_threadState == THREADSTATE_RUN_REQUESTED;
      }
    } m_stateIsRunRequested;

    struct StateIsRunning : public Mutex::Predicate
    {
      ThreadPauser & m_threadPauser;
      StateIsRunning(ThreadPauser & tp) :
        Predicate(tp.m_mutex),
        m_threadPauser(tp)
      { }

      virtual bool EvaluatePrecondition()
      {
        bool ret = m_threadPauser.m_threadState == THREADSTATE_RUN_READY;
        if (!ret)
        {
          LOG.Error("RUN READY precondition failed");
          m_threadPauser.ReportThreadPauserStatus(Logger::ERROR);
        }
        return ret;
      }

      virtual bool EvaluatePredicate()
      {
        return m_threadPauser.m_threadState == THREADSTATE_RUNNING;
      }
    } m_stateIsRunning;

  public:

    ThreadState GetStateBlockingInner()
    {
      return GetAdvanceStateInner(false);
    }

    ThreadState AdvanceStateInner()
    {
      return GetAdvanceStateInner(true);
    }

    ThreadState GetAdvanceStateInner(bool innerReadyToAdvance) ;

    ThreadState GetStateNonblocking() ;

    ThreadState AdvanceStateOuter(ThreadState fromState) ;

    ThreadPauser();

    ~ThreadPauser();

    void RequestPause()
    {
      AdvanceStateOuter(THREADSTATE_RUNNING);
    }

    void SetIgnoreThreadingProblems(bool value)
    {
      m_ignoreThreadingProblems = value;
    }

    void RequestRun()
    {
      AdvanceStateOuter(THREADSTATE_PAUSED);
    }

    void Run()
    {
      AdvanceStateOuter(THREADSTATE_RUN_READY);
    }

    bool IsRunReady()
    {
      return GetStateNonblocking() == THREADSTATE_RUN_READY;
    }

    bool IsPauseReady()
    {
      return GetStateNonblocking() == THREADSTATE_PAUSE_READY;
    }

    void Pause()
    {
      AdvanceStateOuter(THREADSTATE_PAUSE_READY);
    }

    static const char * GetThreadStateName(ThreadState ts) ;

    void ReportThreadPauserStatus(Logger::Level level) ;

#if 0

    bool IsPauseRequested()
    {
      return GetStateNonblocking() == THREADSTATE_PAUSE_REQUESTED;
    }


    bool IsPaused();

    void PauseReady();

    void WaitWhilePaused();

#endif
  };
}

#endif /* THREAD_PAUSER_H */