uint64_t KVALUE_ToUIntValue(KVALUE* kv) {
int64_t v64;
v64 = KVALUE_ToIntValue(kv);
//
// returning unsigned integer value depending on type
//
switch (kv->kind) {
case INT1_KIND:
return v64;
case INT8_KIND:
return (uint8_t)v64;
case INT16_KIND:
return (uint16_t)v64;
case INT24_KIND:
case INT32_KIND:
return (uint32_t)v64;
case INT64_KIND:
return (uint64_t)v64;
case INT80_KIND:
DEBUG_STDERR("Unsupported type INT80_KIND.");
safe_assert(false);
return v64;
default:
return v64;
}
}
std::string KIND_ToString(int kind) {
std::stringstream s;
switch (kind) {
case PTR_KIND:
s << "[PTR]";
break;
case INT1_KIND:
s << "[INT1]";
break;
case INT8_KIND:
s << "[INT8]";
break;
case INT16_KIND:
s << "[INT16]";
break;
case INT24_KIND:
s << "[INT24]";
break;
case INT32_KIND:
s << "[INT32]";
break;
case INT64_KIND:
s << "[INT64]";
break;
case INT80_KIND:
s << "[INT80]";
break;
case FLP32_KIND:
s << "[FLP32]";
break;
case FLP64_KIND:
s << "[FLP64]";
break;
case FLP80X86_KIND:
s << "[FLP80X86]";
break;
case ARRAY_KIND:
s << "[ARRAY]";
break;
case STRUCT_KIND:
s << "[STRUCT]";
break;
case VOID_KIND:
s << "[VOID]";
break;
default:
DEBUG_STDERR("Unsupported kind value " << kind);
safe_assert(false);
break;
}
return s.str();
}
int64_t KVALUE_ToIntValue(KVALUE* kv) {
int32_t v32;
int32_t* v32Ptr;
int64_t v64;
int64_t* v64Ptr;
//
// truncating 64-bit integer value to 32-bit integer value
//
v64 = kv->value.as_int;
v64Ptr = &v64;
v32Ptr = (int32_t*)v64Ptr;
v32 = *v32Ptr;
//
// returning integer value depending on type
//
switch (kv->kind) {
case INT1_KIND:
return v32 & 0x1;
;
case INT8_KIND:
return v32 & 0x000000FF;
case INT16_KIND:
return v32 & 0x0000FFFF;
case INT24_KIND:
return v32 & 0x00FFFFFF;
case INT32_KIND:
return v32;
case INT64_KIND:
return v64;
case INT80_KIND:
DEBUG_STDERR("Unsupported type INT80_KIND.");
safe_assert(false);
return v64;
default:
return v64;
}
}
std::string SCOPE_ToString(SCOPE scope) {
std::stringstream s;
switch (scope) {
case GLOBAL:
s << "GLOBAL";
break;
case LOCAL:
s << "LOCAL";
break;
case CONSTANT:
s << "CONSTANT";
break;
case REGISTER:
s << "REGISTER";
break;
default:
DEBUG_STDERR("Unsupport scope: " << scope);
safe_assert(false);
}
return s.str();
}
long double KVALUE_ToFlpValue(KVALUE* kv) {
double v64;
v64 = kv->value.as_flp;
//
// returning float value depending on type
//
switch (kv->kind) {
case FLP32_KIND:
return (float)v64;
case FLP64_KIND:
return v64;
case FLP80X86_KIND:
return v64;
case FLP128_KIND:
case FLP128PPC_KIND:
DEBUG_STDERR("Unsupported float type: " << kv->kind);
safe_assert(false);
return v64;
default:
return v64;
}
}
std::string KVALUE_ToString(KVALUE* kv) {
std::stringstream s;
if (kv) {
s << "[INX: " << kv->inx << " ";
switch (kv->kind) {
case PTR_KIND:
s << "PTR: " << kv->value.as_ptr << "]";
break;
case INT1_KIND:
s << "INT1: " << kv->value.as_int << "]";
break;
case INT8_KIND:
s << "INT8: " << kv->value.as_int << "]";
break;
case INT16_KIND:
s << "INT16: " << kv->value.as_int << "]";
break;
case INT24_KIND:
s << "INT24: " << kv->value.as_int << "]";
break;
case INT32_KIND:
s << "INT32: " << kv->value.as_int << "]";
break;
case INT64_KIND:
s << "INT64: " << kv->value.as_int << "]";
break;
case INT80_KIND:
s << "INT80: " << kv->value.as_int << "]";
break;
case FLP32_KIND:
s << "FLP32: " << kv->value.as_flp << "]";
break;
case FLP64_KIND:
s << "FLP64: " << kv->value.as_flp << "]";
break;
case FLP80X86_KIND:
s << "FLP80X86: " << kv->value.as_flp << "]";
break;
case ARRAY_KIND:
s << "ARRAY: " << kv->value.as_flp << "]";
break;
case STRUCT_KIND:
s << "STRUCT: " << kv->value.as_flp << "]";
break;
default:
safe_assert(false);
break;
}
if (kv->isGlobal) {
s << " GLOBAL";
}
s << "]";
} else {
DEBUG_STDERR("KVALUE is NULL.");
safe_assert(false);
}
return s.str();
}
int Parallel::setup() {
/**
* OpenCL initialization.
*/
cl_int status = Simulator::setup();
CheckStatus(status, "Simulator::setup() failed.");
cl_uint numPlatforms;
status = clGetPlatformIDs(0, NULL, &numPlatforms);
CheckStatus(status, "clGetPlatformIDs, fetching number");
DEBUG_STDOUT("Number of platforms: " << numPlatforms);
cl_platform_id platform = NULL;
if (numPlatforms > 0) {
std::unique_ptr<cl_platform_id[]> platforms (new cl_platform_id[numPlatforms]);
status = clGetPlatformIDs(numPlatforms, platforms.get(), NULL);
CheckStatus(status, "clGetPlatformIDs, fetching platforms");
for (unsigned i = 0; i < numPlatforms; ++i) {
char pbuf[100];
status = clGetPlatformInfo(platforms[i],
CL_PLATFORM_VENDOR,
sizeof(pbuf),
pbuf,
NULL);
CheckStatus(status, "clGetPlatformInfo");
}
// Just grab the first platform.
platform = platforms[0];
}
CheckConditional(platform != NULL, "platform == NULL");
cl_uint numDevices;
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 0, NULL, &numDevices);
CheckStatus(status, "clGetDeviceIDs: fetching number");
DEBUG_STDOUT("Number of devices: " << numDevices);
cl_device_id *devices = new cl_device_id[numDevices];
status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, numDevices, devices, NULL);
CheckStatus(status, "clGetDeviceIDs: fetching devices");
int deviceIndex = 0;
for (unsigned i = 0; i < numDevices; ++i) {
char pbuf[100];
status = clGetDeviceInfo(devices[i],
CL_DEVICE_NAME,
sizeof(pbuf),
pbuf,
NULL);
if (!strncmp(pbuf, "ATI", 3)) {
deviceIndex = i;
}
}
/* Create the context. */
context = clCreateContext(0, numDevices, devices, NULL, NULL, &status);
CheckConditional(context != NULL, "clCreateContextFromType");
/* Create command queue */
cl_command_queue_properties prop = CL_QUEUE_PROFILING_ENABLE;
commandQueue = clCreateCommandQueue(context, devices[deviceIndex], prop, &status);
CheckStatus(status, "clCreateCommandQueue");
/* Create a CL program using the kernel source */
SDKFile kernelFile;
std::string kernelPath = getenv("HOME") + std::string("/md-simulator/src/TestKernel.cl");
if(!kernelFile.open(kernelPath.c_str())) {
DEBUG_STDERR("Failed to load kernel file : " << kernelPath);
return MD_FAILURE;
}
const char *source = kernelFile.source().c_str();
size_t sourceSize[] = {strlen(source)};
program = clCreateProgramWithSource(context,
1,
&source,
sourceSize,
&status);
CheckStatus(status, "clCreateProgramWithSource");
/* Create a cl program executable for all the devices specified */
status = clBuildProgram(program,
numDevices,
devices,
NULL,
NULL,
NULL);
if (status != CL_SUCCESS) {
if (status == CL_BUILD_PROGRAM_FAILURE) {
cl_int logStatus;
std::unique_ptr<char[]> buildLog (nullptr);
//char *buildLog = NULL;
size_t buildLogSize = 0;
logStatus = clGetProgramBuildInfo(program,
devices[deviceIndex],
CL_PROGRAM_BUILD_LOG,
buildLogSize,
buildLog.get(),
&buildLogSize);
CheckStatus(logStatus, "clGetProgramBuildInfo");
buildLog = std::unique_ptr<char[]>(new char[buildLogSize]);
if(!buildLog) {
return MD_FAILURE;
}
std::fill_n(buildLog.get(), buildLogSize, 0);
logStatus = clGetProgramBuildInfo(program,
devices[deviceIndex],
CL_PROGRAM_BUILD_LOG,
buildLogSize,
buildLog.get(),
NULL);
CheckStatus(logStatus, "clGetProgramBuildInfo (2)");
DEBUG_STDERR("\n\t\t\tBUILD LOG\n");
DEBUG_STDERR("************************************************\n");
DEBUG_STDERR(buildLog.get());
DEBUG_STDERR("************************************************\n");
}
}
CheckStatus(status, "clBuildProgram");
/* Get a kernel object handle for a kernel with the given name */
kernel = clCreateKernel(program, "computeAccelerations", &status);
CheckStatus(status, "clCreateKernel");
/* Check group size against group size returned by kernel */
status = clGetKernelWorkGroupInfo(kernel,
devices[deviceIndex],
CL_KERNEL_WORK_GROUP_SIZE,
sizeof(size_t),
&kernelWorkGroupSize,
0);
CheckStatus(status, "clGetKernelWorkGroupInfo");
DEBUG_STDOUT("kernelWorkGroupSize: " << kernelWorkGroupSize);
/**
* Initialize some simulator data structures.
*/
global = particleCount * particleCount;
local = particleCount;
if (global * local > kernelWorkGroupSize) {
DEBUG_STDERR("WARNING - global * local > kernelWorkGroupSize; global: " << global << ", local: " << local << ", kernelWorkGroupSize: " << kernelWorkGroupSize);
return MD_FAILURE;
}
// Data holds the molecule positions.
data = std::unique_ptr<float[]> (new float[particleCount * 3]);
// Constants holds simulator constants.
constants = std::unique_ptr<float[]> (new float[NUM_CONSTANTS]);
// Copy constants to buffer;
constants[0] = epsilon;
constants[1] = sigma;
constants[2] = negForceCutoffMinusHalf;
constants[3] = forceCutoffMinusHalf;
constants[4] = wallStiffness;
// Results holds pairwise forces.
results = std::unique_ptr<float[]> (new float[particleCount * particleCount * 3]);
return MD_SUCCESS;
}
