JezK

Edit File: reducer_opmul.h

/*  reducer_opmul.h                  -*- C++ -*-
 *
 *  @copyright
 *  Copyright (C) 2012-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_opmul.h
 *
 *  @brief Defines classes for doing parallel multiplication reductions.
 *
 *  @ingroup ReducersMul
 *
 *  @see ReducersMul
 */

#ifndef REDUCER_OPMUL_H_INCLUDED
#define REDUCER_OPMUL_H_INCLUDED

#include <cilk/reducer.h>

/** @defgroup ReducersMul Multiplication Reducers
 *
 *  Multiplication reducers allow the computation of the product 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 redopmul_usage Usage Example
 *
 *      cilk::reducer< cilk::op_mul<double> > r;
 *      cilk_for (int i = 0; i != N; ++i) {
 *          *r *= a[i];
 *      }
 *      double product;
 *      r.move_out(product);
 *
 *  @section redopmul_monoid The Monoid
 *
 *  @subsection redopmul_monoid_values Value Set
 *
 *  The value set of a multiplication 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 redopmul_monoid_operator Operator
 *
 *  The operator of a multiplication reducer is the multiplication operation,
 *  defined by the “`*`” binary operator on `Type`.
 *
 *  @subsection redopmul_monoid_identity Identity
 *
 *  The identity value of the reducer is the numeric value “`1`”. This is
 *  expected to be the value of the expression `Type(1)`.
 *
 *  @section redopmul_operations Operations
 *
 *  @subsection redopmul_constructors Constructors
 *
 *      reducer()   // identity
 *      reducer(const Type& value)
 *      reducer(move_in(Type& variable))
 *
 *  @subsection redopmul_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 redopmul_initial Initial Values
 *
 *  If a multiplication 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 redopmul_types.
 *
 *  @subsection redopmul_view_ops View Operations
 *
 *      *r *= a
 *      *r = *r * a
 *      *r = *r * a1 * a2 … * an
 *
 *  @section redopmul_floating_point Issues with Floating-Point Types
 *
 *  Because of overflow and underflow issues, floating-point multiplication is
 *  not really associative. For example, `(1e200 * 1e-200) * 1e-200 == 1e-200`,
 *  but `1e200 * (1e-200 * 1e-200 == 0.
 *
 *  In many cases, this won’t matter, but computations which have been
 *  carefully ordered to control overflow and underflow 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 redopmul_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`.
 *
 *  The expression `Type(1)` must be a valid expression which yields the
 *  identity value (the value of `Type` whose numeric value is `1`).
 *
 *  @section redopmul_in_c Multiplication Reducers in C
 *
 *  The @ref CILK_C_REDUCER_OPMUL and @ref CILK_C_REDUCER_OPMUL_TYPE macros can
 *  be used to do multiplication reductions in C. For example:
 *
 *      CILK_C_REDUCER_OPMUL(r, double, 1);
 *      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 product of the elements of a is %f\n", REDUCER_VIEW(r));
 *
 *  See @ref reducers_c_predefined.
 */

#ifdef __cplusplus

namespace cilk {

/** The multiplication reducer view class.
 *
 *  This is the view class for reducers created with 
 *  `cilk::reducer< cilk::op_mul<Type> >`. It holds the accumulator variable 
 *  for the reduction, and allows only multiplication 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_mul 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 ReducersMul
 *  @see op_mul
 *
 *  @ingroup ReducersMul
 */
template <typename Type>
class op_mul_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_mul_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_mul_view are
     *  ones which generate an rhs_proxy — that is, expressions of the form
     *  `op_mul_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_mul_view
     */
    class rhs_proxy {
        friend class op_mul_view;

const op_mul_view* m_view;
        Type               m_value;

// Constructor is invoked only from op_mul_view::operator*().
        //
        rhs_proxy(const op_mul_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:
        /** Multiply by an additional rhs value. If `v` is an op_mul_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; }
    };

/** Default/identity constructor. This constructor initializes the 
     *  contained value to `Type(1)`, which is expected to be the identity
     *  value for multiplication on `Type`.
     */
    op_mul_view() : base(Type(1)) {}

/** Construct with a specified initial value.
     */
    explicit op_mul_view(const Type& v) : base(v) {}
    
    /** Reduction operation.
     *
     *  This function is invoked by the @ref op_mul monoid to combine the views
     *  of two strands when the right strand merges with the left one. It
     *  multiplies the value contained in the left-strand view by the value
     *  contained in the right-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_mul monoid to implement the monoid
     *          reduce operation.
     */
    void reduce(op_mul_view* right) { this->m_value *= right->m_value; }
    
    /** @name Accumulator variable updates.
     *
     *  These functions support the various syntaxes for multiplying the
     *  accumulator variable contained in the view by some value.
     */
    //@{

/** Multiply the accumulator variable by @a x.
     */
    op_mul_view& operator*=(const Type& x) { this->m_value *= x; return *this; }

/** 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_mul_view& operator=(const rhs_proxy& rhs) {
        __CILKRTS_ASSERT(this == rhs.m_view);
        this->m_value *= rhs.m_value;
        return *this;
    }
    
    //@}
};

/** Monoid class for multiplication reductions. Instantiate the cilk::reducer
 *  template class with an op_mul monoid to create a multiplication reducer
 *  class. For example, to compute the product of a set of `double` values:
 *
 *      cilk::reducer< cilk::op_mul<double> > r;
 *
 *  @see ReducersMul
 *  @see op_mul_view
 *
 *  @ingroup ReducersMul
 */
template <typename Type>
struct op_mul : public monoid_with_view< op_mul_view<Type> > {};

} // namespace cilk

#endif // __cplusplus

/** @ingroup ReducersAdd
 */
//@{

/** @name C language reducer macros
 *
 *  These macros are used to declare and work with numeric op_mul reducers in
 *  C code.
 *
 *  @see @ref page_reducers_in_c
 */
 //@{
 
__CILKRTS_BEGIN_EXTERN_C

/** Opmul reducer type name.
 *
 *  This macro expands into the identifier which is the name of the op_mul
 *  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 ReducersMul
 */
#define CILK_C_REDUCER_OPMUL_TYPE(tn)                                         \
    __CILKRTS_MKIDENT(cilk_c_reducer_opmul_,tn)

/** Declare an op_mul reducer object.
 *
 *  This macro expands into a declaration of an op_mul reducer object for a
 *  specified numeric type. For example:
 *
 *      CILK_C_REDUCER_OPMUL(my_reducer, double, 1.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 ReducersMul
 */
#define CILK_C_REDUCER_OPMUL(obj,tn,v)                                        \
    CILK_C_REDUCER_OPMUL_TYPE(tn) obj =                                       \
        CILK_C_INIT_REDUCER(_Typeof(obj.value),                               \
                        __CILKRTS_MKIDENT(cilk_c_reducer_opmul_reduce_,tn),   \
                        __CILKRTS_MKIDENT(cilk_c_reducer_opmul_identity_,tn), \
                        __cilkrts_hyperobject_noop_destroy, v)

/// @cond internal

/** Declare the op_mul reducer functions for a numeric type.
 *
 *  This macro expands into external function declarations for functions which 
 *  implement the reducer functionality for the op_mul 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_OPMUL_DECLARATION(t,tn)                             \
    typedef CILK_C_DECLARE_REDUCER(t) CILK_C_REDUCER_OPMUL_TYPE(tn);       \
    __CILKRTS_DECLARE_REDUCER_REDUCE(cilk_c_reducer_opmul,tn,l,r);         \
    __CILKRTS_DECLARE_REDUCER_IDENTITY(cilk_c_reducer_opmul,tn);
 
/** Define the op_mul reducer functions for a numeric type.
 *
 *  This macro expands into function definitions for functions which implement
 *  the reducer functionality for the op_mul 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_OPMUL_DEFINITION(t,tn)                              \
    typedef CILK_C_DECLARE_REDUCER(t) CILK_C_REDUCER_OPMUL_TYPE(tn);       \
    __CILKRTS_DECLARE_REDUCER_REDUCE(cilk_c_reducer_opmul,tn,l,r)          \
        { *(t*)l *= *(t*)r; }                                              \
    __CILKRTS_DECLARE_REDUCER_IDENTITY(cilk_c_reducer_opmul,tn)            \
        { *(t*)v = 1; }
 
//@{
/** @def CILK_C_REDUCER_OPMUL_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_OPMUL_INSTANCE(t,tn)  \
        CILK_C_REDUCER_OPMUL_DEFINITION(t,tn)
#else
#   define CILK_C_REDUCER_OPMUL_INSTANCE(t,tn)  \
        CILK_C_REDUCER_OPMUL_DECLARATION(t,tn)
#endif
//@}

/*  Declare or define an instance of the reducer type and its functions for each 
 *  numeric type.
 */
CILK_C_REDUCER_OPMUL_INSTANCE(char,                 char)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned char,        uchar)
CILK_C_REDUCER_OPMUL_INSTANCE(signed char,          schar)
CILK_C_REDUCER_OPMUL_INSTANCE(wchar_t,              wchar_t)
CILK_C_REDUCER_OPMUL_INSTANCE(short,                short)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned short,       ushort)
CILK_C_REDUCER_OPMUL_INSTANCE(int,                  int)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned int,         uint)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned int,         unsigned) /* alternate name */
CILK_C_REDUCER_OPMUL_INSTANCE(long,                 long)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned long,        ulong)
CILK_C_REDUCER_OPMUL_INSTANCE(long long,            longlong)
CILK_C_REDUCER_OPMUL_INSTANCE(unsigned long long,   ulonglong)
CILK_C_REDUCER_OPMUL_INSTANCE(float,                float)
CILK_C_REDUCER_OPMUL_INSTANCE(double,               double)
CILK_C_REDUCER_OPMUL_INSTANCE(long double,          longdouble)

//@endcond

__CILKRTS_END_EXTERN_C

//@}

#endif /*  REDUCER_OPMUL_H_INCLUDED */

Veranstaltungen | Fairnetzt-Hochrhein

Keine Veranstaltung gefunden!