| // |
| // Copyright (c) 2017 The Khronos Group Inc. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| #ifndef __RUN_SERVICES_H |
| #define __RUN_SERVICES_H |
| |
| #include <string> |
| #include "kernelargs.h" |
| #include "datagen.h" |
| #include <list> |
| |
| void get_cl_file_path(const char *folder, const char *str, std::string &cl_file_path); |
| void get_bc_file_path(const char *folder, const char *str, std::string &bc_file_path, cl_uint size_t_width); |
| void get_h_file_path(const char *folder, const char *str, std::string &h_file_path); |
| void get_kernel_name(const char *test_name, std::string &kernel_name); |
| |
| cl_device_id get_context_device(cl_context context); |
| |
| void create_context_and_queue(cl_device_id device, cl_context *out_context, cl_command_queue *out_queue); |
| cl_program create_program_from_cl(cl_context context, const std::string& file_name); |
| cl_program create_program_from_bc(cl_context context, const std::string& file_name); |
| /** |
| Retrieves the kernel with the given name from the program |
| */ |
| cl_kernel create_kernel_helper(cl_program program, const std::string& kernel_name); |
| |
| cl_device_id get_program_device (cl_program program); |
| |
| void generate_kernel_ws( cl_device_id device, cl_kernel kernel, WorkSizeInfo& ws); |
| |
| /** |
| Responsible for holding the result of a single test |
| */ |
| class TestResult |
| { |
| public: |
| TestResult(){}; |
| |
| KernelArgs& kernelArgs() { return m_kernelArgs; } |
| |
| const KernelArgs& kernelArgs() const { return m_kernelArgs; } |
| |
| void readToHost(cl_command_queue queue) { m_kernelArgs.readToHost(queue); } |
| |
| /* |
| * Clones this object to a newly heap-allocated (deeply copied) object. |
| */ |
| TestResult* clone(cl_context ctx, const WorkSizeInfo& ws, const cl_kernel kernel, const cl_device_id device) const; |
| |
| private: |
| KernelArgs m_kernelArgs; |
| }; |
| |
| template <int i> |
| struct KhrValue |
| { |
| enum {Mask = (1 << i)}; |
| }; |
| |
| template <> |
| struct KhrValue<0> |
| { |
| enum {Mask = 1}; |
| }; |
| |
| /* |
| * Represents a set of OpenCL extension. |
| */ |
| class OclExtensions |
| { |
| public: |
| static OclExtensions getDeviceCapabilities(cl_device_id); |
| |
| static OclExtensions empty(); |
| |
| #define STRINIGFY(X) #X |
| |
| #define RETURN_IF_ENUM(S, E) if(S == STRINIGFY(E)) return E |
| |
| |
| static OclExtensions fromString(const std::string&); |
| |
| std::string toString(); |
| |
| // Operators |
| |
| // Merges the given extension and this one together, and returns the merged |
| // value. |
| OclExtensions operator|(const OclExtensions&) const; |
| |
| |
| // Indicates whether each extension in this objects also resides in b. |
| bool supports(const OclExtensions& b) const; |
| |
| // Return list of missing extensions |
| OclExtensions get_missing(const OclExtensions& b) const; |
| |
| |
| size_t get() const { return m_extVector; } |
| private: |
| |
| OclExtensions(size_t ext) : m_extVector(ext) {} |
| |
| // Fix a compilation error, since cl_khr_gl_sharing is defined as a macro. |
| #ifdef cl_khr_gl_sharing |
| #undef cl_khr_gl_sharing |
| #endif//cl_khr_gl_sharing |
| |
| #ifdef cl_khr_icd |
| #undef cl_khr_icd |
| #endif//cl_khr_icd |
| |
| enum ClKhrs |
| { |
| no_extensions = KhrValue<0>::Mask, |
| cl_khr_int64_base_atomics = KhrValue<1>::Mask, |
| cl_khr_int64_extended_atomics = KhrValue<2>::Mask, |
| cl_khr_3d_image_writes = KhrValue<3>::Mask, |
| cl_khr_fp16 = KhrValue<4>::Mask, |
| cl_khr_gl_sharing = KhrValue<5>::Mask, |
| cl_khr_gl_event = KhrValue<6>::Mask, |
| cl_khr_d3d10_sharing = KhrValue<7>::Mask, |
| cl_khr_dx9_media_sharing = KhrValue<8>::Mask, |
| cl_khr_d3d11_sharing = KhrValue<9>::Mask, |
| cl_khr_depth_images = KhrValue<10>::Mask, |
| cl_khr_gl_depth_images = KhrValue<11>::Mask, |
| cl_khr_gl_msaa_sharing = KhrValue<12>::Mask, |
| cl_khr_image2d_from_buffer = KhrValue<13>::Mask, |
| cl_khr_initialize_memory = KhrValue<14>::Mask, |
| cl_khr_context_abort = KhrValue<15>::Mask, |
| cl_khr_spir = KhrValue<16>::Mask, |
| cl_khr_fp64 = KhrValue<17>::Mask, |
| cl_khr_global_int32_base_atomics = KhrValue<18>::Mask, |
| cl_khr_global_int32_extended_atomics = KhrValue<19>::Mask, |
| cl_khr_local_int32_base_atomics = KhrValue<20>::Mask, |
| cl_khr_local_int32_extended_atomics = KhrValue<21>::Mask, |
| cl_khr_byte_addressable_store = KhrValue<22>::Mask, |
| cles_khr_int64 = KhrValue<23>::Mask, |
| cles_khr_2d_image_array_writes = KhrValue<24>::Mask, |
| }; |
| |
| size_t m_extVector; |
| }; |
| |
| std::ostream& operator<<(std::ostream& os, OclExtensions ext); |
| |
| /* |
| * Indicates whether a given test needs KHR extension. |
| */ |
| |
| class DataRow; |
| |
| class DataTable |
| { |
| std::vector<DataRow*> m_rows; |
| public: |
| size_t getNumRows() const; |
| void addTableRow(DataRow*); |
| const DataRow& operator[](int index)const; |
| DataRow& operator[](int index); |
| }; |
| |
| class KhrSupport |
| { |
| public: |
| static const KhrSupport* get(const std::string& csvFile); |
| DataRow* parseLine(const std::string&); |
| OclExtensions getRequiredExtensions(const char* suite, const char* test) const; |
| cl_bool isImagesRequired(const char* suite, const char* test) const; |
| cl_bool isImages3DRequired(const char* suite, const char* test) const; |
| |
| private: |
| static const int SUITE_INDEX = 0; |
| static const int TEST_INDEX = 1; |
| static const int EXT_INDEX = 2; |
| static const int IMAGES_INDEX = 3; |
| static const int IMAGES_3D_INDEX = 4; |
| |
| void parseCSV(std::fstream&); |
| |
| DataTable m_dt; |
| static KhrSupport* m_instance; |
| }; |
| |
| class DataRow |
| { |
| std::vector<std::string> m_row; |
| DataRow() {} |
| public: |
| const std::string& operator[](int)const; |
| std::string& operator[](int); |
| |
| friend DataRow* KhrSupport::parseLine(const std::string&); |
| }; |
| |
| /* |
| * Generates data for the given kernel. |
| * Parameters: |
| * context - The context of the kernel. |
| * kernel - The kernel to which arguments will be generated |
| * ws(OUT) - generated work size info. |
| * res(OUT)- generated test results. |
| */ |
| void generate_kernel_data(cl_context context, cl_kernel kernel, |
| WorkSizeInfo &ws, TestResult& res); |
| |
| void run_kernel(cl_kernel kernel, cl_command_queue queue, WorkSizeInfo &ws, TestResult& result); |
| bool compare_results(const TestResult& lhs, const TestResult& rhs, float ulps); |
| |
| #endif |