Mercurial > hg > orthanc-stone
annotate Platforms/Generic/Oracle.cpp @ 87:4a541cd4fa83 wasm
OrthancVolumeImageLoader
| author | Sebastien Jodogne <s.jodogne@gmail.com> |
|---|---|
| date | Fri, 26 May 2017 15:31:58 +0200 |
| parents | 02c3a7a4938f |
| children | f244018a4e4b |
| rev | line source |
|---|---|
| 80 | 1 /** |
| 2 * Stone of Orthanc | |
| 3 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics | |
| 4 * Department, University Hospital of Liege, Belgium | |
| 5 * Copyright (C) 2017 Osimis, Belgium | |
| 6 * | |
| 7 * This program is free software: you can redistribute it and/or | |
| 8 * modify it under the terms of the GNU Affero General Public License | |
| 9 * as published by the Free Software Foundation, either version 3 of | |
| 10 * the License, or (at your option) any later version. | |
| 11 * | |
| 12 * This program is distributed in the hope that it will be useful, but | |
| 13 * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| 15 * Affero General Public License for more details. | |
| 16 * | |
| 17 * You should have received a copy of the GNU Affero General Public License | |
| 18 * along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| 19 **/ | |
| 20 | |
| 21 | |
| 22 #include "Oracle.h" | |
| 23 | |
| 24 #include "../../Resources/Orthanc/Core/Logging.h" | |
| 25 #include "../../Resources/Orthanc/Core/MultiThreading/SharedMessageQueue.h" | |
| 26 #include "../../Resources/Orthanc/Core/OrthancException.h" | |
| 27 | |
| 28 #include <vector> | |
| 29 | |
| 30 namespace OrthancStone | |
| 31 { | |
| 32 class Oracle::PImpl | |
| 33 { | |
| 34 private: | |
| 35 enum State | |
| 36 { | |
| 37 State_Init, | |
| 38 State_Started, | |
| 39 State_Stopped | |
| 40 }; | |
| 41 | |
| 42 boost::mutex* globalMutex_; | |
| 43 boost::mutex oracleMutex_; | |
| 44 State state_; | |
| 45 std::vector<boost::thread*> threads_; | |
| 46 Orthanc::SharedMessageQueue queue_; | |
| 47 | |
| 48 static void Worker(PImpl* that) | |
| 49 { | |
| 50 for (;;) | |
| 51 { | |
| 52 State state; | |
| 53 | |
| 54 { | |
| 55 boost::mutex::scoped_lock lock(that->oracleMutex_); | |
| 56 state = that->state_; | |
| 57 } | |
| 58 | |
| 59 if (state == State_Stopped) | |
| 60 { | |
| 61 break; | |
| 62 } | |
| 63 | |
| 64 std::auto_ptr<Orthanc::IDynamicObject> item(that->queue_.Dequeue(100)); | |
| 65 if (item.get() != NULL) | |
| 66 { | |
| 67 IOracleCommand& command = dynamic_cast<IOracleCommand&>(*item); | |
| 68 command.Execute(); | |
| 69 | |
| 70 if (that->globalMutex_ != NULL) | |
| 71 { | |
| 72 boost::mutex::scoped_lock lock(*that->globalMutex_); | |
| 73 command.Commit(); | |
| 74 } | |
| 75 else | |
| 76 { | |
| 77 command.Commit(); | |
| 78 } | |
| 79 } | |
| 80 } | |
| 81 } | |
| 82 | |
| 83 public: | |
| 84 PImpl(boost::mutex* globalMutex, | |
| 85 unsigned int threadCount) : | |
| 86 globalMutex_(globalMutex), | |
| 87 state_(State_Init), | |
| 88 threads_(threadCount) | |
| 89 { | |
| 90 } | |
| 91 | |
| 92 ~PImpl() | |
| 93 { | |
| 94 if (state_ == State_Started) | |
| 95 { | |
| 96 LOG(ERROR) << "You should have manually called Oracle::Stop()"; | |
| 97 Stop(); | |
| 98 } | |
| 99 } | |
| 100 | |
|
87
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
101 Orthanc::SharedMessageQueue& GetQueue() |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
102 { |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
103 return queue_; |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
104 } |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
105 |
| 80 | 106 void Submit(IOracleCommand* command) |
| 107 { | |
| 108 std::auto_ptr<IOracleCommand> protection(command); | |
| 109 | |
| 110 if (command == NULL) | |
| 111 { | |
| 112 throw Orthanc::OrthancException(Orthanc::ErrorCode_NullPointer); | |
| 113 } | |
| 114 | |
| 115 boost::mutex::scoped_lock lock(oracleMutex_); | |
| 116 | |
| 117 switch (state_) | |
| 118 { | |
| 119 case State_Init: | |
| 120 case State_Started: | |
| 121 queue_.Enqueue(protection.release()); | |
| 122 break; | |
| 123 | |
| 124 case State_Stopped: | |
| 125 LOG(ERROR) << "Cannot schedule a request to the Oracle after having " | |
| 126 << "called Oracle::Stop()"; | |
| 127 break; | |
| 128 | |
| 129 default: | |
| 130 throw Orthanc::OrthancException(Orthanc::ErrorCode_InternalError); | |
| 131 } | |
| 132 | |
| 133 } | |
| 134 | |
| 135 void Start() | |
| 136 { | |
| 137 boost::mutex::scoped_lock lock(oracleMutex_); | |
| 138 | |
| 139 if (state_ != State_Init) | |
| 140 { | |
| 141 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
| 142 } | |
| 143 | |
| 144 for (size_t i = 0; i < threads_.size(); i++) | |
| 145 { | |
| 146 threads_[i] = new boost::thread(Worker, this); | |
| 147 } | |
| 148 | |
| 149 state_ = State_Started; | |
| 150 } | |
| 151 | |
| 152 void Stop() | |
| 153 { | |
| 154 { | |
| 155 boost::mutex::scoped_lock lock(oracleMutex_); | |
| 156 | |
| 157 if (state_ != State_Started) | |
| 158 { | |
| 159 throw Orthanc::OrthancException(Orthanc::ErrorCode_BadSequenceOfCalls); | |
| 160 } | |
| 161 | |
| 162 state_ = State_Stopped; | |
| 163 } | |
| 164 | |
| 165 for (size_t i = 0; i < threads_.size(); i++) | |
| 166 { | |
| 167 if (threads_[i] != NULL) | |
| 168 { | |
| 169 if (threads_[i]->joinable()) | |
| 170 { | |
| 171 threads_[i]->join(); | |
| 172 } | |
| 173 | |
| 174 delete threads_[i]; | |
| 175 } | |
| 176 } | |
| 177 } | |
| 178 }; | |
| 179 | |
| 180 | |
| 181 Oracle::Oracle(boost::mutex& globalMutex, | |
| 182 unsigned int threadCount) : | |
| 183 pimpl_(new PImpl(&globalMutex, threadCount)) | |
| 184 { | |
| 185 } | |
| 186 | |
| 187 | |
| 188 Oracle::Oracle(unsigned int threadCount) : | |
| 189 pimpl_(new PImpl(NULL, threadCount)) | |
| 190 { | |
| 191 } | |
| 192 | |
| 193 | |
| 194 void Oracle::Start() | |
| 195 { | |
| 196 pimpl_->Start(); | |
| 197 } | |
| 198 | |
| 199 | |
| 200 void Oracle::Submit(IOracleCommand* command) | |
| 201 { | |
| 202 pimpl_->Submit(command); | |
| 203 } | |
| 204 | |
| 205 | |
| 206 void Oracle::Stop() | |
| 207 { | |
| 208 pimpl_->Stop(); | |
| 209 } | |
|
87
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
210 |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
211 |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
212 void Oracle::WaitEmpty() |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
213 { |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
214 pimpl_->GetQueue().WaitEmpty(50); |
|
4a541cd4fa83
OrthancVolumeImageLoader
Sebastien Jodogne <s.jodogne@gmail.com>
parents:
86
diff
changeset
|
215 } |
| 80 | 216 } |