00001 #include "otsdaq-core/DataManager/DataManager.h"
00002 #include "otsdaq-core/DataManager/CircularBuffer.h"
00003 #include "otsdaq-core/DataManager/DataProducer.h"
00004 #include "otsdaq-core/DataManager/DataConsumer.h"
00005 #include "otsdaq-core/MessageFacility/MessageFacility.h"
00006 #include "otsdaq-core/Macros/CoutHeaderMacros.h"
00007 #include "otsdaq-core/PluginMakers/MakeDataProcessor.h"
00008 #include "otsdaq-core/ConfigurationInterface/ConfigurationManager.h"
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #include <iostream>
00027 #include <vector>
00028 #include <unistd.h>
00029
00030 using namespace ots;
00031
00032
00033 DataManager::DataManager(const ConfigurationTree& theXDAQContextConfigTree, const std::string& supervisorConfigurationPath)
00034 : Configurable(theXDAQContextConfigTree, supervisorConfigurationPath)
00035 {}
00036
00037
00038 DataManager::~DataManager(void)
00039 {
00040 eraseAllBuffers();
00041 }
00042
00043
00044 void DataManager::configure(void)
00045 {
00046 eraseAllBuffers();
00047
00048 for(const auto& buffer: theXDAQContextConfigTree_.getNode(theConfigurationPath_+"/LinkToDataManagerConfiguration").getChildren())
00049 {
00050 __MOUT__ << "Data Buffer Name: "<< buffer.first << std::endl;
00051 if(buffer.second.getNode("Status").getValue<bool>())
00052 {
00053 std::vector<unsigned int> producersVectorLocation;
00054 std::vector<unsigned int> consumersVectorLocation;
00055 auto bufferConfigurationList = buffer.second.getNode("LinkToDataBufferConfiguration").getChildren();
00056 unsigned int location = 0;
00057 for(const auto& bufferConfiguration: bufferConfigurationList)
00058 {
00059 __MOUT__ << "Processor id: " << bufferConfiguration.first << std::endl;
00060 if(bufferConfiguration.second.getNode("Status").getValue<bool>())
00061 {
00062 if(bufferConfiguration.second.getNode("ProcessorType").getValue<std::string>() == "Producer")
00063 {
00064 producersVectorLocation.push_back(location);
00065 }
00066 else if(bufferConfiguration.second.getNode("ProcessorType").getValue<std::string>() == "Consumer")
00067 {
00068 consumersVectorLocation.push_back(location);
00069 }
00070 else
00071 {
00072 __SS__ << "Node ProcessorType in "
00073 << bufferConfiguration.first
00074 << " of type "
00075 << bufferConfiguration.second.getNode("ProcessorType").getValue<std::string>()
00076 << " is invalid. The only accepted types are Producer and Consumer" << std::endl;
00077 throw std::runtime_error(ss.str());
00078 }
00079 }
00080 ++location;
00081
00082 }
00083
00084 if(producersVectorLocation.size() == 0)
00085 {
00086 __SS__ << "Node Data Buffer "
00087 << buffer.first
00088 << " has " << producersVectorLocation.size() << " Producers"
00089 << " and " << consumersVectorLocation.size() << " Consumers"
00090 << " there must be at least 1 Producer " <<
00091 "for the buffer!" << std::endl;
00092 throw std::runtime_error(ss.str());
00093
00094 }
00095
00096 configureBuffer<std::string,std::map<std::string,std::string>>(buffer.first);
00097 for(auto& producerLocation: producersVectorLocation)
00098 {
00099
00100
00101 __MOUT__ << bufferConfigurationList[producerLocation].first << std::endl;
00102
00103
00104
00105
00106 buffers_[buffer.first].producers_.push_back( std::shared_ptr<DataProducer>(dynamic_cast<DataProducer*>(
00107 makeDataProcessor
00108 (
00109 bufferConfigurationList[producerLocation].second.getNode("ProcessorPluginName").getValue<std::string>()
00110 , theXDAQContextConfigTree_.getBackNode(theConfigurationPath_).getNode("ApplicationUID").getValue<std::string>()
00111 , buffer.first
00112 , bufferConfigurationList[producerLocation].first
00113 , theXDAQContextConfigTree_
00114 , theConfigurationPath_ + "/LinkToDataManagerConfiguration/" + buffer.first + "/LinkToDataBufferConfiguration/" + bufferConfigurationList[producerLocation].first + "/LinkToProcessorConfiguration"
00115 ))));
00116 __MOUT__ << bufferConfigurationList[producerLocation].first << " has been created!" << std::endl;
00117 }
00118 for(auto& consumerLocation: consumersVectorLocation)
00119 {
00120
00121
00122 __MOUT__ << bufferConfigurationList[consumerLocation].first << std::endl;
00123
00124
00125
00126
00127
00128 buffers_[buffer.first].consumers_.push_back( std::shared_ptr<DataConsumer>(dynamic_cast<DataConsumer*>(
00129 makeDataProcessor
00130 (
00131 bufferConfigurationList[consumerLocation].second.getNode("ProcessorPluginName").getValue<std::string>()
00132 , theXDAQContextConfigTree_.getBackNode(theConfigurationPath_).getNode("ApplicationUID").getValue<std::string>()
00133 , buffer.first
00134 , bufferConfigurationList[consumerLocation].first
00135 , theXDAQContextConfigTree_
00136 , theConfigurationPath_ + "/LinkToDataManagerConfiguration/" + buffer.first + "/LinkToDataBufferConfiguration/" + bufferConfigurationList[consumerLocation].first + "/LinkToProcessorConfiguration"
00137 ))));
00138 __MOUT__ << bufferConfigurationList[consumerLocation].first << " has been created!" << std::endl;
00139 }
00140 }
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150 }
00151
00152
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215 }
00216
00217
00218 void DataManager::halt(void)
00219 {
00220 stop();
00221 DataManager::eraseAllBuffers();
00222 }
00223
00224
00225 void DataManager::pause(void)
00226 {
00227 DataManager::pauseAllBuffers();
00228 }
00229
00230
00231 void DataManager::resume(void)
00232 {
00233 DataManager::resumeAllBuffers();
00234 }
00235
00236 void DataManager::start(std::string runNumber)
00237 {
00238 DataManager::startAllBuffers(runNumber);
00239 }
00240
00241
00242 void DataManager::stop()
00243 {
00244 DataManager::stopAllBuffers();
00245 }
00246
00247
00248 void DataManager::eraseAllBuffers(void)
00249 {
00250 for(auto& it: buffers_)
00251 deleteBuffer(it.first);
00252
00253 buffers_.clear();
00254 }
00255
00256
00257 void DataManager::eraseBuffer(std::string bufferUID)
00258 {
00259 if(deleteBuffer(bufferUID))
00260 buffers_.erase(bufferUID);
00261 }
00262
00263
00264 bool DataManager::unregisterConsumer(std::string consumerID)
00265 {
00266 for(auto it=buffers_.begin(); it!=buffers_.end(); it++)
00267 for(auto& itc: it->second.consumers_)
00268 {
00269 if(itc->getProcessorID() == consumerID)
00270 {
00271 it->second.buffer_->unregisterConsumer(itc.get());
00272 return true;
00273 }
00274 }
00275
00276 return false;
00277 }
00278
00279
00280 bool DataManager::deleteBuffer(std::string bufferUID)
00281 {
00282 auto it = buffers_.find(bufferUID);
00283 if(it != buffers_.end())
00284 {
00285 auto aBuffer = it->second;
00286 if(aBuffer.status_ == Running)
00287 stopBuffer(bufferUID);
00288
00289 for(auto& itc: aBuffer.consumers_)
00290 {
00291 aBuffer.buffer_->unregisterConsumer(itc.get());
00292
00293 }
00294 aBuffer.consumers_.clear();
00295
00296
00297 aBuffer.producers_.clear();
00298
00299 delete aBuffer.buffer_;
00300 return true;
00301 }
00302 return false;
00303 }
00304
00305
00306 void DataManager::registerProducer(std::string bufferUID, DataProducer* producer)
00307 {
00308 buffers_[bufferUID].buffer_->registerProducer(producer, producer->getBufferSize());
00309 }
00310
00311
00312 void DataManager::registerConsumer(std::string bufferUID, DataConsumer* consumer, bool registerToBuffer)
00313 {
00314 if(registerToBuffer)
00315 if(buffers_.find(bufferUID) == buffers_.end())
00316 throw std::runtime_error("Can't find buffer UID: " + bufferUID + ". Make sure that your configuration is correct!");
00317 buffers_[bufferUID].buffer_->registerConsumer(consumer);
00318 }
00319
00320
00321
00322
00323
00324
00325
00326
00327 void DataManager::startAllBuffers(std::string runNumber)
00328 {
00329 for(auto it=buffers_.begin(); it!=buffers_.end(); it++)
00330 startBuffer(it->first, runNumber);
00331 }
00332
00333
00334 void DataManager::stopAllBuffers (void)
00335 {
00336 for(auto it=buffers_.begin(); it!=buffers_.end(); it++)
00337 stopBuffer(it->first);
00338 }
00339
00340
00341 void DataManager::resumeAllBuffers(void)
00342 {
00343 for(auto it=buffers_.begin(); it!=buffers_.end(); it++)
00344 resumeBuffer(it->first);
00345 }
00346
00347
00348 void DataManager::pauseAllBuffers (void)
00349 {
00350 for(auto it=buffers_.begin(); it!=buffers_.end(); it++)
00351 pauseBuffer(it->first);
00352 }
00353
00354
00355 void DataManager::startBuffer(std::string bufferUID, std::string runNumber)
00356 {
00357 buffers_[bufferUID].buffer_->reset();
00358 for(auto& it: buffers_[bufferUID].consumers_)
00359 it->startProcessingData(runNumber);
00360 for(auto& it: buffers_[bufferUID].producers_)
00361 it->startProcessingData(runNumber);
00362 buffers_[bufferUID].status_ = Running;
00363 }
00364
00365
00366 void DataManager::stopBuffer(std::string bufferUID)
00367 {
00368 for(auto& it: buffers_[bufferUID].producers_)
00369 it->stopProcessingData();
00370
00371
00372 unsigned int timeOut = 0;
00373 const unsigned int ratio = 100;
00374 const unsigned int sleepTime = 1000*ratio;
00375 unsigned int totalSleepTime = sleepTime/ratio*buffers_[bufferUID].buffer_->getNumberOfBuffers();
00376 if(totalSleepTime < 5000000)
00377 totalSleepTime = 5000000;
00378 while(!buffers_[bufferUID].buffer_->isEmpty())
00379 {
00380 usleep(sleepTime);
00381 timeOut += sleepTime;
00382 if(timeOut > totalSleepTime)
00383 {
00384 std::cout << "Couldn't flush all buffers! Timing out after " << totalSleepTime/1000000. << " seconds!" << std::endl;
00385 buffers_[bufferUID].buffer_->isEmpty();
00386 break;
00387 }
00388 }
00389 std::cout << "Stopping consumers, buffer MUST BE EMPTY. Is buffer empty? "<< buffers_[bufferUID].buffer_->isEmpty() << std::endl;
00390 for(auto& it: buffers_[bufferUID].consumers_)
00391 it->stopProcessingData();
00392 buffers_[bufferUID].buffer_->reset();
00393 buffers_[bufferUID].status_ = Initialized;
00394 }
00395
00396
00397 void DataManager::resumeBuffer(std::string bufferUID)
00398 {
00399 for(auto& it: buffers_[bufferUID].consumers_)
00400 it->resumeProcessingData();
00401 for(auto& it: buffers_[bufferUID].producers_)
00402 it->resumeProcessingData();
00403 buffers_[bufferUID].status_ = Running;
00404 }
00405
00406
00407 void DataManager::pauseBuffer(std::string bufferUID)
00408 {
00409 for(auto& it: buffers_[bufferUID].producers_)
00410 it->pauseProcessingData();
00411
00412 unsigned int timeOut = 0;
00413 const unsigned int sleepTime = 1000;
00414 while(!buffers_[bufferUID].buffer_->isEmpty())
00415 {
00416 usleep(sleepTime);
00417 timeOut += sleepTime;
00418 if(timeOut > sleepTime*buffers_[bufferUID].buffer_->getNumberOfBuffers())
00419 {
00420 std::cout << "Couldn't flush all buffers! Timing out after " << buffers_[bufferUID].buffer_->getNumberOfBuffers()*sleepTime/1000000. << " seconds!" << std::endl;
00421 break;
00422 }
00423 }
00424 for(auto& it: buffers_[bufferUID].consumers_)
00425 it->pauseProcessingData();
00426 buffers_[bufferUID].status_ = Initialized;
00427 }