///////////////////////////////////////////////////////////////////////////
////scvalConvToInt/////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToInt(_value * val)
{
if (scvalGetValType(val) == valINT
|| scvalGetValType(val) == valPOINTER) return;
deb0("ToINT\n");
if (scvalIsImmidiate(val)) {
switch (scvalGetValType(val)) {
case valDOUBLE:
val->adr.val.ival = (int) val->adr.val.dval;
break;
case valFLOAT:
val->adr.val.fval = (float) val->adr.val.dval; //???
break;
case valFIXED:
val->adr.val.ival >>= 16;
break;
default:
scError(scvalConvToInt);
}
scAssert(scvalConvToInt,
(val->type.flags & typTYPE) == typPREDEFINED);
(valTYPE) val->type.main = valINT;
} else {
///////////////////////////////////////////////////////////////////////////
////scvalConvToFloat///////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalConvToFloat(_value * val)
{
if (scvalGetValType(val) == valFLOAT)
return;
deb0("ToFloat\n");
if (scvalIsImmidiate(val)) {
switch (scvalGetValType(val)) {
case valDOUBLE:
val->adr.val.fval = (float) val->adr.val.dval;
break;
case valINT:
val->adr.val.fval = (float) val->adr.val.ival;
break;
case valFIXED:
val->adr.val.fval = (float) (val->adr.val.ival / 65536.0);
break;
default:
// (float)val->val=val->val;
// val->vald=val->val;
scError(scvalConvToFloat);
}
scAssert(scvalConvToFloat,
(val->type.flags & typTYPE) == typPREDEFINED);
(valTYPE) val->type.main = valFLOAT;
} else {
_value v1 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
}
, { /*type */ typPREDEFINED, NULL, (void *) valFLOAT}, NULL };
switch (scvalGetValType(val)) {
case valDOUBLE:
Gen_Opcode(opvcpuDFLT, &v1, val);
*val = v1;
break;
case valSHORT:
case valCHAR:
case valFIXED:
case valINT:
scvalConvToDouble(val);
scvalConvToFloat(val);
return;
break;
default:
serr2(scErr_Cast, illegal_type_conversion, " to float");
}
}
}
///////////////////////////////////////////////////////////////////////////
////scvalImmidiateValue////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
double scvalImmidiateValue(_value * v)
{
switch ((int) scvalGetValType(v)) {
case valINT:
case valSHORT:
case valCHAR:
return (double) v->adr.val.ival;
case valFLOAT:
case valDOUBLE:
case valFIXED:
return v->adr.val.dval;
}
scError(scvalImmidiateValue);
}
///////////////////////////////////////////////////////////////////////////
////sctypGetValType////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
valTYPE sctypGetValType(scType * type)
{
// deb("sctypSizeOf(where=%s)",TYPESTR);
scAssert(sctypGetValType, type);
if (TYPESTR && TYPESTR[0]) {
/* if (TYPESTR[0]=='&')//reference
{int i=0;i=1/i;}
scAssert(sctypGetValType,TYPESTR[0]!='&');*/
if (TYPESTR[0] == '&') //reference
{
char *cq = TYPESTR;
valTYPE i;
TYPESTR++;
i = sctypGetValType(type);
TYPESTR = cq;
return i;
}
if (TYPESTR[0] == '(') //function
{
int x;
char *c = type->params;
while (*type->params++ != ')'); //omit parameter list
if (!*type->params)
type->params = NULL;
x = sctypGetValType(type);
type->params = c;
return x;
}
if (TYPESTR[0] == '*' || TYPESTR[0] == '[')
return valPOINTER; //pointer
}
//no params
switch (type->flags & typTYPE) {
case (typSTRUCT):
return valSTRUCT;
case (typSCRIPT):
return valSCRIPT;
case (typPREDEFINED):
return (int) type->main;
case (typUSERDEFINED):
// *type=type->main->type;
// return sctypGetValType(type);
return sctypGetValType(&type->main->type);
}
deb1("flags=%d", type->flags & typTYPE);
deb1("flags=%d", type->flags);
// type->flags/=0;
scError(sctypGetValType);
}
static void
NotifyCallback(
const char *message, const void *handle, size_t handle_size, void *user_data)
{
sc_session s = (sc_session)user_data;
scError(s, CL_INVALID_VALUE, "Notified of unexpected error: %s\n", message);
if (handle_size > 0)
{
int ii;
scWarning(s, " %d bytes of vendor data.", handle_size);
for (ii = 0; ii < handle_size; ii++)
{
char c = ((const char *) handle)[ii];
if (ii % 10 == 0) {
scWarning(s, "\n %3d:", ii);
}
scWarning(s, " 0x%02x %c", c, isprint(c) ? c : '.');
}
scWarning(s, "\n");
}
}
static sc_status
SetupOpenCLSessionForDeviceType(
sc_session handle,
sc_device_type device_type,
sc_uint device_count)
{
sc_status status = 0;
cl_int system_status = 0;
cl_device_type system_device_type = 0;
cl_uint system_device_count = 0;
cl_uint system_platform_count = 0;
cl_device_id *system_device_list = 0;
cl_platform_id system_platform = 0;
size_t return_size = 0;
sc_session_t *session = (sc_session_t*)handle;
system_status = clGetPlatformIDs(1, &system_platform, &system_platform_count);
if (system_status != CL_SUCCESS || system_platform_count < 1)
{
scError(NULL, SC_INVALID_PLATFORM, "Failed to locate platform!\n");
return SC_INVALID_PLATFORM;
}
system_device_type = GetOpenCLDeviceType(device_type, &status);
if (status != CL_SUCCESS)
{
scError(NULL, SC_INVALID_DEVICE_TYPE, "Invalid compute device type specified!\n");
return SC_INVALID_DEVICE_TYPE;
}
system_status = clGetDeviceIDs(system_platform, system_device_type, 0, NULL, &system_device_count);
if (system_status != CL_SUCCESS || system_device_count < 1)
{
scError(NULL, SC_DEVICE_NOT_AVAILABLE, "Failed to locate compute device!\n");
return SC_DEVICE_NOT_AVAILABLE;
}
if(device_count)
system_device_count = system_device_count > device_count ? device_count : system_device_count;
system_device_list = scAllocate(NULL, sizeof(cl_device_id) * device_count);
memset(system_device_list, 0, sizeof(cl_device_id) * device_count);
system_status = clGetDeviceIDs(system_platform, system_device_type, system_device_count, system_device_list, &system_device_count);
if (system_status != CL_SUCCESS)
{
scError(NULL, SC_DEVICE_NOT_AVAILABLE, "Failed to locate compute device!\n");
return SC_DEVICE_NOT_AVAILABLE;
}
session->context = clCreateContext(NULL, system_device_count, system_device_list, NotifyCallback, session, &system_status);
if (!session->context)
{
scError(handle, SC_INVALID_CONTEXT, "Failed to create compute context!\n");
return SC_INVALID_CONTEXT;
}
session->platform = system_platform;
system_status = clGetContextInfo(session->context, CL_CONTEXT_DEVICES, sizeof(cl_device_id) * system_device_count, system_device_list, &return_size);
if(system_status != CL_SUCCESS || return_size < 1)
{
scError(handle, SC_INVALID_DEVICE, "Failed to retrieve compute devices for context!\n");
return SC_INVALID_DEVICE;
}
session->devices = system_device_list;
session->units = system_device_count;
session->queues = scAllocate(handle, sizeof(cl_command_queue) * session->units);
if(!session->queues)
{
scError(handle, SC_OUT_OF_HOST_MEMORY, "Failed to allocate command queues!\n");
return SC_OUT_OF_HOST_MEMORY;
}
for(sc_uint i = 0; i < session->units; i++)
{
cl_char vendor_name[256] = {0};
cl_char device_name[256] = {0};
system_status = clGetDeviceInfo(session->devices[i], CL_DEVICE_VENDOR, sizeof(vendor_name), vendor_name, &return_size);
system_status|= clGetDeviceInfo(session->devices[i], CL_DEVICE_NAME, sizeof(device_name), device_name, &return_size);
if (system_status != CL_SUCCESS)
{
scError(NULL, SC_INVALID_DEVICE_INFO, "Failed to retrieve device info!\n");
return SC_INVALID_DEVICE_INFO;
}
scInfo(handle, "Adding device '%s' '%s' to compute session.\n", vendor_name, device_name);
session->queues[i] = clCreateCommandQueue(session->context, session->devices[i], 0, &system_status);
if (!session->queues[i])
{
scError(handle, SC_INVALID_COMMAND_QUEUE, "Failed to create a command queue!\n");
return SC_INVALID_COMMAND_QUEUE;
}
}
session->programs = scCreateMap(handle, SC_DEFAULT_MAP_SIZE);
session->kernels = scCreateMap(handle, SC_DEFAULT_MAP_SIZE);
session->mem = scCreateMap(handle, SC_DEFAULT_MAP_SIZE);
session->valid = SC_TRUE;
return SC_SUCCESS;
}
///////////////////////////////////////////////////////////////////////////
////scvalPutToRegister/////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
void scvalPutToRegister(_value * val, int freeit)
{
if (val->adr.flags & adrADDRESS) { //address we have here
scvalGetAddress(val, 3); //get rid of adrADDRESS
return;
}
if (val->adr.flags & adrPOINTER) {
// _value v2={{/*ADDRESS*/0,adrREGISTER,{0}},val->type,val->sym};
_value v2 = { { /*ADDRESS*/ 0,
adrREGISTER, {0}
}
,
{val->type.flags, val->type.params, val->type.main}
,
val->sym
};
if (val->adr.flags & adrIMPORTED) {
v2.adr.address = scvalFindFreeRegister(val);
Gen_Opcode(opvcpuMOV, &v2, val);
// val->adr.flags-=adrIMPORTED;
// val->adr.flags|=adrCPU;
val->adr = v2.adr;
val->adr.flags |= adrCPU;
return;
}
switch (scvalGetValType(val)) {
case valCHAR:
case valSHORT:
case valINT:
case valFIXED:
case valPOINTER:
v2.adr.address = scvalFindFreeRegister(val);
Gen_Opcode(opvcpuMOV, &v2, val); //???
break;
case valDOUBLE:
v2.adr.address = scvalFindFreeDoubleRegister(val);
// (int)v2.type.main=valDOUBLE;
Gen_Opcode(opvcpuMOV, &v2, val); //DMOV ???
break;
case valFLOAT:
v2.adr.address = scvalFindFreeDoubleRegister(val);
(int) v2.type.main = valDOUBLE;
Gen_Opcode(opvcpuFDBL, &v2, val);
break;
default:
scError(scvalPutToRegister);
v2.adr.address = scvalFindFreeRegister(val);
// v2.type.main=valINT;
Gen_Opcode(opvcpuMOV, &v2, val);
}
if (freeit)
scvalFreeValue(val);
*val = v2;
} else if (val->adr.flags & adrREGISTER) //already register
{
if (val->adr.address >= 240) //special register
{
_value v2;
scvalSetRegister(&v2, valINT, scvalFindFreeRegister(val));
Gen_Opcode(opvcpuMOV, &v2, val);
*val = v2;
return;
}
if (!act.registers[val->adr.address].used) //apply changes to the register list
act.registers[val->adr.address].used = val;
if (scvalSizeOf(val) == 8)
if (!act.registers[val->adr.address + 1].used)
act.registers[val->adr.address + 1].used = val;
return;
} else if (val->adr.flags & adrIMMIDIATE) //numer
{
_value v2 = { { /*ADDRESS*/ 0, adrREGISTER, {0}
}
, { /*type */ typPREDEFINED, NULL, (scSymbol *) valINT}
, NULL };
switch (scvalGetValType(val)) {
case valFIXED:
v2.adr.address = scvalFindFreeRegister(val);
v2.type.flags = typPREDEFINED;
(valTYPE) v2.type.main = valFIXED;
Gen_Opcode(opvcpuMOV, &v2, val);
break;
case valDOUBLE:
v2.adr.address = scvalFindFreeDoubleRegister(val);
v2.type.flags = typPREDEFINED;
(valTYPE) v2.type.main = valDOUBLE;
// v2.type.flags=valDOUBLE;
Gen_Opcode(opvcpuMOV, &v2, val); //DMOV ???
break;
default:
v2.adr.address = scvalFindFreeRegister(val);
v2.type.flags = typPREDEFINED;
(valTYPE) v2.type.main = valINT;
// v2.type.flags=valINT;
Gen_Opcode(opvcpuMOV, &v2, val);
}
val->adr = v2.adr;
}
}
