From 2421f7bdce2e9267c6b25aea45a165371124f212 Mon Sep 17 00:00:00 2001 From: MitchellHansen Date: Sat, 25 Mar 2017 21:25:14 -0700 Subject: [PATCH] Having some performance issues on a new windows install. Going to pull device selection out to the GUI and do further testing --- include/raycaster/Hardware_Caster.h | 51 +++++++++++++ src/main.cpp | 42 ++++++++--- src/raycaster/Hardware_Caster.cpp | 106 +++++++++++++++++++++++++++- 3 files changed, 188 insertions(+), 11 deletions(-) diff --git a/include/raycaster/Hardware_Caster.h b/include/raycaster/Hardware_Caster.h index 605de31..fad7449 100644 --- a/include/raycaster/Hardware_Caster.h +++ b/include/raycaster/Hardware_Caster.h @@ -43,6 +43,54 @@ struct device { bool cl_gl_sharing = false; }; +struct device_info { + cl_uint cl_device_address_bits; + cl_bool cl_device_available; + cl_bool cl_device_compiler_available; + cl_bool cl_device_endian_little; + cl_bool cl_device_error_correction_support; + char cl_device_extensions[1024]; + cl_ulong cl_device_global_mem_cache_size; + cl_uint cl_device_global_mem_cacheline_size; + cl_ulong cl_device_global_mem_size; + cl_bool cl_device_image_support; + size_t cl_device_image2d_max_height; + size_t cl_device_image2d_max_width; + size_t cl_device_image3d_max_depth; + size_t cl_device_image3d_max_height; + size_t cl_device_image3d_max_width; + cl_ulong cl_device_local_mem_size; + cl_uint cl_device_max_clock_frequency; + cl_uint cl_device_max_compute_units; + cl_uint cl_device_max_constant_args; + cl_ulong cl_device_max_constant_buffer_size; + cl_ulong cl_device_max_mem_alloc_size; + size_t cl_device_max_parameter_size; + cl_uint cl_device_max_read_image_args; + cl_uint cl_device_max_samplers; + size_t cl_device_max_work_group_size; + cl_uint cl_device_max_work_item_dimensions; + size_t cl_device_max_work_item_sizes[3]; + cl_uint cl_device_max_write_image_args; + cl_uint cl_device_mem_base_addr_align; + cl_uint cl_device_min_data_type_align_size; + char cl_device_name[128]; + cl_platform_id cl_device_platform; + cl_uint cl_device_preferred_vector_width_char; + cl_uint cl_device_preferred_vector_width_short; + cl_uint cl_device_preferred_vector_width_int; + cl_uint cl_device_preferred_vector_width_long; + cl_uint cl_device_preferred_vector_width_float; + cl_uint cl_device_preferred_vector_width_double; + char cl_device_profile[256]; + size_t cl_device_profiling_timer_resolution; + cl_device_type cl_device_type; + char cl_device_vendor[128]; + cl_uint cl_device_vendor_id; + char cl_device_version[128]; + char cl_driver_version[128]; +}; + struct raycaster_settings { }; @@ -98,6 +146,7 @@ public: // Modify the viewport matrix void test_edit_viewport(int width, int height, float v_fov, float h_fov); + void gui(); private: @@ -105,6 +154,8 @@ private: // Also checks for the sharing extension int acquire_platform_and_device(); + int query_hardware(); + // With respect to the individual platforms implementation of sharing // create a shared cl_gl context int create_shared_context(); diff --git a/src/main.cpp b/src/main.cpp index da166aa..1f75c6f 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -40,12 +40,12 @@ #include "imgui/imgui-SFML.h" #include "imgui/imgui.h" -const int WINDOW_X = 1440; -const int WINDOW_Y = 900; +const int WINDOW_X = 1536; +const int WINDOW_Y = 1024; const int WORK_SIZE = WINDOW_X * WINDOW_Y; -const int MAP_X = 512; -const int MAP_Y = 512; +const int MAP_X = 256; +const int MAP_Y = 256; const int MAP_Z = 256; float elap_time(){ @@ -97,14 +97,14 @@ int main() { _map.generate_octree(); _map.a.print_block(0); _map.test_map(); - std::cin.get(); - return 0; + //std::cin.get(); + //return 0; // ============================= sf::RenderWindow window(sf::VideoMode(WINDOW_X, WINDOW_Y), "SFML"); window.setMouseCursorVisible(false); window.setKeyRepeatEnabled(false); - window.setFramerateLimit(60); + window.setFramerateLimit(120); window.setVerticalSyncEnabled(false); ImGui::SFML::Init(window); @@ -219,7 +219,18 @@ int main() { fps.frame(delta_time); fps.draw(); - ImGui::Begin("Camera"); + ImGuiWindowFlags window_flags = ImGuiWindowFlags_MenuBar; + bool window_show = true; + ImGui::Begin("Camera", &window_show, window_flags); + + if (ImGui::BeginMenuBar()) + { + if (ImGui::BeginMenu("Menu")) + { + ImGui::EndMenu(); + } + ImGui::EndMenuBar(); + } ImGui::Columns(2); @@ -277,16 +288,27 @@ int main() { handle->set_position(light); } + // Menu + + + + + if (ImGui::CollapsingHeader("Window options")) + { + if (ImGui::TreeNode("Style")) + { + ImGui::ShowStyleEditor(); + ImGui::TreePop(); + } + } //light_pos[0] = static_cast(sin(elapsed_time) * 100.0f + 300.0f); //light_pos[1] = static_cast(sin(elapsed_time) * 100.0f + 300.0f); //sf::Vector3f light(light_pos[0], light_pos[1], light_pos[2]); //handle->set_position(light); - ImGui::End(); - ImGui::Render(); diff --git a/src/raycaster/Hardware_Caster.cpp b/src/raycaster/Hardware_Caster.cpp index 51d0538..04c8627 100644 --- a/src/raycaster/Hardware_Caster.cpp +++ b/src/raycaster/Hardware_Caster.cpp @@ -10,6 +10,8 @@ Hardware_Caster::~Hardware_Caster() { int Hardware_Caster::init() { + query_hardware(); + // Initialize opencl up to the point where we start assigning buffers error = acquire_platform_and_device(); if(vr_assert(error, "aquire_platform_and_device")) @@ -265,6 +267,11 @@ void Hardware_Caster::test_edit_viewport(int width, int height, float v_fov, flo } } + +void Hardware_Caster::gui() { + +} + int Hardware_Caster::acquire_platform_and_device() { // Get the number of platforms @@ -420,6 +427,103 @@ int Hardware_Caster::acquire_platform_and_device() { return 1; }; + +int Hardware_Caster::query_hardware() { + + // Get the number of platforms + cl_uint plt_cnt = 0; + clGetPlatformIDs(0, nullptr, &plt_cnt); + + // Fetch the platforms + std::map> plt_ids; + + // buffer before map init + std::vector plt_buf(plt_cnt); + clGetPlatformIDs(plt_cnt, plt_buf.data(), nullptr); + + // Map init + for (auto id : plt_buf) { + plt_ids.emplace(std::make_pair(id, std::vector())); + } + + // For each platform, populate its devices + for (unsigned int i = 0; i < plt_cnt; i++) { + + cl_uint deviceIdCount = 0; + error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceIdCount); + + // Check to see if we even have OpenCL on this machine + if (deviceIdCount == 0) { + std::cout << "There appears to be no devices, or none at least supporting OpenCL" << std::endl; + return OPENCL_NOT_SUPPORTED; + } + + // Get the device ids + std::vector deviceIds(deviceIdCount); + error = clGetDeviceIDs(plt_buf[i], CL_DEVICE_TYPE_ALL, deviceIdCount, deviceIds.data(), NULL); + + if (vr_assert(error, "clGetDeviceIDs")) + return OPENCL_ERROR; + + for (unsigned int q = 0; q < deviceIdCount; q++) { + + device_info d; + + cl_device_id id = deviceIds[q]; + + clGetDeviceInfo(id, CL_DEVICE_ADDRESS_BITS, sizeof(cl_uint), &d.cl_device_address_bits, NULL); + clGetDeviceInfo(id, CL_DEVICE_AVAILABLE, sizeof(cl_bool), &d.cl_device_available, NULL); + clGetDeviceInfo(id, CL_DEVICE_COMPILER_AVAILABLE, sizeof(cl_bool), &d.cl_device_compiler_available, NULL); + clGetDeviceInfo(id, CL_DEVICE_ENDIAN_LITTLE, sizeof(cl_bool), &d.cl_device_endian_little, NULL); + clGetDeviceInfo(id, CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(cl_bool), &d.cl_device_error_correction_support, NULL); + clGetDeviceInfo(id, CL_DEVICE_EXTENSIONS, sizeof(char)*1024, &d.cl_device_extensions, NULL); + clGetDeviceInfo(id, CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, sizeof(cl_ulong), &d.cl_device_global_mem_cache_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, sizeof(cl_uint), &d.cl_device_global_mem_cacheline_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(cl_ulong), &d.cl_device_global_mem_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE_SUPPORT, sizeof(cl_bool), &d.cl_device_image_support, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t), &d.cl_device_image2d_max_height, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t), &d.cl_device_image2d_max_width, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t), &d.cl_device_image3d_max_depth, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t), &d.cl_device_image3d_max_height, NULL); + clGetDeviceInfo(id, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t), &d.cl_device_image3d_max_width, NULL); + clGetDeviceInfo(id, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(cl_ulong), &d.cl_device_local_mem_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(size_t), &d.cl_device_max_clock_frequency, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(size_t), &d.cl_device_max_compute_units, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_CONSTANT_ARGS, sizeof(size_t), &d.cl_device_max_constant_args, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(cl_ulong), &d.cl_device_max_constant_buffer_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(cl_ulong), &d.cl_device_max_mem_alloc_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_PARAMETER_SIZE, sizeof(size_t), &d.cl_device_max_parameter_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(cl_uint), &d.cl_device_max_read_image_args, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_SAMPLERS, sizeof(cl_uint), &d.cl_device_max_samplers, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(cl_ulong), &d.cl_device_max_work_group_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(cl_ulong), &d.cl_device_max_work_item_dimensions, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(size_t)*3, &d.cl_device_max_work_item_sizes, NULL); + clGetDeviceInfo(id, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(cl_uint), &d.cl_device_max_write_image_args, NULL); + clGetDeviceInfo(id, CL_DEVICE_MEM_BASE_ADDR_ALIGN, sizeof(cl_uint), &d.cl_device_mem_base_addr_align, NULL); + clGetDeviceInfo(id, CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof(cl_uint), &d.cl_device_min_data_type_align_size, NULL); + clGetDeviceInfo(id, CL_DEVICE_NAME, sizeof(char)*128, &d.cl_device_name, NULL); + clGetDeviceInfo(id, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &d.cl_device_platform, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_GLOBAL_ATOMIC_ALIGNMENT, sizeof(cl_uint), &d.cl_device_preferred_vector_width_char, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(cl_uint), &d.cl_device_preferred_vector_width_short, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), &d.cl_device_preferred_vector_width_int, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(cl_uint), &d.cl_device_preferred_vector_width_long, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(cl_uint), &d.cl_device_preferred_vector_width_float, NULL); + clGetDeviceInfo(id, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &d.cl_device_preferred_vector_width_double, NULL); + clGetDeviceInfo(id, CL_DEVICE_PROFILE, sizeof(char) * 256, &d.cl_device_profile, NULL); + clGetDeviceInfo(id, CL_DEVICE_PROFILING_TIMER_RESOLUTION, sizeof(size_t), &d.cl_device_profiling_timer_resolution, NULL); + clGetDeviceInfo(id, CL_DEVICE_TYPE, sizeof(cl_device_type), &d.cl_device_type, NULL); + clGetDeviceInfo(id, CL_DEVICE_VENDOR, sizeof(char)*128, &d.cl_device_vendor, NULL); + clGetDeviceInfo(id, CL_DEVICE_VENDOR_ID, sizeof(cl_uint), &d.cl_device_vendor_id, NULL); + clGetDeviceInfo(id, CL_DEVICE_VERSION, sizeof(char)*128, &d.cl_device_version, NULL); + clGetDeviceInfo(id, CL_DRIVER_VERSION, sizeof(char)*128, &d.cl_driver_version, NULL); + + plt_ids.at(d.cl_device_platform).push_back(d); + } + } + + return 1; +} + int Hardware_Caster::create_shared_context() { // Hurray for standards! @@ -526,7 +630,7 @@ int Hardware_Caster::compile_kernel(std::string kernel_source, bool is_path, std // Try and build the program // "-cl-finite-math-only -cl-fast-relaxed-math -cl-unsafe-math-optimizations" - error = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL); + error = clBuildProgram(program, 1, &device_id, "-cl-finite-math-only -cl-fast-relaxed-math -cl-unsafe-math-optimizations", NULL, NULL); // Check to see if it errored out if (vr_assert(error, "clBuildProgram")) {