vrj::Kernel Class Reference

Main control class for all VR Juggler applications. More...

#include <vrj/Kernel/Kernel.h>

Collaboration diagram for vrj::Kernel:

[legend]List of all members.

Public Types
typedef boost::function< void(const int)>	signal_callback_t
	Type definition fo the pre- and post-stop callbacks invoked by the kernel signal handler.
Public Member Functions
void	initConfig ()
	Loads initial configuration data for the managers.
void	controlLoop (void *nullParam)
	The Kernel loop.
void	setApplication (vrj::App *newApp)
	Sets the application object for the Kernel to deal with.
void	loadConfigFile (const char *filename)
	Loads configuration data for the kernel.
void	loadConfigFile (std::string filename)
	Loads configuration data for the kernel.
void	scanForConfigDefinitions (const std::string &path)
	Scans the given directory (or directories) for .jdef files and loads all discovered files into the JCCL Element Factory.
Kernel Control Loop Functions
int	start ()
	Starts the VR Juggler microkernel running by spawning the control loop thread.
void	stop ()
	Stops the kernel control loop.
bool	isRunning () const
	Returns the status of kernel.
void	waitForKernelStop ()
	Blocks until the kernel exits.
Signal Handler Callbacks
void	addHandlerPreCallback (signal_callback_t callback)
	Adds a "pre-stop" callback to be invoked if a handled signal is received by this kernel instance.
void	addHandlerPostCallback (signal_callback_t callback)
	Adds a "post-stop" callback to be invoked if a handled signal is received by this kernel instance.
Global "get" interface
gadget::InputManager *	getInputManager ()
	Gets the Input Manager.
vrj::User *	getUser (const std::string &userName)
	Gets the user associated with the given name.
std::vector< vrj::User * >	getUsers ()
	Returns a list of the users.
const vpr::Thread *	getThread ()
Protected Member Functions
void	updateFrameData ()
	Updates any data that needs updated once a frame (Trackers, etc.
void	checkForReconfig ()
	Checks to see if there is reconfiguration to be done.
void	changeApplication (vrj::App *newApp)
	Changes the application in use.
void	initSignalButtons ()
	Initializes the signal buttons for the kernel.
void	checkSignalButtons ()
	Checks the signal buttons to see if anything has been triggered.
void	handleSignal (const int signum)
	Handles a signal delivered by the operating system.
	Kernel ()
	Constructor: Hidden, so no direct instantiation is allowed.
	Kernel (const vrj::Kernel &k)
void	operator= (const vrj::Kernel &)
virtual	~Kernel ()
	vprSingletonHeader (Kernel)
Config element handler interface implementation
virtual bool	configCanHandle (jccl::ConfigElementPtr element)
	Can the handler handle the given element?
virtual bool	configAdd (jccl::ConfigElementPtr element)
	Adds the element to the configuration.
virtual bool	configRemove (jccl::ConfigElementPtr element)
	Removes the element from the current configuration.
Local config functions
bool	addUser (jccl::ConfigElementPtr element)
	Adds a User to the system.
bool	removeUser (jccl::ConfigElementPtr element)
	Removes a User from the system.
Draw Manager routines
void	startDrawManager (bool newMgr)
	Starts the Draw Manager running.
void	stopDrawManager ()
	Stops the Draw Manager, closes its resources, and deletes it.
Protected Attributes
vrj::App *	mApp
	The current active app object.
vrj::App *	mNewApp
	New application to set.
bool	mNewAppSet
	Flag to notify that a new application should be set.
bool	mIsRunning
	Flag for wether the kernel is currently running.
bool	mExitFlag
	Set true when the kernel should exit.
vpr::ThreadMemberFunctor< vrj::Kernel > *	mControlFunctor
vpr::Thread *	mControlThread
	The thread in control of me.
vpr::CondVar	mExitWaitCondVar
	Cond var for waiting for exit.
gadget::DigitalInterface	mStopKernelSignalButton
	Control "signals" from input interfaces.
Factories and Managers
gadget::InputManager *	mInputManager
	The input manager for the system.
DrawManager *	mDrawManager
	The Draw Manager we are currently using.
SoundManager *	mSoundManager
	The Audio Manager we are currently using.
DisplayManager *	mDisplayManager
	The Display Manager we are currently using.
cluster::ClusterManager *	mClusterManager
	The Cluster Manager for the system.
PerformanceMediator *	mPerformanceMediator
Multi-user information
std::vector< vrj::User * >	mUsers
	A list of user objects in system.
Signal Handler Callbacks
std::vector< signal_callback_t >	mPreStopCallbacks
	Callbacks invoked by handleSignal() before stopping the kernel.
std::vector< signal_callback_t >	mPostStopCallbacks
	Callbacks invoked by handleSignal() after stopping the kernel.

---

Detailed Description

Main control class for all VR Juggler applications.

The kernel takes care of all initialization and object creation. This class is the only class that MUST be instantiated for all application objects.

Definition at line 80 of file Kernel.h.

---

Member Typedef Documentation

typedef boost::function<void(const int)> vrj::Kernel::signal_callback_t

Type definition fo the pre- and post-stop callbacks invoked by the kernel signal handler.

These callbacks take a signal integer argument (the signal number) and return nothing.

See also:

addHandlerPreCallback

addHandlerPostCallback

Since:

2.0.2

Definition at line 143 of file Kernel.h.

---

Constructor & Destructor Documentation

vrj::Kernel::Kernel

(

)

[protected]

Constructor: Hidden, so no direct instantiation is allowed.

Definition at line 708 of file Kernel.cpp.

References vrj::getVersionString().

   : mApp(NULL)
   , mNewApp(NULL)
   , mNewAppSet(false)
   , mIsRunning(false)
   , mExitFlag(false)
   , mControlFunctor(NULL)
   , mControlThread(NULL)
   , mInputManager(NULL)
   , mDrawManager(NULL)
   , mSoundManager(NULL)
   , mDisplayManager(NULL)
   , mClusterManager(NULL)
   , mPerformanceMediator(NULL)
{
   // Print out the Juggler version number when the kernel is created.
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << std::string(strlen(VJ_VERSION) + 12, '=')
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << clrOutNORM(clrGREEN, "VR Juggler: ")
      << clrOutNORM(clrGREEN, VJ_VERSION) << clrRESET
      << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << clrOutNORM(clrGREEN, "VPR: ")
      << clrOutNORM(clrGREEN, vpr::getVersionString())
      << clrRESET << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << clrOutNORM(clrGREEN, "JCCL: ")
      << clrOutNORM(clrGREEN, jccl::getVersionString())
      << clrRESET << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << clrOutNORM(clrGREEN, "Gadgeteer: ")
      << clrOutNORM(clrGREEN, gadget::getVersionString())
      << clrRESET << std::endl << vprDEBUG_FLUSH;
   vprDEBUG(vprDBG_ALL, vprDBG_CRITICAL_LVL)
      << std::string(strlen(VJ_VERSION) + 12, '=')
      << std::endl << vprDEBUG_FLUSH;

   // Load in the configuration definitions
   std::string def_path;
   if ( vpr::System::getenv("VJ_BASE_DIR", def_path).success() )
   {
      def_path = "${VJ_BASE_DIR}/" VJ_SHARE_DIR "/data/definitions";
   }
   else
   {
      def_path = VJ_ROOT_DIR "/" VJ_SHARE_DIR "/data/definitions";
      vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
         << "Loading Definitions: VJ_BASE_DIR is not set.\n"
         << vprDEBUG_FLUSH;
      vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
         << "Defaulting to " << def_path << std::endl << vprDEBUG_FLUSH;
   }
   jccl::ElementFactory::instance()->loadDefs(def_path);


   // Set up a default configuration path if the user does not already have
   // one defined in the environment variable $JCCL_CFG_PATH.  If that
   // environment variable is not defined, check to see if $VJ_CFG_PATH is
   // defined.  If it is, use it.  Otherwise, use
   // $VJ_BASE_DIR/share/data/configFiles as a last-ditch fallback.
   // XXX: Should $VJ_CFG_PATH supercede $JCCL_CFG_PATH instead of doing it
   // this way?
   std::string cfg_path;
   if ( ! vpr::System::getenv("JCCL_CFG_PATH", cfg_path).success() )
   {
      if ( vpr::System::getenv("VJ_CFG_PATH", cfg_path).success() )
      {
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "JCCL_CFG_PATH environment variable not set.\n"
            << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Using VJ_CFG_PATH instead.\n" << vprDEBUG_FLUSH;
      }
      // Neither $JCCL_CFG_PATH nor $VJ_CFG_PATH is set, so use what basically
      // amounts to a hard-coded default.
      else if ( vpr::System::getenv("VJ_BASE_DIR", cfg_path).success() )
      {
         cfg_path = "${VJ_BASE_DIR}/" VJ_SHARE_DIR "/data/configFiles";
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Neither JCCL_CFG_PATH nor VJ_CFG_PATH is set.\n"
            << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Defaulting to " << cfg_path << std::endl << vprDEBUG_FLUSH;
         cfg_path = vpr::replaceEnvVars(cfg_path);
      }
      else
      {
         cfg_path = VJ_ROOT_DIR "/" VJ_SHARE_DIR "/data/configFiles";
         vprDEBUG(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "JCCL_CFG_PATH, VJ_CFG_PATH, and VJ_BASE_DIR are not set.\n"
            << vprDEBUG_FLUSH;
         vprDEBUG_NEXT(vprDBG_ALL, vprDBG_WARNING_LVL)
            << "Defaulting to " << cfg_path << std::endl << vprDEBUG_FLUSH;
         cfg_path = vpr::replaceEnvVars(cfg_path);
      }

      jccl::ParseUtil::setCfgSearchPath(cfg_path);
   }
}

vrj::Kernel::Kernel

(

const vrj::Kernel &

k

)

[inline, protected]

Definition at line 439 of file Kernel.h.

: jccl::ConfigElementHandler(k) {;}

vrj::Kernel::~Kernel

(

)

[protected, virtual]

Definition at line 810 of file Kernel.cpp.

References mControlFunctor, mControlThread, mPerformanceMediator, and mUsers.

{
   if ( NULL != mPerformanceMediator )
   {
      delete mPerformanceMediator;
      mPerformanceMediator = NULL;
   }

   if ( NULL != mControlThread )
   {
      delete mControlThread;
      mControlThread = NULL;
   }

   if ( NULL != mControlFunctor )
   {
      delete mControlFunctor;
      mControlFunctor = NULL;
   }

   for ( std::vector<vrj::User*>::iterator i = mUsers.begin(); i != mUsers.end(); ++i )
   {
      delete *i;
   }

   mUsers.clear();
}

---

Member Function Documentation

int vrj::Kernel::start

(

)

Starts the VR Juggler microkernel running by spawning the control loop thread.

The methods of the user-supplied application object are invoked from the spawned thread.

Postcondition:

A signal handler is registered with the operating system for SIGINT, SIGTERM, and (on Windows only) SIGBREAK. Upon successful completion, a new thread is running the kernel control loop.

Returns:

0 is returned if the kernel control loop thread is started successfully. 1 is returned if the thread fails to spawn.

See also:

setApplication()

waitForKernelStop()

stop()

addHandlerPreCallback()

addHandlerPostCallback()

handleSignal()

controlLoop()

Definition at line 91 of file Kernel.cpp.

References controlLoop(), gRealHandler, handleSignal(), initSignalButtons(), mControlFunctor, mControlThread, mIsRunning, signalHandler(), and vrjDBG_KERNEL().

Referenced by vrj::VRJProcRunSystem().

{
   // Set the real signal handler to be invoked by signalHandler() (see
   // above).
   gRealHandler = boost::bind(&Kernel::handleSignal, this, _1);

   vpr::SignalAction sig_action(signalHandler);
   // Catch SIGINT, SIGTERM, and SIGBREAK so that we can shut down the kernel
   // cleanly.
   vpr::SigHandler::registerHandler(SIGINT, sig_action, false);
   vpr::SigHandler::registerHandler(SIGTERM, sig_action, false);
#if defined(VPR_OS_Windows)
   vpr::SigHandler::registerHandler(SIGBREAK, sig_action, false);
#endif

   if(mControlThread != NULL) // Have already started
   {
      vprDEBUG(vprDBG_ERROR, vprDBG_CRITICAL_LVL)
         << clrOutNORM(clrRED,"ERROR:")
         << " vrj::Kernel::start() called when kernel already running!\n"
         << vprDEBUG_FLUSH;
      vprASSERT(false);
      exit(0);
   }

   mIsRunning = true;
   initSignalButtons();    // Initialize the signal buttons that may be pressed

   // Create a new thread to handle the control
   mControlFunctor = new vpr::ThreadMemberFunctor<Kernel>(this,
                                                          &Kernel::controlLoop,
                                                          NULL);

   // mControlThread is set in controlLoop().
   new vpr::Thread(mControlFunctor);

   vprDEBUG(vrjDBG_KERNEL,vprDBG_STATE_LVL)
      << "vrj::Kernel::start(): Just started control loop." << std::endl
      << vprDEBUG_FLUSH;

   return 1;
}

void vrj::Kernel::stop

(

)

Stops the kernel control loop.

If there is an application set, then it will be closed first.

Postcondition:

The kernel exits, and the VR Juggler system shuts down.

Definition at line 137 of file Kernel.cpp.

References mExitFlag, mExitWaitCondVar, and setApplication().

Referenced by checkSignalButtons(), and handleSignal().

{
   mExitWaitCondVar.acquire();
   {
      mExitFlag = true;
      mExitWaitCondVar.signal();
   }
   mExitWaitCondVar.release();

   setApplication(NULL);    // Set NULL application so that the app gets closed
}

bool vrj::Kernel::isRunning

(

)

const [inline]

Returns the status of kernel.

Definition at line 117 of file Kernel.h.

Referenced by handleSignal().

   {
      return mIsRunning;
   }

void vrj::Kernel::waitForKernelStop

(

)

Blocks until the kernel exits.

See also:

stop()

Definition at line 157 of file Kernel.cpp.

References mExitFlag, mExitWaitCondVar, and mIsRunning.

Referenced by vrj::VRJProcRunSystem().

{
   mExitWaitCondVar.acquire();
   {
      while (! (!mIsRunning && mExitFlag) )   // Wait until !mIsRunning && mExitFlag
      {
         mExitWaitCondVar.wait();
      }
   }
   mExitWaitCondVar.release();
}

void vrj::Kernel::addHandlerPreCallback

(

signal_callback_t

callback

)

Adds a "pre-stop" callback to be invoked if a handled signal is received by this kernel instance.

The job of the kernel signal handler is to try to shut down the kernel cleanly upon receiving one of the handled signals. Prior to stopping the kernel, all registered pre-stop callbacks are invoked regardless of whether the control loop for this kernel is currently running.

Postcondition:

The given callback is appended to mPreStopCallbacks.

Parameters:

callback

The callback to be invoked by this kernel's signal handler prior to stopping the kernel control loop.

Note:

To avoid a race condition wherein the signal handler gets registered with the operating system and a signal is delivered prior to this method being invoked, it is recommended that pre-stop callbacks be registered prior to invoking start().

See also:

start()

handleSignal()

Since:

2.0.2

Definition at line 169 of file Kernel.cpp.

References mPreStopCallbacks.

{
   mPreStopCallbacks.push_back(callback);
}

void vrj::Kernel::addHandlerPostCallback

(

signal_callback_t

callback

)

Adds a "post-stop" callback to be invoked if a handled signal is received by this kernel instance.

The job of the kernel signal handler is to try to shut down the kernel cleanly upon receiving one of the handled signals. After stopping the kernel, all registered post-stop callbacks are invoked regardless of whether the control loop for this kernel is currently running.

Postcondition:

The given callback is appended to mPostStopCallbacks.

Parameters:

callback

The callback to be invoked by this kernel's signal handler after stopping the kernel control loop.

Note:

To avoid a race condition wherein the signal handler gets registered with the operating system and a signal is delivered prior to this method being invoked, it is recommended that post-stop callbacks be registered prior to invoking start().

See also:

start()

handleSignal()

Since:

2.0.2

Definition at line 174 of file Kernel.cpp.

References mPostStopCallbacks.

{
   mPostStopCallbacks.push_back(callback);
}

void vrj::Kernel::initConfig

(

)

Loads initial configuration data for the managers.

Postcondition:

Input Manager, Display Manager, and kernel configuration files are loaded and handed to configAdd().

Definition at line 454 of file Kernel.cpp.

References mClusterManager, mDisplayManager, mInputManager, mPerformanceMediator, and vrjDBG_KERNEL().

Referenced by controlLoop().

{
   vprDEBUG_BEGIN(vrjDBG_KERNEL, vprDBG_CONFIG_LVL)
      << "vrj::Kernel::initConfig(): Setting initial config.\n"
      << vprDEBUG_FLUSH;

   // ---- ALLOCATE MANAGERS --- //
   //initialSetupInputManager();
   mInputManager = gadget::InputManager::instance();

   //initialSetupDisplayManager();
   mDisplayManager = DisplayManager::instance();  // Get display manager
   vprASSERT(mDisplayManager != NULL);            // Did we get an object

   mClusterManager = cluster::ClusterManager::instance();


   mPerformanceMediator = new PerformanceMediator();

   //??// processPending() // Should I do this here

   // hook dynamically-reconfigurable managers up to config manager
   // XXX: Should replace with dynamic support in future
   jccl::ConfigManager::instance()->addConfigElementHandler(this);
   jccl::ConfigManager::instance()->addConfigElementHandler(mInputManager);
   jccl::ConfigManager::instance()->addConfigElementHandler(mClusterManager);
   jccl::ConfigManager::instance()->addConfigElementHandler(mDisplayManager);
   vprDEBUG_END(vrjDBG_KERNEL, vprDBG_CONFIG_LVL)
      << "vrj::Kernel::initConfig(): Done.\n" << vprDEBUG_FLUSH;
}

void vrj::Kernel::controlLoop

(

void *

nullParam

)

The Kernel loop.

Definition at line 180 of file Kernel.cpp.

References checkForReconfig(), checkSignalButtons(), vrj::DrawManager::draw(), getInputManager(), initConfig(), vrj::App::intraFrame(), vrj::App::latePreFrame(), mApp, mClusterManager, mControlThread, mDrawManager, mExitFlag, mExitWaitCondVar, mIsRunning, mSoundManager, vrj::App::postFrame(), vrj::App::preFrame(), vrj::DrawManager::sync(), vrj::SoundManager::sync(), vrj::SoundManager::update(), updateFrameData(), and vrjDBG_KERNEL().

Referenced by start().

{
   boost::ignore_unused_variable_warning(nullParam);
   vprDEBUG(vrjDBG_KERNEL, vprDBG_CONFIG_LVL)
      << "vrj::Kernel::controlLoop: Started.\n" << vprDEBUG_FLUSH;
   vprASSERT (NULL != vpr::Thread::self());

   mControlThread = vpr::Thread::self();

   // Do any initial configuration
   initConfig();

   vpr::prof::start("Kernel: controlLoop",10);

   // --- MAIN CONTROL LOOP -- //
   while(! (mExitFlag && (mApp == NULL)))     // While not exit flag set and don't have app. (can't exit until app is closed)
   {
      // Might not want the Kernel to know about the ClusterNetwork
      // It is currently being registered as a jccl::ConfigElementHandler in
      // the ClusterManager constructor
         vpr::prof::start("Cluster: updateNewConnections.",10);
       cluster::ClusterManager::instance()->getNetwork()->updateNewConnections();
         vpr::prof::next("Cluster: sendRequests.",10);
       cluster::ClusterManager::instance()->sendRequests();
         vpr::prof::stop();

      bool cluster = !( cluster::ClusterManager::instance()->isClusterActive() &&
                        !cluster::ClusterManager::instance()->isClusterReady());

      // Iff we have an app and a draw manager
      if((mApp != NULL) && (mDrawManager != NULL) && cluster)
      {
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: mApp->preFrame()\n"
               << vprDEBUG_FLUSH;
         vpr::prof::start("App: PreFrame",10);
         mApp->preFrame();         // PREFRAME: Do Any application pre-draw stuff
         vpr::prof::stop();
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: Update ClusterManager preDraw()\n"
               << vprDEBUG_FLUSH;
      }
      else
      {
         // ??? Should we do this, or just grind up the CPU as fast as possible
         vprASSERT(NULL != mControlThread);      // If control thread is not set correctly, it will seg fault here
         vpr::Thread::yield();   // Give up CPU
      }

      vpr::prof::start("Cluster: preDraw",10);
      mClusterManager->preDraw();
      vpr::prof::stop();

      if((mApp != NULL) && (mDrawManager != NULL) && cluster)
      {
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: mApp->latePreFrame()\n"
               << vprDEBUG_FLUSH;
            vpr::prof::start("App: latePreFrame",10);
         mApp->latePreFrame();
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: drawManager->draw()\n"
               << vprDEBUG_FLUSH;
            vpr::prof::next("trigger draw",10);
         mDrawManager->draw();    // DRAW: Trigger the beginning of frame drawing
            vpr::prof::next("sound mgr update",10);
         mSoundManager->update();
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: mApp->intraFrame()\n"
               << vprDEBUG_FLUSH;
            vpr::prof::next("App: intraFrame",10);
         mApp->intraFrame();        // INTRA FRAME: Do computations that can be done while drawing.  This should be for next frame.
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: drawManager->sync()\n"
               << vprDEBUG_FLUSH;
            vpr::prof::next("sound sync",10);
         mSoundManager->sync();
            vpr::prof::next("draw sync",10);
         mDrawManager->sync();    // SYNC: Block until drawing is done
            vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
               << "vrj::Kernel::controlLoop: mApp->postFrame()\n"
               << vprDEBUG_FLUSH;
            vpr::prof::next("App: postFrame",10);
         mApp->postFrame();        // POST FRAME: Do processing after drawing is complete
            vpr::prof::stop();
      }
      else
      {
         // ??? Should we do this, or just grind up the CPU as fast as possible
         vprASSERT(NULL != mControlThread);      // If control thread is not set correctly, it will seg fault here
         vpr::Thread::yield();   // Give up CPU
      }

      // --- Stop for reconfiguration -- //
         vpr::prof::start("checkForReconfig",10);
      checkForReconfig();        // Check for any reconfiguration that needs done (system or application)
         vpr::prof::next("check kern signals",10);
      checkSignalButtons();      // Check for any pending control requests
         vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
            << "vrj::Kernel::controlLoop: Update Trackers\n" << vprDEBUG_FLUSH;
         vpr::prof::next("resetAllDevicesAndProxies", 10);
      getInputManager()->resetAllDevicesAndProxies();
         vpr::prof::next("updateAllDevices",10);
      getInputManager()->updateAllDevices();
         vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
            << "vrj::Kernel::controlLoop: Update ClusterManager\n"
            << vprDEBUG_FLUSH;
         vpr::prof::next("Cluster: postPostFrame.",10);
      mClusterManager->postPostFrame();
           vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
            << "vrj::Kernel::controlLoop: Update Proxies\n"
            << vprDEBUG_FLUSH;
         vpr::prof::next("updateAllProxies",10);
      getInputManager()->updateAllProxies();
         vprDEBUG(vrjDBG_KERNEL, vprDBG_HVERB_LVL)
            << "vrj::Kernel::controlLoop: Update Projections\n"
            << vprDEBUG_FLUSH;
         vpr::prof::next("Update frame data",10);
      updateFrameData();         // Any frame-based manager data
         vpr::prof::stop();
   }

   vpr::prof::stop();

   vprDEBUG(vrjDBG_KERNEL, vprDBG_WARNING_LVL)
      << "vrj::Kernel::controlLoop: Exiting. \n" << vprDEBUG_FLUSH;

   // Set the running status to false
   mExitWaitCondVar.acquire();
   {
      mIsRunning = false;
      mExitWaitCondVar.signal();
   }
   mExitWaitCondVar.release();
}

void vrj::Kernel::setApplication

(

vrj::App *

newApp

)

Sets the application object for the Kernel to deal with.

If there is another application active, the kernel has to stop that application first and then restart all the graphics API-specific Managers.

Parameters:

newApp

If NULL, stops current application.

Definition at line 318 of file Kernel.cpp.

References mNewApp, mNewAppSet, and vrjDBG_KERNEL().

Referenced by stop(), and vrj::VRJProcRunSystem().

{
   vprDEBUG(vrjDBG_KERNEL,vprDBG_CONFIG_LVL)
      << "[vrj::Kernel::setApplication()] New application set\n"
      << vprDEBUG_FLUSH;
   mNewApp = newApp;
   mNewAppSet = true;
}

void vrj::Kernel::loadConfigFile

(

const char *

filename

)

[inline]

Loads configuration data for the kernel.

Postcondition:

Config data has been read into initial the buffer.

Parameters:

filename

The name of the configuration file to load.

Definition at line 226 of file Kernel.h.

Referenced by vrj::VRJConfigure().

   {
      std::string filename_str = std::string(filename);
      loadConfigFile(filename_str);
   }

void vrj::Kernel::loadConfigFile

(

std::string

filename

)

Loads configuration data for the kernel.

Postcondition:

Config data has been read into initial the buffer.

Parameters:

filename

The name of the configuration file to load.

Definition at line 575 of file Kernel.cpp.

References vrjDBG_KERNEL().

{
   vprDEBUG(vrjDBG_KERNEL,vprDBG_CONFIG_LVL)
      << "Loading config file: " << filename << std::endl << vprDEBUG_FLUSH;

   // We can allocate this on thte stack because the config elements get
   // copied into a new PendingConfigElement from the configuration.
   jccl::Configuration cfg;

   // ------- OPEN Program specified Config file ------ //
   if(filename.empty())   // We have a filename
   {
      return;
   }

   bool cfg_load_success = cfg.load(filename);
   if (!cfg_load_success)
   {
      vprDEBUG(vprDBG_ERROR,vprDBG_CRITICAL_LVL) << clrOutNORM(clrRED,"ERROR:")
         << "vrj::Kernel::loadConfigFile: Failed to load file: "
         << filename << std::endl << vprDEBUG_FLUSH;
      exit(1);
   }

   // Put all the newly loaded config elments into the Config Manager's
   // incoming element list.
   jccl::ConfigManager::instance()->addConfigurationAdditions(&cfg);
}

void vrj::Kernel::scanForConfigDefinitions

(

const std::string &

path

)

Scans the given directory (or directories) for .jdef files and loads all discovered files into the JCCL Element Factory.

Postcondition:

The config element factory can now manage elements with the discovered types.

Parameters:

path

One or more directories, delineated by a platform-specific path separator, that will be searched for .jdef files.

Definition at line 606 of file Kernel.cpp.

{
   jccl::ElementFactory::instance()->loadDefs(path);
}

bool vrj::Kernel::configCanHandle

(

jccl::ConfigElementPtr

element

)

[protected, virtual]

Can the handler handle the given element?

Returns:

true if we can handle the element; false otherwise.

Definition at line 492 of file Kernel.cpp.

Referenced by configAdd(), and configRemove().

{
   return std::string("user") == element->getID();
}

bool vrj::Kernel::configAdd

(

jccl::ConfigElementPtr

element

)

[protected, virtual]

Adds the element to the configuration.

Precondition:

configCanHandle(element) == true.

Returns:

Success.

Definition at line 497 of file Kernel.cpp.

References addUser(), and configCanHandle().

{
   const std::string element_type(element->getID());

   vprASSERT(configCanHandle(element));

   bool result(false);

   if(std::string("user") == element_type)
   {
      result = addUser(element);
   }

   return result;
}

bool vrj::Kernel::configRemove

(

jccl::ConfigElementPtr

element

)

[protected, virtual]

Removes the element from the current configuration.

Precondition:

configCanHandle(element) == true.

Returns:

success.

Definition at line 513 of file Kernel.cpp.

References configCanHandle(), and removeUser().

{
   const std::string element_type(element->getID());

   vprASSERT(configCanHandle(element));

   bool result(false);

   if(std::string("user") == element_type)
   {
      result = removeUser(element);
   }

   return result;
}

bool vrj::Kernel::addUser

(

jccl::ConfigElementPtr

element

)

[protected]

Adds a User to the system.

Definition at line 530 of file Kernel.cpp.

References mUsers, and vrjDBG_KERNEL().

Referenced by configAdd().

{
   vprASSERT(element->getID() == "user");

   User* new_user = new User;
   bool success = new_user->config(element);

   if(!success)
   {
      vprDEBUG(vrjDBG_KERNEL, vprDBG_CRITICAL_LVL)
         << clrOutNORM(clrRED,"ERROR:") << " Failed to add new User: "
         << element->getName() << std::endl << vprDEBUG_FLUSH;
      delete new_user;
   }
   else
   {
      vprDEBUG(vrjDBG_KERNEL, vprDBG_STATE_LVL)
         << "vrj::Kernel: Added new User: " << new_user->getName() << std::endl
         << vprDEBUG_FLUSH;
      mUsers.push_back(new_user);
   }

   return success;
}

bool vrj::Kernel::removeUser

(

jccl::ConfigElementPtr

element

)

[protected]

Removes a User from the system.

Definition at line 555 of file Kernel.cpp.

References vrj::User::getName(), getUser(), mUsers, and vrjDBG_KERNEL().

Referenced by configRemove().

{
   vprASSERT(element->getID() == "user");
   
   std::string user_name = element->getName();
   vrj::User* user = getUser(user_name);

   if (NULL != user)
   {
      vprDEBUG(vrjDBG_KERNEL, vprDBG_STATE_LVL)
         << "vrj::Kernel: Removing User: " << user->getName() << std::endl
         << vprDEBUG_FLUSH;
         
      mUsers.erase(std::find(mUsers.begin(), mUsers.end(), user));
      return true;
   }
   return false;
}

void vrj::Kernel::updateFrameData

(

)

[protected]

Updates any data that needs updated once a frame (Trackers, etc.

).

Postcondition:

All tracker data is ready for next frame.

Definition at line 485 of file Kernel.cpp.

Referenced by controlLoop().

{
   // When we have a draw manager, tell it to update its projections
   // XXX: Moved to be updated on demand
   // mDisplayManager->updateProjections();
}

void vrj::Kernel::checkForReconfig

(

)

[protected]

Checks to see if there is reconfiguration to be done.

Postcondition:

Any reconfiguration needed has been completed.

Note:

Can only be called by the kernel thread.

Definition at line 328 of file Kernel.cpp.

References changeApplication(), vrj::App::depSatisfied(), mControlThread, mNewApp, mNewAppSet, and vrjDBG_KERNEL().

Referenced by controlLoop().

{
   vprASSERT(vpr::Thread::self() == mControlThread);      // ASSERT: We are being called from kernel thread
   // ---- RECONFIGURATION --- //
   jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();
   unsigned num_processed(0);

   do
   {
      num_processed = cfg_mgr->attemptReconfiguration();
   }
   while (num_processed > 0);
   // ---- APP SWITCH ---- //
   // check for a new applications
   if(mNewAppSet)
   {
      if((mNewApp == NULL) || (mNewApp->depSatisfied()) )   // If app is NULL or dependencies satisfied
      {
         vprDEBUG(vrjDBG_KERNEL,vprDBG_CONFIG_STATUS_LVL)
            << "New application set; dependencies satisfied.\n"
            << vprDEBUG_FLUSH;
         mNewAppSet = false;
         changeApplication(mNewApp);
      }
      else
      {
         vprDEBUG(vrjDBG_KERNEL,vprDBG_WARNING_LVL)
            << "New application set; dependencies not satisfied yet.\n"
            << vprDEBUG_FLUSH;
      }
   }
}

void vrj::Kernel::changeApplication

(

vrj::App *

newApp

)

[protected]

Changes the application in use.

If there is another application object active, it has to stop that application first then restart all API-specific Managers.

Parameters:

newApp

If NULL, stops current application.

Note:

This can only be called from the kernel thread.

Definition at line 367 of file Kernel.cpp.

References vrj::App::getDrawManager(), vrj::App::getSoundManager(), mApp, mControlThread, mDrawManager, mSoundManager, startDrawManager(), stopDrawManager(), and vrjDBG_KERNEL().

Referenced by checkForReconfig().

{
   vprDEBUG(vrjDBG_KERNEL, vprDBG_CONFIG_LVL)
      << "vrj::Kernel::changeApplication() Changing to: "
      << std::hex << std::showbase << (void*) newApp << std::dec << std::endl
      << vprDEBUG_FLUSH;

   vprASSERT(vpr::Thread::self() == mControlThread);      // ASSERT: We are being called from kernel thread
   jccl::ConfigManager* cfg_mgr = jccl::ConfigManager::instance();

   // Quick out if for some reason the user calls setApplication with
   // the same application that is running.
   if (newApp == mApp)
   {
      return;
   }

   // XXX: TODO: Free resources (ie closeContext())

   // If the new application is NULL OR
   // we have an old draw manager and it is different from the new one, stop it.
   if (NULL == newApp || NULL != mDrawManager && newApp->getDrawManager() != mDrawManager)
   {
      stopDrawManager();
      cfg_mgr->removeConfigElementHandler(mDrawManager);
      cfg_mgr->removeConfigElementHandler(mSoundManager);
   }

   // If we have an old application, exit it.
   if (NULL != mApp)
   {
      cfg_mgr->removeConfigElementHandler(mApp);
      mApp->exit();
   }

   // Start using the new application.
   // NOTE: The kernel no longer has a reference to the old application
   //       so it can be safely deleted.
   mApp = newApp;

   // If we have a new application
   if (NULL != mApp)
   {
      // If the new application uses a different draw manager.
      if(mApp->getDrawManager() != mDrawManager)
      {
         mDrawManager = mApp->getDrawManager();
         vprASSERT(NULL != mDrawManager);

         mDrawManager = mApp->getDrawManager();             // Get the new draw manager
         mSoundManager = mApp->getSoundManager();           // Get the new sound manager
         cfg_mgr->addConfigElementHandler(mDrawManager);    // Tell config manager about them
         cfg_mgr->addConfigElementHandler(mSoundManager);   // Tell config manager about them
         startDrawManager(true);                      // Start the new one
      }
      else
      {
         startDrawManager(false);                     // Start new app
      }
      // Now handle configuration
      cfg_mgr->addConfigElementHandler(mApp);
      cfg_mgr->refreshPendingList();                  // New managers, so we may be able to handle config requests now
   }
}

void vrj::Kernel::initSignalButtons

(

)

[protected]

Initializes the signal buttons for the kernel.

Definition at line 433 of file Kernel.cpp.

References mStopKernelSignalButton.

Referenced by start().

{
   mStopKernelSignalButton.init("VJSystemStopKernel");
}

void vrj::Kernel::checkSignalButtons

(

)

[protected]

Checks the signal buttons to see if anything has been triggered.

Definition at line 439 of file Kernel.cpp.

References mStopKernelSignalButton, and stop().

Referenced by controlLoop().

{
   if(mStopKernelSignalButton->getData() == gadget::Digital::TOGGLE_ON)
   {
      vprDEBUG(vprDBG_ALL, vprDBG_STATE_LVL)
         << "Stop kernel signal button pressed: Kernel will exit.\n"
         << vprDEBUG_FLUSH;
      this->stop();  // Signal kernel to stop
   }
}

void vrj::Kernel::startDrawManager

(

bool

newMgr

)

[protected]

Starts the Draw Manager running.

Calls the app callbacks for the Draw Manager.

Precondition:

The application object, current Draw Manager, and current Display Manager have all been set.

Postcondition:

All processes and data should have been created by Draw Manager.

Parameters:

newMgr

Is this a new manager or the same one.

Definition at line 612 of file Kernel.cpp.

References vrj::App::apiInit(), vrj::App::init(), vrj::DrawManager::initAPI(), mApp, mDisplayManager, mDrawManager, vrj::DrawManager::setApp(), vrj::DrawManager::setDisplayManager(), vrj::DisplayManager::setDrawManager(), vrjDBG_KERNEL(), and vrj::ManagerException::what().

Referenced by changeApplication().

{
   vprASSERT((mApp != NULL) && (mDrawManager != NULL) && (mDisplayManager != NULL));

   if(newMgr)
   {
      mDrawManager->setDisplayManager(mDisplayManager);
      jccl::ConfigManager::instance()->lockPending();
      {
         mDrawManager->configProcessPending();                 // Handle any pending configuration requests BEFORE we init and start it going
      }
      jccl::ConfigManager::instance()->unlockPending();
   }

   try
   {
      mDrawManager->setApp(mApp);

      mApp->init();                // Init the app

      if(newMgr)
      {
         // Just sets up API type stuff, possibly starts new processes.
         mDrawManager->initAPI();
      }

      mApp->apiInit();             // Have app do any app-init stuff

      if(newMgr)
      {
         // This can trigger the update of windows to the Draw Manager.
         mDisplayManager->setDrawManager(mDrawManager);
      }
   }
   catch(vrj::DrawMgrException& ex)
   {
      vprDEBUG(vrjDBG_KERNEL, vprDBG_WARNING_LVL)
         << clrOutBOLD(clrYELLOW, "WARNING:")
         << " Draw Manager rejected application object:" << std::endl
         << vprDEBUG_FLUSH;
      vprDEBUG_NEXT(vrjDBG_KERNEL, vprDBG_WAR