@delali/narsil-react-native 0.0.0-stage → 0.3.1-next.146

package/cpp/HybridNarsilFilesImpl.cpp

@@ -0,0 +1,245 @@
+#include "HybridNarsilFilesImpl.hpp"
+#include "HostMemory.hpp"
+
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <dirent.h>
+#include <fcntl.h>
+#include <string>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <vector>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+constexpr mode_t PRIVATE_FILE_MODE = 0600;
+constexpr mode_t PRIVATE_DIRECTORY_MODE = 0700;
+constexpr double CURRENT_POSITION = -1;
+
+int openFlagsOf(const std::string& flags) {
+  if (flags == "r") return O_RDONLY;
+  if (flags == "r+") return O_RDWR;
+  if (flags == "w") return O_WRONLY | O_CREAT | O_TRUNC;
+  if (flags == "wx") return O_WRONLY | O_CREAT | O_EXCL;
+  if (flags == "w+") return O_RDWR | O_CREAT | O_TRUNC;
+  if (flags == "wx+") return O_RDWR | O_CREAT | O_EXCL;
+  if (flags == "a") return O_WRONLY | O_CREAT | O_APPEND;
+  if (flags == "a+") return O_RDWR | O_CREAT | O_APPEND;
+  throwInvalid("A file opens with r, r+, w, wx, w+, wx+, a, or a+, not " + flags);
+}
+
+int descriptorOf(double value) {
+  if (!std::isfinite(value) || value < 0 || value > INT32_MAX || std::floor(value) != value) {
+    throwSystemError(EBADF, "use the file descriptor", "");
+  }
+  return static_cast<int>(value);
+}
+
+void requirePath(const std::string& path) {
+  if (path.empty() || path.find('\0') != std::string::npos) throwInvalid("A path must be non-empty text without NUL");
+}
+
+double millisecondsOf(const struct timespec& time) {
+  return static_cast<double>(time.tv_sec) * 1000 + static_cast<double>(time.tv_nsec) / 1e6;
+}
+
+FileStatus statusOf(const struct stat& status) {
+#if defined(__APPLE__)
+  double modifiedMs = millisecondsOf(status.st_mtimespec);
+#else
+  double modifiedMs = millisecondsOf(status.st_mtim);
+#endif
+  return FileStatus(static_cast<double>(status.st_size), S_ISDIR(status.st_mode), S_ISREG(status.st_mode),
+                    std::to_string(static_cast<uint64_t>(status.st_dev)),
+                    std::to_string(static_cast<uint64_t>(status.st_ino)), modifiedMs);
+}
+
+void syncDescriptor(int descriptor) {
+#if defined(__APPLE__)
+  if (fcntl(descriptor, F_FULLFSYNC) == 0) return;
+  if (errno != ENOTSUP && errno != EINVAL && errno != ENOTTY) throwSystemError(errno, "flush the file", "");
+#endif
+  int result = 0;
+  do {
+    result = fsync(descriptor);
+  } while (result != 0 && errno == EINTR);
+  if (result != 0) throwSystemError(errno, "flush the file", "");
+}
+
+}
+
+double HybridNarsilFilesImpl::open(const std::string& path, const std::string& flags) {
+  requirePath(path);
+  int mode = openFlagsOf(flags) | O_CLOEXEC;
+  int descriptor = -1;
+  do {
+    descriptor = ::open(path.c_str(), mode, PRIVATE_FILE_MODE);
+  } while (descriptor < 0 && errno == EINTR);
+  if (descriptor < 0) throwSystemError(errno, "open", path);
+  return static_cast<double>(descriptor);
+}
+
+void HybridNarsilFilesImpl::close(double descriptor) {
+  if (::close(descriptorOf(descriptor)) != 0 && errno != EINTR) throwSystemError(errno, "close the file", "");
+}
+
+double HybridNarsilFilesImpl::read(double descriptor, const std::shared_ptr<ArrayBuffer>& target, double byteOffset,
+                                   double byteLength, double position) {
+  int file = descriptorOf(descriptor);
+  uint8_t* bytes = bytesWithin(target, byteOffset, byteLength, "The read target");
+  size_t length = static_cast<size_t>(byteLength);
+  if (length == 0) return 0;
+  ssize_t count = -1;
+  do {
+    count = position == CURRENT_POSITION
+                ? ::read(file, bytes, length)
+                : pread(file, bytes, length, static_cast<off_t>(requireByteCount(position, "A read position")));
+  } while (count < 0 && errno == EINTR);
+  if (count < 0) throwSystemError(errno, "read the file", "");
+  return static_cast<double>(count);
+}
+
+double HybridNarsilFilesImpl::write(double descriptor, const std::shared_ptr<ArrayBuffer>& source, double byteOffset,
+                                    double byteLength, double position) {
+  int file = descriptorOf(descriptor);
+  uint8_t* bytes = bytesWithin(source, byteOffset, byteLength, "The write source");
+  size_t length = static_cast<size_t>(byteLength);
+  if (length == 0) return 0;
+  ssize_t count = -1;
+  do {
+    count = position == CURRENT_POSITION
+                ? ::write(file, bytes, length)
+                : pwrite(file, bytes, length, static_cast<off_t>(requireByteCount(position, "A write position")));
+  } while (count < 0 && errno == EINTR);
+  if (count < 0) throwSystemError(errno, "write the file", "");
+  return static_cast<double>(count);
+}
+
+void HybridNarsilFilesImpl::sync(double descriptor) { syncDescriptor(descriptorOf(descriptor)); }
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridNarsilFilesImpl::readAsync(double descriptor, double byteLength, double position) {
+  int file = descriptorOf(descriptor);
+  size_t length = requireByteCount(byteLength, "A read length");
+  bool atCurrentPosition = position == CURRENT_POSITION;
+  off_t offset = atCurrentPosition ? 0 : static_cast<off_t>(requireByteCount(position, "A read position"));
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([file, length, atCurrentPosition, offset]() {
+    std::vector<uint8_t> bytes(length);
+    ssize_t count = 0;
+    if (length > 0) {
+      do {
+        count = atCurrentPosition ? ::read(file, bytes.data(), length) : pread(file, bytes.data(), length, offset);
+      } while (count < 0 && errno == EINTR);
+      if (count < 0) throwSystemError(errno, "read the file", "");
+    }
+    bytes.resize(static_cast<size_t>(count));
+    return ArrayBuffer::move(std::move(bytes));
+  });
+}
+
+std::shared_ptr<Promise<double>> HybridNarsilFilesImpl::writeAsync(double descriptor,
+                                                                   const std::shared_ptr<ArrayBuffer>& source,
+                                                                   double byteOffset, double byteLength,
+                                                                   double position) {
+  int file = descriptorOf(descriptor);
+  uint8_t* start = bytesWithin(source, byteOffset, byteLength, "The write source");
+  size_t length = static_cast<size_t>(byteLength);
+  bool atCurrentPosition = position == CURRENT_POSITION;
+  off_t offset = atCurrentPosition ? 0 : static_cast<off_t>(requireByteCount(position, "A write position"));
+  auto bytes = std::make_shared<std::vector<uint8_t>>(start, start + length);
+  return Promise<double>::async([file, bytes, atCurrentPosition, offset]() {
+    if (bytes->empty()) return 0.0;
+    ssize_t count = -1;
+    do {
+      count = atCurrentPosition ? ::write(file, bytes->data(), bytes->size())
+                                : pwrite(file, bytes->data(), bytes->size(), offset);
+    } while (count < 0 && errno == EINTR);
+    if (count < 0) throwSystemError(errno, "write the file", "");
+    return static_cast<double>(count);
+  });
+}
+
+std::shared_ptr<Promise<void>> HybridNarsilFilesImpl::syncAsync(double descriptor) {
+  int file = descriptorOf(descriptor);
+  return Promise<void>::async([file]() { syncDescriptor(file); });
+}
+
+void HybridNarsilFilesImpl::truncate(double descriptor, double byteLength) {
+  off_t length = static_cast<off_t>(requireByteCount(byteLength, "A file length"));
+  if (ftruncate(descriptorOf(descriptor), length) != 0) throwSystemError(errno, "truncate the file", "");
+}
+
+FileStatus HybridNarsilFilesImpl::descriptorStatus(double descriptor) {
+  struct stat status {};
+  if (fstat(descriptorOf(descriptor), &status) != 0) throwSystemError(errno, "read the file's status", "");
+  return statusOf(status);
+}
+
+FileStatus HybridNarsilFilesImpl::pathStatus(const std::string& path) {
+  requirePath(path);
+  struct stat status {};
+  if (stat(path.c_str(), &status) != 0) throwSystemError(errno, "stat", path);
+  return statusOf(status);
+}
+
+void HybridNarsilFilesImpl::makeDirectory(const std::string& path) {
+  requirePath(path);
+  if (mkdir(path.c_str(), PRIVATE_DIRECTORY_MODE) != 0) throwSystemError(errno, "mkdir", path);
+}
+
+std::vector<DirectoryEntry> HybridNarsilFilesImpl::readDirectory(const std::string& path) {
+  requirePath(path);
+  DIR* directory = opendir(path.c_str());
+  if (directory == nullptr) throwSystemError(errno, "scandir", path);
+  std::vector<DirectoryEntry> entries;
+  errno = 0;
+  while (struct dirent* entry = readdir(directory)) {
+    std::string name = entry->d_name;
+    if (name == "." || name == "..") continue;
+    bool isDirectory = entry->d_type == DT_DIR;
+    bool isFile = entry->d_type == DT_REG;
+    if (entry->d_type == DT_UNKNOWN) {
+      struct stat status {};
+      std::string full = path + "/" + name;
+      if (lstat(full.c_str(), &status) == 0) {
+        isDirectory = S_ISDIR(status.st_mode);
+        isFile = S_ISREG(status.st_mode);
+      }
+    }
+    entries.emplace_back(name, isDirectory, isFile);
+    errno = 0;
+  }
+  int failure = errno;
+  closedir(directory);
+  if (failure != 0) throwSystemError(failure, "scandir", path);
+  return entries;
+}
+
+void HybridNarsilFilesImpl::rename(const std::string& from, const std::string& to) {
+  requirePath(from);
+  requirePath(to);
+  if (::rename(from.c_str(), to.c_str()) != 0) throwSystemError(errno, "rename", from + "' -> '" + to);
+}
+
+void HybridNarsilFilesImpl::unlink(const std::string& path) {
+  requirePath(path);
+  if (::unlink(path.c_str()) != 0) throwSystemError(errno, "unlink", path);
+}
+
+void HybridNarsilFilesImpl::removeDirectory(const std::string& path) {
+  requirePath(path);
+  if (rmdir(path.c_str()) != 0) throwSystemError(errno, "rmdir", path);
+}
+
+void HybridNarsilFilesImpl::link(const std::string& existingPath, const std::string& newPath) {
+  requirePath(existingPath);
+  requirePath(newPath);
+  if (::link(existingPath.c_str(), newPath.c_str()) != 0) {
+    throwSystemError(errno, "link", existingPath + "' -> '" + newPath);
+  }
+}
+
+}

package/cpp/HybridNarsilFilesImpl.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "HybridNarsilFilesSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+class HybridNarsilFilesImpl : public HybridNarsilFilesSpec {
+public:
+  HybridNarsilFilesImpl() : HybridObject(TAG) {}
+
+  double open(const std::string& path, const std::string& flags) override;
+  void close(double descriptor) override;
+  double read(double descriptor, const std::shared_ptr<ArrayBuffer>& target, double byteOffset, double byteLength,
+              double position) override;
+  double write(double descriptor, const std::shared_ptr<ArrayBuffer>& source, double byteOffset, double byteLength,
+               double position) override;
+  void sync(double descriptor) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> readAsync(double descriptor, double byteLength,
+                                                                   double position) override;
+  std::shared_ptr<Promise<double>> writeAsync(double descriptor, const std::shared_ptr<ArrayBuffer>& source,
+                                              double byteOffset, double byteLength, double position) override;
+  std::shared_ptr<Promise<void>> syncAsync(double descriptor) override;
+  void truncate(double descriptor, double byteLength) override;
+  FileStatus descriptorStatus(double descriptor) override;
+  FileStatus pathStatus(const std::string& path) override;
+  void makeDirectory(const std::string& path) override;
+  std::vector<DirectoryEntry> readDirectory(const std::string& path) override;
+  void rename(const std::string& from, const std::string& to) override;
+  void unlink(const std::string& path) override;
+  void removeDirectory(const std::string& path) override;
+  void link(const std::string& existingPath, const std::string& newPath) override;
+};
+
+}

package/cpp/HybridNarsilHostImpl.cpp

@@ -0,0 +1,126 @@
+#include "HybridNarsilHostImpl.hpp"
+#include "Compression.hpp"
+#include "HostMemory.hpp"
+#include "NativeAtomics.hpp"
+#include "ProcessInfo.hpp"
+#include "ThreadPriority.hpp"
+#include "WorkletRuntimeDispatcher.hpp"
+
+#include <cerrno>
+#include <chrono>
+#include <cmath>
+#include <csignal>
+#include <cstdint>
+#include <cstdlib>
+#include <jsi/instrumentation.h>
+#include <unistd.h>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+double millisecondsSinceEpoch() {
+  auto now = std::chrono::system_clock::now().time_since_epoch();
+  return static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(now).count());
+}
+
+const double LIBRARY_LOADED_AT_MS = millisecondsSinceEpoch();
+
+const char* const GARBAGE_COLLECTION_CAUSE = "narsil-memory-limit";
+
+}
+
+void HybridNarsilHostImpl::loadHybridMethods() {
+  HybridNarsilHostSpec::loadHybridMethods();
+  registerHybrids(this, [](Prototype& prototype) {
+    prototype.registerRawHybridMethod("collectGarbage", 0, &HybridNarsilHostImpl::collectGarbage);
+    prototype.registerRawHybridMethod("installWorkletDispatcher", 0, &HybridNarsilHostImpl::installWorkletDispatcher);
+    prototype.registerRawHybridMethod("threadPriority", 0, &HybridNarsilHostImpl::threadPriority);
+    prototype.registerRawHybridMethod("adoptAppThreadPriority", 1, &HybridNarsilHostImpl::adoptAppThreadPriority);
+  });
+}
+
+jsi::Value HybridNarsilHostImpl::installWorkletDispatcher(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value*,
+                                                          size_t) {
+  return jsi::Value(installWorkletRuntimeDispatcher(runtime));
+}
+
+jsi::Value HybridNarsilHostImpl::threadPriority(jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t) {
+  return jsi::Value(priorityOfThisThread());
+}
+
+jsi::Value HybridNarsilHostImpl::adoptAppThreadPriority(jsi::Runtime&, const jsi::Value&, const jsi::Value* arguments,
+                                                        size_t count) {
+  if (count < 1 || !arguments[0].isNumber()) return jsi::Value(false);
+  return jsi::Value(margelo::nitro::narsil::adoptAppThreadPriority(arguments[0].getNumber()));
+}
+
+jsi::Value HybridNarsilHostImpl::collectGarbage(jsi::Runtime& runtime, const jsi::Value&, const jsi::Value*,
+                                                size_t) {
+  runtime.instrumentation().collectGarbage(GARBAGE_COLLECTION_CAUSE);
+  return jsi::Value(true);
+}
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::reserveMemory(double bytes) { return reserveRegion(bytes); }
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::allocateMemory(double bytes) { return allocateZeroed(bytes); }
+
+bool HybridNarsilHostImpl::ownsMemory(const std::shared_ptr<ArrayBuffer>& buffer) { return isHostOwned(buffer); }
+
+double HybridNarsilHostImpl::atomic(double operation, double elementKind, const std::shared_ptr<ArrayBuffer>& buffer,
+                                    double byteIndex, double value, double replacement) {
+  return atomicOnHostMemory(operation, elementKind, buffer, byteIndex, value, replacement);
+}
+
+void HybridNarsilHostImpl::fillRandom(const std::shared_ptr<ArrayBuffer>& target, double byteOffset,
+                                      double byteLength) {
+  uint8_t* bytes = bytesWithin(target, byteOffset, byteLength, "The random byte target");
+  if (bytes != nullptr) arc4random_buf(bytes, static_cast<size_t>(byteLength));
+}
+
+double HybridNarsilHostImpl::processId() { return static_cast<double>(getpid()); }
+
+double HybridNarsilHostImpl::processStartedAtMs() { return LIBRARY_LOADED_AT_MS; }
+
+bool HybridNarsilHostImpl::processIsAlive(double processId) {
+  if (!std::isfinite(processId) || processId <= 0 || std::floor(processId) != processId || processId > INT32_MAX) {
+    return false;
+  }
+  return kill(static_cast<pid_t>(processId), 0) == 0;
+}
+
+ProcessMemory HybridNarsilHostImpl::processMemory() {
+  return ProcessMemory(residentBytesOfThisProcess(), availableBytesForThisProcess());
+}
+
+std::string HybridNarsilHostImpl::appStorageDirectory() { return privateStorageDirectory(); }
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::deflateRaw(const std::shared_ptr<ArrayBuffer>& source,
+                                                              double byteOffset, double byteLength) {
+  uint8_t* bytes = bytesWithin(source, byteOffset, byteLength, "The bytes to compress");
+  return compressBytes(bytes, static_cast<size_t>(byteLength), CompressionFormat::RawDeflate);
+}
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::inflateRaw(const std::shared_ptr<ArrayBuffer>& source,
+                                                              double byteOffset, double byteLength,
+                                                              double rawByteLength) {
+  uint8_t* bytes = bytesWithin(source, byteOffset, byteLength, "The bytes to decompress");
+  size_t limit = requireByteCount(rawByteLength, "The decompressed length");
+  return inflateBytes(bytes, static_cast<size_t>(byteLength), CompressionFormat::RawDeflate, limit);
+}
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::gzip(const std::shared_ptr<ArrayBuffer>& source,
+                                                        double byteOffset, double byteLength) {
+  uint8_t* bytes = bytesWithin(source, byteOffset, byteLength, "The bytes to compress");
+  return compressBytes(bytes, static_cast<size_t>(byteLength), CompressionFormat::Gzip);
+}
+
+std::shared_ptr<ArrayBuffer> HybridNarsilHostImpl::gunzip(const std::shared_ptr<ArrayBuffer>& source,
+                                                          double byteOffset, double byteLength,
+                                                          double maxByteLength) {
+  uint8_t* bytes = bytesWithin(source, byteOffset, byteLength, "The bytes to decompress");
+  size_t limit = requireByteCount(maxByteLength, "The decompressed length limit");
+  return inflateBytes(bytes, static_cast<size_t>(byteLength), CompressionFormat::Gzip, limit);
+}
+
+}

package/cpp/HybridNarsilHostImpl.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "HybridNarsilHostSpec.hpp"
+
+namespace margelo::nitro::narsil {
+
+class HybridNarsilHostImpl : public HybridNarsilHostSpec {
+public:
+  HybridNarsilHostImpl() : HybridObject(TAG) {}
+
+  void loadHybridMethods() override;
+  jsi::Value collectGarbage(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                            size_t count);
+  jsi::Value installWorkletDispatcher(jsi::Runtime& runtime, const jsi::Value& thisValue,
+                                      const jsi::Value* arguments, size_t count);
+  jsi::Value threadPriority(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                            size_t count);
+  jsi::Value adoptAppThreadPriority(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+                                    size_t count);
+
+  std::shared_ptr<ArrayBuffer> reserveMemory(double bytes) override;
+  std::shared_ptr<ArrayBuffer> allocateMemory(double bytes) override;
+  bool ownsMemory(const std::shared_ptr<ArrayBuffer>& buffer) override;
+  double atomic(double operation, double elementKind, const std::shared_ptr<ArrayBuffer>& buffer, double byteIndex,
+                double value, double replacement) override;
+  void fillRandom(const std::shared_ptr<ArrayBuffer>& target, double byteOffset, double byteLength) override;
+  double processId() override;
+  double processStartedAtMs() override;
+  bool processIsAlive(double processId) override;
+  ProcessMemory processMemory() override;
+  std::string appStorageDirectory() override;
+  std::shared_ptr<ArrayBuffer> deflateRaw(const std::shared_ptr<ArrayBuffer>& source, double byteOffset,
+                                          double byteLength) override;
+  std::shared_ptr<ArrayBuffer> inflateRaw(const std::shared_ptr<ArrayBuffer>& source, double byteOffset,
+                                          double byteLength, double rawByteLength) override;
+  std::shared_ptr<ArrayBuffer> gzip(const std::shared_ptr<ArrayBuffer>& source, double byteOffset,
+                                    double byteLength) override;
+  std::shared_ptr<ArrayBuffer> gunzip(const std::shared_ptr<ArrayBuffer>& source, double byteOffset,
+                                      double byteLength, double maxByteLength) override;
+};
+
+}

package/cpp/NativeAtomics.cpp

@@ -0,0 +1,110 @@
+#include "NativeAtomics.hpp"
+#include "HostMemory.hpp"
+
+#include <cmath>
+#include <cstdint>
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+enum AtomicOperation : int {
+  ATOMIC_LOAD = 0,
+  ATOMIC_STORE = 1,
+  ATOMIC_ADD = 2,
+  ATOMIC_SUB = 3,
+  ATOMIC_AND = 4,
+  ATOMIC_OR = 5,
+  ATOMIC_XOR = 6,
+  ATOMIC_EXCHANGE = 7,
+  ATOMIC_COMPARE_EXCHANGE = 8,
+};
+
+enum AtomicElementKind : int {
+  ELEMENT_INT8 = 0,
+  ELEMENT_UINT8 = 1,
+  ELEMENT_INT16 = 2,
+  ELEMENT_UINT16 = 3,
+  ELEMENT_INT32 = 4,
+  ELEMENT_UINT32 = 5,
+};
+
+constexpr double TWO_TO_THE_32 = 4294967296.0;
+
+uint32_t wrappedToUint32(double value) {
+  if (!std::isfinite(value)) return 0;
+  double wrapped = std::fmod(std::trunc(value), TWO_TO_THE_32);
+  if (wrapped < 0) wrapped += TWO_TO_THE_32;
+  return static_cast<uint32_t>(wrapped);
+}
+
+template <typename T>
+T elementOf(double value) {
+  return static_cast<T>(wrappedToUint32(value));
+}
+
+template <typename T>
+double atomicOn(T* at, int operation, double value, double replacement) {
+  T operand = elementOf<T>(value);
+  switch (operation) {
+    case ATOMIC_LOAD:
+      return static_cast<double>(__atomic_load_n(at, __ATOMIC_SEQ_CST));
+    case ATOMIC_STORE:
+      __atomic_store_n(at, operand, __ATOMIC_SEQ_CST);
+      return static_cast<double>(operand);
+    case ATOMIC_ADD:
+      return static_cast<double>(__atomic_fetch_add(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_SUB:
+      return static_cast<double>(__atomic_fetch_sub(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_AND:
+      return static_cast<double>(__atomic_fetch_and(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_OR:
+      return static_cast<double>(__atomic_fetch_or(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_XOR:
+      return static_cast<double>(__atomic_fetch_xor(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_EXCHANGE:
+      return static_cast<double>(__atomic_exchange_n(at, operand, __ATOMIC_SEQ_CST));
+    case ATOMIC_COMPARE_EXCHANGE: {
+      T expected = operand;
+      __atomic_compare_exchange_n(at, &expected, elementOf<T>(replacement), false, __ATOMIC_SEQ_CST,
+                                  __ATOMIC_SEQ_CST);
+      return static_cast<double>(expected);
+    }
+    default:
+      throwInvalid("An atomic operation is a number from 0 to 8");
+  }
+}
+
+template <typename T>
+double atomicAt(const std::shared_ptr<ArrayBuffer>& buffer, double byteIndex, int operation, double value,
+                double replacement) {
+  uint8_t* bytes = bytesWithin(buffer, byteIndex, static_cast<double>(sizeof(T)), "The atomic element");
+  if (reinterpret_cast<uintptr_t>(bytes) % alignof(T) != 0) throwInvalid("The atomic element is not aligned");
+  return atomicOn(reinterpret_cast<T*>(bytes), operation, value, replacement);
+}
+
+}
+
+double atomicOnHostMemory(double operation, double elementKind, const std::shared_ptr<ArrayBuffer>& buffer,
+                          double byteIndex, double value, double replacement) {
+  if (!isHostOwned(buffer)) throwInvalid("Atomic operations run only on memory that the native module allocated");
+  int op = static_cast<int>(operation);
+  switch (static_cast<int>(elementKind)) {
+    case ELEMENT_INT8:
+      return atomicAt<int8_t>(buffer, byteIndex, op, value, replacement);
+    case ELEMENT_UINT8:
+      return atomicAt<uint8_t>(buffer, byteIndex, op, value, replacement);
+    case ELEMENT_INT16:
+      return atomicAt<int16_t>(buffer, byteIndex, op, value, replacement);
+    case ELEMENT_UINT16:
+      return atomicAt<uint16_t>(buffer, byteIndex, op, value, replacement);
+    case ELEMENT_INT32:
+      return atomicAt<int32_t>(buffer, byteIndex, op, value, replacement);
+    case ELEMENT_UINT32:
+      return atomicAt<uint32_t>(buffer, byteIndex, op, value, replacement);
+    default:
+      throwInvalid("An atomic element kind is a number from 0 to 5");
+  }
+}
+
+}

package/cpp/NativeAtomics.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+
+namespace margelo::nitro::narsil {
+
+double atomicOnHostMemory(double operation, double elementKind, const std::shared_ptr<ArrayBuffer>& buffer,
+                          double byteIndex, double value, double replacement);
+
+}

package/cpp/ProcessInfo.cpp

@@ -0,0 +1,83 @@
+#include "ProcessInfo.hpp"
+#include "HostMemory.hpp"
+
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#if defined(__APPLE__)
+#include <mach/mach.h>
+#include <os/proc.h>
+#elif defined(__ANDROID__)
+#include "AndroidEnvironment.hpp"
+#include <fstream>
+#endif
+
+namespace margelo::nitro::narsil {
+
+namespace {
+
+constexpr double UNKNOWN_BYTES = -1;
+
+void makeDirectoryIfMissing(const std::string& path) {
+  if (mkdir(path.c_str(), 0700) != 0 && errno != EEXIST) throwSystemError(errno, "create the directory", path);
+}
+
+}
+
+#if defined(__APPLE__)
+
+double residentBytesOfThisProcess() {
+  task_vm_info_data_t info{};
+  mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
+  if (task_info(mach_task_self(), TASK_VM_INFO, reinterpret_cast<task_info_t>(&info), &count) != KERN_SUCCESS) {
+    return UNKNOWN_BYTES;
+  }
+  return static_cast<double>(info.phys_footprint);
+}
+
+double availableBytesForThisProcess() { return static_cast<double>(os_proc_available_memory()); }
+
+std::string privateStorageDirectory() {
+  const char* home = std::getenv("HOME");
+  if (home == nullptr || home[0] == '\0') throwSystemError(ENOENT, "find the app's home directory", "HOME");
+  std::string library = std::string(home) + "/Library";
+  std::string support = library + "/Application Support";
+  makeDirectoryIfMissing(library);
+  makeDirectoryIfMissing(support);
+  return support;
+}
+
+#elif defined(__ANDROID__)
+
+double residentBytesOfThisProcess() {
+  std::ifstream statm("/proc/self/statm");
+  double totalPages = 0;
+  double residentPages = 0;
+  if (!(statm >> totalPages >> residentPages)) return UNKNOWN_BYTES;
+  long page = sysconf(_SC_PAGESIZE);
+  return residentPages * static_cast<double>(page > 0 ? page : 4096);
+}
+
+double availableBytesForThisProcess() { return androidAvailableBytes(); }
+
+std::string privateStorageDirectory() {
+  std::string files = androidFilesDirectory();
+  if (files.empty()) throwSystemError(ENOENT, "find the app's private directory", "Context.getFilesDir()");
+  makeDirectoryIfMissing(files);
+  return files;
+}
+
+#else
+
+double residentBytesOfThisProcess() { return UNKNOWN_BYTES; }
+double availableBytesForThisProcess() { return UNKNOWN_BYTES; }
+std::string privateStorageDirectory() { throwSystemError(ENOTSUP, "find the app's private directory", ""); }
+
+#endif
+
+}

package/cpp/ProcessInfo.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <string>
+
+namespace margelo::nitro::narsil {
+
+double residentBytesOfThisProcess();
+double availableBytesForThisProcess();
+std::string privateStorageDirectory();
+
+}