# To Cache or Not to Cache
## 6 Conclusions  
Conventional caches are datapath caches due to each accessed item requiring that it must first reside in the cache before being consumed by the application. Non-datapath caches, being free of this requirement, demand entirely new techniques. Current non-datapath caches typically represented by flash- or NVM- based SSDs additionally have a limited number of write cycles, motivating cache management strategies that minimize cache updates. We developed **FOMO**, a non-datapath cache admission policy that operates in two states: _insert_ and _filter_, allowing cache insertions in the former state, and only selectively enabling insertions in the latter. Using two simple and inexpensive metrics, the _cache hit rate_ and the _reuse rate of missed items_, **FOMO** makes judicious decisions about cache admission dynamically.  
**FOMO** was algorithmically analyzed and comparatively evaluated against state-of-the-art datapath (LRU, ARC, LIRS) and non-datapath (LARC, mARC) caching algorithms and the TinyLFU cache admission policy. **FOMO** improves upon other non-datapath caching algorithms across a range of production storage workloads, while also reducing the write rate.  
**FOMO** is able to better take advantage of moments where inserting into the cache is beneficial to the hit rate compared to LARC and TinyLFU. Compared to mARC, **FOMO** is better able to reduce writes and provides better performance overall. **FOMO**, by allowing for more writes and taking calculated risks by caching new items based on the surrounding behavior is able to provide better performance in workloads with changing working sets compared to LARC and TinyLFU. This reinforces the design decision that led to **FOMO** mitigating the problems of both LARC and mARC, strengthening the reasonability of **FOMO**'s state decisions. The effectiveness of **FOMO** (and other non-datapath caching algorithms) relies heavily on the observability of reuse. For workloads that do not have a dominant behavior, as with CloudCache, **FOMO** is able to react quickly to any observed reuse patterns. It pairs observations from cache reuse with observations of reuse in **FOMO**'s Miss-History to derive an excellent understanding of the workload behavior. Our implementation of **FOMO** is available publicly ([[https://github.com/sylab/fomo](https://github.com/sylab/fomo)]([https://github.com/sylab/fomo](https://github.com/sylab/fomo)), accessed on 3 July 2024).  
Conceptualization, S.L.J. and R.R.; methodology, S.L.J. and R.R.; software, S.L.J.; resources, R.R.; data curation, S.L.J.; writing--original draft preparation, S.L.J.; writing--review and editing, R.R.; visualization, S.L.J.; supervision, R.R.; project administration, R.R. All authors have read and agreed to the published version of the manuscript.  
This work is supported in part by NSF awards CNS-1018262 and CNS-144874, and a NetApp Faculty Fellowship.  
The sources of the FOMO algorithm can be found in the following online location: [[https://github.com/sylab/fomo](https://github.com/sylab/fomo)]([https://github.com/sylab/fomo](https://github.com/sylab/fomo)), accessed on 3 July 2024.  
The authors declare no conflicts of interest.  
The following abbreviations are used in this manuscript: