Parallel asset download (#2992)

This will download simulation assets in background threads by default. You can force simulation to wait for assets using the --wait-for-assets CLI option. I'm defaulting to async download because:

It's a better user experience to have some instant GUI feedback.
If you're using only the simulation server (no GUI), then you're in the experienced user category and can choose whether to wait for assets or not.
---------

Signed-off-by: Nate Koenig <natekoenig@gmail.com>
Signed-off-by: Addisu Z. Taddese <addisu@openrobotics.org>
Co-authored-by: Addisu Z. Taddese <addisu@openrobotics.org>

Author: nkoenig

examples/worlds/tunnel.sdf

@@ -213,7 +213,7 @@
     <include>
       <pose>9.23 2.18 0 0 0 -1.226</pose>
       <uri>
-        https://fuel.gazebosim.org/1.0/chapulina/models/Extinguisher PBR
+        https://fuel.gazebosim.org/1.0/OpenRobotics/models/Fire Extinguisher
       </uri>
     </include>
 

include/gz/sim/ServerConfig.hh

@@ -447,6 +447,20 @@ namespace gz
       public: const std::chrono::time_point<std::chrono::system_clock> &
               Timestamp() const;
 
+      /// \brief Set whether simulation should wait for assets to
+      /// download before starting.
+      /// The default value is true.
+      /// \param[in] _set True to wait while assets download. False will
+      /// download assets in a background thread.
+      public: void SetWaitForAssets(bool _set);
+
+      /// \brief Get whether simulation should wait for assets to
+      /// download before starting.
+      /// The default value is true.
+      /// \return True if simulation should wait while assets download. False
+      /// indicates assets should be downloaded in a separate thread.
+      public: bool WaitForAssets() const;
+
       /// \brief Get the type of source
       /// \return The source type.
       public: SourceType Source() const;

src/Server.cc

@@ -69,6 +69,11 @@ Server::Server(const ServerConfig &_config)
     config.SetCacheLocation(_config.ResourceCache());
   this->dataPtr->fuelClient = std::make_unique<fuel_tools::FuelClient>(config);
 
+  // Turn off downloads so that we can do an initial parsing of the SDF
+  // file. This will let us get the world names, and queue the simulation asset
+  // URIs for download.
+  this->dataPtr->enableDownload = false;
+
   // Configure SDF to fetch assets from Gazebo Fuel.
   sdf::setFindCallback(std::bind(&ServerPrivate::FetchResource,
         this->dataPtr.get(), std::placeholders::_1));
@@ -77,42 +82,62 @@ Server::Server(const ServerConfig &_config)
 
   addResourcePaths();
 
+  sdf::Root sdfRoot;
+
   // Loads the SDF root object based on values in a ServerConfig object.
-  sdf::Errors errors = this->dataPtr->LoadSdfRootHelper(_config);
+  // Ignore the sdf::Errors returned by this function. The errors will be
+  // displayed later in the downloadThread.
+  ServerConfig cfg = _config;
+  cfg.SetBehaviorOnSdfErrors(
+    ServerConfig::SdfErrorBehavior::CONTINUE_LOADING);
+  sdf::Errors errors = this->dataPtr->LoadSdfRootHelper(
+    cfg, sdfRoot);
 
-  if (!errors.empty())
+  // Add record plugin
+  if (_config.UseLogRecord())
   {
-    for (auto &err : errors)
-      gzerr << err << "\n";
-    if (_config.BehaviorOnSdfErrors() ==
-        ServerConfig::SdfErrorBehavior::EXIT_IMMEDIATELY)
-    {
-      return;
-    }
+    this->dataPtr->AddRecordPlugin(_config, sdfRoot);
   }
 
-  // Add record plugin
-  if (_config.UseLogRecord())
+  // Remove all the models, lights, and actors from the primary sdfRoot object
+  // so that they can be downloaded and added to simulation in the background.
+  for (uint64_t i = 0; i < sdfRoot.WorldCount(); ++i)
   {
-    this->dataPtr->AddRecordPlugin(_config);
+    sdfRoot.WorldByIndex(i)->ClearModels();
+    sdfRoot.WorldByIndex(i)->ClearActors();
+    sdfRoot.WorldByIndex(i)->ClearLights();
   }
 
+  // This will create the simulation runners, but not entities.
+  this->dataPtr->CreateSimulationRunners(sdfRoot);
+
+  // Storing the sdf root. The ServerPrivate.hh header file mentions
+  // that other classes may keep pointers to child nodes of the root,
+  // so we need to keep this object around.
+  // However, everything seems to work fine without storing this.
+  // \todo(nkoenig): Look into removing the sdfRoot member variable.
+  this->dataPtr->sdfRoot = sdfRoot;
+
+  // Establish publishers and subscribers. Setup transport before
+  // downloading simulation assets so that the GUI is not blocked during
+  // download.
+  this->dataPtr->SetupTransport();
+
   // If we've received a signal before we create entities, the Stop event
   // won't be propagated to them. Instead, we just quit early here.
   if (this->dataPtr->signalReceived)
     return;
 
-  this->dataPtr->CreateEntities();
+  // Download the simulation assets. This function will block if
+  // _config.WaitForAssets() is true;
+  this->dataPtr->DownloadAssets(_config);
 
   // Set the desired update period, this will override the desired RTF given in
-  // the world file which was parsed by CreateEntities.
+  // the world file which was parsed by LoadSdfRootHelper.
   if (_config.UpdatePeriod())
   {
     this->SetUpdatePeriod(_config.UpdatePeriod().value());
   }
-
-  // Establish publishers and subscribers.
-  this->dataPtr->SetupTransport();
 }
 
 /////////////////////////////////////////////////

src/ServerConfig.cc

@@ -212,8 +212,10 @@ class gz::sim::ServerConfigPrivate
             seed(_cfg->seed),
             logRecordTopics(_cfg->logRecordTopics),
             isHeadlessRendering(_cfg->isHeadlessRendering),
+            sdfRoot(_cfg->sdfRoot),
             source(_cfg->source),
-            behaviorOnSdfErrors(_cfg->behaviorOnSdfErrors){ }
+            behaviorOnSdfErrors(_cfg->behaviorOnSdfErrors),
+            waitForAssets(_cfg->waitForAssets) { }
 
   // \brief The SDF file that the server should load
   public: std::string sdfFile = "";
@@ -293,14 +295,17 @@ class gz::sim::ServerConfigPrivate
   public: bool isHeadlessRendering{false};
 
   /// \brief Optional SDF root object.
-  public: std::optional<sdf::Root> sdfRoot;
+  public: std::optional<sdf::Root> sdfRoot{std::nullopt};
 
   /// \brief Type of source used.
   public: ServerConfig::SourceType source{ServerConfig::SourceType::kNone};
 
   /// \brief Server loading behavior in presence of SDF errors.
   public: ServerConfig::SdfErrorBehavior behaviorOnSdfErrors{
       ServerConfig::SdfErrorBehavior::EXIT_IMMEDIATELY};
+
+  /// \brief True to block while simulation assets download.
+  public: bool waitForAssets{true};
 };
 
 //////////////////////////////////////////////////
@@ -741,6 +746,18 @@ ServerConfig::Timestamp() const
   return this->dataPtr->timestamp;
 }
 
+/////////////////////////////////////////////////
+void ServerConfig::SetWaitForAssets(bool _set)
+{
+  this->dataPtr->waitForAssets = _set;
+}
+
+/////////////////////////////////////////////////
+bool ServerConfig::WaitForAssets() const
+{
+  return this->dataPtr->waitForAssets;
+}
+
 /////////////////////////////////////////////////
 void ServerConfig::AddLogRecordTopic(const std::string &_topic)
 {