core_files += Glob('src/core/CL/gemm/reshaped/*.cpp')
core_files += Glob('src/core/CL/gemm/reshaped_only_rhs/*.cpp')
+ arm_compute_env.Append(CPPDEFINES=['ARM_COMPUTE_CL'])
runtime_files += Glob('src/runtime/CL/*.cpp')
runtime_files += Glob('src/runtime/CL/functions/*.cpp')
runtime_files += Glob('src/runtime/CL/tuners/*.cpp')
/** Access the cache of built OpenCL programs */
const std::map<std::string, cl::Program> &get_built_programs() const;
+ /** Access the cache of new built OpenCL programs */
+ std::map<std::string, cl::Program> &get_new_built_programs();
+
/** Add a new built program to the cache
*
* @param[in] built_program_name Name of the program
std::string _kernel_path; /**< Path to the kernels folder. */
mutable std::map<std::string, const Program> _programs_map; /**< Map with all already loaded program data. */
mutable std::map<std::string, cl::Program> _built_programs_map; /**< Map with all already built program data. */
+ mutable std::map<std::string, cl::Program> _new_built_programs_map; /**< Map with new built program data. */
static const std::map<std::string, std::string> _kernel_program_map; /**< Map that associates kernel names with programs. */
static const std::map<std::string, std::string> _program_source_map; /**< Contains sources for all programs.
Used for compile-time kernel inclusion. >*/
--- /dev/null
+/*
+ * Copyright (c) 2017-2019 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#ifndef ARM_COMPUTE_CORE_CL_UTILS_H
+#define ARM_COMPUTE_CORE_CL_UTILS_H
+
+#include <string>
+
+namespace arm_compute
+{
+/** This function saves opencl kernels library to a file
+ *
+ * @param[in] filename Name of the file to be used to save the library
+ */
+void save_program_cache_to_file(const std::string &filename = "cache.bin");
+
+/** This function loads prebuilt opencl kernels from a file
+ *
+ * @param[in] filename Name of the file to be used to load the kernels
+ */
+void restore_program_cache_from_file(const std::string &filename = "cache.bin");
+} // namespace arm_compute
+#endif /* ARM_COMPUTE_CORE_CL_UTILS_H */
#include "arm_compute/core/Types.h"
#include "arm_compute/runtime/CL/CLHelpers.h"
#include "arm_compute/runtime/CL/CLScheduler.h"
+#ifdef ARM_COMPUTE_CL
+#include "arm_compute/runtime/CL/Utils.h"
+#endif
#include "utils/Utils.h"
using namespace arm_compute;
std::transform(argv1.begin(), argv1.end(), argv1.begin(), ::tolower);
if(argv1 == "--restore_cache")
{
+#ifdef ARM_COMPUTE_CL
// Load the precompiled kernels from a file into the kernel library, in this way the next time they are needed
// compilation won't be required.
restore_program_cache_from_file();
+#endif
}
else
{
permute_nchw.configure(&tensor_nhwc, &tensor_nchw_result, vector_nhwc_to_nchw);
tensor_nchw_result.allocator()->allocate();
+#ifdef ARM_COMPUTE_CL
// Save the opencl kernels to a file
save_program_cache_to_file();
+#endif
return true;
}
* SOFTWARE.
*/
#include "arm_compute/graph.h"
+#ifdef ARM_COMPUTE_CL
+#include "arm_compute/runtime/CL/Utils.h"
+#endif
#include "support/ToolchainSupport.h"
#include "utils/CommonGraphOptions.h"
#include "utils/GraphUtils.h"
#include "utils/Utils.h"
+using namespace arm_compute;
using namespace arm_compute::utils;
using namespace arm_compute::graph::frontend;
using namespace arm_compute::graph_utils;
// compilation won't be required.
if(common_params.enable_cl_cache)
{
+#ifdef ARM_COMPUTE_CL
restore_program_cache_from_file();
+#endif
}
graph.finalize(common_params.target, config);
// Save the opencl kernels to a file
if(common_opts.enable_cl_cache)
{
+#ifdef ARM_COMPUTE_CL
save_program_cache_to_file();
+#endif
}
return true;
* SOFTWARE.
*/
#include "arm_compute/graph.h"
+#ifdef ARM_COMPUTE_CL
+#include "arm_compute/runtime/CL/Utils.h"
+#endif
#include "support/ToolchainSupport.h"
#include "utils/CommonGraphOptions.h"
#include "utils/GraphUtils.h"
#include "utils/Utils.h"
+using namespace arm_compute;
using namespace arm_compute::utils;
using namespace arm_compute::graph::frontend;
using namespace arm_compute::graph_utils;
// compilation won't be required.
if(common_params.enable_cl_cache)
{
+#ifdef ARM_COMPUTE_CL
restore_program_cache_from_file();
+#endif
}
graph.finalize(common_params.target, config);
// Save the opencl kernels to a file
if(common_opts.enable_cl_cache)
{
+#ifdef ARM_COMPUTE_CL
save_program_cache_to_file();
+#endif
}
return true;
};
CLKernelLibrary::CLKernelLibrary()
- : _context(), _device(), _kernel_path("."), _programs_map(), _built_programs_map()
+ : _context(), _device(), _kernel_path("."), _programs_map(), _built_programs_map(), _new_built_programs_map()
{
opencl_is_available(); // Make sure the OpenCL symbols are initialised *before* the CLKernelLibrary is built
}
cl_program = program.build(build_options);
// Add built program to internal map
- _built_programs_map.emplace(built_program_name, cl_program);
+ _new_built_programs_map.emplace(built_program_name, cl_program);
}
// Create and return kernel
{
_programs_map.clear();
_built_programs_map.clear();
+ _new_built_programs_map.clear();
}
const std::map<std::string, cl::Program> &CLKernelLibrary::get_built_programs() const
return _built_programs_map;
}
+std::map<std::string, cl::Program> &CLKernelLibrary::get_new_built_programs()
+{
+ return _new_built_programs_map;
+}
+
void CLKernelLibrary::add_built_program(const std::string &built_program_name, const cl::Program &program)
{
_built_programs_map.emplace(built_program_name, program);
--- /dev/null
+/*
+ * Copyright (c) 2017-2019 ARM Limited.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+#include "arm_compute/core/CL/CLKernelLibrary.h"
+#include "arm_compute/runtime/CL/CLScheduler.h"
+
+#include <fstream>
+#include <map>
+#include <string>
+
+namespace arm_compute
+{
+void restore_program_cache_from_file(const std::string &filename)
+{
+ std::ifstream cache_file(filename, std::ios::binary);
+ if(cache_file.is_open())
+ {
+ if(!CLScheduler::get().is_initialised())
+ {
+ arm_compute::CLScheduler::get().default_init();
+ }
+
+ while(!cache_file.eof())
+ {
+ size_t name_len = 0;
+ size_t binary_len = 0;
+ cache_file.read(reinterpret_cast<char *>(&name_len), sizeof(size_t));
+ cache_file.read(reinterpret_cast<char *>(&binary_len), sizeof(size_t));
+ if(name_len == 0 || binary_len == 0)
+ {
+ break;
+ }
+ std::vector<char> tmp(name_len);
+ std::vector<unsigned char> binary(binary_len);
+ std::string name;
+ cache_file.read(tmp.data(), name_len);
+ name.assign(tmp.data(), name_len);
+ tmp.resize(binary_len);
+ cache_file.read(reinterpret_cast<char *>(binary.data()), binary_len);
+ cl::Context context = arm_compute::CLScheduler::get().context();
+ cl::Program::Binaries binaries{ binary };
+ std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
+ cl::Program program(context, devices, binaries);
+ program.build();
+ CLKernelLibrary::get().add_built_program(name, program);
+ }
+ cache_file.close();
+ }
+}
+
+void save_program_cache_to_file(const std::string &filename)
+{
+ if(CLScheduler::get().is_initialised())
+ {
+ std::ofstream cache_file(filename, std::ios::binary | std::ios::app);
+ if(cache_file.is_open())
+ {
+ for(const auto &it : CLKernelLibrary::get().get_new_built_programs())
+ {
+ std::vector<std::vector<unsigned char>> binaries = it.second.getInfo<CL_PROGRAM_BINARIES>();
+ ARM_COMPUTE_ERROR_ON(binaries.size() != 1);
+ const std::string kernel_name = it.first;
+ size_t kernel_name_size = kernel_name.length();
+ size_t binary_size = binaries[0].size();
+ cache_file.write(reinterpret_cast<char *>(&kernel_name_size), sizeof(size_t));
+ cache_file.write(reinterpret_cast<char *>(&binary_size), sizeof(size_t));
+ cache_file.write(kernel_name.c_str(), kernel_name_size);
+ cache_file.write(reinterpret_cast<const char *>(binaries[0].data()), binaries[0].size());
+ }
+ cache_file.close();
+ CLKernelLibrary::get().get_new_built_programs().clear();
+ }
+ else
+ {
+ ARM_COMPUTE_ERROR("Cannot open cache file");
+ }
+ }
+}
+} // namespace arm_compute
return 0;
}
-/** This function loads prebuilt opencl kernels from a file
- *
- * @param[in] filename Name of the file to be used to load the kernels
- */
-void restore_program_cache_from_file(const std::string &filename)
-{
-#ifdef ARM_COMPUTE_CL
- std::ifstream cache_file(filename, std::ios::binary);
- if(cache_file.is_open())
- {
- if(!CLScheduler::get().is_initialised())
- {
- arm_compute::CLScheduler::get().default_init();
- }
-
- while(!cache_file.eof())
- {
- size_t name_len = 0;
- size_t binary_len = 0;
- cache_file.read(reinterpret_cast<char *>(&name_len), sizeof(size_t));
- cache_file.read(reinterpret_cast<char *>(&binary_len), sizeof(size_t));
- if(name_len == 0 || binary_len == 0)
- {
- break;
- }
- std::vector<char> tmp(name_len);
- std::vector<unsigned char> binary(binary_len);
- std::string name;
- cache_file.read(tmp.data(), name_len);
- name.assign(tmp.data(), name_len);
- tmp.resize(binary_len);
- cache_file.read(reinterpret_cast<char *>(binary.data()), binary_len);
- cl::Context context = arm_compute::CLScheduler::get().context();
- cl::Program::Binaries binaries{ binary };
- std::vector<cl::Device> devices = context.getInfo<CL_CONTEXT_DEVICES>();
- cl::Program program(context, devices, binaries);
- program.build();
- CLKernelLibrary::get().add_built_program(name, program);
- }
- cache_file.close();
- }
-#else /* ARM_COMPUTE_CL */
- ARM_COMPUTE_UNUSED(filename);
-#endif /* ARM_COMPUTE_CL */
-}
-
-/** This function saves opencl kernels library to a file
- *
- * @param[in] filename Name of the file to be used to save the library
- */
-void save_program_cache_to_file(const std::string &filename)
-{
-#ifdef ARM_COMPUTE_CL
- if(CLScheduler::get().is_initialised())
- {
- std::ofstream cache_file(filename, std::ios::binary);
- if(cache_file.is_open())
- {
- for(const auto &it : CLKernelLibrary::get().get_built_programs())
- {
- std::vector<std::vector<unsigned char>> binaries = it.second.getInfo<CL_PROGRAM_BINARIES>();
- ARM_COMPUTE_ERROR_ON(binaries.size() != 1);
- const std::string kernel_name = it.first;
- size_t kernel_name_size = kernel_name.length();
- size_t binary_size = binaries[0].size();
- cache_file.write(reinterpret_cast<char *>(&kernel_name_size), sizeof(size_t));
- cache_file.write(reinterpret_cast<char *>(&binary_size), sizeof(size_t));
- cache_file.write(kernel_name.c_str(), kernel_name_size);
- cache_file.write(reinterpret_cast<const char *>(binaries[0].data()), binaries[0].size());
- }
- cache_file.close();
- }
- else
- {
- ARM_COMPUTE_ERROR("Cannot open cache file");
- }
- }
-#else /* ARM_COMPUTE_CL */
- ARM_COMPUTE_UNUSED(filename);
-#endif /* ARM_COMPUTE_CL */
-}
} // namespace utils
} // namespace arm_compute
return num_mismatches;
}
-/** This function saves opencl kernels library to a file
- *
- * @param[in] filename Name of the file to be used to save the library
- */
-void save_program_cache_to_file(const std::string &filename = "cache.bin");
-
-/** This function loads prebuilt opencl kernels from a file
- *
- * @param[in] filename Name of the file to be used to load the kernels
- */
-void restore_program_cache_from_file(const std::string &filename = "cache.bin");
} // namespace utils
} // namespace arm_compute
#endif /* __UTILS_UTILS_H__*/
projects / platform / upstream / armcl.git / commitdiff