detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-27 08:40:02 +02:00
Code Issues Actions Packages Releases Activity

Merge pull request #8 from slsdetectorgroup/use-unique-ptr

Browse Source 
In Listener, remove raw pointers allocations, use `unique_ptr` instead.
This commit is contained in:
Dhanya Thattil 2019-03-06 17:48:28 +01:00 committed by GitHub
commit 999a2f4d15
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 42 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
slsReceiverSoftware/include/Listener.h
View File

@ -9,6 +9,8 @@
*@short creates & manages a listener thread each *@short creates & manages a listener thread each
*/ */
#include <memory>
#include "ThreadObject.h" #include "ThreadObject.h"
class GeneralData; class GeneralData;
@ -169,7 +171,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
* Pop free addresses, listen to udp socket, * Pop free addresses, listen to udp socket,
* write to memory & push the address into fifo * write to memory & push the address into fifo
*/ */
void ThreadExecution(); void ThreadExecution() override;
/** /**
* Pushes non empty buffers into fifo/ frees empty buffer, * Pushes non empty buffers into fifo/ frees empty buffer,
@ -207,7 +209,6 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
/** Fifo structure */ /** Fifo structure */
Fifo* fifo; Fifo* fifo;
// individual members // individual members
/** Detector Type */ /** Detector Type */
detectorType myDetectorType; detectorType myDetectorType;
@ -216,7 +217,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
runStatus* status; runStatus* status;
/** UDP Socket - Detector to Receiver */ /** UDP Socket - Detector to Receiver */
genericSocket* udpSocket; std::unique_ptr<genericSocket> udpSocket;
/** UDP Port Number */ /** UDP Port Number */
uint32_t* udpPortNumber; uint32_t* udpPortNumber;
@ -293,10 +294,10 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
bool carryOverFlag; bool carryOverFlag;
/** Carry over packet buffer */ /** Carry over packet buffer */
char* carryOverPacket; std::unique_ptr<char []> carryOverPacket;
/** Listening buffer for one packet - might be removed when we can peek and eiger fnum is in header */ /** Listening buffer for one packet - might be removed when we can peek and eiger fnum is in header */
char* listeningPacket; std::unique_ptr<char []> listeningPacket;
/** if the udp socket is connected */ /** if the udp socket is connected */
bool udpSocketAlive; bool udpSocketAlive;

63
slsReceiverSoftware/src/Listener.cpp
View File

@ -10,6 +10,7 @@
#include "GeneralData.h" #include "GeneralData.h"
#include "Fifo.h" #include "Fifo.h"
#include "genericSocket.h" #include "genericSocket.h"
#include "container_utils.h" // For sls::make_unique<>
#include <iostream> #include <iostream>
#include <errno.h> #include <errno.h>
@ -50,8 +51,6 @@ Listener::Listener(int ind, detectorType dtype, Fifo* f, runStatus* s,
lastCaughtFrameIndex(0), lastCaughtFrameIndex(0),
currentFrameIndex(0), currentFrameIndex(0),
carryOverFlag(0), carryOverFlag(0),
carryOverPacket(nullptr),
listeningPacket(nullptr),
udpSocketAlive(0), udpSocketAlive(0),
numPacketsStatistic(0), numPacketsStatistic(0),
numFramesStatistic(0), numFramesStatistic(0),
@ -66,13 +65,10 @@ Listener::Listener(int ind, detectorType dtype, Fifo* f, runStatus* s,
Listener::~Listener() { Listener::~Listener() {
if (udpSocket){ if (udpSocket){
delete udpSocket;
sem_post(&semaphore_socket); sem_post(&semaphore_socket);
sem_destroy(&semaphore_socket); sem_destroy(&semaphore_socket);
} }
if (carryOverPacket) delete [] carryOverPacket;
if (listeningPacket) delete [] listeningPacket;
ThreadObject::DestroyThread(); ThreadObject::DestroyThread();
} }
@ -131,14 +127,10 @@ void Listener::ResetParametersforNewMeasurement() {
numPacketsCaught = 0; numPacketsCaught = 0;
firstMeasurementIndex = 0; firstMeasurementIndex = 0;
carryOverFlag = false; carryOverFlag = false;
if (carryOverPacket) carryOverPacket = sls::make_unique<char[]>(generalData->packetSize);
delete [] carryOverPacket; memset(carryOverPacket.get(),0,generalData->packetSize);
carryOverPacket = new char[generalData->packetSize]; listeningPacket = sls::make_unique<char[]>(generalData->packetSize);
memset(carryOverPacket,0,generalData->packetSize); memset(carryOverPacket.get(),0,generalData->packetSize);
if (listeningPacket)
delete [] listeningPacket;
listeningPacket = new char[generalData->packetSize];
memset(listeningPacket,0,generalData->packetSize);
numPacketsStatistic = 0; numPacketsStatistic = 0;
numFramesStatistic = 0; numFramesStatistic = 0;
@ -204,10 +196,9 @@ int Listener::CreateUDPSockets() {
ShutDownUDPSocket(); ShutDownUDPSocket();
try{ try{
genericSocket* g = new genericSocket(*udpPortNumber, genericSocket::UDP, udpSocket = sls::make_unique<genericSocket>(*udpPortNumber, genericSocket::UDP,
generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize, generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize,
*udpSocketBufferSize); *udpSocketBufferSize);
udpSocket = g;
FILE_LOG(logINFO) << index << ": UDP port opened at port " << *udpPortNumber; FILE_LOG(logINFO) << index << ": UDP port opened at port " << *udpPortNumber;
} catch (...) { } catch (...) {
FILE_LOG(logERROR) << "Could not create UDP socket on port " << *udpPortNumber; FILE_LOG(logERROR) << "Could not create UDP socket on port " << *udpPortNumber;
@ -235,8 +226,6 @@ void Listener::ShutDownUDPSocket() {
//give a post to semaphore(at stopListening) //give a post to semaphore(at stopListening)
if (runningFlag) if (runningFlag)
sem_wait(&semaphore_socket); sem_wait(&semaphore_socket);
delete udpSocket;
udpSocket = nullptr;
sem_destroy(&semaphore_socket); sem_destroy(&semaphore_socket);
} }
} }
@ -261,13 +250,11 @@ int Listener::CreateDummySocketForUDPSocketBufferSize(uint64_t s) {
// shutdown if any open // shutdown if any open
if(udpSocket){ if(udpSocket){
udpSocket->ShutDownSocket(); udpSocket->ShutDownSocket();
delete udpSocket;
udpSocket = nullptr;
} }
//create dummy socket //create dummy socket
try { try {
udpSocket = new genericSocket(*udpPortNumber, genericSocket::UDP, udpSocket = sls::make_unique<genericSocket>(*udpPortNumber, genericSocket::UDP,
generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize, generalData->packetSize, (strlen(eth)?eth:nullptr), generalData->headerPacketSize,
*udpSocketBufferSize); *udpSocketBufferSize);
} catch (...) { } catch (...) {
@ -287,8 +274,6 @@ int Listener::CreateDummySocketForUDPSocketBufferSize(uint64_t s) {
if(udpSocket){ if(udpSocket){
udpSocketAlive = false; udpSocketAlive = false;
udpSocket->ShutDownSocket(); udpSocket->ShutDownSocket();
delete udpSocket;
udpSocket = nullptr;
} }
return OK; return OK;
@ -422,13 +407,13 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//check if its the current image packet //check if its the current image packet
// -------------------------- new header ---------------------------------------------------------------------- // -------------------------- new header ----------------------------------------------------------------------
if (standardheader) { if (standardheader) {
old_header = (sls_detector_header*) (carryOverPacket + esize); old_header = (sls_detector_header*) (&carryOverPacket[esize]);
fnum = old_header->frameNumber; fnum = old_header->frameNumber;
pnum = old_header->packetNumber; pnum = old_header->packetNumber;
} }
// -------------------old header ----------------------------------------------------------------------------- // -------------------old header -----------------------------------------------------------------------------
else { else {
generalData->GetHeaderInfo(index, carryOverPacket + esize, generalData->GetHeaderInfo(index, &carryOverPacket[esize],
*dynamicRange, oddStartingPacket, fnum, pnum, snum, bid); *dynamicRange, oddStartingPacket, fnum, pnum, snum, bid);
} }
//------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------
@ -462,19 +447,19 @@ uint32_t Listener::ListenToAnImage(char* buf) {
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data + 640*2 bytes data !! // 2nd packet: 4 bytes fnum, previous 1*2 bytes data + 640*2 bytes data !!
case GOTTHARD: case GOTTHARD:
if(!pnum) if(!pnum)
memcpy(buf + fifohsize , carryOverPacket + hsize+4, dsize-2); memcpy(buf + fifohsize , &carryOverPacket[hsize+4], dsize-2);
else else
memcpy(buf + fifohsize + dsize - 2, carryOverPacket + hsize, dsize+2); memcpy(buf + fifohsize + dsize - 2, &carryOverPacket[hsize], dsize+2);
break; break;
case CHIPTESTBOARD: case CHIPTESTBOARD:
case MOENCH: case MOENCH:
if (pnum == (pperFrame-1)) if (pnum == (pperFrame-1))
memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize, corrected_dsize); memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize], corrected_dsize);
else else
memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize, dsize); memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize], dsize);
break; break;
default: default:
memcpy(buf + fifohsize + (pnum * dsize), carryOverPacket + hsize, dsize); memcpy(buf + fifohsize + (pnum * dsize), &carryOverPacket[hsize], dsize);
break; break;
} }
@ -510,7 +495,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//listen to new packet //listen to new packet
rc = 0; rc = 0;
if (udpSocketAlive){ if (udpSocketAlive){
rc = udpSocket->ReceiveDataOnly(listeningPacket); rc = udpSocket->ReceiveDataOnly(&listeningPacket[0]);
} }
// end of acquisition // end of acquisition
if(rc <= 0) { if(rc <= 0) {
@ -540,7 +525,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
// -------------------------- new header ---------------------------------------------------------------------- // -------------------------- new header ----------------------------------------------------------------------
if (standardheader) { if (standardheader) {
old_header = (sls_detector_header*) (listeningPacket + esize); old_header = (sls_detector_header*) (&listeningPacket[esize]);
fnum = old_header->frameNumber; fnum = old_header->frameNumber;
pnum = old_header->packetNumber; pnum = old_header->packetNumber;
} }
@ -548,10 +533,10 @@ uint32_t Listener::ListenToAnImage(char* buf) {
else { else {
// set first packet to be odd or even (check required when switching from roi to no roi) // set first packet to be odd or even (check required when switching from roi to no roi)
if (myDetectorType == GOTTHARD && !measurementStartedFlag) { if (myDetectorType == GOTTHARD && !measurementStartedFlag) {
oddStartingPacket = generalData->SetOddStartingPacket(index, listeningPacket + esize); oddStartingPacket = generalData->SetOddStartingPacket(index, &listeningPacket[esize]);
} }
generalData->GetHeaderInfo(index, listeningPacket + esize, generalData->GetHeaderInfo(index, &listeningPacket[esize],
*dynamicRange, oddStartingPacket, fnum, pnum, snum, bid); *dynamicRange, oddStartingPacket, fnum, pnum, snum, bid);
} }
//------------------------------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------------------------------
@ -582,7 +567,7 @@ uint32_t Listener::ListenToAnImage(char* buf) {
//future packet by looking at image number (all other detectors) //future packet by looking at image number (all other detectors)
if (fnum != currentFrameIndex) { if (fnum != currentFrameIndex) {
carryOverFlag = true; carryOverFlag = true;
memcpy(carryOverPacket,listeningPacket, generalData->packetSize); memcpy(carryOverPacket.get(), &listeningPacket[0], generalData->packetSize);
switch(*frameDiscardMode) { switch(*frameDiscardMode) {
case DISCARD_EMPTY_FRAMES: case DISCARD_EMPTY_FRAMES:
@ -608,19 +593,19 @@ uint32_t Listener::ListenToAnImage(char* buf) {
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data + 640*2 bytes data !! // 2nd packet: 4 bytes fnum, previous 1*2 bytes data + 640*2 bytes data !!
case GOTTHARD: case GOTTHARD:
if(!pnum) if(!pnum)
memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize+4, dsize-2); memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize+4], dsize-2);
else else
memcpy(buf + fifohsize + (pnum * dsize) - 2, listeningPacket + hsize, dsize+2); memcpy(buf + fifohsize + (pnum * dsize) - 2, &listeningPacket[hsize], dsize+2);
break; break;
case CHIPTESTBOARD: case CHIPTESTBOARD:
case MOENCH: case MOENCH:
if (pnum == (pperFrame-1)) if (pnum == (pperFrame-1))
memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, corrected_dsize); memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], corrected_dsize);
else else
memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, dsize); memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], dsize);
break; break;
default: default:
memcpy(buf + fifohsize + (pnum * dsize), listeningPacket + hsize, dsize); memcpy(buf + fifohsize + (pnum * dsize), &listeningPacket[hsize], dsize);
break; break;
} }
++numpackets; //number of packets in this image (each time its copied to buf) ++numpackets; //number of packets in this image (each time its copied to buf)

13
slsSupportLib/include/container_utils.h
View File

@ -8,6 +8,7 @@
#include <vector> #include <vector>
#include <sstream> #include <sstream>
#include <memory> #include <memory>
namespace sls { namespace sls {
@ -15,10 +16,20 @@ namespace sls {
// C++11 make_unique implementation for exception safety // C++11 make_unique implementation for exception safety
// already available as std::make_unique in C++14 // already available as std::make_unique in C++14
template <typename T, typename... Args> template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args &&... args) { typename std::enable_if<!std::is_array<T>::value, std::unique_ptr<T>>::type
make_unique(Args &&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
} }
template <typename T>
typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
make_unique(std::size_t n)
{
typedef typename std::remove_extent<T>::type RT;
return std::unique_ptr<T>(new RT[n]);
}
template <typename T> template <typename T>
bool allEqual(const std::vector<T>& container) bool allEqual(const std::vector<T>& container)
{ {