casadi::RevWeakCache< K, T > Class Template Reference

#include <generic_shared.hpp>

Detailed Description

template<typename K, typename T>
class casadi::RevWeakCache< K, T >

Key is stored as a weakref Value is stored as regular ref

Definition at line 343 of file generic_shared.hpp.

Public Member Functions
void	tocache (const K &key, const T &f, bool needs_lock=true, bool prune=true)
void	tocache_if_missing (const K &key, T &f, bool prune=true)
bool	incache (const K &key, T &f, bool needs_lock=true) const

Member Function Documentation

incache()

template<typename K , typename T >

bool casadi::RevWeakCache< K, T >::incache ( const K &  key, T &  f, bool  needs_lock = true  ) const

inline

Definition at line 393 of file generic_shared.hpp.

                                                                 {
#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;
      }
    }

tocache()

template<typename K , typename T >

void casadi::RevWeakCache< K, T >::tocache ( const K &  key, const T &  f, bool  needs_lock = true, bool  prune = true  )

inline

Definition at line 345 of file generic_shared.hpp.

                         {
#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
        }
      }
    }

tocache_if_missing()

template<typename K , typename T >

void casadi::RevWeakCache< K, T >::tocache_if_missing ( const K &  key, T &  f, bool  prune = true  )

inline

Definition at line 384 of file generic_shared.hpp.

                                                                 {
#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);
      }
    }

---

The documentation for this class was generated from the following file:

• generic_shared.hpp