Ignore:
Timestamp:
Feb 15, 2017, 4:08:37 PM (2 years ago)
Author:
nmedfort
Message:

memcpy/memset support for 32-bit systems; more error messages/handling; bug fix for ParabixCharacterClassKernelBuilder?. continued work on parenthesis matching + expandable buffers.

File:
1 edited

Legend:

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

    r5317 r5320  
    5757    mMarker.emplace(entryBlock->createOnes(), iBuilder->allOnes());
    5858
    59     for (unsigned i = 0; i < mKernel->getNumOfInputs(); ++i) {
    60         Var * var = mKernel->getInput(i);
    61         if (LLVM_UNLIKELY(var->isScalar())) {
    62             mMarker.emplace(var, mKernel->getScalarFieldPtr(var->getName()));
    63         }
    64     }
    65 
    66     for (unsigned i = 0; i < mKernel->getNumOfOutputs(); ++i) {
    67         Var * var = mKernel->getOutput(i);
    68         if (LLVM_UNLIKELY(var->isScalar())) {
    69             mMarker.emplace(var, mKernel->getScalarFieldPtr(var->getName()));
    70         }
    71     }
    72 
    7359    compileBlock(entryBlock);
    7460
     
    129115
    130116    for (const Var * var : ifStatement->getEscaped()) {
    131         auto f = mMarker.find(var);
    132         if (LLVM_UNLIKELY(f == mMarker.end())) {
    133             std::string tmp;
    134             raw_string_ostream out(tmp);
    135             var->print(out);
    136             out << " is uninitialized prior to entering ";
    137             ifStatement->print(out);
    138             report_fatal_error(out.str());
    139         }
    140         incoming.emplace_back(var, f->second);
     117        if (LLVM_UNLIKELY(var->isKernelParameter())) {
     118            Value * marker = nullptr;
     119            if (var->isScalar()) {
     120                marker = mKernel->getScalarFieldPtr(var->getName());
     121            } else if (var->isReadOnly()) {
     122                marker = mKernel->getInputStreamBlockPtr(var->getName(), iBuilder->getInt32(0));
     123            } else if (var->isReadNone()) {
     124                marker = mKernel->getOutputStreamBlockPtr(var->getName(), iBuilder->getInt32(0));
     125            }
     126            mMarker[var] = marker;
     127        } else {
     128            auto f = mMarker.find(var);
     129            if (LLVM_UNLIKELY(f == mMarker.end())) {
     130                std::string tmp;
     131                raw_string_ostream out(tmp);
     132                var->print(out);
     133                out << " is uninitialized prior to entering ";
     134                ifStatement->print(out);
     135                report_fatal_error(out.str());
     136            }
     137            incoming.emplace_back(var, f->second);
     138        }
    141139    }
    142140
     
    223221#endif
    224222    // On entry to the while structure, proceed to execute the first iteration
    225     // of the loop body unconditionally.   The while condition is tested at the end of
     223    // of the loop body unconditionally. The while condition is tested at the end of
    226224    // the loop.
     225
     226    for (const Var * var : escaped) {
     227        if (LLVM_UNLIKELY(var->isKernelParameter())) {
     228            Value * marker = nullptr;
     229            if (var->isScalar()) {
     230                marker = mKernel->getScalarFieldPtr(var->getName());
     231            } else if (var->isReadOnly()) {
     232                marker = mKernel->getInputStreamBlockPtr(var->getName(), iBuilder->getInt32(0));
     233            } else if (var->isReadNone()) {
     234                marker = mKernel->getOutputStreamBlockPtr(var->getName(), iBuilder->getInt32(0));
     235            }
     236            mMarker[var] = marker;
     237        }
     238    }
    227239
    228240    mCarryManager->enterLoopScope(whileBody);
     
    346358        Value * value = nullptr;
    347359        if (LLVM_UNLIKELY(isa<Assign>(stmt))) {
    348 
    349360            value = compileExpression(cast<Assign>(stmt)->getValue());
    350 
    351361            expr = cast<Assign>(stmt)->getVariable();
    352 
    353             bool storeRequired = false;
    354 
     362            Value * ptr = nullptr;
    355363            if (LLVM_LIKELY(isa<Var>(expr))) {
    356364                const Var * var = cast<Var>(expr);
     
    358366                    std::string tmp;
    359367                    raw_string_ostream out(tmp);
    360                     out << "cannot assign value to ";
     368                    out << mKernel->getName();
     369                    out << " cannot assign value to ";
    361370                    var->print(out);
    362371                    out << ": ";
     
    365374                    report_fatal_error(out.str());
    366375                }
    367                 storeRequired = var->isKernelParameter();
    368             }
    369 
    370             if (storeRequired || isa<Extract>(expr)) {
     376                if (var->isKernelParameter()) {
     377                    if (var->isScalar()) {
     378                        ptr = mKernel->getScalarFieldPtr(var->getName());
     379                    } else {
     380                        ptr = mKernel->getOutputStreamBlockPtr(var->getName(), iBuilder->getInt32(0));
     381                    }
     382                }
     383            } else if (isa<Extract>(expr)) {
    371384                const auto f = mMarker.find(expr);
    372385                if (LLVM_UNLIKELY(f == mMarker.end())) {
    373386                    std::string tmp;
    374387                    raw_string_ostream out(tmp);
    375                     out << "cannot assign value to ";
     388                    out << mKernel->getName();
     389                    out << " cannot assign value to ";
    376390                    expr->print(out);
    377391                    out << ": ";
     
    381395                    report_fatal_error(out.str());
    382396                }
    383                 Value * const ptr = f->second;
     397                ptr = f->second;
     398                assert (ptr);
     399            }
     400            if (ptr) {
    384401                iBuilder->CreateAlignedStore(value, ptr, getAlignment(value));
    385402                value = ptr;
    386403            }
    387 
    388404        } else if (const Extract * extract = dyn_cast<Extract>(stmt)) {
    389405            Value * index = compileExpression(extract->getIndex());
     
    397413                    std::string tmp;
    398414                    raw_string_ostream out(tmp);
    399                     out << "stream ";
     415                    out << mKernel->getName();
     416                    out << " stream ";
    400417                    expr->print(out);
    401418                    out << " cannot be read or written to";
     
    458475            }
    459476            Value * ptr = mKernel->getScalarFieldPtr(f->second);
    460             Value * count = iBuilder->CreateAlignedLoad(ptr, getPointerElementAlignment(ptr));
     477            const auto alignment = getPointerElementAlignment(ptr);
     478            Value * count = iBuilder->CreateAlignedLoad(ptr, alignment, c->getName() + "_accumulator");
    461479            Value * const partial = iBuilder->simd_popcount(counterSize, to_count);
    462480            if (LLVM_UNLIKELY(counterSize <= 1)) {
     
    471489            }
    472490            value = iBuilder->CreateAdd(value, count);
    473             iBuilder->CreateStore(value, ptr);
    474 
     491            iBuilder->CreateAlignedStore(value, ptr, alignment);
    475492        } else if (const Lookahead * l = dyn_cast<Lookahead>(stmt)) {
    476493            Var * var = nullptr;
     
    520537            std::string tmp;
    521538            raw_string_ostream out(tmp);
    522             out << "Internal error: ";
     539            out << "PabloCompiler: statement ";
    523540            stmt->print(out);
    524             out << " is not a recognized statement in the Pablo compiler.";
    525             throw std::runtime_error(out.str());
     541            out << " was not recognized by the compiler";
     542            report_fatal_error(out.str());
    526543        }
    527544
Note: See TracChangeset for help on using the changeset viewer.