Try Fix MapBuffer

Author: chiaramooney

.vscode/settings.json

@@ -46,5 +46,8 @@
   "typescript.tsdk": "node_modules\\typescript\\lib",
   "editor.codeActionsOnSave": {
     "source.fixAll.eslint": true
+  },
+  "files.associations": {
+    "*.ipp": "cpp"
   }
 }

vnext/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mapbuffer/MapBuffer.cpp

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "MapBuffer.h"
+
+using namespace facebook::react;
+
+namespace facebook {
+namespace react {
+
+// TODO T83483191: Extend MapBuffer C++ implementation to support basic random
+// access
+MapBuffer::MapBuffer(std::vector<uint8_t> data) : bytes_(std::move(data)) {
+  count_ = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&count_),
+      bytes_.data() + HEADER_COUNT_OFFSET,
+      UINT16_SIZE);
+
+  // TODO T83483191: extract memcpy calls into an inline function to simplify
+  // the code
+  uint32_t dataSize;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&dataSize),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + HEADER_BUFFER_SIZE_OFFSET),
+      INT_SIZE);
+
+  if (dataSize != bytes_.size()) {
+    LOG(ERROR) << "Error: Data size does not match, expected " << dataSize
+               << " found: " << bytes_.size();
+    abort();
+  }
+}
+
+int32_t MapBuffer::getInt(Key key) const {
+  int32_t value = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&value),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + getValueOffset(key)),
+      INT_SIZE);
+  return value;
+}
+
+bool MapBuffer::getBool(Key key) const {
+  return getInt(key) != 0;
+}
+
+double MapBuffer::getDouble(Key key) const {
+  // TODO T83483191: extract this code into a "template method" and reuse it for
+  // other types
+  double value = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&value),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + getValueOffset(key)),
+      DOUBLE_SIZE);
+  return value;
+}
+
+int32_t MapBuffer::getDynamicDataOffset() const {
+  // The begininig of dynamic data can be calculated as the offset of the next
+  // key in the map
+  return getKeyOffset(count_);
+}
+
+std::string MapBuffer::getString(Key key) const {
+  // TODO T83483191:Add checks to verify that offsets are under the boundaries
+  // of the map buffer
+  int32_t dynamicDataOffset = getDynamicDataOffset();
+  int32_t stringLength = 0;
+  int32_t offset = getInt(key);
+  memcpy(
+      reinterpret_cast<uint8_t *>(&stringLength),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + dynamicDataOffset + offset),
+      INT_SIZE);
+
+  char *value = new char[stringLength];
+
+  memcpy(
+      reinterpret_cast<char *>(value),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + dynamicDataOffset + offset + INT_SIZE),
+      stringLength);
+
+  return std::string(value, 0, stringLength);
+}
+
+MapBuffer MapBuffer::getMapBuffer(Key key) const {
+  // TODO T83483191: Add checks to verify that offsets are under the boundaries
+  // of the map buffer
+  int32_t dynamicDataOffset = getDynamicDataOffset();
+
+  int32_t mapBufferLength = 0;
+  int32_t offset = getInt(key);
+  memcpy(
+      reinterpret_cast<uint8_t *>(&mapBufferLength),
+      reinterpret_cast<const uint8_t *>(bytes_.data() + dynamicDataOffset + offset),
+      INT_SIZE);
+
+  std::vector<uint8_t> value(mapBufferLength);
+
+  memcpy(
+      value.data(),
+      bytes_.data() + dynamicDataOffset + offset + INT_SIZE,
+      mapBufferLength);
+
+  return MapBuffer(std::move(value));
+}
+
+bool MapBuffer::isNull(Key key) const {
+  return getInt(key) == NULL_VALUE;
+}
+
+int32_t MapBuffer::getBufferSize() const {
+  return bytes_.size();
+}
+
+void MapBuffer::copy(uint8_t *output) const {
+  memcpy(output, bytes_.data(), bytes_.size());
+}
+
+uint16_t MapBuffer::getCount() const {
+  uint16_t size = 0;
+
+  memcpy(
+      reinterpret_cast<uint8_t *>(&size),
+      bytes_.data() + HEADER_COUNT_OFFSET,
+      UINT16_SIZE);
+
+  return size;
+}
+
+
+} // namespace react
+} // namespace facebook

vnext/ReactCommon/TEMP_UntilReactCommonUpdate/react/renderer/mapbuffer/MapBuffer.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/mapbuffer/primitives.h>
+
+#include <limits>
+
+namespace facebook {
+namespace react {
+
+class ReadableMapBuffer;
+
+/**
+ * MapBuffer is an optimized map format for transferring data like props between
+ * C++ and other platforms The implementation of this map is optimized to:
+ * - be compact to optimize space when sparse (sparse is the common case).
+ * - be accessible through JNI with zero/minimal copying via ByteBuffer.
+ * - be Have excellent C++ single-write and many-read performance by maximizing
+ *   CPU cache performance through compactness, data locality, and fixed offsets
+ *   where possible.
+ * - be optimized for iteration and intersection against other maps, but with
+ *   reasonably good random access as well.
+ * - Work recursively for nested maps/arrays.
+ * - Supports dynamic types that map to JSON.
+ * - Don't require mutability - single-write on creation.
+ * - have minimal APK size and build time impact.
+ */
+class MapBuffer {
+  friend ReadableMapBuffer;
+
+ private:
+  // Buffer and its size
+  std::vector<uint8_t> const bytes_;
+
+  // amount of items in the MapBuffer
+  uint16_t count_ = 0;
+
+  // returns the relative offset of the first byte of dynamic data
+  int32_t getDynamicDataOffset() const;
+
+ public:
+  explicit MapBuffer(std::vector<uint8_t> data);
+
+  MapBuffer(MapBuffer const &buffer) = delete;
+
+  MapBuffer &operator=(MapBuffer other) = delete;
+
+  MapBuffer(MapBuffer &&buffer) = default;
+
+  int32_t getInt(Key key) const;
+
+  bool getBool(Key key) const;
+
+  double getDouble(Key key) const;
+
+  std::string getString(Key key) const;
+
+  // TODO T83483191: review this declaration
+  MapBuffer getMapBuffer(Key key) const;
+
+  int32_t getBufferSize() const;
+
+  // TODO T83483191: review parameters of copy method
+  void copy(uint8_t *output) const;
+
+  bool isNull(Key key) const;
+
+  uint16_t getCount() const;
+};
+
+} // namespace react
+} // namespace facebook