detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-05-12 23:42:12 +02:00
Code Issues Actions Packages Releases Activity

Merge branch 'shm' into refactor

Browse Source
This commit is contained in:
maliakal_d 2019-03-13 15:21:12 +01:00
commit 75ce111344
11 changed files with 1230 additions and 1137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
integrationTests/src/a.cpp
View File

@ -10,42 +10,12 @@
#include "sls_detector_funcs.h" #include "sls_detector_funcs.h"
#include <iostream> #include <iostream>
#include <vector> #include <vector>
#define VERBOSE #define VERBOSE
int main() { int main() {
// const std::string hostname = "beb083";
// auto d = slsDetector(hostname);
// d.setOnline(1);
// std::cout << "type: " << d.getDetectorTypeAsString() << '\n';
// std::cout << "hostname: " << d.getHostname() << '\n';
// std::cout << "receiver: " << d.getReceiverOnline() << '\n';
// std::cout << "control: " << d.getControlPort() << '\n';
// std::cout << "stop: " << d.getStopPort() << '\n';
// std::cout << "receiver: " << d.getReceiverPort() << '\n';
// std::cout << "exptime: " << d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) << '\n';
// auto d2 = slsDetector(type, 0, 1);
// d2.setHostname("beb098");.
// auto d2 = slsDetector();
// std::cout << "hn: " << d2.getHostname() << '\n';
// sls::Timer t;
// for (int i = 0; i != 100; ++i) {
// int fnum = 1;
// int ret = slsDetectorDefs::FAIL;
// slsDetectorDefs::detectorType retval = slsDetectorDefs::detectorType::GENERIC;
// auto cs = sls::ClientSocket("beb083", 1952);
// cs.sendData(reinterpret_cast<char *>(&fnum), sizeof(fnum));
// cs.receiveData(reinterpret_cast<char *>(&ret), sizeof(ret));
// cs.receiveData(reinterpret_cast<char *>(&retval), sizeof(retval));
// std::cout << "retval: " << retval << '\n';
// }
// t.print_elapsed();
return 0; return 0;
} }

6
slsDetectorSoftware/CMakeLists.txt
View File

@ -1,6 +1,6 @@
set(SOURCES set(SOURCES
multiSlsDetector/multiSlsDetector.cpp multiSlsDetector/multiSlsDetector.cpp
sharedMemory/SharedMemory.cpp # sharedMemory/SharedMemory.cpp
slsDetector/slsDetectorUsers.cpp slsDetector/slsDetectorUsers.cpp
slsDetector/slsDetectorCommand.cpp slsDetector/slsDetectorCommand.cpp
slsDetector/slsDetector.cpp slsDetector/slsDetector.cpp
@ -49,6 +49,10 @@ if(DOXYGEN_FOUND)
) )
endif() endif()
if (SLS_USE_TESTS)
add_subdirectory(tests)
endif(SLS_USE_TESTS)
install(TARGETS slsDetectorShared install(TARGETS slsDetectorShared
EXPORT "${TARGETS_EXPORT_NAME}" EXPORT "${TARGETS_EXPORT_NAME}"

315
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp
View File

@ -31,12 +31,7 @@ multiSlsDetector::multiSlsDetector(int id, bool verify, bool update)
setupMultiDetector(verify, update); setupMultiDetector(verify, update);
} }
multiSlsDetector::~multiSlsDetector() { multiSlsDetector::~multiSlsDetector() = default;
if (sharedMemory) {
sharedMemory->UnmapSharedMemory(thisMultiDetector);
delete sharedMemory;
}
}
void multiSlsDetector::setupMultiDetector(bool verify, bool update) { void multiSlsDetector::setupMultiDetector(bool verify, bool update) {
initSharedMemory(verify); initSharedMemory(verify);
@ -197,21 +192,21 @@ void multiSlsDetector::setErrorMaskFromAllDetectors() {
} }
void multiSlsDetector::setAcquiringFlag(bool b) { void multiSlsDetector::setAcquiringFlag(bool b) {
thisMultiDetector->acquiringFlag = b; sharedMemory()->acquiringFlag = b;
} }
bool multiSlsDetector::getAcquiringFlag() const { bool multiSlsDetector::getAcquiringFlag() const {
return thisMultiDetector->acquiringFlag; return sharedMemory()->acquiringFlag;
} }
bool multiSlsDetector::isAcquireReady() { bool multiSlsDetector::isAcquireReady() {
if (thisMultiDetector->acquiringFlag) { if (sharedMemory()->acquiringFlag) {
FILE_LOG(logWARNING) << "Acquire has already started. " FILE_LOG(logWARNING) << "Acquire has already started. "
"If previous acquisition terminated unexpectedly, " "If previous acquisition terminated unexpectedly, "
"reset busy flag to restart.(sls_detector_put busy 0)"; "reset busy flag to restart.(sls_detector_put busy 0)";
return FAIL; return FAIL;
} }
thisMultiDetector->acquiringFlag = true; sharedMemory()->acquiringFlag = true;
return OK; return OK;
} }
@ -249,23 +244,18 @@ void multiSlsDetector::freeSharedMemory(int multiId, int detPos) {
return; return;
} }
// multi // multi - get number of detectors from shm
// get number of detectors SharedMemory<sharedMultiSlsDetector> multiShm(multiId, -1);
int numDetectors = 0; int numDetectors = 0;
auto shm = SharedMemory(multiId, -1);
// get number of detectors from multi shm if (multiShm.IsExisting()) {
if (shm.IsExisting()) { multiShm.OpenSharedMemory();
sharedMultiSlsDetector *mdet = numDetectors = multiShm()->numberOfDetectors;
(sharedMultiSlsDetector *)shm.OpenSharedMemory( multiShm.RemoveSharedMemory();
sizeof(sharedMultiSlsDetector));
numDetectors = mdet->numberOfDetectors;
shm.UnmapSharedMemory(mdet);
shm.RemoveSharedMemory();
} }
for (int i = 0; i < numDetectors; ++i) { for (int i = 0; i < numDetectors; ++i) {
auto shm = SharedMemory(multiId, i); SharedMemory<sharedSlsDetector> shm(multiId, i);
shm.RemoveSharedMemory(); shm.RemoveSharedMemory();
} }
} }
@ -286,17 +276,7 @@ void multiSlsDetector::freeSharedMemory(int detPos) {
detectors.clear(); detectors.clear();
// clear multi detector shm // clear multi detector shm
if (sharedMemory) { sharedMemory.RemoveSharedMemory();
if (thisMultiDetector) {
sharedMemory->UnmapSharedMemory(thisMultiDetector);
thisMultiDetector = nullptr;
}
sharedMemory->RemoveSharedMemory();
delete sharedMemory;
sharedMemory = nullptr;
}
// zmq
client_downstream = false; client_downstream = false;
} }
@ -312,78 +292,56 @@ std::string multiSlsDetector::getUserDetails() {
sstream << d->getDetectorTypeAsString() << "+"; sstream << d->getDetectorTypeAsString() << "+";
} }
sstream << "\nPID: " << thisMultiDetector->lastPID sstream << "\nPID: " << sharedMemory()->lastPID
<< "\nUser: " << thisMultiDetector->lastUser << "\nUser: " << sharedMemory()->lastUser
<< "\nDate: " << thisMultiDetector->lastDate << std::endl; << "\nDate: " << sharedMemory()->lastDate << std::endl;
return sstream.str(); return sstream.str();
} }
/* /*
* pre: sharedMemory=0, thisMultiDetector = 0, detectors.size() = 0 * pre: sharedMemory=0, sharedMemory() = 0, detectors.size() = 0
* exceptions are caught in calling function, shm unmapped and deleted
*/ */
void multiSlsDetector::initSharedMemory(bool verify) { void multiSlsDetector::initSharedMemory(bool verify) {
try { sharedMemory = SharedMemory<sharedMultiSlsDetector>(detId, -1);
// shared memory object with name if (!sharedMemory.IsExisting()) {
sharedMemory = new SharedMemory(detId, -1); sharedMemory.CreateSharedMemory();
size_t sz = sizeof(sharedMultiSlsDetector);
// create
if (!sharedMemory->IsExisting()) {
thisMultiDetector =
(sharedMultiSlsDetector *)sharedMemory->CreateSharedMemory(sz);
initializeDetectorStructure(); initializeDetectorStructure();
} }
// open and verify version
else { else {
thisMultiDetector = sharedMemory.OpenSharedMemory();
(sharedMultiSlsDetector *)sharedMemory->OpenSharedMemory(sz); if (verify && sharedMemory()->shmversion != MULTI_SHMVERSION) {
if (verify && thisMultiDetector->shmversion != MULTI_SHMVERSION) {
FILE_LOG(logERROR) << "Multi shared memory (" << detId << ") version mismatch " FILE_LOG(logERROR) << "Multi shared memory (" << detId << ") version mismatch "
"(expected 0x" "(expected 0x"
<< std::hex << MULTI_SHMVERSION << " but got 0x" << thisMultiDetector->shmversion << std::dec; << std::hex << MULTI_SHMVERSION << " but got 0x" << sharedMemory()->shmversion << std::dec;
throw SharedMemoryException(); throw SharedMemoryException();
} }
} }
} catch (...) {
if (sharedMemory) {
// unmap
if (thisMultiDetector) {
sharedMemory->UnmapSharedMemory(thisMultiDetector);
thisMultiDetector = nullptr;
}
// delete
delete sharedMemory;
sharedMemory = nullptr;
}
throw;
}
} }
void multiSlsDetector::initializeDetectorStructure() { void multiSlsDetector::initializeDetectorStructure() {
thisMultiDetector->shmversion = MULTI_SHMVERSION; sharedMemory()->shmversion = MULTI_SHMVERSION;
thisMultiDetector->numberOfDetectors = 0; sharedMemory()->numberOfDetectors = 0;
thisMultiDetector->numberOfDetector[X] = 0; sharedMemory()->numberOfDetector[X] = 0;
thisMultiDetector->numberOfDetector[Y] = 0; sharedMemory()->numberOfDetector[Y] = 0;
thisMultiDetector->onlineFlag = 1; sharedMemory()->onlineFlag = 1;
thisMultiDetector->stoppedFlag = 0; sharedMemory()->stoppedFlag = 0;
thisMultiDetector->dataBytes = 0; sharedMemory()->dataBytes = 0;
thisMultiDetector->dataBytesInclGapPixels = 0; sharedMemory()->dataBytesInclGapPixels = 0;
thisMultiDetector->numberOfChannels = 0; sharedMemory()->numberOfChannels = 0;
thisMultiDetector->numberOfChannel[X] = 0; sharedMemory()->numberOfChannel[X] = 0;
thisMultiDetector->numberOfChannel[Y] = 0; sharedMemory()->numberOfChannel[Y] = 0;
thisMultiDetector->numberOfChannelInclGapPixels[X] = 0; sharedMemory()->numberOfChannelInclGapPixels[X] = 0;
thisMultiDetector->numberOfChannelInclGapPixels[Y] = 0; sharedMemory()->numberOfChannelInclGapPixels[Y] = 0;
thisMultiDetector->maxNumberOfChannelsPerDetector[X] = 0; sharedMemory()->maxNumberOfChannelsPerDetector[X] = 0;
thisMultiDetector->maxNumberOfChannelsPerDetector[Y] = 0; sharedMemory()->maxNumberOfChannelsPerDetector[Y] = 0;
for (int64_t &i : thisMultiDetector->timerValue) { for (int64_t &i : sharedMemory()->timerValue) {
i = 0; i = 0;
} }
thisMultiDetector->acquiringFlag = false; sharedMemory()->acquiringFlag = false;
thisMultiDetector->receiverOnlineFlag = OFFLINE_FLAG; sharedMemory()->receiverOnlineFlag = OFFLINE_FLAG;
thisMultiDetector->receiver_upstream = false; sharedMemory()->receiver_upstream = false;
} }
void multiSlsDetector::initializeMembers(bool verify) { void multiSlsDetector::initializeMembers(bool verify) {
@ -391,7 +349,7 @@ void multiSlsDetector::initializeMembers(bool verify) {
zmqSocket.clear(); zmqSocket.clear();
// get objects from single det shared memory (open) // get objects from single det shared memory (open)
for (int i = 0; i < thisMultiDetector->numberOfDetectors; i++) { for (int i = 0; i < sharedMemory()->numberOfDetectors; i++) {
try { try {
detectors.push_back( detectors.push_back(
sls::make_unique<slsDetector>(detId, i, verify)); sls::make_unique<slsDetector>(detId, i, verify));
@ -406,15 +364,15 @@ void multiSlsDetector::initializeMembers(bool verify) {
} }
void multiSlsDetector::updateUserdetails() { void multiSlsDetector::updateUserdetails() {
thisMultiDetector->lastPID = getpid(); sharedMemory()->lastPID = getpid();
memset(thisMultiDetector->lastUser, 0, SHORT_STRING_LENGTH); memset(sharedMemory()->lastUser, 0, SHORT_STRING_LENGTH);
memset(thisMultiDetector->lastDate, 0, SHORT_STRING_LENGTH); memset(sharedMemory()->lastDate, 0, SHORT_STRING_LENGTH);
try { try {
sls::strcpy_safe(thisMultiDetector->lastUser, exec("whoami").c_str()); sls::strcpy_safe(sharedMemory()->lastUser, exec("whoami").c_str());
sls::strcpy_safe(thisMultiDetector->lastDate, exec("date").c_str()); sls::strcpy_safe(sharedMemory()->lastDate, exec("date").c_str());
} catch (...) { } catch (...) {
sls::strcpy_safe(thisMultiDetector->lastUser, "errorreading"); sls::strcpy_safe(sharedMemory()->lastUser, "errorreading");
sls::strcpy_safe(thisMultiDetector->lastDate, "errorreading"); sls::strcpy_safe(sharedMemory()->lastDate, "errorreading");
} }
} }
@ -450,7 +408,7 @@ void multiSlsDetector::setHostname(const char *name, int detPos) {
// multi // multi
// this check is there only to allow the previous detsizechan command // this check is there only to allow the previous detsizechan command
if (thisMultiDetector->numberOfDetectors) { if (sharedMemory()->numberOfDetectors) {
FILE_LOG(logWARNING) << "There are already detector(s) in shared memory." FILE_LOG(logWARNING) << "There are already detector(s) in shared memory."
"Freeing Shared memory now."; "Freeing Shared memory now.";
freeSharedMemory(); freeSharedMemory();
@ -503,11 +461,11 @@ void multiSlsDetector::addSlsDetector(const std::string &hostname) {
int pos = (int)detectors.size(); int pos = (int)detectors.size();
detectors.push_back(sls::make_unique<slsDetector>(type, detId, pos, false)); detectors.push_back(sls::make_unique<slsDetector>(type, detId, pos, false));
thisMultiDetector->numberOfDetectors = detectors.size(); sharedMemory()->numberOfDetectors = detectors.size();
thisMultiDetector->dataBytes += detectors[pos]->getDataBytes(); sharedMemory()->dataBytes += detectors[pos]->getDataBytes();
thisMultiDetector->dataBytesInclGapPixels += sharedMemory()->dataBytesInclGapPixels +=
detectors[pos]->getDataBytesInclGapPixels(); detectors[pos]->getDataBytesInclGapPixels();
thisMultiDetector->numberOfChannels += sharedMemory()->numberOfChannels +=
detectors[pos]->getTotalNumberOfChannels(); detectors[pos]->getTotalNumberOfChannels();
detectors[pos]->setHostname(hostname); detectors[pos]->setHostname(hostname);
@ -541,12 +499,12 @@ int multiSlsDetector::getNumberOfDetectors() const {
} }
int multiSlsDetector::getNumberOfDetectors(dimension d) const { int multiSlsDetector::getNumberOfDetectors(dimension d) const {
return thisMultiDetector->numberOfDetector[d]; return sharedMemory()->numberOfDetector[d];
} }
void multiSlsDetector::getNumberOfDetectors(int &nx, int &ny) const { void multiSlsDetector::getNumberOfDetectors(int &nx, int &ny) const {
nx = thisMultiDetector->numberOfDetector[X]; nx = sharedMemory()->numberOfDetector[X];
ny = thisMultiDetector->numberOfDetector[Y]; ny = sharedMemory()->numberOfDetector[Y];
} }
int multiSlsDetector::getTotalNumberOfChannels(int detPos) { int multiSlsDetector::getTotalNumberOfChannels(int detPos) {
@ -556,7 +514,7 @@ int multiSlsDetector::getTotalNumberOfChannels(int detPos) {
} }
// multi // multi
return thisMultiDetector->numberOfChannels; return sharedMemory()->numberOfChannels;
} }
int multiSlsDetector::getTotalNumberOfChannels(dimension d, int detPos) { int multiSlsDetector::getTotalNumberOfChannels(dimension d, int detPos) {
@ -566,7 +524,7 @@ int multiSlsDetector::getTotalNumberOfChannels(dimension d, int detPos) {
} }
// multi // multi
return thisMultiDetector->numberOfChannel[d]; return sharedMemory()->numberOfChannel[d];
} }
int multiSlsDetector::getTotalNumberOfChannelsInclGapPixels(dimension d, int multiSlsDetector::getTotalNumberOfChannelsInclGapPixels(dimension d,
@ -577,16 +535,16 @@ int multiSlsDetector::getTotalNumberOfChannelsInclGapPixels(dimension d,
} }
// multi // multi
return thisMultiDetector->numberOfChannelInclGapPixels[d]; return sharedMemory()->numberOfChannelInclGapPixels[d];
} }
int multiSlsDetector::getMaxNumberOfChannelsPerDetector(dimension d) { int multiSlsDetector::getMaxNumberOfChannelsPerDetector(dimension d) {
return thisMultiDetector->maxNumberOfChannelsPerDetector[d]; return sharedMemory()->maxNumberOfChannelsPerDetector[d];
} }
int multiSlsDetector::setMaxNumberOfChannelsPerDetector(dimension d, int i) { int multiSlsDetector::setMaxNumberOfChannelsPerDetector(dimension d, int i) {
thisMultiDetector->maxNumberOfChannelsPerDetector[d] = i; sharedMemory()->maxNumberOfChannelsPerDetector[d] = i;
return thisMultiDetector->maxNumberOfChannelsPerDetector[d]; return sharedMemory()->maxNumberOfChannelsPerDetector[d];
} }
int multiSlsDetector::getDetectorOffset(dimension d, int detPos) { int multiSlsDetector::getDetectorOffset(dimension d, int detPos) {
@ -601,22 +559,22 @@ void multiSlsDetector::updateOffsets() {
FILE_LOG(logDEBUG1) << "Updating Multi-Detector Offsets"; FILE_LOG(logDEBUG1) << "Updating Multi-Detector Offsets";
int offsetX = 0, offsetY = 0, numX = 0, numY = 0; int offsetX = 0, offsetY = 0, numX = 0, numY = 0;
int maxChanX = thisMultiDetector->maxNumberOfChannelsPerDetector[X]; int maxChanX = sharedMemory()->maxNumberOfChannelsPerDetector[X];
int maxChanY = thisMultiDetector->maxNumberOfChannelsPerDetector[Y]; int maxChanY = sharedMemory()->maxNumberOfChannelsPerDetector[Y];
int prevChanX = 0; int prevChanX = 0;
int prevChanY = 0; int prevChanY = 0;
bool firstTime = true; bool firstTime = true;
thisMultiDetector->numberOfChannel[X] = 0; sharedMemory()->numberOfChannel[X] = 0;
thisMultiDetector->numberOfChannel[Y] = 0; sharedMemory()->numberOfChannel[Y] = 0;
thisMultiDetector->numberOfDetector[X] = 0; sharedMemory()->numberOfDetector[X] = 0;
thisMultiDetector->numberOfDetector[Y] = 0; sharedMemory()->numberOfDetector[Y] = 0;
// gap pixels // gap pixels
int offsetX_gp = 0, offsetY_gp = 0, numX_gp = 0, numY_gp = 0; int offsetX_gp = 0, offsetY_gp = 0, numX_gp = 0, numY_gp = 0;
int prevChanX_gp = 0, prevChanY_gp = 0; int prevChanX_gp = 0, prevChanY_gp = 0;
thisMultiDetector->numberOfChannelInclGapPixels[X] = 0; sharedMemory()->numberOfChannelInclGapPixels[X] = 0;
thisMultiDetector->numberOfChannelInclGapPixels[Y] = 0; sharedMemory()->numberOfChannelInclGapPixels[Y] = 0;
for (size_t idet = 0; idet < detectors.size(); ++idet) { for (size_t idet = 0; idet < detectors.size(); ++idet) {
FILE_LOG(logDEBUG1) << "offsetX:" << offsetX << " prevChanX:" << prevChanX << " offsetY:" << offsetY << " prevChanY:" << prevChanY << " offsetX_gp:" << offsetX_gp << " prevChanX_gp:" << prevChanX_gp << " offsetY_gp:" << offsetY_gp << " prevChanY_gp:" << prevChanY_gp; FILE_LOG(logDEBUG1) << "offsetX:" << offsetX << " prevChanX:" << prevChanX << " offsetY:" << offsetY << " prevChanY:" << prevChanY << " offsetX_gp:" << offsetX_gp << " prevChanX_gp:" << prevChanX_gp << " offsetY_gp:" << offsetY_gp << " prevChanY_gp:" << prevChanY_gp;
@ -649,8 +607,8 @@ void multiSlsDetector::updateOffsets() {
detectors[idet]->getTotalNumberOfChannelsInclGapPixels(X); detectors[idet]->getTotalNumberOfChannelsInclGapPixels(X);
numY_gp += numY_gp +=
detectors[idet]->getTotalNumberOfChannelsInclGapPixels(Y); detectors[idet]->getTotalNumberOfChannelsInclGapPixels(Y);
++thisMultiDetector->numberOfDetector[X]; ++sharedMemory()->numberOfDetector[X];
++thisMultiDetector->numberOfDetector[Y]; ++sharedMemory()->numberOfDetector[Y];
FILE_LOG(logDEBUG1) << "incrementing in both direction"; FILE_LOG(logDEBUG1) << "incrementing in both direction";
} }
@ -668,8 +626,8 @@ void multiSlsDetector::updateOffsets() {
numY_gp += numY_gp +=
detectors[idet]->getTotalNumberOfChannelsInclGapPixels(Y); detectors[idet]->getTotalNumberOfChannelsInclGapPixels(Y);
// increment in y again only in the first column (else you double increment) // increment in y again only in the first column (else you double increment)
if (thisMultiDetector->numberOfDetector[X] == 1) if (sharedMemory()->numberOfDetector[X] == 1)
++thisMultiDetector->numberOfDetector[Y]; ++sharedMemory()->numberOfDetector[Y];
FILE_LOG(logDEBUG1) << "incrementing in y direction"; FILE_LOG(logDEBUG1) << "incrementing in y direction";
} }
@ -698,7 +656,7 @@ void multiSlsDetector::updateOffsets() {
numX += detectors[idet]->getTotalNumberOfChannels(X); numX += detectors[idet]->getTotalNumberOfChannels(X);
numX_gp += numX_gp +=
detectors[idet]->getTotalNumberOfChannelsInclGapPixels(X); detectors[idet]->getTotalNumberOfChannelsInclGapPixels(X);
++thisMultiDetector->numberOfDetector[X]; ++sharedMemory()->numberOfDetector[X];
FILE_LOG(logDEBUG1) << "incrementing in x direction"; FILE_LOG(logDEBUG1) << "incrementing in x direction";
} }
@ -716,28 +674,28 @@ void multiSlsDetector::updateOffsets() {
<< detectors[idet]->getDetectorOffset(Y) << ")"; << detectors[idet]->getDetectorOffset(Y) << ")";
// offsetY has been reset sometimes and offsetX the first time, // offsetY has been reset sometimes and offsetX the first time,
// but remember the highest values // but remember the highest values
if (numX > thisMultiDetector->numberOfChannel[X]) { if (numX > sharedMemory()->numberOfChannel[X]) {
thisMultiDetector->numberOfChannel[X] = numX; sharedMemory()->numberOfChannel[X] = numX;
} }
if (numY > thisMultiDetector->numberOfChannel[Y]) { if (numY > sharedMemory()->numberOfChannel[Y]) {
thisMultiDetector->numberOfChannel[Y] = numY; sharedMemory()->numberOfChannel[Y] = numY;
} }
if (numX_gp > thisMultiDetector->numberOfChannelInclGapPixels[X]) { if (numX_gp > sharedMemory()->numberOfChannelInclGapPixels[X]) {
thisMultiDetector->numberOfChannelInclGapPixels[X] = numX_gp; sharedMemory()->numberOfChannelInclGapPixels[X] = numX_gp;
} }
if (numY_gp > thisMultiDetector->numberOfChannelInclGapPixels[Y]) { if (numY_gp > sharedMemory()->numberOfChannelInclGapPixels[Y]) {
thisMultiDetector->numberOfChannelInclGapPixels[Y] = numY_gp; sharedMemory()->numberOfChannelInclGapPixels[Y] = numY_gp;
} }
} }
FILE_LOG(logDEBUG1) << "\n\tNumber of Channels in X direction:" << thisMultiDetector->numberOfChannel[X] << "\n\tNumber of Channels in Y direction:" << thisMultiDetector->numberOfChannel[Y] << "\n\tNumber of Channels in X direction with Gap Pixels:" << thisMultiDetector->numberOfChannelInclGapPixels[X] << "\n\tNumber of Channels in Y direction with Gap Pixels:" << thisMultiDetector->numberOfChannelInclGapPixels[Y]; FILE_LOG(logDEBUG1) << "\n\tNumber of Channels in X direction:" << sharedMemory()->numberOfChannel[X] << "\n\tNumber of Channels in Y direction:" << sharedMemory()->numberOfChannel[Y] << "\n\tNumber of Channels in X direction with Gap Pixels:" << sharedMemory()->numberOfChannelInclGapPixels[X] << "\n\tNumber of Channels in Y direction with Gap Pixels:" << sharedMemory()->numberOfChannelInclGapPixels[Y];
thisMultiDetector->numberOfChannels = sharedMemory()->numberOfChannels =
thisMultiDetector->numberOfChannel[0] * sharedMemory()->numberOfChannel[0] *
thisMultiDetector->numberOfChannel[1]; sharedMemory()->numberOfChannel[1];
for (auto &d : detectors) { for (auto &d : detectors) {
d->updateMultiSize(thisMultiDetector->numberOfDetector[0], d->updateMultiSize(sharedMemory()->numberOfDetector[0],
thisMultiDetector->numberOfDetector[1]); sharedMemory()->numberOfDetector[1]);
} }
} }
@ -750,9 +708,9 @@ int multiSlsDetector::setOnline(int value, int detPos) {
// multi // multi
if (value != GET_ONLINE_FLAG) { if (value != GET_ONLINE_FLAG) {
auto r = parallelCall(&slsDetector::setOnline, value); auto r = parallelCall(&slsDetector::setOnline, value);
thisMultiDetector->onlineFlag = sls::minusOneIfDifferent(r); sharedMemory()->onlineFlag = sls::minusOneIfDifferent(r);
} }
return thisMultiDetector->onlineFlag; return sharedMemory()->onlineFlag;
} }
std::string multiSlsDetector::checkOnline(int detPos) { std::string multiSlsDetector::checkOnline(int detPos) {
@ -1104,12 +1062,12 @@ int multiSlsDetector::stopAcquisition(int detPos) {
if (detPos >= 0) { if (detPos >= 0) {
// if only 1 detector, set flag to stop current acquisition // if only 1 detector, set flag to stop current acquisition
if (detectors.size() == 1) { if (detectors.size() == 1) {
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
} }
return detectors[detPos]->stopAcquisition(); return detectors[detPos]->stopAcquisition();
} else { } else {
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
auto r = parallelCall(&slsDetector::stopAcquisition); auto r = parallelCall(&slsDetector::stopAcquisition);
return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL; return sls::allEqualTo(r, static_cast<int>(OK)) ? OK : FAIL;
} }
@ -1196,7 +1154,7 @@ int64_t multiSlsDetector::setTimer(timerIndex index, int64_t t, int detPos) {
<< "Cannot set number of frames, cycles, " << "Cannot set number of frames, cycles, "
"storage cells or measurements individually."; "storage cells or measurements individually.";
setErrorMask(getErrorMask() | MUST_BE_MULTI_CMD); setErrorMask(getErrorMask() | MUST_BE_MULTI_CMD);
return thisMultiDetector->timerValue[index]; return sharedMemory()->timerValue[index];
default: default:
break; break;
} }
@ -1227,7 +1185,7 @@ int64_t multiSlsDetector::setTimer(timerIndex index, int64_t t, int detPos) {
} }
} }
thisMultiDetector->timerValue[index] = ret; sharedMemory()->timerValue[index] = ret;
return ret; return ret;
} }
@ -1395,16 +1353,16 @@ int multiSlsDetector::setDynamicRange(int dr, int detPos) {
int ret = sls::minusOneIfDifferent(r); int ret = sls::minusOneIfDifferent(r);
// update shm // update shm
int prevValue = thisMultiDetector->dataBytes; int prevValue = sharedMemory()->dataBytes;
int prevGValue = thisMultiDetector->dataBytesInclGapPixels; int prevGValue = sharedMemory()->dataBytesInclGapPixels;
thisMultiDetector->dataBytes = 0; sharedMemory()->dataBytes = 0;
thisMultiDetector->dataBytesInclGapPixels = 0; sharedMemory()->dataBytesInclGapPixels = 0;
thisMultiDetector->numberOfChannels = 0; sharedMemory()->numberOfChannels = 0;
for (auto &d : detectors) { for (auto &d : detectors) {
thisMultiDetector->dataBytes += d->getDataBytes(); sharedMemory()->dataBytes += d->getDataBytes();
thisMultiDetector->dataBytesInclGapPixels += sharedMemory()->dataBytesInclGapPixels +=
d->getDataBytesInclGapPixels(); d->getDataBytesInclGapPixels();
thisMultiDetector->numberOfChannels += d->getTotalNumberOfChannels(); sharedMemory()->numberOfChannels += d->getTotalNumberOfChannels();
} }
// for usability // for usability
@ -1427,8 +1385,8 @@ int multiSlsDetector::setDynamicRange(int dr, int detPos) {
// update offsets if there was a change FIXME:add dr to sls shm and check // update offsets if there was a change FIXME:add dr to sls shm and check
// that instead // that instead
if ((prevValue != thisMultiDetector->dataBytes) || if ((prevValue != sharedMemory()->dataBytes) ||
(prevGValue != thisMultiDetector->dataBytesInclGapPixels)) { (prevGValue != sharedMemory()->dataBytesInclGapPixels)) {
updateOffsets(); updateOffsets();
} }
@ -1955,7 +1913,6 @@ std::string multiSlsDetector::getAdditionalJsonParameter(const std::string &key,
return sls::concatenateIfDifferent(r); return sls::concatenateIfDifferent(r);
} }
int multiSlsDetector::setDetectorMinMaxEnergyThreshold(const int index, int value, int detPos) { int multiSlsDetector::setDetectorMinMaxEnergyThreshold(const int index, int value, int detPos) {
std::string parameter = (index ? "emax" : "emin"); std::string parameter = (index ? "emax" : "emin");
@ -2064,7 +2021,7 @@ int multiSlsDetector::loadImageToDetector(imageType index,
// multi // multi
// read image for all // read image for all
int nch = thisMultiDetector->numberOfChannels; int nch = sharedMemory()->numberOfChannels;
short int imageVals[nch]; short int imageVals[nch];
if (readDataFile(fname, imageVals, nch) < nch * (int)sizeof(short int)) { if (readDataFile(fname, imageVals, nch) < nch * (int)sizeof(short int)) {
FILE_LOG(logERROR) << "Could not open file or not enough data in file " FILE_LOG(logERROR) << "Could not open file or not enough data in file "
@ -2093,7 +2050,7 @@ int multiSlsDetector::writeCounterBlockFile(const std::string &fname,
// multi // multi
// get image from all // get image from all
int nch = thisMultiDetector->numberOfChannels; int nch = sharedMemory()->numberOfChannels;
short int imageVals[nch]; short int imageVals[nch];
std::vector<int> r; std::vector<int> r;
for (size_t idet = 0; idet < detectors.size(); ++idet) { for (size_t idet = 0; idet < detectors.size(); ++idet) {
@ -2537,7 +2494,7 @@ int multiSlsDetector::enableGapPixels(int val, int detPos) {
// update data bytes incl gap pixels // update data bytes incl gap pixels
if (val != -1) { if (val != -1) {
auto r = serialCall(&slsDetector::getDataBytesInclGapPixels); auto r = serialCall(&slsDetector::getDataBytesInclGapPixels);
thisMultiDetector->dataBytesInclGapPixels = sls::sum(r); sharedMemory()->dataBytesInclGapPixels = sls::sum(r);
// update // update
updateOffsets(); updateOffsets();
@ -2744,9 +2701,9 @@ int multiSlsDetector::setReceiverOnline(int value, int detPos) {
// multi // multi
if (value != GET_ONLINE_FLAG) { if (value != GET_ONLINE_FLAG) {
auto r = parallelCall(&slsDetector::setReceiverOnline, value); auto r = parallelCall(&slsDetector::setReceiverOnline, value);
thisMultiDetector->receiverOnlineFlag = sls::minusOneIfDifferent(r); sharedMemory()->receiverOnlineFlag = sls::minusOneIfDifferent(r);
} }
return thisMultiDetector->receiverOnlineFlag; return sharedMemory()->receiverOnlineFlag;
} }
std::string multiSlsDetector::checkReceiverOnline(int detPos) { std::string multiSlsDetector::checkReceiverOnline(int detPos) {
@ -3084,8 +3041,8 @@ int multiSlsDetector::createReceivingDataSockets(const bool destroy) {
void multiSlsDetector::readFrameFromReceiver() { void multiSlsDetector::readFrameFromReceiver() {
int nX = int nX =
thisMultiDetector->numberOfDetector[X]; // to copy data in multi module sharedMemory()->numberOfDetector[X]; // to copy data in multi module
int nY = thisMultiDetector int nY = sharedMemory()
->numberOfDetector[Y]; // for eiger, to reverse the data ->numberOfDetector[Y]; // for eiger, to reverse the data
bool gappixelsenable = false; bool gappixelsenable = false;
bool eiger = false; bool eiger = false;
@ -3233,8 +3190,8 @@ void multiSlsDetector::readFrameFromReceiver() {
// 4bit gap pixels // 4bit gap pixels
if (dynamicRange == 4 && gappixelsenable) { if (dynamicRange == 4 && gappixelsenable) {
int n = processImageWithGapPixels(multiframe, multigappixels); int n = processImageWithGapPixels(multiframe, multigappixels);
nPixelsX = thisMultiDetector->numberOfChannelInclGapPixels[X]; nPixelsX = sharedMemory()->numberOfChannelInclGapPixels[X];
nPixelsY = thisMultiDetector->numberOfChannelInclGapPixels[Y]; nPixelsY = sharedMemory()->numberOfChannelInclGapPixels[Y];
thisData = new detectorData(getCurrentProgress(), thisData = new detectorData(getCurrentProgress(),
currentFileName.c_str(), nPixelsX, currentFileName.c_str(), nPixelsX,
nPixelsY, multigappixels, n, nPixelsY, multigappixels, n,
@ -3290,12 +3247,12 @@ void multiSlsDetector::readFrameFromReceiver() {
int multiSlsDetector::processImageWithGapPixels(char *image, char *&gpImage) { int multiSlsDetector::processImageWithGapPixels(char *image, char *&gpImage) {
// eiger 4 bit mode // eiger 4 bit mode
int nxb = thisMultiDetector->numberOfDetector[X] * (512 + 3); int nxb = sharedMemory()->numberOfDetector[X] * (512 + 3);
int nyb = thisMultiDetector->numberOfDetector[Y] * (256 + 1); int nyb = sharedMemory()->numberOfDetector[Y] * (256 + 1);
int gapdatabytes = nxb * nyb; int gapdatabytes = nxb * nyb;
int nxchip = thisMultiDetector->numberOfDetector[X] * 4; int nxchip = sharedMemory()->numberOfDetector[X] * 4;
int nychip = thisMultiDetector->numberOfDetector[Y] * 1; int nychip = sharedMemory()->numberOfDetector[Y] * 1;
// allocate // allocate
if (gpImage == nullptr) { if (gpImage == nullptr) {
@ -3902,20 +3859,20 @@ void multiSlsDetector::registerDataCallback(
int multiSlsDetector::setTotalProgress() { int multiSlsDetector::setTotalProgress() {
int nf = 1, nc = 1, ns = 1, nm = 1; int nf = 1, nc = 1, ns = 1, nm = 1;
if (thisMultiDetector->timerValue[FRAME_NUMBER]) { if (sharedMemory()->timerValue[FRAME_NUMBER]) {
nf = thisMultiDetector->timerValue[FRAME_NUMBER]; nf = sharedMemory()->timerValue[FRAME_NUMBER];
} }
if (thisMultiDetector->timerValue[CYCLES_NUMBER] > 0) { if (sharedMemory()->timerValue[CYCLES_NUMBER] > 0) {
nc = thisMultiDetector->timerValue[CYCLES_NUMBER]; nc = sharedMemory()->timerValue[CYCLES_NUMBER];
} }
if (thisMultiDetector->timerValue[STORAGE_CELL_NUMBER] > 0) { if (sharedMemory()->timerValue[STORAGE_CELL_NUMBER] > 0) {
ns = thisMultiDetector->timerValue[STORAGE_CELL_NUMBER] + 1; ns = sharedMemory()->timerValue[STORAGE_CELL_NUMBER] + 1;
} }
if (thisMultiDetector->timerValue[MEASUREMENTS_NUMBER] > 0) { if (sharedMemory()->timerValue[MEASUREMENTS_NUMBER] > 0) {
nm = thisMultiDetector->timerValue[MEASUREMENTS_NUMBER]; nm = sharedMemory()->timerValue[MEASUREMENTS_NUMBER];
} }
totalProgress = nm * nf * nc * ns; totalProgress = nm * nf * nc * ns;
@ -3967,10 +3924,10 @@ int multiSlsDetector::acquire() {
bool receiver = (setReceiverOnline() == ONLINE_FLAG); bool receiver = (setReceiverOnline() == ONLINE_FLAG);
progressIndex = 0; progressIndex = 0;
thisMultiDetector->stoppedFlag = 0; sharedMemory()->stoppedFlag = 0;
setJoinThreadFlag(false); setJoinThreadFlag(false);
int nm = thisMultiDetector->timerValue[MEASUREMENTS_NUMBER]; int nm = sharedMemory()->timerValue[MEASUREMENTS_NUMBER];
if (nm < 1) { if (nm < 1) {
nm = 1; nm = 1;
} }
@ -3980,7 +3937,7 @@ int multiSlsDetector::acquire() {
std::lock_guard<std::mutex> lock(mg); std::lock_guard<std::mutex> lock(mg);
if (getReceiverStatus() != IDLE) { if (getReceiverStatus() != IDLE) {
if (stopReceiver() == FAIL) { if (stopReceiver() == FAIL) {
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
} }
} }
} }
@ -3991,13 +3948,13 @@ int multiSlsDetector::acquire() {
if (receiver) { if (receiver) {
std::lock_guard<std::mutex> lock(mg); std::lock_guard<std::mutex> lock(mg);
if (resetFramesCaught() == FAIL) { if (resetFramesCaught() == FAIL) {
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
} }
} }
// loop through measurements // loop through measurements
for (int im = 0; im < nm; ++im) { for (int im = 0; im < nm; ++im) {
if (thisMultiDetector->stoppedFlag) { if (sharedMemory()->stoppedFlag) {
break; break;
} }
@ -4007,7 +3964,7 @@ int multiSlsDetector::acquire() {
if (startReceiver() == FAIL) { if (startReceiver() == FAIL) {
FILE_LOG(logERROR) << "Start receiver failed "; FILE_LOG(logERROR) << "Start receiver failed ";
stopReceiver(); stopReceiver();
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
break; break;
} }
// let processing thread listen to these packets // let processing thread listen to these packets
@ -4020,7 +3977,7 @@ int multiSlsDetector::acquire() {
std::lock_guard<std::mutex> lock(mg); std::lock_guard<std::mutex> lock(mg);
if (receiver) { if (receiver) {
if (stopReceiver() == FAIL) { if (stopReceiver() == FAIL) {
thisMultiDetector->stoppedFlag = 1; sharedMemory()->stoppedFlag = 1;
} else { } else {
if (dataReady) { if (dataReady) {
sem_wait(&sem_endRTAcquisition); // waits for receiver's sem_wait(&sem_endRTAcquisition); // waits for receiver's
@ -4035,7 +3992,7 @@ int multiSlsDetector::acquire() {
if (measurement_finished) { if (measurement_finished) {
measurement_finished(im, findex, measFinished_p); measurement_finished(im, findex, measFinished_p);
} }
if (thisMultiDetector->stoppedFlag) { if (sharedMemory()->stoppedFlag) {
break; break;
} }

25
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.h
View File

@ -7,12 +7,11 @@
* @short This is the base class for multi detector system functionalities * @short This is the base class for multi detector system functionalities
* @author Anna Bergamaschi * @author Anna Bergamaschi
*/ */
#include "SharedMemory.h"
#include "error_defs.h" #include "error_defs.h"
#include "logger.h" #include "logger.h"
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
class slsDetector; class slsDetector;
class SharedMemory;
class ZmqSocket; class ZmqSocket;
class detectorData; class detectorData;
@ -27,15 +26,11 @@ class detectorData;
#define SHORT_STRING_LENGTH 50 #define SHORT_STRING_LENGTH 50
#define DATE_LENGTH 30 #define DATE_LENGTH 30
class multiSlsDetector : public virtual slsDetectorDefs,
public virtual errorDefs {
private:
/** /**
* @short structure allocated in shared memory to store detector settings * @short structure allocated in shared memory to store detector settings
* for IPC and cache * for IPC and cache
*/ */
typedef struct sharedMultiSlsDetector { struct sharedMultiSlsDetector {
/* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND /* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND
* ------*/ * ------*/
@ -99,7 +94,7 @@ class multiSlsDetector : public virtual slsDetectorDefs,
int maxNumberOfChannelsPerDetector[2]; int maxNumberOfChannelsPerDetector[2];
/** timer values */ /** timer values */
int64_t timerValue[MAX_TIMERS]; int64_t timerValue[slsDetectorDefs::timerIndex::MAX_TIMERS];
/** flag for acquiring */ /** flag for acquiring */
bool acquiringFlag; bool acquiringFlag;
@ -110,8 +105,12 @@ class multiSlsDetector : public virtual slsDetectorDefs,
/** data streaming (up stream) enable in receiver */ /** data streaming (up stream) enable in receiver */
bool receiver_upstream; bool receiver_upstream;
};
} sharedMultiSlsDetector; class multiSlsDetector : public virtual slsDetectorDefs,
public virtual errorDefs {
// private:
public: public:
/** /**
@ -441,8 +440,6 @@ class multiSlsDetector : public virtual slsDetectorDefs,
*/ */
int setReceiverPort(int port_number = -1, int detPos = -1); int setReceiverPort(int port_number = -1, int detPos = -1);
/** /**
* Lock server for this client IP * Lock server for this client IP
* @param p 0 to unlock, 1 to lock * @param p 0 to unlock, 1 to lock
@ -948,7 +945,6 @@ class multiSlsDetector : public virtual slsDetectorDefs,
*/ */
int setReceiverUDPPort(int udpport, int detPos = -1); int setReceiverUDPPort(int udpport, int detPos = -1);
/** /**
* Returns the receiver UDP port * Returns the receiver UDP port
* @param detPos -1 for all detectors in list or specific detector position * @param detPos -1 for all detectors in list or specific detector position
@ -1963,10 +1959,7 @@ class multiSlsDetector : public virtual slsDetectorDefs,
int detId; int detId;
/** Shared Memory object */ /** Shared Memory object */
SharedMemory *sharedMemory {nullptr}; SharedMemory<sharedMultiSlsDetector> sharedMemory{0, -1};
/** Shared memory structure */
sharedMultiSlsDetector *thisMultiDetector {nullptr};
/** pointers to the slsDetector structures */ /** pointers to the slsDetector structures */
std::vector<std::unique_ptr<slsDetector>> detectors; std::vector<std::unique_ptr<slsDetector>> detectors;

165
slsDetectorSoftware/sharedMemory/SharedMemory.cpp
View File

@ -1,165 +0,0 @@
#include "SharedMemory.h"
#include "sls_detector_exceptions.h"
#include "ansi.h"
#include "logger.h"
#include <iostream>
#include <stdio.h> // printf
#include <cerrno> // errno
#include <cstring> // strerror
#include <unistd.h>
#include <fcntl.h> // O_CREAT, O_TRUNC..
#include <sys/stat.h> // fstat
#include <sys/mman.h> // shared memory
#include <sstream>
#include "stdlib.h"
#define SHM_MULTI_PREFIX "/slsDetectorPackage_multi_"
#define SHM_SLS_PREFIX "_sls_"
#define SHM_ENV_NAME "SLSDETNAME"
SharedMemory::SharedMemory(int multiId, int slsId):
fd(-1),
shmSize(0)
{
name = ConstructSharedMemoryName(multiId, slsId);
}
SharedMemory::~SharedMemory(){
if (fd >= 0)
close(fd);
}
bool SharedMemory::IsExisting() {
bool ret = true;
int tempfd = shm_open(name.c_str(), O_RDWR, 0);
if ((tempfd < 0) && (errno == ENOENT)) {
ret = false;
}
close(tempfd);
return ret;
}
std::string SharedMemory::GetName() {
return name;
}
void* SharedMemory::CreateSharedMemory(size_t sz){
// create
fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
if (fd < 0) {
FILE_LOG(logERROR) << "Create shared memory " << name << " failed: " << strerror(errno);
throw SharedMemoryException();
}
// resize
if (ftruncate(fd, sz) < 0) {
FILE_LOG(logERROR) << "Create shared memory " << name << " failed at ftruncate: " << strerror(errno);
close(fd);
RemoveSharedMemory();
throw SharedMemoryException();
}
// map
void* addr = MapSharedMemory(sz);
FILE_LOG(logINFO) << "Shared memory created " << name;
return addr;
}
void* SharedMemory::OpenSharedMemory(size_t sz){
// open
fd = shm_open(name.c_str(), O_RDWR, 0);
if (fd < 0) {
FILE_LOG(logERROR) << "Open existing shared memory " << name << " failed: " << strerror(errno);
throw SharedMemoryException();
}
return MapSharedMemory(sz);
}
void SharedMemory::UnmapSharedMemory(void* addr) {
if (munmap(addr, shmSize) < 0) {
FILE_LOG(logERROR) << "Unmapping shared memory " << name << " failed: " << strerror(errno);
close(fd);
throw SharedMemoryException();
}
}
void SharedMemory::RemoveSharedMemory() {
if (shm_unlink(name.c_str()) < 0) {
// silent exit if shm did not exist anyway
if (errno == ENOENT)
return;
FILE_LOG(logERROR) << "Free Shared Memory " << name << " Failed: " << strerror(errno);
throw SharedMemoryException();
}
FILE_LOG(logINFO) << "Shared memory deleted " << name;
}
void* SharedMemory::MapSharedMemory(size_t sz) {
void* addr = mmap(nullptr, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (addr == MAP_FAILED) {
FILE_LOG(logERROR) << "Mapping shared memory " << name << " failed: " << strerror(errno);
close(fd);
throw SharedMemoryException();
}
shmSize = sz;
close(fd);
return addr;
}
std::string SharedMemory::ConstructSharedMemoryName(int multiId, int slsId) {
// using environment path
std::string sEnvPath = "";
char* envpath = getenv(SHM_ENV_NAME);
if (envpath != nullptr) {
sEnvPath.assign(envpath);
sEnvPath.insert(0,"_");
}
std::stringstream ss;
if (slsId < 0)
ss << SHM_MULTI_PREFIX << multiId << sEnvPath;
else
ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath;
std::string temp = ss.str();
if (temp.length() > NAME_MAX) {
FILE_LOG(logERROR) << "Shared memory initialization failed. " <<
temp << " has " << temp.length() << " characters. \n"
"Maximum is " << NAME_MAX << ". Change the environment variable " << SHM_ENV_NAME;
throw SharedMemoryException();
}
return temp;
}
int SharedMemory::VerifySizeMatch(size_t expectedSize) {
struct stat sb;
// could not fstat
if (fstat(fd, &sb) < 0) {
FILE_LOG(logERROR) << "Could not verify existing shared memory " << name << " size match "
"(could not fstat): " << strerror(errno);
close(fd);
throw SharedMemoryException();
}
//size does not match
long unsigned int sz = (long unsigned int)sb.st_size;
if (sz != expectedSize) {
FILE_LOG(logERROR) << "Existing shared memory " << name << " size does not match";
FILE_LOG(logDEBUG1) << "Expected " << expectedSize << ", found " << sz;
throw SharedMemoryException();
return 1;
}
return 0;
}

228
slsDetectorSoftware/sharedMemory/SharedMemory.h
View File

@ -8,9 +8,29 @@
*@short functions basic implemenation of shared memory *@short functions basic implemenation of shared memory
*/ */
#include "ansi.h"
#include "logger.h"
#include "sls_detector_exceptions.h"
#include "stdlib.h"
#include <cerrno> // errno
#include <cstring> // strerror
#include <fcntl.h> // O_CREAT, O_TRUNC..
#include <iostream>
#include <sstream>
#include <stdio.h> // printf
#include <sys/mman.h> // shared memory
#include <sys/stat.h> // fstat
#include <unistd.h>
#define SHM_MULTI_PREFIX "/slsDetectorPackage_multi_"
#define SHM_SLS_PREFIX "_sls_"
#define SHM_ENV_NAME "SLSDETNAME"
#include <iostream> #include <iostream>
#include <string> #include <string>
template <typename T>
class SharedMemory { class SharedMemory {
public: public:
/** /**
@ -19,56 +39,178 @@ public:
* @param multiId multi detector id * @param multiId multi detector id
* @param slsId sls detector id, -1 if a multi detector shared memory * @param slsId sls detector id, -1 if a multi detector shared memory
*/ */
SharedMemory(int multiId, int slsId); SharedMemory(int multiId, int slsId) {
name = ConstructSharedMemoryName(multiId, slsId);
}
/** /**
* Destructor * Delete the copy constructor and copy assignment since we don't want two
* objects managing the same resource
*/ */
~SharedMemory(); SharedMemory(const SharedMemory &) = delete;
SharedMemory &operator=(const SharedMemory &other) = delete;
//Move constructor
SharedMemory(SharedMemory &&other) : name(other.name),
fd(other.fd),
shmSize(other.shmSize),
shared_struct(other.shared_struct) {
other.fd = -1;
other.shared_struct = nullptr;
other.shmSize = 0;
}
//Move assignment
SharedMemory &operator=(SharedMemory &&other) {
name = other.name;
if (fd) {
close(fd);
}
fd = other.fd;
other.fd = -1;
if (shared_struct != nullptr) {
UnmapSharedMemory();
}
shared_struct = other.shared_struct;
other.shared_struct = nullptr;
shmSize = other.shmSize;
other.shmSize = 0;
return *this;
}
~SharedMemory() {
if (fd >= 0)
close(fd);
if (shared_struct) {
UnmapSharedMemory();
}
}
/** /**
* Verify if it exists * Verify if it exists
* @param name of shared memory * @param name of shared memory
* @return true if exists, else false * @return true if exists, else false
*/ */
bool IsExisting(); bool IsExisting() {
bool ret = true;
int tempfd = shm_open(name.c_str(), O_RDWR, 0);
if ((tempfd < 0) && (errno == ENOENT)) {
ret = false;
}
close(tempfd);
return ret;
}
/** /**
* Get shared memory name * Get shared memory name
*/ */
std::string GetName(); std::string GetName() const {
return name;
}
size_t size() const {
return shmSize;
}
/** /**
* Create Shared memory and call MapSharedMemory to map it to an address * Create Shared memory and call MapSharedMemory to map it to an address
* throws a SharedMemoryException exception on failure to create, ftruncate or map * throws a SharedMemoryException exception on failure to create, ftruncate or map
* @param sz of shared memory * @param sz of shared memory
*/ */
void* CreateSharedMemory(size_t sz); void CreateSharedMemory(size_t sz = 0) {
if (sz == 0) {
sz = sizeof(T);
}
fd = shm_open(name.c_str(), O_CREAT | O_TRUNC | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR);
if (fd < 0) {
FILE_LOG(logERROR) << "Create shared memory " << name << " failed: " << strerror(errno);
throw SharedMemoryException();
}
if (ftruncate(fd, sz) < 0) {
FILE_LOG(logERROR) << "Create shared memory " << name << " failed at ftruncate: " << strerror(errno);
close(fd);
RemoveSharedMemory();
throw SharedMemoryException();
}
shared_struct = MapSharedMemory(sz);
FILE_LOG(logINFO) << "Shared memory created " << name;
}
/** /**
* Open existing Shared memory and call MapSharedMemory to map it to an address * Open existing Shared memory and call MapSharedMemory to map it to an address
* throws a SharedMemoryException exception on failure to open or map * throws a SharedMemoryException exception on failure to open or map
* @param sz of shared memory * @param sz of shared memory
*/ */
void* OpenSharedMemory(size_t sz); void OpenSharedMemory(size_t sz = 0) {
if (sz == 0) {
sz = sizeof(T);
}
fd = shm_open(name.c_str(), O_RDWR, 0);
if (fd < 0) {
FILE_LOG(logERROR) << "Open existing shared memory " << name << " failed: " << strerror(errno);
throw SharedMemoryException();
}
shared_struct = MapSharedMemory(sz);
}
/** /**
* Unmap shared memory from an address * Unmap shared memory from an address
* throws a SharedMemoryException exception on failure * throws a SharedMemoryException exception on failure
* @param addr double pointer to address to be mapped
*/ */
void UnmapSharedMemory(void* addr); void UnmapSharedMemory() {
if (shared_struct != nullptr) {
if (munmap(shared_struct, shmSize) < 0) {
FILE_LOG(logERROR) << "Unmapping shared memory " << name << " failed: " << strerror(errno);
close(fd);
throw SharedMemoryException();
}
shared_struct = nullptr;
}
}
/** /**
* Remove existing Shared memory * Remove existing Shared memory
*/ */
void RemoveSharedMemory(); void RemoveSharedMemory() {
UnmapSharedMemory();
if (shm_unlink(name.c_str()) < 0) {
// silent exit if shm did not exist anyway
if (errno == ENOENT)
return;
FILE_LOG(logERROR) << "Free Shared Memory " << name << " Failed: " << strerror(errno);
throw SharedMemoryException();
}
FILE_LOG(logINFO) << "Shared memory deleted " << name;
}
/** /**
* Maximum length of name as from man pages * Maximum length of name as from man pages
*/ */
static const int NAME_MAX = 255; static const int NAME_MAX = 255;
/**
*Using the call operator to access the pointer
*/
T *operator()() {
return shared_struct;
}
/**
*Using the call operator to access the pointer, const overload
*/
const T *operator()() const {
return shared_struct;
}
private: private:
/** /**
* Create Shared memory name * Create Shared memory name
@ -77,29 +219,85 @@ private:
* @param slsId sls detector id, -1 if a multi detector shared memory * @param slsId sls detector id, -1 if a multi detector shared memory
* @returns shared memory name * @returns shared memory name
*/ */
std::string ConstructSharedMemoryName(int multiId, int slsId); std::string ConstructSharedMemoryName(int multiId, int slsId) {
// using environment path
std::string sEnvPath = "";
char *envpath = getenv(SHM_ENV_NAME);
if (envpath != nullptr) {
sEnvPath.assign(envpath);
sEnvPath.insert(0, "_");
}
std::stringstream ss;
if (slsId < 0)
ss << SHM_MULTI_PREFIX << multiId << sEnvPath;
else
ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath;
std::string temp = ss.str();
if (temp.length() > NAME_MAX) {
FILE_LOG(logERROR) << "Shared memory initialization failed. " << temp << " has " << temp.length() << " characters. \n"
"Maximum is "
<< NAME_MAX << ". Change the environment variable " << SHM_ENV_NAME;
throw SharedMemoryException();
}
return temp;
}
/** /**
* Map shared memory to an address * Map shared memory to an address
* throws a SharedMemoryException exception on failure * throws a SharedMemoryException exception on failure
* @param sz of shared memory * @param sz of shared memory
*/ */
void* MapSharedMemory(size_t sz);
T *MapSharedMemory(size_t sz) {
void *addr = mmap(nullptr, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if (addr == MAP_FAILED) {
FILE_LOG(logERROR) << "Mapping shared memory " << name << " failed: " << strerror(errno);
close(fd);
throw SharedMemoryException();
}
shmSize = sz;
close(fd);
return (T *)addr;
}
/** /**
* Verify if existing shared memory size matches expected size * Verify if existing shared memory size matches expected size
* @param expectedSize expected size of shared memory, replaced with smaller size if size does not match * @param expectedSize expected size of shared memory, replaced with smaller size if size does not match
* @return 0 for success, 1 for fail * @return 0 for success, 1 for fail
*/ */
int VerifySizeMatch(size_t expectedSize); int VerifySizeMatch(size_t expectedSize) {
struct stat sb;
// could not fstat
if (fstat(fd, &sb) < 0) {
FILE_LOG(logERROR) << "Could not verify existing shared memory " << name << " size match "
"(could not fstat): "
<< strerror(errno);
close(fd);
throw SharedMemoryException();
}
//size does not match
long unsigned int sz = (long unsigned int)sb.st_size;
if (sz != expectedSize) {
FILE_LOG(logERROR) << "Existing shared memory " << name << " size does not match";
FILE_LOG(logDEBUG1) << "Expected " << expectedSize << ", found " << sz;
throw SharedMemoryException();
return 1;
}
return 0;
}
/** Shared memory name */ /** Shared memory name */
std::string name; std::string name;
/** File descriptor */ /** File descriptor */
int fd; int fd{-1};
/** shm size */ /** shm size */
size_t shmSize; size_t shmSize{0};
T *shared_struct{nullptr};
}; };

29
slsDetectorSoftware/slsDetector/slsDetector.cpp
View File

@ -31,7 +31,7 @@ slsDetector::slsDetector(detectorType type, int multiId, int id, bool verify)
* so sls shared memory will be created */ * so sls shared memory will be created */
// ensure shared memory was not created before // ensure shared memory was not created before
auto shm = SharedMemory(multiId, id); SharedMemory<sharedSlsDetector> shm(multiId, id);
if (shm.IsExisting()) { if (shm.IsExisting()) {
FILE_LOG(logWARNING) << "This shared memory should have been " FILE_LOG(logWARNING) << "This shared memory should have been "
"deleted before! " "deleted before! "
@ -59,7 +59,7 @@ slsDetector::slsDetector(int multiId, int id, bool verify)
slsDetector::~slsDetector() { slsDetector::~slsDetector() {
if (sharedMemory) { if (sharedMemory) {
sharedMemory->UnmapSharedMemory(thisDetector); sharedMemory->UnmapSharedMemory();
delete sharedMemory; delete sharedMemory;
} }
} }
@ -202,13 +202,13 @@ int64_t slsDetector::getId(idMode mode) {
} }
void slsDetector::freeSharedMemory(int multiId, int slsId) { void slsDetector::freeSharedMemory(int multiId, int slsId) {
auto shm = SharedMemory(multiId, slsId); SharedMemory<sharedSlsDetector> shm(multiId, slsId);
shm.RemoveSharedMemory(); shm.RemoveSharedMemory();
} }
void slsDetector::freeSharedMemory() { void slsDetector::freeSharedMemory() {
if (sharedMemory) { if (sharedMemory) {
sharedMemory->UnmapSharedMemory(thisDetector); sharedMemory->UnmapSharedMemory();
sharedMemory->RemoveSharedMemory(); sharedMemory->RemoveSharedMemory();
delete sharedMemory; delete sharedMemory;
sharedMemory = nullptr; sharedMemory = nullptr;
@ -236,15 +236,17 @@ void slsDetector::initSharedMemory(bool created, detectorType type, int multiId,
int sz = calculateSharedMemorySize(type); int sz = calculateSharedMemorySize(type);
// shared memory object with name // shared memory object with name
sharedMemory = new SharedMemory(multiId, detId); sharedMemory = new SharedMemory<sharedSlsDetector>(multiId, detId);
// create // create
if (created) { if (created) {
thisDetector = (sharedSlsDetector *)sharedMemory->CreateSharedMemory(sz); sharedMemory->CreateSharedMemory(sz);
thisDetector = (*sharedMemory)();
} }
// open and verify version // open and verify version
else { else {
thisDetector = (sharedSlsDetector *)sharedMemory->OpenSharedMemory(sz); sharedMemory->OpenSharedMemory(sz);
thisDetector = (*sharedMemory)();
if (verify && thisDetector->shmversion != SLS_SHMVERSION) { if (verify && thisDetector->shmversion != SLS_SHMVERSION) {
FILE_LOG(logERROR) << "Single shared memory " FILE_LOG(logERROR) << "Single shared memory "
"(" "("
@ -259,7 +261,7 @@ void slsDetector::initSharedMemory(bool created, detectorType type, int multiId,
if (sharedMemory) { if (sharedMemory) {
// unmap // unmap
if (thisDetector) { if (thisDetector) {
sharedMemory->UnmapSharedMemory(thisDetector); sharedMemory->UnmapSharedMemory();
thisDetector = nullptr; thisDetector = nullptr;
} }
// delete // delete
@ -636,17 +638,16 @@ int slsDetector::receiveModule(sls_detector_module *myMod) {
} }
slsDetectorDefs::detectorType slsDetector::getDetectorTypeFromShm(int multiId, bool verify) { slsDetectorDefs::detectorType slsDetector::getDetectorTypeFromShm(int multiId, bool verify) {
auto shm = SharedMemory(multiId, detId); SharedMemory<sharedSlsDetector> shm(multiId, detId);
if (!shm.IsExisting()) { if (!shm.IsExisting()) {
FILE_LOG(logERROR) << "Shared memory " << shm.GetName() << " does not exist.\n" FILE_LOG(logERROR) << "Shared memory " << shm.GetName() << " does not exist.\n"
"Corrupted Multi Shared memory. Please free shared memory."; "Corrupted Multi Shared memory. Please free shared memory.";
throw SharedMemoryException(); throw SharedMemoryException();
} }
size_t sz = sizeof(sharedSlsDetector);
// open, map, verify version // open, map, verify version
auto sdet = (sharedSlsDetector *)shm.OpenSharedMemory(sz); shm.OpenSharedMemory();
auto sdet = shm();
if (verify && sdet->shmversion != SLS_SHMVERSION) { if (verify && sdet->shmversion != SLS_SHMVERSION) {
FILE_LOG(logERROR) << "Single shared memory " FILE_LOG(logERROR) << "Single shared memory "
"(" "("
@ -654,13 +655,13 @@ slsDetectorDefs::detectorType slsDetector::getDetectorTypeFromShm(int multiId, b
"(expected 0x" "(expected 0x"
<< std::hex << SLS_SHMVERSION << " but got 0x" << sdet->shmversion << ")" << std::dec; << std::hex << SLS_SHMVERSION << " but got 0x" << sdet->shmversion << ")" << std::dec;
// unmap and throw // unmap and throw
sharedMemory->UnmapSharedMemory(thisDetector); sharedMemory->UnmapSharedMemory();
throw SharedMemoryException(); throw SharedMemoryException();
} }
// get type, unmap // get type, unmap
auto type = sdet->myDetectorType; auto type = sdet->myDetectorType;
shm.UnmapSharedMemory(sdet); shm.UnmapSharedMemory();
return type; return type;
} }

47
slsDetectorSoftware/slsDetector/slsDetector.h
View File

@ -9,17 +9,16 @@
* @author Anna Bergamaschi * @author Anna Bergamaschi
*/ */
#include "sls_detector_defs.h" #include "ClientSocket.h"
#include "SharedMemory.h"
#include "error_defs.h" #include "error_defs.h"
#include "logger.h" #include "logger.h"
#include "ClientSocket.h" #include "sls_detector_defs.h"
class ClientInterface; class ClientInterface;
#include <cmath> #include <cmath>
class multiSlsDetector; class multiSlsDetector;
class SharedMemory;
class ServerInterface; class ServerInterface;
class MySocketTCP; class MySocketTCP;
@ -41,14 +40,10 @@ typedef struct detParameterList {
int nGappixelsY; int nGappixelsY;
} detParameterList; } detParameterList;
class slsDetector : public virtual slsDetectorDefs, public virtual errorDefs {
private:
/** /**
* @short structure allocated in shared memory to store detector settings for IPC and cache * @short structure allocated in shared memory to store detector settings for IPC and cache
*/ */
typedef struct sharedSlsDetector { struct sharedSlsDetector {
/* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/ /* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/
@ -68,13 +63,10 @@ private:
char hostname[MAX_STR_LENGTH]; char hostname[MAX_STR_LENGTH];
/** detector type \ see :: detectorType*/ /** detector type \ see :: detectorType*/
detectorType myDetectorType; slsDetectorDefs::detectorType myDetectorType;
/** END OF FIXED PATTERN -----------------------------------------------*/ /** END OF FIXED PATTERN -----------------------------------------------*/
/** Detector offset in the X & Y direction in the multi detector structure */ /** Detector offset in the X & Y direction in the multi detector structure */
int offset[2]; int offset[2];
@ -125,22 +117,22 @@ private:
int nROI; int nROI;
/** list of rois */ /** list of rois */
ROI roiLimits[MAX_ROIS]; slsDetectorDefs::ROI roiLimits[MAX_ROIS];
/** readout flags */ /** readout flags */
readOutFlags roFlags; slsDetectorDefs::readOutFlags roFlags;
/** name root of the output files */ /** name root of the output files */
char settingsFile[MAX_STR_LENGTH]; char settingsFile[MAX_STR_LENGTH];
/** detector settings (standard, fast, etc.) */ /** detector settings (standard, fast, etc.) */
detectorSettings currentSettings; slsDetectorDefs::detectorSettings currentSettings;
/** detector threshold (eV) */ /** detector threshold (eV) */
int currentThresholdEV; int currentThresholdEV;
/** timer values */ /** timer values */
int64_t timerValue[MAX_TIMERS]; int64_t timerValue[slsDetectorDefs::timerIndex::MAX_TIMERS];
/** memory offsets for the module structures */ /** memory offsets for the module structures */
int modoff; int modoff;
@ -226,7 +218,7 @@ private:
int64_t receiverAPIVersion; int64_t receiverAPIVersion;
/** receiver frames discard policy */ /** receiver frames discard policy */
frameDiscardPolicy receiver_frameDiscardMode; slsDetectorDefs::frameDiscardPolicy receiver_frameDiscardMode;
/** receiver partial frames padding enable */ /** receiver partial frames padding enable */
bool receiver_framePadding; bool receiver_framePadding;
@ -250,7 +242,7 @@ private:
int receiver_fileIndex; int receiver_fileIndex;
/** file format */ /** file format */
fileFormat receiver_fileFormatType; slsDetectorDefs::fileFormat receiver_fileFormatType;
/** frames per file */ /** frames per file */
int receiver_framesPerFile; int receiver_framesPerFile;
@ -260,15 +252,10 @@ private:
/** overwriteenable */ /** overwriteenable */
bool receiver_overWriteEnable; bool receiver_overWriteEnable;
};
} sharedSlsDetector; class slsDetector : public virtual slsDetectorDefs, public virtual errorDefs {
public: public:
/** /**
* Constructor called when creating new shared memory * Constructor called when creating new shared memory
* @param type detector type * @param type detector type
@ -462,7 +449,6 @@ public:
*/ */
int setOnline(int value = GET_ONLINE_FLAG); int setOnline(int value = GET_ONLINE_FLAG);
/** /**
* Returns the online flag * Returns the online flag
*/ */
@ -602,7 +588,6 @@ public:
*/ */
int getThresholdEnergy(); int getThresholdEnergy();
/** /**
* Set threshold energy (Mythen and Eiger) * Set threshold energy (Mythen and Eiger)
* For Eiger, calls setThresholdEneryAndSettings * For Eiger, calls setThresholdEneryAndSettings
@ -1259,7 +1244,6 @@ public:
*/ */
int setAutoComparatorDisableMode(int ival = -1); int setAutoComparatorDisableMode(int ival = -1);
/** /**
* Returns the trimbits from the detector's shared memmory (Eiger) * Returns the trimbits from the detector's shared memmory (Eiger)
* @param retval is the array with the trimbits * @param retval is the array with the trimbits
@ -1278,7 +1262,6 @@ public:
*/ */
int setModule(sls_detector_module module, int tb = 1); int setModule(sls_detector_module module, int tb = 1);
/** /**
* Get module structure from detector (all detectors) * Get module structure from detector (all detectors)
* @returns pointer to module structure (which has been created and must then be deleted) * @returns pointer to module structure (which has been created and must then be deleted)
@ -1649,7 +1632,6 @@ public:
int setDigitalIODelay(uint64_t pinMask, int delay); int setDigitalIODelay(uint64_t pinMask, int delay);
private: private:
/** /**
* Get Detector Type from Shared Memory (opening shm without verifying size) * Get Detector Type from Shared Memory (opening shm without verifying size)
* @param multiId multi detector Id * @param multiId multi detector Id
@ -1789,12 +1771,11 @@ private:
*/ */
int writeSettingsFile(const std::string &fname, sls_detector_module mod); int writeSettingsFile(const std::string &fname, sls_detector_module mod);
/** slsDetector Id or position in the detectors list */ /** slsDetector Id or position in the detectors list */
int detId; int detId;
/** Shared Memory object */ /** Shared Memory object */
SharedMemory* sharedMemory {nullptr}; SharedMemory<sharedSlsDetector> *sharedMemory{nullptr};
/** Shared memory structure */ /** Shared memory structure */
sharedSlsDetector *thisDetector{nullptr}; sharedSlsDetector *thisDetector{nullptr};

23
slsDetectorSoftware/tests/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
include_directories(
${PROJECT_SOURCE_DIR}/catch
)
set(SOURCES
test.cpp
test-SharedMemory.cpp
)
add_executable(testSlsDetector ${SOURCES})
target_link_libraries(testSlsDetector
slsSupportLib
slsDetectorShared
pthread
rt
)
set_target_properties(testSlsDetector PROPERTIES
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
)
#TODO! Move to automatic test discovery
add_test(test-testSlsDetector ${CMAKE_BINARY_DIR}/bin/testSlsDetector)

128
slsDetectorSoftware/tests/test-SharedMemory.cpp Normal file
View File

@ -0,0 +1,128 @@
#include "SharedMemory.h"
#include "catch.hpp"
#include "string_utils.h"
#include <iostream>
struct Data {
int x;
double y;
char mess[50];
};
TEST_CASE("Create SharedMemory read and write") {
SharedMemory<Data> shm(0, -1);
shm.CreateSharedMemory();
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0");
shm()->x = 3;
shm()->y = 5.7;
sls::strcpy_safe(shm()->mess, "Some string");
CHECK(shm()->x == 3);
CHECK(shm()->y == 5.7);
CHECK(std::string(shm()->mess) == "Some string");
shm.UnmapSharedMemory();
shm.RemoveSharedMemory();
CHECK(shm.IsExisting() == false);
}
TEST_CASE("Open existing SharedMemory and read") {
{
SharedMemory<double> shm(0, -1);
shm.CreateSharedMemory();
*shm() = 5.3;
}
SharedMemory<double> shm2(0, -1);
shm2.OpenSharedMemory();
CHECK(*shm2() == 5.3);
shm2.RemoveSharedMemory();
}
TEST_CASE("Creating a second shared memory with the same name throws") {
SharedMemory<double> shm0(0, -1);
SharedMemory<double> shm1(0, -1);
shm0.CreateSharedMemory();
CHECK_THROWS(shm1.CreateSharedMemory());
shm0.RemoveSharedMemory();
}
TEST_CASE("Open two shared memories to the same place") {
//Create the first shared memory
SharedMemory<Data> shm(0, -1);
shm.CreateSharedMemory();
shm()->x = 5;
CHECK(shm()->x == 5);
//Open the second shared memory with the same name
SharedMemory<Data> shm2(0, -1);
shm2.OpenSharedMemory();
CHECK(shm2()->x == 5);
CHECK(shm.GetName() == shm2.GetName());
//Check that they still point to the same place
shm2()->x = 7;
CHECK(shm()->x == 7);
//Remove only needs to be done once since they refer
//to the same memory
shm2.RemoveSharedMemory();
CHECK(shm.IsExisting() == false);
CHECK(shm2.IsExisting() == false);
}
TEST_CASE("Move SharedMemory"){
SharedMemory<Data> shm(0,-1);
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0");
shm.CreateSharedMemory();
shm()->x = 9;
CHECK(shm.size()== sizeof(Data));
SharedMemory<Data> shm2(1,-1);
shm2 = std::move(shm); //shm is now a moved from object!
CHECK(shm2()->x == 9);
CHECK(shm() == nullptr);
CHECK(shm.size() == 0);
CHECK(shm2.GetName() == "/slsDetectorPackage_multi_0");
shm2.RemoveSharedMemory();
}
TEST_CASE("Create several shared memories") {
constexpr int N = 5;
std::vector<SharedMemory<int>> v;
v.reserve(N);
for (int i = 0; i != N; ++i) {
v.emplace_back(i, -1);
CHECK(v[i].IsExisting() == false);
v[i].CreateSharedMemory();
*v[i]() = i;
CHECK(*v[i]() == i);
}
for (int i = 0; i != N; ++i) {
CHECK(*v[i]() == i);
CHECK(v[i].GetName() == std::string("/slsDetectorPackage_multi_")+std::to_string(i));
}
for (int i = 0; i != N; ++i) {
v[i].RemoveSharedMemory();
CHECK(v[i].IsExisting() == false);
}
}

3
slsDetectorSoftware/tests/test.cpp Normal file
View File

@ -0,0 +1,3 @@
// tests-main.cpp
#define CATCH_CONFIG_MAIN
#include "catch.hpp"