projects / Faustine.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Update readme, install and license files.
[Faustine.git] / interpretor / preprocessor / faust-0.9.47mr3 / compiler / generator / compile_vect.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #include "compile_vect.hh"
25 #include "floats.hh"
26 #include "ppsig.hh"
27
28 extern int gVecSize;
29
30 void VectorCompiler::compileMultiSignal (Tree L)
31 {
32 //contextor recursivness(0);
33 L = prepare(L); // optimize, share and annotate expression
34
35 for (int i = 0; i < fClass->inputs(); i++) {
36 fClass->addZone3(subst("$1* input$0 = &input[$0][index];", T(i), xfloat()));
37 }
38 for (int i = 0; i < fClass->outputs(); i++) {
39 fClass->addZone3(subst("$1* output$0 = &output[$0][index];", T(i), xfloat()));
40 }
41
42 fClass->addSharedDecl("fullcount");
43 fClass->addSharedDecl("input");
44 fClass->addSharedDecl("output");
45
46 for (int i = 0; isList(L); L = tl(L), i++) {
47 Tree sig = hd(L);
48 fClass->openLoop("count");
49 fClass->addExecCode(subst("output$0[i] = $2$1;", T(i), CS(sig), xcast()));
50 fClass->closeLoop(sig);
51 }
52
53 generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
54 generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
55 if (fDescription) {
56 fDescription->ui(prepareUserInterfaceTree(fUIRoot));
57 }
58 }
59
60
61 /**
62 * Compile a signal
63 * @param sig the signal expression to compile.
64 * @return the C code translation of sig as a string
65 */
66 string VectorCompiler::CS (Tree sig)
67 {
68 string code;
69 //cerr << "ENTER VectorCompiler::CS : "<< ppsig(sig) << endl;
70 if (!getCompiledExpression(sig, code)) {
71 code = generateCode(sig);
72 //cerr << "CS : " << code << " for " << ppsig(sig) << endl;
73 setCompiledExpression(sig, code);
74 } else {
75 // we require an already compiled expression
76 // therefore we must update the dependencies of
77 // the current loop
78 int i;
79 Tree x, d, r;
80 Loop* ls;
81 Loop* tl = fClass->topLoop();
82
83 if (fClass->getLoopProperty(sig,ls)) {
84 // sig has a loop property
85 //cerr << "CASE SH : fBackwardLoopDependencies.insert : " << tl << " --depend(A)son--> " << ls << endl;
86 tl->fBackwardLoopDependencies.insert(ls);
87
88 } else if (isSigFixDelay(sig, x, d) && fClass->getLoopProperty(x,ls)) {
89 //cerr << "CASE DL : fBackwardLoopDependencies.insert : " << tl << " --depend(B)son--> " << ls << endl;
90 tl->fBackwardLoopDependencies.insert(ls);
91
92 } else if (isSigFixDelay(sig, x, d) && isProj(x, &i, r) && fClass->getLoopProperty(r,ls)) {
93 //cerr << "CASE DR : fBackwardLoopDependencies.insert : " << tl << " --depend(B)son--> " << ls << endl;
94 tl->fBackwardLoopDependencies.insert(ls);
95
96 } else if (isProj(sig, &i, r) && fClass->getLoopProperty(r,ls)) {
97 //cerr << "CASE R* : fBackwardLoopDependencies.insert : " << tl << " --depend(B)son--> " << ls << endl;
98 tl->fBackwardLoopDependencies.insert(ls);
99
100 } else {
101 if (isProj(sig, &i, r)) {
102 //cerr << "SYMBOL RECURSIF EN COURS ??? " << *r << endl;
103 } else if (getCertifiedSigType(sig)->variability()<kSamp) {
104 //cerr << "SLOW EXPRESSION " << endl;
105 } else {
106 //cerr << "Expression absorbée" << *sig << endl;
107 }
108
109 }
110 }
111 //cerr << "EXIT VectorCompiler::CS : "<< ppsig(sig) << "---code---> " << code << endl;
112 return code;
113 }
114
115 string VectorCompiler::generateCode (Tree sig)
116 {
117 generateCodeRecursions(sig);
118 return generateCodeNonRec(sig);
119 }
120
121 void VectorCompiler::generateCodeRecursions (Tree sig)
122 {
123 Tree id, body;
124 string code;
125 //cerr << "VectorCompiler::generateCodeRecursions( " << ppsig(sig) << " )" << endl;
126 if (getCompiledExpression(sig, code)) {
127 //cerr << "** ALREADY VISITED : " << code << " ===> " << ppsig(sig) << endl;
128 return;
129 } else if( isRec(sig, id, body) ) {
130 //cerr << "we have a recursive expression non compiled yet : " << ppsig(sig) << endl;
131 setCompiledExpression(sig, "[RecursionVisited]");
132 fClass->openLoop(sig, "count");
133 generateRec(sig, id, body);
134 fClass->closeLoop(sig);
135 } else {
136 // we go down the expression
137 vector<Tree> subsigs;
138 int n = getSubSignals(sig, subsigs, false);
139 for (int i=0; i<n; i++) { generateCodeRecursions(subsigs[i]); }
140 }
141 }
142
143 string VectorCompiler::generateCodeNonRec (Tree sig)
144 {
145 string code;
146 if (getCompiledExpression(sig, code)) {
147 // already visited
148 return code;
149 } else {
150 //cerr << "VectorCompiler::generateCodeNonRec( " << ppsig(sig) << " )" << endl;
151 code = generateLoopCode(sig);
152 setCompiledExpression(sig, code);
153 return code;
154 }
155 }
156
157 /**
158 * Compile a signal
159 * @param sig the signal expression to compile.
160 * @return the C code translation of sig as a string
161 */
162 string VectorCompiler::generateLoopCode (Tree sig)
163 {
164 int i;
165 Tree x;
166 Loop* l;
167
168 l = fClass->topLoop();
169 assert(l);
170 //cerr << "VectorCompiler::OLDgenerateCode " << ppsig(sig) << endl;
171 if (needSeparateLoop(sig)) {
172 // we need a separate loop unless it's an old recursion
173 if (isProj(sig, &i, x)) {
174 // projection of a recursive group x
175 if (l->hasRecDependencyIn(singleton(x))) {
176 // x is already in the loop stack
177 return ScalarCompiler::generateCode(sig);
178 } else {
179 // x must be defined
180 fClass->openLoop(x, "count");
181 string c = ScalarCompiler::generateCode(sig);
182 fClass->closeLoop(sig);
183 return c;
184 }
185 } else {
186 fClass->openLoop("count");
187 string c = ScalarCompiler::generateCode(sig);
188 fClass->closeLoop(sig);
189 return c;
190 }
191 } else {
192 return ScalarCompiler::generateCode(sig);
193 }
194 }
195
196
197 /**
198 * Generate cache code for a signal if needed
199 * @param sig the signal expression.
200 * @param exp the corresponding C code.
201 * @return the cached C code
202 */
203 string VectorCompiler::generateCacheCode(Tree sig, const string& exp)
204 {
205 string vname, ctype;
206 int sharing = getSharingCount(sig);
207 Type t = getCertifiedSigType(sig);
208 Occurences* o = fOccMarkup.retrieve(sig);
209 int d = o->getMaxDelay();
210
211 if (t->variability() < kSamp) {
212 if (d==0) {
213 // non-sample, not delayed : same as scalar cache
214 return ScalarCompiler::generateCacheCode(sig,exp);
215
216 } else {
217 // it is a non-sample expressions but used delayed
218 // we need a delay line
219 getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
220 if ((sharing > 1) && !verySimple(sig)) {
221 // first cache this expression because it
222 // it is shared and complex
223 string cachedexp = generateVariableStore(sig, exp);
224 generateDelayLine(ctype, vname, d, cachedexp);
225 setVectorNameProperty(sig, vname);
226 return cachedexp;
227 } else {
228 // no need to cache this expression because
229 // it is either not shared or very simple
230 generateDelayLine(ctype, vname, d, exp);
231 setVectorNameProperty(sig, vname);
232 return exp;
233 }
234 }
235 } else {
236 // sample-rate signal
237 if (d > 0) {
238 // used delayed : we need a delay line
239 getTypedNames(getCertifiedSigType(sig), "Yec", ctype, vname);
240 generateDelayLine(ctype, vname, d, exp);
241 setVectorNameProperty(sig, vname);
242
243 if (verySimple(sig)) {
244 return exp;
245 } else {
246 if (d < gMaxCopyDelay) {
247 return subst("$0[i]", vname);
248 } else {
249 // we use a ring buffer
250 string mask = T(pow2limit(d + gVecSize)-1);
251 return subst("$0[($0_idx+i) & $1]", vname, mask);
252 }
253 }
254 } else {
255 // not delayed
256 if ( sharing > 1 && ! verySimple(sig) ) {
257 // shared and not simple : we need a vector
258 // cerr << "ZEC : " << ppsig(sig) << endl;
259 getTypedNames(getCertifiedSigType(sig), "Zec", ctype, vname);
260 generateDelayLine(ctype, vname, d, exp);
261 setVectorNameProperty(sig, vname);
262 return subst("$0[i]", vname);
263 } else {
264 // not shared or simple : no cache needed
265 return exp;
266 }
267 }
268 }
269 }
270
271 /**
272 * Test if a signal need to be compiled in a separate loop.
273 * @param sig the signal expression to test.
274 * @return true if a separate loop is needed
275 */
276 bool VectorCompiler::needSeparateLoop(Tree sig)
277 {
278 Occurences* o = fOccMarkup.retrieve(sig);
279 Type t = getCertifiedSigType(sig);
280 int c = getSharingCount(sig);
281 bool b;
282
283 int i;
284 Tree x,y;
285
286
287 if (o->getMaxDelay()>0) {
288 //cerr << "DLY "; // delayed expressions require a separate loop
289 b = true;
290 } else if (verySimple(sig) || t->variability()<kSamp) {
291 b = false; // non sample computation never require a loop
292 } else if (isSigFixDelay(sig, x, y)) {
293 b = false; //
294 } else if (isProj(sig, &i ,x)) {
295 //cerr << "REC "; // recursive expressions require a separate loop
296 b = true;
297 } else if (c > 1) {
298 //cerr << "SHA(" << c << ") "; // expressions used several times required a separate loop
299 b = true;
300 } else {
301 // sample expressions that are not recursive, not delayed
302 // and not shared, doesn't require a separate loop.
303 b = false;
304 }
305 /* if (b) {
306 cerr << "Separate Loop for " << ppsig(sig) << endl;
307 } else {
308 cerr << "Same Loop for " << ppsig(sig) << endl;
309 }*/
310 return b;
311 }
312
313 void VectorCompiler::generateDelayLine(const string& ctype, const string& vname, int mxd, const string& exp)
314 {
315 if (mxd == 0) {
316 vectorLoop(ctype, vname, exp);
317 } else {
318 dlineLoop(ctype, vname, mxd, exp);
319 }
320 }
321
322 string VectorCompiler::generateVariableStore(Tree sig, const string& exp)
323 {
324 Type t = getCertifiedSigType(sig);
325
326 if (getCertifiedSigType(sig)->variability() == kSamp) {
327 string vname, ctype;
328 getTypedNames(t, "Vector", ctype, vname);
329 vectorLoop(ctype, vname, exp);
330 return subst("$0[i]", vname);
331 } else {
332 return ScalarCompiler::generateVariableStore(sig, exp);
333 }
334 }
335
336
337 /**
338 * Generate code for accessing a delayed signal. The generated code depend of
339 * the maximum delay attached to exp and the gLessTempSwitch.
340 */
341
342 string VectorCompiler::generateFixDelay (Tree sig, Tree exp, Tree delay)
343 {
344 int mxd, d;
345 string vecname;
346
347 //cerr << "VectorCompiler::generateFixDelay " << ppsig(sig) << endl;
348
349 CS(exp); // ensure exp is compiled to have a vector name
350
351 mxd = fOccMarkup.retrieve(exp)->getMaxDelay();
352
353 if (! getVectorNameProperty(exp, vecname)) {
354 cerr << "ERROR no vector name for " << ppsig(exp) << endl;
355 exit(1);
356 }
357
358 if (mxd == 0) {
359 // not a real vector name but a scalar name
360 return subst("$0[i]", vecname);
361
362 } else if (mxd < gMaxCopyDelay){
363 if (isSigInt(delay, &d)) {
364 if (d == 0) {
365 return subst("$0[i]", vecname);
366 } else {
367 return subst("$0[i-$1]", vecname, T(d));
368 }
369 } else {
370 return subst("$0[i-$1]", vecname, CS(delay));
371 }
372
373 } else {
374
375 // long delay : we use a ring buffer of size 2^x
376 int N = pow2limit( mxd+gVecSize );
377
378 if (isSigInt(delay, &d)) {
379 if (d == 0) {
380 return subst("$0[($0_idx+i)&$1]", vecname, T(N-1));
381 } else {
382 return subst("$0[($0_idx+i-$2)&$1]", vecname, T(N-1), T(d));
383 }
384 } else {
385 return subst("$0[($0_idx+i-$2)&$1]", vecname, T(N-1), CS(delay));
386 }
387 }
388 }
389
390
391 /**
392 * Generate code for the delay mecchanism. The generated code depend of the
393 * maximum delay attached to exp and the "less temporaries" switch
394 */
395
396 string VectorCompiler::generateDelayVec(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
397 {
398 // it is a non-sample but used delayed
399 // we need a delay line
400 generateDelayLine(ctype, vname, mxd, exp);
401 setVectorNameProperty(sig, vname);
402 if (verySimple(sig)) {
403 return exp;
404 } else {
405 return subst("$0[i]", vname);
406 }
407 }
408
409 #if 0
410 static int pow2limit(int x)
411 {
412 int n = 2;
413 while (n < x) { n = 2*n; }
414 return n;
415 }
416 #endif
417
418 /**
419 * Generate the code for a (short) delay line
420 * @param k the c++ class where the delay line will be placed.
421 * @param l the loop where the code will be placed.
422 * @param tname the name of the C++ type (float or int)
423 * @param dlname the name of the delay line (vector) to be used.
424 * @param delay the maximum delay
425 * @param cexp the content of the signal as a C++ expression
426 */
427 void VectorCompiler::vectorLoop (const string& tname, const string& vecname, const string& cexp)
428 {
429 // -- declare the vector
430 fClass->addSharedDecl(vecname);
431
432 // -- variables moved as class fields...
433 fClass->addZone1(subst("$0 \t$1[$2];", tname, vecname, T(gVecSize)));
434
435 // -- compute the new samples
436 fClass->addExecCode(subst("$0[i] = $1;", vecname, cexp));
437 }
438
439
440 /**
441 * Generate the code for a (short) delay line
442 * @param k the c++ class where the delay line will be placed.
443 * @param l the loop where the code will be placed.
444 * @param tname the name of the C++ type (float or int)
445 * @param dlname the name of the delay line (vector) to be used.
446 * @param delay the maximum delay
447 * @param cexp the content of the signal as a C++ expression
448 */
449 void VectorCompiler::dlineLoop (const string& tname, const string& dlname, int delay, const string& cexp)
450 {
451 if (delay < gMaxCopyDelay) {
452
453 // Implementation of a copy based delayline
454
455 // create names for temporary and permanent storage
456 string buf = subst("$0_tmp", dlname);
457 string pmem= subst("$0_perm", dlname);
458
459 // constraints delay size to be multiple of 4
460 delay = (delay+3)&-4;
461
462 // allocate permanent storage for delayed samples
463 string dsize = T(delay);
464 fClass->addDeclCode(subst("$0 \t$1[$2];", tname, pmem, dsize));
465
466 // init permanent memory
467 fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i]=0;", pmem, dsize));
468
469 // compute method
470
471 // -- declare a buffer and a "shifted" vector
472 fClass->addSharedDecl(buf);
473
474 // -- variables moved as class fields...
475 fClass->addZone1(subst("$0 \t$1[$2+$3];", tname, buf, T(gVecSize), dsize));
476
477 fClass->addFirstPrivateDecl(dlname);
478 fClass->addZone2(subst("$0* \t$1 = &$2[$3];", tname, dlname, buf, dsize));
479
480 // -- copy the stored samples to the delay line
481 fClass->addPreCode(subst("for (int i=0; i<$2; i++) $0[i]=$1[i];", buf, pmem, dsize));
482
483 // -- compute the new samples
484 fClass->addExecCode(subst("$0[i] = $1;", dlname, cexp));
485
486 // -- copy back to stored samples
487 fClass->addPostCode(subst("for (int i=0; i<$2; i++) $0[i]=$1[count+i];", pmem, buf, dsize));
488
489 } else {
490
491 // Implementation of a ring-buffer delayline
492
493 // the size should be large enough and aligned on a power of two
494 delay = pow2limit(delay + gVecSize);
495 string dsize = T(delay);
496 string mask = T(delay-1);
497
498 // create names for temporary and permanent storage
499 string idx = subst("$0_idx", dlname);
500 string idx_save = subst("$0_idx_save", dlname);
501
502 // allocate permanent storage for delayed samples
503 fClass->addDeclCode(subst("$0 \t$1[$2];", tname, dlname, dsize));
504 fClass->addDeclCode(subst("int \t$0;", idx));
505 fClass->addDeclCode(subst("int \t$0;", idx_save));
506
507 // init permanent memory
508 fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i]=0;", dlname, dsize));
509 fClass->addInitCode(subst("$0 = 0;", idx));
510 fClass->addInitCode(subst("$0 = 0;", idx_save));
511
512 // -- update index
513 fClass->addPreCode(subst("$0 = ($0+$1)&$2;", idx, idx_save, mask));
514
515 // -- compute the new samples
516 fClass->addExecCode(subst("$0[($2+i)&$3] = $1;", dlname, cexp, idx, mask));
517
518 // -- save index
519 fClass->addPostCode(subst("$0 = count;", idx_save));
520 }
521 }
522
An OCaml-based interpreter for Faust and its vector extension