Allow navy/common/Device to take a BufferView to avoid unnecessary deep copy

Summary:
Before this diff, the Device class takes ownership of the buffer to be written into the NVM device.
After this diff, the Device class can take either a buffer with ownership, or a buffer view.

If a buffer is used and there is encryption, the Device class will overwrite this buffer.
If a buffer view is used and there is encryption, the Device class will make a copy of this buffer view and encrypt-overwrite the created buffer.

A future optimization could be to allow the encryptor directly create and write the encrypted content into the new buffer.

Reviewed By: jaesoo-fb

Differential Revision: D42050939

fbshipit-source-id: dc0ccecb03462f43aabf645f21ccc7b245915b15

Author: haowu14

cachelib/navy/block_cache/RegionManager.cpp

@@ -106,9 +106,7 @@ void RegionManager::reset() {
 Region::FlushRes RegionManager::flushBuffer(const RegionId& rid) {
   auto& region = getRegion(rid);
   auto callBack = [this](RelAddress addr, BufferView view) {
-    auto writeBuffer = device_.makeIOBuffer(view.size());
-    writeBuffer.copyFrom(0, view);
-    if (!deviceWrite(addr, std::move(writeBuffer))) {
+    if (!deviceWrite(addr, view)) {
       return false;
     }
     numInMemBufWaitingFlush_.dec();
@@ -488,11 +486,11 @@ bool RegionManager::isValidIORange(uint32_t offset, uint32_t size) const {
   return static_cast<uint64_t>(offset) + size <= regionSize_;
 }
 
-bool RegionManager::deviceWrite(RelAddress addr, Buffer buf) {
-  const auto bufSize = buf.size();
+bool RegionManager::deviceWrite(RelAddress addr, BufferView view) {
+  const auto bufSize = view.size();
   XDCHECK(isValidIORange(addr.offset(), bufSize));
   auto physOffset = physicalOffset(addr);
-  if (!device_.write(physOffset, std::move(buf))) {
+  if (!device_.write(physOffset, view)) {
     return false;
   }
   physicalWrittenCount_.add(bufSize);

cachelib/navy/block_cache/RegionManager.h

@@ -258,7 +258,7 @@ class RegionManager {
     return baseOffset_ + toAbsolute(addr).offset();
   }
 
-  bool deviceWrite(RelAddress addr, Buffer buf);
+  bool deviceWrite(RelAddress addr, BufferView buf);
 
   bool isValidIORange(uint32_t offset, uint32_t size) const;
   OpenStatus assignBufferToRegion(RegionId rid);

cachelib/navy/common/Device.cpp

@@ -212,6 +212,19 @@ class MemoryDevice final : public Device {
 };
 } // namespace
 
+bool Device::write(uint64_t offset, BufferView view) {
+  if (encryptor_) {
+    auto writeBuffer = makeIOBuffer(view.size());
+    writeBuffer.copyFrom(0, view);
+    return write(offset, std::move(writeBuffer));
+  }
+
+  const auto size = view.size();
+  XDCHECK_LE(offset + size, size_);
+  const uint8_t* data = reinterpret_cast<const uint8_t*>(view.data());
+  return writeInternal(offset, data, size);
+}
+
 bool Device::write(uint64_t offset, Buffer buffer) {
   const auto size = buffer.size();
   XDCHECK_LE(offset + buffer.size(), size_);
@@ -225,7 +238,10 @@ bool Device::write(uint64_t offset, Buffer buffer) {
       return false;
     }
   }
+  return writeInternal(offset, data, size);
+}
 
+bool Device::writeInternal(uint64_t offset, const uint8_t* data, size_t size) {
   auto remainingSize = size;
   auto maxWriteSize = (maxWriteSize_ == 0) ? remainingSize : maxWriteSize_;
   bool result = true;

cachelib/navy/common/Device.h

@@ -116,6 +116,10 @@ class Device {
   // @param offset    Must be ioAlignmentSize_ aligned
   bool write(uint64_t offset, Buffer buffer);
 
+  // Write buffer view to the device. This call makes a copy of the buffer if
+  // entryptor is present.
+  bool write(uint64_t offset, BufferView bufferView);
+
   // Reads @size bytes from device at @deviceOffset and copys to @value
   // There must be sufficient space allocated already in the mutableView.
   // @offset and @size must be ioAligmentSize_ aligned
@@ -166,6 +170,8 @@ class Device {
 
   bool readInternal(uint64_t offset, uint32_t size, void* value);
 
+  bool writeInternal(uint64_t offset, const uint8_t* data, size_t size);
+
   // size of the device. All offsets for write/read should be contained
   // below this.
   const uint64_t size_{0};