Implement all delays types in C/C++ backends.

Author: sletz

compiler/generator/c/c_code_container.cpp

@@ -807,18 +807,8 @@ void CScalarCodeContainer::generateComputeAux(int n)
     tab(n + 1, *fOut);
     fCodeProducer->Tab(n + 1);
 
-    // Generates local variables declaration and setup
-    generateComputeBlock(fCodeProducer);
-
-    // Generates one single scalar loop
-    ForLoopInst* loop = fCurLoop->generateScalarLoop(fFullCount);
-    loop->accept(fCodeProducer);
-
-    /*
-     // TODO : atomic switch
-     // Currently for soundfile management
-     */
-    generatePostComputeBlock(fCodeProducer);
+    BlockInst* block = generateComputeBlockLoop();
+    block->accept(fCodeProducer);
 
     back(1, *fOut);
     *fOut << "}" << endl;

compiler/generator/code_container.cpp

@@ -71,6 +71,8 @@ CodeContainer::CodeContainer()
       fNumPassives(0),
       fSubContainerType(kInt),
       fGeneratedSR(false),
+      fComputeByBlock(false),
+      fComputeBlockIndex(""),
       fExtGlobalDeclarationInstructions(IB::genBlockInst()),
       fGlobalDeclarationInstructions(IB::genBlockInst()),
       fDeclarationInstructions(IB::genBlockInst()),
@@ -123,6 +125,80 @@ CodeContainer::CodeContainer()
     }
 }
 
+void CodeContainer::setComputeByBlock(bool b)
+{
+    fComputeByBlock = b;
+    if (b && fComputeBlockIndex.empty()) {
+        fComputeBlockIndex = gGlobal->getFreshID("index");
+    }
+}
+
+BlockInst* CodeContainer::generateComputeBlockLoop(bool loop_var_in_bytes)
+{
+    BlockInst* block = IB::genBlockInst();
+
+    if (!fComputeByBlock) {
+        block->merge(fComputeBlockInstructions);
+        block->pushBackInst(fCurLoop->generateScalarLoop(fFullCount, loop_var_in_bytes));
+        block->merge(fPostComputeBlockInstructions);
+        return block;
+    }
+
+    ValueInst* fullcount_value = IB::genLoadFunArgsVar(fFullCount);
+    ValueInst* vec_size        = IB::genInt32NumInst(gGlobal->gVecSize);
+
+    ValueInst* byte_size = nullptr;
+    ValueInst* step      = nullptr;
+
+    // int fullcount = count;
+    DeclareVarInst* fullcount = nullptr;
+    if (loop_var_in_bytes) {
+        int byte_size_int = 1 << (gGlobal->gFloatSize + 1);
+        byte_size         = IB::genInt32NumInst(byte_size_int);
+        fullcount = IB::genDecStackVar("fullcount", IB::genInt32Typed(),
+                                       IB::genMul(byte_size, fullcount_value));
+        step = IB::genInt32NumInst(gGlobal->gVecSize * byte_size_int);
+    } else {
+        fullcount = IB::genDecStackVar("fullcount", IB::genInt32Typed(), fullcount_value);
+        step      = vec_size;
+    }
+    block->pushBackInst(fullcount);
+
+    // for (int index = 0; index < fullcount; index += gVecSize)
+    if (fComputeBlockIndex.empty()) {
+        fComputeBlockIndex = gGlobal->getFreshID("index");
+    }
+    DeclareVarInst* index_decl =
+        IB::genDecLoopVar(fComputeBlockIndex, IB::genInt32Typed(), IB::genInt32NumInst(0));
+
+    BlockInst* loop_code = IB::genBlockInst();
+
+    // int count = min(gVecSize, fullcount - index);
+    ValueInst* remaining = IB::genSub(fullcount->load(), index_decl->load());
+    ValueInst* count_base = remaining;
+    if (loop_var_in_bytes) {
+        count_base = IB::genDiv(remaining, byte_size);
+    }
+    Values     min_fun_args;
+    min_fun_args.push_back(vec_size);
+    min_fun_args.push_back(count_base);
+    ValueInst* count_val = IB::genFunCallInst("min_i", min_fun_args);
+    DeclareVarInst* count_decl = IB::genDecStackVar("count", IB::genInt32Typed(), count_val);
+    loop_code->pushBackInst(count_decl);
+
+    loop_code->merge(fComputeBlockInstructions);
+    loop_code->pushBackInst(
+        fCurLoop->generateScalarLoop(count_decl->load(), loop_var_in_bytes));
+    loop_code->merge(fPostComputeBlockInstructions);
+
+    ValueInst*  loop_end = IB::genLessThan(index_decl->load(), fullcount->load());
+    StoreVarInst* loop_inc = index_decl->store(IB::genAdd(index_decl->load(), step));
+    ForLoopInst* loop = IB::genForLoopInst(index_decl, loop_end, loop_inc, loop_code, false);
+    block->pushBackInst(loop);
+
+    return block;
+}
+
 int ZoneArray::gInternalMemorySize = 0;
 
 CodeContainer::~CodeContainer()

compiler/generator/code_container.hh

@@ -76,6 +76,8 @@ class CodeContainer : public virtual Garbageable {
 
     int  fSubContainerType;
     bool fGeneratedSR;
+    bool fComputeByBlock{false};  ///< true if a compute method by block is needed
+    std::string fComputeBlockIndex;  ///< loop index name for block-based compute
 
     MemoryLayoutType fMemoryLayout;
     std::string      fKlassName;
@@ -338,6 +340,12 @@ class CodeContainer : public virtual Garbageable {
     virtual DeclareFunInst* generateComputeFun(const std::string& name, const std::string& obj,
                                                bool ismethod, bool isvirtual);
 
+    void setComputeByBlock(bool b);
+    bool getComputeByBlock() const { return fComputeByBlock; }
+    const std::string& getComputeBlockIndex() const { return fComputeBlockIndex; }
+
+    BlockInst* generateComputeBlockLoop(bool loop_var_in_bytes = false);
+
     virtual BlockInst* generateComputeAux()
     {
         faustassert(false);

compiler/generator/cpp/cpp_code_container.cpp

@@ -947,18 +947,8 @@ void CPPScalarCodeContainer::generateCompute(int n)
     tab(n + 2, *fOut);
     fCodeProducer->Tab(n + 2);
 
-    // Generates local variables declaration and setup
-    generateComputeBlock(fCodeProducer);
-
-    // Generates one single scalar loop
-    ForLoopInst* loop = fCurLoop->generateScalarLoop(fFullCount);
-    loop->accept(fCodeProducer);
-
-    /*
-     // TODO : atomic switch
-     // Currently for soundfile management
-     */
-    generatePostComputeBlock(fCodeProducer);
+    BlockInst* block = generateComputeBlockLoop();
+    block->accept(fCodeProducer);
 
     back(1, *fOut);
     *fOut << "}";

compiler/generator/fir/fir_code_container.cpp

@@ -156,6 +156,9 @@ static void dumpCost(StatementInst* inst, ostream* dst)
 
 void FIRCodeContainer::dumpComputeBlock(FIRInstVisitor& firvisitor, ostream* dst)
 {
+    if (getComputeByBlock()) {
+        return;
+    }
     if (fComputeBlockInstructions->fCode.size() > 0) {
         *dst << "======= Compute control begin ==========" << endl << endl;
         // Complexity estimation
@@ -323,6 +326,9 @@ void FIRCodeContainer::produceClass()
 
 void FIRCodeContainer::dumpPostCompute(FIRInstVisitor& firvisitor, ostream* dst)
 {
+    if (getComputeByBlock()) {
+        return;
+    }
     *dst << "======= Post compute DSP begin ==========" << endl << endl;
     fPostComputeBlockInstructions->accept(&firvisitor);
     *dst << endl << "======= Post compute DSP end ==========" << endl << endl;