Refactor GenericPieces to inherit from GenericPiecesBase

Summary:
**Context**
Multi range support requires same piecewise logic but the request can contain non-contiguous ranges.
Refactor `GenericPieces`, so that we can implement a "multi range" piece iteration class based on `GenericPiecesBase`.

**Change**
- Isolate the generic piece related variables / methods into a base class `GenericPiecesBase`.
- Keep request and piece iteration related logic within `GenericPieces`.

Reviewed By: tang-jianfeng

Differential Revision: D88178507

fbshipit-source-id: 96b306739d44995bae098bd960572dd2fd1adcc7

Author: Fenchao Du

cachelib/common/piecewise/GenericPieces.cpp

@@ -16,12 +16,8 @@
 
 #include "cachelib/common/piecewise/GenericPieces.h"
 
-#include <folly/Conv.h>
-#include <folly/String.h>
 #include <folly/logging/xlog.h>
 
-#include <vector>
-
 namespace facebook {
 namespace cachelib {
 
@@ -30,20 +26,11 @@ GenericPieces::GenericPieces(const std::string& baseKey,
                              uint64_t piecesPerGroup,
                              uint64_t fullBodyLen,
                              const RequestRange* range)
-    : baseKey_(baseKey),
-      pieceSize_(pieceSize),
-      numPiecesPerGroup_(piecesPerGroup),
-      fullBodyLen_(fullBodyLen) {
-  XCHECK(fullBodyLen > 0);
-
-  numPiecesTotal_ = calculateNumPiecesTotal(fullBodyLen_, pieceSize_);
-
-  // Figure out the first and last bytes/pieces we need to fetch
-  requestedStartByte_ = 0;
-  requestedEndByte_ = fullBodyLen_ - 1;
-  startPieceIndex_ = 0;
-  endPieceIndex_ = numPiecesTotal_ - 1;
-
+    : GenericPiecesBase(baseKey, pieceSize, piecesPerGroup, fullBodyLen),
+      requestedStartByte_{0},
+      requestedEndByte_{fullBodyLen - 1},
+      startPieceIndex_{0},
+      endPieceIndex_{numPiecesTotal_ - 1} {
   if (range) {
     resetFromRequestRange(*range);
   }
@@ -70,65 +57,10 @@ void GenericPieces::resetFromRequestRange(const RequestRange& range) {
   firstByteOffsetToFetch_ = startPieceIndex_ * pieceSize_;
 }
 
-std::string GenericPieces::escapeCacheKey(const std::string& key) {
-  std::vector<folly::StringPiece> parts;
-  folly::split(kCachePieceSeparator, key, parts);
-  if (parts.size() == 1) {
-    return key;
-  }
-  std::string escapeSeparator =
-      folly::to<std::string>(kCachePieceSeparator, kCachePieceSeparator);
-
-  std::string ret;
-  folly::join(escapeSeparator, parts, ret);
-  return ret;
-}
-
 uint64_t GenericPieces::getTargetNumPieces() const {
   XDCHECK_GE(endPieceIndex_, startPieceIndex_);
   return (endPieceIndex_ - startPieceIndex_) + 1;
 }
 
-std::string GenericPieces::createPieceHeaderKey(const std::string& baseKey,
-                                                uint64_t versionID) {
-  return folly::to<std::string>(
-      baseKey, kCachePieceSeparator, "header-", versionID);
-}
-
-std::string GenericPieces::createPieceKey(const std::string& baseKey,
-                                          size_t pieceNum,
-                                          uint64_t piecesPerGroup,
-                                          uint64_t versionID) {
-  uint64_t groupNum = 0;
-  if (piecesPerGroup > 0) {
-    groupNum = pieceNum / piecesPerGroup;
-  }
-  if (groupNum == 0) {
-    return folly::to<std::string>(
-        baseKey, kCachePieceSeparator, "body-", versionID, "-", pieceNum);
-  } else {
-    return folly::to<std::string>(baseKey,
-                                  kCacheGroupSeparator,
-                                  groupNum,
-                                  kCachePieceSeparator,
-                                  "body-",
-                                  versionID,
-                                  "-",
-                                  pieceNum);
-  }
-}
-
-folly::StringPiece GenericPieces::getBaseKey(folly::StringPiece key) {
-  auto found = key.find(kCacheGroupSeparator);
-  if (found == folly::StringPiece::npos) {
-    found = key.find(kCachePieceSeparator);
-  }
-
-  if (found != folly::StringPiece::npos) {
-    return key.subpiece(0, found);
-  }
-  return key;
-}
-
 } // namespace cachelib
 } // namespace facebook

cachelib/common/piecewise/GenericPieces.h

@@ -16,28 +16,22 @@
 
 #pragma once
 
-#include <folly/io/IOBuf.h>
-#include <folly/json/dynamic.h>
 #include <folly/logging/xlog.h>
 
-#include <memory>
 #include <string>
-#include <unordered_map>
 
+#include "cachelib/common/piecewise/GenericPiecesBase.h"
 #include "cachelib/common/piecewise/RequestRange.h"
 
 namespace facebook {
 namespace cachelib {
 
-const std::string kCacheGroupSeparator = "|@|";
-const std::string kCachePieceSeparator = "|#|";
-
 /**
  * A content can be split and stored in multiple pieces in cache. The class
  * provides the utility to map content object to pieces.
  *
  */
-class GenericPieces {
+class GenericPieces : public GenericPiecesBase {
  public:
   /**
    * @param baseKey: base key of the request. we will generate piece key from
@@ -57,12 +51,6 @@ class GenericPieces {
 
   void resetFromRequestRange(const RequestRange& range);
 
-  /**
-   * We fetch one piece at a time and keep track of that piece
-   * number here.
-   */
-  uint64_t getCurFetchingPieceIndex() const { return curFetchingPieceIndex_; }
-
   bool morePiecesToFetch() const {
     return curFetchingPieceIndex_ < endPieceIndex_;
   }
@@ -92,9 +80,6 @@ class GenericPieces {
     return getLastByteOffsetOfLastPiece() - getFirstByteOffsetOfCurPiece() + 1;
   }
 
-  uint64_t getPieceSize() const { return pieceSize_; }
-  uint64_t getPiecesPerGroup() const { return numPiecesPerGroup_; }
-
   bool isPieceWithinBound(uint64_t pieceIndex) const {
     return pieceIndex <= endPieceIndex_;
   }
@@ -143,18 +128,11 @@ class GenericPieces {
     return (requestedEndByte_ - requestedStartByte_ + 1);
   }
 
-  /**
-   * Returns the body-length of the *full* blob (e.g. if there is a
-   * 1000000-byte blob and 6400 bytes are requested in a range request, this
-   * will still return 1000000)
-   */
-  uint64_t getFullBodyLength() const { return fullBodyLen_; }
   uint64_t getStartPieceIndex() const { return startPieceIndex_; }
   [[nodiscard]] uint64_t getStartPieceOffset() const {
     return startPieceIndex_ * pieceSize_;
   }
   uint64_t getEndPieceIndex() const { return endPieceIndex_; }
-  uint64_t getNumPiecesTotal() const { return numPiecesTotal_; }
   uint64_t getRequestedStartByte() const { return requestedStartByte_; }
   uint64_t getRequestedEndByte() const { return requestedEndByte_; }
   uint64_t getFirstByteOffsetToFetch() const { return firstByteOffsetToFetch_; }
@@ -164,61 +142,14 @@ class GenericPieces {
    */
   uint64_t getTargetNumPieces() const;
 
-  /**
-   * We use "|#|" as the separator between the actual cachekey and meta
-   * key information (Is it a header?  Is it a piece?  Which piece?)  So
-   * we want to make sure this separator is escaped in the main key.  Do this
-   * by doubling it whenever we see it.  If we ever see the single separator
-   * string by itself, we know it's actually the separator.
-   */
-  static std::string escapeCacheKey(const std::string& key);
-
-  /**
-   * Get the basekey from the given pieceKey (full key). The returned value
-   * shares the same lifetime as the passed in pieceKey.
-   */
-  static folly::StringPiece getBaseKey(folly::StringPiece pieceKey);
-
-  /**
-   * @param versionID: unique identifer of the content's version, e.g.,
-   * hash of the content.
-   */
-  static std::string createPieceHeaderKey(const std::string& baseKey,
-                                          uint64_t versionID = 0);
-
-  /**
-   * Keys used to store each piece of the response.  We include the pieceSize
-   * in the key in case we change pieceSize at some point, so we can
-   * distinguish between the different values.
-   */
-  static std::string createPieceKey(const std::string& baseKey,
-                                    size_t pieceNum,
-                                    uint64_t piecesPerGroup,
-                                    uint64_t versionID = 0);
-
-  static uint64_t calculateNumPiecesTotal(const uint64_t fullBodyLen,
-                                          const uint64_t pieceSize) {
-    return ((fullBodyLen - 1) / pieceSize) + 1;
-  }
-
  protected:
-  std::string baseKey_;
-  uint64_t pieceSize_;
-  uint64_t numPiecesPerGroup_;
-  uint64_t fullBodyLen_;
-
-  uint64_t curFetchingPieceIndex_;
-
-  // Calculated values
-  // Total number of pieces for the full content
-  uint64_t numPiecesTotal_;
   // Start byte of the request content (or range)
   uint64_t requestedStartByte_;
   // End byte of the request content (or range)
   uint64_t requestedEndByte_;
-  // Start piece index of he request content (or range)
+  // Start piece index of the request content (or range)
   uint64_t startPieceIndex_;
-  // End piece index of he request content (or range)
+  // End piece index of the request content (or range)
   uint64_t endPieceIndex_;
   // Starting byte offset of the first piece
   uint64_t firstByteOffsetToFetch_;

cachelib/common/piecewise/GenericPiecesBase.cpp

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "cachelib/common/piecewise/GenericPiecesBase.h"
+
+#include <folly/Conv.h>
+#include <folly/String.h>
+#include <folly/logging/xlog.h>
+
+#include <vector>
+
+namespace facebook {
+namespace cachelib {
+
+const std::string kCacheGroupSeparator = "|@|";
+const std::string kCachePieceSeparator = "|#|";
+
+GenericPiecesBase::GenericPiecesBase(const std::string& baseKey,
+                                     uint64_t pieceSize,
+                                     uint64_t piecesPerGroup,
+                                     uint64_t fullBodyLen)
+    : baseKey_{baseKey},
+      pieceSize_{pieceSize},
+      numPiecesPerGroup_{piecesPerGroup},
+      fullBodyLen_{fullBodyLen} {
+  XCHECK(fullBodyLen > 0);
+  numPiecesTotal_ = calculateNumPiecesTotal(fullBodyLen_, pieceSize_);
+}
+
+std::string GenericPiecesBase::escapeCacheKey(const std::string& key) {
+  std::vector<folly::StringPiece> parts;
+  folly::split(kCachePieceSeparator, key, parts);
+  if (parts.size() == 1) {
+    return key;
+  }
+  std::string escapeSeparator =
+      folly::to<std::string>(kCachePieceSeparator, kCachePieceSeparator);
+
+  std::string ret;
+  folly::join(escapeSeparator, parts, ret);
+  return ret;
+}
+
+std::string GenericPiecesBase::createPieceHeaderKey(const std::string& baseKey,
+                                                    uint64_t versionID) {
+  return folly::to<std::string>(
+      baseKey, kCachePieceSeparator, "header-", versionID);
+}
+
+std::string GenericPiecesBase::createPieceKey(const std::string& baseKey,
+                                              size_t pieceNum,
+                                              uint64_t piecesPerGroup,
+                                              uint64_t versionID) {
+  uint64_t groupNum = 0;
+  if (piecesPerGroup > 0) {
+    groupNum = pieceNum / piecesPerGroup;
+  }
+  if (groupNum == 0) {
+    return folly::to<std::string>(
+        baseKey, kCachePieceSeparator, "body-", versionID, "-", pieceNum);
+  } else {
+    return folly::to<std::string>(baseKey,
+                                  kCacheGroupSeparator,
+                                  groupNum,
+                                  kCachePieceSeparator,
+                                  "body-",
+                                  versionID,
+                                  "-",
+                                  pieceNum);
+  }
+}
+
+folly::StringPiece GenericPiecesBase::getBaseKey(folly::StringPiece key) {
+  auto found = key.find(kCacheGroupSeparator);
+  if (found == folly::StringPiece::npos) {
+    found = key.find(kCachePieceSeparator);
+  }
+
+  if (found != folly::StringPiece::npos) {
+    return key.subpiece(0, found);
+  }
+  return key;
+}
+
+} // namespace cachelib
+} // namespace facebook