Ignore:
Timestamp:
Feb 10, 2017, 1:48:34 PM (2 years ago)
Author:
nmedfort
Message:

Adjusted pablo compiler to use getInputStream and getOutputStream when accessing packed stream fields.

Location:
icGREP/icgrep-devel/icgrep/pablo
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/pablo/carry_manager.cpp

    r5307 r5310  
    6060
    6161    if (mHasLoop) {
    62         mKernel->addScalar(iBuilder->getInt32Ty(), "loopSelector");
     62        mKernel->addScalar(iBuilder->getInt32Ty(), "selector");
    6363    }
    6464}
     
    8282
    8383    if (mHasLoop) {
    84         mLoopSelector = mKernel->getScalarField("loopSelector");
     84        mLoopSelector = mKernel->getScalarField("selector");
    8585    }
    8686}
     
    9191void CarryManager::finalizeCodeGen() {
    9292    if (mHasLoop) {
    93         mKernel->setScalarField("loopSelector", iBuilder->CreateXor(mLoopSelector, iBuilder->getInt32(1)));
     93        mKernel->setScalarField("selector", iBuilder->CreateXor(mLoopSelector, iBuilder->getInt32(1)));
    9494    }
    9595}
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r5307 r5310  
    2626#include <pablo/carry_manager.h>
    2727#include <IR_Gen/idisa_builder.h>
     28#include <kernels/streamset.h>
    2829#include <llvm/IR/Module.h>
    2930#include <llvm/Support/raw_os_ostream.h>
     
    5859    for (unsigned i = 0; i < mKernel->getNumOfInputs(); ++i) {
    5960        Var * var = mKernel->getInput(i);
    60         std::string name = var->getName().str();
    61         Value * input = nullptr;
    62         if (var->getType()->isSingleValueType()) {
    63             input = mKernel->getScalarFieldPtr(name);
    64         } else {
    65             input = mKernel->getInputStream(name, iBuilder->getInt32(0));
    66         }
    67         mMarker.emplace(var, input);
     61        if (LLVM_UNLIKELY(var->isScalar())) {
     62            mMarker.emplace(var, mKernel->getScalarFieldPtr(var->getName()));
     63        }
    6864    }
    6965
    7066    for (unsigned i = 0; i < mKernel->getNumOfOutputs(); ++i) {
    7167        Var * var = mKernel->getOutput(i);
    72         std::string name = var->getName().str();
    73         Value * output = nullptr;
    74         if (var->getType()->isSingleValueType()) {
    75             output = mKernel->getScalarFieldPtr(name);
    76         } else {
    77             output = mKernel->getOutputStream(name, iBuilder->getInt32(0));
    78         }
    79         mMarker.emplace(var, output);
     68        if (LLVM_UNLIKELY(var->isScalar())) {
     69            mMarker.emplace(var, mKernel->getScalarFieldPtr(var->getName()));
     70        }
    8071    }
    8172
     
    145136            out << " is uninitialized prior to entering ";
    146137            ifStatement->print(out);
    147             llvm::report_fatal_error(out.str());
     138            report_fatal_error(out.str());
    148139        }
    149140        incoming.emplace_back(var, f->second);
     
    189180            var->print(out);
    190181            out << " was not assigned an outgoing value.";
    191             llvm::report_fatal_error(out.str());
     182            report_fatal_error(out.str());
    192183        }
    193184
     
    208199            out << ") within ";
    209200            ifStatement->print(out);
    210             llvm::report_fatal_error(out.str());
     201            report_fatal_error(out.str());
    211202        }
    212203
     
    262253            out << " is uninitialized prior to entering ";
    263254            whileStatement->print(out);
    264             llvm::report_fatal_error(out.str());
     255            report_fatal_error(out.str());
    265256        }
    266257        Value * entryValue = f->second;
     
    314305            var->print(out);
    315306            out << " is no longer assigned a value.";
    316             llvm::report_fatal_error(out.str());
     307            report_fatal_error(out.str());
    317308        }
    318309
     
    330321            out << ") within ";
    331322            whileStatement->print(out);
    332             llvm::report_fatal_error(out.str());
     323            report_fatal_error(out.str());
    333324        }
    334325
     
    345336}
    346337
    347 void PabloCompiler::compileStatement(const Statement * stmt) {
     338void PabloCompiler::compileStatement(const Statement * const stmt) {
    348339
    349340    if (LLVM_UNLIKELY(isa<If>(stmt))) {
     
    356347        if (LLVM_UNLIKELY(isa<Assign>(stmt))) {
    357348
     349            value = compileExpression(cast<Assign>(stmt)->getValue());
     350
    358351            expr = cast<Assign>(stmt)->getVariable();
    359             value = compileExpression(cast<Assign>(stmt)->getValue());
    360 
    361             bool storeInstRequired = false;
     352
     353            bool storeRequired = false;
     354
    362355            if (LLVM_LIKELY(isa<Var>(expr))) {
    363                 for (unsigned i = 0; i < mKernel->getNumOfOutputs(); ++i) {
    364                     if (expr == mKernel->getOutput(i)) {
    365                         storeInstRequired = true;
    366                         break;
    367                     }
     356                const Var * var = cast<Var>(expr);
     357                if (LLVM_UNLIKELY(var->isReadOnly())) {
     358                    std::string tmp;
     359                    raw_string_ostream out(tmp);
     360                    out << "cannot assign value to ";
     361                    var->print(out);
     362                    out << ": ";
     363                    var->print(out);
     364                    out << " is read only";
     365                    report_fatal_error(out.str());
    368366                }
    369             }
    370 
    371             if (LLVM_UNLIKELY(storeInstRequired || isa<Extract>(expr))) {
     367                storeRequired = var->isKernelParameter();
     368            }
     369
     370            if (storeRequired || isa<Extract>(expr)) {
    372371                const auto f = mMarker.find(expr);
    373372                if (LLVM_UNLIKELY(f == mMarker.end())) {
    374373                    std::string tmp;
    375374                    raw_string_ostream out(tmp);
    376                     out << "PabloCompiler: use-before-definition error: ";
     375                    out << "cannot assign value to ";
     376                    expr->print(out);
     377                    out << ": ";
    377378                    expr->print(out);
    378379                    out << " does not dominate ";
    379380                    stmt->print(out);
    380                     llvm::report_fatal_error(out.str());
     381                    report_fatal_error(out.str());
    381382                }
    382383                Value * const ptr = f->second;
     
    386387
    387388        } else if (const Extract * extract = dyn_cast<Extract>(stmt)) {
    388             Value * array = compileExpression(extract->getArray(), false);
    389389            Value * index = compileExpression(extract->getIndex());
    390             value = iBuilder->CreateGEP(array, index, stmt->getName());
     390            Var * const array = dyn_cast<Var>(extract->getArray());
     391            if (LLVM_LIKELY(array && array->isKernelParameter())) {
     392                if (array->isReadOnly()) {
     393                    value = mKernel->getInputStream(array->getName(), index);
     394                } else if (array->isReadNone()) {
     395                    value = mKernel->getOutputStream(array->getName(), index);
     396                } else {
     397                    std::string tmp;
     398                    raw_string_ostream out(tmp);
     399                    out << "stream ";
     400                    expr->print(out);
     401                    out << " cannot be read or written to";
     402                    report_fatal_error(out.str());
     403                }
     404            } else {
     405                Value * ptr = compileExpression(extract->getArray(), false);
     406                value = iBuilder->CreateGEP(ptr, {ConstantInt::getNullValue(index->getType()), index}, "extract");
     407            }
    391408        } else if (isa<And>(stmt)) {
    392409            value = compileExpression(stmt->getOperand(0));
     
    438455            const auto f = mAccumulator.find(c);
    439456            if (LLVM_UNLIKELY(f == mAccumulator.end())) {
    440                 llvm::report_fatal_error("Unknown accumulator: " + c->getName().str());
     457                report_fatal_error("Unknown accumulator: " + c->getName().str());
    441458            }
    442459            Value * ptr = mKernel->getScalarFieldPtr(f->second);
     
    474491            std::string inputName = cast<Var>(var)->getName().str();
    475492            Value * blockNo = mKernel->getBlockNo();
    476             Value * lookAhead_blockPtr  = mKernel->getStreamSetPtr(inputName, iBuilder->CreateAdd(blockNo, iBuilder->getSize(block_shift)));
     493            Value * lookAhead_blockPtr  = mKernel->getInputStreamSetPtr(inputName, iBuilder->CreateAdd(blockNo, iBuilder->getSize(block_shift)));
    477494            Value * lookAhead_inputPtr = iBuilder->CreateGEP(lookAhead_blockPtr, {iBuilder->getInt32(0), iBuilder->getInt32(index)});
    478495            Value * lookAhead = iBuilder->CreateBlockAlignedLoad(lookAhead_inputPtr);
     
    480497                value = lookAhead;
    481498            } else { // Need to form shift result from two adjacent blocks.
    482                 Value * lookAhead_blockPtr1  = mKernel->getStreamSetPtr(inputName, iBuilder->CreateAdd(blockNo, iBuilder->getSize(block_shift + 1)));
     499                Value * lookAhead_blockPtr1  = mKernel->getInputStreamSetPtr(inputName, iBuilder->CreateAdd(blockNo, iBuilder->getSize(block_shift + 1)));
    483500                Value * lookAhead_inputPtr1 = iBuilder->CreateGEP(lookAhead_blockPtr1, {iBuilder->getInt32(0), iBuilder->getInt32(index)});
    484501                Value * lookAhead1 = iBuilder->CreateBlockAlignedLoad(lookAhead_inputPtr1);
     
    496513        } else {
    497514            std::string tmp;
    498             llvm::raw_string_ostream out(tmp);
     515            raw_string_ostream out(tmp);
    499516            out << "Internal error: ";
    500517            stmt->print(out);
     
    521538        return iBuilder->allZeroes();
    522539    } else if (LLVM_UNLIKELY(isa<Integer>(expr))) {
    523         return iBuilder->getInt64(cast<Integer>(expr)->value());
     540        return ConstantInt::get(cast<Integer>(expr)->getType(), cast<Integer>(expr)->value());
    524541    } else if (LLVM_UNLIKELY(isa<Operator>(expr))) {
    525542        const Operator * op = cast<Operator>(expr);
     
    536553            rh->getType()->print(out);
    537554            out << ")";
    538             llvm::report_fatal_error(out.str());
     555            report_fatal_error(out.str());
    539556        }
    540557        switch (op->getClassTypeId()) {
     
    561578        expr->print(out);
    562579        out << " is not a valid Operator";
    563         llvm::report_fatal_error(out.str());
     580        report_fatal_error(out.str());
    564581    }
    565582    const auto f = mMarker.find(expr);
    566583    if (LLVM_UNLIKELY(f == mMarker.end())) {
    567584        std::string tmp;
    568         llvm::raw_string_ostream out(tmp);
     585        raw_string_ostream out(tmp);
    569586        out << "Compilation error: ";
    570587        expr->print(out);
    571588        out << " was used before definition!";
    572         llvm::report_fatal_error(out.str());
     589        report_fatal_error(out.str());
    573590    }
    574591    Value * value = f->second;
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.h

    r5297 r5310  
    99
    1010#include <unordered_map>
    11 #include <boost/container/flat_set.hpp>
    1211namespace IDISA { class IDISA_Builder; }
    1312namespace llvm { class Function; }
     
    2423
    2524class PabloCompiler {
    26     friend class CarryManager;
    27 
    28     using IntSet = boost::container::flat_set<unsigned>;
     25//    friend class CarryManager;
    2926
    3027    using TranslationMap = std::unordered_map<const PabloAST *, llvm::Value *>;
     
    5956    TranslationMap                  mMarker;
    6057    TranslationMap                  mAccumulator;
    61     IntSet                          mInputStreamOffset;
    6258
    6359};
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.cpp

    r5307 r5310  
    1010#include <pablo/pe_zeroes.h>
    1111#include <pablo/pe_ones.h>
    12 //#include <llvm/IR/Module.h>
    13 //#include <llvm/IR/Verifier.h>
    14 //#include <IR_Gen/idisa_builder.h>
    1512#include "llvm/Support/Debug.h"
    1613
     
    3128}
    3229
    33 Var * PabloKernel::getInputSet(std::string inputSetName) {
    34     unsigned ssIndex = getStreamSetIndex(inputSetName);
    35     return mInputs[ssIndex];
     30Var * PabloKernel::getInputStreamVar(const std::string & inputSetName) {
     31    return mInputs[getStreamSetIndex(inputSetName)];
    3632}
    3733
    38 Var * PabloKernel::getOutputSet(std::string outputSetName) {
    39     unsigned ssIndex = getStreamSetIndex(outputSetName);
    40     return mOutputs[ssIndex - mInputs.size()];
     34Var * PabloKernel::getOutputStreamVar(const std::string & outputSetName) {
     35    return mOutputs[getStreamSetIndex(outputSetName)];
    4136}
    4237
    43 
    44 Var * PabloKernel::getScalarOutput(std::string outputName) {
     38Var * PabloKernel::getOutputScalarVar(const std::string & outputName) {
    4539    const auto f = mScalarOutputNameMap.find(outputName);
    4640    if (LLVM_UNLIKELY(f == mScalarOutputNameMap.end())) {
    47         llvm::report_fatal_error("Kernel does not contain scalar: " + outputName);
     41        report_fatal_error("Kernel does not contain scalar: " + outputName);
    4842    }
    4943    return f->second;
     
    5145
    5246Var * PabloKernel::addInput(const std::string & name, Type * const type) {
    53     Var * param = new (mAllocator) Var(mSymbolTable->makeString(name, iBuilder), type, mAllocator, Var::ReadOnly);
     47    Var * param = new (mAllocator) Var(mSymbolTable->makeString(name, iBuilder), type, mAllocator, Var::KernelInputParameter);
    5448    param->addUser(this);
    5549    mInputs.push_back(param);
    5650    mVariables.push_back(param);
    5751    if (isStreamType(type)) {
    58         mStreamSetInputs.emplace_back(type, name);
     52        mStreamSetNameMap.emplace(name, mStreamSetInputs.size());
     53        mStreamSetInputs.emplace_back(type, name);       
    5954    } else {
    6055        mScalarInputs.emplace_back(type, name);
     56        param->setScalar();
    6157    }
    6258    assert (mStreamSetInputs.size() + mScalarInputs.size() == mInputs.size());
     
    6561
    6662Var * PabloKernel::addOutput(const std::string & name, Type * const type) {
    67     Var * result = new (mAllocator) Var(mSymbolTable->makeString(name, iBuilder), type, mAllocator, Var::ReadNone);
     63    Var * result = new (mAllocator) Var(mSymbolTable->makeString(name, iBuilder), type, mAllocator, Var::KernelOutputParameter);
    6864    result->addUser(this);
    6965    mOutputs.push_back(result);
    7066    mVariables.push_back(result);
    7167    if (isStreamType(type)) {
     68        mStreamSetNameMap.emplace(name, mStreamSetOutputs.size());
    7269        mStreamSetOutputs.emplace_back(type, name);
    7370    } else {
    7471        mScalarOutputs.emplace_back(type, name);
    7572        mScalarOutputNameMap.emplace(name, result);
     73        result->setScalar();
    7674    }
    7775    assert (mStreamSetOutputs.size() + mScalarOutputs.size() == mOutputs.size());
     
    130128}
    131129
    132 PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName)
    133 : BlockOrientedKernel(builder, std::move(kernelName), {}, {}, {}, {}, {Binding{builder->getBitBlockType(), "EOFbit"}, Binding{builder->getBitBlockType(), "EOFmask"}})
    134 , PabloAST(PabloAST::ClassTypeId::Kernel, nullptr, mAllocator)
    135 , mPabloCompiler(new PabloCompiler(this))
    136 , mSymbolTable(new SymbolGenerator(mAllocator))
    137 , mEntryBlock(PabloBlock::Create(this)) {
    138     setDoBlockUpdatesProducedItemCountsAttribute(false);
    139 }
    140 
    141 PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName,
    142                          std::vector<Binding> && stream_inputs,
    143                          std::vector<Binding> && stream_outputs,
    144                          std::vector<Binding> && scalar_outputs)
     130PabloKernel::PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName,
     131                         std::vector<Binding> stream_inputs,
     132                         std::vector<Binding> stream_outputs,
     133                         std::vector<Binding> scalar_parameters,
     134                         std::vector<Binding> scalar_outputs)
    145135: BlockOrientedKernel(builder, std::move(kernelName),
    146136                      std::move(stream_inputs), std::move(stream_outputs),
    147                       {}, std::move(scalar_outputs),
     137                      std::move(scalar_parameters), std::move(scalar_outputs),
    148138                      {Binding{builder->getBitBlockType(), "EOFbit"}, Binding{builder->getBitBlockType(), "EOFmask"}})
    149139, PabloAST(PabloAST::ClassTypeId::Kernel, nullptr, mAllocator)
     
    153143    setDoBlockUpdatesProducedItemCountsAttribute(false);
    154144    prepareKernelSignature();
    155     for (auto ss : mStreamSetInputs) {
    156         Var * param = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::ReadOnly);
     145    for (const Binding & ss : mStreamSetInputs) {
     146        Var * param = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::KernelInputParameter);
    157147        param->addUser(this);
    158148        mInputs.push_back(param);
    159149        mVariables.push_back(param);
    160150    }
    161     for (auto ss : mStreamSetOutputs) {
    162         Var * result = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::ReadNone);
     151    for (const Binding & ss : mStreamSetOutputs) {
     152        Var * result = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::KernelOutputParameter);
    163153        result->addUser(this);
    164154        mOutputs.push_back(result);
    165155        mVariables.push_back(result);
    166156    }
    167     for (auto ss : mScalarOutputs) {
    168         Var * result = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::ReadNone);
     157    for (const Binding & ss : mScalarOutputs) {
     158        Var * result = new (mAllocator) Var(mSymbolTable->makeString(ss.name, iBuilder), ss.type, mAllocator, Var::KernelOutputParameter);
    169159        result->addUser(this);
    170160        mOutputs.push_back(result);
  • icGREP/icgrep-devel/icgrep/pablo/pablo_kernel.h

    r5300 r5310  
    4646    }
    4747
    48     PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName);
    49    
    5048    PabloKernel(IDISA::IDISA_Builder * builder, std::string kernelName,                     
    51                     std::vector<Binding> && stream_inputs,
    52                     std::vector<Binding> && stream_outputs,
    53                     std::vector<Binding> && scalar_outputs);
     49                std::vector<Binding> stream_inputs = {},
     50                std::vector<Binding> stream_outputs = {},
     51                std::vector<Binding> scalar_parameters = {},
     52                std::vector<Binding> scalar_outputs = {});
    5453
    5554    virtual ~PabloKernel();
     
    6968    }
    7069   
    71     Var * getInputSet(std::string inputSetName);
     70    Var * getInputStreamVar(const std::string & inputSetName);
    7271
    7372    Var * getInput(const unsigned index) {
     
    8584    }
    8685   
    87     Var * getOutputSet(std::string inputSetName);
     86    Var * getOutputStreamVar(const std::string & inputSetName);
    8887   
    89     Var * getScalarOutput(std::string outputName);
     88    Var * getOutputScalarVar(const std::string & outputName);
    9089
    9190    Var * getOutput(const unsigned index) {
     
    119118    inline SymbolGenerator * getSymbolTable() const {
    120119        return mSymbolTable;
     120    }
     121
     122    void * operator new (std::size_t size) noexcept {
     123        return std::malloc(size);
    121124    }
    122125
  • icGREP/icgrep-devel/icgrep/pablo/pe_var.h

    r5283 r5310  
    2121
    2222    enum Attribute {
    23         None = 0
    24         , ReadOnly = 1
    25         , ReadNone = 2
     23        None = 0x00
     24        , ReadOnly = 0x01
     25        , ReadNone = 0x02
     26        , Scalar = 0x04
     27        , KernelParameter = 0x80
     28        // Composite attributes
     29        , KernelInputParameter = ReadOnly | KernelParameter
     30        , KernelOutputParameter = ReadNone | KernelParameter
    2631    };
    2732
     
    3338    }
    3439    bool isReadOnly() const {
    35         return mAttribute & Attribute::ReadOnly;
     40        return (mAttribute & Attribute::ReadOnly) != 0;
    3641    }
    3742    void setReadOnly(const bool value = true) {
     
    4348    }
    4449    bool isReadNone() const {
    45         return mAttribute & Attribute::ReadNone;
     50        return (mAttribute & Attribute::ReadNone) != 0;
    4651    }
    4752    void setReadNone(const bool value = true) {
     
    5257        }
    5358    }
    54 
     59    bool isKernelParameter() const {
     60        return (mAttribute & Attribute::KernelParameter) != 0;
     61    }
     62    void setKernelParameter(const bool value = true) {
     63        if (value) {
     64            mAttribute |= Attribute::KernelParameter;
     65        } else {
     66            mAttribute &= ~(Attribute::KernelParameter);
     67        }
     68    }
     69    bool isScalar() const {
     70        return (mAttribute & Attribute::Scalar) != 0;
     71    }
     72    void setScalar(const bool value = true) {
     73        if (value) {
     74            mAttribute |= Attribute::Scalar;
     75        } else {
     76            mAttribute &= ~(Attribute::Scalar);
     77        }
     78    }
    5579    const String & getName() const noexcept {
    5680        return *mName;
Note: See TracChangeset for help on using the changeset viewer.