FM / parallel

/usr/include/c++/4.4.4/parallel/

/usr/include/c++/4.4.4/parallel

Name	Size	Mode	Actions
algo.h	104807	0644	edit dl rm
algobase.h	11140	0644	edit dl rm
algorithm	1385	0644	edit dl rm
algorithmfwd.h	30167	0644	edit dl rm
balanced_quicksort.h	16157	0644	edit dl rm
base.h	12313	0644	edit dl rm
basic_iterator.h	1606	0644	edit dl rm
checkers.h	4605	0644	edit dl rm
compatibility.h	10301	0644	edit dl rm
compiletime_settings.h	2818	0644	edit dl rm
equally_split.h	3191	0644	edit dl rm
features.h	3580	0644	edit dl rm
find.h	14295	0644	edit dl rm
find_selectors.h	7092	0644	edit dl rm
for_each.h	3666	0644	edit dl rm
for_each_selectors.h	9804	0644	edit dl rm
iterator.h	5270	0644	edit dl rm
list_partition.h	5929	0644	edit dl rm
losertree.h	25725	0644	edit dl rm
merge.h	9549	0644	edit dl rm
multiseq_selection.h	16706	0644	edit dl rm
multiway_merge.h	72745	0644	edit dl rm
multiway_mergesort.h	15478	0644	edit dl rm
numeric	19494	0644	edit dl rm
numericfwd.h	6934	0644	edit dl rm
omp_loop.h	3996	0644	edit dl rm
omp_loop_static.h	4037	0644	edit dl rm
parallel.h	1577	0644	edit dl rm
partial_sum.h	7042	0644	edit dl rm
partition.h	14909	0644	edit dl rm
par_loop.h	4541	0644	edit dl rm
queue.h	4904	0644	edit dl rm
quicksort.h	5914	0644	edit dl rm
random_number.h	3808	0644	edit dl rm
random_shuffle.h	17696	0644	edit dl rm
search.h	5598	0644	edit dl rm
settings.h	10987	0644	edit dl rm
set_operations.h	14472	0644	edit dl rm
sort.h	7421	0644	edit dl rm
tags.h	6103	0644	edit dl rm
types.h	4116	0644	edit dl rm
unique_copy.h	5811	0644	edit dl rm
workstealing.h	10088	0644	edit dl rm

Edit: /usr/include/c++/4.4.4/parallel/for_each_selectors.h (9804B)

// -*- 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/for_each_selectors.h
 *  @brief Functors representing different tasks to be plugged into the
 *  generic parallelization methods for embarrassingly parallel functions.
 *  This file is a GNU parallel extension to the Standard C++ Library.
 */

// Written by Felix Putze.

#ifndef _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H
#define _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H 1

#include <parallel/basic_iterator.h>

namespace __gnu_parallel
{

/** @brief Generic selector for embarrassingly parallel functions. */
  template<typename It>
  struct generic_for_each_selector
  {
    /** @brief Iterator on last element processed; needed for some
     *  algorithms (e. g. std::transform()).
     */
    It finish_iterator;
  };

/** @brief std::for_each() selector. */
  template<typename It>
    struct for_each_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object. */
      template<typename Op>
        bool
        operator()(Op& o, It i)
	{
	  o(*i);
	  return true;
	}
    };

/** @brief std::generate() selector. */
  template<typename It>
    struct generate_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object. */
      template<typename Op>
        bool
        operator()(Op& o, It i)
        {
	  *i = o();
	  return true;
	}
    };

/** @brief std::fill() selector. */
  template<typename It>
    struct fill_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param v Current value.
       *  @param i Iterator referencing object. */
      template<typename Val>
        bool
        operator()(Val& v, It i)
	{
	  *i = v;
	  return true;
	}
    };

/** @brief std::transform() selector, one input sequence variant. */
  template<typename It>
    struct transform1_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object. */
      template<typename Op>
        bool
        operator()(Op& o, It i)
	{
	  *i.second = o(*i.first);
	  return true;
	}
    };

/** @brief std::transform() selector, two input sequences variant. */
  template<typename It>
    struct transform2_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object. */
      template<typename Op>
        bool
        operator()(Op& o, It i)
	{
	  *i.third = o(*i.first, *i.second);
	  return true;
	}
    };

/** @brief std::replace() selector. */
  template<typename It, typename T>
    struct replace_selector : public generic_for_each_selector<It>
    {
      /** @brief Value to replace with. */
      const T& new_val;

/** @brief Constructor
       *  @param new_val Value to replace with. */
      explicit
      replace_selector(const T &new_val) : new_val(new_val) {}

/** @brief Functor execution.
       *  @param v Current value.
       *  @param i Iterator referencing object. */
      bool
      operator()(T& v, It i)
      {
	if (*i == v)
	  *i = new_val;
	return true;
      }
    };

/** @brief std::replace() selector. */
  template<typename It, typename Op, typename T>
    struct replace_if_selector : public generic_for_each_selector<It>
    {
      /** @brief Value to replace with. */
      const T& new_val;

/** @brief Constructor.
       *  @param new_val Value to replace with. */
      explicit
      replace_if_selector(const T &new_val) : new_val(new_val) { }

/** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object. */
      bool
      operator()(Op& o, It i)
      {
	if (o(*i))
	  *i = new_val;
	return true;
      }
    };

/** @brief std::count() selector. */
  template<typename It, typename Diff>
    struct count_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param v Current value.
       *  @param i Iterator referencing object.
       *  @return 1 if count, 0 if does not count. */
      template<typename Val>
        Diff
        operator()(Val& v, It i)
	{ return (v == *i) ? 1 : 0; }
    };

/** @brief std::count_if () selector. */
  template<typename It, typename Diff>
    struct count_if_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator.
       *  @param i Iterator referencing object.
       *  @return 1 if count, 0 if does not count. */
      template<typename Op>
        Diff
        operator()(Op& o, It i)
	{ return (o(*i)) ? 1 : 0; }
    };

/** @brief std::accumulate() selector. */
  template<typename It>
    struct accumulate_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator (unused).
       *  @param i Iterator referencing object.
       *  @return The current value. */
      template<typename Op>
        typename std::iterator_traits<It>::value_type operator()(Op o, It i)
	{ return *i; }
    };

/** @brief std::inner_product() selector. */
  template<typename It, typename It2, typename T>
    struct inner_product_selector : public generic_for_each_selector<It>
    {
      /** @brief Begin iterator of first sequence. */
      It begin1_iterator;

/** @brief Begin iterator of second sequence. */
      It2 begin2_iterator;

/** @brief Constructor.
       *  @param b1 Begin iterator of first sequence.
       *  @param b2 Begin iterator of second sequence. */
      explicit
      inner_product_selector(It b1, It2 b2)
      : begin1_iterator(b1), begin2_iterator(b2) { }

/** @brief Functor execution.
       *  @param mult Multiplication functor.
       *  @param current Iterator referencing object.
       *  @return Inner product elemental result. */
      template<typename Op>
        T
        operator()(Op mult, It current)
	{
	  typename std::iterator_traits<It>::difference_type position
	    = current - begin1_iterator;
	  return mult(*current, *(begin2_iterator + position));
	}
    };

/** @brief Selector that just returns the passed iterator. */
  template<typename It>
    struct identity_selector : public generic_for_each_selector<It>
    {
      /** @brief Functor execution.
       *  @param o Operator (unused).
       *  @param i Iterator referencing object.
       *  @return Passed iterator. */
      template<typename Op>
        It
        operator()(Op o, It i)
	{ return i; }
    };

/** @brief Selector that returns the difference between two adjacent
   *  elements.
   */
  template<typename It>
    struct adjacent_difference_selector : public generic_for_each_selector<It>
    {
      template<typename Op>
        bool
        operator()(Op& o, It i)
	{
	  typename It::first_type go_back_one = i.first;
	  --go_back_one;
	  *i.second = o(*i.first, *go_back_one);
	  return true;
	}
    };

// XXX move into type_traits?
  /** @brief Functor doing nothing
   *
   *  For some reduction tasks (this is not a function object, but is
   *  passed as selector dummy parameter.
   */
  struct nothing
  {
    /** @brief Functor execution.
     *  @param i Iterator referencing object. */
    template<typename It>
      void
      operator()(It i) { }
  };

/** @brief Reduction function doing nothing. */
  struct dummy_reduct
  {
    bool
    operator()(bool /*x*/, bool /*y*/) const
    { return true; }
  };

/** @brief Reduction for finding the maximum element, using a comparator. */
  template<typename Comp, typename It>
    struct min_element_reduct
    {
      Comp& comp;

explicit
      min_element_reduct(Comp &c) : comp(c) { }

It
      operator()(It x, It y)
      {
	if (comp(*x, *y))
	  return x;
	else
	  return y;
      }
    };

/** @brief Reduction for finding the maximum element, using a comparator. */
  template<typename Comp, typename It>
    struct max_element_reduct
    {
      Comp& comp;

explicit
      max_element_reduct(Comp& c) : comp(c) { }

It
      operator()(It x, It y)
      {
	if (comp(*x, *y))
	  return y;
	else
	  return x;
      }
    };

/** @brief General reduction, using a binary operator. */
  template<typename BinOp>
    struct accumulate_binop_reduct
    {
      BinOp& binop;

explicit
      accumulate_binop_reduct(BinOp& b) : binop(b) { }

template<typename Result, typename Addend>
        Result
        operator()(const Result& x, const Addend& y)
	{ return binop(x, y); }
    };
}

#endif /* _GLIBCXX_PARALLEL_FOR_EACH_SELECTORS_H */

cmd: