detail/wrap_argument_vector.hpp

   1 //  vector signal argument wrappers
   2 //  Copyright (C) 2010 Tim Blechmann
   3 //
   4 //  This program is free software; you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation; either version 2 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program; see the file COPYING.  If not, write to
  16 //  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17 //  Boston, MA 02111-1307, USA.
  18
  19 #ifndef NOVA_SIMD_DETAIL_WRAP_ARGUMENT_VECTOR_HPP
  20 #define NOVA_SIMD_DETAIL_WRAP_ARGUMENT_VECTOR_HPP
  21
  22 #include "../vec.hpp"
  23
  24 #include "wrap_arguments.hpp"
  25
  26 #if defined(__GNUC__) && defined(NDEBUG)
  27 #define always_inline inline  __attribute__((always_inline))
  28 #else
  29 #define always_inline inline
  30 #endif
  31
  32
  33 namespace nova {
  34 namespace detail {
  35
  36 template <typename FloatType>
  37 struct vector_pointer_argument
  38 {
  39     always_inline explicit vector_pointer_argument(const FloatType * arg):
  40         data(arg)
  41     {}
  42
  43     always_inline void increment(void)
  44     {
  45         data += vec<FloatType>::size;
  46     }
  47
  48     always_inline vec<FloatType> get(void) const
  49     {
  50         vec<FloatType> ret;
  51         ret.load_aligned(data);
  52         return ret;
  53     }
  54
  55     always_inline vec<FloatType> consume(void)
  56     {
  57         vec<FloatType> ret;
  58         ret.load_aligned(data);
  59         increment();
  60         return ret;
  61     }
  62
  63     const FloatType * data;
  64 };
  65
  66 template <typename FloatType>
  67 struct vector_scalar_argument
  68 {
  69     always_inline explicit vector_scalar_argument(FloatType const & arg):
  70         data(arg)
  71     {}
  72
  73     always_inline void increment(void)
  74     {}
  75
  76     always_inline vec<FloatType> get(void) const
  77     {
  78         return vec<FloatType>(data);
  79     }
  80
  81     always_inline vec<FloatType> consume(void)
  82     {
  83         return vec<FloatType>(data);
  84     }
  85
  86     FloatType data;
  87 };
  88
  89 template <typename FloatType>
  90 struct vector_ramp_argument
  91 {
  92     always_inline vector_ramp_argument(FloatType const & base, FloatType const & slope)
  93     {
  94         float vSlope = data.set_slope(base, slope);
  95         slope_.set_vec(vSlope);
  96     }
  97
  98     always_inline void increment(void)
  99     {
 100         data += slope_;
 101     }
 102
 103     always_inline vec<FloatType> get(void) const
 104     {
 105         return data;
 106     }
 107
 108     always_inline vec<FloatType> consume(void)
 109     {
 110         vec<FloatType> ret(data);
 111         increment();
 112         return ret;
 113     }
 114
 115     vec<FloatType> data;
 116     vec<FloatType> slope_;
 117 };
 118
 119 /* convert scalar args to vector args */
 120 template <typename FloatType>
 121 always_inline detail::vector_scalar_argument<FloatType>
 122 wrap_vector_arg(detail::scalar_scalar_argument<FloatType> const & arg)
 123 {
 124     return detail::vector_scalar_argument<FloatType>(arg.data);
 125 }
 126
 127 template <typename FloatType>
 128 always_inline detail::vector_pointer_argument<FloatType>
 129 wrap_vector_arg(detail::scalar_pointer_argument<FloatType> const & arg)
 130 {
 131     return detail::vector_pointer_argument<FloatType>(arg.data);
 132 }
 133
 134 template <typename FloatType>
 135 always_inline detail::vector_ramp_argument<FloatType>
 136 wrap_vector_arg(detail::scalar_ramp_argument<FloatType> const & arg)
 137 {
 138     return detail::vector_ramp_argument<FloatType>(arg.data, arg.slope_);
 139 }
 140
 141 } /* namespace detail */
 142 } /* namespace nova */
 143
 144 #undef always_inline
 145
 146
 147 #endif /* NOVA_SIMD_DETAIL_WRAP_ARGUMENT_VECTOR_HPP */