Add Modulecache::GetAndPut method which wraps sequence of Get and Put (if module wasn't found in cache) calls.

[ovyalov]

Summary

Now module cache isn't thread/process-safe and cannot be properly used with concurrent remote test execution - there is no synchronization between module's downloading and Put calls.
This CL puts together module's downloading and insertion into cache and prepares ground for synchronization.
With a follow-up CL I'm planning to add file-based locking per each module which is in the middle of GetAndPut call - so, it will be safe to use module cache in multi-threaded/process environment.

[ovyalov]

AFFECTED FILES

/lldb/trunk/source/Target/Platform.cpp
/lldb/trunk/source/Utility/ModuleCache.cpp
/lldb/trunk/source/Utility/ModuleCache.h

USERS

ovyalov (Author)

http://reviews.llvm.org/rL235011

source/Target/Platform.cpp

 #include "lldb/Host/HostInfo.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 #include "lldb/Interpreter/Property.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/FileUtilities.h"
 
 #include "Utility/ModuleCache.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;
 

 {
     if (IsHost() ||
         !GetGlobalPlatformProperties ()->GetUseModuleCache ())
         return false;
 
     Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM);
 
     // Check local cache for a module.
-    auto error = m_module_cache->Get (GetModuleCacheRoot (),
-                                      GetCacheHostname (),
-                                      module_spec,
-                                      module_sp,
-                                      did_create_ptr);
-    if (error.Success ())
-        return true;
-
-    if (log)
-        log->Printf("Platform::%s - module %s not found in local cache: %s",
-                    __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());
-
+    auto error = m_module_cache->GetAndPut (
+        GetModuleCacheRoot (),
+        [=](const ModuleSpec &module_spec, FileSpec &tmp_download_file_spec)
+        {
             // Get temporary file name for a downloaded module.
             llvm::SmallString<PATH_MAX> tmp_download_file_path;
             const auto err_code = llvm::sys::fs::createTemporaryFile (
                 "lldb", module_spec.GetUUID ().GetAsString ().c_str (), tmp_download_file_path);
             if (err_code)
-    {
-        if (log)
-            log->Printf ("Platform::%s - failed to create unique file: %s",
-                         __FUNCTION__, err_code.message ().c_str ());
-        return false;
-    }
-
-    llvm::FileRemover tmp_file_remover (tmp_download_file_path.c_str ());
+                return Error ("Failed to create temp file: %s", err_code.message ().c_str ());
 
-    const FileSpec tmp_download_file_spec (tmp_download_file_path.c_str (), true);
-    // Download a module file.
-    error = DownloadModuleSlice (module_spec.GetFileSpec (),
+            tmp_download_file_spec.SetFile (tmp_download_file_path.c_str (), true);
+            return DownloadModuleSlice (module_spec.GetFileSpec (),
                                         module_spec.GetObjectOffset (),
                                         module_spec.GetObjectSize (),
                                         tmp_download_file_spec);
-    if (error.Fail ())
-    {
-        if (log)
-            log->Printf("Platform::%s - failed to download %s to %s: %s",
-                        __FUNCTION__, module_spec.GetFileSpec ().GetPath ().c_str (),
-                        tmp_download_file_path.c_str (), error.AsCString ());
-        return false;
-    }
 
-    // Put downloaded file into local module cache.
-    error = m_module_cache->Put (GetModuleCacheRoot (),
-                                 GetCacheHostname (),
-                                 module_spec,
-                                 tmp_download_file_spec);
-    if (error.Fail ())
-    {
-        if (log)
-            log->Printf("Platform::%s - failed to put module %s into cache: %s",
-                        __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (),
-                        error.AsCString ());
-        return false;
-    }
-
-    error = m_module_cache->Get (GetModuleCacheRoot (),
-                                 GetCacheHostname (),
-                                 module_spec,
-                                 module_sp,
-                                 did_create_ptr);
-    return error.Success ();
+        },
+    if (error.Success ())
+        return true;
+
+    if (log)
+        log->Printf("Platform::%s - module %s not found in local cache: %s",
+                    __FUNCTION__, module_spec.GetUUID ().GetAsString ().c_str (), error.AsCString ());
+    return false;
 }
 
 Error
 Platform::DownloadModuleSlice (const FileSpec& src_file_spec,
                                const uint64_t src_offset,
                                const uint64_t src_size,
                                const FileSpec& dst_file_spec)
 {

source/Utility/ModuleCache.h

 #define utility_ModuleCache_h_
 
 #include "lldb/lldb-types.h"
 #include "lldb/lldb-forward.h"
 
 #include "lldb/Core/Error.h"
 #include "lldb/Host/FileSpec.h"
 
+#include <functional>
 #include <string>
 #include <unordered_map>
 
 namespace lldb_private {
 
 class Module;
 class UUID;
 

 /// Example:
 /// UUID view   : /tmp/lldb/remote-linux/.cache/30C94DC6-6A1F-E951-80C3-D68D2B89E576-D5AE213C/libc.so.6
 /// Sysroot view: /tmp/lldb/remote-linux/ubuntu/lib/x86_64-linux-gnu/libc.so.6
 //----------------------------------------------------------------------
 
 class ModuleCache
 {
 public:
+    using Downloader = std::function<Error (const ModuleSpec&, FileSpec&)>;
+
     Error
     Put (const FileSpec &root_dir_spec,
          const char *hostname,
          const ModuleSpec &module_spec,
          const FileSpec &tmp_file);
 
     Error
     Get (const FileSpec &root_dir_spec,
          const char *hostname,
          const ModuleSpec &module_spec,
          lldb::ModuleSP &cached_module_sp,
          bool *did_create_ptr);
 
+    Error
+    GetAndPut(const FileSpec &root_dir_spec,
+              const char *hostname,
+              const ModuleSpec &module_spec,
+              const Downloader &downloader,
+              lldb::ModuleSP &cached_module_sp,
+              bool *did_create_ptr);
+
 private:
     static FileSpec
     GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid);
 
     static FileSpec
     GetHostSysRootModulePath (const FileSpec &root_dir_spec, const char *hostname, const FileSpec &platform_module_spec);
 
     static Error
     CreateHostSysRootModuleSymLink (const FileSpec &sysroot_module_path_spec, const FileSpec &module_file_path);
 
     std::unordered_map<std::string, lldb::ModuleWP> m_loaded_modules;
 };
 
 } // namespace lldb_private
 
 #endif  // utility_ModuleCache_h_

source/Utility/ModuleCache.cpp

 //===--------------------- ModuleCache.cpp ----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ModuleCache.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/FileUtilities.h"
 
 #include <assert.h>
 
 #include <cstdio>
 #
 using namespace lldb;
 using namespace lldb_private;
 
ModuleCache::Get (const FileSpec &root_dir_spec,
     if (did_create_ptr)
         *did_create_ptr = true;
 
     m_loaded_modules.insert (std::make_pair (module_spec.GetUUID ().GetAsString (), cached_module_sp));
 
     return Error ();
 }
 
+Error
+ModuleCache::GetAndPut (const FileSpec &root_dir_spec,
+                        const char *hostname,
+                        const ModuleSpec &module_spec,
+                        const Downloader &downloader,
+                        lldb::ModuleSP &cached_module_sp,
+                        bool *did_create_ptr)
+{
+    // Check local cache for a module.
+    auto error = Get (root_dir_spec,
+                      hostname,
+                      module_spec,
+                      cached_module_sp,
+                      did_create_ptr);
+    if (error.Success ())
+        return error;
+
+    FileSpec tmp_download_file_spec;
+    error = downloader (module_spec, tmp_download_file_spec);
+    llvm::FileRemover tmp_file_remover (tmp_download_file_spec.GetPath ().c_str ());
+    if (error.Fail ())
+        return Error("Failed to download module: %s", error.AsCString ());
+
+    // Put downloaded file into local module cache.
+    error = Put (root_dir_spec,
+                 hostname,
+                 module_spec,
+                 tmp_download_file_spec);
+    if (error.Fail ())
+        return Error ("Failed to put module into cache: %s", error.AsCString ());
+
+    return Get (root_dir_spec,
+                hostname,
+                module_spec,
+                cached_module_sp,
+                did_create_ptr);
+}
+
 FileSpec
 ModuleCache::GetModuleDirectory (const FileSpec &root_dir_spec, const UUID &uuid)
 {
     const auto modules_dir_spec = JoinPath (root_dir_spec, kModulesSubdir);
     return JoinPath (modules_dir_spec, uuid.GetAsString ().c_str ());
 }
 
 FileSpec