Changeset 5242


Ignore:
Timestamp:
Dec 29, 2016, 8:35:20 PM (12 months ago)
Author:
cameron
Message:

Add pthread create, join and exit support into CBuilder

Location:
icGREP/icgrep-devel/icgrep
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/IR_Gen/CBuilder.cpp

    r5239 r5242  
    212212    return inst;
    213213}
     214
     215//
     216// int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     217//                    void *(*start_routine)(void*), void *arg);
     218//
     219Value * CBuilder::CreatePThreadCreateCall(Value * thread, Value * attr, Function * start_routine, Value * arg) {
     220
     221    Type * pthreadTy = getSizeTy();
     222    FunctionType * funVoidPtrVoidTy = FunctionType::get(getVoidTy(), getVoidPtrTy(), false);
     223   
     224    Function * pthreadCreateFunc = cast<Function>(mMod->getOrInsertFunction("pthread_create",
     225                                                                         getInt32Ty(),
     226                                                                         pthreadTy->getPointerTo(),
     227                                                                         getVoidPtrTy(),
     228                                                                         static_cast<Type *>(funVoidPtrVoidTy)->getPointerTo(),
     229                                                                         getVoidPtrTy(), nullptr));
     230    pthreadCreateFunc->setCallingConv(llvm::CallingConv::C);
     231    return CreateCall(pthreadCreateFunc, {thread, attr, start_routine, arg});
     232}
     233
     234//  #include <pthread.h>
     235//  void pthread_exit(void *value_ptr);
     236
     237Value * CBuilder::CreatePThreadExitCall(Value * value_ptr) {
     238    Function * pthreadExitFunc = cast<Function>(mMod->getOrInsertFunction("pthread_exit",
     239                                                                            getVoidTy(),
     240                                                                            getVoidPtrTy(), nullptr));
     241    pthreadExitFunc->addFnAttr(llvm::Attribute::NoReturn);
     242    pthreadExitFunc->setCallingConv(llvm::CallingConv::C);
     243    return CreateCall(pthreadExitFunc, {value_ptr});
     244    CallInst * exitThread = CreateCall(pthreadExitFunc, {value_ptr});
     245    exitThread->setDoesNotReturn();
     246    return exitThread;
     247}
     248
     249//  int pthread_join(pthread_t thread, void **value_ptr);
     250Value * CBuilder::CreatePThreadJoinCall(Value * thread, Value * value_ptr){
     251    Type * pthreadTy = getSizeTy();
     252    Function * pthreadJoinFunc = cast<Function>(mMod->getOrInsertFunction("pthread_join",
     253                                                                       getInt32Ty(),
     254                                                                       pthreadTy,
     255                                                                       getVoidPtrTy()->getPointerTo(), nullptr));
     256    pthreadJoinFunc->setCallingConv(llvm::CallingConv::C);
     257    return CreateCall(pthreadJoinFunc, {thread, value_ptr});
     258}
  • icGREP/icgrep-devel/icgrep/IR_Gen/CBuilder.h

    r5239 r5242  
    4949    void CreateMemZero(Value * ptr, Value * size, const unsigned alignment = 1);
    5050   
     51   
     52    // Create calls to Posix thread (pthread.h) functions.
     53    //
     54    //  int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
     55    //                    void *(*start_routine)(void*), void *arg);
     56    Value * CreatePThreadCreateCall(Value * thread, Value * attr, Function * start_routine, Value * arg);
     57    //  void pthread_exit(void *value_ptr);
     58    Value * CreatePThreadExitCall(Value * value_ptr);
     59    //  int pthread_join(pthread_t thread, void **value_ptr);
     60    Value * CreatePThreadJoinCall(Value * thread, Value * value_ptr);
     61   
     62   
    5163    void CallPrintRegister(const std::string & regName, Value * const value);
    5264    void CallPrintInt(const std::string & name, Value * const value);
  • icGREP/icgrep-devel/icgrep/base64.cpp

    r5240 r5242  
    8080    Type * const inputType = PointerType::get(ArrayType::get(ArrayType::get(mBitBlockType, 8), 1), 0);
    8181    Type * const outputType = PointerType::get(ArrayType::get(ArrayType::get(mBitBlockType, 8), 1), 0);
    82     Type * const int32ty = iBuilder->getInt32Ty();
    83     Type * const int8PtrTy = iBuilder->getInt8PtrTy();
    84     Type * const voidPtrTy = iBuilder->getVoidPtrTy();
    8582
    8683   
     
    105102    Base64out.allocateBuffer();
    106103
    107 
    108     Type * pthreadTy = size_ty;
    109     FunctionType * funVoidPtrVoidTy = FunctionType::get(voidTy, int8PtrTy, false);
    110    
    111     Function * pthreadCreateFunc = cast<Function>(mMod->getOrInsertFunction("pthread_create",
    112                                                                          int32ty,
    113                                                                          pthreadTy->getPointerTo(),
    114                                                                          voidPtrTy,
    115                                                                          static_cast<Type *>(funVoidPtrVoidTy)->getPointerTo(),
    116                                                                          voidPtrTy, nullptr));
    117     pthreadCreateFunc->setCallingConv(llvm::CallingConv::C);
    118     Function * pthreadJoinFunc = cast<Function>(mMod->getOrInsertFunction("pthread_join",
    119                                                                        int32ty,
    120                                                                        pthreadTy,
    121                                                                        PointerType::get(int8PtrTy, 0), nullptr));
    122     pthreadJoinFunc->setCallingConv(llvm::CallingConv::C);
    123    
    124     Function * pthreadExitFunc = cast<Function>(mMod->getOrInsertFunction("pthread_exit",
    125                                                                        voidTy,
    126                                                                        voidPtrTy, nullptr));
    127     pthreadExitFunc->addFnAttr(llvm::Attribute::NoReturn);
    128     pthreadExitFunc->setCallingConv(llvm::CallingConv::C);
    129104
    130105    if (segmentPipelineParallel){
  • icGREP/icgrep-devel/icgrep/grep_engine.cpp

    r5241 r5242  
    312312    BasisBits.allocateBuffer();
    313313
    314     Type * pthreadTy = size_ty;
    315     FunctionType * funVoidPtrVoidTy = FunctionType::get(voidTy, int8PtrTy, false);   
    316    
    317     Function * pthreadCreateFunc = cast<Function>(M->getOrInsertFunction("pthread_create",
    318                                         int32ty,
    319                                         pthreadTy->getPointerTo(),
    320                                         voidPtrTy,
    321                                         static_cast<Type *>(funVoidPtrVoidTy)->getPointerTo(),
    322                                         voidPtrTy, nullptr));
    323     pthreadCreateFunc->setCallingConv(llvm::CallingConv::C);
    324     Function * pthreadJoinFunc = cast<Function>(M->getOrInsertFunction("pthread_join",
    325                                         int32ty,
    326                                         pthreadTy,
    327                                         PointerType::get(int8PtrTy, 0), nullptr));
    328     pthreadJoinFunc->setCallingConv(llvm::CallingConv::C);
    329 
    330     Function * pthreadExitFunc = cast<Function>(M->getOrInsertFunction("pthread_exit",
    331                                         voidTy,
    332                                         voidPtrTy, nullptr));
    333     pthreadExitFunc->addFnAttr(llvm::Attribute::NoReturn);
    334     pthreadExitFunc->setCallingConv(llvm::CallingConv::C);
    335 
    336     if (CountOnly) {       
     314
     315    if (CountOnly) {
    337316        icgrepK.generateKernel({&BasisBits}, {});       
    338317        if (pipelineParallel){
  • icGREP/icgrep-devel/icgrep/kernels/kernel.cpp

    r5233 r5242  
    585585    }
    586586
    587     Value * nullVal = Constant::getNullValue(voidPtrTy);
    588     Function * pthreadExitFunc = m->getFunction("pthread_exit");
    589     CallInst * exitThread = iBuilder->CreateCall(pthreadExitFunc, {nullVal});
    590     exitThread->setDoesNotReturn();
     587    iBuilder->CreatePThreadExitCall(Constant::getNullValue(voidPtrTy));
    591588    iBuilder->CreateRetVoid();
    592589
  • icGREP/icgrep-devel/icgrep/kernels/pipeline.cpp

    r5238 r5242  
    8383    iBuilder->SetInsertPoint(exitThreadBlock);
    8484    Value * nullVal = Constant::getNullValue(voidPtrTy);
    85     Function * pthreadExitFunc = m->getFunction("pthread_exit");
    86     CallInst * exitThread = iBuilder->CreateCall(pthreadExitFunc, {nullVal});
    87     exitThread->setDoesNotReturn();
     85    iBuilder->CreatePThreadExitCall(nullVal);
    8886    iBuilder->CreateRetVoid();
    8987
     
    131129    iBuilder->restoreIP(ip);
    132130
    133     Function * pthreadCreateFunc = m->getFunction("pthread_create");
    134     Function * pthreadJoinFunc = m->getFunction("pthread_join");
    135 
    136131    for (unsigned i = 0; i < threadNum; i++) {
    137         iBuilder->CreateCall(pthreadCreateFunc, std::vector<Value *>({pthreadsPtrs[i], nullVal, thread_functions[i], iBuilder->CreateBitCast(sharedStruct, int8PtrTy)}));
     132        iBuilder->CreatePThreadCreateCall(pthreadsPtrs[i], nullVal, thread_functions[i], iBuilder->CreateBitCast(sharedStruct, int8PtrTy));
    138133    }
    139134
     
    144139   
    145140    for (unsigned i = 0; i < threadNum; i++) {
    146         iBuilder->CreateCall(pthreadJoinFunc, std::vector<Value *>({threadIDs[i], status}));
     141        iBuilder->CreatePThreadJoinCall(threadIDs[i], status);
    147142    }
    148143
     
    151146void generatePipelineParallel(IDISA::IDISA_Builder * iBuilder, std::vector<KernelBuilder *> kernels) {
    152147 
    153     Module * m = iBuilder->getModule();
    154 
    155     Type * pthreadTy = iBuilder->getSizeTy();     
     148    Type * pthreadTy = iBuilder->getSizeTy();
    156149    Type * const voidPtrTy = iBuilder->getVoidPtrTy();
    157150    Type * const int8PtrTy = iBuilder->getInt8PtrTy();
     
    176169    iBuilder->restoreIP(ip);
    177170
    178     Function * pthreadCreateFunc = m->getFunction("pthread_create");
    179     Function * pthreadJoinFunc = m->getFunction("pthread_join");
    180 
    181     for (unsigned i = 0; i < kernels.size(); i++) {
    182         iBuilder->CreateCall(pthreadCreateFunc, std::vector<Value *>({pthreadsPtrs[i], nullVal, kernel_functions[i], iBuilder->CreateBitCast(kernels[i]->getInstance(), int8PtrTy)}));
     171    for (unsigned i = 0; i < kernels.size(); i++) {
     172        iBuilder->CreatePThreadCreateCall(pthreadsPtrs[i], nullVal, kernel_functions[i], iBuilder->CreateBitCast(kernels[i]->getInstance(), int8PtrTy));
    183173    }
    184174
     
    189179   
    190180    for (unsigned i = 0; i < kernels.size(); i++) {
    191         iBuilder->CreateCall(pthreadJoinFunc, std::vector<Value *>({threadIDs[i], status}));
     181        iBuilder->CreatePThreadJoinCall(threadIDs[i], status);
    192182    }
    193183}
  • icGREP/icgrep-devel/icgrep/u8u16.cpp

    r5240 r5242  
    338338    }
    339339
    340     Type * pthreadTy = size_ty;
    341     FunctionType * funVoidPtrVoidTy = FunctionType::get(voidTy, int8PtrTy, false);
    342 
    343     Function * pthreadCreateFunc = cast<Function>(mod->getOrInsertFunction("pthread_create",
    344                                                                          int32ty,
    345                                                                          pthreadTy->getPointerTo(),
    346                                                                          voidPtrTy,
    347                                                                          static_cast<Type *>(funVoidPtrVoidTy)->getPointerTo(),
    348                                                                          voidPtrTy, nullptr));
    349     pthreadCreateFunc->setCallingConv(llvm::CallingConv::C);
    350     Function * pthreadJoinFunc = cast<Function>(mod->getOrInsertFunction("pthread_join",
    351                                                                        int32ty,
    352                                                                        pthreadTy,
    353                                                                        PointerType::get(int8PtrTy, 0), nullptr));
    354     pthreadJoinFunc->setCallingConv(llvm::CallingConv::C);
    355 
    356     Function * pthreadExitFunc = cast<Function>(mod->getOrInsertFunction("pthread_exit",
    357                                                                        voidTy,
    358                                                                        voidPtrTy, nullptr));
    359     pthreadExitFunc->addFnAttr(llvm::Attribute::NoReturn);
    360     pthreadExitFunc->setCallingConv(llvm::CallingConv::C);
    361 
    362340    if (segmentPipelineParallel){
    363341        generateSegmentParallelPipeline(iBuilder, {&s2pk, &u8u16k, &delK, &p2sk, &stdoutK});
Note: See TracChangeset for help on using the changeset viewer.