TMFE Class Reference

#include <tmfe.h>

Collaboration diagram for TMFE:

Public Member Functions
TMFeResult	Connect (const char *progname=NULL, const char *hostname=NULL, const char *exptname=NULL)
TMFeResult	Disconnect ()
void	RpcThread ()
void	StartRpcThread ()
void	StopRpcThread ()
TMFeResult	EventBufferOpen (TMEventBuffer **pbuf, const char *bufname, size_t bufsize=0)
TMFeResult	EventBufferFlushCacheAll (bool wait=true)
TMFeResult	EventBufferCloseAll ()
void	StopRun ()
void	StartRun ()
TMFeResult	SetWatchdogSec (int sec)
void	Yield (double sleep_sec)
void	MidasPeriodicTasks ()
TMFeResult	TriggerAlarm (const char *name, const char *message, const char *aclass)
TMFeResult	ResetAlarm (const char *name)
void	Msg (int message_type, const char *filename, int line, const char *routine, const char *format,...) MATTRPRINTF(6
void void	Msg (int message_type, const char *filename, int line, const char *routine, const std::string &message)
void	AddRpcHandler (TMFeRpcHandlerInterface *)
void	RemoveRpcHandler (TMFeRpcHandlerInterface *)
void	SetTransitionSequenceStart (int seqno)
void	SetTransitionSequenceStop (int seqno)
void	SetTransitionSequencePause (int seqno)
void	SetTransitionSequenceResume (int seqno)
void	SetTransitionSequenceStartAbort (int seqno)
void	DeregisterTransitions ()
void	DeregisterTransitionStart ()
void	DeregisterTransitionStop ()
void	DeregisterTransitionPause ()
void	DeregisterTransitionResume ()
void	DeregisterTransitionStartAbort ()
void	RegisterTransitionStartAbort ()
void	RegisterRPCs ()
TMFeError	Connect (const char *progname, const char *filename=NULL, const char *hostname=NULL, const char *exptname=NULL)
TMFeError	Disconnect ()
TMFeError	RegisterEquipment (TMFeEquipment *eq)
void	RegisterRpcHandler (TMFeRpcHandlerInterface *handler)
	RPC handlers are executed from the RPC thread, if started.
void	RegisterPeriodicHandler (TMFeEquipment *eq, TMFePeriodicHandlerInterface *handler)
	periodic handlers are executed from the periodic thread, if started
void	StartRpcThread ()
void	StartPeriodicThread ()
void	StopRpcThread ()
void	StopPeriodicThread ()
TMFeError	SetWatchdogSec (int sec)
void	PollMidas (int millisec)
void	MidasPeriodicTasks ()
void	EquipmentPeriodicTasks ()
TMFeError	TriggerAlarm (const char *name, const char *message, const char *aclass)
TMFeError	ResetAlarm (const char *name)
void	Msg (int message_type, const char *filename, int line, const char *routine, const char *format,...) MATTRPRINTF(6
void void	SetTransitionSequenceStart (int seqno)
void	SetTransitionSequenceStop (int seqno)
void	SetTransitionSequencePause (int seqno)
void	SetTransitionSequenceResume (int seqno)
void	SetTransitionSequenceStartAbort (int seqno)
void	DeregisterTransitions ()
void	DeregisterTransitionStart ()
void	DeregisterTransitionStop ()
void	DeregisterTransitionPause ()
void	DeregisterTransitionResume ()
void	DeregisterTransitionStartAbort ()
void	RegisterTransitionStartAbort ()

Static Public Member Functions
static TMFE *	Instance ()
static double	GetTime ()
	return current time in seconds, with micro-second precision
static void	Sleep (double sleep_time_sec)
	sleep, with micro-second precision
static std::string	GetThreadId ()
	return identification of this thread
static TMFE *	Instance ()
static double	GetTime ()
	return current time in seconds, with micro-second precision
static void	Sleep (double sleep_time_sec)
	sleep, with micro-second precision
static std::string	GetThreadId ()
	return identification of this thread

Public Attributes
std::string	fExptname
	experiment name, blank if only one experiment defined in exptab
std::string	fMserverHostname
	hostname where the mserver is running, blank if using shared memory
std::string	fProgramName
	frontend program name
std::string	fHostname
	hostname we are running on
std::mutex	fMutex
int	fDB = 0
	ODB database handle.
MVOdb *	fOdbRoot = NULL
	ODB root.
std::atomic_bool	fShutdownRequested {false}
	shutdown was requested by Ctrl-C or by RPC command
int	fRunNumber = 0
	current run number
bool	fStateRunning = false
	run state is running or paused
std::thread *	fRpcThread = NULL
std::atomic_bool	fRpcThreadStarting {false}
std::atomic_bool	fRpcThreadRunning {false}
std::atomic_bool	fRpcThreadShutdownRequested {false}
std::mutex	fEventBuffersMutex
std::vector< TMEventBuffer * >	fEventBuffers
bool	fRunStopRequested = false
	run stop was requested by equipment
double	fRunStartTime = 0
	start a new run at this time
std::vector< TMFeRpcHandlerInterface * >	fRpcHandlers
std::string	fFrontendName
	frontend program name
std::string	fFrontendHostname
	frontend hostname
std::string	fFrontendFilename
	frontend program file name
bool	fShutdownRequested
	shutdown was requested by Ctrl-C or by RPC command
std::vector< TMFeEquipment * >	fEquipments
std::vector< TMFePeriodicHandler * >	fPeriodicHandlers
double	fNextPeriodic
bool	fRpcThreadStarting
bool	fRpcThreadRunning
bool	fRpcThreadShutdownRequested
bool	fPeriodicThreadStarting
bool	fPeriodicThreadRunning
bool	fPeriodicThreadShutdownRequested

Static Public Attributes
static bool	gfVerbose = false

Private Member Functions
	TMFE ()
	default constructor is private for singleton classes
virtual	~TMFE ()
	destructor is private for singleton classes
	TMFE ()
	default constructor is private for singleton classes
virtual	~TMFE ()
	destructor is private for singleton classes

Static Private Attributes
static TMFE *	gfMFE = NULL

Detailed Description

Definition at line 380 of file tmfe.h.

Constructor & Destructor Documentation

TMFE() [1/2]

TMFE::TMFE ( )

private

default constructor is private for singleton classes

Definition at line 44 of file tmfe.cxx.

{
   if (gfVerbose)
      printf("TMFE::ctor!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

~TMFE() [1/2]

TMFE::~TMFE ( )

privatevirtual

destructor is private for singleton classes

Definition at line 50 of file tmfe.cxx.

{
   if (gfVerbose)
      printf("TMFE::dtor!\n");
   assert(!"TMFE::~TMFE(): destruction of the TMFE singleton is not permitted!");
}

Here is the call graph for this function:

TMFE() [2/2]

TMFE::TMFE ( )

private

default constructor is private for singleton classes

~TMFE() [2/2]

virtual TMFE::~TMFE ( )

privatevirtual

destructor is private for singleton classes

Member Function Documentation

AddRpcHandler()

void TMFE::AddRpcHandler

(

TMFeRpcHandlerInterface *

h

)

Definition at line 1526 of file tmfe.cxx.

{
   fRpcHandlers.push_back(h);
}

Here is the caller graph for this function:

Connect() [1/2]

TMFeError TMFE::Connect	(	const char *	progname,
		const char *	filename = NULL,
		const char *	hostname = NULL,
		const char *	exptname = NULL
	)

Definition at line 51 of file tmfe_rev0.cxx.

{
   if (progname)
      fFrontendName     = progname;
   if (filename)
      fFrontendFilename = filename;
 
   fFrontendHostname = ss_gethostname();
 
   int status;
  
   char xhostname[HOST_NAME_LENGTH];
   char xexptname[NAME_LENGTH];
   
   /* get default from environment */
   status = cm_get_environment(xhostname, sizeof(xhostname), xexptname, sizeof(xexptname));
   assert(status == CM_SUCCESS);
   
   if (hostname)
      mstrlcpy(xhostname, hostname, sizeof(xhostname));
   
   if (exptname)
      mstrlcpy(xexptname, exptname, sizeof(xexptname));
   
   fHostname = xhostname;
   fExptname = xexptname;
   
   fprintf(stderr, "TMFE::Connect: Program \"%s\" connecting to experiment \"%s\" on host \"%s\"\n", progname, fExptname.c_str(), fHostname.c_str());
   
   int watchdog = DEFAULT_WATCHDOG_TIMEOUT;
   //int watchdog = 60*1000;
   
   status = cm_connect_experiment1(fHostname.c_str(), fExptname.c_str(), progname, NULL, DEFAULT_ODB_SIZE, watchdog);
   
   if (status == CM_UNDEF_EXP) {
      fprintf(stderr, "TMidasOnline::connect: Error: experiment \"%s\" not defined.\n", fExptname.c_str());
      return TMFeError(status, "experiment is not defined");
   } else if (status != CM_SUCCESS) {
      fprintf(stderr, "TMidasOnline::connect: Cannot connect to MIDAS, status %d.\n", status);
      return TMFeError(status, "cannot connect");
   }
 
   status = cm_get_experiment_database(&fDB, NULL);
   if (status != CM_SUCCESS) {
      return TMFeError(status, "cm_get_experiment_database");
   }
 
   fOdbRoot = MakeMidasOdb(fDB);
  
   return TMFeError();
}

Here is the call graph for this function:

Connect() [2/2]

TMFeResult TMFE::Connect	(	const char *	progname = NULL,
		const char *	hostname = NULL,
		const char *	exptname = NULL
	)

Definition at line 65 of file tmfe.cxx.

{
   if (progname)
      fProgramName = progname;
 
   if (fProgramName.empty()) {
      return TMFeErrorMessage("TMFE::Connect: frontend program name is not set");
   }
 
   fHostname = ss_gethostname();
 
   int status;
  
   std::string env_hostname;
   std::string env_exptname;
   
   /* get default from environment */
   status = cm_get_environment(&env_hostname, &env_exptname);
 
   if (status != CM_SUCCESS) {
      return TMFeMidasError("Cannot connect to MIDAS", "cm_get_environment", status);
   }
 
   if (hostname && hostname[0]) {
      fMserverHostname = hostname;
   } else {
      fMserverHostname = env_hostname;
   }
   
   if (exptname && exptname[0]) {
      fExptname = exptname;
   } else {
      fExptname = env_exptname;
   }
 
   if (gfVerbose) {
      printf("TMFE::Connect: Program \"%s\" connecting to experiment \"%s\" on host \"%s\"\n", fProgramName.c_str(), fExptname.c_str(), fMserverHostname.c_str());
   }
   
   int watchdog = DEFAULT_WATCHDOG_TIMEOUT;
   //int watchdog = 60*1000;
   
   status = cm_connect_experiment1(fMserverHostname.c_str(), fExptname.c_str(), fProgramName.c_str(), NULL, DEFAULT_ODB_SIZE, watchdog);
   
   if (status == CM_UNDEF_EXP) {
      return TMFeMidasError(msprintf("Cannot connect to MIDAS, experiment \"%s\" is not defined", fExptname.c_str()), "cm_connect_experiment1", status);
   } else if (status != CM_SUCCESS) {
      return TMFeMidasError("Cannot connect to MIDAS", "cm_connect_experiment1", status);
   }
 
   status = cm_get_experiment_database(&fDB, NULL);
   if (status != CM_SUCCESS) {
      return TMFeMidasError("Cannot connect to MIDAS", "cm_get_experiment_database", status);
   }
 
   fOdbRoot = MakeMidasOdb(fDB);
 
   int run_state = 0;
 
   fOdbRoot->RI("Runinfo/state", &run_state);
   fOdbRoot->RI("Runinfo/run number", &fRunNumber);
 
   if (run_state == STATE_RUNNING) {
      fStateRunning = true;
   } else if (run_state == STATE_PAUSED) {
      fStateRunning = true;
   } else {
      fStateRunning = false;
   }
 
   RegisterRPCs();
 
   if (gfVerbose) {
      printf("TMFE::Connect: Program \"%s\" connected to experiment \"%s\" on host \"%s\"\n", fProgramName.c_str(), fExptname.c_str(), fMserverHostname.c_str());
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeregisterTransitionPause() [1/2]

void TMFE::DeregisterTransitionPause

(

)

Definition at line 1492 of file tmfe.cxx.

{
   cm_deregister_transition(TR_PAUSE);
}

Here is the call graph for this function:

DeregisterTransitionPause() [2/2]

void TMFE::DeregisterTransitionPause

(

)

DeregisterTransitionResume() [1/2]

void TMFE::DeregisterTransitionResume

(

)

Definition at line 1497 of file tmfe.cxx.

{
   cm_deregister_transition(TR_RESUME);
}

Here is the call graph for this function:

DeregisterTransitionResume() [2/2]

void TMFE::DeregisterTransitionResume

(

)

DeregisterTransitions() [1/2]

void TMFE::DeregisterTransitions

(

)

Definition at line 1473 of file tmfe.cxx.

{
   cm_deregister_transition(TR_START);
   cm_deregister_transition(TR_STOP);
   cm_deregister_transition(TR_PAUSE);
   cm_deregister_transition(TR_RESUME);
   cm_deregister_transition(TR_STARTABORT);
}

Here is the call graph for this function:

DeregisterTransitions() [2/2]

void TMFE::DeregisterTransitions

(

)

DeregisterTransitionStart() [1/2]

void TMFE::DeregisterTransitionStart

(

)

Definition at line 1482 of file tmfe.cxx.

{
   cm_deregister_transition(TR_START);
}

Here is the call graph for this function:

DeregisterTransitionStart() [2/2]

void TMFE::DeregisterTransitionStart

(

)

DeregisterTransitionStartAbort() [1/2]

void TMFE::DeregisterTransitionStartAbort

(

)

Definition at line 1502 of file tmfe.cxx.

{
   cm_deregister_transition(TR_STARTABORT);
}

Here is the call graph for this function:

DeregisterTransitionStartAbort() [2/2]

void TMFE::DeregisterTransitionStartAbort

(

)

DeregisterTransitionStop() [1/2]

void TMFE::DeregisterTransitionStop

(

)

Definition at line 1487 of file tmfe.cxx.

{
   cm_deregister_transition(TR_STOP);
}

Here is the call graph for this function:

DeregisterTransitionStop() [2/2]

void TMFE::DeregisterTransitionStop

(

)

Disconnect() [1/2]

TMFeError TMFE::Disconnect

(

)

Definition at line 154 of file tmfe.cxx.

{
   if (gfVerbose)
      printf("TMFE::Disconnect: Disconnecting from experiment \"%s\" on host \"%s\"\n", fExptname.c_str(), fMserverHostname.c_str());
   StopRpcThread();
   cm_disconnect_experiment();
   if (gfVerbose)
      printf("TMFE::Disconnect: Disconnected from experiment \"%s\" on host \"%s\"\n", fExptname.c_str(), fMserverHostname.c_str());
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Disconnect() [2/2]

TMFeError TMFE::Disconnect

(

)

EquipmentPeriodicTasks()

void TMFE::EquipmentPeriodicTasks

(

)

Definition at line 128 of file tmfe_rev0.cxx.

{
   double now = GetTime();
 
   if (fNextPeriodic == 0 || now >= fNextPeriodic) {
      int n = fPeriodicHandlers.size();
      fNextPeriodic = 0;
      for (int i=0; i<n; i++) {
         TMFePeriodicHandler* h = fPeriodicHandlers[i];
         double period = h->fEq->fCommon->Period/1000.0;
         //printf("periodic[%d] period %f, last call %f, next call %f (+%f)\n", i, period, h->fLastCallTime, h->fNextCallTime, now - h->fNextCallTime);
         if (period <= 0)
            continue;
         if (h->fNextCallTime == 0 || now >= h->fNextCallTime) {
            h->fLastCallTime = now;
            h->fNextCallTime = h->fLastCallTime + period;
 
            if (h->fNextCallTime < now) {
               fprintf(stderr, "TMFE::EquipmentPeriodicTasks: periodic equipment does not keep up!\n"); // FIXME
               while (h->fNextCallTime < now) {
                  h->fNextCallTime += period;
               }
            }
 
            if (fNextPeriodic == 0)
               fNextPeriodic = h->fNextCallTime;
            else if (h->fNextCallTime < fNextPeriodic)
               fNextPeriodic = h->fNextCallTime;
 
            h->fHandler->HandlePeriodic();
 
            now = GetTime();
         }
      }
 
      //printf("next periodic %f (+%f)\n", fNextPeriodic, fNextPeriodic - now);
   } else {
      //printf("next periodic %f (+%f), waiting\n", fNextPeriodic, fNextPeriodic - now);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

EventBufferCloseAll()

TMFeResult TMFE::EventBufferCloseAll

(

)

Definition at line 484 of file tmfe.cxx.

{
   std::lock_guard<std::mutex> guard(fEventBuffersMutex);
 
   for (auto b : fEventBuffers) {
      if (!b)
         continue;
      TMFeResult r = b->CloseBuffer();
      if (r.error_flag)
         return r;
 
      delete b;
   }
 
   fEventBuffers.clear();
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EventBufferFlushCacheAll()

TMFeResult TMFE::EventBufferFlushCacheAll

(

bool

wait = true

)

Definition at line 448 of file tmfe.cxx.

{
   int flag = BM_NO_WAIT;
   if (wait)
      flag = BM_WAIT;
 
   /* flush of event socket in no-wait mode does nothing */
   if (wait && rpc_is_remote()) {
      int status = bm_flush_cache(0, flag);
 
      //printf("bm_flush_cache(0,%d) status %d\n", flag, status);
 
      if (status == BM_SUCCESS) {
         // nothing
      } else if (status == BM_ASYNC_RETURN) {
         // nothing
      } else {
         return TMFeMidasError("Cannot flush mserver event socket", "bm_flush_cache", status);
      }
   }
 
   std::lock_guard<std::mutex> guard(fEventBuffersMutex);
 
   for (auto b : fEventBuffers) {
      if (!b)
         continue;
 
      TMFeResult r = b->FlushCache(wait);
 
      if (r.error_flag)
         return r;
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

EventBufferOpen()

TMFeResult TMFE::EventBufferOpen	(	TMEventBuffer **	pbuf,
		const char *	bufname,
		size_t	bufsize = 0
	)

Definition at line 413 of file tmfe.cxx.

{
   assert(pbuf != NULL);
   assert(bufname != NULL);
   
   std::lock_guard<std::mutex> guard(fEventBuffersMutex);
 
   for (auto b : fEventBuffers) {
      if (!b)
         continue;
 
      if (b->fBufName == bufname) {
         *pbuf = b;
         if (bufsize != 0 && bufsize > b->fBufSize) {
            Msg(MERROR, "TMFE::EventBufferOpen", "Event buffer \"%s\" size %d is smaller than requested size %d", b->fBufName.c_str(), (int)b->fBufSize, (int)bufsize);
         }
         return TMFeOk();
      }
   }
 
   TMEventBuffer *b = new TMEventBuffer(this);
 
   fEventBuffers.push_back(b);
 
   *pbuf = b;
 
   TMFeResult r = b->OpenBuffer(bufname, bufsize);
 
   if (r.error_flag) {
      return r;
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetThreadId() [1/2]

std::string TMFE::GetThreadId ( )

static

return identification of this thread

Definition at line 1140 of file tmfe.cxx.

{
   return ss_tid_to_string(ss_gettid());
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetThreadId() [2/2]

static std::string TMFE::GetThreadId ( )

static

return identification of this thread

GetTime() [1/2]

double TMFE::GetTime ( )

static

return current time in seconds, with micro-second precision

Definition at line 1011 of file tmfe.cxx.

{
   struct timeval tv;
   gettimeofday(&tv, NULL);
   return tv.tv_sec*1.0 + tv.tv_usec/1000000.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetTime() [2/2]

static double TMFE::GetTime ( )

static

return current time in seconds, with micro-second precision

Instance() [1/2]

TMFE * TMFE::Instance ( )

static

TMFE is a singleton class. Call instance() to get a reference to the one instance of this class.

Definition at line 57 of file tmfe.cxx.

{
   if (!gfMFE)
      gfMFE = new TMFE();
   
   return gfMFE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Instance() [2/2]

static TMFE * TMFE::Instance ( )

static

TMFE is a singleton class. Call instance() to get a reference to the one instance of this class.

MidasPeriodicTasks() [1/2]

void TMFE::MidasPeriodicTasks

(

)

Definition at line 852 of file tmfe.cxx.

{
   cm_periodic_tasks();
}

Here is the call graph for this function:

MidasPeriodicTasks() [2/2]

void TMFE::MidasPeriodicTasks

(

)

Msg() [1/3]

void TMFE::Msg	(	int	message_type,
		const char *	filename,
		int	line,
		const char *	routine,
		const char *	format,
			...
	)

Definition at line 991 of file tmfe.cxx.

{
   char message[1024];
   //printf("format [%s]\n", format);
   va_list ap;
   va_start(ap, format);
   vsnprintf(message, sizeof(message)-1, format, ap);
   va_end(ap);
   //printf("message [%s]\n", message);
   cm_msg(message_type, filename, line, routine, "%s", message);
   cm_msg_flush_buffer();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Msg() [2/3]

void TMFE::Msg	(	int	message_type,
		const char *	filename,
		int	line,
		const char *	routine,
		const char *	format,
			...
	)

Msg() [3/3]

void TMFE::Msg	(	int	message_type,
		const char *	filename,
		int	line,
		const char *	routine,
		const std::string &	message
	)

Definition at line 1004 of file tmfe.cxx.

{
   //printf("message [%s]\n", message.c_str());
   cm_msg(message_type, filename, line, routine, "%s", message.c_str());
   cm_msg_flush_buffer();
}

Here is the call graph for this function:

PollMidas()

void TMFE::PollMidas

(

int

millisec

)

Definition at line 169 of file tmfe_rev0.cxx.

{
   double now = GetTime();
   //double sleep_start = now;
   double sleep_end = now + msec/1000.0;
 
   while (!fShutdownRequested) {
      if (!fPeriodicThreadRunning) {
         EquipmentPeriodicTasks();
      }
 
      now = GetTime();
 
      double sleep_time = sleep_end - now;
      int s = 0;
      if (sleep_time > 0)
         s = 1 + sleep_time*1000.0;
 
      //printf("now %f, sleep_end %f, s %d\n", now, sleep_end, s);
      
      int status = cm_yield(s);
      
      if (status == RPC_SHUTDOWN || status == SS_ABORT) {
         fShutdownRequested = true;
         fprintf(stderr, "TMFE::PollMidas: cm_yield(%d) status %d, shutdown requested...\n", msec, status);
      }
 
      now = GetTime();
      if (now >= sleep_end)
         break;
   }
 
   //printf("TMFE::PollMidas: msec %d, actual %f msec\n", msec, (now - sleep_start) * 1000.0);
}

Here is the call graph for this function:

RegisterEquipment()

TMFeError TMFE::RegisterEquipment

(

TMFeEquipment *

eq

)

Definition at line 122 of file tmfe_rev0.cxx.

{
   fEquipments.push_back(eq);
   return TMFeError();
}

RegisterPeriodicHandler()

void TMFE::RegisterPeriodicHandler	(	TMFeEquipment *	eq,
		TMFePeriodicHandlerInterface *	handler
	)

periodic handlers are executed from the periodic thread, if started

Definition at line 579 of file tmfe_rev0.cxx.

{
   TMFePeriodicHandler *p = new TMFePeriodicHandler();
   p->fEq = eq;
   p->fHandler = h;
   fPeriodicHandlers.push_back(p);
   fNextPeriodic = 0;
}

RegisterRpcHandler()

void TMFE::RegisterRpcHandler

(

TMFeRpcHandlerInterface *

handler

)

RPC handlers are executed from the RPC thread, if started.

Definition at line 484 of file tmfe_rev0.cxx.

{
   if (fRpcHandlers.size() == 0) {
      // for the first handler, register with MIDAS
      cm_register_function(RPC_JRPC, rpc_callback);
      cm_register_transition(TR_START, tr_start, 500);
      cm_register_transition(TR_STOP, tr_stop, 500);
      cm_register_transition(TR_PAUSE, tr_pause, 500);
      cm_register_transition(TR_RESUME, tr_resume, 500);
      //cm_register_transition(TR_STARTABORT, tr_startabort, 500);
   }
 
   fRpcHandlers.push_back(h);
}

Here is the call graph for this function:

RegisterRPCs()

void TMFE::RegisterRPCs

(

)

Definition at line 1512 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::RegisterRPCs!\n");
   
   cm_register_function(RPC_JRPC, rpc_callback);
   cm_register_function(RPC_BRPC, binary_rpc_callback);
   cm_register_transition(TR_START, tr_start, 500);
   cm_register_transition(TR_STOP, tr_stop, 500);
   cm_register_transition(TR_PAUSE, tr_pause, 500);
   cm_register_transition(TR_RESUME, tr_resume, 500);
   cm_register_transition(TR_STARTABORT, tr_startabort, 500);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterTransitionStartAbort() [1/2]

void TMFE::RegisterTransitionStartAbort

(

)

Definition at line 1507 of file tmfe.cxx.

{
   cm_register_transition(TR_STARTABORT, tr_startabort, 500);
}

Here is the call graph for this function:

Here is the caller graph for this function:

RegisterTransitionStartAbort() [2/2]

void TMFE::RegisterTransitionStartAbort

(

)

RemoveRpcHandler()

void TMFE::RemoveRpcHandler

(

TMFeRpcHandlerInterface *

h

)

Definition at line 1531 of file tmfe.cxx.

{
   for (unsigned i=0; i<fRpcHandlers.size(); i++) {
      if (fRpcHandlers[i] == h) {
         fRpcHandlers[i] = NULL;
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetAlarm() [1/2]

TMFeError TMFE::ResetAlarm

(

const char *

name

)

Definition at line 2239 of file tmfe.cxx.

{
   int status = al_reset_alarm(name);
 
   if (status) {
      return TMFeMidasError("Cannot reset alarm", "al_reset_alarm", status);
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

ResetAlarm() [2/2]

TMFeError TMFE::ResetAlarm

(

const char *

name

)

RpcThread()

void TMFE::RpcThread

(

)

Definition at line 857 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::RpcThread: RPC thread started\n");
 
   int msec = 1000;
 
   fRpcThreadRunning = true;
   ss_suspend_set_rpc_thread(ss_gettid());
 
   while (!fShutdownRequested && !fRpcThreadShutdownRequested) {
 
      int status = cm_yield(msec);
 
      if (status == RPC_SHUTDOWN || status == SS_ABORT) {
         fShutdownRequested = true;
         if (TMFE::gfVerbose)
            printf("TMFE::RpcThread: cm_yield(%d) status %d, shutdown requested...\n", msec, status);
      }
   }
   ss_suspend_exit();
   if (TMFE::gfVerbose)
      printf("TMFE::RpcThread: RPC thread stopped\n");
   fRpcThreadRunning = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetTransitionSequencePause() [1/2]

void TMFE::SetTransitionSequencePause

(

int

seqno

)

Definition at line 1458 of file tmfe.cxx.

{
   cm_set_transition_sequence(TR_PAUSE, seqno);
}

Here is the call graph for this function:

SetTransitionSequencePause() [2/2]

void TMFE::SetTransitionSequencePause

(

int

seqno

)

SetTransitionSequenceResume() [1/2]

void TMFE::SetTransitionSequenceResume

(

int

seqno

)

Definition at line 1463 of file tmfe.cxx.

{
   cm_set_transition_sequence(TR_RESUME, seqno);
}

Here is the call graph for this function:

SetTransitionSequenceResume() [2/2]

void TMFE::SetTransitionSequenceResume

(

int

seqno

)

SetTransitionSequenceStart() [1/2]

void TMFE::SetTransitionSequenceStart

(

int

seqno

)

Definition at line 1448 of file tmfe.cxx.

{
   cm_set_transition_sequence(TR_START, seqno);
}

Here is the call graph for this function:

SetTransitionSequenceStart() [2/2]

void void TMFE::SetTransitionSequenceStart

(

int

seqno

)

SetTransitionSequenceStartAbort() [1/2]

void TMFE::SetTransitionSequenceStartAbort

(

int

seqno

)

Definition at line 1468 of file tmfe.cxx.

{
   cm_set_transition_sequence(TR_STARTABORT, seqno);
}

Here is the call graph for this function:

SetTransitionSequenceStartAbort() [2/2]

void TMFE::SetTransitionSequenceStartAbort

(

int

seqno

)

SetTransitionSequenceStop() [1/2]

void TMFE::SetTransitionSequenceStop

(

int

seqno

)

Definition at line 1453 of file tmfe.cxx.

{
   cm_set_transition_sequence(TR_STOP, seqno);
}

Here is the call graph for this function:

SetTransitionSequenceStop() [2/2]

void TMFE::SetTransitionSequenceStop

(

int

seqno

)

SetWatchdogSec() [1/2]

TMFeError TMFE::SetWatchdogSec

(

int

sec

)

Definition at line 144 of file tmfe.cxx.

{
   if (sec == 0) {
      cm_set_watchdog_params(false, 0);
   } else {
      cm_set_watchdog_params(true, sec*1000);
   }
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetWatchdogSec() [2/2]

TMFeError TMFE::SetWatchdogSec

(

int

sec

)

Sleep() [1/2]

void TMFE::Sleep ( double  sleep_time_sec )

static

sleep, with micro-second precision

Definition at line 1019 of file tmfe.cxx.

{
   if (time_sec < 0) {
      TMFE::Instance()->Msg(MERROR, "TMFE::Sleep", "TMFE::Sleep() called with negative sleep time: %f", time_sec);
      return;
   }
   
   if (time_sec == 0) {
      TMFE::Instance()->Msg(MERROR, "TMFE::Sleep", "TMFE::Sleep() called with zero sleep time");
      return;
   }
 
   if (time_sec > 1.01) {
      // break long sleep into short sleeps
 
      double t0 = TMFE::GetTime();
      double tend = t0 + time_sec;
 
      while (1) {
         double now = TMFE::GetTime();
         if (now >= tend) {
            //printf("t0 %f, tend %f, now %f, done!\n", t0, tend, now);
            return;
         }
 
         double tsleep = tend - now;
 
         //printf("t0 %f, tend %f, now %f, tsleep %f!\n", t0, tend, now, tsleep);
 
         if (tsleep > 1.0)
            tsleep = 1.0;
 
         TMFE::Sleep(tsleep);
      }
 
      return;
   }
   
   int status;
   struct timeval timeout;
      
   timeout.tv_sec = time_sec;
   timeout.tv_usec = (time_sec-timeout.tv_sec)*1000000.0;
 
   while (1) {
      status = select(0, NULL, NULL, NULL, &timeout);
#ifdef EINVAL
      if (status < 0 && errno == EINVAL) {
         // #warning HERE EINVAL!
         TMFE::Instance()->Msg(MERROR, "TMFE::Sleep", "TMFE::Sleep() called with invalid sleep time: %f, tv_sec: %lld, tv_usec: %lld", time_sec, (long long int)timeout.tv_sec, (long long int)timeout.tv_usec);
         return;
      }
#endif
#ifdef EINTR
      if (status < 0 && errno == EINTR) {
         // #warning HERE EINTR!
         // NOTE1: on linux, "timeout" is modified by the kernel to subtract time already slept, we do not need to adjust it while handling EINTR.
         // NOTE2: on macos and other BSD-based systems, "timeout" value is not changed, and for accurate sleeping we should modify here, to account for time already slept, but we do not.
         // NOTE3: see "man select" on Linux and Macos.
         // NOTE4: MIDAS no longer uses SIGALRM to run cm_watchdog() and MIDAS applications do nto use signals.
         // NOTE4: so in theory, we do not have to worry about EINTR interrupting our sleep. K.O. Dec-2024
         // TMFE::Instance()->Msg(MERROR, "TMFE::Sleep", "TMFE::Sleep() EINTR, sleep time: %f, tv_sec: %lld, tv_usec: %lld", time_sec, (long long int)timeout.tv_sec, (long long int)timeout.tv_usec);
         continue;
      }
#endif
      break;
   }
      
   if (status < 0) {
      TMFE::Instance()->Msg(MERROR, "TMFE::Sleep", "select() returned %d, errno %d (%s)", status, errno, strerror(errno));
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Sleep() [2/2]

static void TMFE::Sleep ( double  sleep_time_sec )

static

sleep, with micro-second precision

StartPeriodicThread()

void TMFE::StartPeriodicThread

(

)

Definition at line 262 of file tmfe_rev0.cxx.

{
   if (fPeriodicThreadRunning || fPeriodicThreadStarting) {
      fprintf(stderr, "TMFE::StartPeriodicThread: periodic thread already running\n");
      return;
   }
 
   fPeriodicThreadStarting = true;
   ss_thread_create(tmfe_periodic_thread, NULL);
}

Here is the call graph for this function:

StartRpcThread() [1/2]

void TMFE::StartRpcThread

(

)

Definition at line 903 of file tmfe.cxx.

{
   // NOTE: this is thread safe
 
   std::lock_guard<std::mutex> guard(fMutex);
   
   if (fRpcThreadRunning || fRpcThreadStarting || fRpcThread) {
      if (gfVerbose)
         printf("TMFE::StartRpcThread: RPC thread already running\n");
      return;
   }
   
   fRpcThreadStarting = true;
   fRpcThread = new std::thread(&TMFE::RpcThread, this);
}

Here is the call graph for this function:

StartRpcThread() [2/2]

void TMFE::StartRpcThread

(

)

StartRun()

void TMFE::StartRun

(

)

Definition at line 714 of file tmfe.cxx.

{
   fRunStartTime = 0;
 
   /* check if really stopped */
   int run_state = 0;
   fOdbRoot->RI("Runinfo/State", &run_state);
 
   if (run_state != STATE_STOPPED) {
      Msg(MERROR, "TMFE::StartRun", "Run start requested, but run is already in progress");
      return;
   }
 
   bool logger_auto_restart = false;
   fOdbRoot->RB("Logger/Auto restart", &logger_auto_restart);
 
   if (!logger_auto_restart) {
      Msg(MERROR, "TMFE::StartRun", "Run start requested, but logger/auto restart is off");
      return;
   }
 
   Msg(MTALK, "TMFE::StartRun", "Starting new run");
 
   char str[TRANSITION_ERROR_STRING_LENGTH];
 
   int status = cm_transition(TR_START, 0, str, sizeof(str), TR_SYNC, FALSE);
   if (status != CM_SUCCESS) {
      Msg(MERROR, "TMFE::StartRun", "Cannot restart run, error: %s", str);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

StopPeriodicThread()

void TMFE::StopPeriodicThread

(

)

Definition at line 294 of file tmfe_rev0.cxx.

{
   if (!fPeriodicThreadRunning)
      return;
   
   fPeriodicThreadStarting = false;
   fPeriodicThreadShutdownRequested = true;
   for (int i=0; i<60; i++) {
      if (!fPeriodicThreadRunning)
         break;
      if (i>5) {
         fprintf(stderr, "TMFE::StopPeriodicThread: waiting for periodic thread to stop\n");
      }
      ::sleep(1);
   }
 
   if (fPeriodicThreadRunning) {
      fprintf(stderr, "TMFE::StopPeriodicThread: timeout waiting for periodic thread to stop\n");
   }
}

Here is the call graph for this function:

StopRpcThread() [1/2]

void TMFE::StopRpcThread

(

)

Definition at line 935 of file tmfe.cxx.

{
   // NOTE: this is thread safe
   
   fRpcThreadStarting = false;
   fRpcThreadShutdownRequested = true;
   
   for (int i=0; i<60; i++) {
      if (!fRpcThreadRunning) {
         std::lock_guard<std::mutex> guard(fMutex);
         if (fRpcThread) {
            fRpcThread->join();
            delete fRpcThread;
            fRpcThread = NULL;
            if (gfVerbose)
               printf("TMFE::StopRpcThread: RPC thread stopped\n");
         }
         return;
      }
      if (i>5) {
         fprintf(stderr, "TMFE::StopRpcThread: waiting for RPC thread to stop\n");
      }
      ::sleep(1);
   }
 
   fprintf(stderr, "TMFE::StopRpcThread: timeout waiting for RPC thread to stop\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

StopRpcThread() [2/2]

void TMFE::StopRpcThread

(

)

StopRun()

void TMFE::StopRun

(

)

Definition at line 687 of file tmfe.cxx.

{
   char str[TRANSITION_ERROR_STRING_LENGTH];
 
   int status = cm_transition(TR_STOP, 0, str, sizeof(str), TR_SYNC, FALSE);
   if (status != CM_SUCCESS) {
      Msg(MERROR, "TMFE::StopRun", "Cannot stop run, error: %s", str);
      fRunStopRequested = false;
      return;
   }
 
   fRunStopRequested = false;
 
   bool logger_auto_restart = false;
   fOdbRoot->RB("Logger/Auto restart", &logger_auto_restart);
 
   int logger_auto_restart_delay = 0;
   fOdbRoot->RI("Logger/Auto restart delay", &logger_auto_restart_delay);
 
   if (logger_auto_restart) {
      Msg(MINFO, "TMFE::StopRun", "Run will restart after %d seconds", logger_auto_restart_delay);
      fRunStartTime = GetTime() + logger_auto_restart_delay;
   } else {
      fRunStartTime = 0;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TriggerAlarm() [1/2]

TMFeError TMFE::TriggerAlarm	(	const char *	name,
		const char *	message,
		const char *	aclass
	)

Definition at line 2228 of file tmfe.cxx.

{
   int status = al_trigger_alarm(name, message, aclass, message, AT_INTERNAL);
 
   if (status) {
      return TMFeMidasError("Cannot trigger alarm", "al_trigger_alarm", status);
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

TriggerAlarm() [2/2]

TMFeError TMFE::TriggerAlarm	(	const char *	name,
		const char *	message,
		const char *	aclass
	)

Yield()

void TMFE::Yield

(

double

sleep_sec

)

Definition at line 821 of file tmfe.cxx.

{
   double now = GetTime();
   //double sleep_start = now;
   double sleep_end = now + sleep_sec;
 
   while (!fShutdownRequested) {
      now = GetTime();
 
      double sleep_time = sleep_end - now;
      int s = 0;
      if (sleep_time > 0)
         s = 1 + sleep_time*1000.0;
 
      //printf("TMFE::Yield: now %f, sleep_end %f, s %d\n", now, sleep_end, s);
      
      int status = cm_yield(s);
      
      if (status == RPC_SHUTDOWN || status == SS_ABORT) {
         fShutdownRequested = true;
         fprintf(stderr, "TMFE::Yield: cm_yield(%d) status %d, shutdown requested...\n", s, status);
      }
 
      now = GetTime();
      if (now >= sleep_end)
         break;
   }
 
   //printf("TMFE::Yield: sleep_sec %.6f, actual %.6f sec\n", sleep_sec, now - sleep_start);
}

Here is the call graph for this function:

Member Data Documentation

fDB

int TMFE::fDB = 0

ODB database handle.

Definition at line 394 of file tmfe.h.

fEquipments

std::vector<TMFeEquipment*> TMFE::fEquipments

Definition at line 224 of file tmfe_rev0.h.

fEventBuffers

std::vector<TMEventBuffer*> TMFE::fEventBuffers

Definition at line 436 of file tmfe.h.

fEventBuffersMutex

std::mutex TMFE::fEventBuffersMutex

Definition at line 435 of file tmfe.h.

fExptname

std::string TMFE::fExptname

experiment name, blank if only one experiment defined in exptab

Definition at line 384 of file tmfe.h.

fFrontendFilename

std::string TMFE::fFrontendFilename

frontend program file name

Definition at line 214 of file tmfe_rev0.h.

fFrontendHostname

std::string TMFE::fFrontendHostname

frontend hostname

Definition at line 213 of file tmfe_rev0.h.

fFrontendName

std::string TMFE::fFrontendName

frontend program name

Definition at line 212 of file tmfe_rev0.h.

fHostname

std::string TMFE::fHostname

hostname we are running on

hostname where the mserver is running, blank if using shared memory

Definition at line 388 of file tmfe.h.

fMserverHostname

std::string TMFE::fMserverHostname

hostname where the mserver is running, blank if using shared memory

Definition at line 385 of file tmfe.h.

fMutex

std::mutex TMFE::fMutex

Definition at line 391 of file tmfe.h.

fNextPeriodic

double TMFE::fNextPeriodic

Definition at line 227 of file tmfe_rev0.h.

fOdbRoot

MVOdb * TMFE::fOdbRoot = NULL

ODB root.

Definition at line 395 of file tmfe.h.

fPeriodicHandlers

std::vector<TMFePeriodicHandler*> TMFE::fPeriodicHandlers

Definition at line 226 of file tmfe_rev0.h.

fPeriodicThreadRunning

bool TMFE::fPeriodicThreadRunning

Definition at line 235 of file tmfe_rev0.h.

fPeriodicThreadShutdownRequested

bool TMFE::fPeriodicThreadShutdownRequested

Definition at line 236 of file tmfe_rev0.h.

fPeriodicThreadStarting

bool TMFE::fPeriodicThreadStarting

Definition at line 234 of file tmfe_rev0.h.

fProgramName

std::string TMFE::fProgramName

frontend program name

Definition at line 387 of file tmfe.h.

fRpcHandlers

std::vector< TMFeRpcHandlerInterface * > TMFE::fRpcHandlers

Definition at line 464 of file tmfe.h.

fRpcThread

std::thread* TMFE::fRpcThread = NULL

Definition at line 405 of file tmfe.h.

fRpcThreadRunning [1/2]

std::atomic_bool TMFE::fRpcThreadRunning {false}

Definition at line 407 of file tmfe.h.

{false};

fRpcThreadRunning [2/2]

bool TMFE::fRpcThreadRunning

Definition at line 231 of file tmfe_rev0.h.

fRpcThreadShutdownRequested [1/2]

std::atomic_bool TMFE::fRpcThreadShutdownRequested {false}

Definition at line 408 of file tmfe.h.

{false};

fRpcThreadShutdownRequested [2/2]

bool TMFE::fRpcThreadShutdownRequested

Definition at line 232 of file tmfe_rev0.h.

fRpcThreadStarting [1/2]

std::atomic_bool TMFE::fRpcThreadStarting {false}

Definition at line 406 of file tmfe.h.

{false};

fRpcThreadStarting [2/2]

bool TMFE::fRpcThreadStarting

Definition at line 230 of file tmfe_rev0.h.

fRunNumber

int TMFE::fRunNumber = 0

current run number

Definition at line 401 of file tmfe.h.

fRunStartTime

double TMFE::fRunStartTime = 0

start a new run at this time

Definition at line 445 of file tmfe.h.

fRunStopRequested

bool TMFE::fRunStopRequested = false

run stop was requested by equipment

Definition at line 444 of file tmfe.h.

fShutdownRequested [1/2]

std::atomic_bool TMFE::fShutdownRequested {false}

shutdown was requested by Ctrl-C or by RPC command

Definition at line 398 of file tmfe.h.

{false}; 

fShutdownRequested [2/2]

bool TMFE::fShutdownRequested

shutdown was requested by Ctrl-C or by RPC command

Definition at line 221 of file tmfe_rev0.h.

fStateRunning

bool TMFE::fStateRunning = false

run state is running or paused

Definition at line 402 of file tmfe.h.

gfMFE

static TMFE * TMFE::gfMFE = NULL

staticprivate

TMFE is a singleton class: only one instance is allowed at any time

Definition at line 413 of file tmfe.h.

gfVerbose

bool TMFE::gfVerbose = false

static

Definition at line 424 of file tmfe.h.

---

The documentation for this class was generated from the following files:

• include/tmfe.h
• include/tmfe_rev0.h
• src/tmfe.cxx
• src/tmfe_rev0.cxx