← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blitz++/utopic-proposed

« back to all changes in this revision

Viewing changes to benchmarks/daxpy.cpp

  • Committer: Package Import Robot
  • Author(s): Christophe Trophime
  • Date: 2012-07-06 09:15:30 UTC
  • mfrom: (11.1.5 sid)
  • Revision ID: package-import@ubuntu.com-20120706091530-vzrb8zf0vpbf8tp9
Tags: 1:0.10-1
http://bugs.debian.org/679407
* New upstream release
  Closes: #679407
* debian/rules:
  - update for new release
  - add override_dh_auto_test target
  - regenerate configure and Makefile.am
* debian/control:
  - add libtool, automake to BuildDepends
* debian/libblitz-doc.install
  - modify path for html files
* remove uneeded patches
* add examples.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
benchmarks/daxpy.cpp
1
 
// In KAI C++ 3.2c, restrict causes problems for copy propagation.
2
 
// Temporary kludge is to disable use of the restrict keyword.
3
 
 
4
 
#define BZ_DISABLE_RESTRICT
5
 
 
6
 
#include <blitz/vector.h>
 
1
#include <blitz/vector2.h>
7
2
#include <blitz/array.h>
8
 
#include <blitz/rand-uniform.h>
 
3
#include <random/uniform.h>
9
4
#include <blitz/benchext.h>
10
5
 
11
6
#ifdef BZ_HAVE_VALARRAY
16
11
#include <valarray>
17
12
#endif
18
13
 
 
14
BZ_NAMESPACE(blitz)
 
15
extern void sink();
 
16
BZ_NAMESPACE_END
 
17
 
19
18
BZ_USING_NAMESPACE(blitz)
20
19
 
21
20
#if defined(BZ_FORTRAN_SYMBOLS_WITH_TRAILING_UNDERSCORES)
80
79
 
81
80
    const int numSizes = 19;
82
81
    bench.setNumParameters(numSizes);
83
 
    bench.setRateDescription("Mflops/s");
84
82
 
85
83
    Vector<int> parameters(numSizes);
86
84
    Vector<long> iters(numSizes);
88
86
 
89
87
    for (int i=0; i < numSizes; ++i)
90
88
    {
91
 
        parameters[i] = static_cast<int>(pow(10.0, 0.25*(i+1)));
92
 
        iters[i] = 50000000L / parameters[i];
93
 
        if (iters[i] < 2)
94
 
            iters[i] = 2;
95
 
        flops[i] = 2 * parameters[i] * 2;
 
89
        parameters(i) = static_cast<int>(pow(10.0, 0.25*(i+1)));
 
90
        iters(i) = 50000000L / parameters(i);
 
91
        if (iters(i) < 2)
 
92
            iters(i) = 2;
 
93
        flops(i) = 2 * parameters(i) * 2;
96
94
    }
97
95
 
98
96
    bench.setParameterVector(parameters);
99
97
    bench.setIterations(iters);
100
 
    bench.setFlopsPerIteration(flops);
 
98
    bench.setOpsPerIteration(flops);
101
99
 
102
100
    bench.beginBenchmarking();
103
101
 
121
119
    return 0;
122
120
}
123
121
 
124
 
void initializeRandomDouble(double* data, int numElements, int stride = 1)
 
122
 
 
123
template<class T>
 
124
void initializeRandomDouble(T* data, int numElements, int stride = 1)
125
125
{
126
 
    static Random<Uniform> rnd;
 
126
    ranlib::Uniform<T> rnd;
127
127
 
128
128
    for (int i=0; i < numElements; ++i)
129
 
        data[i*stride] = rnd.random();
 
129
        data[size_t(i*stride)] = rnd.random();
130
130
}
131
131
 
132
132
template<class T>
133
 
void initializeArray(T& array, int numElements)
 
133
void initializeRandomDouble(valarray<T>& data, int numElements, int stride = 1)
134
134
{
135
 
    static Random<Uniform> rnd;
 
135
    ranlib::Uniform<T> rnd;
136
136
 
137
 
    for (size_t i=0; i < numElements; ++i)
138
 
        array[i] = rnd.random();
 
137
    for (int i=0; i < numElements; ++i)
 
138
        data[size_t(i*stride)] = rnd.random();
139
139
}
140
140
 
141
141
void daxpyVectorVersion(BenchmarkExt<int>& bench, double a, double b)
190
190
        bench.start();
191
191
        for (long i=0; i < iters; ++i)
192
192
        {
193
 
            y += a * x;
194
 
            y += b * x;
 
193
            y = y + a * x;
 
194
            y = y + b * x;
 
195
            sink();
195
196
        }
196
197
        bench.stop();
 
198
 
 
199
        bench.startOverhead();
 
200
        for (long i=0; i < iters; ++i) {
 
201
            sink();
 
202
        }
 
203
        bench.stopOverhead();
197
204
    }
198
205
 
199
206
    bench.endImplementation();
320
327
        long iters = bench.getIterations();
321
328
 
322
329
        valarray<double> x(N), y(N);
323
 
        initializeArray(x, N);
324
 
        initializeArray(y, N);
 
330
        initializeRandomDouble(x, N);
 
331
        initializeRandomDouble(y, N);
325
332
 
326
333
        double b = - a;
327
334