File: BrainModelAlgorithmMultiThreaded.h

package info (click to toggle)
caret 5.6.4~dfsg.1-3
  • links: PTS, VCS
  • area: main
  • in suites: jessie, jessie-kfreebsd, wheezy
  • size: 31,904 kB
  • ctags: 28,901
  • sloc: cpp: 378,050; python: 6,718; ansic: 5,507; makefile: 333; sh: 46
file content (134 lines) | stat: -rw-r--r-- 4,482 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*LICENSE_START*/
/*
 *  Copyright 1995-2002 Washington University School of Medicine
 *
 *  http://brainmap.wustl.edu
 *
 *  This file is part of CARET.
 *
 *  CARET 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 2 of the License, or
 *  (at your option) any later version.
 *
 *  CARET 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 CARET; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*LICENSE_END*/

#ifndef __BRAIN_MODEL_ALGORITHM_MULTI_THREADED_H__
#define __BRAIN_MODEL_ALGORITHM_MULTI_THREADED_H__

#include <QMutex>
#include <QThread>

#include "BrainModelAlgorithm.h"

/// Abstract class for multi-threaded algorithms that work on brain models
class BrainModelAlgorithmMultiThreaded : public BrainModelAlgorithm,
                                         protected QThread {
   public:
      /// get the number of thread to run
      int getNumberOfThreadsToRun() const { return numberOfThreadsToRun; }
      
      /// set the number of thread to run
      void setNumberOfThreadsToRun(const int num) { numberOfThreadsToRun = num; }
      
      /// destructor
      virtual ~BrainModelAlgorithmMultiThreaded();
      
      /// Increment the number of children threads that have started their iterations
      void incrementNumChildThreadStarted();
      
      /// Increment the number of children thread that are done with their iteration.
      void incrementNumChildThreadDone();

   protected:
      //
      // initialize
      //
      
      /// constructor
      BrainModelAlgorithmMultiThreaded(BrainSet* bs,
                              BrainModelAlgorithmMultiThreaded* parentOfThisThreadIn,
                              int threadNumberIn,
                              const bool iAmAThread);
      
      /// get the parent of this thread
      BrainModelAlgorithmMultiThreaded* getParentOfThisThread()
                                                     { return parentOfThisThread; }

      /// get the thread keep looping flag
      bool getThreadKeepLoopingFlag() const { return threadKeepLoopingFlag; }
      
      /// set the thread keep looping flag
      void setThreadKeepLoopingFlag(const bool flag) { threadKeepLoopingFlag = flag; }
      
      /// get the number of this thread
      int getThreadNumber() const { return threadNumber; }
      
      /// Get the number of children threads that have started
      int getNumChildThreadStarted();
      
      /// Reset the number of children thread done (set it to zero).
      void resetNumChildThreadDone();
      
      /// Get the number of children thread that are done with their iteration.
      int getNumChildThreadDone();

      /// Get the threaded iteration done flag
      bool getThreadedIterationDoneFlag();

      /// Set the threaded iteration done flag
      void setThreadedIterationDoneFlag(const bool flag);

      /// see if i'm a thread instance
      bool getImAThread() const { return threadFlag; }
      
private:      
      /// number of threads to run
      int numberOfThreadsToRun;

      /// thread flag (set if this instance is run as a thread)
      bool threadFlag;
      
      /// mutex for accessing number of children thread started
      QMutex mutexNumChildThreadStarted;
      
      /// number of children threads started
      int numChildThreadStarted;

      /// number of children thread done
      int numChildThreadDone;
      
      /// mutex for accessing number of children thread done
      QMutex mutexNumChildThreadDone;
      
      /// threaded iteration done flag
      bool threadedIterationDoneFlag;
      
      /// mutex for accessing the threaded iteration done flag
      QMutex mutexThreadedIterationDoneFlag;

      /// number of this thread
      int threadNumber;
      
      /// used to remain in run() when running as a thread
      bool threadKeepLoopingFlag;
      
      /// parent of this thread
      BrainModelAlgorithmMultiThreaded* parentOfThisThread;
      
      
      
};

#endif // __BRAIN_MODEL_ALGORITHM_MULTI_THREADED_H__