Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2017 ARM Limited. |
| 3 | * |
| 4 | * SPDX-License-Identifier: MIT |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
| 7 | * of this software and associated documentation files (the "Software"), to |
| 8 | * deal in the Software without restriction, including without limitation the |
| 9 | * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| 10 | * sell copies of the Software, and to permit persons to whom the Software is |
| 11 | * furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in all |
| 14 | * copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| 19 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 21 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 22 | * SOFTWARE. |
| 23 | */ |
| 24 | #ifndef __ARM_COMPUTE_GCKERNELLIBRARY_H__ |
| 25 | #define __ARM_COMPUTE_GCKERNELLIBRARY_H__ |
| 26 | |
| 27 | #include "arm_compute/core/GLES_COMPUTE/OpenGLES.h" |
| 28 | #include "arm_compute/core/Utils.h" |
| 29 | |
| 30 | #include <map> |
| 31 | #include <set> |
| 32 | #include <string> |
| 33 | #include <utility> |
| 34 | #include <vector> |
| 35 | |
| 36 | namespace arm_compute |
| 37 | { |
| 38 | /** GCProgram class */ |
| 39 | class GCProgram |
| 40 | { |
| 41 | public: |
| 42 | /** Default constructor. */ |
| 43 | GCProgram(); |
| 44 | /** Construct program from source file. |
| 45 | * |
| 46 | * @param[in] name Program name. |
| 47 | * @param[in] source Program source. |
| 48 | */ |
| 49 | GCProgram(std::string name, std::string source); |
| 50 | /** Default Copy Constructor. */ |
| 51 | GCProgram(const GCProgram &) = default; |
| 52 | /** Default Move Constructor. */ |
| 53 | GCProgram(GCProgram &&) = default; |
| 54 | /** Default copy assignment operator. */ |
| 55 | GCProgram &operator=(const GCProgram &) = default; |
| 56 | /** Default move assignment operator. */ |
| 57 | GCProgram &operator=(GCProgram &&) = default; |
| 58 | /** Returns program name. |
| 59 | * |
| 60 | * @return Program's name. |
| 61 | */ |
| 62 | std::string name() const |
| 63 | { |
| 64 | return _name; |
| 65 | } |
| 66 | /** Link program. |
| 67 | * |
| 68 | * @param[in] shader Shader used to link program. |
| 69 | * |
| 70 | * @return linked program id . |
| 71 | */ |
| 72 | GLuint link_program(GLuint shader); |
| 73 | /** Compile shader. |
| 74 | * |
| 75 | * @param[in] build_options Shader build options. |
| 76 | * |
| 77 | * @return GLES shader object. |
| 78 | */ |
| 79 | GLuint compile_shader(const std::string &build_options); |
| 80 | |
| 81 | private: |
| 82 | std::string _name; /**< Program name. */ |
| 83 | std::string _source; /**< Source code for the program. */ |
| 84 | }; |
| 85 | |
| 86 | /** GCKernel class */ |
| 87 | class GCKernel |
| 88 | { |
| 89 | public: |
| 90 | /** Default Constructor. */ |
| 91 | GCKernel(); |
| 92 | /** Default Copy Constructor. */ |
| 93 | GCKernel(const GCKernel &) = default; |
| 94 | /** Default Move Constructor. */ |
| 95 | GCKernel(GCKernel &&) = default; |
| 96 | /** Default copy assignment operator. */ |
| 97 | GCKernel &operator=(const GCKernel &) = default; |
| 98 | /** Default move assignment operator. */ |
| 99 | GCKernel &operator=(GCKernel &&) = default; |
| 100 | /** Constructor. |
| 101 | * |
| 102 | * @param[in] name Kernel name. |
| 103 | * @param[in] program Built program. |
| 104 | */ |
| 105 | GCKernel(std::string name, GLuint program); |
| 106 | /** Returns kernel name. |
| 107 | * |
| 108 | * @return Kernel's name. |
| 109 | */ |
| 110 | std::string name() const |
| 111 | { |
| 112 | return _name; |
| 113 | } |
| 114 | /** Get program id. |
| 115 | * |
| 116 | * @return program id. |
| 117 | */ |
| 118 | GLuint get_program() const |
| 119 | { |
| 120 | return _program; |
| 121 | } |
| 122 | /** Use current program. |
| 123 | * |
| 124 | * @return program id. |
| 125 | */ |
| 126 | void use(); |
| 127 | /** Unuse current program. |
| 128 | * |
| 129 | * @return program id. |
| 130 | */ |
| 131 | void unuse(); |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 132 | /** Set argument value at index of shader params. |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 133 | * |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 134 | * @param[in] idx Index in shader params. |
| 135 | * @param[in] value Argument value to be set. |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 136 | */ |
| 137 | template <class T> |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 138 | void set_argument(unsigned int idx, T value) |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 139 | { |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 140 | if(idx >= _shader_arguments.size()) |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 141 | { |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 142 | _shader_arguments.resize(idx + 1, 0); |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 143 | } |
| 144 | |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 145 | unsigned int *p = reinterpret_cast<unsigned int *>(&value); |
| 146 | _shader_arguments[idx] = *p; |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 147 | } |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 148 | /** Clear shader arguments. |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 149 | * |
| 150 | */ |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 151 | void clear_arguments() |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 152 | { |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 153 | _shader_arguments.clear(); |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 154 | } |
| 155 | /** Set shader params binding point. |
| 156 | * |
| 157 | * @param[in] binding Shader params binding point. |
| 158 | */ |
| 159 | void set_shader_params_binding_point(unsigned int binding) |
| 160 | { |
| 161 | _shader_params_binding_point = binding; |
| 162 | } |
| 163 | /** Update shader params. |
| 164 | * |
| 165 | */ |
| 166 | void update_shader_params(); |
| 167 | /** Clean up program and ubo. |
| 168 | * |
| 169 | */ |
| 170 | void cleanup(); |
| 171 | |
| 172 | private: |
| 173 | std::string _name; /**< Kernel name */ |
| 174 | GLuint _program; /**< Linked program id */ |
Joel Liang | f1f3ebd | 2017-11-10 09:59:19 +0800 | [diff] [blame^] | 175 | std::vector<unsigned int> _shader_arguments; /**< Store all the values of the shader arguments */ |
| 176 | GLuint _shader_params_ubo_name; /**< Uniform buffer object name for shader parameters */ |
Anthony Barbier | 7068f99 | 2017-10-26 15:23:08 +0100 | [diff] [blame] | 177 | GLuint _shader_params_binding_point; /**< The binding point of the uniform block for shader parameters */ |
| 178 | GLuint _shader_params_index; /**< The index of the uniform block */ |
| 179 | GLint _shader_params_size; /**< The uniform block data size in the shader */ |
| 180 | static constexpr const char *_shader_params_name = "shader_params"; /**< The uniform block name in the shader */ |
| 181 | }; |
| 182 | |
| 183 | /** GCKernelLibrary class */ |
| 184 | class GCKernelLibrary |
| 185 | { |
| 186 | using StringSet = std::set<std::string>; |
| 187 | |
| 188 | private: |
| 189 | /** Default Constructor. */ |
| 190 | GCKernelLibrary(); |
| 191 | |
| 192 | public: |
| 193 | /** Prevent instances of this class from being copied. */ |
| 194 | GCKernelLibrary(const GCKernelLibrary &) = delete; |
| 195 | /** Prevent instances of this class from being copied. */ |
| 196 | const GCKernelLibrary &operator=(const GCKernelLibrary &) = delete; |
| 197 | /** Default Destructor. */ |
| 198 | ~GCKernelLibrary(); |
| 199 | |
| 200 | static GCKernelLibrary &get(); |
| 201 | /** Initialises the kernel library. |
| 202 | * |
| 203 | * @param[in] shader_path (Optional) Path of the directory from which shader sources are loaded. |
| 204 | * @param[in] dpy (Optional) EGLdisplay set by external application. |
| 205 | * @param[in] ctx (Optional) EGLContext set by external application. |
| 206 | */ |
| 207 | void init(std::string shader_path = "./", EGLDisplay dpy = EGL_NO_DISPLAY, EGLContext ctx = EGL_NO_CONTEXT) |
| 208 | { |
| 209 | //TODO: deal with old display and context. |
| 210 | _shader_path = std::move(shader_path); |
| 211 | |
| 212 | _display = dpy; |
| 213 | _context = ctx; |
| 214 | |
| 215 | if(_display == EGL_NO_DISPLAY || _context == EGL_NO_CONTEXT) |
| 216 | { |
| 217 | setup_context(); |
| 218 | |
| 219 | _own_context = true; |
| 220 | } |
| 221 | |
| 222 | eglMakeCurrent(_display, EGL_NO_SURFACE, EGL_NO_SURFACE, _context); |
| 223 | setup_dummy_fbo(); |
| 224 | } |
| 225 | |
| 226 | /** Sets the path that the shaders reside in. |
| 227 | * |
| 228 | * @param[in] shader_path Path of the shader. |
| 229 | */ |
| 230 | void set_shader_path(const std::string &shader_path) |
| 231 | { |
| 232 | _shader_path = shader_path; |
| 233 | }; |
| 234 | /** Sets display and context to create kernel. |
| 235 | * |
| 236 | * @param[in] dpy EGLdisplay set by external application. |
| 237 | * @param[in] ctx EGLContext set by external application. |
| 238 | */ |
| 239 | void set_context(EGLDisplay dpy, EGLContext ctx) |
| 240 | { |
| 241 | //TODO: deal with old display and context. |
| 242 | _display = dpy; |
| 243 | _context = ctx; |
| 244 | |
| 245 | eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx); |
| 246 | setup_dummy_fbo(); |
| 247 | }; |
| 248 | /** Creates a kernel from the kernel library. |
| 249 | * |
| 250 | * @param[in] shader_name Shader name. |
| 251 | * @param[in] build_options_set Shader build options as a set. |
| 252 | * |
| 253 | * @return The created kernel. |
| 254 | */ |
| 255 | GCKernel create_kernel(const std::string &shader_name, const StringSet &build_options_set = {}) const; |
| 256 | /** Serializes and saves programs to a binary. |
| 257 | * |
| 258 | */ |
| 259 | void save_binary(); |
| 260 | /** Load serialized binary with all the programs. |
| 261 | * |
| 262 | */ |
| 263 | void load_binary(); |
| 264 | /** Setup a dummy fbo to workaround an issue on Galaxy S8. |
| 265 | * |
| 266 | */ |
| 267 | void setup_dummy_fbo(); |
| 268 | |
| 269 | private: |
| 270 | /** Preprocess GLES shader |
| 271 | * |
| 272 | * @param[in] shader_source Source code of the shader to preprocess. |
| 273 | * |
| 274 | * @return Preprocessed GLES shader object. |
| 275 | */ |
| 276 | const std::string preprocess_shader(const std::string &shader_source) const; |
| 277 | /** Load program and its dependencies. |
| 278 | * |
| 279 | * @param[in] program_name Name of the program to load. |
| 280 | */ |
| 281 | const GCProgram &load_program(const std::string &program_name) const; |
| 282 | /** Concatenates contents of a set into a single string. |
| 283 | * |
| 284 | * @param[in] s Input set to concatenate. |
| 285 | * |
| 286 | * @return Concatenated string. |
| 287 | */ |
| 288 | std::string stringify_set(const StringSet &s) const; |
| 289 | /** Set up EGL context. |
| 290 | */ |
| 291 | void setup_context(); |
| 292 | |
| 293 | EGLDisplay _display; /**< Underlying EGL Display. */ |
| 294 | EGLContext _context; /**< Underlying EGL Context. */ |
| 295 | GLuint _frame_buffer; /**< Dummy fbo */ |
| 296 | GLuint _tex_rt; /**< Dummy texture for render target */ |
| 297 | bool _own_context; /**< Self created context or not. */ |
| 298 | std::string _shader_path; /**< Path to the shaders folder. */ |
| 299 | mutable std::map<std::string, const GCProgram> _programs_map; /**< Map with all already loaded program data. */ |
| 300 | mutable std::map<std::string, const GCKernel> _built_programs_map; /**< Map with all already built program data. */ |
| 301 | static const std::map<std::string, std::string> _shader_program_map; /**< Map that associates kernel names with programs. */ |
| 302 | static const std::map<std::string, std::string> _program_source_map; /**< Contains sources for all programs. |
| 303 | Used for compile-time shader inclusion. */ |
| 304 | }; |
| 305 | } |
| 306 | #endif /* __ARM_COMPUTE_GCKERNELLIBRARY_H__ */ |