reorganized mutexes and locks; passes test

src/register_target.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -34,59 +34,88 @@ inline namespace MIGRAPHX_INLINE_NS {
 void store_target_lib(const dynamic_loader& lib)
 {
     static std::vector<dynamic_loader> target_loader;
-    std::mutex mutex;
+    static std::mutex mutex;
     std::unique_lock<std::mutex> lock(mutex);
 
     target_loader.emplace_back(lib);
 }
 
+/**
+ * Returns a singleton map of targets and names.
+ */
 std::unordered_map<std::string, target>& target_map()
 {
     static std::unordered_map<std::string, target> m; // NOLINT
     return m;
 }
 
+/**
+ * Returns a singleton mutex used by the various register_target methods.
+ */
+std::mutex& target_mutex()
+{
+    static std::mutex m; // NOLINT
+    return m;
+}
+
 void register_target_init() { (void)target_map(); }
 
 void unregister_target(const std::string& name)
 {
-    std::mutex mutex;
-    std::unique_lock<std::mutex> lock(mutex);
+    std::unique_lock<std::mutex> lock(target_mutex());
     assert(target_map().count(name));
     target_map().erase(name);
 }
 
+/**
+ * Insert a target name in the target_map; thread safe.
+ */
 void register_target(const target& t)
 {
-    std::mutex mutex;
-    std::unique_lock<std::mutex> lock(mutex);
-
+    std::unique_lock<std::mutex> lock(target_mutex());
     target_map()[t.name()] = t;
 }
 
-target make_target(const std::string& name)
+/**
+ * Search for a target by name in the target_map; thread-safe.
+ */
+migraphx::optional<target> find_target(const std::string& name)
 {
-    // debug
-    for(auto pp : target_map())
-        std::cout << pp.first << "\n";
+    // search for match or return none
+    std::unique_lock<std::mutex> lock(target_mutex());
+    const auto it = target_map().find(name);
 
-    std::mutex mutex;
-    std::unique_lock<std::mutex> lock(mutex);
-    if(not contains(target_map(), name))
+    if(it == target_map().end())
+        return nullopt;
+    return it->second;
+}
+
+/**
+ * Get a target by name.  Load target library and register target if needed.
+ * Thread safe.
+ */
+target make_target(const std::string& name)
+{
+    //   no lock required here
+    auto t = find_target(name);
+    if(t == nullopt)
     {
         std::string target_name = "libmigraphx_" + name + ".so";
+        // register_target is called by this
         store_target_lib(dynamic_loader(target_name));
+        t = find_target(name);
     }
-    const auto it = target_map().find(name);
-    if(it == target_map().end())
-    {
-        MIGRAPHX_THROW("Requested target '" + name + "' is not loaded or not supported");
-    }
-    return it->second;
+    // at this point we should always have a target
+
+    return *t;
 }
 
+/**
+ * Get list of names of registered targets.
+ */
 std::vector<std::string> get_targets()
 {
+    std::unique_lock<std::mutex> lock(target_mutex());
     std::vector<std::string> result;
     std::transform(target_map().begin(),
                    target_map().end(),

test/targets.cpp

@@ -57,7 +57,7 @@ TEST_CASE(concurrent_targets)
 {
     std::vector<std::thread> threads;
 
-    for(auto i = 0u; i < 10000; i++)
+    for(auto i = 0u; i < 1000; i++)
     {
         auto thread_body = []() {
             auto ref_target = migraphx::make_target("gpu");