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

Search this page:

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

namespace ParCompMark
{

  //
  // Constructors & destructor
  //

  Thread::Thread(const std::string & name)
        // You have to initialize the following attributes:
        // - mThreadName
        // - mWait
        // - mStopRequested
        // - mJoinable
        // - mWaitThread
        // - mThread
        // - mCondition
        // - mConditionMutex
        // - mRunning
        // - mCurrentFPS
        // - mExpectedFPS
        // - mIterationNumber
  {
        mThreadName = name;
        mWait = new bool;
        *mWait.getPtr() = false;
        mStopRequested = false;
        mRunning = false;
        mThread = 0;
        mJoinable = false;

        if(0 != pthread_cond_init(&mCondition, 0))
        {
         Except(INTERNAL_ERROR, "Thread::wait()", "Unable to init condition variable.");
        }
        if(0 != pthread_mutex_init(&mConditionMutex, 0))
        {
         Except(INTERNAL_ERROR, "Thread::wait()", "Unable to init mutex variable.");
        }

        mCurrentFPS = 0;
        mExpectedFPS = 0;
        mIterationNumber = 0;
  }

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

  Thread::~Thread()
  {
        pthread_mutex_destroy(&mConditionMutex);
        pthread_cond_destroy(&mCondition);

        if(mRunning)
         shutDownThread();

        Logger::getInstance()->log(Logger::DEBUG, "Thread " + mThreadName + " is dying.");

  }

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

  //
  // Class methods
  //

  void *Thread::entryPoint(void *arg)
  {

        Thread *pthis = (Thread *) arg;

        // Setting cancellation state
        if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL))
        {
         Except(INTERNAL_ERROR, "Thread::entryPoint", "Unable to set cancel enabling");
        }
        // Setting cancellation type
        if(pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL))
        {
         Except(INTERNAL_ERROR, "Thread::entryPoint", "Unable to set cancelling type");
        }

        pthis->thread();

        pthis->mRunning = false;
        Logger::getInstance()->log(Logger::DEBUG, "Thread " + pthis->mThreadName + " finished.");

        // Proper termination
        pthread_exit(0);
  }

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

  //
  // Methods
  //

  void Thread::initThread(const u32 & iterationNumber, const u32 & expectedFPS,
                         const bool & joinable, const bool & waitThread)
  {
        Assert(joinable || !waitThread, INVALID_OPERATION_ERROR, "Thread::initThread");
        Assert(!((waitThread) && iterationNumber == 0), INVALID_OPERATION_ERROR, "Thread::initThread");

        mExpectedFPS = expectedFPS;
        mIterationNumber = iterationNumber;
        mJoinable = joinable;
        mWaitThread = waitThread;
  }

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

  void Thread::threadInitialize()
  {
  }

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

  void Thread::threadFinalize()
  {
  }

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

  void Thread::startThread()
  {

        // The thread can not run
        Assert(!mRunning, INVALID_OPERATION_ERROR, "Thread::startThread");

        pthread_attr_t attr;

        // Set detached state
        pthread_attr_init(&attr);

        if(mJoinable)
        {
         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
        } else
        {
         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
        }

        // Start new thread
        mRunning = true;
        pthread_create(&mThread, &attr, &(Thread::entryPoint), (void *) this);

        pthread_attr_destroy(&attr);
        Logger::getInstance()->log(Logger::DEBUG, "Thread " + mThreadName + " started.");
  }

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

  void Thread::joinThread()
  {
        //TODO: assert!
        //Assert(!(mIterationNumber == 0 && !mStopRequested && mRunning), INVALID_OPERATION_ERROR,

        // "Thread::joinThread()");
        Assert(mJoinable, INVALID_OPERATION_ERROR, "Thread::joinThread()");

        if(!mRunning)
        {
         return;
        }

        if(pthread_join(mThread, 0))
        {
         Except(INTERNAL_ERROR, "Thread::joinThread()", "Unable to join thread " + mThreadName);
        }

  }

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

  void Thread::shutDownThread()
  {
        // The thread must run
        Assert(mRunning, INVALID_OPERATION_ERROR, "Thread::shutDownThread()");
        Assert(mThread, NULL_POINTER_ERROR, "Thread::shutDownThread()");
        Logger::getInstance()->log(Logger::DEBUG, "Thread " + mThreadName + " is going down.");

        // Wait for thread termination

        if(mWaitThread)
        {
         if(pthread_join(mThread, 0))
         {
                Except(INTERNAL_ERROR, "Thread::shutDownThread()", "Unable join thread " + mThreadName);
         }
        } else
        {
         if(pthread_cancel(mThread))
         {
                Except(INTERNAL_ERROR, "Thread::shutDownThread()", "Unable to shut down thread " + mThreadName);
         }
        }

        mStopRequested = false;
        mRunning = false;
        mThread = 0;
        Logger::getInstance()->log(Logger::DEBUG, "Thread " + mThreadName + " is down.");
  }

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

  void Thread::stopThread()
  {
        Logger::getInstance()->log(Logger::DEBUG, "Stopping " + mThreadName);
        mStopRequested = true;
  }

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

  void Thread::go()
  {

        if(pthread_mutex_lock(&mConditionMutex) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::go", "??? can't lock");
        }

        if(pthread_cond_signal(&mCondition) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::go", "??? can't go");
        }

        if(pthread_mutex_unlock(&mConditionMutex) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::go", "??? can't unlock");
        }

  }

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

  void Thread::thread()
  {
        threadInitialize();

        yield();

        if(mIterationNumber == 0)
         // Infinite loop
         for(;;)
         {

                if(iteration())
                 break;
         }

        else
         // Specified number of loops
         for(u32 i = 0; i < mIterationNumber; i++)
         {
                if(iteration())
                 break;
         }

        threadFinalize();

        yield();

  }

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

  void Thread::task()
  {

        // Nothing to do, but do something :)
        Timer::sleep(0.01);

  }

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

  void Thread::wait()
  {

        if(pthread_mutex_lock(&mConditionMutex) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::wait", "??? can't lock");
        }

        if(pthread_cond_wait(&mCondition, &mConditionMutex) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::wait", "??? can't cond_wait");
        }

        if(pthread_mutex_unlock(&mConditionMutex) != 0)
        {
         Except(INTERNAL_ERROR, "Thread::wait", "??? can't unlock");
        }

  }

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

}

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