Subversion Repositories open8_urisc

// workqueue-threads.cc -- the threaded workqueue for gold

// Copyright 2007, 2008 Free Software Foundation, Inc.

// Written by Ian Lance Taylor <iant@google.com>.

// This file is part of gold.

// 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 3 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., 51 Franklin Street - Fifth Floor, Boston,

// MA 02110-1301, USA.

// This file holds the workqueue implementation which may be used when

// using threads.

#include "gold.h"

#ifdef ENABLE_THREADS

#include <cstring>

#include <pthread.h>

#include "debug.h"

#include "gold-threads.h"

#include "workqueue.h"

#include "workqueue-internal.h"

namespace gold

{

// Class Workqueue_thread represents a single thread.  Creating an

// instance of this spawns a new thread.

class Workqueue_thread

{

 public:

  Workqueue_thread(Workqueue_threader_threadpool*, int thread_number);

  ~Workqueue_thread();

 private:

  // This class can not be copied.

  Workqueue_thread(const Workqueue_thread&);

  Workqueue_thread& operator=(const Workqueue_thread&);

  // Check for error from a pthread function.

  void

  check(const char* function, int err) const;

  // A function to pass to pthread_create.  This is called with a

  // pointer to an instance of this object.

  static void*

  thread_body(void*);

  // A pointer to the threadpool that this thread is part of.

  Workqueue_threader_threadpool* threadpool_;

  // The thread number.

  int thread_number_;

  // The thread ID.

  pthread_t tid_;

};

// Create the thread in the constructor.

Workqueue_thread::Workqueue_thread(Workqueue_threader_threadpool* threadpool,

                                   int thread_number)

  : threadpool_(threadpool), thread_number_(thread_number)

{

  pthread_attr_t attr;

  int err = pthread_attr_init(&attr);

  this->check("pthread_attr_init", err);

  err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

  this->check("pthread_attr_setdetachstate", err);

  err = pthread_create(&this->tid_, &attr, &Workqueue_thread::thread_body,

                       reinterpret_cast<void*>(this));

  this->check("pthread_create", err);

  err = pthread_attr_destroy(&attr);

  this->check("pthread_attr_destroy", err);

}

// The destructor will be called when the thread is exiting.

Workqueue_thread::~Workqueue_thread()

{

}

// Check for an error.

void

Workqueue_thread::check(const char* function, int err) const

{

  if (err != 0)

    gold_fatal(_("%s failed: %s"), function, strerror(err));

}

// Passed to pthread_create.

extern "C"

void*

Workqueue_thread::thread_body(void* arg)

{

  Workqueue_thread* pwt = reinterpret_cast<Workqueue_thread*>(arg);

  pwt->threadpool_->process(pwt->thread_number_);

  // Delete the thread object as we exit.

  delete pwt;

  return NULL;

}

// Class Workqueue_threader_threadpool.

// Constructor.

Workqueue_threader_threadpool::Workqueue_threader_threadpool(

    Workqueue* workqueue)

  : Workqueue_threader(workqueue),

    check_thread_count_(0),

    lock_(),

    desired_thread_count_(1),

    threads_(1)

{

}

// Destructor.

Workqueue_threader_threadpool::~Workqueue_threader_threadpool()

{

  // Tell the threads to exit.

  this->get_workqueue()->set_thread_count(0);

}

// Set the thread count.

void

Workqueue_threader_threadpool::set_thread_count(int thread_count)

{

  int create;

  {

    Hold_lock hl(this->lock_);

    this->desired_thread_count_ = thread_count;

    create = this->desired_thread_count_ - this->threads_;

    if (create < 0)

      this->check_thread_count_ = 1;

  }

  if (create > 0)

    {

      for (int i = 0; i < create; ++i)

        {

          // Note that threads delete themselves when they exit, so we

          // don't keep pointers to them.

          new Workqueue_thread(this, this->threads_);

          ++this->threads_;

        }

    }

}

// Return whether the current thread should be cancelled.

bool

Workqueue_threader_threadpool::should_cancel_thread(int thread_number)

{

  // Fast exit without taking a lock.

  if (!this->check_thread_count_)

    return false;

  {

    Hold_lock hl(this->lock_);

    if (thread_number > this->desired_thread_count_)

      {

        --this->threads_;

        if (this->threads_ <= this->desired_thread_count_)

          this->check_thread_count_ = 0;

        return true;

      }

  }

  return false;

}

} // End namespace gold.

#endif // defined(ENABLE_THREADS)