• Main
• Home
• Features
• Screenshots
• Downloads
• License
• Team profile
• Documentation
• Manual
• FAQ
• Reference

Search this page:

PCMHost.cpp

Go to the documentation of this file.

//
// This source file is a part of ParCompMark
// Parallel Compositing Benchmark Framework
//
// for latest info see http://parcompmark.sourceforge.net

//
// Copyright (C) 2006 IT2 ParCompMark Dev. Team
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

//
// Inner includes
//

#include "../include/PCMHost.h"

#include "../include/PCMNetClient.h"

#include "../include/PCMApplication.h"

#include "../include/PCMStringConverter.h"

namespace ParCompMark
{

  template <> Host * Singleton < Host >::mInstance = 0;

  //
  // Class constants
  //

  const std::string Host::HOSTINITNUT = "scripts/framework/host-init.nut";

  //
  // Constructors & destructor
  //

   Host::Host(const std::string & name, NetClient * netClient)
        // You have to initialize the following attributes:
        // - mWait
        // - mName
        // - mSqVM
        // - mLowLevelScript
        // - mXDisplays
        // - mNodes
        // - mInitialized
        // - mOutputDocument
        // - mSessionID
        // - mNetClient
        // - mEndProcessCount
        // - mProcessCount
        // - mID
        // - mMessageSendingTime
  {
        mName = name;
        mNetClient = netClient;

        mEndProcessCount = IntPointer(new int);
         *mEndProcessCount.getPtr() = 0;

        mProcessCount = -1;

        mLowLevelScript = "";

        mInitialized = false;

        mSessionID = 0;

        // Create displays
        mXDisplays = new Container < XDisplay, Mutex >;

        Logger::getInstance()->log(Logger::NOTICE, "Host `" + mName + "\' has been created.");
  }

 /*----------------------------------------------------------------------*/

  Host::~Host()
  {

        if(mInitialized)
         finalize();

        mXDisplays.kill();

        Logger::getInstance()->log(Logger::NOTICE, "Host `" + mName + "\' has been destroyed.");

  }

 /*----------------------------------------------------------------------*/

  //
  // Class methods
  //

  Host *Host::getInstance()
  {
        return Singleton < Host >::getInstance();
  }

 /*----------------------------------------------------------------------*/

  //
  // Methods
  //

  XDisplay::Pointer Host::openXDisplay(const std::string & displayName)
  {
        mXDisplays.lock();

        // Return existing opened display
        if(mXDisplays->has(displayName))
        {
         XDisplay::Pointer display(mXDisplays->get(displayName));
         mXDisplays.unlock();

         // Initialize if needed
         if(!display->getInitialized())
                display->initialize();

         Logger::getInstance()->log(Logger::NOTICE,
                                   "Display `" + displayName + "\' has been (re)opened on host `" + mName + "\'.");
         return display;
        }
        // Open new display 
        XDisplay::Pointer display(new XDisplay(displayName));
        display->initialize();

        mXDisplays->add(displayName, display);
        mXDisplays.unlock();

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Display `" + displayName + "\' has been created and opened on host `" + mName +
                                 "\'.");
        return display;
  }

 /*----------------------------------------------------------------------*/

  XDisplay::Pointer Host::getFirstXDisplay()
  {
        Container < XDisplay, Mutex >::Iterator i = mXDisplays->begin();
        if(i != mXDisplays->end())
         return i->second;
        else
         return XDisplay::Pointer();
  }

 /*----------------------------------------------------------------------*/

  void Host::openXDisplays()
  {
        // TODO: scan displays
        openXDisplay();
  }

 /*----------------------------------------------------------------------*/

  void Host::closeXDisplays()
  {
        for(Container < XDisplay, Mutex >::Iterator i = mXDisplays->begin(); i != mXDisplays->end(); i++)
        {
         i->second->finalize();
        }
  }

 /*----------------------------------------------------------------------*/

  void Host::initialize()
  {
        //Assert(!mInitialized, INVALID_OPERATION_ERROR, "Host::initialize()");

        //fprintf(stderr, "Host init: %s\n", mName.c_str());

        if(mInitialized)
         finalize();

        // Create output document
        mOutputDocument = new OutputNode("host", OutputNode::INFORMATION);

        //Create nodes
        mNodes = new Container < Node, Mutex >;

        // Initialize time correction
        Timer::setTimeCorrection(0.0);

        // Automatically scan available X displays on this host and open them.
        //openXDisplays();

        // Create session
        //if(PCerr err = pcSessionCreate(0) != PC_NO_ERROR)
        //Except(INTERNAL_ERROR, "Host::initialize()", pcGetErrorString(err));

        Logger::getInstance()->log(Logger::DEBUG,
                                 "Session #" + StringConverter::toString(mSessionID) + " has been created on host `" +
                                 mName + "\'.");

        // Initialize host from squirrel
        mSqVM = new SqVM("Host-" + mName + "-VM");
        mSqVM.lock();
        // Load PC API, ParCompMark API, and utils
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::PCAPINUT),
                                 SqVM::NOMAINMETHOD);
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::PARCOMPMARKNUT),
                                 SqVM::NOMAINMETHOD);
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(Application::UTILSNUT),
                                 SqVM::NOMAINMETHOD);

        std::list < std::string > params;
        params.push_back(mName);
        params.push_back(mLowLevelScript);
        mSqVM->runScriptFromFile(FileSystemManager::getInstance()->getPathDataFile(HOSTINITNUT), "main", params);
        mSqVM.unlock();

        // Set name in output document
        mOutputDocument->setAttribute("name", mName);

        // Initialize nodes
        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
         if(!i->second->getInitialized())
                i->second->initialize();

        mEndProcessCount.lock();
        *mEndProcessCount.getPtr() = 0;
        mEndProcessCount.unlock();

        mProcessCount = 0;

        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
         mProcessCount += i->second->getProcesses()->getSize();

        mInitialized = true;

        Logger::getInstance()->log(Logger::DEBUG, "Host `" + mName + "\' has been initialized.");
  }

 /*----------------------------------------------------------------------*/

  void Host::finalize()
  {
        Assert(mInitialized, INVALID_OPERATION_ERROR, "Host::finalize()");

        // Kill nodes
        mNodes.kill();

        mSqVM.kill();

        mProcessCount = -1;

        if(mOutputDocument.isNotNull())
         mOutputDocument.kill();

        // Close all opened X displays
        //closeXDisplays();

        //if(PCerr err = pcSessionDestroy() != PC_NO_ERROR)
        //Except(INTERNAL_ERROR, "Host::finalize()", pcGetErrorString(err));

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG, "Host `" + mName + "\' has been finalized.");

  }

 /*----------------------------------------------------------------------*/

  Node *Host::createNode(const char *nodeName)
  {
        mNodes.lock();

        Node::Pointer node(new Node(nodeName, this));

        mNodes->add(nodeName, node);

        mNodes.unlock();

        return node.getPtr();
  }

 /*----------------------------------------------------------------------*/

  void Host::start()
  {

        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
         i->second->start();

        Logger::getInstance()->log(Logger::NOTICE, "Nodes has been started on host `" + mName + "\'.");
  }

 /*----------------------------------------------------------------------*/

  u32 Host::stop()
  {
        u32 result = 0;
        u32 u;

        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
        {
         u = i->second->stop();
         if(u > result)
         {
                result = u;
         }
        }

        Logger::getInstance()->log(Logger::NOTICE, "Nodes has been stopped on host `" + mName + "\'.");

        return result;
  }

 /*----------------------------------------------------------------------*/

  void Host::collectData()
  {
        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
        {
         i->second->collectData();
         mOutputDocument->addChildNode(i->second->getOutputDocument());
        }
  }

 /*----------------------------------------------------------------------*/

  void Host::setFrameID(const u32 & frameID)
  {

        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)
        {
         i->second->setFrameID(frameID);
        }
        for(Container < Node, Mutex >::Iterator i = mNodes->begin(); i != mNodes->end(); i++)

         for(Container < Process, Mutex >::Iterator j = i->second->getProcesses()->begin();
                j != i->second->getProcesses()->end(); j++)
         {
                j->second->joinThread();
         }

  }

 /*----------------------------------------------------------------------*/

}

© Copyright - 2006 (IT)² ParCompMark Dev. Team