VectorCompiler Class Reference

Compile a list of FAUST signals into a vector C++ class. More...

#include <compile_vect.hh>

Inherits Compiler.

List of all members.

Public Member Functions

virtual string CS (Tree tEnv, Tree sig, int ctxt)
 Compile a signal.


Detailed Description

Compile a list of FAUST signals into a vector C++ class.

Definition at line 35 of file compile_vect.hh.


Member Function Documentation

string VectorCompiler::CS ( Tree  env,
Tree  sig,
int  context 
) [virtual]

Compile a signal.

Parameters:
env the type environment (enclosing recursions).
sig the signal expression to compile.
context the type of the enclosing expression ( vector, scalar produced as vector or true scalar )
Returns:
the C code translation of sig as a string

Definition at line 216 of file compile_vect.cpp.

References shcount().

00217 {
00218   // Changement �faire:
00219   // quel que soit le contexte dans lequel on cherche �compiler, il faut v�ifier si le signal a d����  // compil�dans n'importe quel contexte, dans ce cas il doit avoir une variable de cache,
00220   // sinon on compile
00221 
00222 
00223   Tree prop;
00224 
00225   Type t = getSigType(sig);//,env);
00226   int type = t->vectorability();
00227   int varia = t->variability();
00228 
00229 
00230   // node already compiled for the current context
00231   if((context==kVect)&&(getProperty(sig,fCompileVecKey,prop))) return tree2str(prop); // vector code
00232   else if((context==kScal)&&(getProperty(sig,fCompileScalarVecKey[loop_unroll],prop))) return tree2str(prop); // scalar code emulated with vectors
00233   else if((context==kTrueScal)&&(getProperty(sig,fCompileScalKey[loop_unroll],prop))) return tree2str(prop); // true scalar code
00234   // node already compiled in an another context
00235   else if((varia==kSamp)&&(context==kScal)&&(getProperty(sig,fCompileVecKey,prop))) { // node already compiled as a vector and used as a scalar
00236 
00237     string temp;
00238     if(shcount(fSharingKeyScal,sig)>1) {
00239 
00240       temp = generateCacheCode(env,sig,subst("VEC2SCALVEC0($0)",tree2str(prop)),kScal);
00241       setProperty(sig,fCompileScalarVecKey[0],tree(temp));
00242       setProperty(sig,fCompileScalarVecKey[1],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC1($0)",tree2str(prop)),kScal)));
00243       setProperty(sig,fCompileScalarVecKey[2],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC2($0)",tree2str(prop)),kScal)));
00244       setProperty(sig,fCompileScalarVecKey[3],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC3($0)",tree2str(prop)),kScal)));
00245 
00246     } else {
00247 
00248       temp = subst("VEC2SCALVEC0($0)",tree2str(prop));
00249       setProperty(sig,fCompileScalarVecKey[0],tree(temp));
00250       setProperty(sig,fCompileScalarVecKey[1],tree(subst("VEC2SCALVEC1($0)",tree2str(prop))));
00251       setProperty(sig,fCompileScalarVecKey[2],tree(subst("VEC2SCALVEC2($0)",tree2str(prop))));
00252       setProperty(sig,fCompileScalarVecKey[3],tree(subst("VEC2SCALVEC3($0)",tree2str(prop))));
00253 
00254     }
00255 
00256     return temp;
00257 
00258   } else if((varia==kSamp)&&(context==kTrueScal)&&(getProperty(sig,fCompileVecKey,prop))) { // node already compiled as a vector and used as a true scalar
00259 
00260     string vname = getFreshID("vec_tempScal");
00261 //    if (t->nature() == kInt) fClass->addExecCode(subst("__vec_int $0; $0.v = $1;", vname, tree2str(prop)));
00262 //    else fClass->addExecCode(subst("__vec_float $0; $0.v = $1;", vname, tree2str(prop)));
00263     if (t->nature() == kInt) fClass->addExecCode(subst("vec_int $0($1);", vname, tree2str(prop)));
00264     else fClass->addExecCode(subst("vec_float $0($1);", vname, tree2str(prop)));
00265 
00266     string temp;
00267     if(shcount(fSharingKeyTrueScal,sig)>1) {
00268 
00269       temp = generateCacheCode(env,sig,subst("$0[0]",vname),kTrueScal);
00270       setProperty(sig,fCompileScalKey[0],tree(temp));
00271       setProperty(sig,fCompileScalKey[1],tree(generateCacheCode(env,sig,subst("$0[1]",vname),kTrueScal)));
00272       setProperty(sig,fCompileScalKey[2],tree(generateCacheCode(env,sig,subst("$0[2]",vname),kTrueScal)));
00273       setProperty(sig,fCompileScalKey[3],tree(generateCacheCode(env,sig,subst("$0[3]",vname),kTrueScal)));
00274 
00275     } else {
00276 
00277       temp = subst("$0[0]",vname);
00278       setProperty(sig,fCompileScalKey[0],tree(temp));
00279       setProperty(sig,fCompileScalKey[1],tree(subst("$0[1]",vname)));
00280       setProperty(sig,fCompileScalKey[2],tree(subst("$0[2]",vname)));
00281       setProperty(sig,fCompileScalKey[3],tree(subst("$0[3]",vname)));
00282 
00283     }
00284 
00285     return temp;
00286 
00287 
00288   // node not yet compiled
00289   } else {
00290 
00291     string code;
00292     int i;
00293     Tree id,z,x,y,ff,largs,label,le;
00294 
00295 
00296 
00297 
00298     if(context==kVect) {
00299 
00300 
00301       if(varia==kSamp) {
00302 
00303     code = generateVec(env,sig); // whatever the type
00304 
00305 
00306     if(shcount(fSharingKeyVec,sig)>1) code = generateCacheCode(env,sig,code,kVect);
00307     else if((shcount(fSharingKeyScal,sig)>=1)&&(!getProperty(sig,fCompileScalarVecKey[loop_unroll],prop))) code = generateCacheCode(env,sig,code,kVect);
00308     //else if((shcount(fSharingKeyTrueScal,sig)>=1)&&(!getProperty(sig,fCompileScalKey[loop_unroll],prop))) code = generateCacheCode(env,sig,code,kVect);
00309 
00310 
00311       } else {
00312 
00313     code = generateCacheCode(env,sig,CS(env,sig,kTrueScal),kVect);
00314     setProperty(sig,fCompileVecKey,tree(code));
00315     setProperty(sig,fCompileScalarVecKey[0],tree(code));
00316     setProperty(sig,fCompileScalarVecKey[1],tree(code));
00317     setProperty(sig,fCompileScalarVecKey[2],tree(code));
00318     setProperty(sig,fCompileScalarVecKey[3],tree(code));
00319 
00320       }
00321 
00322       setProperty(sig,fCompileVecKey,tree(code));
00323 
00324 
00325 
00326 
00327 
00328     } else if(context==kScal) {
00329 
00330 
00331       if(varia==kSamp) {
00332 
00333     if(type==kVect) {
00334 
00335       if(isSigInput(sig,&i)&&(shcount(fSharingKeyVec,sig)==1)&&(shcount(fSharingKeyScal,sig)==1)) {
00336 
00337         code = generateScalarVec(env,sig);
00338 
00339         if(shcount(fSharingKeyScal,sig)>1) code = generateCacheCode(env,sig,code,kScal);
00340         setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00341 
00342       } else if(isProj(sig,&i,x)&&isRec(x,label,le)) {
00343 
00344         if(heuristiqueRec(env,sig,&code)) {
00345 
00346           string temp = generateCacheCode(env,sig,subst("VEC2SCALVEC0($0)",code),kScal);
00347           setProperty(sig,fCompileScalarVecKey[0],tree(temp));
00348           setProperty(sig,fCompileScalarVecKey[1],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC1($0)",code),kScal)));
00349           setProperty(sig,fCompileScalarVecKey[2],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC2($0)",code),kScal)));
00350           setProperty(sig,fCompileScalarVecKey[3],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC3($0)",code),kScal)));
00351           setProperty(sig,fCompileVecKey,tree(subst("$0",code)));
00352 
00353           code = temp;
00354 
00355         } else {
00356 
00357           code = generateScalarVec(env,sig);
00358           setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00359         }
00360 
00361 
00362       } else {
00363 
00364         //code = subst("VEC2SCALVEC$0($1)",T(loop_unroll),CS(env,sig,kVect));
00365         //setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00366 
00367         string tempVec = CS(env,sig,kVect);
00368         string temp = generateCacheCode(env,sig,subst("VEC2SCALVEC0($0)",tempVec),kScal);
00369         setProperty(sig,fCompileScalarVecKey[0],tree(temp));
00370         setProperty(sig,fCompileScalarVecKey[1],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC1($0)",tempVec),kScal)));
00371         setProperty(sig,fCompileScalarVecKey[2],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC2($0)",tempVec),kScal)));
00372         setProperty(sig,fCompileScalarVecKey[3],tree(generateCacheCode(env,sig,subst("VEC2SCALVEC3($0)",tempVec),kScal)));
00373 
00374         code = temp;
00375       }
00376 
00377     // type = kScal
00378     } else {
00379       code = generateScalarVec(env,sig);
00380 
00381       if(shcount(fSharingKeyScal,sig)>1) code = generateCacheCode(env,sig,code,kScal);
00382       setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00383 
00384     }
00385 
00386 
00387     //if(shcount(fSharingKeyScal,sig)>1) code = generateCacheCode(env,sig,code,kScal);
00388     //setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00389 
00390       } else {
00391 
00392     code = generateCacheCode(env,sig,CS(env,sig,kTrueScal),kVect); // kVect parce que vecteur constant
00393     setProperty(sig,fCompileVecKey,tree(code));
00394     setProperty(sig,fCompileScalarVecKey[0],tree(code));
00395     setProperty(sig,fCompileScalarVecKey[1],tree(code));
00396     setProperty(sig,fCompileScalarVecKey[2],tree(code));
00397     setProperty(sig,fCompileScalarVecKey[3],tree(code));
00398       }
00399 
00400 
00401       //setProperty(sig,fCompileScalarVecKey[loop_unroll],tree(code));
00402 
00403 
00404 
00405 
00406 
00407     } else if(context==kTrueScal) {
00408 
00409 
00410       if(varia==kSamp) {
00411 
00412     if(type==kVect) {
00413 
00414       if(isSigInput(sig,&i)||isSigGen(sig,x)||isSigTable(sig,id,x,y)||isSigWRTbl(sig,id,x,y,z)||isSigRDTbl(sig,x,y)||isSigFFun(sig,ff,largs)) { // don't need VEC2SCAL
00415 
00416         code = generateScal(env,sig);
00417 
00418       } else if(isProj(sig,&i,x)&&isRec(x,label,le)) {
00419 
00420         code = CS(env,sig,kVect);
00421 
00422         string vname = getFreshID("vec_tempScal");
00423 //      if (t->nature() == kInt) fClass->addExecCode(subst("__vec_int $0; $0.v = $1;", vname, code));
00424 //      else fClass->addExecCode(subst("__vec_float $0; $0.v = $1;", vname, code));
00425         if (t->nature() == kInt) fClass->addExecCode(subst("vec_int $0($1);", vname, code));
00426         else fClass->addExecCode(subst("vec_float $0($1);", vname, code));
00427 
00428         setProperty(sig,fCompileScalKey[0],tree(subst("$0[0]",vname)));
00429         setProperty(sig,fCompileScalKey[1],tree(subst("$0[1]",vname)));
00430         setProperty(sig,fCompileScalKey[2],tree(subst("$0[2]",vname)));
00431         setProperty(sig,fCompileScalKey[3],tree(subst("$0[3]",vname)));
00432 
00433         code = subst("$0[0]",vname);
00434 
00435       } else {
00436 
00437         string temp = CS(env,sig,kVect);
00438 
00439         string vname = getFreshID("vec_tempScal");
00440 //      if (t->nature() == kInt) fClass->addExecCode(subst("__vec_int $0; $0.v = $1;", vname, temp));
00441 //      else fClass->addExecCode(subst("__vec_float $0; $0.v = $1;", vname, temp));
00442         if (t->nature() == kInt) fClass->addExecCode(subst("vec_int $0($1);", vname, temp));
00443         else fClass->addExecCode(subst("vec_float $0($1);", vname, temp));
00444 
00445         setProperty(sig,fCompileScalKey[0],tree(subst("$0[0]",vname)));
00446         setProperty(sig,fCompileScalKey[1],tree(subst("$0[1]",vname)));
00447         setProperty(sig,fCompileScalKey[2],tree(subst("$0[2]",vname)));
00448         setProperty(sig,fCompileScalKey[3],tree(subst("$0[3]",vname)));
00449 
00450         code = subst("$0[0]",vname);
00451 
00452       }
00453 
00454 
00455     } else { // type = kScal
00456 
00457       if(isSigInput(sig,&i)||isSigGen(sig,x)||isSigTable(sig,id,x,y)||isSigWRTbl(sig,id,x,y,z)||isSigRDTbl(sig,x,y)||isSigFFun(sig,ff,largs)) { // don't need VEC2SCAL
00458 
00459         code = generateScal(env,sig);
00460 
00461       } else {
00462 
00463         code = subst("VEC2SCAL0($0)",CS(env,sig,kScal));
00464 
00465       }
00466     }
00467 
00468     if(shcount(fSharingKeyTrueScal,sig)>1) code = generateCacheCode(env,sig,code,kTrueScal);
00469 
00470 
00471     if((!isSigGen(sig,x))&&(!isSigTable(sig,id,x,y))) setProperty(sig,fCompileScalKey[loop_unroll],tree(code));
00472     else {
00473       setProperty(sig,fCompileScalKey[0],tree(code));
00474       setProperty(sig,fCompileScalKey[1],tree(code));
00475       setProperty(sig,fCompileScalKey[2],tree(code));
00476       setProperty(sig,fCompileScalKey[3],tree(code));
00477     }
00478 
00479 
00480       } else {
00481 
00482     code = generateScal(env,sig);
00483 
00484     if(shcount(fSharingKeyTrueScal,sig)>1) code = generateCacheCode(env,sig,code,kTrueScal);
00485 
00486     setProperty(sig,fCompileScalKey[0],tree(code));
00487     setProperty(sig,fCompileScalKey[1],tree(code));
00488     setProperty(sig,fCompileScalKey[2],tree(code));
00489     setProperty(sig,fCompileScalKey[3],tree(code));
00490 
00491       }
00492     }
00493 
00494 
00495     return code;
00496   }
00497 
00498 }


The documentation for this class was generated from the following files:

Generated on Sat Jul 25 13:29:16 2009 for FAUST compiler by  doxygen 1.5.9