TMFrontend Class Reference

#include <tmfe.h>

Inheritance diagram for TMFrontend:

Collaboration diagram for TMFrontend:

Public Member Functions
	TMFrontend ()
virtual	~TMFrontend ()
int	FeMain (int argc, char *argv[])
int	FeMain (const std::vector< std::string > &args)
void	FeUsage (const char *argv0)
virtual TMFeResult	HandleArguments (const std::vector< std::string > &args)
virtual void	HandleUsage ()
virtual TMFeResult	HandleFrontendInit (const std::vector< std::string > &args)
virtual TMFeResult	HandleFrontendReady (const std::vector< std::string > &args)
virtual void	HandleFrontendExit ()
void	FeSetName (const char *program_name)
TMFeResult	FeAddEquipment (TMFeEquipment *eq)
TMFeResult	FeRemoveEquipment (TMFeEquipment *eq)
TMFeResult	FeInitEquipments (const std::vector< std::string > &args)
void	FeDeleteEquipments ()
void	FeStopEquipmentPollThreads ()
double	FePeriodicTasks ()
double	FePollTasks (double next_periodic_time)
TMFeResult	FeInit (const std::vector< std::string > &args)
void	FeMainLoop ()
void	FeShutdown ()
void	FePollMidas (double sleep_sec)
void	FePeriodicThread ()
void	FeStartPeriodicThread ()
void	FeStopPeriodicThread ()

Public Attributes
TMFE *	fMfe = NULL
TMFrontendRpcHelper *	fFeRpcHelper = NULL
int	fFeIndex = 0
bool	fFeIfRunningCallExit = false
bool	fFeIfRunningCallBeginRun = true
std::mutex	fFeMutex
std::vector< TMFeEquipment * >	fFeEquipments
std::thread *	fFePeriodicThread = NULL
std::atomic_bool	fFePeriodicThreadStarting {false}
std::atomic_bool	fFePeriodicThreadRunning {false}
std::atomic_bool	fFePeriodicThreadShutdownRequested {false}
double	fFeFlushWriteCachePeriodSec = 0.5
double	fFeFlushWriteCacheNextCallTime = 0

Detailed Description

Definition at line 306 of file tmfe.h.

Constructor & Destructor Documentation

TMFrontend()

TMFrontend::TMFrontend

(

)

Definition at line 1597 of file tmfe.cxx.

{
   fMfe = TMFE::Instance();
}

Here is the call graph for this function:

~TMFrontend()

TMFrontend::~TMFrontend ( )

virtual

Definition at line 1602 of file tmfe.cxx.

{
   if (fFeRpcHelper) {
      fMfe->RemoveRpcHandler(fFeRpcHelper);
      delete fFeRpcHelper;
      fFeRpcHelper = NULL;
   }
   // poison all pointers
   fMfe = NULL;
}

Here is the call graph for this function:

Member Function Documentation

FeAddEquipment()

TMFeResult TMFrontend::FeAddEquipment

(

TMFeEquipment *

eq

)

Definition at line 1657 of file tmfe.cxx.

{
   // NOTE: not thread-safe, we modify the fEquipments object. K.O.
   
   // NOTE: should not use range-based for() loop, it uses an iterator and it not thread-safe. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      if (fFeEquipments[i] == eq) {
         fprintf(stderr, "TMFE::AddEquipment: Fatal error: Equipment \"%s\" is already registered, bye...\n", fFeEquipments[i]->fEqName.c_str());
         fMfe->Disconnect();
         exit(1);
         //return TMFeErrorMessage(msprintf("TMFE::AddEquipment: Equipment \"%s\" is already registered", fFeEquipments[i]->fEqName.c_str()));
      }
      if (fFeEquipments[i]->fEqName == eq->fEqName) {
         fprintf(stderr, "TMFE::AddEquipment: Fatal error: Duplicate equipment name \"%s\", bye...\n", eq->fEqName.c_str());
         fMfe->Disconnect();
         exit(1);
         //return TMFeErrorMessage(std::string("TMFE::AddEquipment: Duplicate equipment name \"") + eq->fEqName + "\"");
      }
   }
 
   eq->fFe = this;
 
   // NOTE: fEquipments must be protected again multithreaded access here. K.O.
   fFeEquipments.push_back(eq);
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeDeleteEquipments()

void TMFrontend::FeDeleteEquipments

(

)

Definition at line 1638 of file tmfe.cxx.

{
   // NOTE: this is thread-safe: we do not modify the fEquipments object. K.O.
   // NOTE: this is not thread-safe, we will race against ourselves and do multiple delete of fEquipents[i]. K.O.
 
   // NOTE: should not use range-based for() loop, it uses an iterator and it not thread-safe. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      //printf("delete equipment [%s]\n", fFeEquipments[i]->fEqName.c_str());
      fMfe->RemoveRpcHandler(fFeEquipments[i]);
      delete fFeEquipments[i];
      fFeEquipments[i] = NULL;
   }
 
   fMfe->EventBufferFlushCacheAll();
   fMfe->EventBufferCloseAll();
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeInit()

TMFeResult TMFrontend::FeInit

(

const std::vector< std::string > &

args

)

Definition at line 2346 of file tmfe.cxx.

{
   setbuf(stdout, NULL);
   setbuf(stderr, NULL);
 
   signal(SIGPIPE, SIG_IGN);
 
   std::vector<std::string> eq_args;
 
   bool help = false;
   std::string exptname;
   std::string hostname;
   bool daemon0 = false;
   bool daemon1 = false;
 
   for (unsigned int i=1; i<args.size(); i++) { // loop over the commandline options
      //printf("argv[%d] is %s\n", i, args[i].c_str());
      if (args[i] == "--") {
         // remaining arguments are passed to equipment Init()
         for (unsigned j=i+1; j<args.size(); j++)
            eq_args.push_back(args[j]);
         break;
      } else if (args[i] == "-v") {
         TMFE::gfVerbose = true;
      } else if (args[i] == "-D") {
         daemon0 = true;
      } else if (args[i] == "-O") {
         daemon1 = true;
      } else if (args[i] == "-h") {
         i++;
         if (i >= args.size()) { help = true; break; }
         hostname = args[i];
      } else if (args[i] == "-e") {
         i++;
         if (i >= args.size()) { help = true; break; }
         exptname = args[i];
      } else if (args[i] == "-i") {
         i++;
         if (i >= args.size()) { help = true; break; }
         fFeIndex = atoi(args[i].c_str());
      } else if (args[i] == "--help") {
         help = true;
         break;
      } else if (args[i][0] == '-') {
         help = true;
         break;
      } else {
         help = true;
         break;
      }
   }
 
   //
   // daemonize...
   //
 
   if (daemon0) {
      printf("Becoming a daemon...\n");
      ss_daemon_init(FALSE);
   } else if (daemon1) {
      printf("Becoming a daemon...\n");
      ss_daemon_init(TRUE);
   }
 
   //
   // apply frontend index to indexed frontend
   //
 
   if (fMfe->fProgramName.find("%") != std::string::npos) {
      fMfe->fProgramName = msprintf(fMfe->fProgramName.c_str(), fFeIndex);
   }
      
   TMFeResult r;
 
   // call arguments handler before calling the usage handlers. Otherwise,
   // if the arguments handler creates new equipments,
   // we will never see their Usage(). K.O.
   r = HandleArguments(eq_args);
 
   if (r.error_flag) {
      fprintf(stderr, "Fatal error: arguments handler error: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   if (help) {
      FeUsage(args[0].c_str());
      HandleUsage();
      fMfe->Disconnect();
      exit(1);
   }
 
   r = fMfe->Connect(NULL, hostname.c_str(), exptname.c_str());
 
   if (r.error_flag) {
      fprintf(stderr, "Fatal error: cannot connect to MIDAS, error: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   r = HandleFrontendInit(eq_args);
 
   if (r.error_flag) {
      fprintf(stderr, "Fatal error: frontend init error: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   fFeRpcHelper = new TMFrontendRpcHelper(this);
   fMfe->AddRpcHandler(fFeRpcHelper);
 
   //mfe->SetWatchdogSec(0);
   //mfe->SetTransitionSequenceStart(910);
   //mfe->SetTransitionSequenceStop(90);
   //mfe->DeregisterTransitionPause();
   //mfe->DeregisterTransitionResume();
   //mfe->RegisterTransitionStartAbort();
 
   r = FeInitEquipments(eq_args);
 
   if (r.error_flag) {
      fprintf(stderr, "Cannot initialize equipments, error message: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   r = HandleFrontendReady(eq_args);
 
   if (r.error_flag) {
      fprintf(stderr, "Fatal error: frontend post-init error: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   if (fMfe->fStateRunning) {
      if (fFeIfRunningCallExit) {
         fprintf(stderr, "Fatal error: Cannot start frontend, run is in progress!\n");
         fMfe->Disconnect();
         exit(1);
      } else if (fFeIfRunningCallBeginRun) {
         char errstr[TRANSITION_ERROR_STRING_LENGTH];
         tr_start(fMfe->fRunNumber, errstr);
      }
   }
 
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeInitEquipments()

TMFeResult TMFrontend::FeInitEquipments

(

const std::vector< std::string > &

args

)

Definition at line 1613 of file tmfe.cxx.

{
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleInit() modifies fEquipments. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      if (!fFeEquipments[i]->fEqConfEnabled)
         continue;
      TMFeResult r = fFeEquipments[i]->EqInit(args);
      if (r.error_flag)
         return r;
   }
   return TMFeOk();
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeMain() [1/2]

int TMFrontend::FeMain

(

const std::vector< std::string > &

args

)

Definition at line 2511 of file tmfe.cxx.

{
   TMFeResult r = FeInit(args);
 
   if (r.error_flag) {
      fprintf(stderr, "Fatal error: frontend init error: %s, bye.\n", r.error_message.c_str());
      fMfe->Disconnect();
      exit(1);
   }
 
   FeMainLoop();
   FeShutdown();
 
   return 0;
}

Here is the call graph for this function:

FeMain() [2/2]

int TMFrontend::FeMain	(	int	argc,
		char *	argv[]
	)

Definition at line 2336 of file tmfe.cxx.

{
   std::vector<std::string> args;
   for (int i=0; i<argc; i++) {
      args.push_back(argv[i]);
   }
 
   return FeMain(args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeMainLoop()

void TMFrontend::FeMainLoop

(

)

Definition at line 2494 of file tmfe.cxx.

{
   while (!fMfe->fShutdownRequested) {
      FePollMidas(0.100);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FePeriodicTasks()

double TMFrontend::FePeriodicTasks

(

)

Definition at line 507 of file tmfe.cxx.

{
   double now = TMFE::GetTime();
 
   double next_periodic = now + 60;
 
   int n = fFeEquipments.size();
   for (int i=0; i<n; i++) {
      TMFeEquipment* eq = fFeEquipments[i];
      if (!eq)
         continue;
      if (!eq->fEqConfEnabled)
         continue;
      if (!eq->fEqConfEnablePeriodic)
         continue;
      double period = eq->fEqConfPeriodMilliSec/1000.0;
      if (period <= 0)
         continue;
      if (eq->fEqPeriodicNextCallTime == 0)
         eq->fEqPeriodicNextCallTime = now + 0.5; // we are off by 0.5 sec with updating of statistics
      //printf("periodic[%d] period %f, last call %f, next call %f (%f)\n", i, period, eq->fEqPeriodicLastCallTime, eq->fEqPeriodicNextCallTime, now - eq->fEqPeriodicNextCallTime);
      if (now >= eq->fEqPeriodicNextCallTime) {
         eq->fEqPeriodicNextCallTime += period;
         
         if (eq->fEqPeriodicNextCallTime < now) {
            if (TMFE::gfVerbose)
               printf("TMFE::EquipmentPeriodicTasks: periodic equipment \"%s\" skipped some beats!\n", eq->fEqName.c_str());
            fMfe->Msg(MERROR, "TMFE::EquipmentPeriodicTasks", "Equipment \"%s\" skipped some beats!", eq->fEqName.c_str());
            while (eq->fEqPeriodicNextCallTime < now) {
               eq->fEqPeriodicNextCallTime += period;
            }
         }
         
         if (fMfe->fStateRunning || !eq->fEqConfReadOnlyWhenRunning) {
            eq->fEqPeriodicLastCallTime = now;
            //printf("handler %d eq [%s] call HandlePeriodic()\n", i, h->fEq->fName.c_str());                     
            eq->HandlePeriodic();
         }
         
         now = TMFE::GetTime();
      }
      
      if (eq->fEqPeriodicNextCallTime < next_periodic)
         next_periodic = eq->fEqPeriodicNextCallTime;
   }
 
   now = TMFE::GetTime();
 
   // update statistics
   for (auto eq : fFeEquipments) {
      if (!eq)
         continue;
      if (!eq->fEqConfEnabled)
         continue;
      double next = eq->fEqStatNextWrite; // NOTE: this is not thread-safe, possible torn read of "double"
      if (now > next) {
         eq->EqWriteStatistics();
         next = eq->fEqStatNextWrite; // NOTE: this is not thread-safe, possible torn read of "double"
      }
      if (next < next_periodic)
         next_periodic = next;
   }
 
   now = TMFE::GetTime();
 
   // flush write cache
   if ((fFeFlushWriteCachePeriodSec > 0) && (now >= fFeFlushWriteCacheNextCallTime)) {
      fMfe->EventBufferFlushCacheAll(false);
      fFeFlushWriteCacheNextCallTime = now + fFeFlushWriteCachePeriodSec;
      if (fFeFlushWriteCacheNextCallTime < next_periodic)
         next_periodic = fFeFlushWriteCacheNextCallTime;
   }
 
   return next_periodic;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FePeriodicThread()

void TMFrontend::FePeriodicThread

(

)

Definition at line 883 of file tmfe.cxx.

{
   if (TMFE::gfVerbose)
      printf("TMFE::PeriodicThread: periodic thread started\n");
   
   fFePeriodicThreadRunning = true;
   while (!fMfe->fShutdownRequested && !fFePeriodicThreadShutdownRequested) {
      double next_periodic_time = FePeriodicTasks();
      double now = TMFE::GetTime();
      double sleep = next_periodic_time - now;
      //printf("TMFrontend::FePeriodicThread: now %.6f next %.6f, sleep %.6f\n", now, next_periodic_time, sleep);
      if (sleep >= 1.0)
         sleep = 1.0;
      TMFE::Sleep(sleep);
   }
   if (TMFE::gfVerbose)
      printf("TMFE::PeriodicThread: periodic thread stopped\n");
   fFePeriodicThreadRunning = false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

FePollMidas()

void TMFrontend::FePollMidas

(

double

sleep_sec

)

Definition at line 745 of file tmfe.cxx.

{
   assert(sleep_sec >= 0);
   bool debug = false;
   double now = TMFE::GetTime();
   double sleep_start = now;
   double sleep_end = now + sleep_sec;
   int count_yield_loops = 0;
 
   while (!fMfe->fShutdownRequested) {
      double next_periodic_time = 0;
      double poll_sleep = 1.0;
 
      if (!fFePeriodicThreadRunning) {
         next_periodic_time = FePeriodicTasks();
         poll_sleep = FePollTasks(next_periodic_time);
      } else {
         poll_sleep = FePollTasks(TMFE::GetTime() + 0.100);
      }
 
      if (fMfe->fRunStopRequested) {
         fMfe->StopRun();
         continue;
      }
 
      now = TMFE::GetTime();
 
      if (fMfe->fRunStartTime && now >= fMfe->fRunStartTime) {
         fMfe->StartRun();
         continue;
      }
 
      double sleep_time = sleep_end - now;
 
      if (next_periodic_time > 0 && next_periodic_time < sleep_end) {
         sleep_time = next_periodic_time - now;
      }
 
      int s = 0;
      if (sleep_time > 0)
         s = 1 + sleep_time*1000.0;
 
      if (poll_sleep*1000.0 < s) {
         s = 0;
      }
 
      if (debug) {
         printf("now %.6f, sleep_end %.6f, next_periodic %.6f, sleep_time %.6f, cm_yield(%d), poll period %.6f\n", now, sleep_end, next_periodic_time, sleep_time, s, poll_sleep);
      }
 
      int status = cm_yield(s);
      
      if (status == RPC_SHUTDOWN || status == SS_ABORT) {
         fMfe->fShutdownRequested = true;
         if (TMFE::gfVerbose) {
            fprintf(stderr, "TMFE::PollMidas: cm_yield(%d) status %d, shutdown requested...\n", s, status);
         }
      }
 
      now = TMFE::GetTime();
      double sleep_more = sleep_end - now;
      if (sleep_more <= 0)
         break;
 
      count_yield_loops++;
 
      if (poll_sleep < sleep_more) {
         TMFE::Sleep(poll_sleep);
      }
   }
 
   if (debug) {
      printf("TMFE::PollMidas: sleep %.1f msec, actual %.1f msec, %d loops\n", sleep_sec * 1000.0, (now - sleep_start) * 1000.0, count_yield_loops);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

FePollTasks()

double TMFrontend::FePollTasks

(

double

next_periodic_time

)

Definition at line 583 of file tmfe.cxx.

{
   //printf("poll %f next %f diff %f\n", TMFE::GetTime(), next_periodic_time, next_periodic_time - TMFE::GetTime());
   
   double poll_sleep_sec = 9999.0;
   while (!fMfe->fShutdownRequested) {
      bool poll_again = false;
      // NOTE: ok to use range-based for() loop, there will be a crash if HandlePoll() or HandlePollRead() modify fEquipments, so they should not do that. K.O.
      for (auto eq : fFeEquipments) {
         if (!eq)
            continue;
         if (!eq->fEqConfEnabled)
            continue;
         if (eq->fEqConfEnablePoll && !eq->fEqPollThreadRunning && !eq->fEqPollThreadStarting) {
            if (fMfe->fStateRunning || !eq->fEqConfReadOnlyWhenRunning) {
               if (eq->fEqConfPollSleepSec < poll_sleep_sec)
                  poll_sleep_sec = eq->fEqConfPollSleepSec;
               bool poll = eq->HandlePoll();
               if (poll) {
                  poll_again = true;
                  eq->HandlePollRead();
               }
            }
         }
      }
      if (!poll_again)
         break;
 
      if (next_periodic_time) {
         // stop polling if we need to run periodic activity
         double now = TMFE::TMFE::GetTime();
         if (now >= next_periodic_time)
            break;
      }
   }
   return poll_sleep_sec;
}

Here is the caller graph for this function:

FeRemoveEquipment()

TMFeResult TMFrontend::FeRemoveEquipment

(

TMFeEquipment *

eq

)

Definition at line 1687 of file tmfe.cxx.

{
   // NOTE: this is thread-safe, we do not modify the fEquipments object. K.O.
   
   // NOTE: should not use range-based for() loop, it uses an iterator and it not thread-safe. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      if (fFeEquipments[i] == eq) {
         fFeEquipments[i] = NULL;
         return TMFeOk();
      }
   }
 
   return TMFeErrorMessage(msprintf("TMFE::RemoveEquipment: Cannot find equipment \"%s\"", eq->fEqName.c_str()));
}

Here is the call graph for this function:

FeSetName()

void TMFrontend::FeSetName

(

const char *

program_name

)

Definition at line 1704 of file tmfe.cxx.

{
   assert(program_name != NULL);
   fMfe->fProgramName = program_name;
}

Here is the caller graph for this function:

FeShutdown()

void TMFrontend::FeShutdown

(

)

Definition at line 2501 of file tmfe.cxx.

{
   fMfe->StopRpcThread();
   FeStopPeriodicThread();
   FeStopEquipmentPollThreads();
   HandleFrontendExit();
   FeDeleteEquipments();
   fMfe->Disconnect();
}

Here is the call graph for this function:

Here is the caller graph for this function:

FeStartPeriodicThread()

void TMFrontend::FeStartPeriodicThread

(

)

Definition at line 919 of file tmfe.cxx.

{
   // NOTE: this is thread safe
 
   std::lock_guard<std::mutex> guard(fFeMutex);
 
   if (fFePeriodicThreadRunning || fFePeriodicThreadStarting || fFePeriodicThread) {
      if (TMFE::gfVerbose)
         printf("TMFE::StartPeriodicThread: periodic thread already running\n");
      return;
   }
 
   fFePeriodicThreadStarting = true;
   fFePeriodicThread = new std::thread(&TMFrontend::FePeriodicThread, this);
}

Here is the call graph for this function:

FeStopEquipmentPollThreads()

void TMFrontend::FeStopEquipmentPollThreads

(

)

Definition at line 1628 of file tmfe.cxx.

{
   // NOTE: should not use range-based for() loop, it uses an iterator and it not thread-safe. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      fFeEquipments[i]->EqStopPollThread();
   }
}

Here is the caller graph for this function:

FeStopPeriodicThread()

void TMFrontend::FeStopPeriodicThread

(

)

Definition at line 963 of file tmfe.cxx.

{
   // NOTE: this is thread safe
   
   fFePeriodicThreadStarting = false;
   fFePeriodicThreadShutdownRequested = true;
 
   for (int i=0; i<60; i++) {
      if (!fFePeriodicThreadRunning) {
         std::lock_guard<std::mutex> guard(fFeMutex);
         if (fFePeriodicThread) {
            fFePeriodicThread->join();
            delete fFePeriodicThread;
            fFePeriodicThread = NULL;
            if (TMFE::gfVerbose)
               printf("TMFE::StopPeriodicThread: periodic thread stopped\n");
         }
         return;
      }
      if (i>5) {
         fprintf(stderr, "TMFE::StopPeriodicThread: waiting for periodic thread to stop\n");
      }
      ::sleep(1);
   }
 
   fprintf(stderr, "TMFE::StopPeriodicThread: timeout waiting for periodic thread to stop\n");
}

Here is the caller graph for this function:

FeUsage()

void TMFrontend::FeUsage

(

const char *

argv0

)

Definition at line 2307 of file tmfe.cxx.

{
   fprintf(stderr, "\n");
   fprintf(stderr, "Usage: %s args... [-- equipment args...]\n", argv0);
   fprintf(stderr, "\n");
   fprintf(stderr, " --help -- print this help message\n");
   fprintf(stderr, " -h -- print this help message\n");
   fprintf(stderr, " -v -- report all activities\n");
   fprintf(stderr, "\n");
   fprintf(stderr, " -h hostname[:tcpport] -- connect to MIDAS mserver on given host and tcp port number\n");
   fprintf(stderr, " -e exptname -- connect to given MIDAS experiment\n");
   fprintf(stderr, "\n");
   fprintf(stderr, " -D -- Become a daemon\n");
   fprintf(stderr, " -O -- Become a daemon but keep stdout for saving in a log file: frontend -O >file.log 2>&1\n");
   fprintf(stderr, "\n");
   fprintf(stderr, " -i NNN -- Set frontend index number\n");
   fprintf(stderr, "\n");
 
   // NOTE: cannot use range-based for() loop, it uses an iterator and will crash if HandleUsage() modifies fEquipments. K.O.
   for (unsigned i=0; i<fFeEquipments.size(); i++) {
      if (!fFeEquipments[i])
         continue;
      fprintf(stderr, "Usage of equipment \"%s\":\n", fFeEquipments[i]->fEqName.c_str());
      fprintf(stderr, "\n");
      fFeEquipments[i]->HandleUsage();
      fprintf(stderr, "\n");
   }
}

Here is the caller graph for this function:

HandleArguments()

virtual TMFeResult TMFrontend::HandleArguments ( const std::vector< std::string > &  args )

inlinevirtual

Reimplemented in FeTest, and FeEverything.

Definition at line 331 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

Here is the caller graph for this function:

HandleFrontendExit()

virtual void TMFrontend::HandleFrontendExit ( )

inlinevirtual

Reimplemented in FeTest, FeEverything, and FeExample.

Definition at line 335 of file tmfe.h.

{ };

Here is the caller graph for this function:

HandleFrontendInit()

virtual TMFeResult TMFrontend::HandleFrontendInit ( const std::vector< std::string > &  args )

inlinevirtual

Reimplemented in FeTest, FeEverything, and FeExample.

Definition at line 333 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

Here is the caller graph for this function:

HandleFrontendReady()

virtual TMFeResult TMFrontend::HandleFrontendReady ( const std::vector< std::string > &  args )

inlinevirtual

Reimplemented in FeTest, FeEverything, and FeExample.

Definition at line 334 of file tmfe.h.

{ return TMFeOk(); };

Here is the call graph for this function:

Here is the caller graph for this function:

HandleUsage()

virtual void TMFrontend::HandleUsage ( )

inlinevirtual

Reimplemented in FeTest, and FeEverything.

Definition at line 332 of file tmfe.h.

{ };

Here is the caller graph for this function:

Member Data Documentation

fFeEquipments

std::vector<TMFeEquipment*> TMFrontend::fFeEquipments

Definition at line 343 of file tmfe.h.

fFeFlushWriteCacheNextCallTime

double TMFrontend::fFeFlushWriteCacheNextCallTime = 0

Definition at line 376 of file tmfe.h.

fFeFlushWriteCachePeriodSec

double TMFrontend::fFeFlushWriteCachePeriodSec = 0.5

Definition at line 375 of file tmfe.h.

fFeIfRunningCallBeginRun

bool TMFrontend::fFeIfRunningCallBeginRun = true

Definition at line 316 of file tmfe.h.

fFeIfRunningCallExit

bool TMFrontend::fFeIfRunningCallExit = false

Definition at line 315 of file tmfe.h.

fFeIndex

int TMFrontend::fFeIndex = 0

Definition at line 313 of file tmfe.h.

fFeMutex

std::mutex TMFrontend::fFeMutex

Definition at line 319 of file tmfe.h.

fFePeriodicThread

std::thread* TMFrontend::fFePeriodicThread = NULL

Definition at line 369 of file tmfe.h.

fFePeriodicThreadRunning

std::atomic_bool TMFrontend::fFePeriodicThreadRunning {false}

Definition at line 371 of file tmfe.h.

{false};

fFePeriodicThreadShutdownRequested

std::atomic_bool TMFrontend::fFePeriodicThreadShutdownRequested {false}

Definition at line 372 of file tmfe.h.

{false};

fFePeriodicThreadStarting

std::atomic_bool TMFrontend::fFePeriodicThreadStarting {false}

Definition at line 370 of file tmfe.h.

{false};

fFeRpcHelper

TMFrontendRpcHelper* TMFrontend::fFeRpcHelper = NULL

Definition at line 310 of file tmfe.h.

fMfe

TMFE* TMFrontend::fMfe = NULL

Definition at line 309 of file tmfe.h.

---

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

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