Ignore:
Timestamp:
Jul 16, 2015, 1:51:51 PM (4 years ago)
Author:
nmedfort
Message:

Added pablo Prototype to compiler. All Calls must be given one instead of a Name.

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

Legend:

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

    r4641 r4680  
    7676
    7777
    78 Call * PabloBuilder::createCall(String * name) {
    79     MAKE_UNARY(createCall, PabloAST::ClassTypeId::Call, name);
     78Call * PabloBuilder::createCall(Prototype * prototype) {
     79    MAKE_UNARY(createCall, PabloAST::ClassTypeId::Call, prototype);
    8080    return cast<Call>(result);
    8181}
  • icGREP/icgrep-devel/icgrep/pablo/builder.hpp

    r4657 r4680  
    5151    }
    5252
    53     inline Call * createCall(const std::string name) {
    54         return createCall(mPb->getName(name));
    55     }
    56 
    57     Call * createCall(String * name);
     53    Call * createCall(Prototype * prototype);
    5854
    5955    Assign * createAssign(const std::string && prefix, PabloAST * expr) {
     
    171167    }
    172168
     169    inline String * getName(const std::string name, const bool generated = true) const {
     170        return mPb->getName(std::move(name), generated);
     171    }
     172
     173    inline String * makeName(const std::string prefix, const bool generated = true) const {
     174        return mPb->makeName(std::move(prefix), generated);
     175    }
     176
     177    inline Integer * getInteger(Integer::integer_t value) {
     178        return mPb->getInteger(value);
     179    }
     180
     181
    173182    inline Statement * getInsertPoint() const {
    174183        return mPb->getInsertPoint();
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.cpp

    r4657 r4680  
    7272}
    7373
    74 Call * PabloBlock::createCall(PabloAST * name) {
    75     assert (name);
    76     return insertAtInsertionPoint(new Call(name));
     74Call * PabloBlock::createCall(PabloAST * prototype) {
     75    assert (prototype);
     76    return insertAtInsertionPoint(new Call(prototype));
    7777}
    7878
  • icGREP/icgrep-devel/icgrep/pablo/codegenstate.h

    r4672 r4680  
    2929#include <pablo/ps_if.h>
    3030#include <pablo/ps_while.h>
     31#include <pablo/function.h>
    3132#include <stdexcept>
    3233
     
    7576    }
    7677
    77     inline Call * createCall(const std::string name) {
    78         return createCall(getName(name, false));
    79     }
    80 
    81     inline Call * createCall(String * name) {
    82         return createCall(cast<PabloAST>(name));
     78    inline Call * createCall(Prototype * prototype) {
     79        return createCall(prototype);
    8380    }
    8481
     
    168165   
    169166protected:
     167
     168
    170169    PabloBlock(SymbolGenerator & symbolGenerator);
    171170
     
    187186private:
    188187
    189     Call * createCall(PabloAST * name);
     188    Call * createCall(PabloAST * prototype);
    190189
    191190    Var * createVar(PabloAST * name);
  • icGREP/icgrep-devel/icgrep/pablo/function.cpp

    r4659 r4680  
    11#include "function.h"
    22#include <pablo/codegenstate.h>
     3#include <cstring>
    34
    45namespace pablo {
    56
    6 PabloFunction::PabloFunction(std::string && name)
    7 : PabloAST(ClassTypeId::Function)
    8 , mEntryBlock(PabloBlock::Create(mSymbolTable))
    9 , mParameters(reinterpret_cast<ParamAllocator &>(mVectorAllocator))
    10 , mResults(reinterpret_cast<ResultAllocator &>(mVectorAllocator))
    11 , mName(mSymbolTable.get(name, false)) {
     7Prototype::Prototype(const PabloAST::ClassTypeId type, std::string && name, const unsigned numOfParameters, const unsigned numOfResults, const unsigned requiredStateSpace)
     8: PabloAST(type)
     9, mName(new String(name, false)) // <-- Should there be a global pool to assert that no two prototypes have the same name?
     10, mNumOfParameters(numOfParameters)
     11, mNumOfResults(numOfResults)
     12, mRequiredStateSpace(requiredStateSpace) {
    1213
    1314}
    1415
     16PabloFunction::PabloFunction(std::string && name, const unsigned numOfParameters, const unsigned numOfResults)
     17: Prototype(ClassTypeId::Function, std::move(name), numOfParameters, numOfResults, 0)
     18, mEntryBlock(PabloBlock::Create(mSymbolTable))
     19, mParameters(reinterpret_cast<Var **>(mAllocator.allocate(sizeof(Var *) * numOfParameters)))
     20, mResults(reinterpret_cast<Assign **>(mAllocator.allocate(sizeof(Assign *) * numOfResults))) {
     21    std::memset(mParameters, 0, sizeof(Var *) * numOfParameters);
     22    std::memset(mResults, 0, sizeof(Assign *) * numOfResults);
    1523}
     24
     25void PabloFunction::throwInvalidParameterIndex(const unsigned index) const {
     26    throw std::runtime_error(
     27                "Invalid parameter index " +
     28                std::to_string(index) + " of " + std::to_string(getNumOfParameters()) +
     29                " in function " + getName()->to_string());
     30}
     31
     32void PabloFunction::throwInvalidResultIndex(const unsigned index) const {
     33    throw std::runtime_error(
     34                "Invalid result index " +
     35                std::to_string(index) + " of " + std::to_string(getNumOfResults()) +
     36                " in function " + getName()->to_string());
     37}
     38
     39
     40}
  • icGREP/icgrep-devel/icgrep/pablo/function.h

    r4659 r4680  
    1414class String;
    1515
    16 class PabloFunction : public PabloAST {
     16class Prototype : public PabloAST {
    1717    friend class PabloBlock;
    18     using ParamAllocator = VectorAllocator::rebind<Var *>::other;
    19     using Parameters = std::vector<Var *, ParamAllocator>;
    20     using ResultAllocator = VectorAllocator::rebind<Assign *>::other;
    21     using Results = std::vector<Assign *, ResultAllocator>;
    2218public:
    2319
    2420    static inline bool classof(const PabloAST * e) {
    25         return e->getClassTypeId() == ClassTypeId::Function;
     21        return e->getClassTypeId() == ClassTypeId::Prototype;
    2622    }
    2723
     
    3026    }
    3127
    32     static PabloFunction Create(std::string && name);
     28    static Prototype * Create(std::string name, const unsigned inputVariables, const unsigned outputVariables, const unsigned requiredStateSpace);
     29
     30    const String * getName() const {
     31        return mName;
     32    }
     33
     34    // Note: this will have to be updated once different stream types exist
     35    unsigned getNumOfParameters() const {
     36        return mNumOfParameters;
     37    }
     38
     39    unsigned getNumOfResults() const {
     40        return mNumOfResults;
     41    }
     42
     43    unsigned getRequiredStateSpace() const {
     44        return mRequiredStateSpace;
     45    }
     46
     47protected:
     48    // Should only be modified by a pablo::Function after compilation
     49    void setRequiredStateSpace(const unsigned value) {
     50        mRequiredStateSpace = value;
     51    }
     52
     53    Prototype(const PabloAST::ClassTypeId type, std::string && name, const unsigned numOfParameters, const unsigned numOfResults, const unsigned requiredStateSpace);
     54protected:
     55    const String * const    mName;
     56    const unsigned          mNumOfParameters;
     57    const unsigned          mNumOfResults;
     58    unsigned                mRequiredStateSpace;
     59};
     60
     61inline Prototype * Prototype::Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults, const unsigned requiredStateSpace) {
     62    return new Prototype(PabloAST::ClassTypeId::Prototype, std::move(name), numOfParameters, numOfResults, requiredStateSpace);
     63}
     64
     65class PabloFunction : public Prototype {
     66    friend class PabloBlock;
     67    using ParamAllocator = VectorAllocator::rebind<Var *>::other;
     68    using ResultAllocator = VectorAllocator::rebind<Assign *>::other;
     69public:
     70
     71    static inline bool classof(const PabloAST * e) {
     72        switch (e->getClassTypeId()) {
     73            case ClassTypeId::Function:
     74            case ClassTypeId::Prototype:
     75                return true;
     76            default:
     77                return false;
     78        }       
     79    }
     80
     81    static inline bool classof(const void *) {
     82        return false;
     83    }
     84
     85    static PabloFunction Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults);
    3386
    3487    virtual bool operator==(const PabloAST & other) const {
     
    4093    }
    4194
    42     const String * getName() const {
    43         return mName;
    44     }
    45 
    4695    const PabloBlock & getEntryBlock() const {
    4796        return mEntryBlock;
    48     }
    49 
    50     const Parameters & getParameters() const {
    51         return mParameters;
    52     }
    53 
    54     const Results & getResults() const {
    55         return mResults;
    56     }
    57 
    58     Var * getParameter(const unsigned index) {
    59         return mParameters[index];
    60     }
    61 
    62     const Var * getParameter(const unsigned index) const {
    63         return mParameters[index];
    64     }
    65 
    66     void addParameter(Var * value) {
    67         mParameters.push_back(value); value->addUser(this);
    68     }
    69 
    70     Assign * getResult(const unsigned index) {
    71         return mResults[index];
    72     }
    73 
    74     const Assign * getResult(const unsigned index) const {
    75         return mResults[index];
    76     }
    77 
    78     void addResult(Assign * value) {
    79         mResults.push_back(value); value->addUser(this);
    80     }
    81 
    82     void setResult(const unsigned index, PabloAST * value) {
    83         getResult(index)->setExpression(value);
    8497    }
    8598
     
    88101    }
    89102
     103    Var * getParameter(const unsigned index) {
     104        if (LLVM_LIKELY(index < getNumOfParameters()))
     105            return mParameters[index];
     106        else throwInvalidParameterIndex(index);
     107    }
     108
     109    const Var * getParameter(const unsigned index) const {
     110        if (LLVM_LIKELY(index < getNumOfParameters()))
     111            return mParameters[index];
     112        else throwInvalidParameterIndex(index);
     113    }
     114
     115    void setParameter(const unsigned index, Var * value) {
     116        if (LLVM_LIKELY(index < getNumOfParameters()))
     117            mParameters[index] = value;
     118        else throwInvalidParameterIndex(index);
     119    }
     120
     121    Assign * getResult(const unsigned index) {
     122        if (LLVM_LIKELY(index < getNumOfResults()))
     123            return mResults[index];
     124        else throwInvalidResultIndex(index);
     125    }
     126
     127    const Assign * getResult(const unsigned index) const {
     128        if (LLVM_LIKELY(index < getNumOfResults()))
     129            return mResults[index];
     130        else throwInvalidResultIndex(index);
     131    }
     132
     133    void setResult(const unsigned index, Assign * value) {       
     134        if (LLVM_LIKELY(index < getNumOfResults())) {
     135            if (LLVM_LIKELY(mResults[index] != value)) {
     136                if (LLVM_UNLIKELY(mResults[index] != nullptr)) {
     137                    mResults[index]->removeUser(this);
     138                }
     139                mResults[index] = value;
     140                value->addUser(this);
     141            }
     142        }
     143        else throwInvalidResultIndex(index);
     144    }
     145
    90146    virtual ~PabloFunction() { }
    91147
    92148protected:
    93     PabloFunction(std::string && name);
     149
     150    __attribute__((noreturn)) void throwInvalidParameterIndex(const unsigned index) const;
     151
     152    __attribute__((noreturn)) void throwInvalidResultIndex(const unsigned index) const;
     153
     154    PabloFunction(std::string && name, const unsigned numOfParameters, const unsigned numOfResults);
    94155private:
    95156    PabloBlock &        mEntryBlock;
    96     Parameters          mParameters;
    97     Results             mResults;
    98157    SymbolGenerator     mSymbolTable;
    99     String *            mName;
     158    Var ** const        mParameters;
     159    Assign ** const     mResults;
    100160};
    101161
    102 inline PabloFunction PabloFunction::Create(std::string && name) {
    103     return PabloFunction(std::move(name));
     162inline PabloFunction PabloFunction::Create(std::string name, const unsigned numOfParameters, const unsigned numOfResults) {
     163    return PabloFunction(std::move(name), numOfParameters, numOfResults);
    104164}
    105165
  • icGREP/icgrep-devel/icgrep/pablo/optimizers/pablo_automultiplexing.cpp

    r4665 r4680  
    176176    flat_map<const PabloAST *, unsigned> map;   
    177177    std::stack<Statement *> scope;
    178     unsigned complexStatements = 0; // number of statements that cannot always be categorized without generating a new variable
     178    unsigned variableCount = 0; // number of statements that cannot always be categorized without generating a new variable
    179179
    180180    // Scan through and collect all the advances, calls, scanthrus and matchstars ...
     
    202202                case PabloAST::ClassTypeId::ScanThru:
    203203                case PabloAST::ClassTypeId::MatchStar:
    204                     complexStatements++;
     204                    variableCount++;
    205205                    break;
    206206                default:
     
    294294
    295295    // Initialize the BDD engine ...
    296     mManager = Cudd_Init((complexStatements + function.getParameters().size()), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
     296    mManager = Cudd_Init((variableCount + function.getNumOfParameters()), 0, CUDD_UNIQUE_SLOTS, CUDD_CACHE_SLOTS, 0);
    297297    Cudd_AutodynDisable(mManager);
    298298
     
    303303    // Order the variables so the input Vars are pushed to the end; they ought to
    304304    // be the most complex to resolve.
    305     unsigned i = complexStatements;
    306     for (const Var * var : function.getParameters()) {
    307         mCharacterizationMap[var] = Cudd_bddIthVar(mManager, i++);
     305    for (auto i = 0; i != function.getNumOfParameters(); ++i) {
     306        mCharacterizationMap[function.getParameter(i)] = Cudd_bddIthVar(mManager, variableCount++);
    308307    }
    309308
  • icGREP/icgrep-devel/icgrep/pablo/pabloAST.h

    r4657 r4680  
    2828    friend class While;
    2929    friend class PabloBlock;
     30    friend class Prototype;
    3031    friend class PabloFunction;
    3132    friend class SymbolGenerator;
     
    6566        , Integer
    6667        , String
     68        , Prototype
    6769    };
    6870    inline ClassTypeId getClassTypeId() const {
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r4679 r4680  
    166166
    167167    //The basis bits structure
    168     for (unsigned i = 0; i != function.getParameters().size(); ++i) {
     168    for (unsigned i = 0; i != function.getNumOfParameters(); ++i) {
    169169        Value* indices[] = {mBuilder->getInt64(0), mBuilder->getInt32(i)};
    170170        Value * gep = mBuilder->CreateGEP(mInputAddressPtr, indices);
     
    188188   
    189189    // Write the output values out
    190     for (unsigned i = 0; i != function.getResults().size(); ++i) {
     190    for (unsigned i = 0; i != function.getNumOfResults(); ++i) {
     191        assert (function.getResult(i));
    191192        SetOutputValue(mMarkerMap[function.getResult(i)], i);
    192193    }
     
    205206
    206207inline void PabloCompiler::GenerateFunction(PabloFunction & function) {
    207     mInputType = PointerType::get(StructType::get(mMod->getContext(), std::vector<Type *>(function.getParameters().size(), mBitBlockType)), 0);
     208    mInputType = PointerType::get(StructType::get(mMod->getContext(), std::vector<Type *>(function.getNumOfParameters(), mBitBlockType)), 0);
    208209    Type * carryType = PointerType::get(mBitBlockType, 0);
    209     Type * outputType = PointerType::get(StructType::get(mMod->getContext(), std::vector<Type *>(function.getResults().size(), mBitBlockType)), 0);
     210    Type * outputType = PointerType::get(StructType::get(mMod->getContext(), std::vector<Type *>(function.getNumOfResults(), mBitBlockType)), 0);
    210211    FunctionType * functionType = FunctionType::get(Type::getVoidTy(mMod->getContext()), {{mInputType, carryType, outputType}}, false);
    211212
     
    793794   
    794795void PabloCompiler::SetOutputValue(Value * marker, const unsigned index) {
     796    assert (marker);
    795797    if (marker->getType()->isPointerTy()) {
    796798        marker = mBuilder->CreateAlignedLoad(marker, BLOCK_SIZE/8, false);
  • icGREP/icgrep-devel/icgrep/pablo/pe_call.h

    r4650 r4680  
    33
    44#include <pablo/pabloAST.h>
    5 #include <pablo/pe_string.h>
     5#include <pablo/function.h>
    66
    77namespace pablo {
     
    1616        return false;
    1717    }
    18     virtual ~Call() {
     18    virtual ~Call() { }
     19    inline const String * getCallee() const {
     20        return cast<Prototype>(getOperand(0))->getName();
    1921    }
    20     inline const String * getCallee() const {
    21         return cast<String>(getOperand(0));
     22    inline void setLocalCarryIndex(const unsigned idx) {
     23        mLocalCarryIndex = idx;
     24    }
     25    inline unsigned getLocalCarryIndex() const {
     26        return mLocalCarryIndex;
    2227    }
    2328protected:
    24     Call(PabloAST * callee)
    25     : Statement(ClassTypeId::Call, {callee}, cast<String>(callee)) {
     29    Call(PabloAST * prototype)
     30    : Statement(ClassTypeId::Call, {prototype}, cast<Prototype>(prototype)->getName())
     31    , mLocalCarryIndex(0) {
    2632
    2733    }
     34private:
     35    unsigned mLocalCarryIndex;
    2836};
    2937}
  • icGREP/icgrep-devel/icgrep/pablo/pe_string.h

    r4567 r4680  
    1414class String : public PabloAST {
    1515    friend class SymbolGenerator;
     16    friend class Prototype;
    1617    friend std::ostream & operator<< (std::ostream& stream, const String & string);
    1718public:
Note: See TracChangeset for help on using the changeset viewer.