#include "llvm/ADT/STLExtras.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/ExecutionEngine/Interpreter.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/TargetSelect.h"
#include <iostream>
#include <pthread.h>
using namespace llvm;
static Function* createAdd1(Module *M) {
Function *Add1F =
cast<Function>(M->getOrInsertFunction("add1",
Type::getInt32Ty(M->getContext()),
Type::getInt32Ty(M->getContext()),
nullptr));
BasicBlock *BB = BasicBlock::Create(M->getContext(), "EntryBlock", Add1F);
Value *One = ConstantInt::get(Type::getInt32Ty(M->getContext()), 1);
assert(Add1F->arg_begin() != Add1F->arg_end()); Argument *ArgX = &*Add1F->arg_begin(); ArgX->setName("AnArg");
Instruction *Add = BinaryOperator::CreateAdd(One, ArgX, "addresult", BB);
ReturnInst::Create(M->getContext(), Add, BB);
return Add1F;
}
static Function *CreateFibFunction(Module *M) {
Function *FibF =
cast<Function>(M->getOrInsertFunction("fib",
Type::getInt32Ty(M->getContext()),
Type::getInt32Ty(M->getContext()),
nullptr));
BasicBlock *BB = BasicBlock::Create(M->getContext(), "EntryBlock", FibF);
Value *One = ConstantInt::get(Type::getInt32Ty(M->getContext()), 1);
Value *Two = ConstantInt::get(Type::getInt32Ty(M->getContext()), 2);
Argument *ArgX = &*FibF->arg_begin(); ArgX->setName("AnArg");
BasicBlock *RetBB = BasicBlock::Create(M->getContext(), "return", FibF);
BasicBlock* RecurseBB = BasicBlock::Create(M->getContext(), "recurse", FibF);
Value *CondInst = new ICmpInst(*BB, ICmpInst::ICMP_SLE, ArgX, Two, "cond");
BranchInst::Create(RetBB, RecurseBB, CondInst, BB);
ReturnInst::Create(M->getContext(), One, RetBB);
Value *Sub = BinaryOperator::CreateSub(ArgX, One, "arg", RecurseBB);
Value *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB);
Sub = BinaryOperator::CreateSub(ArgX, Two, "arg", RecurseBB);
Value *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB);
Value *Sum =
BinaryOperator::CreateAdd(CallFibX1, CallFibX2, "addresult", RecurseBB);
ReturnInst::Create(M->getContext(), Sum, RecurseBB);
return FibF;
}
struct threadParams {
ExecutionEngine* EE;
Function* F;
int value;
};
class WaitForThreads
{
public:
WaitForThreads()
{
n = 0;
waitFor = 0;
int result = pthread_cond_init( &condition, nullptr );
assert( result == 0 );
result = pthread_mutex_init( &mutex, nullptr );
assert( result == 0 );
}
~WaitForThreads()
{
int result = pthread_cond_destroy( &condition );
(void)result;
assert( result == 0 );
result = pthread_mutex_destroy( &mutex );
assert( result == 0 );
}
void block()
{
int result = pthread_mutex_lock( &mutex );
(void)result;
assert( result == 0 );
n ++;
assert( waitFor == 0 || n <= waitFor );
if ( waitFor > 0 && n == waitFor )
{
std::cout << "Unblocking threads from block()" << std::endl;
unblockThreads();
}
else
{
result = pthread_cond_wait( &condition, &mutex );
assert( result == 0 );
}
result = pthread_mutex_unlock( &mutex );
assert( result == 0 );
}
void releaseThreads( size_t num )
{
int result = pthread_mutex_lock( &mutex );
(void)result;
assert( result == 0 );
if ( n >= num ) {
std::cout << "Unblocking threads from releaseThreads()" << std::endl;
unblockThreads();
}
else
{
waitFor = num;
pthread_cond_wait( &condition, &mutex );
}
result = pthread_mutex_unlock( &mutex );
assert( result == 0 );
}
private:
void unblockThreads()
{
n = 0;
waitFor = 0;
int result = pthread_cond_broadcast( &condition );
(void)result;
assert(result == 0);
}
size_t n;
size_t waitFor;
pthread_cond_t condition;
pthread_mutex_t mutex;
};
static WaitForThreads synchronize;
void* callFunc( void* param )
{
struct threadParams* p = (struct threadParams*) param;
std::vector<GenericValue> Args(1);
Args[0].IntVal = APInt(32, p->value);
synchronize.block(); GenericValue gv = p->EE->runFunction(p->F, Args);
return (void*)(intptr_t)gv.IntVal.getZExtValue();
}
int main() {
InitializeNativeTarget();
LLVMContext Context;
std::unique_ptr<Module> Owner = make_unique<Module>("test", Context);
Module *M = Owner.get();
Function* add1F = createAdd1( M );
Function* fibF = CreateFibFunction( M );
ExecutionEngine* EE = EngineBuilder(std::move(Owner)).create();
struct threadParams add1 = { EE, add1F, 1000 };
struct threadParams fib1 = { EE, fibF, 39 };
struct threadParams fib2 = { EE, fibF, 42 };
pthread_t add1Thread;
int result = pthread_create( &add1Thread, nullptr, callFunc, &add1 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
pthread_t fibThread1;
result = pthread_create( &fibThread1, nullptr, callFunc, &fib1 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
pthread_t fibThread2;
result = pthread_create( &fibThread2, nullptr, callFunc, &fib2 );
if ( result != 0 ) {
std::cerr << "Could not create thread" << std::endl;
return 1;
}
synchronize.releaseThreads(3);
void* returnValue;
result = pthread_join( add1Thread, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Add1 returned " << intptr_t(returnValue) << std::endl;
result = pthread_join( fibThread1, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Fib1 returned " << intptr_t(returnValue) << std::endl;
result = pthread_join( fibThread2, &returnValue );
if ( result != 0 ) {
std::cerr << "Could not join thread" << std::endl;
return 1;
}
std::cout << "Fib2 returned " << intptr_t(returnValue) << std::endl;
return 0;
}