Optimize hashing of program source for the purpose of offline caching

Author: ddemidov

vexcl/backend/common.hpp

@@ -182,20 +182,30 @@ inline std::string program_binaries_path(const std::string &hash, bool create =
     return dir + path_delim();
 }
 
-/// Returns SHA1 hash of the string parameter.
-inline std::string sha1(const std::string &src) {
-    boost::uuids::detail::sha1 sha1;
-    sha1.process_bytes(src.c_str(), src.size());
-
-    unsigned int hash[5];
-    sha1.get_digest(hash);
-
-    std::ostringstream buf;
-    for(int i = 0; i < 5; ++i)
-        buf << std::hex << std::setfill('0') << std::setw(8) << hash[i];
-
-    return buf.str();
-}
+/// SHA1 hasher.
+class sha1_hasher {
+    public:
+        sha1_hasher(const std::string &s = "") {
+            if (!s.empty()) (*this)(s);
+        }
+
+        void operator()(const std::string &s) {
+            h.process_bytes(s.c_str(), s.size());
+        }
+
+        operator std::string() {
+            unsigned int digest[5];
+            h.get_digest(digest);
+
+            std::ostringstream buf;
+            for(int i = 0; i < 5; ++i)
+                buf << std::hex << std::setfill('0') << std::setw(8) << digest[i];
+
+            return buf.str();
+        }
+    private:
+        boost::uuids::detail::sha1 h;
+};
 
 } // namespace vex
 

vexcl/backend/cuda/compiler.hpp

@@ -63,15 +63,17 @@ inline CUmodule build_sources(
 
     queue.context().set_current();
 
+    sha1_hasher sha1(source);
+
+    sha1(queue.device().name());
+    sha1(options);
+
     auto cc = queue.device().compute_capability();
-    std::ostringstream fullsrc;
-    fullsrc << "// Device:  " << queue.device().name() << "\n"
-            << "// CC:      " << std::get<0>(cc) << "." << std::get<1>(cc) << "\n"
-            << "// options: " << options << "\n"
-            << source;
+    sha1(std::to_string(std::get<0>(cc)) + std::to_string(std::get<1>(cc)));
+
+    std::string hash = static_cast<std::string>(sha1);
 
     // Write source to a .cu file
-    std::string hash = sha1( fullsrc.str() );
     std::string basename = program_binaries_path(hash, true) + "kernel";
     std::string ptxfile  = basename + ".ptx";
 
@@ -81,20 +83,19 @@ inline CUmodule build_sources(
 
         {
             std::ofstream f(basename + ".cu");
-            f << fullsrc.str();
+            f << source;
         }
 
         // Compile the source to ptx.
         std::ostringstream cmdline;
-        auto cc = queue.device().compute_capability();
         cmdline
             << "nvcc -ptx -O3"
             << " -arch=sm_" << std::get<0>(cc) << std::get<1>(cc)
             << " " << options
             << " -o " << ptxfile << " " << cufile;
         if (0 != system(cmdline.str().c_str()) ) {
 #ifndef VEXCL_SHOW_KERNELS
-            std::cerr << fullsrc.str() << std::endl;
+            std::cerr << source << std::endl;
 #endif
 
             vex::detail::print_backtrace();

vexcl/backend/opencl/compiler.hpp

@@ -49,7 +49,7 @@ namespace opencl {
 
 /// Saves program binaries for future reuse.
 inline void save_program_binaries(
-        const std::string &hash, const cl::Program &program, const std::string &source
+        const std::string &hash, const cl::Program &program
         )
 {
     // Prevent writing to the same file by several threads at the same time.
@@ -67,8 +67,6 @@ inline void save_program_binaries(
     bfile.write((char*)&sizes[0], sizeof(size_t));
     bfile.write(binaries[0], sizes[0]);
     delete[] binaries[0];
-
-    bfile << "\n" << source << "\n";
 }
 
 /// Tries to read program binaries from file cache.
@@ -133,12 +131,14 @@ inline cl::Program build_sources(
 
 #ifdef VEXCL_CACHE_KERNELS
     // Get unique (hopefully) hash string for the kernel.
-    std::ostringstream fullsrc;
+    sha1_hasher sha1(source);
+
+    sha1(cl::Platform(device[0].getInfo<CL_DEVICE_PLATFORM>()).getInfo<CL_PLATFORM_NAME>());
+    sha1(device[0].getInfo<CL_DEVICE_NAME>());
+    sha1(compile_options);
 
-    fullsrc
-        << "// Platform: " << cl::Platform(device[0].getInfo<CL_DEVICE_PLATFORM>()).getInfo<CL_PLATFORM_NAME>()
-        << "\n// Device:   " << device[0].getInfo<CL_DEVICE_NAME>()
-        << "\n// Compiler: "
+    std::ostringstream compiler_tag;
+    compiler_tag
 #if defined(_MSC_VER)
         << "MSC " << _MSC_VER
 #elif defined(__clang__)
@@ -148,10 +148,10 @@ inline cl::Program build_sources(
 #else
         << "unknown"
 #endif
-        << "\n// options:  " << compile_options
-        << "\n" << source;
+        ;
+    sha1(compiler_tag.str());
 
-    std::string hash = sha1( fullsrc.str() );
+    std::string hash = static_cast<std::string>(sha1);
 
     // Try to get cached program binaries:
     try {
@@ -181,7 +181,7 @@ inline cl::Program build_sources(
 
 #ifdef VEXCL_CACHE_KERNELS
     // Save program binaries for future reuse:
-    save_program_binaries(hash, program, fullsrc.str());
+    save_program_binaries(hash, program);
 #endif
 
     return program;