S3FC project page

S3FC home page

---

               

---

s3_thread_base.cc

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#include <s3fc/s3_thread_base.h>
#include <s3fc/s3_macros.h>
#include <signal.h>
#include <errno.h>
#include <sstream>
#include <iostream>

//
const pthread_t s3_thread_base::invalid_thread_id = (pthread_t)(-1);

// dflt ctor - zero init and default init thread variables
s3_thread_base::s3_thread_base() :
   started(false),
   detached(false),
   thread_id(invalid_thread_id)
{
   pthread_attr_init(&thread_attr);
}

// dtor - clean thread variables
s3_thread_base::~s3_thread_base()
{
   if (is_running())
   {
      throw s3_generic_exception("s3_thread_base::~s3_thread_base(): ",
             "is_running() == true");
   }
   pthread_attr_destroy(&thread_attr);
}

// start through static wrapper, passing arg to main_loop and returning
//  immediately with pthread_create return value
void s3_thread_base::start()
{
    // check that start() is only called ONCE
   if ( started )
   {
      throw s3_generic_exception("s3_thread_base::start()",
                                 "Attempt to start() an already "
                                 "start()'ed thread");
   }
   // check that previous invocation was joined after termination
   if ( thread_id != invalid_thread_id )
   {
      throw s3_generic_exception("s3_thread_base::start()",
                                 "Attempt to start() an instance "
                                 "that was not joined after last stop.");
   }
   // clear pending term requests
   term_request = false;
   started = true;
   if (detached)
   {
      if (pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED) 
     != 0 )
      {
         throw s3_generic_exception("s3_thread_base::start()",
                                    "Failed to set DETACHED attribute.");
      }
   }
   else
   {
      // Reset thread attribute so that a new start will be joinable.
      if (pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_JOINABLE) 
     != 0 )
      {
         throw s3_generic_exception("s3_thread_base::start()",
                                    "Failed to set JOINABLE attribute.");
      }
   }

   lock_state();
   int ptc_val = pthread_create(&thread_id,
            &thread_attr,
            s3_thread_base::pthread_create_ccpp_wrapper,
            this);
   unlock_state();

   if ( ptc_val != 0 )
   {
      started = false;
      std::stringstream str;
      str << "pthread_create() failed. Error: " << strerror(ptc_val);
      throw s3_generic_exception("s3_thread_base::start()",
             str.str());
   }
}

// stop by calling pthread_cancel with id thread_id
void s3_thread_base::stop()
{
   if (!started)
   {
      return;
   }

   int rv;
   rv = pthread_cancel(thread_id);   
   if ( rv != 0 )
   {
      throw s3_generic_exception("s3_thread_base::stop()",
                                 "pthread_cancel failed");
   }
}

// return thread id
s3_thread_base::s3_thread_id s3_thread_base::get_thread_id() const
{
   return thread_id;
}

// set detached
void s3_thread_base::set_detached(bool n_detached)
{
   // check precondition - may not be running
   if ( is_running() != false )
   {
      throw s3_generic_exception("s3_thread_base::set_detached()",
             "Precondition violation: "
             "is_running() != false");
   }
   detached = n_detached;
}
   

// return detached
bool s3_thread_base::is_detached() const
{
   return detached;
}


void s3_thread_base::set_sched_round_robin(unsigned int priority)
{
   if ( thread_id == invalid_thread_id )
   {
      throw s3_generic_exception("s3_thread_base::set_sched_robin()",
                                 "Invalid thread id, "
             "thread probably not started yet.");
   }

   struct sched_param s;
   int retval;
   s.sched_priority = priority;
   retval = pthread_setschedparam(thread_id,SCHED_RR,&s);

   switch(retval)
   {
   case 0: // Success
      break;      
   case EINVAL:
      throw s3_generic_exception("s3_thread_base::set_sched_round_robin()",
             "Prority level invalid.");
      break;
   case EPERM:
      throw s3_generic_exception("s3_thread_base::set_sched_round_robin()",
             "Process requires superuser permission");
      break;
   default:
      throw s3_generic_exception("s3_thread_base::set_sched_round_robin()",
             "Unknown error setting scheduler policy");
   }
}

void s3_thread_base::set_sched_fifo(unsigned int priority)
{
   if ( thread_id == invalid_thread_id )
   {
      throw s3_generic_exception("s3_thread_base::set_sched_fifo()",
                                 "Invalid thread id, "
             "thread probably not started yet.");
   }

   struct sched_param s;
   int retval;
   s.sched_priority = priority;
   retval = pthread_setschedparam(thread_id,SCHED_FIFO,&s);

   switch(retval)
   {
   case 0: // Success
      break;      
   case EINVAL:
      throw s3_generic_exception("s3_thread_base::set_sched_fifo()",
             "Prority level invalid.");
      break;
   case EPERM:
      throw s3_generic_exception("s3_thread_base::set_sched_fifo()",
             "Process requires superuser permission");
      break;
   default:
      throw s3_generic_exception("s3_thread_base::set_sched_fifo()",
             "Unknown error setting scheduler policy");
   }
}

void s3_thread_base::set_sched_normal(unsigned int priority)
{
   if ( thread_id == invalid_thread_id )
   {
      throw s3_generic_exception("s3_thread_base::set_sched_normal()",
                                 "Invalid thread id, "
             "thread probably not started yet.");
   }

   struct sched_param s;
   int retval;
   s.sched_priority = priority;
   retval = pthread_setschedparam(thread_id,SCHED_OTHER,&s);
   
   switch(retval)
   {
  case 0: // Success
      break;
   case EINVAL:
      throw s3_generic_exception("s3_thread_base::set_sched_normal()",
             "Prority level invalid.");
      break;
   default:
      throw s3_generic_exception("s3_thread_base::set_sched_normal()",
             "Unknown error setting scheduler policy");
   }
}

// return started
bool s3_thread_base::is_running() const
{
   return started;
}

// join and wait
void s3_thread_base::wait_on_exit()
{
   // check to ensure that we don't join twice or join on a thread
   // that never executed
   if (thread_id == invalid_thread_id) return;
   
   if (!detached)
   {
      void* p;
      pthread_join(thread_id, &p);
      thread_id = invalid_thread_id;
   }
   else
   {
      throw s3_generic_exception("s3_thread_base::wait_on_exit()",
                                 "Attempt to wait on a detached thread.");
   }
}

// lock state mutex
void s3_thread_base::lock_state() const
{
   state_lock.lock();
}

// unlock state mutex
void s3_thread_base::unlock_state() const
{
   state_lock.unlock();
}

// Test state mutex to see if someone is holding it.
bool s3_thread_base::test_state() const
{
   return state_lock.try_lock();
}

// wait on semaphore - use locking wait
void s3_thread_base::wait_on_state_changed() const
{
   state_changed.wait();
}

// up semaphore
void s3_thread_base::signal_state_changed() const
{
   state_changed.post();
}

//
void s3_thread_base::request_terminate()
{
   term_request_lock.lock();
   term_request = true;
   term_request_lock.unlock();
   signal_state_changed();
}

// call pthread_testcancel()
void s3_thread_base::test_cancel()
{
   pthread_testcancel();
}

void s3_thread_base::cleanup()
{
}

// invoked by pthread_create as the thread start_routine
// invoke the @c main_loop of an @c s3_thread_base instance
// and return with it
// obj is the @c this pointer of the @c s3_thread_base instance
// wrap the forwarding call in a push/pop pair
void* s3_thread_base::pthread_create_ccpp_wrapper(void* obj) 
{
   void* rv = 0;
   s3_thread_base* s3b_obj = static_cast<s3_thread_base*>(obj);

   pthread_cleanup_push(s3_thread_base::pthread_cleanup_ccpp_wrapper, obj);
   
   try
   {
      // invoke main loop
      s3b_obj->lock_state();
      s3b_obj->unlock_state();
      s3b_obj->main_loop();
   }
   catch ( const s3_exception &e )
   {
      std::cerr << "s3_thread_base::pthread_create_ccpp_wrapper() -- " <<
         "s3_exception caught: " << e.what() << std::endl << std::flush;
   }
   
   catch ( const std::exception &e )
   {
      std::cerr << "s3_thread_base::pthread_create_ccpp_wrapper() -- " <<
         "exception caught: " << e.what() << std::endl << std::flush;
   }
   catch ( ... )
   {
      std::cerr << "s3_thread_base::pthread_create_ccpp_wrapper() -- " <<
         "(unknown) exception caught." << std::endl << std::flush;
   }
   // remove AND execute cleanup handler
   pthread_cleanup_pop(1);
   return rv;
}

// invoked by the thread mechanism when pthread_exit() exits 
// the thread. forward to obj->cleanup()
void s3_thread_base::pthread_cleanup_ccpp_wrapper(void* obj)
{
   s3_thread_base* s3b_obj = static_cast<s3_thread_base*>(obj);
   s3b_obj->cleanup();
   s3b_obj->started = false;
}

//
bool s3_thread_base::test_terminate()
{
   bool rv;
   term_request_lock.lock();
   rv = term_request;
   term_request_lock.unlock();
   return rv;
}

---

Send comments to: s3fc@stonethree.com