thread.h

Go to the documentation of this file.

/*  Copyright (C) 2013  Eric Larson and Rochelle Palting
    elarson@seattleu.edu

    This file is part of the MDAT infrastructure.

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program 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 THREAD_H
#define THREAD_H

#include <string>
#include <vector>
#include <deque>
#include <pthread.h>
using namespace std;

class ThreadManager
{
  public:

    void init(int numThreads, bool useInteractive, bool useSeed, unsigned int seed);

    void startThread(int id, string property);

    bool finishThread();

    void invokeScheduler(int location = -1);

    void markWaitingOnLock(int id, string name);
        
    void markWaitingOnSem(int id, string name);
      
    int wakeupThread(deque<int> &waiting);

    void updateSection(string section);

    int getCurrThreadId() const;

    string getThreadProperty(int id) const;

    string getThreadTable() const;

  private:

    /* Thread state */
    enum ThreadState {
      UNKNOWN,          // Status is unknown / unitialized
      READY,            // Ready to run but not currently running
      WAITING_LOCK,     // Waiting for a lock
      WAITING_SEM,      // Waiting for a semaphore
      RUNNING,          // Currently running
      COMPLETED         // Thread has commpleted execution
    };

    /* Thread data type */
    struct Thread {
      pthread_t threadId;       // thread id
      string property;          // thread property
      ThreadState status;       // status of a thread
      int location;             // current location in program
      string section;           // current section in program
      string waitingOn;         // name of lock or semaphore thread is waiting on
    };

    int threadCount;            // number of threads
    vector<Thread> threadArray; // array of threads
    int numAddedThreads;        // number of added threads
    bool allThreadsAdded;       // set to true when all threads have been added
    pthread_mutex_t initLock;   // lock to prevent race conditions at startup
    int numThreadsCompleted;    // number of finished threads
    bool interactiveMode;       // set if interactive mode is used
    deque<int> ready;           // ready queue
    int initialThread;          // initial thread to start running
    int currThreadId;           // thread that is currently running

    /* Pauses thread until a signal is received to wake it up. */
    void pauseThread(int id);

    /* Blocks the SIGUSR1 signal so it is not received prematurely before
     * sigwait is called.
     */
    void blockSignal();

    /* Selects a thread from the queue based on the scheduler mode. */
    int selectThread(deque<int> &queue, string message);

    /* Returns state of a thread in a string. */
    string getThreadState(ThreadState state) const;
};

extern ThreadManager threads;

#endif