react-nitro-yoga 0.0.0-stage → 0.0.1-alpha.7

package/yoga/benchmark/TreeDeserialization.cpp

@@ -0,0 +1,248 @@
+/*
+ * 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 <memory>
+#include <vector>
+
+#include <benchmark/TreeDeserialization.h>
+#include <capture/CaptureTree.h>
+#include <nlohmann/json.hpp>
+#include <yoga/Yoga.h>
+
+namespace facebook::yoga {
+
+using namespace nlohmann;
+
+static inline bool isAuto(json& j) {
+  return j.is_string() && j == "auto";
+}
+
+static inline bool isUndefined(json& j) {
+  return j.is_string() && j == "undefined";
+}
+
+static inline std::string invalidArgumentMessage(
+    const std::string& arg,
+    const std::string& enumName) {
+  return arg + " does not represent any " + enumName + " values";
+}
+
+static inline float floatFromJson(json& j) {
+  float result = YGUndefined;
+  if (!j.is_null()) {
+    result = j;
+  }
+
+  return result;
+}
+
+YGFlexDirection flexDirectionFromString(const std::string& str) {
+  if (str == "row") {
+    return YGFlexDirectionRow;
+  } else if (str == "row-reverse") {
+    return YGFlexDirectionRowReverse;
+  } else if (str == "column") {
+    return YGFlexDirectionColumn;
+  } else if (str == "column-reverse") {
+    return YGFlexDirectionColumnReverse;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGFlexDirection"));
+  }
+}
+
+YGJustify justifyContentFromString(const std::string& str) {
+  if (str == "flex-start") {
+    return YGJustifyFlexStart;
+  } else if (str == "center") {
+    return YGJustifyCenter;
+  } else if (str == "flex-end") {
+    return YGJustifyFlexEnd;
+  } else if (str == "space-between") {
+    return YGJustifySpaceBetween;
+  } else if (str == "space-around") {
+    return YGJustifySpaceAround;
+  } else if (str == "space-evenly") {
+    return YGJustifySpaceEvenly;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGJustify"));
+  }
+}
+
+YGAlign alignFromString(const std::string& str) {
+  if (str == "auto") {
+    return YGAlignAuto;
+  } else if (str == "flex-start") {
+    return YGAlignFlexStart;
+  } else if (str == "center") {
+    return YGAlignCenter;
+  } else if (str == "flex-end") {
+    return YGAlignFlexEnd;
+  } else if (str == "stretch") {
+    return YGAlignStretch;
+  } else if (str == "baseline") {
+    return YGAlignBaseline;
+  } else if (str == "space-between") {
+    return YGAlignSpaceBetween;
+  } else if (str == "space-around") {
+    return YGAlignSpaceAround;
+  } else if (str == "space-evenly") {
+    return YGAlignSpaceEvenly;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGAlign"));
+  }
+}
+
+YGWrap wrapFromString(const std::string& str) {
+  if (str == "no-wrap") {
+    return YGWrapNoWrap;
+  } else if (str == "wrap") {
+    return YGWrapWrap;
+  } else if (str == "wrap-reverse") {
+    return YGWrapWrapReverse;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGAlign"));
+  }
+}
+
+YGOverflow overflowFromString(const std::string& str) {
+  if (str == "visible") {
+    return YGOverflowVisible;
+  } else if (str == "hidden") {
+    return YGOverflowHidden;
+  } else if (str == "scroll") {
+    return YGOverflowScroll;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGAlign"));
+  }
+}
+
+YGDisplay displayFromString(const std::string& str) {
+  if (str == "flex") {
+    return YGDisplayFlex;
+  } else if (str == "none") {
+    return YGDisplayNone;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGAlign"));
+  }
+}
+
+YGPositionType positionTypeFromString(const std::string& str) {
+  if (str == "static") {
+    return YGPositionTypeStatic;
+  } else if (str == "relative") {
+    return YGPositionTypeRelative;
+  } else if (str == "absolute") {
+    return YGPositionTypeAbsolute;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGAlign"));
+  }
+}
+
+YGUnit unitFromJson(json& j) {
+  if (isAuto(j)) {
+    return YGUnitAuto;
+  }
+  if (isUndefined(j)) {
+    return YGUnitUndefined;
+  }
+
+  std::string unit = j["unit"];
+  if (unit == "px") {
+    return YGUnitPoint;
+  } else if (unit == "pct") {
+    return YGUnitPercent;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(unit, "YGUnit"));
+  }
+}
+
+YGEdge edgeFromString(const std::string& str) {
+  if (str == "left") {
+    return YGEdgeLeft;
+  } else if (str == "top") {
+    return YGEdgeTop;
+  } else if (str == "right") {
+    return YGEdgeRight;
+  } else if (str == "bottom") {
+    return YGEdgeBottom;
+  } else if (str == "start") {
+    return YGEdgeStart;
+  } else if (str == "end") {
+    return YGEdgeEnd;
+  } else if (str == "horizontal") {
+    return YGEdgeHorizontal;
+  } else if (str == "vertical") {
+    return YGEdgeVertical;
+  } else if (str == "all") {
+    return YGEdgeAll;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGEdge"));
+  }
+}
+
+YGErrata errataFromString(const std::string& str) {
+  if (str == "none") {
+    return YGErrataNone;
+  } else if (str == "all") {
+    return YGErrataAll;
+  } else if (str == "classic") {
+    return YGErrataClassic;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGErrata"));
+  }
+}
+
+YGExperimentalFeature experimentalFeatureFromString(const std::string& str) {
+  if (str == "web-flex-basis") {
+    return YGExperimentalFeatureWebFlexBasis;
+  } else {
+    throw std::invalid_argument(
+        invalidArgumentMessage(str, "YGExperimentalFeature"));
+  }
+}
+
+std::string edgeStringFromPropertyName(
+    const json::iterator& it,
+    const std::string& propertyName) {
+  return it.key().substr(propertyName.length() + 1);
+}
+
+YGDirection directionFromString(const std::string& str) {
+  if (str == "ltr") {
+    return YGDirectionLTR;
+  } else if (str == "rtl") {
+    return YGDirectionRTL;
+  } else if (str == "inherit") {
+    return YGDirectionInherit;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGDirection"));
+  }
+}
+
+YGMeasureMode measureModeFromString(const std::string& str) {
+  if (str == "at-most") {
+    return YGMeasureModeAtMost;
+  } else if (str == "exactly") {
+    return YGMeasureModeExactly;
+  } else if (str == "undefined") {
+    return YGMeasureModeUndefined;
+  } else {
+    throw std::invalid_argument(invalidArgumentMessage(str, "YGMeasureMode"));
+  }
+}
+
+SerializedMeasureFunc serializedMeasureFuncFromJson(json& j) {
+  return SerializedMeasureFunc{
+      .inputWidth = floatFromJson(j["width"]),
+      .widthMode = measureModeFromString(j["width-mode"]),
+      .inputHeight = floatFromJson(j["height"]),
+      .heightMode = measureModeFromString(j["height-mode"]),
+      .outputWidth = floatFromJson(j["output-width"]),
+      .outputHeight = floatFromJson(j["output-height"]),
+      .durationNs = j["duration-ns"]};
+}
+} // namespace facebook::yoga

package/yoga/benchmark/TreeDeserialization.h

@@ -0,0 +1,52 @@
+/*
+ * 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 <memory>
+#include <vector>
+
+#include <capture/CaptureTree.h>
+#include <nlohmann/json.hpp>
+#include <yoga/Yoga.h>
+
+namespace facebook::yoga {
+
+using namespace nlohmann;
+
+YGFlexDirection flexDirectionFromString(const std::string& str);
+
+YGJustify justifyContentFromString(const std::string& str);
+
+YGAlign alignFromString(const std::string& str);
+
+YGWrap wrapFromString(const std::string& str);
+
+YGOverflow overflowFromString(const std::string& str);
+
+YGDisplay displayFromString(const std::string& str);
+
+YGPositionType positionTypeFromString(const std::string& str);
+
+YGUnit unitFromJson(json& j);
+
+YGEdge edgeFromString(const std::string& str);
+
+YGErrata errataFromString(const std::string& str);
+
+YGExperimentalFeature experimentalFeatureFromString(const std::string& str);
+
+std::string edgeStringFromPropertyName(
+    const json::iterator& it,
+    const std::string& propertyName);
+
+YGDirection directionFromString(const std::string& str);
+
+YGMeasureMode measureModeFromString(const std::string& str);
+
+SerializedMeasureFunc serializedMeasureFuncFromJson(json& j);
+} // namespace facebook::yoga

package/yoga/benchmark/YGBenchmark.c

@@ -0,0 +1,183 @@
+/*
+ * 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 <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include <yoga/Yoga.h>
+
+#define NUM_REPETITIONS 1000
+
+#define YGBENCHMARKS(BLOCK)                \
+  int main(int argc, char const* argv[]) { \
+    (void)argc;                            \
+    (void)argv;                            \
+    clock_t __start;                       \
+    clock_t __endTimes[NUM_REPETITIONS];   \
+    {                                      \
+      BLOCK                                \
+    }                                      \
+    return 0;                              \
+  }
+
+#define YGBENCHMARK(NAME, BLOCK)                         \
+  __start = clock();                                     \
+  for (uint32_t __i = 0; __i < NUM_REPETITIONS; __i++) { \
+    {BLOCK} __endTimes[__i] = clock();                   \
+  }                                                      \
+  __printBenchmarkResult(NAME, __start, __endTimes);
+
+static int __compareDoubles(const void* a, const void* b) {
+  double arg1 = *(const double*)a;
+  double arg2 = *(const double*)b;
+
+  if (arg1 < arg2) {
+    return -1;
+  }
+
+  if (arg1 > arg2) {
+    return 1;
+  }
+
+  return 0;
+}
+
+static void
+__printBenchmarkResult(char* name, clock_t start, const clock_t* endTimes) {
+  double timesInMs[NUM_REPETITIONS];
+  double mean = 0;
+  clock_t lastEnd = start;
+  for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
+    timesInMs[i] =
+        ((double)(endTimes[i] - lastEnd)) / (double)CLOCKS_PER_SEC * 1000;
+    lastEnd = endTimes[i];
+    mean += timesInMs[i];
+  }
+  mean /= NUM_REPETITIONS;
+
+  qsort(timesInMs, NUM_REPETITIONS, sizeof(double), __compareDoubles);
+  double median = timesInMs[NUM_REPETITIONS / 2];
+
+  double variance = 0;
+  for (uint32_t i = 0; i < NUM_REPETITIONS; i++) {
+    variance += pow(timesInMs[i] - mean, 2);
+  }
+  variance /= NUM_REPETITIONS;
+  double stddev = sqrt(variance);
+
+  printf("%s: median: %lf ms, stddev: %lf ms\n", name, median, stddev);
+}
+
+static YGSize _measure(
+    YGNodeConstRef node,
+    float width,
+    YGMeasureMode widthMode,
+    float height,
+    YGMeasureMode heightMode) {
+  (void)node;
+  return (YGSize){
+      .width = widthMode == YGMeasureModeUndefined ? 10 : width,
+      .height = heightMode == YGMeasureModeUndefined ? 10 : height,
+  };
+}
+
+YGBENCHMARKS({
+  YGBENCHMARK("Stack with flex", {
+    const YGNodeRef root = YGNodeNew();
+    YGNodeStyleSetWidth(root, 100);
+    YGNodeStyleSetHeight(root, 100);
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeSetMeasureFunc(child, _measure);
+      YGNodeStyleSetFlex(child, 1);
+      YGNodeInsertChild(root, child, 0);
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Align stretch in undefined axis", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetHeight(child, 20);
+      YGNodeSetMeasureFunc(child, _measure);
+      YGNodeInsertChild(root, child, 0);
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Nested flex", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetFlex(child, 1);
+      YGNodeInsertChild(root, child, 0);
+
+      for (uint32_t ii = 0; ii < 10; ii++) {
+        const YGNodeRef grandChild = YGNodeNew();
+        YGNodeSetMeasureFunc(grandChild, _measure);
+        YGNodeStyleSetFlex(grandChild, 1);
+        YGNodeInsertChild(child, grandChild, 0);
+      }
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+
+  YGBENCHMARK("Huge nested layout", {
+    const YGNodeRef root = YGNodeNew();
+
+    for (uint32_t i = 0; i < 10; i++) {
+      const YGNodeRef child = YGNodeNew();
+      YGNodeStyleSetFlexGrow(child, 1);
+      YGNodeStyleSetWidth(child, 10);
+      YGNodeStyleSetHeight(child, 10);
+      YGNodeInsertChild(root, child, 0);
+
+      for (uint32_t ii = 0; ii < 10; ii++) {
+        const YGNodeRef grandChild = YGNodeNew();
+        YGNodeStyleSetFlexDirection(grandChild, YGFlexDirectionRow);
+        YGNodeStyleSetFlexGrow(grandChild, 1);
+        YGNodeStyleSetWidth(grandChild, 10);
+        YGNodeStyleSetHeight(grandChild, 10);
+        YGNodeInsertChild(child, grandChild, 0);
+
+        for (uint32_t iii = 0; iii < 10; iii++) {
+          const YGNodeRef grandGrandChild = YGNodeNew();
+          YGNodeStyleSetFlexGrow(grandGrandChild, 1);
+          YGNodeStyleSetWidth(grandGrandChild, 10);
+          YGNodeStyleSetHeight(grandGrandChild, 10);
+          YGNodeInsertChild(grandChild, grandGrandChild, 0);
+
+          for (uint32_t iiii = 0; iiii < 10; iiii++) {
+            const YGNodeRef grandGrandGrandChild = YGNodeNew();
+            YGNodeStyleSetFlexDirection(
+                grandGrandGrandChild, YGFlexDirectionRow);
+            YGNodeStyleSetFlexGrow(grandGrandGrandChild, 1);
+            YGNodeStyleSetWidth(grandGrandGrandChild, 10);
+            YGNodeStyleSetHeight(grandGrandGrandChild, 10);
+            YGNodeInsertChild(grandGrandChild, grandGrandGrandChild, 0);
+          }
+        }
+      }
+    }
+
+    YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
+    YGNodeFreeRecursive(root);
+  });
+});

package/yoga/benchmark/benchmark

@@ -0,0 +1,15 @@
+#!/bin/sh
+# 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.
+cd "$(dirname "$0")" || exit
+CAPTURES_PATH="$(dirname "$(realpath "$0")")""/captures"
+
+if [ "$1" = "buck" ]; then
+  buck run @//fbcode/mode/opt :benchmarkCXX "${CAPTURES_PATH}"
+else
+  cmake -B build -S . -D CMAKE_BUILD_TYPE=Release
+  cmake --build build
+  build/benchmark "${CAPTURES_PATH}"
+fi