+++ /dev/null
-/* -*- C++ -*- ------------------------------------------------------------
-
-Copyright (c) 2007 Jesse Anders and Demian Nave http://cmldev.net/
-
-The Configurable Math Library (CML) is distributed under the terms of the
-Boost Software License, v1.0 (see cml/LICENSE for details).
-
- *-----------------------------------------------------------------------*/
-/** @file
- * @brief
- *
- * Defines vector unrollers.
- *
- * @todo Add unrolling for dynamic vectors, and for vectors longer than
- * CML_VECTOR_UNROLL_LIMIT.
- *
- * @todo Does it make sense to unroll an assignment if either side of the
- * assignment has a fixed size, or just when the target vector is fixed
- * size?
- */
-
-#ifndef vector_unroller_h
-#define vector_unroller_h
-
-#include <cml/et/traits.h>
-#include <cml/et/size_checking.h>
-#include <cml/et/scalar_ops.h>
-
-#if !defined(CML_VECTOR_UNROLL_LIMIT)
-#error "CML_VECTOR_UNROLL_LIMIT is undefined."
-#endif
-
-namespace cml {
-namespace et {
-namespace detail {
-
-/** Unroll a binary assignment operator on a fixed-size vector.
- *
- * This uses forward iteration to make efficient use of the cache.
- *
- * @sa cml::vector
- * @sa cml::et::OpAssign
- *
- * @bug Need to verify that OpT is actually an assignment operator.
- */
-template<class OpT, typename E, class AT, class SrcT>
-class VectorAssignmentUnroller
-{
- protected:
-
- /* Forward declare: */
- template<int N, int Last, bool can_unroll> struct Eval;
-
- /* The vector type being assigned to: */
- typedef cml::vector<E,AT> vector_type;
-
- /* Record traits for the arguments: */
- typedef ExprTraits<vector_type> dest_traits;
- typedef ExprTraits<SrcT> src_traits;
-
- /** Evaluate the binary operator for the first Len-1 elements. */
- template<int N, int Last> struct Eval<N,Last,true> {
- void operator()(vector_type& dest, const SrcT& src) const {
-
- /* Apply to current N: */
- OpT().apply(dest[N], src_traits().get(src,N));
- /* Note: we don't need get(), since dest is a vector. */
-
- /* Apply to N+1: */
- Eval<N+1,Last,true>()(dest, src);
- }
- };
-
- /** Evaluate the binary operator at element Last. */
- template<int Last> struct Eval<Last,Last,true> {
- void operator()(vector_type& dest, const SrcT& src) const {
-
- /* Apply to last element: */
- OpT().apply(dest[Last], src_traits().get(src,Last));
- /* Note: we don't need get(), since dest is a vector. */
- }
- };
-
-
- /** Evaluate the binary operator using a loop.
- *
- * This is used when the vector's length is longer than
- * CML_VECTOR_UNROLL_LIMIT
- */
- template<int N, int Last> struct Eval<N,Last,false> {
- void operator()(vector_type& dest, const SrcT& src) const {
- for(size_t i = 0; i <= Last; ++i) {
- OpT().apply(dest[i], src_traits().get(src,i));
- /* Note: we don't need get(), since dest is a vector. */
- }
- }
- };
-
-
- public:
-
- /** Unroll assignment to a fixed-sized vector. */
- void operator()(vector_type& dest, const SrcT& src, cml::fixed_size_tag)
- {
- typedef cml::vector<E,AT> vector_type;
- enum { Len = vector_type::array_size };
- typedef typename VectorAssignmentUnroller<OpT,E,AT,SrcT>::template
- Eval<0, Len-1, (Len <= CML_VECTOR_UNROLL_LIMIT)> Unroller;
- /* Note: Len is the array size, so Len-1 is the last element. */
-
- /* Use a run-time check if src is a run-time sized expression: */
- typedef typename ExprTraits<SrcT>::size_tag src_size;
- typedef typename select_if<
- same_type<src_size,dynamic_size_tag>::is_true,
- dynamic_size_tag, fixed_size_tag>::result size_tag;
-
- /* Check the expression size (the returned size isn't needed): */
- CheckedSize(dest,src,size_tag());
- /* Note: for two fixed-size expressions, the if-statements and
- * comparisons should be completely eliminated as dead code. If src
- * is a dynamic-sized expression, the check will still happen.
- */
-
- /* Now, call the unroller: */
- Unroller()(dest,src);
- }
-
-
- private:
- /* XXX Blah, a temp. hack to fix the auto-resizing stuff below. */
- size_t CheckOrResize(
- vector_type& dest, const SrcT& src, cml::resizable_tag)
- {
-#if defined(CML_AUTOMATIC_VECTOR_RESIZE_ON_ASSIGNMENT)
- /* Get the size of src. This also causes src to check its size: */
- size_t N = std::max(dest.size(),src_traits().size(src));
-
- /* Set the destination vector's size: */
- cml::et::detail::Resize(dest,N);
-#else
- size_t N = CheckedSize(dest,src,dynamic_size_tag());
-#endif
-
- return N;
- }
-
- size_t CheckOrResize(
- vector_type& dest, const SrcT& src, cml::not_resizable_tag)
- {
- return CheckedSize(dest,src,dynamic_size_tag());
- }
- /* XXX Blah, a temp. hack to fix the auto-resizing stuff below. */
- public:
-
-
- /** Just use a loop to assign to a runtime-sized vector. */
- void operator()(vector_type& dest, const SrcT& src, cml::dynamic_size_tag)
- {
- /* Shorthand: */
- typedef ExprTraits<SrcT> src_traits;
- size_t N = this->CheckOrResize(
- dest,src,typename vector_type::resizing_tag());
- for(size_t i = 0; i < N; ++i) {
- OpT().apply(dest[i], src_traits().get(src,i));
- /* Note: we don't need get(), since dest is a vector. */
- }
- }
-
-};
-
-/** Unroll a vector accumulation/reduction operator.
- *
- * This uses forward iteration to make efficient use of the cache.
- */
-template<class AccumT, class OpT, class LeftT, class RightT>
-struct VectorAccumulateUnroller
-{
- /* Forward declare: */
- template<int N, int Last, bool can_unroll> struct Eval;
-
- /* Record traits for the arguments: */
- typedef ExprTraits<LeftT> left_traits;
- typedef ExprTraits<RightT> right_traits;
-
- /* Figure out the return type: */
- typedef typename AccumT::value_type result_type;
-
- /** Evaluate for the first Len-1 elements. */
- template<int N, int Last> struct Eval<N,Last,true> {
- result_type operator()(
- const LeftT& left, const RightT& right) const
- {
- /* Apply to last value: */
- return AccumT().apply(
- OpT().apply(left[N], right_traits().get(right,N)),
- Eval<N+1,Last,true>()(left, right));
- /* Note: we don't need get(), since dest is a vector. */
- }
- };
-
- /** Evaluate the binary operator at element Last. */
- template<int Last> struct Eval<Last,Last,true> {
- result_type operator()(
- const LeftT& left, const RightT& right) const
- {
- return OpT().apply(left[Last],right_traits().get(right,Last));
- /* Note: we don't need get(), since dest is a vector. */
- }
- };
-
- /** Evaluate using a loop. */
- template<int N, int Last> struct Eval<N,Last,false> {
- result_type operator()(
- const LeftT& left, const RightT& right) const
- {
- result_type accum = OpT().apply(left[0],right[0]);
- for(size_t i = 1; i <= Last; ++i) {
- /* XXX This might not be optimized properly by some compilers,
- * but to do anything else requires changing the requirements
- * of a scalar operator.
- */
- accum = AccumT().apply(accum, OpT().apply(
- left[i],right_traits().get(right,i)));
- /* Note: we don't need get(), since dest is a vector. */
- }
- }
- };
-};
-
-}
-
-/** Construct an assignment unroller.
- *
- * The operator must be an assignment op, otherwise, this doesn't make any
- * sense.
- *
- * @bug Need to verify that OpT is actually an assignment operator.
- */
-template<class OpT, class SrcT, typename E, class AT> inline
-void UnrollAssignment(cml::vector<E,AT>& dest, const SrcT& src)
-{
- /* Record the destination vector type, and the expression traits: */
- typedef cml::vector<E,AT> vector_type;
-
- /* Record the type of the unroller: */
- typedef detail::VectorAssignmentUnroller<OpT,E,AT,SrcT> unroller;
-
- /* Do the unroll call: */
- unroller()(dest, src, typename vector_type::size_tag());
- /* XXX It may make sense to unroll if either side is a fixed size. */
-}
-
-} // namespace et
-} // namespace cml
-
-#endif
-
-// -------------------------------------------------------------------------
-// vim:ft=cpp
projects / chaz / yoink / blobdiff