mujoco

// Copyright 2024 DeepMind Technologies Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef MUJOCO_SRC_ENGINE_ENGINE_GLOBAL_TABLE_H_
#define MUJOCO_SRC_ENGINE_ENGINE_GLOBAL_TABLE_H_

#include <atomic>
#include <cctype>
#include <cstdio>
#include <mutex>
#include <new>
#include <string>
#include <string_view>
#include <type_traits>

#include "engine/engine_util_errmem.h"

namespace mujoco {
static constexpr int kCacheLineBytes = 256;

static inline bool CaseInsensitiveEqual(std::string_view s1, std::string_view s2) {
  if (s1.length() != s2.length()) {
    return false;
  }
  auto len = s1.length();
  for (decltype(len) i = 0; i < len; ++i) {
    if (std::tolower(s1[i]) != std::tolower(s2[i])) {
      return false;
    }
  }
  return true;
}

// A table intended for use as global storage for extension objects such as plugins, implemented as
// a linked list of array "blocks". This is a compromise that maintains a good degree of memory
// locality while not invalidating existing pointers when growing the table. It is expected that for
// most users, the number of objects loaded will be small enough to fit in the initial block, and
// so the global table will behave like an array. Since pointers are never invalidated, we do not
// need to apply a read lock on the global table when resolving an element.
template<typename T>
struct alignas(kCacheLineBytes) TableBlock {
  static constexpr int kBlockSize = 15;

  TableBlock() : objects{}, next(nullptr) {
    static_assert(
        sizeof(TableBlock<T>) / kCacheLineBytes ==
        sizeof(TableBlock<T>::objects) / kCacheLineBytes
        + (sizeof(TableBlock<T>::objects) % kCacheLineBytes > 0),
        "TableBlock::next doesn't fit in the same cache line as the end of TableBlock::objects");
  }

  T objects[kBlockSize];
  TableBlock<T>* next;
};


using Mutex = std::mutex;

class ReentrantWriteLock {
 public:
  ReentrantWriteLock(Mutex& mutex) : mutex_(mutex) {
    if (LockCountOnCurrentThread() == 0) {
      mutex_.lock();
    }
    ++LockCountOnCurrentThread();
  }

  ~ReentrantWriteLock() {
    if (--LockCountOnCurrentThread() == 0) {
      mutex_.unlock();
    }
  }

 private:
  Mutex& mutex_;

  static int& LockCountOnCurrentThread() noexcept {
    thread_local int counter = 0;
    return counter;
  }
};

template<typename T, typename Tag = void>
class GlobalTable {
 public:
  static GlobalTable<T, Tag>& GetSingleton() {
    static_assert(std::is_trivially_destructible_v<GlobalTable<T, Tag>>);
    static GlobalTable<T, Tag> global;
    return global;
  }

  // Each extension object type T must implement these.
  using ErrorMessage = char[512];
  static const char* HumanReadableTypeName();
  static std::string_view ObjectKey(const T&);
  static bool ObjectEqual(const T&, const T&);
  static bool CopyObject(T& dst, const T& src, ErrorMessage& err);

  int count() {
    return count_.load(std::memory_order_acquire);
  }

  ReentrantWriteLock LockExclusively() {
    return ReentrantWriteLock(mutex());
  }

  int AppendIfUnique(const T& obj) {
    ErrorMessage err = "\0";

    // ========= ATTENTION! ========================================================================
    // Do not handle objects with nontrivial destructors outside of this lambda.
    // Do not call mju_error inside this lambda.
    int slot = [&]() {
      auto lock = LockExclusively();

      int count = count_.load(std::memory_order_acquire);
      int local_idx = 0;
      TableBlock<T>* block = &first_block_;

      // check if a non-identical object has already been registered
      for (int i = 0; i < count; ++i, ++local_idx) {
        if (local_idx == TableBlock<T>::kBlockSize) {
          local_idx = 0;
          block = block->next;
        }
        const T& existing = block->objects[local_idx];
        if (CaseInsensitiveEqual(ObjectKey(obj), ObjectKey(existing))) {
          if (!ObjectEqual(obj, existing)) {
            std::snprintf(err, sizeof(err), "%s '%s' is already registered",
                          HumanReadableTypeName(), std::string(ObjectKey(obj)).c_str());
            return -1;
          } else {
            return i;
          }
        }
      }

      // allocate a new block if the last allocated block is full
      if (local_idx == TableBlock<T>::kBlockSize) {
        local_idx = 0;
        block->next = new(std::nothrow) TableBlock<T>;
        if (!block->next) {
          std::snprintf(err, sizeof(err), "failed to allocate memory for a new %s table block",
                        HumanReadableTypeName());
          return -1;
        }
        block = block->next;
      }

      // copy the new object into the table
      if (!CopyObject(block->objects[local_idx], obj, err)) {
        return -1;
      }

      // increment the global count with a release memory barrier
      count_.store(count + 1, std::memory_order_release);

      return count;
    }();
    // ========= ATTENTION! ========================================================================
    // End of safe lambda, do not handle objects with non-trivial destructors beyond this point.

    // registration failed, throw an mju_error
    if (slot < 0) {
      err[sizeof(err) - 1] = '\0';
      mju_error("%s", err);
    }

    return slot;
  }

  // look up by slot number, assuming that count() has already been called
  const T* GetAtSlotUnsafe(int slot, int nslot) {
    if (slot < 0 || slot >= nslot) {
      return nullptr;
    }

    TableBlock<T>* block = &first_block_;

    // iterate over blocks in the global table until the local index is less than the block size
    int local_idx = slot;
    while (local_idx >= TableBlock<T>::kBlockSize) {
      local_idx -= TableBlock<T>::kBlockSize;
      block = block->next;
      if (!block) {
        return nullptr;
      }
    }

    // local_idx is now a valid index into the current block
    T* obj = &(block->objects[local_idx]);

    // check if obj has been initialized
    if (obj && ObjectKey(*obj).empty()) {
      return nullptr;
    }

    return obj;
  }

  // look up by key, assuming that count() has already been called
  const T* GetByKeyUnsafe(std::string_view key, int* slot, int nslot) {
    if (slot) *slot = -1;

    if (key.empty()) {
      return nullptr;
    }

    TableBlock<T>* block = &first_block_;
    int found_slot = 0;
    while (block) {
      for (int i = 0;
          i < TableBlock<T>::kBlockSize && found_slot < nslot;
          ++i, ++found_slot) {
        const T& obj = block->objects[i];

        // reached an uninitialized object, which means that iterated beyond the object count
        // this should never happen if `count` was actually returned by count()
        std::string_view candidate_key = ObjectKey(obj);
        if (candidate_key.empty()) {
          return nullptr;
        }

        // check if key matches the query
        if (CaseInsensitiveEqual(candidate_key, key)) {
          if (slot) *slot = found_slot;
          return &obj;
        }
      }

      block = block->next;
    }

    return nullptr;
  }

  const T* GetAtSlot(int slot) {
    // count() uses memory_order_acquire which acts as a barrier that guarantees that all
    // objects up to `count` have been completely inserted
    return GetAtSlotUnsafe(slot, count());
  }

  const T* GetByKey(std::string_view key, int* slot) {
    // count() uses memory_order_acquire which acts as a barrier that guarantees that all
    // objects up to `count` have been completely inserted
    return GetByKeyUnsafe(key, slot, count());
  }

 private:
  GlobalTable() {
    new(mutex_) Mutex;
  }

  Mutex& mutex() {
    return *std::launder(reinterpret_cast<Mutex*>(&mutex_));
  }

  TableBlock<T> first_block_;
  std::atomic_int count_;

  // A mutex whose destructor is never run.
  // When a C++ program terminates, the destructors for function static objects and globals will be
  // executed by whichever thread started that termination but there is no guarantee that other
  // threads have terminated. In other words, a static object may be accessed by another thread
  // after it is deleted. We avoid destruction issues by never running the destructor.
  alignas(Mutex) unsigned char mutex_[sizeof(Mutex)];
};

}  // namespace mujoco

#endif  // MUJOCO_SRC_ENGINE_ENGINE_GLOBAL_TABLE_H_