perf: prefetch next ListObjects page while consumer iterates current page

include/miniocpp/client.h

@@ -40,17 +40,27 @@ class ListObjectsResult {
   bool failed_ = false;
   ListObjectsResponse resp_;
   std::list<Item>::iterator itr_;
+  std::shared_ptr<std::future<ListObjectsResponse>> prefetch_future_;
 
   void Populate();
+  void StartPrefetch();
+  void UpdatePaginationArgs();
 
  public:
   explicit ListObjectsResult(error::Error err);
   ListObjectsResult(Client* const client, const ListObjectsArgs& args);
   ListObjectsResult(Client* const client, ListObjectsArgs&& args);
   ~ListObjectsResult() = default;
+  ListObjectsResult(const ListObjectsResult&) = delete;
+  ListObjectsResult& operator=(const ListObjectsResult&) = delete;
+  ListObjectsResult(ListObjectsResult&&) = default;
+  ListObjectsResult& operator=(ListObjectsResult&&) = default;
 
   Item& operator*() const { return *itr_; }
-  explicit operator bool() const { return itr_ != resp_.contents.end(); }
+  explicit operator bool() {
+    if (prefetch_future_ && resp_.contents.empty()) Populate();
+    return itr_ != resp_.contents.end();
+  }
 
   ListObjectsResult& operator++() {
     itr_++;
@@ -60,11 +70,7 @@ class ListObjectsResult {
     return *this;
   }
 
-  ListObjectsResult operator++(int) {
-    ListObjectsResult curr = *this;
-    ++(*this);
-    return curr;
-  }
+  void operator++(int) { ++(*this); }
 };  // class ListObjectsResult
 
 class RemoveObjectsResult {

include/miniocpp/response.h

@@ -298,6 +298,10 @@ struct ListObjectsResponse : public Response {
   std::string_view next_version_id_marker;
 
   ListObjectsResponse() = default;
+  ListObjectsResponse(const ListObjectsResponse&) = delete;
+  ListObjectsResponse& operator=(const ListObjectsResponse&) = delete;
+  ListObjectsResponse(ListObjectsResponse&&) = default;
+  ListObjectsResponse& operator=(ListObjectsResponse&&) = default;
 
   explicit ListObjectsResponse(error::Error err) : Response(std::move(err)) {}
 

src/client.cc

@@ -141,16 +141,16 @@ ListObjectsResult::ListObjectsResult(error::Error err) : failed_(true) {
 ListObjectsResult::ListObjectsResult(Client* const client,
                                      const ListObjectsArgs& args)
     : client_(client), args_(args) {
-  Populate();
+  StartPrefetch();
 }
 
 ListObjectsResult::ListObjectsResult(Client* const client,
                                      ListObjectsArgs&& args)
     : client_(client), args_(std::move(args)) {
-  Populate();
+  StartPrefetch();
 }
 
-void ListObjectsResult::Populate() {
+void ListObjectsResult::UpdatePaginationArgs() {
   if (args_.include_versions) {
     args_.key_marker = resp_.next_key_marker;
     args_.version_id_marker = resp_.next_version_id_marker;
@@ -160,34 +160,55 @@ void ListObjectsResult::Populate() {
     args_.start_after = resp_.start_after;
     args_.continuation_token = resp_.next_continuation_token;
   }
+}
 
-  std::string region;
-  if (GetRegionResponse resp = client_->GetRegion(args_.bucket, args_.region)) {
-    region = resp.region;
-    if (args_.recursive) {
-      args_.delimiter = "";
-    } else if (args_.delimiter.empty()) {
-      args_.delimiter = "/";
-    }
-
-    if (args_.include_versions || !args_.version_id_marker.empty()) {
-      resp_ = client_->ListObjectVersions(ListObjectVersionsArgs(args_));
-    } else if (args_.use_api_v1) {
-      resp_ = client_->ListObjectsV1(ListObjectsV1Args(args_));
-    } else {
-      resp_ = client_->ListObjectsV2(ListObjectsV2Args(args_));
-    }
+void ListObjectsResult::StartPrefetch() {
+  ListObjectsArgs next_args = args_;
+  prefetch_future_ =
+      std::make_shared<std::future<ListObjectsResponse>>(std::async(
+          std::launch::async,
+          [client = client_, next_args = std::move(next_args)]() mutable {
+            std::string region;
+            if (GetRegionResponse resp =
+                    client->GetRegion(next_args.bucket, next_args.region)) {
+              next_args.region = resp.region;
+              if (next_args.recursive) {
+                next_args.delimiter = "";
+              } else if (next_args.delimiter.empty()) {
+                next_args.delimiter = "/";
+              }
+
+              if (next_args.include_versions ||
+                  !next_args.version_id_marker.empty()) {
+                return client->ListObjectVersions(
+                    ListObjectVersionsArgs(next_args));
+              } else if (next_args.use_api_v1) {
+                return client->ListObjectsV1(ListObjectsV1Args(next_args));
+              } else {
+                return client->ListObjectsV2(ListObjectsV2Args(next_args));
+              }
+            }
+            return ListObjectsResponse(
+                error::make<ListObjectsResponse>("unable to get region"));
+          }));
+}
 
-    if (!resp_) {
-      failed_ = true;
-      resp_.contents.push_back(Item(resp_));
-    }
-  } else {
+void ListObjectsResult::Populate() {
+  if (!prefetch_future_ || !prefetch_future_->valid()) {
+    return;
+  }
+  resp_ = prefetch_future_->get();
+  prefetch_future_.reset();
+  if (!resp_) {
     failed_ = true;
-    resp_.contents.push_back(Item(resp));
+    resp_.contents.push_back(Item(resp_));
   }
-
   itr_ = resp_.contents.begin();
+
+  if (resp_ && resp_.is_truncated) {
+    UpdatePaginationArgs();
+    StartPrefetch();
+  }
 }
 
 RemoveObjectsResult::RemoveObjectsResult(error::Error err) {