projects / Faustine.git / blob
? search:


85a42fb1c51482f53695bfae26b41c8a9e8b3443
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / bench.cpp
1 /************************************************************************
2
3 IMPORTANT NOTE : this file contains two clearly delimited sections :
4 the ARCHITECTURE section (in two parts) and the USER section. Each section
5 is governed by its own copyright and license. Please check individually
6 each section for license and copyright information.
7 *************************************************************************/
8
9 /*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
10
11 /************************************************************************
12 FAUST Architecture File
13 Copyright (C) 2003-2011 GRAME, Centre National de Creation Musicale
14 ---------------------------------------------------------------------
15 This Architecture section is free software; you can redistribute it
16 and/or modify it under the terms of the GNU General Public License
17 as published by the Free Software Foundation; either version 3 of
18 the License, or (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; If not, see <http://www.gnu.org/licenses/>.
27
28 EXCEPTION : As a special exception, you may create a larger work
29 that contains this FAUST architecture section and distribute
30 that work under terms of your choice, so long as this FAUST
31 architecture section is not modified.
32
33
34 ************************************************************************
35 ************************************************************************/
36
37
38 /* link with */
39 /* link with : "" */
40 #include <stdlib.h>
41 #include <stdlib.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <limits.h>
45 #include <math.h>
46 #include <errno.h>
47 #include <time.h>
48 #include <sys/ioctl.h>
49 #include <unistd.h>
50 #include <fcntl.h>
51 #include <pwd.h>
52 #include <sys/types.h>
53 #include <assert.h>
54 #include <pthread.h>
55 #include <sys/wait.h>
56 #include <list>
57
58 #include <iostream>
59
60
61 using namespace std;
62
63 #include <map>
64
65 using namespace std;
66
67 // On Intel set FZ (Flush to Zero) and DAZ (Denormals Are Zero)
68 // flags to avoid costly denormals
69 #ifdef __SSE__
70 #include <xmmintrin.h>
71 #ifdef __SSE2__
72 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8040)
73 #else
74 #define AVOIDDENORMALS _mm_setcsr(_mm_getcsr() | 0x8000)
75 #endif
76 #else
77 #define AVOIDDENORMALS
78 #endif
79
80 struct Meta : map<const char*, const char*>
81 {
82 void declare (const char* key, const char* value) { (*this)[key]=value; }
83 };
84
85
86
87 float* gBuffer = 0; // a buffer of NV*VSize samples
88
89 unsigned int COUNT = 2000; // number of measures
90 unsigned int NV = 4096; // number of vectors in BIG buffer (should exceed cache)
91 unsigned int ITER = 10; // number of iterations per measure
92 unsigned int VSIZE = 4096; // size of a vector in samples
93 unsigned int IDX = 0; // current vector number (0 <= VIdx < NV)
94
95
96 //inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((unsigned)(calloc((nmemb*size)+15,sizeof(char)))+15 & 0xfffffff0); }
97 //inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((size_t)(calloc((nmemb*size)+15,sizeof(char)))+15 & ~15); }
98
99
100
101 // g++ -Wall -O3 -lm -lpthread -lasound `gtk-config --cflags --libs` test.cpp -o test
102
103
104 //-------------------------------------------------------------------
105 // Generic min and max using c++ inline
106 //-------------------------------------------------------------------
107
108 inline int max (unsigned int a, unsigned int b) { return (a>b) ? a : b; }
109 inline int max (int a, int b) { return (a>b) ? a : b; }
110
111 inline long max (long a, long b) { return (a>b) ? a : b; }
112 inline long max (int a, long b) { return (a>b) ? a : b; }
113 inline long max (long a, int b) { return (a>b) ? a : b; }
114
115 inline float max (float a, float b) { return (a>b) ? a : b; }
116 inline float max (int a, float b) { return (a>b) ? a : b; }
117 inline float max (float a, int b) { return (a>b) ? a : b; }
118 inline float max (long a, float b) { return (a>b) ? a : b; }
119 inline float max (float a, long b) { return (a>b) ? a : b; }
120
121 inline double max (double a, double b) { return (a>b) ? a : b; }
122 inline double max (int a, double b) { return (a>b) ? a : b; }
123 inline double max (double a, int b) { return (a>b) ? a : b; }
124 inline double max (long a, double b) { return (a>b) ? a : b; }
125 inline double max (double a, long b) { return (a>b) ? a : b; }
126 inline double max (float a, double b) { return (a>b) ? a : b; }
127 inline double max (double a, float b) { return (a>b) ? a : b; }
128
129
130 inline int min (int a, int b) { return (a<b) ? a : b; }
131
132 inline long min (long a, long b) { return (a<b) ? a : b; }
133 inline long min (int a, long b) { return (a<b) ? a : b; }
134 inline long min (long a, int b) { return (a<b) ? a : b; }
135
136 inline float min (float a, float b) { return (a<b) ? a : b; }
137 inline float min (int a, float b) { return (a<b) ? a : b; }
138 inline float min (float a, int b) { return (a<b) ? a : b; }
139 inline float min (long a, float b) { return (a<b) ? a : b; }
140 inline float min (float a, long b) { return (a<b) ? a : b; }
141
142 inline double min (double a, double b) { return (a<b) ? a : b; }
143 inline double min (int a, double b) { return (a<b) ? a : b; }
144 inline double min (double a, int b) { return (a<b) ? a : b; }
145 inline double min (long a, double b) { return (a<b) ? a : b; }
146 inline double min (double a, long b) { return (a<b) ? a : b; }
147 inline double min (float a, double b) { return (a<b) ? a : b; }
148 inline double min (double a, float b) { return (a<b) ? a : b; }
149
150
151 inline int lsr (int x, int n) { return int(((unsigned int)x) >> n); }
152
153
154 bool setRealtimePriority ()
155 {
156 struct passwd * pw;
157 int err;
158 uid_t uid;
159 int policy;
160 struct sched_param param;
161
162 uid = getuid ();
163 pw = getpwnam ("root");
164 setuid (pw->pw_uid);
165
166 pthread_getschedparam(pthread_self(), &policy, &param);
167 policy = SCHED_RR;
168 param.sched_priority = 50;
169 err = pthread_setschedparam(pthread_self(), policy, &param);
170
171 setuid (uid);
172 return (err != -1);
173 }
174
175 #include <sys/time.h>
176
177 double mysecond()
178 {
179 struct timeval tp;
180 struct timezone tzp;
181 int i;
182
183 i = gettimeofday(&tp,&tzp);
184 return ( (double) tp.tv_sec + (double) tp.tv_usec * 1.e-6 );
185 }
186
187 /******************************************************************************
188 *******************************************************************************
189
190 VECTOR INTRINSICS
191
192 *******************************************************************************
193 *******************************************************************************/
194
195
196
197 <<includeIntrinsic>>
198
199
200
201 /******************************************************************************
202 *******************************************************************************
203
204 ABSTRACT USER INTERFACE
205
206 *******************************************************************************
207 *******************************************************************************/
208
209 class UI
210 {
211 bool fStopped;
212 public:
213
214 UI() : fStopped(false) {}
215 virtual ~UI() {}
216
217 virtual void addButton(const char* label, float* zone) = 0;
218 virtual void addToggleButton(const char* label, float* zone) = 0;
219 virtual void addCheckButton(const char* label, float* zone) = 0;
220 virtual void addVerticalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
221 virtual void addHorizontalSlider(const char* label, float* zone, float init, float min, float max, float step) = 0;
222 virtual void addNumEntry(const char* label, float* zone, float init, float min, float max, float step) = 0;
223
224 // -- passive widgets
225
226 virtual void addNumDisplay(const char* label, float* zone, int precision) = 0;
227 virtual void addTextDisplay(const char* label, float* zone, char* names[], float min, float max) = 0;
228 virtual void addHorizontalBargraph(const char* label, float* zone, float min, float max) = 0;
229 virtual void addVerticalBargraph(const char* label, float* zone, float min, float max) = 0;
230
231 virtual void openFrameBox(const char* label) = 0;
232 virtual void openTabBox(const char* label) = 0;
233 virtual void openHorizontalBox(const char* label) = 0;
234 virtual void openVerticalBox(const char* label) = 0;
235
236 virtual void closeBox() = 0;
237
238 virtual void run() = 0;
239
240 void stop() { fStopped = true; }
241 bool stopped() { return fStopped; }
242
243 virtual void declare(float* zone, const char* key, const char* value) {}
244 };
245
246
247
248
249 /******************************************************************************
250 *******************************************************************************
251
252 DSP
253
254 *******************************************************************************
255 *******************************************************************************/
256
257
258
259 //----------------------------------------------------------------
260 // definition du processeur de signal
261 //----------------------------------------------------------------
262
263 class dsp {
264 protected:
265 int fSamplingFreq;
266 public:
267 dsp() {}
268 virtual ~dsp() {}
269 virtual int getNumInputs() = 0;
270 virtual int getNumOutputs() = 0;
271 virtual void buildUserInterface(UI* interface) = 0;
272 virtual void init(int samplingRate) = 0;
273 virtual void compute(int len, float** inputs, float** outputs) = 0;
274 };
275
276 /********************END ARCHITECTURE SECTION (part 1/2)****************/
277
278 /**************************BEGIN USER SECTION **************************/
279
280 <<includeclass>>
281
282 /***************************END USER SECTION ***************************/
283
284 /*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
285
286 mydsp DSP;
287
288
289 #if 0
290
291 static __inline__ unsigned long long int rdtsc(void)
292 {
293 unsigned long long int x;
294 __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
295 return x;
296 }
297
298 #endif
299
300 /**
301 * Bench by calling COUNT times the compute() method for
302 * the computation of vsize samples
303 */
304
305 #define MEGABYTE 1048576.0
306
307 void statistic(const char* name, double* timing)
308 {
309 double lo, hi, tot;
310 double mega = double(VSIZE*ITER)/MEGABYTE; // mega samples
311 // skip first 10 values to avoid cache bias ???
312 lo = hi = tot = mega/(timing[11] - timing[10]);
313 for (int i = 11; i<COUNT; i++) {
314 double delta = mega/(timing[i] - timing[i-1]);
315 if (delta < lo) {
316 lo = delta;
317 } else if (delta > hi) {
318 hi = delta;
319 }
320 tot += delta;
321 }
322
323 cout << '\t' << hi
324 << '\t' << hi*4*DSP.getNumInputs() << '\t' << "MB/s inputs"
325 << '\t' << hi*4*DSP.getNumOutputs() << '\t' << "MB/s outputs"
326 << '\t' << tot/(COUNT-11)
327 << '\t' << lo
328 << endl;
329 }
330
331 void allocBuffer()
332 {
333 unsigned int BSIZE = NV * VSIZE;
334 gBuffer = (float*) calloc (BSIZE, sizeof(float));
335
336 int R0_0 = 0;
337 for (int j = 0; j < BSIZE; j++) {
338 int R0temp0 = (12345 + (1103515245 * R0_0));
339 gBuffer[j] = 4.656613e-10f*R0temp0;
340 R0_0 = R0temp0;
341 }
342 }
343
344 float* nextVect()
345 {
346 IDX = (1+IDX)%NV;
347 return &gBuffer[IDX*VSIZE];
348 }
349
350 void bench(const char* name)
351 {
352
353 int numInChan = DSP.getNumInputs();
354 int numOutChan = DSP.getNumOutputs();
355
356 assert (numInChan < 256);
357 assert (numOutChan < 256);
358
359 float* inChannel[256];
360 float* outChannel[256];
361
362 // allocate input buffers (initialized with white noise)
363 allocBuffer();
364
365 // allocate output channels (not initialized)
366 for (int i = 0; i < numOutChan; i++) outChannel[i] = (float*) calloc (VSIZE, sizeof(float));
367
368 // init the dsp with a resoneable sampling rate)
369 DSP.init(48000);
370 double* timing = (double*) calloc (COUNT, sizeof(double));
371
372 for (int i = 0; i<COUNT; i++) {
373 timing[i] = mysecond();
374 for (int k = 0; k<ITER; k++) {
375 // allocate new input buffers to avoid L2 cache
376 for (int c=0; c<numInChan; c++) { inChannel[c] = nextVect(); }
377 DSP.compute(VSIZE,inChannel,outChannel);
378 }
379 }
380
381 statistic(name, timing);
382 }
383
384 //-------------------------------------------------------------------------
385 // MAIN
386 //-------------------------------------------------------------------------
387
388 // lopt : Scan Command Line long int Arguments
389
390 long lopt (int argc, char *argv[], const char* longname, const char* shortname, long def)
391 {
392 for (int i=2; i<argc; i++)
393 if ( strcmp(argv[i-1], shortname) == 0 || strcmp(argv[i-1], longname) == 0 )
394 return atoi(argv[i]);
395 return def;
396 }
397
398
399 int main(int argc, char *argv[] )
400 {
401 AVOIDDENORMALS;
402 VSIZE = lopt(argc, argv, "--vector-size", "-vec", 4096);
403 NV = lopt(argc, argv, "--num-vector", "-n", 20000);
404 COUNT = lopt(argc, argv, "--count", "-c", 1000);
405 ITER = lopt(argc, argv, "--iteration", "-i", 10);
406 //setRealtimePriority();
407 bench(argv[0]);
408 return 0;
409 }
410
411
412 /********************END ARCHITECTURE SECTION (part 2/2)****************/
413
414
415
An OCaml-based interpreter for Faust and its vector extension