diff options
Diffstat (limited to 'gcc-4.4.3/libstdc++-v3/include/parallel/base.h')
-rw-r--r-- | gcc-4.4.3/libstdc++-v3/include/parallel/base.h | 471 |
1 files changed, 0 insertions, 471 deletions
diff --git a/gcc-4.4.3/libstdc++-v3/include/parallel/base.h b/gcc-4.4.3/libstdc++-v3/include/parallel/base.h deleted file mode 100644 index 7f855dfca..000000000 --- a/gcc-4.4.3/libstdc++-v3/include/parallel/base.h +++ /dev/null @@ -1,471 +0,0 @@ -// -*- C++ -*- - -// Copyright (C) 2007, 2008, 2009 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 parallel/base.h - * @brief Sequential helper functions. - * This file is a GNU parallel extension to the Standard C++ Library. - */ - -// Written by Johannes Singler. - -#ifndef _GLIBCXX_PARALLEL_BASE_H -#define _GLIBCXX_PARALLEL_BASE_H 1 - -#include <functional> -#include <omp.h> -#include <parallel/features.h> -#include <parallel/basic_iterator.h> -#include <parallel/parallel.h> - - -// Parallel mode namespaces. - -/** - * @namespace std::__parallel - * @brief GNU parallel code, replaces standard behavior with parallel behavior. - */ -namespace std -{ - namespace __parallel { } -} - -/** - * @namespace __gnu_parallel - * @brief GNU parallel code for public use. - */ -namespace __gnu_parallel -{ - // Import all the parallel versions of components in namespace std. - using namespace std::__parallel; -} - -/** - * @namespace __gnu_sequential - * @brief GNU sequential classes for public use. - */ -namespace __gnu_sequential -{ - // Import whatever is the serial version. -#ifdef _GLIBCXX_PARALLEL - using namespace std::__norm; -#else - using namespace std; -#endif -} - - -namespace __gnu_parallel -{ - // NB: Including this file cannot produce (unresolved) symbols from - // the OpenMP runtime unless the parallel mode is actually invoked - // and active, which imples that the OpenMP runtime is actually - // going to be linked in. - inline int - get_max_threads() - { - int __i = omp_get_max_threads(); - return __i > 1 ? __i : 1; - } - - - inline bool - is_parallel(const _Parallelism __p) { return __p != sequential; } - - - // XXX remove std::duplicates from here if possible, - // XXX but keep minimal dependencies. - -/** @brief Calculates the rounded-down logarithm of @c n for base 2. - * @param n Argument. - * @return Returns 0 for any argument <1. - */ -template<typename Size> - inline Size - __log2(Size n) - { - Size k; - for (k = 0; n > 1; n >>= 1) - ++k; - return k; - } - -/** @brief Encode two integers into one __gnu_parallel::lcas_t. - * @param a First integer, to be encoded in the most-significant @c - * lcas_t_bits/2 bits. - * @param b Second integer, to be encoded in the least-significant - * @c lcas_t_bits/2 bits. - * @return __gnu_parallel::lcas_t value encoding @c a and @c b. - * @see decode2 - */ -inline lcas_t -encode2(int a, int b) //must all be non-negative, actually -{ - return (((lcas_t)a) << (lcas_t_bits / 2)) | (((lcas_t)b) << 0); -} - -/** @brief Decode two integers from one __gnu_parallel::lcas_t. - * @param x __gnu_parallel::lcas_t to decode integers from. - * @param a First integer, to be decoded from the most-significant - * @c lcas_t_bits/2 bits of @c x. - * @param b Second integer, to be encoded in the least-significant - * @c lcas_t_bits/2 bits of @c x. - * @see encode2 - */ -inline void -decode2(lcas_t x, int& a, int& b) -{ - a = (int)((x >> (lcas_t_bits / 2)) & lcas_t_mask); - b = (int)((x >> 0 ) & lcas_t_mask); -} - -/** @brief Equivalent to std::min. */ -template<typename T> - const T& - min(const T& a, const T& b) - { return (a < b) ? a : b; } - -/** @brief Equivalent to std::max. */ -template<typename T> - const T& - max(const T& a, const T& b) - { return (a > b) ? a : b; } - -/** @brief Constructs predicate for equality from strict weak - * ordering predicate - */ -// XXX comparator at the end, as per others -template<typename Comparator, typename T1, typename T2> - class equal_from_less : public std::binary_function<T1, T2, bool> - { - private: - Comparator& comp; - - public: - equal_from_less(Comparator& _comp) : comp(_comp) { } - - bool operator()(const T1& a, const T2& b) - { - return !comp(a, b) && !comp(b, a); - } - }; - - -/** @brief Similar to std::binder1st, - * but giving the argument types explicitly. */ -template<typename _Predicate, typename argument_type> - class unary_negate - : public std::unary_function<argument_type, bool> - { - protected: - _Predicate _M_pred; - - public: - explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } - - bool - operator()(const argument_type& __x) - { return !_M_pred(__x); } - }; - -/** @brief Similar to std::binder1st, - * but giving the argument types explicitly. */ -template<typename _Operation, typename first_argument_type, - typename second_argument_type, typename result_type> - class binder1st - : public std::unary_function<second_argument_type, result_type> - { - protected: - _Operation op; - first_argument_type value; - - public: - binder1st(const _Operation& __x, - const first_argument_type& __y) - : op(__x), value(__y) { } - - result_type - operator()(const second_argument_type& __x) - { return op(value, __x); } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 109. Missing binders for non-const sequence elements - result_type - operator()(second_argument_type& __x) const - { return op(value, __x); } - }; - -/** - * @brief Similar to std::binder2nd, but giving the argument types - * explicitly. - */ -template<typename _Operation, typename first_argument_type, - typename second_argument_type, typename result_type> - class binder2nd - : public std::unary_function<first_argument_type, result_type> - { - protected: - _Operation op; - second_argument_type value; - - public: - binder2nd(const _Operation& __x, - const second_argument_type& __y) - : op(__x), value(__y) { } - - result_type - operator()(const first_argument_type& __x) const - { return op(__x, value); } - - // _GLIBCXX_RESOLVE_LIB_DEFECTS - // 109. Missing binders for non-const sequence elements - result_type - operator()(first_argument_type& __x) - { return op(__x, value); } - }; - -/** @brief Similar to std::equal_to, but allows two different types. */ -template<typename T1, typename T2> - struct equal_to : std::binary_function<T1, T2, bool> - { - bool operator()(const T1& t1, const T2& t2) const - { return t1 == t2; } - }; - -/** @brief Similar to std::less, but allows two different types. */ -template<typename T1, typename T2> - struct less : std::binary_function<T1, T2, bool> - { - bool - operator()(const T1& t1, const T2& t2) const - { return t1 < t2; } - - bool - operator()(const T2& t2, const T1& t1) const - { return t2 < t1; } - }; - -// Partial specialization for one type. Same as std::less. -template<typename _Tp> -struct less<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, bool> - { - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x < __y; } - }; - - - /** @brief Similar to std::plus, but allows two different types. */ -template<typename _Tp1, typename _Tp2> - struct plus : public std::binary_function<_Tp1, _Tp2, _Tp1> - { - typedef __typeof__(*static_cast<_Tp1*>(NULL) - + *static_cast<_Tp2*>(NULL)) result; - - result - operator()(const _Tp1& __x, const _Tp2& __y) const - { return __x + __y; } - }; - -// Partial specialization for one type. Same as std::plus. -template<typename _Tp> - struct plus<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> - { - typedef __typeof__(*static_cast<_Tp*>(NULL) - + *static_cast<_Tp*>(NULL)) result; - - result - operator()(const _Tp& __x, const _Tp& __y) const - { return __x + __y; } - }; - - -/** @brief Similar to std::multiplies, but allows two different types. */ -template<typename _Tp1, typename _Tp2> - struct multiplies : public std::binary_function<_Tp1, _Tp2, _Tp1> - { - typedef __typeof__(*static_cast<_Tp1*>(NULL) - * *static_cast<_Tp2*>(NULL)) result; - - result - operator()(const _Tp1& __x, const _Tp2& __y) const - { return __x * __y; } - }; - -// Partial specialization for one type. Same as std::multiplies. -template<typename _Tp> - struct multiplies<_Tp, _Tp> : public std::binary_function<_Tp, _Tp, _Tp> - { - typedef __typeof__(*static_cast<_Tp*>(NULL) - * *static_cast<_Tp*>(NULL)) result; - - result - operator()(const _Tp& __x, const _Tp& __y) const - { return __x * __y; } - }; - - -template<typename T, typename _DifferenceTp> - class pseudo_sequence; - -/** @brief Iterator associated with __gnu_parallel::pseudo_sequence. - * If features the usual random-access iterator functionality. - * @param T Sequence value type. - * @param difference_type Sequence difference type. - */ -template<typename T, typename _DifferenceTp> - class pseudo_sequence_iterator - { - public: - typedef _DifferenceTp difference_type; - - private: - typedef pseudo_sequence_iterator<T, _DifferenceTp> type; - - const T& val; - difference_type pos; - - public: - pseudo_sequence_iterator(const T& val, difference_type pos) - : val(val), pos(pos) { } - - // Pre-increment operator. - type& - operator++() - { - ++pos; - return *this; - } - - // Post-increment operator. - const type - operator++(int) - { return type(pos++); } - - const T& - operator*() const - { return val; } - - const T& - operator[](difference_type) const - { return val; } - - bool - operator==(const type& i2) - { return pos == i2.pos; } - - difference_type - operator!=(const type& i2) - { return pos != i2.pos; } - - difference_type - operator-(const type& i2) - { return pos - i2.pos; } - }; - -/** @brief Sequence that conceptually consists of multiple copies of - the same element. - * The copies are not stored explicitly, of course. - * @param T Sequence value type. - * @param difference_type Sequence difference type. - */ -template<typename T, typename _DifferenceTp> - class pseudo_sequence - { - typedef pseudo_sequence<T, _DifferenceTp> type; - - public: - typedef _DifferenceTp difference_type; - - // Better case down to uint64, than up to _DifferenceTp. - typedef pseudo_sequence_iterator<T, uint64> iterator; - - /** @brief Constructor. - * @param val Element of the sequence. - * @param count Number of (virtual) copies. - */ - pseudo_sequence(const T& val, difference_type count) - : val(val), count(count) { } - - /** @brief Begin iterator. */ - iterator - begin() const - { return iterator(val, 0); } - - /** @brief End iterator. */ - iterator - end() const - { return iterator(val, count); } - - private: - const T& val; - difference_type count; - }; - -/** @brief Functor that does nothing */ -template<typename _ValueTp> - class void_functor - { - inline void - operator()(const _ValueTp& v) const { } - }; - -/** @brief Compute the median of three referenced elements, - according to @c comp. - * @param a First iterator. - * @param b Second iterator. - * @param c Third iterator. - * @param comp Comparator. - */ -template<typename RandomAccessIterator, typename Comparator> - RandomAccessIterator - median_of_three_iterators(RandomAccessIterator a, RandomAccessIterator b, - RandomAccessIterator c, Comparator& comp) - { - if (comp(*a, *b)) - if (comp(*b, *c)) - return b; - else - if (comp(*a, *c)) - return c; - else - return a; - else - { - // Just swap a and b. - if (comp(*a, *c)) - return a; - else - if (comp(*b, *c)) - return c; - else - return b; - } - } - -#define _GLIBCXX_PARALLEL_ASSERT(_Condition) __glibcxx_assert(_Condition) - -} //namespace __gnu_parallel - -#endif /* _GLIBCXX_PARALLEL_BASE_H */ |