| /* reducer_opadd.h -*- C++ -*- |
| * |
| * @copyright |
| * Copyright (C) 2009-2013, Intel Corporation |
| * All rights reserved. |
| * |
| * @copyright |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Intel Corporation nor the names of its |
| * contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * @copyright |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY |
| * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /** @file reducer_opadd.h |
| * |
| * @brief Defines classes for doing parallel addition reductions. |
| * |
| * @ingroup ReducersAdd |
| * |
| * @see ReducersAdd |
| */ |
| |
| #ifndef REDUCER_OPADD_H_INCLUDED |
| #define REDUCER_OPADD_H_INCLUDED |
| |
| #include <cilk/reducer.h> |
| |
| /** @defgroup ReducersAdd Addition Reducers |
| * |
| * Addition reducers allow the computation of the sum of a set of values in |
| * parallel. |
| * |
| * @ingroup Reducers |
| * |
| * You should be familiar with @ref pagereducers "Cilk reducers", described in |
| * file `reducers.md`, and particularly with @ref reducers_using, before trying |
| * to use the information in this file. |
| * |
| * @section redopadd_usage Usage Example |
| * |
| * cilk::reducer< cilk::op_add<int> > r; |
| * cilk_for (int i = 0; i != N; ++i) { |
| * *r += a[i]; |
| * } |
| * return r.get_value(); |
| * |
| * @section redopadd_monoid The Monoid |
| * |
| * @subsection redopadd_monoid_values Value Set |
| * |
| * The value set of an addition reducer is the set of values of `Type`, which |
| * is expected to be a builtin numeric type (or something like it, such as |
| * `std::complex`). |
| * |
| * @subsection redopadd_monoid_operator Operator |
| * |
| * The operator of an addition reducer is the addition operator, defined by |
| * the “`+`” binary operator on `Type`. |
| * |
| * @subsection redopadd_monoid_identity Identity |
| * |
| * The identity value of the reducer is the numeric value “`0`”. This is |
| * expected to be the value of the default constructor `Type()`. |
| * |
| * @section redopadd_operations Operations |
| * |
| * @subsection redopadd_constructors Constructors |
| * |
| * reducer() // identity |
| * reducer(const Type& value) |
| * reducer(move_in(Type& variable)) |
| * |
| * @subsection redopadd_get_set Set and Get |
| * |
| * r.set_value(const Type& value) |
| * const Type& = r.get_value() const |
| * r.move_in(Type& variable) |
| * r.move_out(Type& variable) |
| * |
| * @subsection redopadd_initial Initial Values |
| * |
| * If an addition reducer is constructed without an explicit initial value, |
| * then its initial value will be its identity value, as long as `Type` |
| * satisfies the requirements of @ref redopadd_types. |
| * |
| * @subsection redopadd_view_ops View Operations |
| * |
| * *r += a |
| * *r -= a |
| * ++*r |
| * --*r |
| * (*r)++ |
| * (*r)-- |
| * *r = *r + a |
| * *r = *r - a |
| * *r = *r ± a1 ± a2 … ± an |
| * |
| * The post-increment and post-decrement operations do not return a value. (If |
| * they did, they would expose the value contained in the view, which is |
| * non-deterministic in the middle of a reduction.) |
| * |
| * Note that subtraction operations are allowed on an addition reducer because |
| * subtraction is equivalent to addition with a negated operand. It is true |
| * that `(x - y) - z` is not equivalent to `x - (y - z)`, but |
| * `(x + (-y)) + (-z)` _is_ equivalent to `x + ((-y) + (-z))`. |
| * |
| * @section redopadd_floating_point Issues with Floating-Point Types |
| * |
| * Because of precision and round-off issues, floating-point addition is not |
| * really associative. For example, `(1e30 + -1e30) + 1 == 1`, but |
| * `1e30 + (-1e30 + 1) == 0`. |
| * |
| * In many cases, this won’t matter, but computations which have been |
| * carefully ordered to control round-off errors may not deal well with |
| * being reassociated. In general, you should be sure to understand the |
| * floating-point behavior of your program before doing any transformation |
| * that will reassociate its computations. |
| * |
| * @section redopadd_types Type and Operator Requirements |
| * |
| * `Type` must be `Copy Constructible`, `Default Constructible`, and |
| * `Assignable`. |
| * |
| * The operator “`+=`” must be defined on `Type`, with `x += a` having the |
| * same meaning as `x = x + a`. In addition, if the code uses the “`-=`”, |
| * pre-increment, post-increment, pre-decrement, or post-decrement operators, |
| * then the corresponding operators must be defined on `Type`. |
| * |
| * The expression `Type()` must be a valid expression which yields the |
| * identity value (the value of `Type` whose numeric value is zero). |
| * |
| * @section redopadd_in_c Addition Reducers in C |
| * |
| * The @ref CILK_C_REDUCER_OPADD and @ref CILK_C_REDUCER_OPADD_TYPE macros can |
| * be used to do addition reductions in C. For example: |
| * |
| * CILK_C_REDUCER_OPADD(r, double, 0); |
| * CILK_C_REGISTER_REDUCER(r); |
| * cilk_for(int i = 0; i != n; ++i) { |
| * REDUCER_VIEW(r) += a[i]; |
| * } |
| * CILK_C_UNREGISTER_REDUCER(r); |
| * printf("The sum of the elements of a is %f\n", REDUCER_VIEW(r)); |
| * |
| * See @ref reducers_c_predefined. |
| */ |
| |
| #ifdef __cplusplus |
| |
| namespace cilk { |
| |
| /** The addition reducer view class. |
| * |
| * This is the view class for reducers created with |
| * `cilk::reducer< cilk::op_add<Type> >`. It holds the accumulator variable |
| * for the reduction, and allows only addition and subtraction operations to |
| * be performed on it. |
| * |
| * @note The reducer “dereference” operation (`reducer::operator *()`) |
| * yields a reference to the view. Thus, for example, the view class’s |
| * `+=` operation would be used in an expression like `*r += a`, where |
| * `r` is an op_add reducer variable. |
| * |
| * @tparam Type The type of the contained accumulator variable. This will |
| * be the value type of a monoid_with_view that is |
| * instantiated with this view. |
| * |
| * @see ReducersAdd |
| * @see op_add |
| * |
| * @ingroup ReducersAdd |
| */ |
| template <typename Type> |
| class op_add_view : public scalar_view<Type> |
| { |
| typedef scalar_view<Type> base; |
| |
| public: |
| /** Class to represent the right-hand side of |
| * `*reducer = *reducer ± value`. |
| * |
| * The only assignment operator for the op_add_view class takes an |
| * rhs_proxy as its operand. This results in the syntactic restriction |
| * that the only expressions that can be assigned to an op_add_view are |
| * ones which generate an rhs_proxy — that is, expressions of the form |
| * `op_add_view ± value ... ± value`. |
| * |
| * @warning |
| * The lhs and rhs views in such an assignment must be the same; |
| * otherwise, the behavior will be undefined. (I.e., `v1 = v1 + x` is |
| * legal; `v1 = v2 + x` is illegal.) This condition will be checked with a |
| * runtime assertion when compiled in debug mode. |
| * |
| * @see op_add_view |
| */ |
| class rhs_proxy { |
| friend class op_add_view; |
| |
| const op_add_view* m_view; |
| Type m_value; |
| |
| // Constructor is invoked only from op_add_view::operator+() and |
| // op_add_view::operator-(). |
| // |
| rhs_proxy(const op_add_view* view, const Type& value) : |
| m_view(view), m_value(value) {} |
| |
| rhs_proxy& operator=(const rhs_proxy&); // Disable assignment operator |
| rhs_proxy(); // Disable default constructor |
| |
| public: |
| //@{ |
| /** Add or subtract an additional rhs value. If `v` is an op_add_view |
| * and `a1` is a value, then the expression `v + a1` invokes the view’s |
| * `operator+()` to create an rhs_proxy for `(v, a1)`; then |
| * `v + a1 + a2` invokes the rhs_proxy’s `operator+()` to create a new |
| * rhs_proxy for `(v, a1+a2)`. This allows the right-hand side of an |
| * assignment to be not just `view ± value`, but |
| * `view ± value ± value ... ± value`. The effect is that |
| * |
| * v = v ± a1 ± a2 ... ± an; |
| * |
| * is evaluated as |
| * |
| * v = v ± (±a1 ± a2 ... ± an); |
| */ |
| rhs_proxy& operator+(const Type& x) { m_value += x; return *this; } |
| rhs_proxy& operator-(const Type& x) { m_value -= x; return *this; } |
| //@} |
| }; |
| |
| |
| /** Default/identity constructor. This constructor initializes the |
| * contained value to `Type()`, which is expected to be the identity value |
| * for addition on `Type`. |
| */ |
| op_add_view() : base() {} |
| |
| /** Construct with a specified initial value. |
| */ |
| explicit op_add_view(const Type& v) : base(v) {} |
| |
| /** Reduction operation. |
| * |
| * This function is invoked by the @ref op_add monoid to combine the views |
| * of two strands when the right strand merges with the left one. It adds |
| * the value contained in the right-strand view to the value contained in |
| * the left-strand view, and leaves the value in the right-strand view |
| * undefined. |
| * |
| * @param right A pointer to the right-strand view. (`this` points to |
| * the left-strand view.) |
| * |
| * @note Used only by the @ref op_add monoid to implement the monoid |
| * reduce operation. |
| */ |
| void reduce(op_add_view* right) { this->m_value += right->m_value; } |
| |
| /** @name Accumulator variable updates. |
| * |
| * These functions support the various syntaxes for incrementing or |
| * decrementing the accumulator variable contained in the view. |
| */ |
| //@{ |
| |
| /** Increment the accumulator variable by @a x. |
| */ |
| op_add_view& operator+=(const Type& x) { this->m_value += x; return *this; } |
| |
| /** Decrement the accumulator variable by @a x. |
| */ |
| op_add_view& operator-=(const Type& x) { this->m_value -= x; return *this; } |
| |
| /** Pre-increment. |
| */ |
| op_add_view& operator++() { ++this->m_value; return *this; } |
| |
| /** Post-increment. |
| * |
| * @note Conventionally, post-increment operators return the old value |
| * of the incremented variable. However, reducer views do not |
| * expose their contained values, so `view++` does not have a |
| * return value. |
| */ |
| void operator++(int) { this->m_value++; } |
| |
| /** Pre-decrement. |
| */ |
| op_add_view& operator--() { --this->m_value; return *this; } |
| |
| /** Post-decrement. |
| * |
| * @note Conventionally, post-decrement operators return the old value |
| * of the decremented variable. However, reducer views do not |
| * expose their contained values, so `view--` does not have a |
| * return value. |
| */ |
| void operator--(int) { this->m_value--; } |
| |
| /** Create an object representing `*this + x`. |
| * |
| * @see rhs_proxy |
| */ |
| rhs_proxy operator+(const Type& x) const { return rhs_proxy(this, x); } |
| |
| /** Create an object representing `*this - x`. |
| * |
| * @see rhs_proxy |
| */ |
| rhs_proxy operator-(const Type& x) const { return rhs_proxy(this, -x); } |
| |
| /** Assign the result of a `view ± value` expression to the view. Note that |
| * this is the only assignment operator for this class. |
| * |
| * @see rhs_proxy |
| */ |
| op_add_view& operator=(const rhs_proxy& rhs) { |
| __CILKRTS_ASSERT(this == rhs.m_view); |
| this->m_value += rhs.m_value; |
| return *this; |
| } |
| |
| //@} |
| }; |
| |
| |
| /** Monoid class for addition reductions. Instantiate the cilk::reducer |
| * template class with an op_add monoid to create an addition reducer class. |
| * For example, to compute |
| * the sum of a set of `int` values: |
| * |
| * cilk::reducer< cilk::op_add<int> > r; |
| * |
| * @tparam Type The reducer value type. |
| * @tparam Align If `false` (the default), reducers instantiated on this |
| * monoid will be naturally aligned (the Cilk library 1.0 |
| * behavior). If `true`, reducers instantiated on this monoid |
| * will be cache-aligned for binary compatibility with |
| * reducers in Cilk library version 0.9. |
| * |
| * @see ReducersAdd |
| * @see op_add_view |
| * |
| * @ingroup ReducersAdd |
| */ |
| template <typename Type, bool Align = false> |
| struct op_add : public monoid_with_view<op_add_view<Type>, Align> {}; |
| |
| /** **Deprecated** addition reducer wrapper class. |
| * |
| * reducer_opadd is the same as @ref reducer<@ref op_add>, except that |
| * reducer_opadd is a proxy for the contained view, so that accumulator |
| * variable update operations can be applied directly to the reducer. For |
| * example, a value is added to a `reducer<%op_add>` with `*r += a`, but a |
| * value can be added to a `%reducer_opadd` with `r += a`. |
| * |
| * @deprecated Users are strongly encouraged to use `reducer<monoid>` |
| * reducers rather than the old wrappers like reducer_opadd. |
| * The `reducer<monoid>` reducers show the reducer/monoid/view |
| * architecture more clearly, are more consistent in their |
| * implementation, and present a simpler model for new |
| * user-implemented reducers. |
| * |
| * @note Implicit conversions are provided between `%reducer_opadd` |
| * and `reducer<%op_add>`. This allows incremental code |
| * conversion: old code that used `%reducer_opadd` can pass a |
| * `%reducer_opadd` to a converted function that now expects a |
| * pointer or reference to a `reducer<%op_add>`, and vice |
| * versa. |
| * |
| * @tparam Type The value type of the reducer. |
| * |
| * @see op_add |
| * @see reducer |
| * @see ReducersAdd |
| * |
| * @ingroup ReducersAdd |
| */ |
| template <typename Type> |
| class reducer_opadd : public reducer< op_add<Type, true> > |
| { |
| typedef reducer< op_add<Type, true> > base; |
| using base::view; |
| |
| public: |
| /// The view type for the reducer. |
| typedef typename base::view_type view_type; |
| |
| /// The view’s rhs proxy type. |
| typedef typename view_type::rhs_proxy rhs_proxy; |
| |
| /// The view type for the reducer. |
| typedef view_type View; |
| |
| /// The monoid type for the reducer. |
| typedef typename base::monoid_type Monoid; |
| |
| /** @name Constructors |
| */ |
| //@{ |
| |
| /** Default (identity) constructor. |
| * |
| * Constructs the wrapper with the default initial value of `Type()`. |
| */ |
| reducer_opadd() {} |
| |
| /** Value constructor. |
| * |
| * Constructs the wrapper with a specified initial value. |
| */ |
| explicit reducer_opadd(const Type& initial_value) : base(initial_value) {} |
| |
| //@} |
| |
| /** @name Forwarded functions |
| * @details Functions that update the contained accumulator variable are |
| * simply forwarded to the contained @ref op_add_view. */ |
| //@{ |
| |
| /// @copydoc op_add_view::operator+=(const Type&) |
| reducer_opadd& operator+=(const Type& x) { view() += x; return *this; } |
| |
| /// @copydoc op_add_view::operator-=(const Type&) |
| reducer_opadd& operator-=(const Type& x) { view() -= x; return *this; } |
| |
| /// @copydoc op_add_view::operator++() |
| reducer_opadd& operator++() { ++view(); return *this; } |
| |
| /// @copydoc op_add_view::operator++(int) |
| void operator++(int) { view()++; } |
| |
| /// @copydoc op_add_view::operator-\-() |
| reducer_opadd& operator--() { --view(); return *this; } |
| |
| /// @copydoc op_add_view::operator-\-(int) |
| void operator--(int) { view()--; } |
| |
| // The legacy definitions of reducer_opadd::operator+() and |
| // reducer_opadd::operator-() have different behavior and a different |
| // return type than this definition. The legacy version is defined as a |
| // member function, so this new version is defined as a free function to |
| // give it a different signature, so that they won’t end up sharing a |
| // single object file entry. |
| |
| /// @copydoc op_add_view::operator+(const Type&) const |
| friend rhs_proxy operator+(const reducer_opadd& r, const Type& x) |
| { |
| return r.view() + x; |
| } |
| /// @copydoc op_add_view::operator-(const Type&) const |
| friend rhs_proxy operator-(const reducer_opadd& r, const Type& x) |
| { |
| return r.view() - x; |
| } |
| /// @copydoc op_add_view::operator=(const rhs_proxy&) |
| reducer_opadd& operator=(const rhs_proxy& temp) |
| { |
| view() = temp; |
| return *this; |
| } |
| //@} |
| |
| /** @name Dereference |
| * @details Dereferencing a wrapper is a no-op. It simply returns the |
| * wrapper. Combined with the rule that the wrapper forwards view |
| * operations to its contained view, this means that view operations can |
| * be written the same way on reducers and wrappers, which is convenient |
| * for incrementally converting old code using wrappers to use reducers |
| * instead. That is: |
| * |
| * reducer< op_add<int> > r; |
| * *r += a; // *r returns the view |
| * // operator += is a view member function |
| * |
| * reducer_opadd<int> w; |
| * *w += a; // *w returns the wrapper |
| * // operator += is a wrapper member function that |
| * // calls the corresponding view function |
| */ |
| //@{ |
| reducer_opadd& operator*() { return *this; } |
| reducer_opadd const& operator*() const { return *this; } |
| |
| reducer_opadd* operator->() { return this; } |
| reducer_opadd const* operator->() const { return this; } |
| //@} |
| |
| /** @name Upcast |
| * @details In Cilk library 0.9, reducers were always cache-aligned. In |
| * library 1.0, reducer cache alignment is optional. By default, reducers |
| * are unaligned (i.e., just naturally aligned), but legacy wrappers |
| * inherit from cache-aligned reducers for binary compatibility. |
| * |
| * This means that a wrapper will automatically be upcast to its aligned |
| * reducer base class. The following conversion operators provide |
| * pseudo-upcasts to the corresponding unaligned reducer class. |
| */ |
| //@{ |
| operator reducer< op_add<Type, false> >& () |
| { |
| return *reinterpret_cast< reducer< op_add<Type, false> >* >(this); |
| } |
| operator const reducer< op_add<Type, false> >& () const |
| { |
| return *reinterpret_cast< const reducer< op_add<Type, false> >* >(this); |
| } |
| //@} |
| }; |
| |
| /// @cond internal |
| /** Metafunction specialization for reducer conversion. |
| * |
| * This specialization of the @ref legacy_reducer_downcast template class |
| * defined in reducer.h causes the `reducer< op_add<Type> >` class to have an |
| * `operator reducer_opadd<Type>& ()` conversion operator that statically |
| * downcasts the `reducer<op_add>` to the corresponding `reducer_opadd` type. |
| * (The reverse conversion, from `reducer_opadd` to `reducer<op_add>`, is just |
| * an upcast, which is provided for free by the language.) |
| * |
| * @ingroup ReducersAdd |
| */ |
| template <typename Type, bool Align> |
| struct legacy_reducer_downcast<reducer<op_add<Type, Align> > > |
| { |
| typedef reducer_opadd<Type> type; |
| }; |
| /// @endcond |
| |
| } // namespace cilk |
| |
| #endif // __cplusplus |
| |
| |
| /** @ingroup ReducersAdd |
| */ |
| //@{ |
| |
| /** @name C Language Reducer Macros |
| * |
| * These macros are used to declare and work with numeric op_add reducers in |
| * C code. |
| * |
| * @see @ref page_reducers_in_c |
| */ |
| //@{ |
| |
| __CILKRTS_BEGIN_EXTERN_C |
| |
| /** Opadd reducer type name. |
| * |
| * This macro expands into the identifier which is the name of the op_add |
| * reducer type for a specified numeric type. |
| * |
| * @param tn The @ref reducers_c_type_names "numeric type name" specifying |
| * the type of the reducer. |
| * |
| * @see @ref reducers_c_predefined |
| * @see ReducersAdd |
| */ |
| #define CILK_C_REDUCER_OPADD_TYPE(tn) \ |
| __CILKRTS_MKIDENT(cilk_c_reducer_opadd_,tn) |
| |
| /** Declare an op_add reducer object. |
| * |
| * This macro expands into a declaration of an op_add reducer object for a |
| * specified numeric type. For example: |
| * |
| * CILK_C_REDUCER_OPADD(my_reducer, double, 0.0); |
| * |
| * @param obj The variable name to be used for the declared reducer object. |
| * @param tn The @ref reducers_c_type_names "numeric type name" specifying |
| * the type of the reducer. |
| * @param v The initial value for the reducer. (A value which can be |
| * assigned to the numeric type represented by @a tn.) |
| * |
| * @see @ref reducers_c_predefined |
| * @see ReducersAdd |
| */ |
| #define CILK_C_REDUCER_OPADD(obj,tn,v) \ |
| CILK_C_REDUCER_OPADD_TYPE(tn) obj = \ |
| CILK_C_INIT_REDUCER(_Typeof(obj.value), \ |
| __CILKRTS_MKIDENT(cilk_c_reducer_opadd_reduce_,tn), \ |
| __CILKRTS_MKIDENT(cilk_c_reducer_opadd_identity_,tn), \ |
| __cilkrts_hyperobject_noop_destroy, v) |
| |
| /// @cond internal |
| |
| /** Declare the op_add reducer functions for a numeric type. |
| * |
| * This macro expands into external function declarations for functions which |
| * implement the reducer functionality for the op_add reducer type for a |
| * specified numeric type. |
| * |
| * @param t The value type of the reducer. |
| * @param tn The value “type name” identifier, used to construct the reducer |
| * type name, function names, etc. |
| */ |
| #define CILK_C_REDUCER_OPADD_DECLARATION(t,tn) \ |
| typedef CILK_C_DECLARE_REDUCER(t) CILK_C_REDUCER_OPADD_TYPE(tn); \ |
| __CILKRTS_DECLARE_REDUCER_REDUCE(cilk_c_reducer_opadd,tn,l,r); \ |
| __CILKRTS_DECLARE_REDUCER_IDENTITY(cilk_c_reducer_opadd,tn); |
| |
| /** Define the op_add reducer functions for a numeric type. |
| * |
| * This macro expands into function definitions for functions which implement |
| * the reducer functionality for the op_add reducer type for a specified |
| * numeric type. |
| * |
| * @param t The value type of the reducer. |
| * @param tn The value “type name” identifier, used to construct the reducer |
| * type name, function names, etc. |
| */ |
| #define CILK_C_REDUCER_OPADD_DEFINITION(t,tn) \ |
| typedef CILK_C_DECLARE_REDUCER(t) CILK_C_REDUCER_OPADD_TYPE(tn); \ |
| __CILKRTS_DECLARE_REDUCER_REDUCE(cilk_c_reducer_opadd,tn,l,r) \ |
| { *(t*)l += *(t*)r; } \ |
| __CILKRTS_DECLARE_REDUCER_IDENTITY(cilk_c_reducer_opadd,tn) \ |
| { *(t*)v = 0; } |
| |
| //@{ |
| /** @def CILK_C_REDUCER_OPADD_INSTANCE |
| * @brief Declare or define implementation functions for a reducer type. |
| * |
| * In the runtime source file c_reducers.c, the macro `CILK_C_DEFINE_REDUCERS` |
| * will be defined, and this macro will generate reducer implementation |
| * functions. Everywhere else, `CILK_C_DEFINE_REDUCERS` will be undefined, |
| * and this macro will expand into external declarations for the functions. |
| */ |
| #ifdef CILK_C_DEFINE_REDUCERS |
| # define CILK_C_REDUCER_OPADD_INSTANCE(t,tn) \ |
| CILK_C_REDUCER_OPADD_DEFINITION(t,tn) |
| #else |
| # define CILK_C_REDUCER_OPADD_INSTANCE(t,tn) \ |
| CILK_C_REDUCER_OPADD_DECLARATION(t,tn) |
| #endif |
| //@} |
| |
| /* Declare or define an instance of the reducer type and its functions for each |
| * numeric type. |
| */ |
| CILK_C_REDUCER_OPADD_INSTANCE(char, char) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned char, uchar) |
| CILK_C_REDUCER_OPADD_INSTANCE(signed char, schar) |
| CILK_C_REDUCER_OPADD_INSTANCE(wchar_t, wchar_t) |
| CILK_C_REDUCER_OPADD_INSTANCE(short, short) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned short, ushort) |
| CILK_C_REDUCER_OPADD_INSTANCE(int, int) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned int, uint) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned int, unsigned) /* alternate name */ |
| CILK_C_REDUCER_OPADD_INSTANCE(long, long) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned long, ulong) |
| CILK_C_REDUCER_OPADD_INSTANCE(long long, longlong) |
| CILK_C_REDUCER_OPADD_INSTANCE(unsigned long long, ulonglong) |
| CILK_C_REDUCER_OPADD_INSTANCE(float, float) |
| CILK_C_REDUCER_OPADD_INSTANCE(double, double) |
| CILK_C_REDUCER_OPADD_INSTANCE(long double, longdouble) |
| |
| //@endcond |
| |
| __CILKRTS_END_EXTERN_C |
| |
| //@} |
| |
| //@} |
| |
| #endif /* REDUCER_OPADD_H_INCLUDED */ |
