Add bindings for existing admission algorithms

Author: AlexSutila

libcachesim/__init__.py

@@ -5,7 +5,6 @@
 from .libcachesim_python import (
     Cache,
     Request,
-    Admissioner,
     ReqOp,
     ReaderInitParam,
     TraceType,
@@ -57,6 +56,14 @@
     PluginCache,
 )
 
+from .admissioner import (
+    BloomFilterAdmissioner,
+    ProbAdmissioner,
+    SizeAdmissioner,
+    SizeProbabilisticAdmissioner,
+    AdaptSizeAdmissioner,
+)
+
 from .trace_reader import TraceReader
 from .trace_analyzer import TraceAnalyzer
 from .synthetic_reader import SyntheticReader, create_zipf_requests, create_uniform_requests
@@ -111,6 +118,12 @@
     "LRB",
     # Plugin cache
     "PluginCache",
+    # Admission algorithms
+    "BloomFilterAdmissioner",
+    "ProbAdmissioner",
+    "SizeAdmissioner",
+    "SizeProbabilisticAdmissioner",
+    "AdaptSizeAdmissioner",
     # Readers and analyzers
     "TraceReader",
     "TraceAnalyzer",

libcachesim/admissioner.py

@@ -0,0 +1,69 @@
+from abc import ABC
+from .libcachesim_python import (
+    Admissioner,
+    Request,
+    create_bloomfilter_admissioner,
+    create_prob_admissioner,
+    create_size_admissioner,
+    create_size_probabilistic_admissioner,
+    create_adaptsize_admissioner,
+)
+
+
+class AdmissionerBase(ABC):
+    _admissioner: Admissioner  # Internal C++ admissioner object
+
+    def __init__(self, _admissioner: Admissioner):
+        self._admissioner = _admissioner
+
+    def clone(self):
+        return self._admissioner.clone()
+
+    def update(self, req: Request, cache_size: int):
+        return self._admissioner.update(req, cache_size)
+
+    def admit(self, req: Request):
+        return self._admissioner.admit(req)
+
+    def free(self):
+        return self._admissioner.free()
+
+
+class BloomFilterAdmissioner(AdmissionerBase):
+    def __init__(self):
+        admissioner = create_bloomfilter_admissioner(None)
+        super().__init__(admissioner)
+
+
+class ProbAdmissioner(AdmissionerBase):
+    def __init__(self, prob: float = None):
+        params = f"prob={prob}" if prob is not None else None
+        admissioner = create_prob_admissioner(params)
+        super().__init__(admissioner)
+
+
+class SizeAdmissioner(AdmissionerBase):
+    def __init__(self, size_threshold: int = None):
+        params = f"size={size_threshold}" if size_threshold is not None else None
+        admissioner = create_size_admissioner(params)
+        super().__init__(admissioner)
+
+
+class SizeProbabilisticAdmissioner(AdmissionerBase):
+    def __init__(self, exponent: float = None):
+        params = f"exponent={exponent}" if exponent is not None else None
+        admissioner = create_size_probabilistic_admissioner(params)
+        super().__init__(admissioner)
+
+
+class AdaptSizeAdmissioner(AdmissionerBase):
+    def __init__(self, max_iteration: int = None, reconf_interval: int = None):
+        params = ",".join(
+            f'{arg}={val}' for arg, val in {
+                'max-iteration': max_iteration,
+                'reconf-interval': reconf_interval,
+            }.items() if val is not None
+        ) or None
+
+        admissioner = create_adaptsize_admissioner(params)
+        super().__init__(admissioner)

libcachesim/cache.py

@@ -27,6 +27,8 @@
     # Optimal algorithms
     Belady_init,
     BeladySize_init,
+    # Cache admission
+    Admissioner,
     # Probabilistic algorithms
     LRU_Prob_init,
     flashProb_init,
@@ -49,7 +51,9 @@ class CacheBase(ABC):
 
     _cache: Cache  # Internal C++ cache object
 
-    def __init__(self, _cache: Cache):
+    def __init__(self, _cache: Cache, admissioner: Admissioner = None):
+        if admissioner is not None:
+            _cache.admissioner = admissioner._admissioner
         self._cache = _cache
 
     def get(self, req: Request) -> bool:
@@ -81,7 +85,7 @@ def get_occupied_byte(self) -> int:
 
     def get_n_obj(self) -> int:
         return self._cache.get_n_obj()
-    
+
     def set_cache_size(self, new_size: int) -> None:
         self._cache.set_cache_size(new_size)
 
@@ -171,10 +175,16 @@ class LRU(CacheBase):
     """Least Recently Used cache (no special parameters)"""
 
     def __init__(
-        self, cache_size: int, default_ttl: int = 86400 * 300, hashpower: int = 24, consider_obj_metadata: bool = False
+        self,
+        cache_size: int,
+        default_ttl: int = 86400 * 300,
+        hashpower: int = 24,
+        consider_obj_metadata: bool = False,
+        admissioner: Admissioner = None,
     ):
         super().__init__(
-            _cache=LRU_init(_create_common_params(cache_size, default_ttl, hashpower, consider_obj_metadata))
+            _cache=LRU_init(_create_common_params(cache_size, default_ttl, hashpower, consider_obj_metadata)),
+            admissioner=admissioner
         )
 
 

src/export_admissioner.cpp

@@ -16,7 +16,38 @@ namespace libcachesim {
 
 namespace py = pybind11;
 
+template <admissioner_t *(*fn)(const char *)>
+void export_admissioner_creator(py::module &m, const std::string &name) {
+  m.def(
+      name.c_str(),
+      [=](py::object params_obj) {
+        const char *params = nullptr;
+        std::string s;
+
+        // Here, by allowing the passing of None to resolve to NULL, we can
+        // allow the default arguments specified in C++ to be used when no
+        // arguments are specified through the Python wrapper classes.
+        if (!params_obj.is_none()) {
+          s = params_obj.cast<std::string>();
+          params = s.c_str();
+        }
+
+        // Admissioner is exported lower down
+        admissioner_t *admissioner = fn(params);
+        if (!admissioner)
+          throw std::runtime_error("Creater for " + name + " returned NULL");
+        return admissioner;
+      },
+      py::return_value_policy::reference);
+}
+
 void export_admissioner(py::module &m) {
+  // ***********************************************************************
+  // ****                                                               ****
+  // ****                 Admissioner struct bindings                   ****
+  // ****                                                               ****
+  // ***********************************************************************
+
   py::class_<admissioner_t>(m, "Admissioner")
       .def(py::init<>())
       .def_readwrite("params", &admissioner_t::params)
@@ -70,6 +101,22 @@ void export_admissioner(py::module &m) {
           throw std::runtime_error("free function pointer is NULL");
         self.free(&self);
       });
+  // ***********************************************************************
+  // ****                                                               ****
+  // ****             end of admissioner struct bindings                ****
+  // ****                                                               ****
+  // ***********************************************************************
+
+  export_admissioner_creator<create_bloomfilter_admissioner>(
+      m, "create_bloomfilter_admissioner");
+  export_admissioner_creator<create_prob_admissioner>(
+      m, "create_prob_admissioner");
+  export_admissioner_creator<create_size_admissioner>(
+      m, "create_size_admissioner");
+  export_admissioner_creator<create_size_probabilistic_admissioner>(
+      m, "create_size_probabilistic_admissioner");
+  export_admissioner_creator<create_adaptsize_admissioner>(
+      m, "create_adaptsize_admissioner");
 }
 
 }  // namespace libcachesim

src/export_cache.cpp

@@ -273,6 +273,7 @@ void export_cache(py::module& m) {
       .def_readonly("n_req", &cache_t::n_req)
       .def_readonly("cache_name", &cache_t::cache_name)
       .def_readonly("init_params", &cache_t::init_params)
+      .def_readwrite("admissioner", &cache::admissioner)
       .def(
           "get",
           [](cache_t& self, const request_t& req) {