react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/react/renderer/mapbuffer/BUCK

@@ -2,11 +2,16 @@ load(
     "//tools/build_defs/oss:rn_defs.bzl",
     "ANDROID",
     "fb_xplat_cxx_test",
+    "get_apple_compiler_flags",
+    "get_apple_inspector_flags",
+    "get_preprocessor_flags_for_build_mode",
     "react_native_xplat_target",
     "rn_xplat_cxx_library",
     "subdir_glob",
 )
 
+APPLE_COMPILER_FLAGS = get_apple_compiler_flags()
+
 rn_xplat_cxx_library(
     name = "mapbuffer",
     srcs = glob(
@@ -27,15 +32,18 @@ rn_xplat_cxx_library(
     compiler_flags = [
         "-fexceptions",
         "-frtti",
-        "-std=c++14",
+        "-std=c++17",
         "-Wall",
     ],
+    fbobjc_compiler_flags = APPLE_COMPILER_FLAGS,
+    fbobjc_preprocessor_flags = get_preprocessor_flags_for_build_mode() + get_apple_inspector_flags(),
     force_static = True,
     labels = ["supermodule:xplat/default/public.react_native.infra"],
     macosx_tests_override = [],
-    platforms = (ANDROID),
+    platforms = ANDROID,
     preprocessor_flags = [
         "-DLOG_TAG=\"ReactNative\"",
+        "-DWITH_FBSYSTRACE=1",
     ],
     tests = [":tests"],
     visibility = ["PUBLIC"],
@@ -44,7 +52,7 @@ rn_xplat_cxx_library(
         "//xplat/fbsystrace:fbsystrace",
         "//xplat/folly:headers_only",
         "//xplat/folly:memory",
-        react_native_xplat_target("react/utils:utils"),
+        react_native_xplat_target("react/debug:debug"),
     ],
 )
 
@@ -55,14 +63,15 @@ fb_xplat_cxx_test(
     compiler_flags = [
         "-fexceptions",
         "-frtti",
-        "-std=c++14",
+        "-std=c++17",
         "-Wall",
     ],
     contacts = ["oncall+react_native@xmail.facebook.com"],
-    platforms = (ANDROID),
+    platforms = ANDROID,
     deps = [
         "//xplat/folly:molly",
         "//xplat/third-party/gmock:gtest",
+        react_native_xplat_target("react/debug:debug"),
         react_native_xplat_target("react/renderer/mapbuffer:mapbuffer"),
     ],
 )

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.cpp

@@ -7,15 +7,142 @@
 
 #include "MapBuffer.h"
 
+using namespace facebook::react;
+
 namespace facebook {
 namespace react {
 
-MapBuffer::MapBuffer() {}
+// TODO T83483191: Extend MapBuffer C++ implementation to support basic random
+// access
+MapBuffer::MapBuffer(uint8_t *const data, int32_t dataSize) {
+  react_native_assert(
+      (data != nullptr) && "Error trying to build an invalid MapBuffer");
+
+  // Should we move the memory here or document it?
+  data_ = data;
+
+  count_ = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&count_),
+      reinterpret_cast<const uint8_t *>(data_ + HEADER_COUNT_OFFSET),
+      UINT16_SIZE);
+
+  // TODO T83483191: extract memcpy calls into an inline function to simplify
+  // the code
+  dataSize_ = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&dataSize_),
+      reinterpret_cast<const uint8_t *>(data_ + HEADER_BUFFER_SIZE_OFFSET),
+      INT_SIZE);
+
+  if (dataSize != dataSize_) {
+    LOG(ERROR) << "Error: Data size does not match, expected " << dataSize
+               << " found: " << dataSize_;
+    abort();
+  }
+}
+
+int32_t MapBuffer::getInt(Key key) const {
+  int32_t value = 0;
+  memcpy(
+      reinterpret_cast<uint8_t *>(&value),
+      reinterpret_cast<const uint8_t *>(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 *>(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_);
+}
 
-MapBuffer::~MapBuffer() {}
+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 *>(data_ + dynamicDataOffset + offset),
+      INT_SIZE);
+
+  char *value = new char[stringLength];
+
+  memcpy(
+      reinterpret_cast<char *>(value),
+      reinterpret_cast<const char *>(
+          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 *>(data_ + dynamicDataOffset + offset),
+      INT_SIZE);
+
+  uint8_t *value = new Byte[mapBufferLength];
+
+  memcpy(
+      reinterpret_cast<uint8_t *>(value),
+      reinterpret_cast<const uint8_t *>(
+          data_ + dynamicDataOffset + offset + INT_SIZE),
+      mapBufferLength);
+
+  return MapBuffer(value, mapBufferLength);
+}
+
+bool MapBuffer::isNull(Key key) const {
+  return getInt(key) == NULL_VALUE;
+}
+
+int32_t MapBuffer::getBufferSize() const {
+  return dataSize_;
+}
+
+void MapBuffer::copy(uint8_t *output) const {
+  memcpy(output, data_, dataSize_);
+}
+
+uint16_t MapBuffer::getCount() const {
+  uint16_t size = 0;
+
+  memcpy(
+      reinterpret_cast<uint16_t *>(&size),
+      reinterpret_cast<const uint16_t *>(data_ + HEADER_COUNT_OFFSET),
+
+      UINT16_SIZE);
+
+  return size;
+}
 
-int MapBuffer::getSize() {
-  return 0;
+MapBuffer::~MapBuffer() {
+  delete[] data_;
 }
 
 } // namespace react

package/ReactCommon/react/renderer/mapbuffer/MapBuffer.h

@@ -7,7 +7,11 @@
 
 #pragma once
 
-#include <string>
+#include <react/debug/react_native_assert.h>
+#include <react/renderer/mapbuffer/primitives.h>
+
+#include <stdlib.h>
+#include <limits>
 
 namespace facebook {
 namespace react {
@@ -28,11 +32,43 @@ namespace react {
  * - have minimal APK size and build time impact.
  */
 class MapBuffer {
+ private:
+  // Buffer and its size
+  const uint8_t *data_ = nullptr;
+
+  // amount of bytes in the MapBuffer
+  int32_t dataSize_ = 0;
+
+  // 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:
-  MapBuffer();
-  virtual ~MapBuffer();
+  MapBuffer(uint8_t *const data, int32_t dataSize);
+
+  ~MapBuffer();
+
+  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;
 
-  int getSize();
+  uint16_t getCount() const;
 };
 
 } // namespace react

package/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.cpp

@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "MapBufferBuilder.h"
+
+using namespace facebook::react;
+
+namespace facebook {
+namespace react {
+
+// TODO T83483191: Add asserts to check overflowing on additions
+MapBufferBuilder::MapBufferBuilder()
+    : MapBufferBuilder::MapBufferBuilder(INITIAL_KEY_VALUE_SIZE) {}
+
+MapBuffer MapBufferBuilder::EMPTY() {
+  static auto emptyMap = MapBufferBuilder().build();
+  return emptyMap;
+}
+
+MapBufferBuilder::MapBufferBuilder(uint16_t initialSize) {
+  keyValuesSize_ = initialSize;
+  keyValues_ = new Byte[keyValuesSize_];
+  // First Key should be written right after the header.
+  keyValuesOffset_ = HEADER_SIZE;
+
+  dynamicDataSize_ = 0;
+  dynamicDataValues_ = nullptr;
+  dynamicDataOffset_ = 0;
+}
+
+void MapBufferBuilder::ensureKeyValueSpace() {
+  int32_t oldKeyValuesSize = keyValuesSize_;
+  react_native_assert(
+      (keyValuesSize_ < std::numeric_limits<uint16_t>::max() / 2) &&
+      "Error trying to assign a value beyond the capacity of uint16_t: ");
+  keyValuesSize_ *= 2;
+  uint8_t *newKeyValues = new Byte[keyValuesSize_];
+  uint8_t *oldKeyValues = keyValues_;
+  memcpy(newKeyValues, keyValues_, oldKeyValuesSize);
+  keyValues_ = newKeyValues;
+  delete[] oldKeyValues;
+}
+
+void MapBufferBuilder::storeKeyValue(
+    Key key,
+    uint8_t *value,
+    int32_t valueSize) {
+  if (key < minKeyToStore_) {
+    LOG(ERROR) << "Error: key out of order - key: " << key;
+    abort();
+  }
+  if (valueSize > MAX_VALUE_SIZE) {
+    LOG(ERROR) << "Error: size of value must be <= MAX_VALUE_SIZE. ValueSize: "
+               << valueSize;
+    abort();
+  }
+
+  // TODO T83483191: header.count points to the next index
+  // TODO T83483191: add test to verify storage of sparse keys
+  int32_t keyOffset = getKeyOffset(_header.count);
+  int32_t valueOffset = keyOffset + KEY_SIZE;
+
+  int32_t nextKeyValueOffset = keyOffset + BUCKET_SIZE;
+  if (nextKeyValueOffset >= keyValuesSize_) {
+    ensureKeyValueSpace();
+  }
+
+  memcpy(keyValues_ + keyOffset, &key, KEY_SIZE);
+  memcpy(keyValues_ + valueOffset, value, valueSize);
+
+  _header.count++;
+
+  minKeyToStore_ = key + 1;
+  // Move keyValuesOffset_ to the next available [key, value] position
+  keyValuesOffset_ = std::max(nextKeyValueOffset, keyValuesOffset_);
+}
+
+void MapBufferBuilder::putBool(Key key, bool value) {
+  putInt(key, (int)value);
+}
+
+void MapBufferBuilder::putDouble(Key key, double value) {
+  uint8_t *bytePointer = reinterpret_cast<uint8_t *>(&value);
+  storeKeyValue(key, bytePointer, DOUBLE_SIZE);
+}
+
+void MapBufferBuilder::putNull(Key key) {
+  putInt(key, NULL_VALUE);
+}
+
+void MapBufferBuilder::putInt(Key key, int32_t value) {
+  uint8_t *bytePointer = reinterpret_cast<uint8_t *>(&(value));
+  storeKeyValue(key, bytePointer, INT_SIZE);
+}
+
+void MapBufferBuilder::ensureDynamicDataSpace(int32_t size) {
+  if (dynamicDataValues_ == nullptr) {
+    dynamicDataSize_ = size;
+    dynamicDataValues_ = new Byte[dynamicDataSize_];
+    dynamicDataOffset_ = 0;
+    return;
+  }
+
+  if (dynamicDataOffset_ + size >= dynamicDataSize_) {
+    int32_t oldDynamicDataSize = dynamicDataSize_;
+    react_native_assert(
+        (dynamicDataSize_ < std::numeric_limits<int32_t>::max() / 2) &&
+        "Error: trying to assign a value beyond the capacity of int");
+    dynamicDataSize_ *= dynamicDataSize_;
+
+    react_native_assert(
+        (dynamicDataSize_ < std::numeric_limits<int32_t>::max() - size) &&
+        "Error: trying to assign a value beyond the capacity of int");
+
+    // sum size to ensure that the size always fit into newDynamicDataValues
+    dynamicDataSize_ += size;
+    uint8_t *newDynamicDataValues = new Byte[dynamicDataSize_];
+    uint8_t *oldDynamicDataValues = dynamicDataValues_;
+    memcpy(newDynamicDataValues, dynamicDataValues_, oldDynamicDataSize);
+    dynamicDataValues_ = newDynamicDataValues;
+    delete[] oldDynamicDataValues;
+  }
+}
+
+void MapBufferBuilder::putString(Key key, std::string value) {
+  int32_t strLength = static_cast<int32_t>(value.length());
+  const char *cstring = getCstring(&value);
+
+  // format [lenght of string (int)] + [Array of Characters in the string]
+  int32_t sizeOfLength = INT_SIZE;
+  // TODO T83483191: review if map.getBufferSize() should be an int32_t or long
+  // instead of an int16 (because strings can be longer than int16);
+
+  int32_t sizeOfDynamicData = sizeOfLength + strLength;
+  ensureDynamicDataSpace(sizeOfDynamicData);
+  memcpy(dynamicDataValues_ + dynamicDataOffset_, &strLength, sizeOfLength);
+  memcpy(
+      dynamicDataValues_ + dynamicDataOffset_ + sizeOfLength,
+      cstring,
+      strLength);
+
+  // Store Key and pointer to the string
+  putInt(key, dynamicDataOffset_);
+
+  dynamicDataOffset_ += sizeOfDynamicData;
+}
+
+void MapBufferBuilder::putMapBuffer(Key key, MapBuffer &map) {
+  int32_t mapBufferSize = map.getBufferSize();
+
+  // format [lenght of buffer (int)] + [bytes of MapBuffer]
+  int32_t sizeOfDynamicData = mapBufferSize + INT_SIZE;
+
+  // format [Array of bytes of the mapBuffer]
+  ensureDynamicDataSpace(sizeOfDynamicData);
+
+  memcpy(dynamicDataValues_ + dynamicDataOffset_, &mapBufferSize, INT_SIZE);
+  // Copy the content of the map into dynamicDataValues_
+  map.copy(dynamicDataValues_ + dynamicDataOffset_ + INT_SIZE);
+
+  // Store Key and pointer to the string
+  putInt(key, dynamicDataOffset_);
+
+  dynamicDataOffset_ += sizeOfDynamicData;
+}
+
+MapBuffer MapBufferBuilder::build() {
+  react_native_assert(
+      (keyValues_ != nullptr) &&
+      "Error when building mapbuffer with invalid datastructures.");
+
+  // Create buffer: [header] + [key, values] + [dynamic data]
+  int32_t bufferSize = keyValuesOffset_ + dynamicDataOffset_;
+
+  _header.bufferSize = bufferSize;
+
+  // Copy header at the beginning of "keyValues_"
+  memcpy(keyValues_, &_header, HEADER_SIZE);
+
+  uint8_t *buffer = new Byte[bufferSize];
+
+  memcpy(buffer, keyValues_, keyValuesOffset_);
+
+  if (dynamicDataValues_ != nullptr) {
+    memcpy(buffer + keyValuesOffset_, dynamicDataValues_, dynamicDataOffset_);
+  }
+
+  // TODO T83483191: should we use std::move here?
+  auto map = MapBuffer(buffer, bufferSize);
+
+  // TODO T83483191: we should invalidate the class once the build() method is
+  // called.
+
+  if (keyValues_ != nullptr) {
+    delete[] keyValues_;
+  }
+  keyValues_ = nullptr;
+  keyValuesSize_ = 0;
+  keyValuesOffset_ = 0;
+
+  if (dynamicDataValues_ != nullptr) {
+    delete[] dynamicDataValues_;
+    dynamicDataValues_ = nullptr;
+  }
+  dynamicDataSize_ = 0;
+  dynamicDataOffset_ = 0;
+  _header = {ALIGNMENT, 0, 0};
+
+  return map;
+}
+
+MapBufferBuilder::~MapBufferBuilder() {
+  if (keyValues_ != nullptr) {
+    delete[] keyValues_;
+  }
+  if (dynamicDataValues_ != nullptr) {
+    delete[] dynamicDataValues_;
+  }
+}
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/mapbuffer/MapBufferBuilder.h

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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/MapBuffer.h>
+#include <react/renderer/mapbuffer/primitives.h>
+#include <stdlib.h>
+
+namespace facebook {
+namespace react {
+
+// Default initial size for _keyValues array
+// 108 = 10 entries = 10*10 + 8 sizeof(header)
+constexpr uint16_t INITIAL_KEY_VALUE_SIZE = 108;
+
+// Default initial size for _dynamicDataValues array
+constexpr int32_t INITIAL_DYNAMIC_DATA_SIZE = 200;
+
+/**
+ * MapBufferBuilder is a builder class for MapBuffer
+ */
+class MapBufferBuilder {
+ private:
+  Header _header = {ALIGNMENT, 0, 0};
+
+  void ensureKeyValueSpace();
+
+  void ensureDynamicDataSpace(int32_t size);
+
+  void storeKeyValue(Key key, uint8_t *value, int32_t valueSize);
+
+  // Array of [key,value] map entries:
+  // - Key is represented in 2 bytes
+  // - Value is stored into 8 bytes. The 8 bytes of the value will contain the
+  // actual value for the key or a pointer to the actual value (based on the
+  // type)
+  uint8_t *keyValues_ = nullptr;
+
+  // Amount of bytes allocated on _keyValues
+  uint16_t keyValuesSize_ = 0;
+
+  // Relative offset on the _keyValues array.
+  // This represents the first byte that can be written in _keyValues array
+  int32_t keyValuesOffset_ = 0;
+
+  // This array contains data for dynamic values in the MapBuffer.
+  // A dynamic value is a String or another MapBuffer.
+  uint8_t *dynamicDataValues_ = nullptr;
+
+  // Amount of bytes allocated on _dynamicDataValues
+  int32_t dynamicDataSize_ = 0;
+
+  // Relative offset on the _dynamicDataValues array.
+  // This represents the first byte that can be written in _dynamicDataValues
+  // array
+  int32_t dynamicDataOffset_ = 0;
+
+  // Minimmum key to store in the MapBuffer (this is used to guarantee
+  // consistency)
+  uint16_t minKeyToStore_ = 0;
+
+ public:
+  MapBufferBuilder();
+
+  MapBufferBuilder(uint16_t initialSize);
+
+  ~MapBufferBuilder();
+
+  static MapBuffer EMPTY();
+
+  void putInt(Key key, int32_t value);
+
+  void putBool(Key key, bool value);
+
+  void putDouble(Key key, double value);
+
+  void putNull(Key key);
+
+  void putString(Key key, std::string value);
+
+  void putMapBuffer(Key key, MapBuffer &map);
+
+  // TODO T83483191: This should return MapBuffer!
+  MapBuffer build();
+};
+
+} // namespace react
+} // namespace facebook

package/ReactCommon/react/renderer/mapbuffer/primitives.h

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <glog/logging.h>
+
+// TODO T83483191: Enable CHECK_CONSISTENCY only in debug mode or test
+// environments (or just in demand) #define CHECK_CONSISTENCY 1
+
+constexpr static int32_t NULL_VALUE = 0;
+
+// Value used to verify if the data is serialized with LittleEndian order
+constexpr static uint16_t ALIGNMENT = 0xFE;
+
+using Key = uint16_t;
+
+using Byte = uint8_t;
+
+namespace facebook {
+namespace react {
+
+struct Header {
+  uint16_t alignment; // alignment of serialization
+  uint16_t count; // amount of items in the map
+  int32_t bufferSize; // Amount of bytes used to store the map in memory
+};
+
+constexpr static int32_t KEY_SIZE = sizeof(Key);
+constexpr static int32_t HEADER_SIZE = sizeof(Header);
+constexpr static int32_t INT_SIZE = sizeof(int32_t);
+constexpr static int32_t DOUBLE_SIZE = sizeof(double);
+constexpr static int32_t UINT8_SIZE = sizeof(uint8_t);
+constexpr static int32_t UINT16_SIZE = sizeof(uint16_t);
+constexpr static int32_t UINT64_SIZE = sizeof(uint64_t);
+constexpr static int32_t HEADER_ALIGNMENT_OFFSET = 0;
+constexpr static int32_t HEADER_COUNT_OFFSET = UINT16_SIZE;
+constexpr static int32_t HEADER_BUFFER_SIZE_OFFSET = UINT16_SIZE * 2;
+
+constexpr static int32_t MAX_VALUE_SIZE = UINT64_SIZE;
+
+// 10 bytes : 2 key + 8 value
+constexpr static int32_t BUCKET_SIZE = KEY_SIZE + UINT64_SIZE;
+
+/**
+ * Returns the offset of the key received by parameter.
+ */
+inline int32_t getKeyOffset(Key key) {
+  return HEADER_SIZE + BUCKET_SIZE * key;
+}
+
+/**
+ * Returns the offset of the value associated to the key received by parameter.
+ */
+inline int32_t getValueOffset(Key key) {
+  return getKeyOffset(key) + KEY_SIZE;
+}
+
+static inline const char *getCstring(const std::string *str) {
+  return str ? str->c_str() : "";
+}
+
+inline void
+checkKeyConsistency(const Header &header, const uint8_t *data, Key key) {
+#ifdef CHECK_CONSISTENCY
+  if (key >= header.count) {
+    LOG(ERROR) << "Error: Key is higher than size of Map - key '" << key
+               << "' - size: '" << header.count << "'";
+    assert(false && "Error while reading key");
+  }
+
+  Key storedKey = 0;
+  memcpy(
+      reinterpret_cast<Key *>(&storedKey),
+      reinterpret_cast<const Key *>(data + getKeyOffset(key)),
+      KEY_SIZE);
+
+  if (storedKey != key) {
+    LOG(ERROR) << "Error while reading key, expecting '" << key << "' found: '"
+               << storedKey << "'";
+    assert(false && "Error while reading key");
+  }
+#endif
+}
+
+} // namespace react
+} // namespace facebook