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

Search this page:

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

#include "../include/PCMProcess.h"

#include "../include/PCMXDisplay.h"

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

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

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  Context::Context()
        // You have to initialize the following attributes:
        // - mID
        // - mUseGLFrameletEXT
        // - mContextType
        // - mFrameID
        // - mFrameWidth
        // - mFrameHeight
        // - mColourFormat
        // - mDepthFormat
        // - mPixelFormat
        // - mCompositeType
        // - mCompressionHint
        // - mRetainOutputCount
        // - mVolatileFrameletCount
        // - mOutputDepth
        // - mProcesses
        // - mProcessCount
        // - mProcessIndex
        // - mHostIndex
        // - mNetworkID
        // - mContext
        // - mParent
        // - mInitialized
  {
        Except(INVALID_OPERATION_ERROR, "Context::Context()",
           "Default constructor for Squirrel compatibility. Calling this constructor always raises an exception.");
  }

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

  Context::Context(Process * parent):
        // Initialize parent 
   mParent(parent               /* Parent process */
        )
        // You have to initialize the following attributes:
        // - mID
        // - mUseGLFrameletEXT
        // - mContextType
        // - mFrameID
        // - mFrameWidth
        // - mFrameHeight
        // - mColourFormat
        // - mDepthFormat
        // - mPixelFormat
        // - mCompositeType
        // - mCompressionHint
        // - mRetainOutputCount
        // - mVolatileFrameletCount
        // - mOutputDepth
        // - mProcesses
        // - mProcessCount
        // - mProcessIndex
        // - mHostIndex
        // - mNetworkID
        // - mContext
        // - mParent
        // - mInitialized
  {
        Assert(parent, NULL_POINTER_ERROR, "Context::Context()");

        mUseGLFrameletEXT = true;
        mContextType = SLAVE;
        mFrameID = 0;
        mFrameWidth = 256;
        mFrameHeight = 256;
        mColourFormat = PC_PF_BGRA8;
        mDepthFormat = PC_PF_Z32I;
        mPixelFormat = mColourFormat | mDepthFormat;
        mCompositeType = PC_COMP_DEPTH;
        mCompressionHint = PC_COMPRESSION_NONE;
        mRetainOutputCount = 1;
        mVolatileFrameletCount = 0;
        mOutputDepth = true;
        mProcesses = 0;
        mProcessCount = -1;
        mHostIndex = -1;
        mNetworkID = PC_ID_DEFAULT;
        mContext = 0;
        mInitialized = false;

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Context has been created for process `" + mParent->getName() + "\'");
  }

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

  Context::~Context()
  {
        // Deallocate name buffers

        if(mInitialized)
        {
         finalize();
        }

        if(mProcesses)
        {
         for(int i = 0; i < mProcessCount; i++)
                if(mProcesses[i])
                 delete mProcesses[i];

         delete mProcesses;
        }

        Logger::getInstance()->log(Logger::NOTICE,
                                 "Context has been destroyed for process `" + mParent->getName() + "\'");
  }

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

  //
  // Methods
  //

  void Context::setProcesses(const char *processList)
  {
        std::string processListStr(processList);

        // Get number of processes
        std::string::size_type index = 0, i = 0;
        mProcessCount = 1;

        while((index = processListStr.find(";", index)) != std::string::npos)
        {
         mProcessCount++;
         index++;
        }
        mProcesses = new PCstring[mProcessCount + 1];

        // Get name of processes in format host:localid
        while((index = processListStr.find(";")) != std::string::npos)
        {
         std::string processName = processListStr.substr(0, index);
         mProcesses[i] = strdup(processName.c_str());

         processListStr = processListStr.substr(++index);
         i++;
        }
        mProcesses[i] = strdup(processListStr.c_str());

        mProcesses[mProcessCount] = 0;
  }

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

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

        const int max = 64;

        if(mUseGLFrameletEXT)
        {
         // Query extension in the interface
#ifndef PC_EXT_CUR_GFX_CTX
         Except(INTERNAL_ERROR, "Context::initialize()",
                 "PC_EXT_CUR_GFX_CTX extension is not present in your PC interface.");
#endif
         // TODO what is the extension name 

        }

        switch (mContextType)
        {
                //
                // Master context initialization
                //
         case MASTER:
                {

                 // set attributes i:attribute i+1:attribute value
                 int i = 0;
                 PCint attribs[max];

                 attribs[i++] = PC_FRAME_WIDTH;
                 attribs[i++] = mFrameWidth;
                 attribs[i++] = PC_FRAME_HEIGHT;
                 attribs[i++] = mFrameHeight;
                 attribs[i++] = PC_COMPOSITE_TYPE;
                 attribs[i++] = mCompositeType;
                 attribs[i++] = PC_PIXEL_FORMAT;
                 // PC bug? cannot pass depth format when alpha compositing
                 attribs[i++] = (mCompositeType == PC_COMP_ALPHA_SORT ? mColourFormat : mPixelFormat);
                 attribs[i++] = PC_COMPRESSION_HINT;
                 attribs[i++] = mCompressionHint;
                 attribs[i++] = PC_NETWORK_ID;
                 attribs[i++] = mNetworkID;
                 attribs[i++] = PC_OUTPUT_DEPTH;
                 attribs[i++] = (PCint) (mOutputDepth ? 1 : 0);
                 attribs[i++] = PC_RETAIN_OUTPUT;
                 attribs[i++] = mRetainOutputCount;
                 attribs[i++] = PC_VOLATILE_FRAMELET;
                 attribs[i++] = mVolatileFrameletCount;
                 attribs[i++] = PC_PROPERTY_END;

                 if(PCerr err =
                   pcContextCreateMaster(attribs, mProcesses, mProcesses[mProcessIndex], &mContext) != PC_NO_ERROR)
                 {
                        //std::cerr << "[M] Error: " << mProcesses[mProcessIndex] << std::endl;
                        Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));
                 }
                }

                //std::cerr << "[M] Ok: " << mProcesses[mProcessIndex] << std::endl;

                break;

                //
                // Slave context initialization
                //
         case SLAVE:
                {

                 //std::cerr << "[S] Process: " << mProcesses[mProcessIndex] << std::endl;

                 if(PCerr err = pcContextCreate(mNetworkID, mProcesses[mProcessIndex], &mContext) != PC_NO_ERROR)
                 {
                        //std::cerr << "[S] Error: " << mProcesses[mProcessIndex] << std::endl;
                        Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));
                 }
                 //std::cerr << "[S] Ok: " << mProcesses[mProcessIndex] << std::endl;
                 //int retval = 0; pthread_exit(&retval);

                 Logger::getInstance()->log(Logger::NOTICE,
                                           "Slave PC context has been initialized for process `" +
                                           mParent->getName() + "\'");
                }
        }

        //int retval = 0; pthread_exit(&retval);

        // Synchronize context and set starting time of the process
        if(PCerr err = pcContextSync(mContext) != PC_NO_ERROR)
         Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));
        mParent->setStartTime(Timer::getSystemTime());

        // Get host index
        if(PCerr err = pcContextGetInteger(mContext, PC_HOSTINDEX, PC_LOCALHOST_INDEX, &mHostIndex) != PC_NO_ERROR)
         Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));

        // Get attributes for slave node
        if(mContextType == SLAVE)
        {
         if(PCerr err = pcContextGetInteger(mContext, PC_NUM_HOSTS, PC_ID_DEFAULT, &mProcessCount) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));

         if(PCerr err = pcContextGetInteger(mContext, PC_FRAME_WIDTH, PC_ID_DEFAULT, &mFrameWidth) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));

         if(PCerr err = pcContextGetInteger(mContext, PC_FRAME_HEIGHT, PC_ID_DEFAULT, &mFrameHeight) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));

         if(PCerr err = pcContextGetInteger(mContext, PC_PIXEL_FORMAT, PC_ID_DEFAULT, &mPixelFormat) != PC_NO_ERROR)
                Except(INTERNAL_ERROR, "Context::initialize()", pcGetErrorString(err));
        }

        mInitialized = true;

        // Log starting of the benchmark
        Logger::getInstance()->log(Logger::NOTICE,
                                 "Benchmark timer started at " + StringConverter::toString(mParent->getStartTime()) +
                                 " for process " + mParent->getName());
  }

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

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

        if(PCerr err = pcContextDestroy(mContext) != PC_NO_ERROR)
         Except(INTERNAL_ERROR, "Context::finalize()", pcGetErrorString(err));

        mInitialized = false;

        Logger::getInstance()->log(Logger::DEBUG,
                                 "PC context has been finalized for process `" + mParent->getName() + "\'");

  }

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

}

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