projects / ceph.git / blame
| Commit | Line | Data |
|---|---|---|
| 7c673cae FG |
1 | // |
| 2 | // Copyright (c) 2000-2002 | |
| 3 | // Joerg Walter, Mathias Koch | |
| 4 | // | |
| 5 | // Distributed under the Boost Software License, Version 1.0. (See | |
| 6 | // accompanying file LICENSE_1_0.txt or copy at | |
| 7 | // http://www.boost.org/LICENSE_1_0.txt) | |
| 8 | // | |
| 9 | // The authors gratefully acknowledge the support of | |
| 10 | // GeNeSys mbH & Co. KG in producing this work. | |
| 11 | // | |
| 12 | ||
| 13 | #include "bench2.hpp" | |
| 14 | ||
| 15 | template<class T, int N> | |
| 16 | struct bench_c_matrix_prod { | |
| 17 | typedef T value_type; | |
| 18 | ||
| 19 | void operator () (int runs) const { | |
| 20 | try { | |
| 21 | static typename c_matrix_traits<T, N, N>::type m1, m2, m3; | |
| 22 | initialize_c_matrix<T, N, N> () (m1); | |
| 23 | initialize_c_matrix<T, N, N> () (m2); | |
| 24 | boost::timer t; | |
| 25 | for (int i = 0; i < runs; ++ i) { | |
| 26 | for (int j = 0; j < N; ++ j) { | |
| 27 | for (int k = 0; k < N; ++ k) { | |
| 28 | m3 [j] [k] = 0; | |
| 29 | for (int l = 0; l < N; ++ l) { | |
| 30 | m3 [j] [k] += m1 [j] [l] * m2 [l] [k]; | |
| 31 | } | |
| 32 | } | |
| 33 | } | |
| 34 | // sink_c_matrix<T, N, N> () (m3); | |
| 35 | } | |
| 36 | footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ()); | |
| 37 | } | |
| 38 | catch (std::exception &e) { | |
| 39 | std::cout << e.what () << std::endl; | |
| 40 | } | |
| 41 | } | |
| 42 | }; | |
| 43 | template<class M1, class M2, int N> | |
| 44 | struct bench_my_matrix_prod { | |
| 45 | typedef typename M1::value_type value_type; | |
| 46 | ||
| 47 | void operator () (int runs, safe_tag) const { | |
| 48 | try { | |
| 49 | static M1 m1 (N, N, N * N), m3 (N, N, N * N); | |
| 50 | static M2 m2 (N, N, N * N); | |
| 51 | initialize_matrix (m1); | |
| 52 | initialize_matrix (m2); | |
| 53 | boost::timer t; | |
| 54 | for (int i = 0; i < runs; ++ i) { | |
| 55 | m3 = ublas::prod (m1, m2); | |
| 56 | // sink_matrix (m3); | |
| 57 | } | |
| 58 | footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ()); | |
| 59 | } | |
| 60 | catch (std::exception &e) { | |
| 61 | std::cout << e.what () << std::endl; | |
| 62 | } | |
| 63 | } | |
| 64 | void operator () (int runs, fast_tag) const { | |
| 65 | try { | |
| 66 | static M1 m1 (N, N, N * N), m3 (N, N, N * N); | |
| 67 | static M2 m2 (N, N, N * N); | |
| 68 | initialize_matrix (m1); | |
| 69 | initialize_matrix (m2); | |
| 70 | boost::timer t; | |
| 71 | for (int i = 0; i < runs; ++ i) { | |
| 72 | m3.assign (ublas::prod (m1, m2)); | |
| 73 | // sink_matrix (m3); | |
| 74 | } | |
| 75 | footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ()); | |
| 76 | } | |
| 77 | catch (std::exception &e) { | |
| 78 | std::cout << e.what () << std::endl; | |
| 79 | } | |
| 80 | } | |
| 81 | }; | |
| 82 | template<class M, int N> | |
| 83 | struct bench_cpp_matrix_prod { | |
| 84 | typedef typename M::value_type value_type; | |
| 85 | ||
| 86 | void operator () (int runs) const { | |
| 87 | try { | |
| 88 | static M m1 (N * N), m2 (N * N), m3 (N * N); | |
| 89 | initialize_vector (m1); | |
| 90 | initialize_vector (m2); | |
| 91 | boost::timer t; | |
| 92 | for (int i = 0; i < runs; ++ i) { | |
| 93 | for (int j = 0; j < N; ++ j) { | |
| 94 | std::valarray<value_type> row (m1 [std::slice (N * j, N, 1)]); | |
| 95 | for (int k = 0; k < N; ++ k) { | |
| 96 | std::valarray<value_type> column (m2 [std::slice (k, N, N)]); | |
| 97 | m3 [N * j + k] = (row * column).sum (); | |
| 98 | } | |
| 99 | } | |
| 100 | // sink_vector (m3); | |
| 101 | } | |
| 102 | footer<value_type> () (N * N * N, N * N * (N - 1), runs, t.elapsed ()); | |
| 103 | } | |
| 104 | catch (std::exception &e) { | |
| 105 | std::cout << e.what () << std::endl; | |
| 106 | } | |
| 107 | } | |
| 108 | }; | |
| 109 | ||
| 110 | // Benchmark O (n ^ 3) | |
| 111 | template<class T, int N> | |
| 112 | void bench_3<T, N>::operator () (int runs) { | |
| 113 | header ("bench_3"); | |
| 114 | ||
| 115 | header ("prod (matrix, matrix)"); | |
| 116 | ||
| 117 | header ("C array"); | |
| 118 | bench_c_matrix_prod<T, N> () (runs); | |
| 119 | ||
| 120 | #ifdef USE_SPARSE_MATRIX | |
| 121 | #ifdef USE_MAP_ARRAY | |
| 122 | header ("sparse_matrix<row_major, map_array>, sparse_matrix<column_major, map_array> safe"); | |
| 123 | bench_my_matrix_prod<ublas::sparse_matrix<T, ublas::row_major, ublas::map_array<std::size_t, T> >, | |
| 124 | ublas::sparse_matrix<T, ublas::column_major, ublas::map_array<std::size_t, T> >, N> () (runs, safe_tag ()); | |
| 125 | ||
| 126 | header ("sparse_matrix<row_major, map_array>, sparse_matrix<column_major, map_array> fast"); | |
| 127 | bench_my_matrix_prod<ublas::sparse_matrix<T, ublas::row_major, ublas::map_array<std::size_t, T> >, | |
| 128 | ublas::sparse_matrix<T, ublas::column_major, ublas::map_array<std::size_t, T> >, N> () (runs, fast_tag ()); | |
| 129 | #endif | |
| 130 | ||
| 131 | #ifdef USE_STD_MAP | |
| 132 | header ("sparse_matrix<row_major, std::map>, sparse_matrix<column_major, std::map> safe"); | |
| 133 | bench_my_matrix_prod<ublas::sparse_matrix<T, ublas::row_major, std::map<std::size_t, T> >, | |
| 134 | ublas::sparse_matrix<T, ublas::column_major, std::map<std::size_t, T> >, N> () (runs, safe_tag ()); | |
| 135 | ||
| 136 | header ("sparse_matrix<row_major, std::map>, sparse_matrix<column_major, std::map> fast"); | |
| 137 | bench_my_matrix_prod<ublas::sparse_matrix<T, ublas::row_major, std::map<std::size_t, T> >, | |
| 138 | ublas::sparse_matrix<T, ublas::column_major, std::map<std::size_t, T> >, N> () (runs, fast_tag ()); | |
| 139 | #endif | |
| 140 | #endif | |
| 141 | ||
| 142 | #ifdef USE_COMPRESSED_MATRIX | |
| 143 | header ("compressed_matrix<row_major>, compressed_matrix<column_major> safe"); | |
| 144 | bench_my_matrix_prod<ublas::compressed_matrix<T, ublas::row_major>, | |
| 145 | ublas::compressed_matrix<T, ublas::column_major>, N> () (runs, safe_tag ()); | |
| 146 | ||
| 147 | header ("compressed_matrix<row_major>, compressed_matrix<column_major> fast"); | |
| 148 | bench_my_matrix_prod<ublas::compressed_matrix<T, ublas::row_major>, | |
| 149 | ublas::compressed_matrix<T, ublas::column_major>, N> () (runs, fast_tag ()); | |
| 150 | #endif | |
| 151 | ||
| 152 | #ifdef USE_COORDINATE_MATRIX | |
| 153 | header ("coordinate_matrix<row_major>, coordinate_matrix<column_major> safe"); | |
| 154 | bench_my_matrix_prod<ublas::coordinate_matrix<T, ublas::row_major>, | |
| 155 | ublas::coordinate_matrix<T, ublas::column_major>, N> () (runs, safe_tag ()); | |
| 156 | ||
| 157 | header ("coordinate_matrix<row_major>, coordinate_matrix<column_major> fast"); | |
| 158 | bench_my_matrix_prod<ublas::coordinate_matrix<T, ublas::row_major>, | |
| 159 | ublas::coordinate_matrix<T, ublas::column_major>, N> () (runs, fast_tag ()); | |
| 160 | #endif | |
| 161 | ||
| 162 | #ifdef USE_STD_VALARRAY | |
| 163 | header ("std::valarray"); | |
| 164 | bench_cpp_matrix_prod<std::valarray<T>, N> () (runs); | |
| 165 | #endif | |
| 166 | } | |
| 167 | ||
| 168 | #ifdef USE_FLOAT | |
| 169 | template struct bench_3<float, 3>; | |
| 170 | template struct bench_3<float, 10>; | |
| 171 | template struct bench_3<float, 30>; | |
| 172 | template struct bench_3<float, 100>; | |
| 173 | #endif | |
| 174 | ||
| 175 | #ifdef USE_DOUBLE | |
| 176 | template struct bench_3<double, 3>; | |
| 177 | template struct bench_3<double, 10>; | |
| 178 | template struct bench_3<double, 30>; | |
| 179 | template struct bench_3<double, 100>; | |
| 180 | #endif | |
| 181 | ||
| 182 | #ifdef USE_STD_COMPLEX | |
| 183 | #ifdef USE_FLOAT | |
| 184 | template struct bench_3<std::complex<float>, 3>; | |
| 185 | template struct bench_3<std::complex<float>, 10>; | |
| 186 | template struct bench_3<std::complex<float>, 30>; | |
| 187 | template struct bench_3<std::complex<float>, 100>; | |
| 188 | #endif | |
| 189 | ||
| 190 | #ifdef USE_DOUBLE | |
| 191 | template struct bench_3<std::complex<double>, 3>; | |
| 192 | template struct bench_3<std::complex<double>, 10>; | |
| 193 | template struct bench_3<std::complex<double>, 30>; | |
| 194 | template struct bench_3<std::complex<double>, 100>; | |
| 195 | #endif | |
| 196 | #endif |