generic_shared.hpp

/*
 *    This file is part of CasADi.
 *
 *    CasADi -- A symbolic framework for dynamic optimization.
 *    Copyright (C) 2010-2023 Joel Andersson, Joris Gillis, Moritz Diehl,
 *                            KU Leuven. All rights reserved.
 *    Copyright (C) 2011-2014 Greg Horn
 *
 *    CasADi is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    CasADi is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with CasADi; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */
 
 
#ifndef CASADI_GENERIC_SHARED_HPP
#define CASADI_GENERIC_SHARED_HPP
 
#include "casadi_common.hpp"
#include "exception.hpp"
#include <unordered_map>
#include <vector>
#include <cstdint>
#ifdef CASADI_WITH_THREAD
#ifdef CASADI_WITH_THREAD_MINGW
#include <mingw.mutex.h>
#else // CASADI_WITH_THREAD_MINGW
#include <mutex>
#endif // CASADI_WITH_THREAD_MINGW
#endif //CASADI_WITH_THREAD
 
#include <memory>
 
namespace casadi {
 
  // Forward declaration of weak reference class
  template<typename Shared, typename Internal>
  class GenericWeakRef;
 
  // Forward declaration of internal classes
  template<typename Shared, typename Internal>
  class GenericSharedInternal;
 
  template<typename Shared, typename Internal>
  class GenericWeakRefInternal;
 
  template<typename Shared, typename Internal>
  class CASADI_EXPORT GenericShared {
#ifndef SWIG
    template<class B, class S> friend B shared_cast(S& A);
    template<class B, class S> friend const B shared_cast(const S& A);
#endif // SWIG
 
  public:
#ifndef SWIG
    GenericShared() {
        node = nullptr;
    }
 
    GenericShared(const GenericShared& ref) {
        node = ref.node;
        count_up();
    }
 
    ~GenericShared() {
      count_down();
    }
 
    GenericShared& operator=(const GenericShared& ref);
 
    void own(Internal* node);
 
    void assign(Internal* node);
 
    Internal* get() const;
 
    casadi_int getCount() const;
 
    void swap(GenericShared& other);
 
    Internal* operator->() const;
#endif // SWIG
 
    std::string debug_repr() const;
 
 
    bool is_null() const;
 
    casadi_int __hash__() const;
 
#ifndef SWIG
    GenericWeakRef<Shared, Internal>* weak();
  protected:
    void count_up(); // increase counter of the node
    void count_down(); // decrease counter of the node
  private:
    Internal *node;
#endif // SWIG
  };
 
  template<typename Shared, typename Internal>
  class CASADI_EXPORT GenericWeakRef : public GenericShared<Shared, Internal> {
  public:
    friend class GenericSharedInternal<Shared, Internal>;
 
    using GenericShared<Shared, Internal>::is_null;
 
    GenericWeakRef(int dummy=0);
 
    GenericWeakRef(Shared shared);
 
    Shared shared() const;
 
    bool alive() const;
 
    bool shared_if_alive(Shared& shared) const;
 
    GenericWeakRefInternal<Shared, Internal>* operator->();
 
    const GenericWeakRefInternal<Shared, Internal>* operator->() const;
 
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    std::shared_ptr<std::mutex> get_mutex() const;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
 
#ifndef SWIG
  private:
    explicit GenericWeakRef(Internal* raw);
 
    void kill();
#endif // SWIG
  };
 
#ifndef SWIG
 
  template<class B, class S>
  B shared_cast(S& A) {
 
    typename S::internal_base_type* ptr = A.get();
 
    B ret;
 
    if (!B::test_cast(ptr)) return ret;
 
    ret.own(ptr);
    return ret;
  }
 
  template<class B, class S>
  const B shared_cast(const S& A) {
    S A_copy = A;
    return shared_cast<B, S>(A_copy);
  }
 
#endif // SWIG
 
template<typename K, typename T>
class CASADI_EXPORT WeakCache {
  public:
    void tocache(const K& key, const T& f, bool needs_lock=true,
        bool prune=true) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      // Add to cache
      auto it = cache_.find(key);
 
      if (it == cache_.end()) {
        cache_.emplace(key, f);
      } else if (!it->second.alive()) {
        it->second = f;
      }
 
      // Remove a lost reference, if any, to prevent uncontrolled growth
      if (!prune) return;
      for (auto it = cache_.begin(); it!=cache_.end(); ++it) {
        if (!it->second.alive()) {
          cache_.erase(it);
          break; // just one dead reference is enough
        }
      }
    }
    /* \brief Thread-safe unique caching
    * While an incache/tocache pair in multi-threaded context is safe
    * it may lead to fresh cache entries being overwritten.
    *
    * A mutex lock_guard on the scope of an incache/tocache pair
    * may lead to deadlocks.
    *
    */
    void tocache_if_missing(const K& key, T& f, bool prune=true) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      std::lock_guard<std::mutex> lock(mtx_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      if (!incache(key, f, false)) {
        tocache(key, f, false, prune);
      }
    }
    bool incache(const K& key, T& f, bool needs_lock=true) const {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      auto it = cache_.find(key);
      typename T::base_type temp;
      if (it!=cache_.end() && it->second.shared_if_alive(temp)) {
        f = shared_cast<T>(temp);
        return true;
      } else {
        return false;
      }
    }
    // Remove all expired entries in one pass.
    void prune() {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      std::lock_guard<std::mutex> lock(mtx_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      for (auto it = cache_.begin(); it!=cache_.end();) {
        if (!it->second.alive()) {
          it = cache_.erase(it);
        } else {
          ++it;
        }
      }
    }
    void cache(std::vector<K>& keys, std::vector<T>& entries) const {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      std::lock_guard<std::mutex> lock(mtx_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      keys.clear();
      entries.clear();
      // Add all entries that haven't been deleted
      for (auto&& cf : cache_) {
        typename T::base_type temp;
        if (cf.second.shared_if_alive(temp)) {
          keys.push_back(cf.first);
          entries.push_back(shared_cast<T>(temp));
        }
      }
    }
  private:
    std::unordered_map<K,
      GenericWeakRef<typename T::base_type, typename T::internal_base_type>
    > cache_;
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    mutable std::mutex mtx_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
};
 
template<typename K, typename T>
class CASADI_EXPORT RevWeakCache {
  public:
    void tocache(const K& key, const T& f, bool needs_lock=true,
        bool prune=true) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      // Add to cache
      const void* k = key.get();
      auto it = pre_cache_.find(k);
 
      if (it == pre_cache_.end()) {
        pre_cache_.emplace(k, key);
        cache_.emplace(k, f);
      } else if (it->second.get() != typename K::base_type(key).weak()->get()) {
        // The address was recycled. Compare weak-reference identities without
        // reading liveness, and replace both entries in place.
        it->second = key;
        cache_.find(k)->second = f;
      }
 
      // Remove a lost reference, if any, to prevent uncontrolled growth
      if (!prune) return;
      for (auto it = pre_cache_.begin(); it!=pre_cache_.end(); ++it) {
        if (!it->second.alive()) {
          const void* dead = it->first;
          pre_cache_.erase(it);
          cache_.erase(dead);
          break; // just one dead reference is enough
        }
      }
    }
    /* \brief Thread-safe unique caching
    * While an incache/tocache pair in multi-threaded context is safe
    * it may lead to fresh cache entries being overwritten.
    *
    * A mutex lock_guard on the scope of an incache/tocache pair
    * may lead to deadlocks.
    *
    */
    void tocache_if_missing(const K& key, T& f, bool prune=true) {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      std::lock_guard<std::mutex> lock(mtx_);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      if (!incache(key, f, false)) {
        tocache(key, f, false, prune);
      }
    }
    bool incache(const K& key, T& f, bool needs_lock=true) const {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
      // Safe access to cache_
      casadi::conditional_lock_guard<std::mutex> lock(mtx_, needs_lock);
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
      const void* k = key.get();
      auto it = pre_cache_.find(k);
      K temp;
      if (it!=pre_cache_.end() && it->second.shared_if_alive(temp)) {
        auto it2 = cache_.find(k);
        f = it2->second;
        return true;
      } else {
        return false;
      }
    }
  private:
    std::unordered_map<const void*,
    GenericWeakRef<typename K::base_type, typename K::internal_base_type>
    > pre_cache_;
    std::unordered_map<const void*, T> cache_;
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    mutable std::mutex mtx_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
};
 
template<typename K, typename T>
class CASADI_EXPORT SimpleCache {
  public:
    void tocache(const K& key, const T& value) {
      cache_[key] = value;
    }
 
    bool incache(const K& key, T& value) const {
      auto it = cache_.find(key);
      if (it != cache_.end()) {
        value = it->second;
        return true;
      }
      return false;
    }
 
    const std::unordered_map<K, T>& cache_map() const {
      return cache_;
    }
 
  private:
    std::unordered_map<K, T> cache_;
};
 
} // namespace casadi
 
 
#endif // CASADI_GENERIC_SHARED_HPP