golden hour

/usr/include/c++/4.8.2

File/Folder	Size	Actions
algorithm	2.46 KB
array	9.27 KB
atomic	33.3 KB
backward	-
bits	-
bitset	44.55 KB
cassert	1.58 KB
ccomplex	1.29 KB
cctype	2.35 KB
cerrno	1.7 KB
cfenv	2 KB
cfloat	1.82 KB
chrono	23.04 KB
cinttypes	2.11 KB
ciso646	1.46 KB
climits	1.84 KB
clocale	1.86 KB
cmath	41.45 KB
complex	51.29 KB
complex.h	1.43 KB
condition_variable	7.8 KB
csetjmp	1.9 KB
csignal	1.81 KB
cstdalign	1.37 KB
cstdarg	1.8 KB
cstdbool	1.37 KB
cstddef	1.57 KB
cstdint	2.12 KB
cstdio	4.18 KB
cstdlib	6.01 KB
cstring	3.05 KB
ctgmath	1.29 KB
ctime	2.08 KB
cwchar	6.34 KB
cwctype	2.73 KB
cxxabi.h	21.24 KB
debug	-
decimal	-
deque	2.6 KB
exception	4.95 KB
ext	-
fenv.h	1.97 KB
forward_list	1.54 KB
fstream	29.31 KB
functional	79.23 KB
future	41.7 KB
initializer_list	2.9 KB
iomanip	11.21 KB
ios	1.56 KB
iosfwd	6.69 KB
iostream	2.63 KB
istream	29.25 KB
iterator	2.58 KB
limits	65.68 KB
list	2.53 KB
locale	1.39 KB
map	2.5 KB
memory	2.81 KB
mutex	19.66 KB
new	4.09 KB
numeric	2.72 KB
ostream	19.19 KB
parallel	-
profile	-
queue	2.41 KB
random	1.67 KB
ratio	18.69 KB
regex	1.82 KB
scoped_allocator	15.65 KB
set	2.5 KB
sstream	19.57 KB
stack	2.33 KB
stdexcept	4.61 KB
streambuf	28.71 KB
string	1.9 KB
system_error	10.11 KB
tgmath.h	1.33 KB
thread	7.08 KB
tr1	-
tr2	-
tuple	34.85 KB
type_traits	57.55 KB
typeindex	3.01 KB
typeinfo	7.5 KB
unordered_map	1.81 KB
unordered_set	1.81 KB
utility	5.22 KB
valarray	39.32 KB
vector	2.66 KB
x86_64-redhat-linux	-

Edit: thread

// <thread> -*- C++ -*-

// Copyright (C) 2008-2013 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library 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, 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 General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file include/thread
 *  This is a Standard C++ Library header.
 */

#ifndef _GLIBCXX_THREAD
#define _GLIBCXX_THREAD 1

#pragma GCC system_header

#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else

#include <chrono>
#include <functional>
#include <memory>
#include <bits/functexcept.h>
#include <bits/functional_hash.h>
#include <bits/gthr.h>

#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
   * @defgroup threads Threads
   * @ingroup concurrency
   *
   * Classes for thread support.
   * @{
   */

/// thread
  class thread
  {
  public:
    typedef __gthread_t			native_handle_type;
    struct _Impl_base;
    typedef shared_ptr<_Impl_base>	__shared_base_type;

/// thread::id
    class id
    {
      native_handle_type	_M_thread;

public:
      id() noexcept : _M_thread() { }

explicit
      id(native_handle_type __id) : _M_thread(__id) { }

private:
      friend class thread;
      friend class hash<thread::id>;

friend bool
      operator==(thread::id __x, thread::id __y) noexcept
      { return __gthread_equal(__x._M_thread, __y._M_thread); }

friend bool
      operator<(thread::id __x, thread::id __y) noexcept
      { return __x._M_thread < __y._M_thread; }

template<class _CharT, class _Traits>
	friend basic_ostream<_CharT, _Traits>&
	operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
    };

// Simple base type that the templatized, derived class containing
    // an arbitrary functor can be converted to and called.
    struct _Impl_base
    {
      __shared_base_type	_M_this_ptr;

inline virtual ~_Impl_base();

virtual void _M_run() = 0;
    };

template<typename _Callable>
      struct _Impl : public _Impl_base
      {
	_Callable		_M_func;

_Impl(_Callable&& __f) : _M_func(std::forward<_Callable>(__f))
	{ }

void
	_M_run() { _M_func(); }
      };

private:
    id				_M_id;

public:
    thread() noexcept = default;
    // _GLIBCXX_RESOLVE_LIB_DEFECTS
    // 2097.  packaged_task constructors should be constrained
    thread(thread&) = delete;
    thread(const thread&) = delete;

thread(thread&& __t) noexcept
    { swap(__t); }

template<typename _Callable, typename... _Args>
      explicit 
      thread(_Callable&& __f, _Args&&... __args)
      {
        _M_start_thread(_M_make_routine(std::__bind_simple(
                std::forward<_Callable>(__f),
                std::forward<_Args>(__args)...)));
      }

~thread()
    {
      if (joinable())
	std::terminate();
    }

thread& operator=(const thread&) = delete;

thread& operator=(thread&& __t) noexcept
    {
      if (joinable())
	std::terminate();
      swap(__t);
      return *this;
    }

void
    swap(thread& __t) noexcept
    { std::swap(_M_id, __t._M_id); }

bool
    joinable() const noexcept
    { return !(_M_id == id()); }

void
    join();

void
    detach();

thread::id
    get_id() const noexcept
    { return _M_id; }

/** @pre thread is joinable
     */
    native_handle_type
    native_handle()
    { return _M_id._M_thread; }

// Returns a value that hints at the number of hardware thread contexts.
    static unsigned int
    hardware_concurrency() noexcept;

private:
    void
    _M_start_thread(__shared_base_type);

template<typename _Callable>
      shared_ptr<_Impl<_Callable>>
      _M_make_routine(_Callable&& __f)
      {
	// Create and allocate full data structure, not base.
	return std::make_shared<_Impl<_Callable>>(std::forward<_Callable>(__f));
      }
  };

inline thread::_Impl_base::~_Impl_base() = default;

inline void
  swap(thread& __x, thread& __y) noexcept
  { __x.swap(__y); }

inline bool
  operator!=(thread::id __x, thread::id __y) noexcept
  { return !(__x == __y); }

inline bool
  operator<=(thread::id __x, thread::id __y) noexcept
  { return !(__y < __x); }

inline bool
  operator>(thread::id __x, thread::id __y) noexcept
  { return __y < __x; }

inline bool
  operator>=(thread::id __x, thread::id __y) noexcept
  { return !(__x < __y); }

// DR 889.
  /// std::hash specialization for thread::id.
  template<>
    struct hash<thread::id>
    : public __hash_base<size_t, thread::id>
    {
      size_t
      operator()(const thread::id& __id) const noexcept
      { return std::_Hash_impl::hash(__id._M_thread); }
    };

template<class _CharT, class _Traits>
    inline basic_ostream<_CharT, _Traits>&
    operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
    {
      if (__id == thread::id())
	return __out << "thread::id of a non-executing thread";
      else
	return __out << __id._M_thread;
    }

_GLIBCXX_END_NAMESPACE_VERSION

/** @namespace std::this_thread
   *  @brief ISO C++ 2011 entities sub-namespace for thread.
   *  30.3.2 Namespace this_thread.
   */
  namespace this_thread
  {
  _GLIBCXX_BEGIN_NAMESPACE_VERSION

/// get_id
    inline thread::id
    get_id() noexcept { return thread::id(__gthread_self()); }

/// yield
    inline void
    yield() noexcept
    {
#ifdef _GLIBCXX_USE_SCHED_YIELD
      __gthread_yield();
#endif
    }

void
    __sleep_for(chrono::seconds, chrono::nanoseconds);

/// sleep_for
    template<typename _Rep, typename _Period>
      inline void
      sleep_for(const chrono::duration<_Rep, _Period>& __rtime)
      {
	auto __s = chrono::duration_cast<chrono::seconds>(__rtime);
	auto __ns = chrono::duration_cast<chrono::nanoseconds>(__rtime - __s);
#ifdef _GLIBCXX_USE_NANOSLEEP
	__gthread_time_t __ts =
	  {
	    static_cast<std::time_t>(__s.count()),
	    static_cast<long>(__ns.count())
	  };
	::nanosleep(&__ts, 0);
#else
	__sleep_for(__s, __ns);
#endif
      }

/// sleep_until
    template<typename _Clock, typename _Duration>
      inline void
      sleep_until(const chrono::time_point<_Clock, _Duration>& __atime)
      { sleep_for(__atime - _Clock::now()); }

_GLIBCXX_END_NAMESPACE_VERSION
  }

// @} group threads

} // namespace

#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1

#endif // C++11

#endif // _GLIBCXX_THREAD