const auto &set = unit.getFunctionSet();
const uint32_t kernelNum = set.size();
if (kernelNum == 0) return true;
-
- // Dummy functions now
for (auto it = set.begin(); it != set.end(); ++it) {
const std::string &name = it->first;
Kernel *kernel = this->compileKernel(name);
kernels.insert(std::make_pair(name, kernel));
}
-
return true;
}
-} /* namespace gbe */
+ static void programDelete(gbe_program gbeProgram) {
+ gbe::Program *program = (gbe::Program*)(gbeProgram);
+ GBE_SAFE_DELETE(program);
+ }
+
+ static uint32_t programGetKernelNum(gbe_program gbeProgram) {
+ if (gbeProgram == NULL) return 0;
+ const gbe::Program *program = (const gbe::Program*) gbeProgram;
+ return program->getKernelNum();
+ }
+
+ static gbe_kernel programGetKernelByName(gbe_program gbeProgram, const char *name) {
+ if (gbeProgram == NULL) return NULL;
+ const gbe::Program *program = (gbe::Program*) gbeProgram;
+ return (gbe_kernel) program->getKernel(std::string(name));
+ }
+
+ static gbe_kernel programGetKernel(const gbe_program gbeProgram, uint32_t ID) {
+ if (gbeProgram == NULL) return NULL;
+ const gbe::Program *program = (gbe::Program*) gbeProgram;
+ return (gbe_kernel) program->getKernel(ID);
+ }
+
+ static const char *kernelGetName(gbe_kernel genKernel) {
+ if (genKernel == NULL) return NULL;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getName();
+ }
+
+ static const char *kernelGetCode(gbe_kernel genKernel) {
+ if (genKernel == NULL) return NULL;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getCode();
+ }
+
+ static size_t kernelGetCodeSize(gbe_kernel genKernel) {
+ if (genKernel == NULL) return 0u;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getCodeSize();
+ }
+
+ static uint32_t kernelGetArgNum(gbe_kernel genKernel) {
+ if (genKernel == NULL) return 0u;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getArgNum();
+ }
+
+ static uint32_t kernelGetArgSize(gbe_kernel genKernel, uint32_t argID) {
+ if (genKernel == NULL) return 0u;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getArgSize(argID);
+ }
-/////////////////////////////////////////////////////////////////////////////
-// Common C interface for both Gen and simulator
-/////////////////////////////////////////////////////////////////////////////
-static void GBEProgramDelete(gbe_program gbeProgram) {
- gbe::Program *program = (gbe::Program*)(gbeProgram);
- GBE_SAFE_DELETE(program);
-}
-
-static uint32_t GBEProgramGetKernelNum(gbe_program gbeProgram) {
- if (gbeProgram == NULL) return 0;
- const gbe::Program *program = (const gbe::Program*) gbeProgram;
- return program->getKernelNum();
-}
-
-static gbe_kernel GBEProgramGetKernelByName(gbe_program gbeProgram, const char *name) {
- if (gbeProgram == NULL) return NULL;
- const gbe::Program *program = (gbe::Program*) gbeProgram;
- return (gbe_kernel) program->getKernel(std::string(name));
-}
-
-static gbe_kernel GBEProgramGetKernel(const gbe_program gbeProgram, uint32_t ID) {
- if (gbeProgram == NULL) return NULL;
- const gbe::Program *program = (gbe::Program*) gbeProgram;
- return (gbe_kernel) program->getKernel(ID);
-}
-
-static const char *GBEKernelGetName(gbe_kernel genKernel) {
- if (genKernel == NULL) return NULL;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getName();
-}
-
-static const char *GBEKernelGetCode(gbe_kernel genKernel) {
- if (genKernel == NULL) return NULL;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getCode();
-}
-
-static size_t GBEKernelGetCodeSize(gbe_kernel genKernel) {
- if (genKernel == NULL) return 0u;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getCodeSize();
-}
-
-static uint32_t GBEKernelGetArgNum(gbe_kernel genKernel) {
- if (genKernel == NULL) return 0u;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getArgNum();
-}
-
-static uint32_t GBEKernelGetArgSize(gbe_kernel genKernel, uint32_t argID) {
- if (genKernel == NULL) return 0u;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getArgSize(argID);
-}
-
-static gbe_arg_type GBEKernelGetArgType(gbe_kernel genKernel, uint32_t argID) {
- if (genKernel == NULL) return GBE_ARG_INVALID;
- const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
- return kernel->getArgType(argID);
-}
-
-static uint32_t GBEKernelGetSIMDWidth(gbe_kernel kernel) {
- return 16u;
-}
-
-static uint32_t GBEKernelGetRequiredWorkGroupSize(gbe_kernel kernel, uint32_t dim) {
- return 0u;
-}
+ static gbe_arg_type kernelGetArgType(gbe_kernel genKernel, uint32_t argID) {
+ if (genKernel == NULL) return GBE_ARG_INVALID;
+ const gbe::Kernel *kernel = (const gbe::Kernel*) genKernel;
+ return kernel->getArgType(argID);
+ }
+
+ static uint32_t kernelGetSIMDWidth(gbe_kernel kernel) {
+ return 16u;
+ }
+
+ static uint32_t kernelGetRequiredWorkGroupSize(gbe_kernel kernel, uint32_t dim) {
+ return 0u;
+ }
+} /* namespace gbe */
GBE_EXPORT_SYMBOL gbe_program_new_from_source_cb *gbe_program_new_from_source = NULL;
GBE_EXPORT_SYMBOL gbe_program_new_from_binary_cb *gbe_program_new_from_binary = NULL;
struct CallBackInitializer
{
CallBackInitializer(void) {
- gbe_program_delete = GBEProgramDelete;
- gbe_program_get_kernel_num = GBEProgramGetKernelNum;
- gbe_program_get_kernel_by_name = GBEProgramGetKernelByName;
- gbe_program_get_kernel = GBEProgramGetKernel;
- gbe_kernel_get_name = GBEKernelGetName;
- gbe_kernel_get_code = GBEKernelGetCode;
- gbe_kernel_get_code_size = GBEKernelGetCodeSize;
- gbe_kernel_get_arg_num = GBEKernelGetArgNum;
- gbe_kernel_get_arg_size = GBEKernelGetArgSize;
- gbe_kernel_get_arg_type = GBEKernelGetArgType;
- gbe_kernel_get_simd_width = GBEKernelGetSIMDWidth;
- gbe_kernel_get_required_work_group_size = GBEKernelGetRequiredWorkGroupSize;
+ gbe_program_delete = gbe::programDelete;
+ gbe_program_get_kernel_num = gbe::programGetKernelNum;
+ gbe_program_get_kernel_by_name = gbe::programGetKernelByName;
+ gbe_program_get_kernel = gbe::programGetKernel;
+ gbe_kernel_get_name = gbe::kernelGetName;
+ gbe_kernel_get_code = gbe::kernelGetCode;
+ gbe_kernel_get_code_size = gbe::kernelGetCodeSize;
+ gbe_kernel_get_arg_num = gbe::kernelGetArgNum;
+ gbe_kernel_get_arg_size = gbe::kernelGetArgSize;
+ gbe_kernel_get_arg_type = gbe::kernelGetArgType;
+ gbe_kernel_get_simd_width = gbe::kernelGetSIMDWidth;
+ gbe_kernel_get_required_work_group_size = gbe::kernelGetRequiredWorkGroupSize;
const char *run_it = getenv("OCL_SIMULATOR");
if (run_it != NULL && !strcmp(run_it, "2"))
simSetupCallBacks();
GBE_ARG_INVALID = 0xffffffff
};
+/*! Constant buffer values (ie values to setup in the constant buffer) */
+enum gbe_curbe_value {
+ GBE_CURBE_LOCAL_SIZE_X = 0, /* Order matters! */
+ GBE_CURBE_LOCAL_SIZE_Y,
+ GBE_CURBE_LOCAL_SIZE_Z,
+ GBE_CURBE_GLOBAL_SIZE_X,
+ GBE_CURBE_GLOBAL_SIZE_Y,
+ GBE_CURBE_GLOBAL_SIZE_Z,
+ GBE_CURBE_GLOBAL_OFFSET_X,
+ GBE_CURBE_GLOBAL_OFFSET_Y,
+ GBE_CURBE_GLOBAL_OFFSET_Z,
+ GBE_CURBE_IMAGE_WIDTH,
+ GBE_CURBE_IMAGE_HEIGHT,
+ GBE_CURBE_IMAGE_DEPTH,
+ GBE_CURBE_BUFFER_ADDRESS
+};
+
/*! Create a new program from the given source code (zero terminated string) */
typedef gbe_program (gbe_program_new_from_source_cb)(const char *source);
extern gbe_program_new_from_source_cb *gbe_program_new_from_source;
namespace gbe {
+ /*! Info for the kernel argument */
struct KernelArgument {
gbe_arg_type type; //!< Pointer, structure, regular value?
size_t size; //!< Size of each argument
else
return args[argID].type;
}
+ /*! Return where to put the address of a buffer argument */
+
protected:
friend class Program; //!< Owns the kernels
const std::string name; //!< Kernel name
#include <cstring>
namespace gbe {
-namespace gen {
GenKernel::GenKernel(const std::string &name) :
Kernel(name), insns(NULL), insnNum(0)
return kernel;
}
-} /* namespace gen */
-} /* namespace gbe */
-
-/////////////////////////////////////////////////////////////////////////////
-// C interface for the specific Gen ISA compilation path
-/////////////////////////////////////////////////////////////////////////////
-static gbe_program GenProgramNewFromSource(const char *source) {
- NOT_IMPLEMENTED;
- return NULL;
-}
+ static gbe_program genProgramNewFromSource(const char *source) {
+ NOT_IMPLEMENTED;
+ return NULL;
+ }
-static gbe_program GenProgramNewFromBinary(const char *binary, size_t size) {
- NOT_IMPLEMENTED;
- return NULL;
-}
+ static gbe_program genProgramNewFromBinary(const char *binary, size_t size) {
+ NOT_IMPLEMENTED;
+ return NULL;
+ }
-static gbe_program GenProgramNewFromLLVM(const char *fileName,
- size_t stringSize,
- char *err,
- size_t *errSize)
-{
- using namespace gbe::gen;
- GenProgram *program = GBE_NEW(GenProgram);
- std::string error;
+ static gbe_program genProgramNewFromLLVM(const char *fileName,
+ size_t stringSize,
+ char *err,
+ size_t *errSize)
+ {
+ using namespace gbe;
+ GenProgram *program = GBE_NEW(GenProgram);
+ std::string error;
- // Try to compile the program
- if (program->buildFromLLVMFile(fileName, error) == false) {
- if (err != NULL && errSize != NULL && stringSize > 0u) {
- const size_t msgSize = std::min(error.size(), stringSize-1u);
- std::memcpy(err, error.c_str(), msgSize);
- *errSize = error.size();
+ // Try to compile the program
+ if (program->buildFromLLVMFile(fileName, error) == false) {
+ if (err != NULL && errSize != NULL && stringSize > 0u) {
+ const size_t msgSize = std::min(error.size(), stringSize-1u);
+ std::memcpy(err, error.c_str(), msgSize);
+ *errSize = error.size();
+ }
+ GBE_DELETE(program);
+ return NULL;
}
- GBE_DELETE(program);
- return NULL;
+ // Everything run fine
+ return (gbe_program) program;
}
-
- // Everything run fine
- return (gbe_program) program;
-}
+} /* namespace gbe */
void genSetupCallBacks(void)
{
- gbe_program_new_from_source = GenProgramNewFromSource;
- gbe_program_new_from_binary = GenProgramNewFromBinary;
- gbe_program_new_from_llvm = GenProgramNewFromLLVM;
+ gbe_program_new_from_source = gbe::genProgramNewFromSource;
+ gbe_program_new_from_binary = gbe::genProgramNewFromBinary;
+ gbe_program_new_from_llvm = gbe::genProgramNewFromLLVM;
}
#include "backend/gen/brw_structs.h"
namespace gbe {
-namespace gen {
/*! Describe a compiled kernel */
struct GenKernel : public Kernel
GBE_STRUCT(GenProgram); //!< Use gbe allocators
};
-} /* namespace gen */
} /* namespace gbe */
#endif /* __GBE_GEN_PROGRAM_HPP__ */
#include "dlfcn.h"
namespace gbe {
-namespace sim {
SimKernel::SimKernel(const std::string &name) :
Kernel(name), fn(NULL), handle(NULL) {}
Kernel *SimProgram::compileKernel(const std::string &name) {
SimKernel *kernel = GBE_NEW(SimKernel, name);
char srcStr[L_tmpnam+1], libStr[L_tmpnam+1];
- const std::string srcName = std::string(tmpnam_r(srcStr)) + ".cpp"; // unsecure but we don't care
- const std::string libName = std::string(tmpnam_r(libStr)) + ".so"; // unsecure but we don't care
+ const std::string srcName = std::string(tmpnam_r(srcStr)) + ".cpp"; /* unsecure but we don't care */
+ const std::string libName = std::string(tmpnam_r(libStr)) + ".so"; /* unsecure but we don't care */
- // Output the code first
+ /* Output the code first */
std::ofstream ostream;
ostream.open(srcName);
ostream << "extern \"C\" void " << name << "() {}" << std::endl;
ostream.close();
- // Compile the function
+ /* Compile the function */
std::cout << srcName << " " << libName;
std::string compileCmd = "g++ -shared -O3 -o ";
compileCmd += libName;
if (UNLIKELY(system(compileCmd.c_str()) != 0))
FATAL("Simulation program compilation failed");
- // Load it and get the function pointer
+ /* Load it and get the function pointer */
kernel->handle = dlopen(libName.c_str(), RTLD_NOW);
if (UNLIKELY(kernel->handle == NULL))
FATAL("Failed to open the compiled shared object");
return kernel;
}
-} /* namespace sim */
-} /* namespace gen */
-
-static gbe_program SimProgramNewFromSource(const char *source) {
- NOT_IMPLEMENTED;
- return NULL;
-}
-
-static gbe_program SimProgramNewFromBinary(const char *binary, size_t size) {
- NOT_IMPLEMENTED;
- return NULL;
-}
+ static gbe_program simProgramNewFromSource(const char *source) {
+ NOT_IMPLEMENTED;
+ return NULL;
+ }
-static gbe_program SimProgramNewFromLLVM(const char *fileName,
- size_t stringSize,
- char *err,
- size_t *errSize)
-{
- using namespace gbe::sim;
- SimProgram *program = GBE_NEW(SimProgram);
- std::string error;
+ static gbe_program simProgramNewFromBinary(const char *binary, size_t size) {
+ NOT_IMPLEMENTED;
+ return NULL;
+ }
- // Try to compile the program
- if (program->buildFromLLVMFile(fileName, error) == false) {
- if (err != NULL && errSize != NULL && stringSize > 0u) {
- const size_t msgSize = std::min(error.size(), stringSize-1u);
- std::memcpy(err, error.c_str(), msgSize);
- *errSize = error.size();
+ static gbe_program simProgramNewFromLLVM(const char *fileName,
+ size_t stringSize,
+ char *err,
+ size_t *errSize)
+ {
+ using namespace gbe;
+ SimProgram *program = GBE_NEW(SimProgram);
+ std::string error;
+ /* Try to compile the program */
+ if (program->buildFromLLVMFile(fileName, error) == false) {
+ if (err != NULL && errSize != NULL && stringSize > 0u) {
+ const size_t msgSize = std::min(error.size(), stringSize-1u);
+ std::memcpy(err, error.c_str(), msgSize);
+ *errSize = error.size();
+ }
+ GBE_DELETE(program);
+ return NULL;
}
- GBE_DELETE(program);
- return NULL;
+ /* Everything run fine */
+ return (gbe_program) program;
}
- // Everything run fine
- return (gbe_program) program;
-}
+} /* namespace gen */
void simSetupCallBacks(void)
{
- gbe_program_new_from_source = SimProgramNewFromSource;
- gbe_program_new_from_binary = SimProgramNewFromBinary;
- gbe_program_new_from_llvm = SimProgramNewFromLLVM;
+ gbe_program_new_from_source = gbe::simProgramNewFromSource;
+ gbe_program_new_from_binary = gbe::simProgramNewFromBinary;
+ gbe_program_new_from_llvm = gbe::simProgramNewFromLLVM;
}
#include "backend/gen/brw_structs.h"
namespace gbe {
-namespace sim {
/*! We basically create one real C function for each */
typedef void (SimKernelCallBack)();
virtual ~SimProgram(void);
/*! Implements base class */
virtual Kernel *compileKernel(const std::string &name);
- GBE_STRUCT(SimProgram); //!< Use gbe allocators
+ GBE_STRUCT(SimProgram); //!< Use gbe allocators
};
-} /* namespace sim */
} /* namespace gbe */
#endif /* __GBE_SIM_PROGRAM_HPP__ */
projects / contrib / beignet.git / commitdiff