OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [gold/] [gold-threads.cc] - Rev 143

Go to most recent revision | Compare with Previous | Blame | View Log

// gold-threads.cc -- thread support for gold
 
// Copyright 2006, 2007, 2008, 2009, 2010 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.
 
#include "gold.h"
 
#include <cstring>
 
#ifdef ENABLE_THREADS
#include <pthread.h>
#endif
 
#include "options.h"
#include "parameters.h"
#include "gold-threads.h"
 
namespace gold
{
 
class Condvar_impl_nothreads;
 
// The non-threaded version of Lock_impl.
 
class Lock_impl_nothreads : public Lock_impl
{
 public:
  Lock_impl_nothreads()
    : acquired_(false)
  { }
 
  ~Lock_impl_nothreads()
  { gold_assert(!this->acquired_); }
 
  void
  acquire()
  {
    gold_assert(!this->acquired_);
    this->acquired_ = true;
  }
 
  void
  release()
  {
    gold_assert(this->acquired_);
    this->acquired_ = false;
  }
 
 private:
  friend class Condvar_impl_nothreads;
 
  bool acquired_;
};
 
#ifdef ENABLE_THREADS
 
class Condvar_impl_threads;
 
// The threaded version of Lock_impl.
 
class Lock_impl_threads : public Lock_impl
{
 public:
  Lock_impl_threads();
  ~Lock_impl_threads();
 
  void acquire();
 
  void release();
 
private:
  // This class can not be copied.
  Lock_impl_threads(const Lock_impl_threads&);
  Lock_impl_threads& operator=(const Lock_impl_threads&);
 
  friend class Condvar_impl_threads;
 
  pthread_mutex_t mutex_;
};
 
Lock_impl_threads::Lock_impl_threads()
{
  pthread_mutexattr_t attr;
  int err = pthread_mutexattr_init(&attr);
  if (err != 0)
    gold_fatal(_("pthead_mutextattr_init failed: %s"), strerror(err));
#ifdef PTHREAD_MUTEX_ADAPTIVE_NP
  err = pthread_mutextattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
  if (err != 0)
    gold_fatal(_("pthread_mutextattr_settype failed: %s"), strerror(err));
#endif
 
  err = pthread_mutex_init(&this->mutex_, &attr);
  if (err != 0)
    gold_fatal(_("pthread_mutex_init failed: %s"), strerror(err));
 
  err = pthread_mutexattr_destroy(&attr);
  if (err != 0)
    gold_fatal(_("pthread_mutexattr_destroy failed: %s"), strerror(err));
}
 
Lock_impl_threads::~Lock_impl_threads()
{
  int err = pthread_mutex_destroy(&this->mutex_);
  if (err != 0)
    gold_fatal(_("pthread_mutex_destroy failed: %s"), strerror(err));
}
 
void
Lock_impl_threads::acquire()
{
  int err = pthread_mutex_lock(&this->mutex_);
  if (err != 0)
    gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err));
}
 
void
Lock_impl_threads::release()
{
  int err = pthread_mutex_unlock(&this->mutex_);
  if (err != 0)
    gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err));
}
 
#endif // defined(ENABLE_THREADS)
 
// Class Lock.
 
Lock::Lock()
{
  if (!parameters->options().threads())
    this->lock_ = new Lock_impl_nothreads;
  else
    {
#ifdef ENABLE_THREADS
      this->lock_ = new Lock_impl_threads;
#else
      gold_unreachable();
#endif
    }
}
 
Lock::~Lock()
{
  delete this->lock_;
}
 
// The non-threaded version of Condvar_impl.
 
class Condvar_impl_nothreads : public Condvar_impl
{
 public:
  Condvar_impl_nothreads()
  { }
 
  ~Condvar_impl_nothreads()
  { }
 
  void
  wait(Lock_impl* li)
  { gold_assert(static_cast<Lock_impl_nothreads*>(li)->acquired_); }
 
  void
  signal()
  { }
 
  void
  broadcast()
  { }
};
 
#ifdef ENABLE_THREADS
 
// The threaded version of Condvar_impl.
 
class Condvar_impl_threads : public Condvar_impl
{
 public:
  Condvar_impl_threads();
  ~Condvar_impl_threads();
 
  void
  wait(Lock_impl*);
 
  void
  signal();
 
  void
  broadcast();
 
 private:
  // This class can not be copied.
  Condvar_impl_threads(const Condvar_impl_threads&);
  Condvar_impl_threads& operator=(const Condvar_impl_threads&);
 
  pthread_cond_t cond_;
};
 
Condvar_impl_threads::Condvar_impl_threads()
{
  int err = pthread_cond_init(&this->cond_, NULL);
  if (err != 0)
    gold_fatal(_("pthread_cond_init failed: %s"), strerror(err));
}
 
Condvar_impl_threads::~Condvar_impl_threads()
{
  int err = pthread_cond_destroy(&this->cond_);
  if (err != 0)
    gold_fatal(_("pthread_cond_destroy failed: %s"), strerror(err));
}
 
void
Condvar_impl_threads::wait(Lock_impl* li)
{
  Lock_impl_threads* lit = static_cast<Lock_impl_threads*>(li);
  int err = pthread_cond_wait(&this->cond_, &lit->mutex_);
  if (err != 0)
    gold_fatal(_("pthread_cond_wait failed: %s"), strerror(err));
}
 
void
Condvar_impl_threads::signal()
{
  int err = pthread_cond_signal(&this->cond_);
  if (err != 0)
    gold_fatal(_("pthread_cond_signal failed: %s"), strerror(err));
}
 
void
Condvar_impl_threads::broadcast()
{
  int err = pthread_cond_broadcast(&this->cond_);
  if (err != 0)
    gold_fatal(_("pthread_cond_broadcast failed: %s"), strerror(err));
}
 
#endif // defined(ENABLE_THREADS)
 
// Methods for Condvar class.
 
Condvar::Condvar(Lock& lock)
  : lock_(lock)
{
  if (!parameters->options().threads())
    this->condvar_ = new Condvar_impl_nothreads;
  else
    {
#ifdef ENABLE_THREADS
      this->condvar_ = new Condvar_impl_threads;
#else
      gold_unreachable();
#endif
    }
}
 
Condvar::~Condvar()
{
  delete this->condvar_;
}
 
#ifdef ENABLE_THREADS
 
// Class Once_initialize.  This exists to hold a pthread_once_t
// structure for Once.
 
class Once_initialize
{
 public:
  Once_initialize()
    : once_(PTHREAD_ONCE_INIT)
  { }
 
  // Return a pointer to the pthread_once_t variable.
  pthread_once_t*
  once_control()
  { return &this->once_; }
 
 private:
  pthread_once_t once_;
};
 
#endif // defined(ENABLE_THREADS)
 
#ifdef ENABLE_THREADS
 
// A single lock which controls access to once_pointer.  This is used
// because we can't pass parameters to functions passed to
// pthread_once.
 
static pthread_mutex_t once_pointer_control = PTHREAD_MUTEX_INITIALIZER;
 
// A pointer to Once structure we want to run.  Access to this is
// controlled by once_pointer_control.
 
static Once* once_pointer;
 
// The argument to pass to the Once structure.  Access to this is
// controlled by once_pointer_control.
 
static void* once_arg;
 
// A routine passed to pthread_once which runs the Once pointer.
 
extern "C"
{
 
static void
c_run_once(void)
{
  once_pointer->internal_run(once_arg);
}
 
}
 
#endif // defined(ENABLE_THREADS)
 
// Class Once.
 
Once::Once()
  : was_run_(false), was_run_lock_(0)
{
#ifndef ENABLE_THREADS
  this->once_ = NULL;
#else
  this->once_ = new Once_initialize();
#endif
}
 
// Run the function once.
 
void
Once::run_once(void* arg)
{
#ifndef ENABLE_THREADS
 
  // If there is no threads support, we don't need to use pthread_once.
  if (!this->was_run_)
    this->internal_run(arg);
 
#else // defined(ENABLE_THREADS)
 
  if (parameters->options_valid() && !parameters->options().threads())
    {
      // If we are not using threads, we don't need to lock.
      if (!this->was_run_)
	this->internal_run(arg);
      return;
    }
 
  // If we have the sync builtins, use them to skip the lock if the
  // value has already been initialized.
#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
  while (true)
    {
      if (__sync_bool_compare_and_swap(&this->was_run_lock_, 0, 1))
	break;
    }
  bool was_run = this->was_run_;
  while (true)
    {
      if (__sync_bool_compare_and_swap(&this->was_run_lock_, 1, 0))
	break;
    }
  if (was_run)
    return;
#endif
 
  // Since we can't pass parameters to routines called by
  // pthread_once, we use a static variable: once_pointer.  This in
  // turns means that we need to use a mutex to control access to
  // once_pointer.
 
  int err = pthread_mutex_lock(&once_pointer_control);
  if (err != 0)
    gold_fatal(_("pthread_mutex_lock failed: %s"), strerror(err));
 
  once_pointer = this;
  once_arg = arg;
 
  err = pthread_once(this->once_->once_control(), c_run_once);
  if (err != 0)
    gold_fatal(_("pthread_once failed: %s"), strerror(err));
 
  once_pointer = NULL;
  once_arg = NULL;
 
  err = pthread_mutex_unlock(&once_pointer_control);
  if (err != 0)
    gold_fatal(_("pthread_mutex_unlock failed: %s"), strerror(err));
 
#endif // defined(ENABLE_THREADS)
}
 
// Actually run the function in the child class.  This function will
// be run only once.
 
void
Once::internal_run(void* arg)
{
  this->do_run_once(arg);
  this->was_run_ = true;
}
 
// Class Initialize_lock.
 
// Initialize the lock.
 
bool
Initialize_lock::initialize()
{
  // We can't initialize the lock until we have read the options.
  if (!parameters->options_valid())
    return false;
  else
    {
      this->run_once(NULL);
      return true;
    }
}
 
// Initialize the lock exactly once.
 
void
Initialize_lock::do_run_once(void*)
{
  *this->pplock_ = new Lock();
}
 
} // End namespace gold.
 

Go to most recent revision | Compare with Previous | Blame | View Log

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.