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

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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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;
Note: See TracChangeset for help on using the changeset viewer.