Skip to content
Snippets Groups Projects
Commit 9ef61496 authored by zwart's avatar zwart
Browse files

BugID: 735

Initial checkin of Generator
parent e5e46f7a
No related branches found
No related tags found
No related merge requests found
Showing
with 1666 additions and 9 deletions
//# AH_Generator.h: Application that generates data (and emulates an RSP board)
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_AH_GENERATOR_H
#define LOFAR_GENERATOR_AH_GENERATOR_H
// \file
// Data generator
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <CEPFrame/ApplicationHolder.h>
#include <Transport/TransportHolder.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
class AH_Generator: public LOFAR::ApplicationHolder
{
public:
AH_Generator();
virtual ~AH_Generator();
virtual void undefine();
virtual void define (const LOFAR::KeyValueMap&);
virtual void run (int nsteps);
private:
vector<TransportHolder*> itsTHs;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# AH_Recorder.h: Application that records data
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_AH_RECORDER_H
#define LOFAR_GENERATOR_AH_RECORDER_H
// \file
// Application that records data
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <CEPFrame/ApplicationHolder.h>
#include <Transport/TransportHolder.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
class AH_Recorder: public LOFAR::ApplicationHolder
{
public:
AH_Recorder();
virtual ~AH_Recorder();
virtual void undefine();
virtual void define (const LOFAR::KeyValueMap&);
virtual void run (int nsteps);
private:
vector<TransportHolder*> itsTHs;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# DH_RSP.h: This DataHolders holds the data a RSP-board will output
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_DH_RSP_H
#define LOFAR_GENERATOR_DH_RSP_H
// \file
// This DataHolders holds the data a RSP-board will output
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <APS/ParameterSet.h>
#include <Transport/DataHolder.h>
#include <Generator/RSPEthFrame.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
//# Forward Declarations
//class forward;
// Description of class.
class DH_RSP : public DataHolder
{
public:
typedef u16complex DataType;
explicit DH_RSP(const string& name,
const ACC::APS::ParameterSet& pset);
DH_RSP(const DH_RSP&);
virtual ~DH_RSP();
DataHolder* clone() const;
/// Allocate the buffers.
virtual void init();
// Access methods
Frame* getFrame() const { return itsFrame;};
private:
// forbid assignment
DH_RSP& operator= (const DH_RSP& that);
// Fill the pointers (itsBuffer) to the data in the blob.
virtual void fillDataPointers();
//# Datamembers
Frame* itsFrame;
ACC::APS::ParameterSet itsPSet;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
......@@ -2,7 +2,8 @@
# SUBDIRS = shmem .
# endif
INSTHDRS = RSPTimeStamp.h \
INSTHDRS = Signals.h \
RSPTimeStamp.h \
WH_FakeStation.h \
WH_Signal.h \
WH_Wrap.h \
......
//# RSPEthFrame.h: classes to hold the data from a station
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_RSPETHFRAME_H
#define LOFAR_GENERATOR_RSPETHFRAME_H
// \file
// classes to hold the data from a station
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <Common/lofar_complex.h>
#include <APS/ParameterSet.h>
#include <Generator/RSPTimeStamp.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
//# Forward Declarations
//class forward;
typedef i16complex RSPDataType;
// Header is the class that represents the header data of the epa packet
// it contains the following fields:
// protocol(int32)
// stationId(int32)
// sequenceId(int32)
// blockId(int32)
// This class can only be used on little endian machines because the RSPdata is little endian
class Header
{
public:
explicit Header(char* bufferSpace, const int size) {
ASSERTSTR(size == theirSize, "Header did not receive the right amount of memory");
itsBufferp = bufferSpace;
itsProtp = reinterpret_cast<int*>(itsBufferp);
itsStationIDp = reinterpret_cast<int*>(itsBufferp + theirStatIDOffset);
itsSeqIDp = reinterpret_cast<int*>(itsBufferp + theirSeqIDOffset);
itsBlockIDp = reinterpret_cast<int*>(itsBufferp + theirBlockIDOffset);
};
~Header() {};
int32 getProtocol() const { return *itsProtp;};
void setProtocol(int32 newProt) { *itsProtp = newProt;};
int32 getStationId() const { return *itsStationIDp;};
void setStationId(int32 newSid) { *itsStationIDp = newSid;};
int32 getSeqId() const { return *itsSeqIDp;};
int32 getBlockId() const { return *itsBlockIDp;};
void setSeqId(int32 newSeqId) { *itsSeqIDp = newSeqId;};
void setBlockId(int32 newBlockId) { *itsBlockIDp = newBlockId;};
static int getSize() { return theirSize;};
protected:
char* itsBufferp;
int* itsProtp;
int* itsStationIDp;
int* itsSeqIDp;
int* itsBlockIDp;
static const int theirSize = 16;
static const int theirStatIDOffset = 4;
static const int theirSeqIDOffset = 8;
static const int theirBlockIDOffset = 12;
};
class Data
{
public:
explicit Data(RSPDataType* bufferSpace, const unsigned int size, const ACC::APS::ParameterSet& ps) {
itsNPol = ps.getInt32("NPolarisations");
itsNSubbands = ps.getInt32("NSubbands");
itsNTimes = ps.getInt32("NTimesPerFrame");
ASSERTSTR(itsNPol * itsNSubbands * itsNTimes * sizeof(RSPDataType) == size, "Data did not receive the right amount of memory");
itsBeamlets = bufferSpace;
};
~Data() {};
RSPDataType& getBeamlet(int seq, int subband, int pol) const { return itsBeamlets[pol + subband * itsNPol + seq * itsNPol * itsNSubbands]; };
void clear() { memset(itsBeamlets, 0, itsNPol * itsNSubbands * itsNTimes * sizeof(RSPDataType));};
int getNPols() const {return itsNPol;};
int getNSubbands() const {return itsNSubbands;};
int getNTimes() const {return itsNTimes;};
static int getSize(const ACC::APS::ParameterSet& ps) {
return ps.getInt32("NPolarisations")
* ps.getInt32("NSubbands")
* ps.getInt32("NTimesPerFrame")
* sizeof(RSPDataType); };
protected:
RSPDataType* itsBeamlets;
int itsNPol;
int itsNSubbands;
int itsNTimes;
};
class Frame
{
public:
Frame(char* bufferP,
const int size,
const ACC::APS::ParameterSet& ps) :
itsHeader(bufferP, Header::getSize()),
itsData(reinterpret_cast<RSPDataType*>(bufferP + Header::getSize()),
size - Header::getSize(),
ps)
{};
~Frame() {};
Data* getData() { return &itsData;};
Header* getHeader() { return &itsHeader;};
char* getBufferp() { return itsBufferp; };
int getSize() { return itsSize;};
static int getSize(const ACC::APS::ParameterSet& ps) { return Header::getSize() + Data::getSize(ps);};
private:
Header itsHeader;
Data itsData;
char* itsBufferp;
int itsSize;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# RSPTimeStamp.h: Small class to hold the timestamps from RSP
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_RSPTIMESTAMP_H
#define LOFAR_GENERATOR_RSPTIMESTAMP_H
// \file
// Small class to hold the timestamps from RSP
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
class TimeStamp {
public:
TimeStamp(const int seqId = 0, const int blockId = 0);
// set the Stamp
void setStamp(const int seqId, const int blockId);
// get sequence ID
const int getSeqId () const;
// get block ID
const int getBlockId () const;
static int getMaxBlockId() {return theirMaxBlockId; };
static void setMaxBlockId(int nMBID) {theirMaxBlockId = nMBID; };
// the blockId restarts at zero at some point. Check if we are there yet
void checkOverflow();
// increase the value of the stamp
void operator+= (const TimeStamp& other);
void operator+= (int increment);
void operator++ (int);
TimeStamp operator+ (int other) const;
long long operator- (const TimeStamp& other) const;
TimeStamp operator- (int other) const;
bool operator> (const TimeStamp& other) const;
bool operator< (const TimeStamp& other) const;
bool operator>= (const TimeStamp& other) const;
bool operator<= (const TimeStamp& other) const;
bool operator== (const TimeStamp& other) const;
friend ostream& operator<<(ostream& os, const TimeStamp& ss);
private:
int itsSeqId;
int itsBlockId;
static int theirMaxBlockId;
};
typedef TimeStamp timestamp_t;
inline void TimeStamp::setStamp(const int seqId, const int blockId)
{ itsSeqId = seqId; itsBlockId = blockId; checkOverflow(); };
inline const int TimeStamp::getSeqId () const
{ return itsSeqId; }
inline const int TimeStamp::getBlockId () const
{ return itsBlockId; }
inline void TimeStamp::operator += (const TimeStamp& other)
{
itsBlockId += other.itsBlockId;
checkOverflow();
itsSeqId += other.itsSeqId;
}
inline void TimeStamp::operator += (int increment)
{
itsBlockId += increment;
checkOverflow();
}
inline void TimeStamp::operator ++ (int)
{
itsBlockId ++;
checkOverflow();
}
inline TimeStamp TimeStamp::operator+ (int increment) const
{
// check overflow is done in the constructor
return TimeStamp(itsSeqId, itsBlockId + increment);
}
inline TimeStamp TimeStamp::operator- (int decrement) const
{
// check overflow is done in the constructor
return TimeStamp(itsSeqId, itsBlockId - decrement);
}
inline long long TimeStamp::operator- (const TimeStamp& other) const
{
long long seqdecr = itsSeqId - other.itsSeqId;
int blockdecr = itsBlockId - other.itsBlockId;
return (seqdecr*theirMaxBlockId) + blockdecr;
}
inline bool TimeStamp::operator > (const TimeStamp& other) const
{
if (itsSeqId > other.itsSeqId) return true;
if (itsSeqId < other.itsSeqId) return false;
if (itsBlockId > other.itsBlockId) return true;
return false;
}
inline bool TimeStamp::operator >= (const TimeStamp& other) const
{ return !operator<(other); }
inline bool TimeStamp::operator < (const TimeStamp& other) const
{
if (itsSeqId < other.itsSeqId) return true;
if (itsSeqId > other.itsSeqId) return false;
if (itsBlockId < other.itsBlockId) return true;
return false;
}
inline bool TimeStamp::operator <= (const TimeStamp& other) const
{ return !operator>(other); }
inline bool TimeStamp::operator == (const TimeStamp& other) const
{
return ((itsSeqId == other.itsSeqId) && (itsBlockId == other.itsBlockId));
}
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# Signals.h: contains several signal generators
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_SIGNALS_H
#define LOFAR_GENERATOR_SIGNALS_H
// \file
// Signal generators (several classes)
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <Generator/RSPEthFrame.h>
namespace LOFAR
{
namespace Generator
{
// Description of class.
class Signal
{
public:
typedef float SignalTime;
Signal()
{};
virtual ~Signal() {};
virtual void fillNext(Data* dataptr) = 0;
private:
// Copying is not allowed
Signal (const Signal& that);
Signal& operator= (const Signal that);
//# Datamembers
};
// This signal only produces zeros
class Sig_Zero : public Signal
{
public:
Sig_Zero()
{};
~Sig_Zero() {};
void fillNext(Data* dataptr);
};
// This signal only produces random numbers
class Sig_Random : public Signal
{
public:
Sig_Random()
{};
~Sig_Random() {};
int16 randint16() {
int32 value = rand() - RAND_MAX / 2;
// we need to return a int16 with 12 used bits
// so divide by 2^20
return value / 1048576 ;
};
void fillNext(Data* dataptr);
};
// This signal produces the sum of several monochrome signals
// It is only written in the first subband
class Sig_MultiChrome : public Signal
{
public:
struct SignalInfo{
public:
double amplitude;
double frequency;
double phase;
};
Sig_MultiChrome(vector<SignalInfo> info, double deltaT) :
itsSignals(info),
itsDeltaPhase(2 * M_PI * deltaT)
{};
~Sig_MultiChrome() {};
void fillNext(Data* dataptr);
private:
vector<SignalInfo> itsSignals;
double itsDeltaPhase; // This is 2*pi*deltaT
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# WH_FakeStation.h: Emulate a station
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_WH_FAKESTATION_H
#define LOFAR_GENERATOR_WH_FAKESTATION_H
// \file
// Emulate a station
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <tinyCEP/WorkHolder.h>
#include <APS/ParameterSet.h>
#include <Transport/TransportHolder.h>
#include <Generator/RSPEthFrame.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
using ACC::APS::ParameterSet;
class WH_FakeStation: public WorkHolder
{
public:
explicit WH_FakeStation(const string& name,
const ParameterSet ps,
const int StationID,
const int delay,
TransportHolder* th);
virtual ~WH_FakeStation();
static WorkHolder* construct(const string& name,
const ParameterSet ps,
const int StationID,
const int delay,
TransportHolder* th);
virtual WH_FakeStation* make(const string& name);
virtual void preprocess();
virtual void process();
private:
/// forbid copy constructor
WH_FakeStation (const WH_FakeStation&);
/// forbid assignment
WH_FakeStation& operator= (const WH_FakeStation&);
ParameterSet itsPS;
int itsStationId;
int itsDelay;
TransportHolder* itsTH;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# WH_Signal.h: Create a signal
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#ifndef LOFAR_GENERATOR_WH_SIGNAL_H
#define LOFAR_GENERATOR_WH_SIGNAL_H
// \file
// Create a signal
//# Never #include <config.h> or #include <lofar_config.h> in a header file!
//# Includes
#include <tinyCEP/WorkHolder.h>
#include <APS/ParameterSet.h>
#include <Transport/TransportHolder.h>
#include <Generator/DH_RSP.h>
#include <Generator/Signals.h>
namespace LOFAR
{
namespace Generator
{
// \addtogroup Generator
// @{
using ACC::APS::ParameterSet;
class WH_Signal: public WorkHolder
{
public:
explicit WH_Signal(const string& name,
const int noOutputs,
const ParameterSet ps);
virtual ~WH_Signal();
static WorkHolder* construct(const string& name,
const int noOutputs,
const ParameterSet ps);
virtual WH_Signal* make(const string& name);
virtual void preprocess();
virtual void process();
virtual void postprocess();
//handle timer alarm
static void timerSignal(int signal);
private:
/// forbid copy constructor
WH_Signal (const WH_Signal&);
/// forbid assignment
WH_Signal& operator= (const WH_Signal&);
ParameterSet itsPS;
double itsFrequency;
TimeStamp itsStamp;
Signal* itsSignal;
static int theirNoRunningWHs;
static int theirNoAlarms;
static bool theirTimerSet;
};
// @}
} // namespace Generator
} // namespace LOFAR
#endif
//# AH_Generator.cc: one line description
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/AH_Generator.h>
#include <Common/lofar_iostream.h>
#include <APS/ParameterSet.h>
#include <CEPFrame/Step.h>
// Transporters
#include <Transport/TH_Mem.h>
#include <Transport/TH_File.h>
#include <Transport/TH_Ethernet.h>
// Workholders
#include <tinyCEP/WorkHolder.h>
#include <Generator/WH_Signal.h>
#include <Generator/WH_FakeStation.h>
namespace LOFAR {
namespace Generator {
AH_Generator::AH_Generator()
{
}
AH_Generator::~AH_Generator()
{
this->undefine();
}
void AH_Generator::undefine() {
vector<TransportHolder*>::iterator tit = itsTHs.begin();
for (; tit!=itsTHs.end(); tit++) {
delete *tit;
}
itsTHs.clear();
}
void AH_Generator::define(const LOFAR::KeyValueMap&) {
LOG_TRACE_FLOW_STR("Start of AH_Generator::define()");
undefine();
LOG_TRACE_FLOW_STR("Create the top-level composite");
Composite comp(0, 0, "topComposite");
setComposite(comp); // tell the ApplicationHolder this is the top-level compisite
LOG_TRACE_FLOW_STR("Create output side interface stubs");
// todo: define this input interface; although there are no
// connection involved, we do have to define the port/IP numbering schemes
int NRSP = itsParamSet.getInt32("Data.NStations");
int WH_DH_NameSize = 40;
char WH_DH_Name[WH_DH_NameSize];
bool useEth = itsParamSet.getBool("Generator.UseEth");
vector<string> outFileNames = itsParamSet.getStringVector("Generator.OutputFiles");
vector<string> interfaces = itsParamSet.getStringVector("Generator.Interfaces");
vector<string> dstMacs = itsParamSet.getStringVector("Input.DestinationMacs");
vector<string> srcMacs = itsParamSet.getStringVector("Input.SourceMacs");
vector<int32> stationIds = itsParamSet.getInt32Vector("Generator.StationIds");
vector<int32> delays = itsParamSet.getInt32Vector("Generator.StationDelays");
snprintf(WH_DH_Name, WH_DH_NameSize, "Signal");
Step signalStep(new WH_Signal(WH_DH_Name,
NRSP,
itsParamSet),
WH_DH_Name);
comp.addBlock(signalStep);
for (int s=0; s<NRSP; s++) {
snprintf(WH_DH_Name, WH_DH_NameSize, "FakeStation_%d_of_%d", s, NRSP);
if (useEth) {
// cout<<"interface: "<<interfaces[s]<<" remote: "<<dstMacs[s]<<" own: "<<srcMacs[s]<<endl;
itsTHs.push_back(new TH_Ethernet(interfaces[s],
dstMacs[s],
srcMacs[s]));
} else {
itsTHs.push_back(new TH_File(outFileNames[s], TH_File::Write));
}
ASSERTSTR(itsTHs.back()->init(), "Could not init TransportHolder");
Step stationStep(new WH_FakeStation(WH_DH_Name,
itsParamSet,
stationIds[s],
delays[s],
itsTHs.back()),
WH_DH_Name);
// share input and output DH, no cyclic buffer
stationStep.setInBufferingProperties(0, true, true);
comp.addBlock(stationStep);
stationStep.connect(0, &signalStep, s, 1,
new TH_Mem(),
false);
snprintf(WH_DH_Name, WH_DH_NameSize, "Strip_%d_of_%d", s, NRSP);
};
#ifdef HAVE_MPI
// TODO How do we want to distribute the steps across the nodes?
// ASSERTSTR (lastFreeNode == TH_MPI::getNumberOfNodes(), lastFreeNode << " nodes needed, "<<TH_MPI::getNumberOfNodes()<<" available");
#endif
LOG_TRACE_FLOW_STR("Finished defineGenerator()");
}
void AH_Generator::run(int steps) {
LOG_TRACE_FLOW_STR("Start AH_Generator::run() " );
for (int i = 0; i < steps; i++) {
LOG_TRACE_LOOP_STR("processing run " << i );
getComposite().process();
}
LOG_TRACE_FLOW_STR("Finished AH_Generator::run() " );
}
} // namespace Generator
} // namespace LOFAR
//# AH_Recorder.cc: one line description
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/AH_Recorder.h>
#include <Common/lofar_iostream.h>
#include <APS/ParameterSet.h>
#include <CEPFrame/Step.h>
// Transporters
#include <Transport/TH_Mem.h>
#include <Transport/TH_MPI.h>
#include <Transport/TH_File.h>
#include <Transport/TH_Null.h>
#include <Transport/TH_Ethernet.h>
// Workholders
#include <tinyCEP/WorkHolder.h>
#include <Generator/WH_Signal.h>
#include <Generator/WH_FakeStation.h>
namespace LOFAR {
namespace Generator {
AH_Recorder::AH_Recorder()
{
}
AH_Recorder::~AH_Recorder()
{
this->undefine();
}
void AH_Recorder::undefine() {
vector<TransportHolder*>::iterator tit = itsTHs.begin();
for (; tit!=itsTHs.end(); tit++) {
delete *tit;
}
itsTHs.clear();
}
void AH_Recorder::define(const LOFAR::KeyValueMap&) {
LOG_TRACE_FLOW_STR("Start of AH_Recorder::define()");
undefine();
LOG_TRACE_FLOW_STR("Create the top-level composite");
Composite comp(0, 0, "topComposite");
setComposite(comp); // tell the ApplicationHolder this is the top-level compisite
int lastFreeNode = 0;
#ifdef HAVE_MPICH
// mpich tries to run the first process on the local node
// this is necessary if you want to use totalview
// scampi run the first process on the first node in the machinefile
lastFreeNode = 1;
#endif
int NRSP = itsParamSet.getInt32("Data.NStations");
int WH_DH_NameSize = 40;
char WH_DH_Name[WH_DH_NameSize];
vector<string> outFileNames = itsParamSet.getStringVector("Generator.OutputFiles");
vector<string> interfaces = itsParamSet.getStringVector("Input.Interfaces");
vector<string> dstMacs = itsParamSet.getStringVector("Input.DestinationMacs");
vector<string> srcMacs = itsParamSet.getStringVector("Input.SourceMacs");
int bufferSize = itsParamSet.getInt32("Generator.RecordBufferSize");
snprintf(WH_DH_Name, WH_DH_NameSize, "Signal");
#if 0
for (int s=0; s<NRSP; s++) {
//itsTHs.push_back(new TH_File("Generator1.in", TH_File::Read));
cout<<"Creating TH_Ethernet: "<<srcMacs[s]<<" -> "<<dstMacs[s]<<endl;
#if 0
itsTHs.push_back(new TH_Null());
#else
itsTHs.push_back(new TH_Ethernet(interfaces[s],
srcMacs[s],
dstMacs[s],
1048576));
#endif
Step inStep(&WH_Wrap(WH_DH_Name,
*itsTHs.back(),
itsParamSet),
WH_DH_Name);
inStep.setOutBuffer(0, false, bufferSize);
comp.addBlock(inStep);
inStep.runOnNode(lastFreeNode++);
itsTHs.push_back(new TH_File(outFileNames[s], TH_File::Write));
Step outStep(&WH_Strip(WH_DH_Name,
*itsTHs.back(),
itsParamSet),
WH_DH_Name);
comp.addBlock(outStep);
outStep.runOnNode(lastFreeNode++);
#ifdef HAVE_MPI
// this needs to be done with MPI, so if we don't have MPI do nothing
outStep.connect(0, inStep, 0, 1,
TH_MPI(inStep->getNode(),
outStep->getNode()),
true);
#else
ASSERTSTR(false, "This application is supposed to be run with MPI");
#endif
}
#endif
// This program was written to run with MPI. All workholders run in their own process.
// The machinefile should contain every node name twice, so WH_Wrap and WH_Strip run on
// the same physical host.
#ifdef HAVE_MPI
ASSERTSTR (lastFreeNode == TH_MPI::getNumberOfNodes(), lastFreeNode << " nodes needed, "<<TH_MPI::getNumberOfNodes()<<" available");
#else
ASSERTSTR(false, "This application is supposed to be run with MPI");
#endif
LOG_TRACE_FLOW_STR("Finished defineRecorder()");
}
void AH_Recorder::run(int steps) {
LOG_TRACE_FLOW_STR("Start AH_Recorder::run() " );
for (int i = 0; i < steps; i++) {
LOG_TRACE_LOOP_STR("processing run " << i );
getComposite().process();
}
LOG_TRACE_FLOW_STR("Finished AH_Recorder::run() " );
}
} // namespace Generator
} // namespace LOFAR
//# DH_RSP.cc: one line description
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/DH_RSP.h>
namespace LOFAR {
namespace Generator {
DH_RSP::DH_RSP (const string& name,
const ACC::APS::ParameterSet& pset)
: DataHolder (name, "DH_RSP"),
itsFrame (0),
itsPSet (pset)
{}
DH_RSP::DH_RSP(const DH_RSP& that)
: DataHolder (that),
itsFrame (0),
itsPSet (that.itsPSet)
{}
DH_RSP::~DH_RSP()
{}
DataHolder* DH_RSP::clone() const
{
return new DH_RSP(*this);
}
void DH_RSP::init()
{
// Add the fields to the data definition.
addField ("Frame", BlobField<char>(1, Frame::getSize(itsPSet)));
// Create the data blob
createDataBlock();
}
void DH_RSP::fillDataPointers()
{
itsFrame = new Frame(getData<char>("Frame"), Frame::getSize(itsPSet), itsPSet);
itsFrame->getData()->clear();
}
} // namespace Generator
} // namespace LOFAR
//# Generator_main.cc:
//#
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#include <lofar_config.h>
#include <PLC/ACCmain.h>
#include <Common/LofarLogger.h>
#include <tinyCEP/ApplicationHolderController.h>
#include <Generator/AH_Generator.h>
using namespace LOFAR;
using namespace LOFAR::Generator;
int main(int argc, char **argv) {
INIT_LOGGER("Generator");
AH_Generator myAH;
ApplicationHolderController myAHController(myAH);
return ACC::PLC::ACCmain(argc, argv, &myAHController);
}
lib_LTLIBRARIES = libgenerator.la
libgenerator_la_SOURCES = RSPTimeStamp.cc \
libgenerator_la_SOURCES = Signals.cc \
RSPTimeStamp.cc \
WH_FakeStation.cc \
WH_Signal.cc \
WH_Wrap.cc \
WH_Strip.cc \
AH_Recorder.cc \
AH_Generator.cc \
DH_RSP.cc
......
//# RSPTimeStamp.cc: Small class to hold the timestamps from RSP
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/RSPTimeStamp.h>
namespace LOFAR {
namespace Generator {
int TimeStamp::theirMaxBlockId = 156250;
TimeStamp::TimeStamp(const int seqId, const int blockId)
:itsSeqId(seqId),
itsBlockId(blockId)
{
checkOverflow();
}
void TimeStamp::checkOverflow() {
if (itsBlockId >= theirMaxBlockId) {
int newBlockId = itsBlockId % theirMaxBlockId;
itsSeqId += itsBlockId / theirMaxBlockId;
itsBlockId = newBlockId;
} else if (itsBlockId < 0) {
int newBlockId = (itsBlockId % theirMaxBlockId) + theirMaxBlockId;
itsSeqId += -1 + itsBlockId / theirMaxBlockId;
itsBlockId = newBlockId;
};
}
ostream& operator<<(ostream& os, const TimeStamp& ss){
os<<ss.itsSeqId<<" s: "<<ss.itsBlockId;
return os;
}
} // namespace Generator
} // namespace LOFAR
//# Recorder_main.cc:
//#
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
#include <lofar_config.h>
#include <PLC/ACCmain.h>
#include <Common/LofarLogger.h>
#include <tinyCEP/ApplicationHolderController.h>
#include <Generator/AH_Recorder.h>
using namespace LOFAR;
using namespace LOFAR::Generator;
int main(int argc, char **argv) {
INIT_LOGGER("Recorder");
AH_Recorder myAH;
ApplicationHolderController myAHController(myAH);
return ACC::PLC::ACCmain(argc, argv, &myAHController);
}
//# Signals.cc: one line description
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/Signals.h>
namespace LOFAR {
namespace Generator {
void Sig_Zero::fillNext(Data* dataptr)
{
memset(&dataptr->getBeamlet(0, 0, 0),
0,
dataptr->getNTimes() * dataptr->getNPols() * dataptr->getNSubbands() * sizeof(RSPDataType));
}
void Sig_Random::fillNext(Data* dataptr)
{
RSPDataType* p = &dataptr->getBeamlet(0, 0, 0);
for (int i = 0; i < dataptr->getNTimes() * dataptr->getNSubbands() * dataptr->getNPols(); i ++) {
p[i] = makei16complex(randint16(), randint16());
}
}
void Sig_MultiChrome::fillNext(Data* dataptr)
{
for (int time = 0; time < dataptr->getNTimes(); time++) {
double totSinus = 0;
double totCosinus = 0;
vector<SignalInfo>::iterator sig;
for (sig = itsSignals.begin(); sig != itsSignals.end(); sig++) {
sig->phase += itsDeltaPhase * sig->frequency;
double s, c;
sincos(sig->phase, &s, &c);
totSinus += sig->amplitude * s;
totCosinus += sig->amplitude * c;
}
dataptr->getBeamlet(time, 0, 0) = makei16complex(static_cast<int>(totCosinus), static_cast<int>(totSinus));
}
}
} // namespace Generator
} // namespace LOFAR
//# WH_FakeStation.cc: Emulate a station
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Transport/TransportHolder.h>
#include <Generator/WH_FakeStation.h>
#include <Generator/DH_RSP.h>
#include <Generator/RSPTimeStamp.h>
// This WH can be used with CEPFrame or tinyCEP, but to be able
// to test if we are in CEPFrame, we need to include DataManager.h
#include <CEPFrame/DataManager.h>
namespace LOFAR {
namespace Generator {
WH_FakeStation::WH_FakeStation(const string& name,
const ParameterSet ps,
const int stationID,
const int delay,
TransportHolder* th)
: WorkHolder (1, 1,
name,
"WH_FakeStation"),
itsPS(ps),
itsDelay(delay),
itsTH(th)
{
itsStationId = stationID;
getDataManager().addInDataHolder(0, new DH_RSP("incoming_DH_RSP", itsPS));
getDataManager().addOutDataHolder(0, new DH_RSP("outgoing_DH_RSP", itsPS));
}
WH_FakeStation::~WH_FakeStation() {
}
WorkHolder* WH_FakeStation::construct(const string& name,
const ParameterSet ps,
const int stationID,
const int delay,
TransportHolder* th)
{
return new WH_FakeStation(name, ps, stationID, delay, th);
}
WH_FakeStation* WH_FakeStation::make(const string& name)
{
return new WH_FakeStation(name, itsPS, itsStationId, itsDelay, itsTH);
}
void WH_FakeStation::preprocess() {
DataManager* dm = dynamic_cast<DataManager*> (&getDataManager());
ASSERTSTR(dm, "WH_FakeStation only works in CEPFrame, not tinyCEP. This is because we need shared input and output DHs.");
itsTH->init();
}
void WH_FakeStation::process()
{
Frame& myEthFrame = *((DH_RSP*)getDataManager().getInHolder(0))->getFrame();
TimeStamp myStamp;
Header& myHeader = *myEthFrame.getHeader();
myHeader.setStationId(itsStationId);
// get the stamp
myStamp.setStamp(myHeader.getSeqId(), myHeader.getBlockId());
// add the delay
myStamp += itsDelay;
// set the stamp
myHeader.setSeqId(myStamp.getSeqId());
myHeader.setBlockId(myStamp.getBlockId());
if (itsTH != 0) {
itsTH->sendBlocking(myEthFrame.getBufferp(), myEthFrame.getSize(), 0);
}
}
} // namespace Generator
} // namespace LOFAR
//# WH_Signal.cc: Create a signal
//#
//# Copyright (C) 2006
//# ASTRON (Netherlands Foundation for Research in Astronomy)
//# P.O.Box 2, 7990 AA Dwingeloo, The Netherlands, seg@astron.nl
//#
//# This program is free software; you can redistribute it and/or modify
//# it under the terms of the GNU General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or
//# (at your option) any later version.
//#
//# This program is distributed in the hope that it will be useful,
//# but WITHOUT ANY WARRANTY; without even the implied warranty of
//# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//# GNU General Public License for more details.
//#
//# You should have received a copy of the GNU General Public License
//# along with this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//#
//# $Id$
//# Always #include <lofar_config.h> first!
#include <lofar_config.h>
//# Includes
#include <Common/LofarLogger.h>
#include <Generator/WH_Signal.h>
// for timer
#include <signal.h>
#include <sys/time.h>
// for sleep (yield)
#include <boost/thread.hpp>
namespace LOFAR {
namespace Generator {
int WH_Signal::theirNoRunningWHs = 0;
int WH_Signal::theirNoAlarms = 0;
bool WH_Signal::theirTimerSet = 0;
WH_Signal::WH_Signal(const string& name,
const int noOutputs,
const ParameterSet ps)
: WorkHolder (0, noOutputs,
name,
"WH_Signal"),
itsPS(ps),
itsSignal(0)
{
itsFrequency = ps.getDouble("Generator.OutputRate") / ps.getInt32("Input.NPacketsInFrame");
double deltaT = 1 / ps.getDouble("Generator.SampleFreq");
string signalType = ps.getString("Generator.SignalType");
if (signalType == "RANDOM") {
itsSignal = new Sig_Random();
} else if (signalType == "MULTICHROME") {
int noFreqs = ps.getInt32("Generator.NFreqs");
vector<Sig_MultiChrome::SignalInfo> signals;
char key[60];
for (int f = 0; f < noFreqs; f++)
{
Sig_MultiChrome::SignalInfo s;
snprintf(key, 60, "Generator.Signals.%d.Amplitude", f);
s.amplitude = ps.getDouble(key);
snprintf(key, 60, "Generator.Signals.%d.Frequency", f);
s.frequency = ps.getDouble(key);
snprintf(key, 60, "Generator.Signals.%d.Phase", f);
s.phase = ps.getDouble(key);
signals.push_back(s);
}
itsSignal = new Sig_MultiChrome(signals, deltaT);
} else {
// send zeros by default
itsSignal = new Sig_Zero();
}
for (int outDH = 0; outDH < noOutputs; outDH++) {
getDataManager().addOutDataHolder(outDH, new DH_RSP("signal_out", itsPS));
}
}
WH_Signal::~WH_Signal() {
delete itsSignal;
}
WorkHolder* WH_Signal::construct(const string& name,
const int noOutputs,
const ParameterSet ps)
{
return new WH_Signal(name, noOutputs, ps);
}
WH_Signal* WH_Signal::make(const string& name)
{
return new WH_Signal(name, itsNoutputs, itsPS);
}
void WH_Signal::preprocess()
{
if (itsFrequency == 0) {
// frequency was set to zero, which means output should go as fast as possible
// we do that by setting theirNoAlarms to the number of runs
theirNoAlarms += itsPS.getInt32("Generator.NoRuns");
} else {
if (!theirTimerSet) {
sighandler_t ret = signal(SIGALRM, *WH_Signal::timerSignal);
ASSERTSTR(ret != SIG_ERR, "WH_Signal couldn't set signal handler for timer");
struct itimerval value;
memset (&value, 0, sizeof(itimerval));
double time = 1/itsFrequency;
time_t secs = static_cast<time_t>(floor(time));
time_t usecs = static_cast<time_t>(1e6 * (time - secs));
// this means 1MHz is the highest frequency
if (secs + usecs == 0) usecs = 1;
value.it_interval.tv_sec = secs;
value.it_interval.tv_usec = usecs;
value.it_value.tv_sec = secs;
value.it_value.tv_usec = usecs;
cout << "Setting timer interval to " << secs << "secs and " << usecs << "ms" << endl;
setitimer(ITIMER_REAL, &value, 0);
theirTimerSet = true;
}
}
theirNoRunningWHs++;
}
void WH_Signal::process()
{
Frame& myEthFrame = *((DH_RSP*)getDataManager().getOutHolder(0))->getFrame();
//myEthFrame.reset();
Header& header = *myEthFrame.getHeader();
header.setProtocol(0xAAAB);
header.setSeqId(itsStamp.getSeqId());
header.setBlockId(itsStamp.getBlockId());
itsSignal->fillNext(myEthFrame.getData());
int timerCount = 0;
while (theirNoAlarms == 0)
{
timerCount ++;
// wait for alarm to go off
boost::thread::yield();
};
cout<<"yield was called "<< timerCount << " times"<<endl;
// we handled one alarm, so decrease it
theirNoAlarms--;
itsStamp += myEthFrame.getData()->getNTimes();
}
void WH_Signal::postprocess()
{
theirNoRunningWHs--;
if (theirNoRunningWHs == 0)
{
theirTimerSet = false;
if (itsFrequency != 0) {
// unset timer
struct itimerval value;
memset (&value, 0, sizeof(itimerval));
setitimer(ITIMER_REAL, &value, 0);
// remove sig handler
sighandler_t ret = signal(SIGALRM, SIG_DFL);
ASSERTSTR(ret != SIG_ERR, "WH_Signal couldn't unset signal handler for timer");
}
}
}
void WH_Signal::timerSignal(int sig)
{
// set the number of frames that can be sent
theirNoAlarms += theirNoRunningWHs;
}
} // namespace Generator
} // namespace LOFAR
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment