string APSRack::get_deviceSerial(const int & deviceID) {
// get current number of devices
get_num_devices();
// Get serials from FTDI layer to check for change in devices
vector<string> testSerials;
FTDI::get_device_serials(testSerials);
// match serials for each device id to make sure mapping of device count to serial
// number is still correct
// if serial number is different re-enumerate
for(unsigned int cnt = 0; cnt < testSerials.size(); cnt++) {
if (testSerials[cnt].compare(deviceSerials_[cnt]) != 0) {
FILE_LOG(logDEBUG) << testSerials[cnt] << " does not match " << deviceSerials_[cnt] << " re-enumerating.";
update_device_enumeration();
break;
}
}
// test to make sure ID is valid relative to vector size
if (static_cast<size_t>(deviceID) > deviceSerials_.size()) {
return "InvalidID";
}
return deviceSerials_[deviceID];
}
void handle_device_name_order()
{
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
const uint8_t device_type = parameter_value[0];
const uint8_t device_number = parameter_value[1];
uint8_t num_devices = get_num_devices(device_type);
if (device_number >= num_devices)
{
if (num_devices < 0)
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
else
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER,0);
return;
}
generate_response_start(RSP_OK);
char *response_data_buf = (char *)generate_response_data_ptr();
uint8_t response_data_buf_len = generate_response_data_len();
int8_t length;
if ((length = NVConfigStore::GetDeviceName(device_type, device_number, response_data_buf, response_data_buf_len)) > 0)
generate_response_data_addlen(length);
generate_response_send();
}
cl_uint get_total_num_devices() {
cl_uint count_devices = 0;
cl_uint num_platforms = get_num_opencl_platforms();
cl_platform_id *platforms =
(cl_platform_id *)malloc(sizeof(cl_platform_id) * num_platforms);
CHECK_ALLOC(platforms);
CHECK(clGetPlatformIDs(num_platforms, platforms, NULL));
for (cl_uint platform_index = 0; platform_index < num_platforms;
platform_index++) {
count_devices += get_num_devices(platforms[platform_index]);
}
free(platforms);
return count_devices;
}
int main(int argc, char** argv)
{
cl_device_id dev;
int i, j;
unsigned long res;
cl_runtime rt = new_cl_runtime(false);
for(i = 0; i < get_num_platforms(); i++)
{
for(j = 0; j < get_num_devices(i); j++)
{
dev = get_device(rt, i, j);
print_device_info(dev, false);
clGetDeviceInfo(dev, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(cl_ulong), &res, NULL);
printf("---\nTimer resolution: %lu\n---\n", res);
}
}
delete_cl_runtime(rt);
return 0;
}
void handle_device_count_order()
{
if (parameter_length < 1)
{
send_insufficient_bytes_error_response(1);
return;
}
const uint8_t device_type = parameter_value[0];
uint8_t num_devices = get_num_devices(device_type);
if (num_devices < 0)
{
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
return;
}
generate_response_start(RSP_OK,1);
generate_response_data_addbyte(num_devices);
generate_response_send();
}
void test_platforms()
{
int i, j;
char desc[256];
struct cl_exec exec = { 0, 0, 1 };
//Initialize the runtime
cl_runtime rt = new_cl_runtime(false);
printf("Testing %d platforms\n\n", get_num_platforms());
for(i = 0; i < get_num_platforms(); i++)
{
exec.platform = i;
clGetPlatformInfo(get_platform(rt, i), CL_PLATFORM_NAME, sizeof(desc), desc, NULL);
printf("Testing devices for %s platform\n", desc);
for(j = 0; j < get_num_devices(i); j++)
{
exec.device = j;
test_device(rt, exec, get_device(rt, i, j));
}
printf("\n");
}
delete_cl_runtime(rt);
}
void list_devices() {
cl_uint num_platforms = get_num_opencl_platforms();
cl_platform_id *platforms =
(cl_platform_id *)malloc(sizeof(cl_platform_id) * num_platforms);
CHECK(clGetPlatformIDs(num_platforms, platforms, NULL));
int device_index = 0;
for (cl_uint platform_index = 0; platform_index < num_platforms;
platform_index++) {
cl_uint num_devices = get_num_devices(platforms[platform_index]);
printf("Platform %d (%d devices)\n", platform_index, num_devices);
cl_device_id *devices = (cl_device_id *)malloc(sizeof(cl_device_id) *
num_devices);
CHECK(clGetDeviceIDs(platforms[platform_index], CL_DEVICE_TYPE_ALL,
num_devices, devices, NULL));
for (unsigned d = 0; d < num_devices; d++) {
cl_device_id dev = devices[d];
cl_device_type type;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_TYPE, sizeof(type), &type,
NULL));
printf(" Device %d - ", device_index);
if (type == CL_DEVICE_TYPE_GPU) {
printf("GPU");
} else if (type == CL_DEVICE_TYPE_CPU) {
printf("CPU");
} else {
fprintf(stderr, "Unsupported device type in list_devices\n");
exit(1);
}
printf(" - ");
size_t name_len;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_NAME, 0, NULL, &name_len));
char *device_name = (char *)malloc(name_len + 1);
CHECK(clGetDeviceInfo(dev, CL_DEVICE_NAME, name_len, device_name,
NULL));
device_name[name_len] = '\0';
printf("%s\n", device_name);
size_t version_len;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_VERSION, 0, NULL, &version_len));
char *device_version = (char *)malloc(version_len + 1);
CHECK(clGetDeviceInfo(dev, CL_DEVICE_VERSION, version_len, device_version, NULL));
device_version[version_len] = '\0';
cl_uint compute_units;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(compute_units), &compute_units, NULL));
size_t ext_len;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_EXTENSIONS, 0, NULL, &ext_len));
char *device_ext = (char *)malloc(ext_len + 1);
CHECK(clGetDeviceInfo(dev, CL_DEVICE_EXTENSIONS, ext_len, device_ext, NULL));
device_ext[ext_len] = '\0';
cl_ulong global_mem_size;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(global_mem_size), &global_mem_size, NULL));
cl_ulong max_alloc_size;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(max_alloc_size), &max_alloc_size, NULL));
cl_ulong max_constant_size;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(max_constant_size), &max_constant_size, NULL));
cl_ulong local_mem_size;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(local_mem_size), &local_mem_size, NULL));
cl_device_local_mem_type local_type;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_LOCAL_MEM_TYPE, sizeof(local_type), &local_type, NULL));
size_t max_arg_size;
CHECK(clGetDeviceInfo(dev, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(max_arg_size), &max_arg_size, NULL));
printf(" %d compute units\n", compute_units);
printf(" %lu bytes of global mem\n", global_mem_size);
printf(" %lu byte max alloc size\n", max_alloc_size);
printf(" %lu byte max constant size\n", max_constant_size);
printf(" %lu byte local mem size (really local? %s)\n",
local_mem_size, local_type == CL_LOCAL ? "true" : "false");
printf(" %lu byte max arg size\n", max_arg_size);
printf(" %s\n", device_version);
printf(" %s\n", device_ext);
device_index++;
}
free(devices);
}
free(platforms);
}
static ibv_device *get_device(DevicesPtr devices, int i) {
if(i < 0 || i >= get_num_devices(devices)) {
throw std::out_of_range("cannot get device");
}
return devices.get()[i];
}
cl_uint get_num_devices(cl_platform_id platform) {
return get_num_devices(platform, CL_DEVICE_TYPE_ALL);
}
void handle_device_status_order()
{
if (parameter_length < 2)
{
send_insufficient_bytes_error_response(2);
return;
}
const uint8_t device_type = parameter_value[0];
const uint8_t device_number = parameter_value[1];
uint8_t num_devices = get_num_devices(device_type);
if (device_number >= num_devices)
{
if (num_devices < 0)
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
else
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_NUMBER,0);
return;
}
generate_response_start(RSP_OK, 1);
switch(device_type)
{
case PM_DEVICE_TYPE_SWITCH_INPUT:
if (!Device_InputSwitch::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_SWITCH_OUTPUT:
if (!Device_OutputSwitch::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (!Device_OutputSwitch::GetEnableState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_DISABLED);
// TODO handle inactive state
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_PWM_OUTPUT:
if (!Device_PwmOutput::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (!Device_PwmOutput::GetActiveState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_STEPPER:
if (!AxisInfo::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (is_stopped)
generate_response_data_addbyte(DEVICE_STATUS_STOPPED);
else if (!AxisInfo::GetStepperEnableState(device_number))
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_HEATER:
if (!Device_Heater::ValidateTargetTemperature(device_number, 0))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (is_stopped)
generate_response_data_addbyte(DEVICE_STATUS_STOPPED);
else if (Device_Heater::GetTargetTemperature(device_number) == 0)
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_TEMP_SENSOR:
if (!Device_TemperatureSensor::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
case PM_DEVICE_TYPE_BUZZER:
if (!Device_Buzzer::IsInUse(device_number))
generate_response_data_addbyte(DEVICE_STATUS_CONFIG_ERROR);
else if (Device_Buzzer::GetActiveState(device_number) == 0)
generate_response_data_addbyte(DEVICE_STATUS_INACTIVE);
else
generate_response_data_addbyte(DEVICE_STATUS_ACTIVE);
break;
default:
send_app_error_response(PARAM_APP_ERROR_TYPE_INVALID_DEVICE_TYPE,0);
return;
}
generate_response_send();
}
