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

Search this page:

PCMNode.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/PCMNode.h"

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

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  Node::Node()
        // You have to initialize the following attributes:
        // - mParent
        // - mSearchPath
        // - mProcesses
        // - mOutputDocument
        // - mBuffers
        // - mInitialized
  {
        Except(INVALID_OPERATION_ERROR, "Node::Node()",
           "Default constructor for Squirrel compatibility. Calling this constructor always raises an exception.");
  }

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

  Node::Node(const std::string & name, Host * parent):
        // Parent initialize 
   Name(name                    /* Name of the node */
  ),
        // Initialize parent 
   mParent(parent               /* Parent host */
        )
        // You have to initialize the following attributes:
        // - mParent
        // - mSearchPath
        // - mProcesses
        // - mOutputDocument
        // - mBuffers
        // - mInitialized
  {
        Assert(parent, NULL_POINTER_ERROR, "Node::Node()");

        mSearchPath = "./../lib";

        // Create processes
        mProcesses = new Container < Process, Mutex >;

        // Create buffers
        mBuffers = new Container < Buffer, Mutex >;

        // Create output document
        mOutputDocument = new OutputNode("node", OutputNode::INFORMATION);
        mOutputDocument->setAttribute("name", mName);

        mInitialized = false;

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

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

  Node::~Node()
  {
        if(mInitialized)
         finalize();

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

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

  //
  // Methods
  //

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

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

        mInitialized = true;

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

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

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

        mProcesses.kill();

        mBuffers.kill();

        mInitialized = false;

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

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

  Process *Node::createProcess(const char *processName)
  {

        mProcesses.lock();

        Process::Pointer process(new Process(processName, this));

        mProcesses->add(processName, process);
        process->initThread(0, 0, true);

        mProcesses.unlock();

        return process.getPtr();
  }

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

  Buffer *Node::createBuffer(const char *name, const PCuint left, const PCuint top,
                           const PCuint width, const PCuint height, const PCuint depthFormat)
  {
        mBuffers.lock();

        Buffer::Pointer buffer(new Buffer(left, top, width, height, depthFormat, this));

        mBuffers->add(name, buffer);

        mBuffers.unlock();

        return buffer.getPtr();
  }

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

  Buffer::Pointer Node::getBuffer(const std::string name)
  {
        return mBuffers->get(name);
  }

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

  void Node::start()
  {
        for(Container < Process, Mutex >::Iterator i = mProcesses->begin(); i != mProcesses->end(); i++)
         i->second->start();
  }

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

  u32 Node::stop()
  {

        u32 result = 0;
        u32 u;

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

        return result;
  }

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

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

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

  void Node::setFrameID(const u32 & frameID)
  {
        for(Container < Process, Mutex >::Iterator i = mProcesses->begin(); i != mProcesses->end(); i++)
        {
         i->second->setFinito(frameID);
        }

        for(Container < Process, Mutex >::Iterator i = mProcesses->begin(); i != mProcesses->end(); i++)
        {

         if(i->second->getStopAble())
         {

                i->second->go();
         }
        }

  }

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

}

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