Hackfut Security File Manager
Current Path:
/usr/include/c++/4.4.4/parallel
usr
/
include
/
c++
/
4.4.4
/
parallel
/
📁
..
📄
algo.h
(102.35 KB)
📄
algobase.h
(10.88 KB)
📄
algorithm
(1.35 KB)
📄
algorithmfwd.h
(29.46 KB)
📄
balanced_quicksort.h
(15.78 KB)
📄
base.h
(12.02 KB)
📄
basic_iterator.h
(1.57 KB)
📄
checkers.h
(4.5 KB)
📄
compatibility.h
(10.06 KB)
📄
compiletime_settings.h
(2.75 KB)
📄
equally_split.h
(3.12 KB)
📄
features.h
(3.5 KB)
📄
find.h
(13.96 KB)
📄
find_selectors.h
(6.93 KB)
📄
for_each.h
(3.58 KB)
📄
for_each_selectors.h
(9.57 KB)
📄
iterator.h
(5.15 KB)
📄
list_partition.h
(5.79 KB)
📄
losertree.h
(25.12 KB)
📄
merge.h
(9.33 KB)
📄
multiseq_selection.h
(16.31 KB)
📄
multiway_merge.h
(71.04 KB)
📄
multiway_mergesort.h
(15.12 KB)
📄
numeric
(19.04 KB)
📄
numericfwd.h
(6.77 KB)
📄
omp_loop.h
(3.9 KB)
📄
omp_loop_static.h
(3.94 KB)
📄
par_loop.h
(4.43 KB)
📄
parallel.h
(1.54 KB)
📄
partial_sum.h
(6.88 KB)
📄
partition.h
(14.56 KB)
📄
queue.h
(4.79 KB)
📄
quicksort.h
(5.78 KB)
📄
random_number.h
(3.72 KB)
📄
random_shuffle.h
(17.28 KB)
📄
search.h
(5.47 KB)
📄
set_operations.h
(14.13 KB)
📄
settings.h
(10.73 KB)
📄
sort.h
(7.25 KB)
📄
tags.h
(5.96 KB)
📄
types.h
(4.02 KB)
📄
unique_copy.h
(5.67 KB)
📄
workstealing.h
(9.85 KB)
Editing: algobase.h
// -*- 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/algobase.h * @brief Parallel STL function calls corresponding to the * stl_algobase.h header. The functions defined here mainly do case * switches and call the actual parallelized versions in other files. * Inlining policy: Functions that basically only contain one * function call, are declared inline. * This file is a GNU parallel extension to the Standard C++ Library. */ // Written by Johannes Singler and Felix Putze. #ifndef _GLIBCXX_PARALLEL_ALGOBASE_H #define _GLIBCXX_PARALLEL_ALGOBASE_H 1 #include <bits/stl_algobase.h> #include <parallel/base.h> #include <parallel/tags.h> #include <parallel/settings.h> #include <parallel/find.h> #include <parallel/find_selectors.h> namespace std { namespace __parallel { // NB: equal and lexicographical_compare require mismatch. // Sequential fallback template<typename InputIterator1, typename InputIterator2> inline pair<InputIterator1, InputIterator2> mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2); } // Sequential fallback template<typename InputIterator1, typename InputIterator2, typename Predicate> inline pair<InputIterator1, InputIterator2> mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, Predicate pred, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); } // Sequential fallback for input iterator case template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2> inline pair<InputIterator1, InputIterator2> mismatch_switch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, Predicate pred, IteratorTag1, IteratorTag2) { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); } // Parallel mismatch for random access iterators template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate> pair<RandomAccessIterator1, RandomAccessIterator2> mismatch_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, Predicate pred, random_access_iterator_tag, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION(true)) { RandomAccessIterator1 res = __gnu_parallel::find_template(begin1, end1, begin2, pred, __gnu_parallel:: mismatch_selector()).first; return make_pair(res , begin2 + (res - begin1)); } else return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred); } // Public interface template<typename InputIterator1, typename InputIterator2> inline pair<InputIterator1, InputIterator2> mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2) { typedef std::iterator_traits<InputIterator1> iterator1_traits; typedef std::iterator_traits<InputIterator2> iterator2_traits; typedef typename iterator1_traits::value_type value1_type; typedef typename iterator2_traits::value_type value2_type; typedef typename iterator1_traits::iterator_category iterator1_category; typedef typename iterator2_traits::iterator_category iterator2_category; typedef __gnu_parallel::equal_to<value1_type, value2_type> equal_to_type; return mismatch_switch(begin1, end1, begin2, equal_to_type(), iterator1_category(), iterator2_category()); } // Public interface template<typename InputIterator1, typename InputIterator2, typename Predicate> inline pair<InputIterator1, InputIterator2> mismatch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, Predicate pred) { typedef std::iterator_traits<InputIterator1> iterator1_traits; typedef std::iterator_traits<InputIterator2> iterator2_traits; typedef typename iterator1_traits::iterator_category iterator1_category; typedef typename iterator2_traits::iterator_category iterator2_category; return mismatch_switch(begin1, end1, begin2, pred, iterator1_category(), iterator2_category()); } // Sequential fallback template<typename InputIterator1, typename InputIterator2> inline bool equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::equal(begin1, end1, begin2); } // Sequential fallback template<typename InputIterator1, typename InputIterator2, typename Predicate> inline bool equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, Predicate pred, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::equal(begin1, end1, begin2, pred); } // Public interface template<typename InputIterator1, typename InputIterator2> inline bool equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2) { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2).first == end1; } // Public interface template<typename InputIterator1, typename InputIterator2, typename Predicate> inline bool equal(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, Predicate pred) { return _GLIBCXX_STD_P::mismatch(begin1, end1, begin2, pred).first == end1; } // Sequential fallback template<typename InputIterator1, typename InputIterator2> inline bool lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2); } // Sequential fallback template<typename InputIterator1, typename InputIterator2, typename Predicate> inline bool lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred, __gnu_parallel::sequential_tag) { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2, pred); } // Sequential fallback for input iterator case template<typename InputIterator1, typename InputIterator2, typename Predicate, typename IteratorTag1, typename IteratorTag2> inline bool lexicographical_compare_switch(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred, IteratorTag1, IteratorTag2) { return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2, pred); } // Parallel lexicographical_compare for random access iterators // Limitation: Both valuetypes must be the same template<typename RandomAccessIterator1, typename RandomAccessIterator2, typename Predicate> bool lexicographical_compare_switch(RandomAccessIterator1 begin1, RandomAccessIterator1 end1, RandomAccessIterator2 begin2, RandomAccessIterator2 end2, Predicate pred, random_access_iterator_tag, random_access_iterator_tag) { if (_GLIBCXX_PARALLEL_CONDITION(true)) { typedef iterator_traits<RandomAccessIterator1> traits1_type; typedef typename traits1_type::value_type value1_type; typedef iterator_traits<RandomAccessIterator2> traits2_type; typedef typename traits2_type::value_type value2_type; typedef __gnu_parallel::equal_from_less<Predicate, value1_type, value2_type> equal_type; // Longer sequence in first place. if ((end1 - begin1) < (end2 - begin2)) { typedef pair<RandomAccessIterator1, RandomAccessIterator2> pair_type; pair_type mm = mismatch_switch(begin1, end1, begin2, equal_type(pred), random_access_iterator_tag(), random_access_iterator_tag()); return (mm.first == end1) || bool(pred(*mm.first, *mm.second)); } else { typedef pair<RandomAccessIterator2, RandomAccessIterator1> pair_type; pair_type mm = mismatch_switch(begin2, end2, begin1, equal_type(pred), random_access_iterator_tag(), random_access_iterator_tag()); return (mm.first != end2) && bool(pred(*mm.second, *mm.first)); } } else return _GLIBCXX_STD_P::lexicographical_compare(begin1, end1, begin2, end2, pred); } // Public interface template<typename InputIterator1, typename InputIterator2> inline bool lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2) { typedef iterator_traits<InputIterator1> traits1_type; typedef typename traits1_type::value_type value1_type; typedef typename traits1_type::iterator_category iterator1_category; typedef iterator_traits<InputIterator2> traits2_type; typedef typename traits2_type::value_type value2_type; typedef typename traits2_type::iterator_category iterator2_category; typedef __gnu_parallel::less<value1_type, value2_type> less_type; return lexicographical_compare_switch(begin1, end1, begin2, end2, less_type(), iterator1_category(), iterator2_category()); } // Public interface template<typename InputIterator1, typename InputIterator2, typename Predicate> inline bool lexicographical_compare(InputIterator1 begin1, InputIterator1 end1, InputIterator2 begin2, InputIterator2 end2, Predicate pred) { typedef iterator_traits<InputIterator1> traits1_type; typedef typename traits1_type::iterator_category iterator1_category; typedef iterator_traits<InputIterator2> traits2_type; typedef typename traits2_type::iterator_category iterator2_category; return lexicographical_compare_switch(begin1, end1, begin2, end2, pred, iterator1_category(), iterator2_category()); } } // end namespace } // end namespace #endif /* _GLIBCXX_PARALLEL_ALGOBASE_H */
Upload File
Create Folder