From 6e8a742705bc1f47fff9399a7a6bc0675a09cb1c Mon Sep 17 00:00:00 2001 From: Tuan-Dat Tran Date: Wed, 27 Nov 2024 16:31:46 +0100 Subject: [PATCH] feat: add cache simulation with experiments for TTL and eviction strategies Introduce a new simulation for Age of Information (AoI) cache management, focusing on varying TTL values and eviction strategies (LRU and Random Eviction). This includes: - New Python script for event-driven cache simulations using . - Experiments for "No Refresh" across multiple TTL configurations (, , ..., ) with: - Hit rate and object age tracking (, , etc.). - Visualizations (e.g., , ). - Updated to describe experimental setup and configurations. - Log export file () for simulation results. - Refactor of with detailed strategy configurations and runtime notes. ### Reason The commit enhances the project by enabling detailed experiments with configurable cache parameters, supporting analysis of cache efficiency and AoI under varying conditions. This provides a foundation for more sophisticated simulations and insights. ### Performance - Runtime: ~4m 29s for . Co-authored experiments introduce structured data files and visualizations, improving clarity for future iterations. Signed-off-by: Tuan-Dat Tran --- aoi_cache_simulation.ipynb | 625 +++++++++++++++--- aoi_cache_simulation.py | 306 +++++++++ experiments/No_Refresh_0_5s_ttl/details.csv | 100 +++ experiments/No_Refresh_0_5s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18423 bytes .../No_Refresh_0_5s_ttl/overall_hit_age.csv | 9 + experiments/No_Refresh_1_0s_ttl/details.csv | 100 +++ experiments/No_Refresh_1_0s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18320 bytes .../No_Refresh_1_0s_ttl/overall_hit_age.csv | 9 + experiments/No_Refresh_2_0s_ttl/details.csv | 100 +++ experiments/No_Refresh_2_0s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18402 bytes .../No_Refresh_2_0s_ttl/overall_hit_age.csv | 9 + experiments/No_Refresh_3_0s_ttl/details.csv | 100 +++ experiments/No_Refresh_3_0s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18425 bytes .../No_Refresh_3_0s_ttl/overall_hit_age.csv | 9 + experiments/No_Refresh_4_0s_ttl/details.csv | 100 +++ experiments/No_Refresh_4_0s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18849 bytes .../No_Refresh_4_0s_ttl/overall_hit_age.csv | 9 + experiments/No_Refresh_5_0s_ttl/details.csv | 100 +++ experiments/No_Refresh_5_0s_ttl/hit_age.csv | 101 +++ .../lambda_distribution.pdf | Bin 0 -> 11740 bytes .../objects_in_cache_over_time.pdf | Bin 0 -> 18713 bytes .../No_Refresh_5_0s_ttl/overall_hit_age.csv | 9 + experiments/README.md | 15 + export.csv | 198 +++--- graphs/objects_in_cache_over_time.pdf | Bin 0 -> 20395 bytes logs/export.csv | 100 +++ note.md | 49 +- objects_in_cache_over_time.pdf | Bin 0 -> 18713 bytes 38 files changed, 2337 insertions(+), 216 deletions(-) create mode 100644 aoi_cache_simulation.py create mode 100644 experiments/No_Refresh_0_5s_ttl/details.csv create mode 100644 experiments/No_Refresh_0_5s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_0_5s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_0_5s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_0_5s_ttl/overall_hit_age.csv create mode 100644 experiments/No_Refresh_1_0s_ttl/details.csv create mode 100644 experiments/No_Refresh_1_0s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_1_0s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_1_0s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_1_0s_ttl/overall_hit_age.csv create mode 100644 experiments/No_Refresh_2_0s_ttl/details.csv create mode 100644 experiments/No_Refresh_2_0s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_2_0s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_2_0s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_2_0s_ttl/overall_hit_age.csv create mode 100644 experiments/No_Refresh_3_0s_ttl/details.csv create mode 100644 experiments/No_Refresh_3_0s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_3_0s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_3_0s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_3_0s_ttl/overall_hit_age.csv create mode 100644 experiments/No_Refresh_4_0s_ttl/details.csv create mode 100644 experiments/No_Refresh_4_0s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_4_0s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_4_0s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_4_0s_ttl/overall_hit_age.csv create mode 100644 experiments/No_Refresh_5_0s_ttl/details.csv create mode 100644 experiments/No_Refresh_5_0s_ttl/hit_age.csv create mode 100644 experiments/No_Refresh_5_0s_ttl/lambda_distribution.pdf create mode 100644 experiments/No_Refresh_5_0s_ttl/objects_in_cache_over_time.pdf create mode 100644 experiments/No_Refresh_5_0s_ttl/overall_hit_age.csv create mode 100644 experiments/README.md create mode 100644 graphs/objects_in_cache_over_time.pdf create mode 100644 logs/export.csv create mode 100644 objects_in_cache_over_time.pdf diff --git a/aoi_cache_simulation.ipynb b/aoi_cache_simulation.ipynb index 4a8adb3..2148fe2 100644 --- a/aoi_cache_simulation.ipynb +++ b/aoi_cache_simulation.ipynb @@ -3,7 +3,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "920665b8-9204-42df-ab59-1b9324387750", + "id": "71f85f2a-423f-44d2-b80d-da9ac8d3961a", "metadata": {}, "outputs": [], "source": [ @@ -12,29 +12,111 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", + "from enum import Enum\n", + "import os\n", + "import shutil\n", + "\n", + "# Types of cache\n", + "class CacheType(Enum):\n", + " LRU = 1\n", + " RANDOM_EVICTION = 2\n", + "experiment_name = ''\n", "\n", "# Constants\n", - "SEED = 256\n", - "CACHE_TTL = 5 # Cache TTL in seconds\n", - "CACHE_CAPACITY = 100 # Maximum number of objects the cache can hold\n", - "ACCESS_COUNT_LIMIT = 10_000 # Total time to run the simulation\n", - "EXPORT_NAME = \"./export.csv\"\n", - "\n", - "ZIPF_CONSTANT = 2 # Shape parameter for the Zipf distribution (controls skewness) Needs to be: 1 <\n", - "MAX_REFRESH_RATE = 10\n", + "SEED = 42\n", + "DATABASE_OBJECTS = 100 # Number of objects in the database\n", + "ACCESS_COUNT_LIMIT = 10 # Total time to run the simulation\n", + "EXPERIMENT_BASE_DIR = \"./experiments/\"\n", + "TEMP_BASE_DIR = \"./.aoi_cache/\"\n", "\n", + "ZIPF_CONSTANT = 2 # Shape parameter for the Zipf distribution (controls skewness) Needs to be: 1< \n", "\n", "# Set random seeds\n", "random.seed(SEED)\n", "np.random.seed(SEED)\n", "\n", "# Initialize simulation environment\n", - "env = simpy.Environment()" + "env = simpy.Environment()\n", + "\n", + "os.makedirs(TEMP_BASE_DIR, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "id": "9a37d7a3-3e11-4b89-8dce-6091dd38b16f", + "metadata": {}, + "source": [ + "How to set certain parameters for specific scenarios\n", + "\n", + "\n", + "| Name | Cache Capacity | MAX_REFRESH_RATE | cache_type | CACHE_TTL |\n", + "| -------------------- | -------------------- | ---------------- | ------------------------- | --------- |\n", + "| Default | DATABASE_OBJECTS | 1< | CacheType.LRU | 5 |\n", + "| No Refresh | DATABASE_OBJECTS | 0 | CacheType.LRU | 5 |\n", + "| Infinite TTL | DATABASE_OBJECTS / 2 | 0 | CacheType.LRU | 0 |\n", + "| Random Eviction (RE) | DATABASE_OBJECTS / 2 | 1< | CacheType.RANDOM_EVICTION | 5 |\n", + "| RE without Refresh | DATABASE_OBJECTS / 2 | 0 | CacheType.RANDOM_EVICTION | 5 |\n", + "\n", + "\n" ] }, { "cell_type": "code", "execution_count": 2, + "id": "3d0ab5b1-162a-42c8-80a3-d31f763101f1", + "metadata": {}, + "outputs": [], + "source": [ + "# Configuration (Just example, will be overwritten in next block\n", + "\n", + "CACHE_CAPACITY = DATABASE_OBJECTS # Maximum number of objects the cache can hold\n", + "\n", + "# MAX_REFRESH_RATE is used as the maximum for a uniform\n", + "# distribution for mu.\n", + "# If MAX_REFRESH_RATE is 0, we do not do any refreshes.\n", + "MAX_REFRESH_RATE = 0\n", + "\n", + "cache_type = CacheType.LRU\n", + "\n", + "# CACHE_TTL is used to determin which TTL to set when an\n", + "# object is pulled into the cache\n", + "# If CACHE_TTL is set to 0, the TTL is infinite\n", + "CACHE_TTL = 5\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "3ff299ca-ec65-453b-b167-9a0f7728a207", + "metadata": {}, + "outputs": [], + "source": [ + "configurations = {\n", + " \"default\": (DATABASE_OBJECTS, 10, CacheType.LRU, 5),\n", + " \"No Refresh\": (DATABASE_OBJECTS, 0, CacheType.LRU, 5),\n", + " \"Infinite TTL\": (int(DATABASE_OBJECTS / 2), 0, CacheType.LRU, 0),\n", + " \"Random Eviction\": (int(DATABASE_OBJECTS / 2), 10, CacheType.RANDOM_EVICTION, 5),\n", + " \"RE without Refresh\": (int(DATABASE_OBJECTS / 2), 0, CacheType.RANDOM_EVICTION, 5),\n", + " \"No Refresh (0.5s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 0.5),\n", + " \"No Refresh (1.0s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 1),\n", + " \"No Refresh (2.0s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 2),\n", + " \"No Refresh (3.0s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 3),\n", + " \"No Refresh (4.0s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 4),\n", + " \"No Refresh (5.0s ttl)\": (DATABASE_OBJECTS, 0, CacheType.LRU, 5),\n", + "}\n", + "\n", + "experiment_name = \"No Refresh (0.5s ttl)\"\n", + "config = configurations[experiment_name]\n", + "\n", + "CACHE_CAPACITY = config[0]\n", + "MAX_REFRESH_RATE = config[1]\n", + "cache_type = config[2]\n", + "CACHE_TTL = config[3]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "5cea042f-e9fc-4a1e-9750-de212ca70601", "metadata": {}, "outputs": [], @@ -42,10 +124,14 @@ "class Database:\n", " def __init__(self):\n", " # Each object now has a specific refresh rate 'mu'\n", - " self.data = {i: f\"Object {i}\" for i in range(1, CACHE_CAPACITY + 1)}\n", - " self.lambda_values = {i: np.random.zipf(ZIPF_CONSTANT) for i in range(1, CACHE_CAPACITY + 1)} # Request rate 'lambda' for each object\n", - " self.mu_values = {i: np.random.uniform(1, MAX_REFRESH_RATE) for i in range(1, CACHE_CAPACITY + 1)} # Refresh rate 'mu' for each object\n", - " self.next_request = {i: np.random.exponential(self.lambda_values[i]) for i in range(1, CACHE_CAPACITY + 1)}\n", + " self.data = {i: f\"Object {i}\" for i in range(1, DATABASE_OBJECTS + 1)}\n", + " self.lambda_values = {i: np.random.zipf(ZIPF_CONSTANT) for i in range(1, DATABASE_OBJECTS + 1)} # Request rate 'lambda' for each object\n", + " # Refresh rate 'mu' for each object\n", + " if MAX_REFRESH_RATE == 0:\n", + " self.mu_values = {i: 0 for i in range(1,DATABASE_OBJECTS + 1)} \n", + " else:\n", + " self.mu_values = {i: np.random.uniform(1, MAX_REFRESH_RATE) for i in range(1, DATABASE_OBJECTS + 1)}\n", + " self.next_request = {i: np.random.exponential(self.lambda_values[i]) for i in range(1, DATABASE_OBJECTS + 1)}\n", "\n", "\n", " def get_object(self, obj_id):\n", @@ -55,13 +141,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "id": "499bf543-b2c6-4e4d-afcc-0a6665ce3ae1", "metadata": {}, "outputs": [], "source": [ "class Cache:\n", - " def __init__(self, env, db):\n", + " def __init__(self, env, db, cache_type):\n", + " self.cache_type = cache_type\n", " self.env = env\n", " self.db = db\n", " self.storage = {} # Dictionary to store cached objects\n", @@ -69,15 +156,16 @@ " self.age = {} # Dictionary to store age of each object\n", " self.cache_size_over_time = [] # To record cache state at each interval\n", " self.cache_next_request_over_time = []\n", - " self.request_log = {i: [] for i in range(1, CACHE_CAPACITY + 1)}\n", - " self.hits = {i: 0 for i in range(1, CACHE_CAPACITY + 1)} # Track hits per object\n", - " self.misses = {i: 0 for i in range(1, CACHE_CAPACITY + 1)} # Track misses per object\n", - " self.cumulative_age = {i: 0 for i in range(1, CACHE_CAPACITY + 1)} # Track cumulative age per object\n", - " self.access_count = {i: 0 for i in range(1, CACHE_CAPACITY + 1)} # Track access count per object\n", + " self.request_log = {i: [] for i in range(1, DATABASE_OBJECTS + 1)}\n", + " self.hits = {i: 0 for i in range(1, DATABASE_OBJECTS + 1)} # Track hits per object\n", + " self.misses = {i: 0 for i in range(1, DATABASE_OBJECTS + 1)} # Track misses per object\n", + " self.cumulative_age = {i: 0 for i in range(1, DATABASE_OBJECTS + 1)} # Track cumulative age per object\n", + " self.access_count = {i: 0 for i in range(1, DATABASE_OBJECTS + 1)} # Track access count per object\n", " self.next_refresh = {} # Track the next refresh time for each cached object\n", " \n", " def get(self, obj_id):\n", - " if obj_id in self.storage and self.ttl[obj_id] > env.now:\n", + " if obj_id in self.storage and \\\n", + " (self.ttl[obj_id] > env.now or CACHE_TTL == 0):\n", " # Cache hit: increment hit count and update cumulative age\n", " self.hits[obj_id] += 1\n", " self.cumulative_age[obj_id] += self.age[obj_id]\n", @@ -92,43 +180,64 @@ " \n", " # If the cache is full, evict the oldest object\n", " if len(self.storage) >= CACHE_CAPACITY:\n", - " self.evict_oldest()\n", + " if self.cache_type == CacheType.LRU:\n", + " self.evict_oldest()\n", + " elif self.cache_type == CacheType.RANDOM_EVICTION:\n", + " self.evict_random()\n", " \n", " # Add the object to cache, set TTL, reset age, and schedule next refresh\n", " self.storage[obj_id] = obj\n", - " self.ttl[obj_id] = env.now + CACHE_TTL\n", + " if CACHE_TTL != 0:\n", + " self.ttl[obj_id] = env.now + CACHE_TTL\n", + " else:\n", + " self.ttl[obj_id] = 0\n", " self.age[obj_id] = 0\n", - " self.next_refresh[obj_id] = env.now + np.random.exponential(self.db.mu_values[obj_id]) # Schedule refresh\n", + " if MAX_REFRESH_RATE != 0:\n", + " self.next_refresh[obj_id] = env.now + np.random.exponential(self.db.mu_values[obj_id]) # Schedule refresh\n", "\n", " \n", " def evict_oldest(self):\n", " \"\"\"Remove the oldest item from the cache to make space.\"\"\"\n", " oldest_id = max(self.age, key=self.age.get) # Find the oldest item by age\n", - " print(f\"[{env.now:.2f}] Cache: Evicting object {oldest_id} to make space\")\n", + " print(f\"[{env.now:.2f}] Cache: Evicting oldest object {oldest_id} to make space at {self.ttl[oldest_id]:.2f}\")\n", " del self.storage[oldest_id]\n", " del self.ttl[oldest_id]\n", " del self.age[oldest_id]\n", + "\n", + " def evict_random(self):\n", + " \"\"\"Remove a random item from the cache to make space.\"\"\"\n", + " random_id = np.random.choice(list(self.storage.keys())) # Select a random key from the cache\n", + " print(f\"[{env.now:.2f}] Cache: Evicting random object {random_id} to make space at {self.ttl[random_id]:.2f}\")\n", + " del self.storage[random_id]\n", + " del self.ttl[random_id]\n", + " del self.age[random_id]\n", " \n", " def refresh_object(self, obj_id):\n", - " \"\"\"Refresh the object from the database to keep it up-to-date.\"\"\"\n", + " \"\"\"Refresh the object from the database to keep it up-to-date. TTL is increased on refresh.\"\"\"\n", " obj = self.db.get_object(obj_id)\n", " self.storage[obj_id] = obj\n", - " self.ttl[obj_id] = env.now + CACHE_TTL\n", + " if CACHE_TTL != 0:\n", + " self.ttl[obj_id] = env.now + CACHE_TTL\n", + " else:\n", + " self.ttl[obj_id] = 0\n", " self.age[obj_id] = 0\n", " # print(f\"[{env.now:.2f}] Cache: Refreshed object {obj_id}\")\n", " \n", " def age_objects(self):\n", " \"\"\"Increment age of each cached object.\"\"\"\n", " for obj_id in list(self.age.keys()):\n", - " if self.ttl[obj_id] > env.now:\n", - " self.age[obj_id] += 1\n", - " # print(f\"[{env.now:.2f}] Cache: Object {obj_id} aged to {self.age[obj_id]}\")\n", + " if CACHE_TTL != 0:\n", + " if self.ttl[obj_id] > env.now:\n", + " self.age[obj_id] += 1\n", + " # print(f\"[{env.now:.2f}] Cache: Object {obj_id} aged to {self.age[obj_id]}\")\n", + " else:\n", + " # Remove object if its TTL expired\n", + " # print(f\"[{env.now:.2f}] Cache: Object {obj_id} expired\")\n", + " del self.storage[obj_id]\n", + " del self.ttl[obj_id]\n", + " del self.age[obj_id]\n", " else:\n", - " # Remove object if its TTL expired\n", - " # print(f\"[{env.now:.2f}] Cache: Object {obj_id} expired\")\n", - " del self.storage[obj_id]\n", - " del self.ttl[obj_id]\n", - " del self.age[obj_id]\n", + " self.age[obj_id] += 1\n", " \n", " def record_cache_state(self):\n", " \"\"\"Record the current cache state (number of objects in cache) over time.\"\"\"\n", @@ -138,7 +247,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "7286d498-aa6c-4efb-bb28-fe29736eab64", "metadata": {}, "outputs": [], @@ -148,13 +257,15 @@ " while True:\n", " cache.age_objects() # Age objects and remove expired ones\n", "\n", - " # Refresh objects based on their individual refresh intervals\n", - " for obj_id in list(cache.storage.keys()):\n", - " # Check if it's time to refresh this object based on next_refresh\n", - " if env.now >= cache.next_refresh[obj_id]:\n", - " cache.refresh_object(obj_id)\n", - " # Schedule the next refresh based on the object's mu\n", - " cache.next_refresh[obj_id] = env.now + np.random.exponential(cache.db.mu_values[obj_id])\n", + "\n", + " if MAX_REFRESH_RATE != 0:\n", + " # Refresh objects based on their individual refresh intervals\n", + " for obj_id in list(cache.storage.keys()):\n", + " # Check if it's time to refresh this object based on next_refresh\n", + " if env.now >= cache.next_refresh[obj_id]:\n", + " cache.refresh_object(obj_id)\n", + " # Schedule the next refresh based on the object's mu\n", + " cache.next_refresh[obj_id] = env.now + np.random.exponential(cache.db.mu_values[obj_id])\n", " \n", " cache.record_cache_state() # Record cache state at each time step\n", " yield env.timeout(1) # Run every second\n" @@ -162,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "687f5634-8edf-4337-b42f-bbb292d47f0f", "metadata": {}, "outputs": [], @@ -188,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "c8516830-9880-4d9e-a91b-000338baf9d6", "metadata": { "scrolled": true @@ -197,18 +308,27 @@ "source": [ "# Instantiate components\n", "db = Database()\n", - "cache = Cache(env, db)\n", + "cache = Cache(env, db, cache_type)\n", "stop_event = env.event()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "2ba34b36-9ed5-4996-9600-11dfd25d8e60", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 434 ms, sys: 57.9 ms, total: 492 ms\n", + "Wall time: 491 ms\n" + ] + } + ], "source": [ "%%time\n", "\n", @@ -222,27 +342,336 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "3b6f7c1f-ea54-4496-bb9a-370cee2d2751", "metadata": { "scrolled": true }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Object 1: Hit Rate = 0.34, Average Age = 0.26\n", + "Object 2: Hit Rate = 0.10, Average Age = 0.36\n", + "Object 3: Hit Rate = 0.32, Average Age = 0.24\n", + "Object 4: Hit Rate = 0.35, Average Age = 0.26\n", + "Object 5: Hit Rate = 0.19, Average Age = 0.24\n", + "Object 6: Hit Rate = 0.32, Average Age = 0.25\n", + "Object 7: Hit Rate = 0.10, Average Age = 0.21\n", + "Object 8: Hit Rate = 0.32, Average Age = 0.26\n", + "Object 9: Hit Rate = 0.34, Average Age = 0.24\n", + "Object 10: Hit Rate = 0.34, Average Age = 0.22\n", + "Object 11: Hit Rate = 0.22, Average Age = 0.24\n", + "Object 12: Hit Rate = 0.35, Average Age = 0.31\n", + "Object 13: Hit Rate = 0.32, Average Age = 0.23\n", + "Object 14: Hit Rate = 0.34, Average Age = 0.27\n", + "Object 15: Hit Rate = 0.20, Average Age = 0.20\n", + "Object 16: Hit Rate = 0.18, Average Age = 0.20\n", + "Object 17: Hit Rate = 0.30, Average Age = 0.25\n", + "Object 18: Hit Rate = 0.33, Average Age = 0.25\n", + "Object 19: Hit Rate = 0.12, Average Age = 0.27\n", + "Object 20: Hit Rate = 0.35, Average Age = 0.26\n", + "Object 21: Hit Rate = 0.35, Average Age = 0.21\n", + "Object 22: Hit Rate = 0.35, Average Age = 0.29\n", + "Object 23: Hit Rate = 0.35, Average Age = 0.20\n", + "Object 24: Hit Rate = 0.20, Average Age = 0.18\n", + "Object 25: Hit Rate = 0.35, Average Age = 0.26\n", + "Object 26: Hit Rate = 0.32, Average Age = 0.21\n", + "Object 27: Hit Rate = 0.34, Average Age = 0.24\n", + "Object 28: Hit Rate = 0.09, Average Age = 0.17\n", + "Object 29: Hit Rate = 0.34, Average Age = 0.25\n", + "Object 30: Hit Rate = 0.32, Average Age = 0.28\n", + "Object 31: Hit Rate = 0.33, Average Age = 0.26\n", + "Object 32: Hit Rate = 0.09, Average Age = 0.31\n", + "Object 33: Hit Rate = 0.35, Average Age = 0.25\n", + "Object 34: Hit Rate = 0.07, Average Age = 0.30\n", + "Object 35: Hit Rate = 0.33, Average Age = 0.26\n", + "Object 36: Hit Rate = 0.32, Average Age = 0.30\n", + "Object 37: Hit Rate = 0.37, Average Age = 0.22\n", + "Object 38: Hit Rate = 0.14, Average Age = 0.39\n", + "Object 39: Hit Rate = 0.05, Average Age = 0.20\n", + "Object 40: Hit Rate = 0.33, Average Age = 0.27\n", + "Object 41: Hit Rate = 0.12, Average Age = 0.30\n", + "Object 42: Hit Rate = 0.07, Average Age = 0.25\n", + "Object 43: Hit Rate = 0.22, Average Age = 0.32\n", + "Object 44: Hit Rate = 0.33, Average Age = 0.25\n", + "Object 45: Hit Rate = 0.30, Average Age = 0.34\n", + "Object 46: Hit Rate = 0.33, Average Age = 0.27\n", + "Object 47: Hit Rate = 0.02, Average Age = 0.00\n", + "Object 48: Hit Rate = 0.32, Average Age = 0.24\n", + "Object 49: Hit Rate = 0.31, Average Age = 0.27\n", + "Object 50: Hit Rate = 0.33, Average Age = 0.23\n", + "Object 51: Hit Rate = 0.12, Average Age = 0.25\n", + "Object 52: Hit Rate = 0.04, Average Age = 0.33\n", + "Object 53: Hit Rate = 0.33, Average Age = 0.27\n", + "Object 54: Hit Rate = 0.33, Average Age = 0.25\n", + "Object 55: Hit Rate = 0.35, Average Age = 0.24\n", + "Object 56: Hit Rate = 0.38, Average Age = 0.26\n", + "Object 57: Hit Rate = 0.31, Average Age = 0.26\n", + "Object 58: Hit Rate = 0.00, Average Age = 0.00\n", + "Object 59: Hit Rate = 0.19, Average Age = 0.15\n", + "Object 60: Hit Rate = 0.31, Average Age = 0.20\n", + "Object 61: Hit Rate = 0.13, Average Age = 0.00\n", + "Object 62: Hit Rate = 0.35, Average Age = 0.25\n", + "Object 63: Hit Rate = 0.32, Average Age = 0.23\n", + "Object 64: Hit Rate = 0.25, Average Age = 0.34\n", + "Object 65: Hit Rate = 0.35, Average Age = 0.28\n", + "Object 66: Hit Rate = 0.04, Average Age = 0.33\n", + "Object 67: Hit Rate = 0.34, Average Age = 0.21\n", + "Object 68: Hit Rate = 0.00, Average Age = 0.00\n", + "Object 69: Hit Rate = 0.33, Average Age = 0.33\n", + "Object 70: Hit Rate = 0.33, Average Age = 0.26\n", + "Object 71: Hit Rate = 0.23, Average Age = 0.23\n", + "Object 72: Hit Rate = 0.33, Average Age = 0.24\n", + "Object 73: Hit Rate = 0.34, Average Age = 0.29\n", + "Object 74: Hit Rate = 0.33, Average Age = 0.20\n", + "Object 75: Hit Rate = 0.10, Average Age = 0.29\n", + "Object 76: Hit Rate = 0.20, Average Age = 0.30\n", + "Object 77: Hit Rate = 0.21, Average Age = 0.21\n", + "Object 78: Hit Rate = 0.17, Average Age = 0.20\n", + "Object 79: Hit Rate = 0.04, Average Age = 0.00\n", + "Object 80: Hit Rate = 0.34, Average Age = 0.28\n", + "Object 81: Hit Rate = 0.30, Average Age = 0.26\n", + "Object 82: Hit Rate = 0.06, Average Age = 0.12\n", + "Object 83: Hit Rate = 0.18, Average Age = 0.25\n", + "Object 84: Hit Rate = 0.34, Average Age = 0.29\n", + "Object 85: Hit Rate = 0.33, Average Age = 0.26\n", + "Object 86: Hit Rate = 0.19, Average Age = 0.31\n", + "Object 87: Hit Rate = 0.33, Average Age = 0.20\n", + "Object 88: Hit Rate = 0.21, Average Age = 0.25\n", + "Object 89: Hit Rate = 0.35, Average Age = 0.23\n", + "Object 90: Hit Rate = 0.33, Average Age = 0.28\n", + "Object 91: Hit Rate = 0.22, Average Age = 0.31\n", + "Object 92: Hit Rate = 0.20, Average Age = 0.22\n", + "Object 93: Hit Rate = 0.14, Average Age = 0.26\n", + "Object 94: Hit Rate = 0.32, Average Age = 0.29\n", + "Object 95: Hit Rate = 0.20, Average Age = 0.31\n", + "Object 96: Hit Rate = 0.34, Average Age = 0.21\n", + "Object 97: Hit Rate = 0.33, Average Age = 0.27\n", + "Object 98: Hit Rate = 0.00, Average Age = 0.00\n", + "Object 99: Hit Rate = 0.12, Average Age = 0.33\n", + "Object 100: Hit Rate = 0.23, Average Age = 0.25\n" + ] + } + ], "source": [ + "statistics = []\n", "# Calculate and print hit rate and average age for each object\n", - "for obj_id in range(1, CACHE_CAPACITY + 1):\n", + "for obj_id in range(1, DATABASE_OBJECTS + 1):\n", " if cache.access_count[obj_id] != 0:\n", " hit_rate = cache.hits[obj_id] / max(1, cache.access_count[obj_id]) # Avoid division by zero\n", " avg_age = cache.cumulative_age[obj_id] / max(1, cache.hits[obj_id]) # Only average over hits\n", - " print(f\"Object {obj_id}: Hit Rate = {hit_rate:.2f}, Average Age = {avg_age:.2f}\")" + " print(f\"Object {obj_id}: Hit Rate = {hit_rate:.2f}, Average Age = {avg_age:.2f}\")\n", + " statistics.append({\"obj_id\": obj_id,\"hit_rate\": hit_rate,\"avg_age\": avg_age})" ] }, { "cell_type": "code", - "execution_count": null, - "id": "01f8f9ee-c278-4a22-8562-ba02e77f5ddd", + "execution_count": 11, + "id": "b2d18372-cdba-4151-ae32-5bf45466bf94", "metadata": {}, "outputs": [], + "source": [ + "stats = pd.DataFrame(statistics)\n", + "stats.to_csv(f\"{TEMP_BASE_DIR}/hit_age.csv\",index=False)\n", + "stats.drop(\"obj_id\", axis=1).describe().to_csv(f\"{TEMP_BASE_DIR}/overall_hit_age.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "80971714-44f1-47db-9e89-85be7c885bde", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
access_counthitsmissesmulambdahit_rate
16642244400110.38
2212221900332.39
36732184550134.60
47112464650119.13
5345662790231.74
.....................
95351702810233.89
967172434740132.53
97664216448010.00
982302303711.60
99181211600422.85
\n", + "

99 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " access_count hits misses mu lambda hit_rate\n", + "1 664 224 440 0 1 10.38\n", + "2 212 22 190 0 3 32.39\n", + "3 673 218 455 0 1 34.60\n", + "4 711 246 465 0 1 19.13\n", + "5 345 66 279 0 2 31.74\n", + ".. ... ... ... .. ... ...\n", + "95 351 70 281 0 2 33.89\n", + "96 717 243 474 0 1 32.53\n", + "97 664 216 448 0 1 0.00\n", + "98 23 0 23 0 37 11.60\n", + "99 181 21 160 0 4 22.85\n", + "\n", + "[99 rows x 6 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "access_count = pd.DataFrame.from_dict(cache.access_count, orient='index', columns=['access_count'])\n", + "hits = pd.DataFrame.from_dict(cache.hits, orient='index', columns=['hits'])\n", + "misses = pd.DataFrame.from_dict(cache.misses, orient='index', columns=['misses'])\n", + "mu = pd.DataFrame.from_dict(db.mu_values, orient='index', columns=['mu'])\n", + "lmbda = pd.DataFrame.from_dict(db.lambda_values, orient='index', columns=['lambda'])\n", + "hit_rate = pd.DataFrame(np.round((hits.to_numpy()/access_count.to_numpy())*100,2), columns=['hit_rate'])\n", + "\n", + "merged = access_count.merge(hits, left_index=True, right_index=True).merge(misses, left_index=True, right_index=True)\\\n", + " .merge(mu, left_index=True, right_index=True).merge(lmbda, left_index=True, right_index=True)\\\n", + " .merge(hit_rate, left_index=True, right_index=True)\n", + "merged.to_csv(f\"{TEMP_BASE_DIR}/details.csv\")\n", + "merged" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "01f8f9ee-c278-4a22-8562-ba02e77f5ddd", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Extract recorded data for plotting\n", "times, cache_sizes = zip(*cache.cache_size_over_time)\n", @@ -255,44 +684,28 @@ "plt.title(\"Number of Objects in Cache Over Time\")\n", "plt.legend()\n", "plt.grid(True)\n", + "plt.savefig(f\"{TEMP_BASE_DIR}/objects_in_cache_over_time.pdf\")\n", + "\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, - "id": "80971714-44f1-47db-9e89-85be7c885bde", - "metadata": {}, - "outputs": [], - "source": [ - "access_count = pd.DataFrame.from_dict(cache.access_count, orient='index', columns=['access_count'])\n", - "hits = pd.DataFrame.from_dict(cache.hits, orient='index', columns=['hits'])\n", - "misses = pd.DataFrame.from_dict(cache.misses, orient='index', columns=['misses'])\n", - "mu = pd.DataFrame.from_dict(db.mu_values, orient='index', columns=['mu'])\n", - "lmbda = pd.DataFrame.from_dict(db.lambda_values, orient='index', columns=['lambda'])\n", - "hit_rate = pd.DataFrame(np.round((hits.to_numpy()/access_count.to_numpy())*100,2), columns=['hit_rate'])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "fa36397f-9f09-4467-9e77-8a6b6b1bc691", - "metadata": {}, - "outputs": [], - "source": [ - "merged = access_count.merge(hits, left_index=True, right_index=True).merge(misses, left_index=True, right_index=True)\\\n", - " .merge(mu, left_index=True, right_index=True).merge(lmbda, left_index=True, right_index=True)\\\n", - " .merge(hit_rate, left_index=True, right_index=True)\n", - "merged.to_csv(EXPORT_NAME)\n", - "merged" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "f30a0497-9b2e-4ea9-8ebf-6687de19aaa9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from collections import Counter\n", "# Count occurrences of each number\n", @@ -310,6 +723,7 @@ "plt.xlabel('Number')\n", "plt.ylabel('Occurrences')\n", "plt.title('Occurance of each lambda in db')\n", + "plt.savefig(f\"{TEMP_BASE_DIR}/lambda_distribution.pdf\")\n", "\n", "# Show the plot\n", "plt.show()" @@ -317,10 +731,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "00a12eea-c805-4209-9143-48fa65619873", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from collections import Counter\n", "# Count occurrences of each number\n", @@ -345,7 +770,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "id": "adbfeb40-76bd-4224-ac45-65c7b2b2cb7b", "metadata": {}, "outputs": [], @@ -360,7 +785,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "1f550686-3463-4e50-be83-ceafb27512b0", "metadata": {}, "outputs": [], @@ -380,21 +805,29 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "f246dc61-f131-4d17-80c9-ccff1c4fec64", + "execution_count": 18, + "id": "b47990b1-0231-43ac-8bc5-8340abe4a8b3", "metadata": {}, "outputs": [], "source": [ - "[(print_rate(i),plot_requests(i)) for i in range(1,10)]" + "os.makedirs(EXPERIMENT_BASE_DIR, exist_ok=True)\n", + "folder_name = experiment_name.replace(\" \", \"_\").replace(\"(\", \"\").replace(\")\", \"\").replace(\".\", \"_\")\n", + "folder_path = os.path.join(EXPERIMENT_BASE_DIR, folder_name)\n", + "os.makedirs(folder_path, exist_ok=True)\n" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b2d18372-cdba-4151-ae32-5bf45466bf94", + "execution_count": 19, + "id": "db83cad4-7cc6-4702-ae3a-d1af30a561d2", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "file_names = os.listdir(TEMP_BASE_DIR)\n", + " \n", + "for file_name in file_names:\n", + " shutil.move(os.path.join(TEMP_BASE_DIR, file_name), folder_path)" + ] } ], "metadata": { diff --git a/aoi_cache_simulation.py b/aoi_cache_simulation.py new file mode 100644 index 0000000..80055c8 --- /dev/null +++ b/aoi_cache_simulation.py @@ -0,0 +1,306 @@ +import simpy +import random +import numpy as np +import matplotlib.pyplot as plt +import pandas as pd +from enum import Enum + + +# Types of cache +class CacheType(Enum): + LRU = 1 + RANDOM_EVICTION = 2 + + +# Constants +SEED = 42 +DATABASE_OBJECTS = 100 # Number of objects in the database +ACCESS_COUNT_LIMIT = 10 # Total time to run the simulation +EXPORT_NAME = "./logs/export.csv" + +ZIPF_CONSTANT = ( + 2 # Shape parameter for the Zipf distribution (controls skewness) Needs to be: 1< +) + +# Set random seeds +random.seed(SEED) +np.random.seed(SEED) + +# Initialize simulation environment +env = simpy.Environment() + + +CACHE_CAPACITY = DATABASE_OBJECTS # Maximum number of objects the cache can hold + +# MAX_REFRESH_RATE is used as the maximum for a uniform +# distribution for mu. +# If MAX_REFRESH_RATE is 0, we do not do any refreshes. +MAX_REFRESH_RATE = 10 + +cache_type = CacheType.LRU + +# CACHE_TTL is used to determin which TTL to set when an +# object is pulled into the cache +# If CACHE_TTL is set to 0, the TTL is infinite +CACHE_TTL = 5 + + +configurations = { + "default": (DATABASE_OBJECTS, 10, CacheType.LRU, 5), + "No Refresh": (DATABASE_OBJECTS, 0, CacheType.LRU, 5), + "Infinite TTL": (int(DATABASE_OBJECTS / 2), 0, CacheType.LRU, 0), + "Random Eviction": (int(DATABASE_OBJECTS / 2), 10, CacheType.RANDOM_EVICTION, 5), + "RE without Refresh": (int(DATABASE_OBJECTS / 2), 0, CacheType.RANDOM_EVICTION, 5), +} + +config = configurations["default"] + +CACHE_CAPACITY = config[0] +MAX_REFRESH_RATE = config[1] +cache_type = config[2] +CACHE_TTL = config[3] + + +class Database: + def __init__(self): + # Each object now has a specific refresh rate 'mu' + self.data = {i: f"Object {i}" for i in range(1, DATABASE_OBJECTS + 1)} + self.lambda_values = { + i: np.random.zipf(ZIPF_CONSTANT) for i in range(1, DATABASE_OBJECTS + 1) + } # Request rate 'lambda' for each object + # Refresh rate 'mu' for each object + if MAX_REFRESH_RATE == 0: + self.mu_values = {i: 0 for i in range(1, DATABASE_OBJECTS + 1)} + else: + self.mu_values = { + i: np.random.uniform(1, MAX_REFRESH_RATE) + for i in range(1, DATABASE_OBJECTS + 1) + } + self.next_request = { + i: np.random.exponential(self.lambda_values[i]) + for i in range(1, DATABASE_OBJECTS + 1) + } + + def get_object(self, obj_id): + # print(f"[{env.now:.2f}] Database: Fetched {self.data.get(obj_id, 'Unknown')} for ID {obj_id}") + return self.data.get(obj_id, None) + + +class Cache: + def __init__(self, env, db, cache_type): + self.cache_type = cache_type + self.env = env + self.db = db + self.storage = {} # Dictionary to store cached objects + self.ttl = {} # Dictionary to store TTLs + self.age = {} # Dictionary to store age of each object + self.cache_size_over_time = [] # To record cache state at each interval + self.cache_next_request_over_time = [] + self.request_log = {i: [] for i in range(1, DATABASE_OBJECTS + 1)} + self.hits = { + i: 0 for i in range(1, DATABASE_OBJECTS + 1) + } # Track hits per object + self.misses = { + i: 0 for i in range(1, DATABASE_OBJECTS + 1) + } # Track misses per object + self.cumulative_age = { + i: 0 for i in range(1, DATABASE_OBJECTS + 1) + } # Track cumulative age per object + self.access_count = { + i: 0 for i in range(1, DATABASE_OBJECTS + 1) + } # Track access count per object + self.next_refresh = {} # Track the next refresh time for each cached object + + def get(self, obj_id): + if obj_id in self.storage and (self.ttl[obj_id] > env.now or CACHE_TTL == 0): + # Cache hit: increment hit count and update cumulative age + self.hits[obj_id] += 1 + self.cumulative_age[obj_id] += self.age[obj_id] + self.access_count[obj_id] += 1 + else: + # Cache miss: increment miss count + self.misses[obj_id] += 1 + self.access_count[obj_id] += 1 + + # Fetch the object from the database if it’s not in cache + obj = self.db.get_object(obj_id) + + # If the cache is full, evict the oldest object + if len(self.storage) >= CACHE_CAPACITY: + if self.cache_type == CacheType.LRU: + self.evict_oldest() + elif self.cache_type == CacheType.RANDOM_EVICTION: + self.evict_random() + + # Add the object to cache, set TTL, reset age, and schedule next refresh + self.storage[obj_id] = obj + if CACHE_TTL != 0: + self.ttl[obj_id] = env.now + CACHE_TTL + else: + self.ttl[obj_id] = 0 + self.age[obj_id] = 0 + if MAX_REFRESH_RATE != 0: + self.next_refresh[obj_id] = env.now + np.random.exponential( + self.db.mu_values[obj_id] + ) # Schedule refresh + + def evict_oldest(self): + """Remove the oldest item from the cache to make space.""" + oldest_id = max(self.age, key=self.age.get) # Find the oldest item by age + print( + f"[{env.now:.2f}] Cache: Evicting oldest object {oldest_id} to make space at {self.ttl[oldest_id]:.2f}" + ) + del self.storage[oldest_id] + del self.ttl[oldest_id] + del self.age[oldest_id] + + def evict_random(self): + """Remove a random item from the cache to make space.""" + random_id = np.random.choice( + list(self.storage.keys()) + ) # Select a random key from the cache + print( + f"[{env.now:.2f}] Cache: Evicting random object {random_id} to make space at {self.ttl[random_id]:.2f}" + ) + del self.storage[random_id] + del self.ttl[random_id] + del self.age[random_id] + + def refresh_object(self, obj_id): + """Refresh the object from the database to keep it up-to-date. TTL is increased on refresh.""" + obj = self.db.get_object(obj_id) + self.storage[obj_id] = obj + if CACHE_TTL != 0: + self.ttl[obj_id] = env.now + CACHE_TTL + else: + self.ttl[obj_id] = 0 + self.age[obj_id] = 0 + # print(f"[{env.now:.2f}] Cache: Refreshed object {obj_id}") + + def age_objects(self): + """Increment age of each cached object.""" + for obj_id in list(self.age.keys()): + if CACHE_TTL != 0: + if self.ttl[obj_id] > env.now: + self.age[obj_id] += 1 + # print(f"[{env.now:.2f}] Cache: Object {obj_id} aged to {self.age[obj_id]}") + else: + # Remove object if its TTL expired + # print(f"[{env.now:.2f}] Cache: Object {obj_id} expired") + del self.storage[obj_id] + del self.ttl[obj_id] + del self.age[obj_id] + else: + self.age[obj_id] += 1 + + def record_cache_state(self): + """Record the current cache state (number of objects in cache) over time.""" + self.cache_size_over_time.append((env.now, len(self.storage))) + self.cache_next_request_over_time.append((env.now, self.db.next_request.copy())) + + +def age_cache_process(env, cache): + """Process that ages cache objects over time, removes expired items, and refreshes based on object-specific intervals.""" + while True: + cache.age_objects() # Age objects and remove expired ones + + if MAX_REFRESH_RATE != 0: + # Refresh objects based on their individual refresh intervals + for obj_id in list(cache.storage.keys()): + # Check if it's time to refresh this object based on next_refresh + if env.now >= cache.next_refresh[obj_id]: + cache.refresh_object(obj_id) + # Schedule the next refresh based on the object's mu + cache.next_refresh[obj_id] = env.now + np.random.exponential( + cache.db.mu_values[obj_id] + ) + + cache.record_cache_state() # Record cache state at each time step + yield env.timeout(1) # Run every second + + +def client_request_process(env, cache, event): + """Client process that makes requests for objects from the cache.""" + lowest_lambda_object = max(cache.db.lambda_values.items(), key=lambda x: x[1]) + lowest_lambda_object = ( + [lowest_lambda_object] + if isinstance(lowest_lambda_object, int) + else lowest_lambda_object + ) + while True: + obj_id, next_request = min(cache.db.next_request.items(), key=lambda x: x[1]) + yield env.timeout(next_request - env.now) + if env.now >= next_request: + # print(f"[{env.now:.2f}] Client: Requesting object {obj_id}") + cache.get(obj_id) + + # print(f"[{env.now:.2f}] Client: Schedule next request for {obj_id}") + next_request = env.now + np.random.exponential( + cache.db.lambda_values[obj_id] + ) + cache.request_log[obj_id].append(next_request) + cache.db.next_request[obj_id] = next_request + if all( + cache.access_count[obj] >= ACCESS_COUNT_LIMIT + for obj in lowest_lambda_object + ): + event.succeed() + + +# Instantiate components +db = Database() +cache = Cache(env, db, cache_type) +stop_event = env.event() + +# Start processes +env.process(age_cache_process(env, cache)) +env.process(client_request_process(env, cache, stop_event)) + +# Run the simulation +env.run(until=stop_event) + +# Calculate and print hit rate and average age for each object +for obj_id in range(1, DATABASE_OBJECTS + 1): + if cache.access_count[obj_id] != 0: + hit_rate = cache.hits[obj_id] / max( + 1, cache.access_count[obj_id] + ) # Avoid division by zero + avg_age = cache.cumulative_age[obj_id] / max( + 1, cache.hits[obj_id] + ) # Only average over hits + print( + f"Object {obj_id}: Hit Rate = {hit_rate:.2f}, Average Age = {avg_age:.2f}" + ) + +# Extract recorded data for plotting +times, cache_sizes = zip(*cache.cache_size_over_time) + +# Plot the cache size over time +plt.figure(figsize=(30, 5)) +plt.plot(times, cache_sizes, label="Objects in Cache") +plt.xlabel("Time (s)") +plt.ylabel("Number of Cached Objects") +plt.title("Number of Objects in Cache Over Time") +plt.legend() +plt.grid(True) +plt.savefig("./graphs/objects_in_cache_over_time.pdf") + +access_count = pd.DataFrame.from_dict( + cache.access_count, orient="index", columns=["access_count"] +) +hits = pd.DataFrame.from_dict(cache.hits, orient="index", columns=["hits"]) +misses = pd.DataFrame.from_dict(cache.misses, orient="index", columns=["misses"]) +mu = pd.DataFrame.from_dict(db.mu_values, orient="index", columns=["mu"]) +lmbda = pd.DataFrame.from_dict(db.lambda_values, orient="index", columns=["lambda"]) +hit_rate = pd.DataFrame( + np.round((hits.to_numpy() / access_count.to_numpy()) * 100, 2), columns=["hit_rate"] +) + +merged = ( + access_count.merge(hits, left_index=True, right_index=True) + .merge(misses, left_index=True, right_index=True) + .merge(mu, left_index=True, right_index=True) + .merge(lmbda, left_index=True, right_index=True) + .merge(hit_rate, left_index=True, right_index=True) +) +merged.to_csv(EXPORT_NAME) diff --git a/experiments/No_Refresh_0_5s_ttl/details.csv b/experiments/No_Refresh_0_5s_ttl/details.csv new file mode 100644 index 0000000..48f455a --- /dev/null +++ b/experiments/No_Refresh_0_5s_ttl/details.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,664,224,440,0,1,10.38 +2,212,22,190,0,3,32.39 +3,673,218,455,0,1,34.6 +4,711,246,465,0,1,19.13 +5,345,66,279,0,2,31.74 +6,649,206,443,0,1,10.22 +7,137,14,123,0,5,32.45 +8,681,221,460,0,1,34.4 +9,689,237,452,0,1,34.18 +10,667,228,439,0,1,21.95 +11,328,72,256,0,2,34.97 +12,692,242,450,0,1,32.21 +13,683,220,463,0,1,33.62 +14,696,234,462,0,1,20.35 +15,344,70,274,0,2,18.4 +16,326,60,266,0,2,29.9 +17,689,206,483,0,1,32.85 +18,691,227,464,0,1,11.87 +19,219,26,193,0,3,34.84 +20,732,255,477,0,1,35.05 +21,739,259,480,0,1,34.55 +22,683,236,447,0,1,35.22 +23,670,236,434,0,1,19.94 +24,331,66,265,0,2,34.67 +25,724,251,473,0,1,32.08 +26,692,222,470,0,1,34.18 +27,705,241,464,0,1,8.76 +28,137,12,125,0,5,34.23 +29,672,230,442,0,1,31.7 +30,694,220,474,0,1,33.09 +31,674,223,451,0,1,9.03 +32,144,13,131,0,4,34.63 +33,670,232,438,0,1,7.09 +34,141,10,131,0,4,32.78 +35,659,216,443,0,1,32.27 +36,691,223,468,0,1,36.91 +37,737,272,465,0,1,14.16 +38,219,31,188,0,3,5.0 +39,100,5,95,0,8,32.77 +40,714,234,480,0,1,12.5 +41,184,23,161,0,4,7.45 +42,161,12,149,0,4,21.55 +43,362,78,284,0,2,32.61 +44,696,227,469,0,1,29.98 +45,627,188,439,0,1,32.56 +46,648,211,437,0,1,1.89 +47,53,1,52,0,10,31.51 +48,676,213,463,0,1,31.35 +49,638,200,438,0,1,32.69 +50,673,220,453,0,1,12.5 +51,128,16,112,0,5,3.53 +52,85,3,82,0,9,33.33 +53,747,249,498,0,1,33.0 +54,700,231,469,0,1,35.08 +55,687,241,446,0,1,37.5 +56,720,270,450,0,1,31.3 +57,690,216,474,0,1,0.0 +58,40,0,40,0,17,19.18 +59,318,61,257,0,2,31.31 +60,674,211,463,0,1,13.04 +61,23,3,20,0,26,35.22 +62,724,255,469,0,1,32.32 +63,628,203,425,0,1,24.93 +64,345,86,259,0,2,35.1 +65,681,239,442,0,1,4.11 +66,73,3,70,0,10,33.79 +67,651,220,431,0,1,0.0 +68,10,0,10,0,69,33.02 +69,636,210,426,0,1,32.77 +70,656,215,441,0,1,22.58 +71,372,84,288,0,2,33.48 +72,678,227,451,0,1,33.7 +73,638,215,423,0,1,33.28 +74,685,228,457,0,1,10.45 +75,201,21,180,0,3,20.35 +76,344,70,274,0,2,21.16 +77,345,73,272,0,2,17.24 +78,261,45,216,0,3,4.26 +79,47,2,45,0,15,33.79 +80,660,223,437,0,1,30.28 +81,634,192,442,0,1,5.84 +82,137,8,129,0,5,18.45 +83,309,57,252,0,2,34.11 +84,686,234,452,0,1,32.99 +85,682,225,457,0,1,19.25 +86,322,62,260,0,2,32.99 +87,676,223,453,0,1,20.92 +88,325,68,257,0,2,35.27 +89,689,243,446,0,1,32.95 +90,695,229,466,0,1,21.91 +91,324,71,253,0,2,20.47 +92,337,69,268,0,2,13.96 +93,222,31,191,0,3,31.78 +94,686,218,468,0,1,19.94 +95,351,70,281,0,2,33.89 +96,717,243,474,0,1,32.53 +97,664,216,448,0,1,0.0 +98,23,0,23,0,37,11.6 +99,181,21,160,0,4,22.85 diff --git a/experiments/No_Refresh_0_5s_ttl/hit_age.csv b/experiments/No_Refresh_0_5s_ttl/hit_age.csv new file mode 100644 index 0000000..7ad3f49 --- /dev/null +++ b/experiments/No_Refresh_0_5s_ttl/hit_age.csv @@ -0,0 +1,101 @@ +obj_id,hit_rate,avg_age +1,0.3373493975903614,0.25892857142857145 +2,0.10377358490566038,0.36363636363636365 +3,0.32392273402674593,0.24311926605504589 +4,0.3459915611814346,0.25609756097560976 +5,0.19130434782608696,0.24242424242424243 +6,0.31741140215716485,0.24757281553398058 +7,0.10218978102189781,0.21428571428571427 +8,0.3245227606461087,0.2579185520361991 +9,0.3439767779390421,0.23628691983122363 +10,0.34182908545727136,0.2236842105263158 +11,0.21951219512195122,0.2361111111111111 +12,0.34971098265895956,0.30578512396694213 +13,0.32210834553440704,0.22727272727272727 +14,0.33620689655172414,0.2692307692307692 +15,0.20348837209302326,0.2 +16,0.18404907975460122,0.2 +17,0.29898403483309144,0.2524271844660194 +18,0.32850940665701883,0.24669603524229075 +19,0.1187214611872146,0.2692307692307692 +20,0.3483606557377049,0.25882352941176473 +21,0.35047361299052776,0.21235521235521235 +22,0.34553440702781846,0.288135593220339 +23,0.3522388059701492,0.19915254237288135 +24,0.19939577039274925,0.18181818181818182 +25,0.34668508287292815,0.2589641434262948 +26,0.3208092485549133,0.2072072072072072 +27,0.34184397163120567,0.23651452282157676 +28,0.08759124087591241,0.16666666666666666 +29,0.34226190476190477,0.24782608695652175 +30,0.3170028818443804,0.2818181818181818 +31,0.33086053412462907,0.2600896860986547 +32,0.09027777777777778,0.3076923076923077 +33,0.34626865671641793,0.24568965517241378 +34,0.07092198581560284,0.3 +35,0.3277693474962064,0.2638888888888889 +36,0.3227206946454414,0.29596412556053814 +37,0.36906377204884666,0.22058823529411764 +38,0.1415525114155251,0.3870967741935484 +39,0.05,0.2 +40,0.3277310924369748,0.27350427350427353 +41,0.125,0.30434782608695654 +42,0.07453416149068323,0.25 +43,0.2154696132596685,0.32051282051282054 +44,0.3261494252873563,0.24669603524229075 +45,0.29984051036682613,0.3404255319148936 +46,0.3256172839506173,0.27014218009478674 +47,0.018867924528301886,0.0 +48,0.3150887573964497,0.23943661971830985 +49,0.31347962382445144,0.27 +50,0.32689450222882616,0.22727272727272727 +51,0.125,0.25 +52,0.03529411764705882,0.3333333333333333 +53,0.3333333333333333,0.26506024096385544 +54,0.33,0.24675324675324675 +55,0.3508005822416303,0.24481327800829875 +56,0.375,0.25925925925925924 +57,0.3130434782608696,0.2638888888888889 +58,0.0,0.0 +59,0.1918238993710692,0.14754098360655737 +60,0.31305637982195844,0.1990521327014218 +61,0.13043478260869565,0.0 +62,0.35220994475138123,0.2549019607843137 +63,0.3232484076433121,0.2315270935960591 +64,0.2492753623188406,0.3372093023255814 +65,0.3509544787077827,0.2803347280334728 +66,0.0410958904109589,0.3333333333333333 +67,0.3379416282642089,0.20909090909090908 +68,0.0,0.0 +69,0.330188679245283,0.32857142857142857 +70,0.3277439024390244,0.26046511627906976 +71,0.22580645161290322,0.2261904761904762 +72,0.33480825958702065,0.2422907488986784 +73,0.33699059561128525,0.2930232558139535 +74,0.33284671532846716,0.19736842105263158 +75,0.1044776119402985,0.2857142857142857 +76,0.20348837209302326,0.3 +77,0.21159420289855072,0.2054794520547945 +78,0.1724137931034483,0.2 +79,0.0425531914893617,0.0 +80,0.3378787878787879,0.27802690582959644 +81,0.3028391167192429,0.2604166666666667 +82,0.058394160583941604,0.125 +83,0.18446601941747573,0.24561403508771928 +84,0.34110787172011664,0.2905982905982906 +85,0.32991202346041054,0.26222222222222225 +86,0.19254658385093168,0.3064516129032258 +87,0.32988165680473375,0.20179372197309417 +88,0.20923076923076922,0.25 +89,0.35268505079825835,0.22633744855967078 +90,0.3294964028776978,0.2794759825327511 +91,0.2191358024691358,0.30985915492957744 +92,0.20474777448071216,0.21739130434782608 +93,0.13963963963963963,0.25806451612903225 +94,0.3177842565597668,0.2889908256880734 +95,0.19943019943019943,0.3142857142857143 +96,0.3389121338912134,0.2139917695473251 +97,0.3253012048192771,0.26851851851851855 +98,0.0,0.0 +99,0.11602209944751381,0.3333333333333333 +100,0.228486646884273,0.24675324675324675 diff --git a/experiments/No_Refresh_0_5s_ttl/lambda_distribution.pdf b/experiments/No_Refresh_0_5s_ttl/lambda_distribution.pdf new file mode 100644 index 0000000000000000000000000000000000000000..1be4cdc51c4575780b0a9f1e5df7d793b0dce6fd GIT binary patch literal 11740 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_0_5s_ttl/objects_in_cache_over_time.pdf b/experiments/No_Refresh_0_5s_ttl/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5029a5d14f988b66610095500563321bc81c5704 GIT binary patch literal 18423 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 YUMMS1)QOn@z7|KoL7be5+Df4R0}u~$zW@LL literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_0_5s_ttl/overall_hit_age.csv b/experiments/No_Refresh_0_5s_ttl/overall_hit_age.csv new file mode 100644 index 0000000..a824936 --- /dev/null +++ b/experiments/No_Refresh_0_5s_ttl/overall_hit_age.csv @@ -0,0 +1,9 @@ +,hit_rate,avg_age +count,100.0,100.0 +mean,0.24997190226308422,0.24085664637735987 +std,0.10967384888958667,0.07537398148292249 +min,0.0,0.0 +25%,0.1843617845017571,0.21978900255754474 +50%,0.3172071420007726,0.25 +75%,0.3351579188281965,0.2796906689079315 +max,0.375,0.3870967741935484 diff --git a/experiments/No_Refresh_1_0s_ttl/details.csv b/experiments/No_Refresh_1_0s_ttl/details.csv new file mode 100644 index 0000000..35176cb --- /dev/null +++ b/experiments/No_Refresh_1_0s_ttl/details.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,664,328,336,0,1,22.17 +2,212,47,165,0,3,50.07 +3,673,337,336,0,1,50.63 +4,711,360,351,0,1,32.75 +5,345,113,232,0,2,49.46 +6,649,321,328,0,1,18.98 +7,137,26,111,0,5,49.63 +8,681,338,343,0,1,50.22 +9,689,346,343,0,1,49.33 +10,667,329,338,0,1,37.8 +11,328,124,204,0,2,52.31 +12,692,362,330,0,1,48.46 +13,683,331,352,0,1,49.86 +14,696,347,349,0,1,31.98 +15,344,110,234,0,2,29.14 +16,326,95,231,0,2,48.48 +17,689,334,355,0,1,49.93 +18,691,345,346,0,1,22.83 +19,219,50,169,0,3,51.09 +20,732,374,358,0,1,52.77 +21,739,390,349,0,1,51.1 +22,683,349,334,0,1,49.55 +23,670,332,338,0,1,32.02 +24,331,106,225,0,2,50.97 +25,724,369,355,0,1,50.58 +26,692,350,342,0,1,51.49 +27,705,363,342,0,1,15.33 +28,137,21,116,0,5,49.55 +29,672,333,339,0,1,48.56 +30,694,337,357,0,1,50.3 +31,674,339,335,0,1,17.36 +32,144,25,119,0,4,51.19 +33,670,343,327,0,1,12.77 +34,141,18,123,0,4,50.99 +35,659,336,323,0,1,50.36 +36,691,348,343,0,1,53.05 +37,737,391,346,0,1,24.66 +38,219,54,165,0,3,9.0 +39,100,9,91,0,8,49.72 +40,714,355,359,0,1,22.28 +41,184,41,143,0,4,18.63 +42,161,30,131,0,4,37.57 +43,362,136,226,0,2,49.57 +44,696,345,351,0,1,47.05 +45,627,295,332,0,1,48.77 +46,648,316,332,0,1,5.66 +47,53,3,50,0,10,48.22 +48,676,326,350,0,1,48.12 +49,638,307,331,0,1,49.93 +50,673,336,337,0,1,18.75 +51,128,24,104,0,5,9.41 +52,85,8,77,0,9,51.54 +53,747,385,362,0,1,49.86 +54,700,349,351,0,1,51.24 +55,687,352,335,0,1,53.75 +56,720,387,333,0,1,50.43 +57,690,348,342,0,1,2.5 +58,40,1,39,0,17,32.08 +59,318,102,216,0,2,47.92 +60,674,323,351,0,1,17.39 +61,23,4,19,0,26,50.97 +62,724,369,355,0,1,49.2 +63,628,309,319,0,1,36.52 +64,345,126,219,0,2,50.66 +65,681,345,336,0,1,6.85 +66,73,5,68,0,10,50.23 +67,651,327,324,0,1,0.0 +68,10,0,10,0,69,49.06 +69,636,312,324,0,1,48.17 +70,656,316,340,0,1,34.95 +71,372,130,242,0,2,51.33 +72,678,348,330,0,1,49.69 +73,638,317,321,0,1,50.95 +74,685,349,336,0,1,20.9 +75,201,42,159,0,3,35.76 +76,344,123,221,0,2,36.23 +77,345,125,220,0,2,27.2 +78,261,71,190,0,3,8.51 +79,47,4,43,0,15,50.3 +80,660,332,328,0,1,49.53 +81,634,314,320,0,1,13.87 +82,137,19,118,0,5,30.74 +83,309,95,214,0,2,50.44 +84,686,346,340,0,1,49.41 +85,682,337,345,0,1,32.61 +86,322,105,217,0,2,50.0 +87,676,338,338,0,1,31.69 +88,325,103,222,0,2,49.93 +89,689,344,345,0,1,49.06 +90,695,341,354,0,1,36.73 +91,324,119,205,0,2,33.53 +92,337,113,224,0,2,26.13 +93,222,58,164,0,3,49.85 +94,686,342,344,0,1,35.61 +95,351,125,226,0,2,52.44 +96,717,376,341,0,1,49.25 +97,664,327,337,0,1,0.0 +98,23,0,23,0,37,21.55 +99,181,39,142,0,4,35.31 diff --git a/experiments/No_Refresh_1_0s_ttl/hit_age.csv b/experiments/No_Refresh_1_0s_ttl/hit_age.csv new file mode 100644 index 0000000..42e1795 --- /dev/null +++ b/experiments/No_Refresh_1_0s_ttl/hit_age.csv @@ -0,0 +1,101 @@ +obj_id,hit_rate,avg_age +1,0.4939759036144578,0.45426829268292684 +2,0.22169811320754718,0.5106382978723404 +3,0.5007429420505201,0.5133531157270029 +4,0.5063291139240507,0.5166666666666667 +5,0.32753623188405795,0.4247787610619469 +6,0.4946070878274268,0.5171339563862928 +7,0.1897810218978102,0.46153846153846156 +8,0.49632892804698975,0.4556213017751479 +9,0.502177068214804,0.476878612716763 +10,0.49325337331334335,0.44376899696048633 +11,0.3780487804878049,0.5483870967741935 +12,0.523121387283237,0.5 +13,0.48462664714494874,0.4743202416918429 +14,0.4985632183908046,0.49279538904899134 +15,0.31976744186046513,0.4727272727272727 +16,0.29141104294478526,0.4421052631578947 +17,0.4847605224963715,0.5988023952095808 +18,0.4992764109985528,0.4927536231884058 +19,0.228310502283105,0.52 +20,0.5109289617486339,0.5053475935828877 +21,0.5277401894451962,0.4897435897435897 +22,0.5109809663250366,0.49283667621776506 +23,0.4955223880597015,0.43373493975903615 +24,0.3202416918429003,0.3867924528301887 +25,0.5096685082872928,0.5013550135501355 +26,0.5057803468208093,0.5057142857142857 +27,0.5148936170212766,0.49586776859504134 +28,0.15328467153284672,0.42857142857142855 +29,0.4955357142857143,0.45645645645645644 +30,0.48559077809798273,0.5608308605341247 +31,0.5029673590504451,0.49557522123893805 +32,0.1736111111111111,0.6 +33,0.5119402985074627,0.44314868804664725 +34,0.1276595744680851,0.5 +35,0.5098634294385432,0.5297619047619048 +36,0.5036179450072359,0.5 +37,0.5305291723202171,0.4961636828644501 +38,0.2465753424657534,0.6296296296296297 +39,0.09,0.4444444444444444 +40,0.49719887955182074,0.5014084507042254 +41,0.22282608695652173,0.5853658536585366 +42,0.18633540372670807,0.6666666666666666 +43,0.3756906077348066,0.47794117647058826 +44,0.4956896551724138,0.4956521739130435 +45,0.4704944178628389,0.535593220338983 +46,0.4876543209876543,0.4810126582278481 +47,0.05660377358490566,0.3333333333333333 +48,0.4822485207100592,0.4263803680981595 +49,0.48119122257053293,0.50814332247557 +50,0.49925705794947994,0.4523809523809524 +51,0.1875,0.5 +52,0.09411764705882353,0.5 +53,0.5153949129852744,0.535064935064935 +54,0.49857142857142855,0.5358166189111748 +55,0.512372634643377,0.4943181818181818 +56,0.5375,0.4728682170542636 +57,0.5043478260869565,0.5431034482758621 +58,0.025,1.0 +59,0.32075471698113206,0.5196078431372549 +60,0.4792284866468843,0.47678018575851394 +61,0.17391304347826086,0.25 +62,0.5096685082872928,0.46883468834688347 +63,0.49203821656050956,0.47896440129449835 +64,0.3652173913043478,0.5476190476190477 +65,0.5066079295154186,0.5594202898550724 +66,0.0684931506849315,0.6 +67,0.5023041474654378,0.40978593272171254 +68,0.0,0.0 +69,0.49056603773584906,0.5416666666666666 +70,0.4817073170731707,0.5 +71,0.34946236559139787,0.5615384615384615 +72,0.5132743362831859,0.49137931034482757 +73,0.49686520376175547,0.5362776025236593 +74,0.5094890510948905,0.4813753581661891 +75,0.208955223880597,0.5238095238095238 +76,0.35755813953488375,0.5853658536585366 +77,0.36231884057971014,0.488 +78,0.2720306513409962,0.4647887323943662 +79,0.0851063829787234,0.5 +80,0.503030303030303,0.5180722891566265 +81,0.4952681388012618,0.49044585987261147 +82,0.1386861313868613,0.47368421052631576 +83,0.3074433656957929,0.5368421052631579 +84,0.5043731778425656,0.5028901734104047 +85,0.4941348973607038,0.5014836795252225 +86,0.32608695652173914,0.5428571428571428 +87,0.5,0.5029585798816568 +88,0.3169230769230769,0.4368932038834951 +89,0.49927431059506533,0.45058139534883723 +90,0.4906474820143885,0.49266862170087977 +91,0.36728395061728397,0.5630252100840336 +92,0.3353115727002967,0.415929203539823 +93,0.26126126126126126,0.4827586206896552 +94,0.49854227405247814,0.52046783625731 +95,0.3561253561253561,0.536 +96,0.5244072524407253,0.4627659574468085 +97,0.4924698795180723,0.5015290519877675 +98,0.0,0.0 +99,0.2154696132596685,0.5384615384615384 +100,0.35311572700296734,0.4957983193277311 diff --git a/experiments/No_Refresh_1_0s_ttl/lambda_distribution.pdf b/experiments/No_Refresh_1_0s_ttl/lambda_distribution.pdf new file mode 100644 index 0000000000000000000000000000000000000000..a53c2b877948f3be7c973422edbb7c319ff2f1be GIT binary patch literal 11740 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_1_0s_ttl/objects_in_cache_over_time.pdf b/experiments/No_Refresh_1_0s_ttl/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d8530ecb7bac40c0fb504f2e4e8e69c15faea28c GIT binary patch literal 18320 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_2_0s_ttl/overall_hit_age.csv b/experiments/No_Refresh_2_0s_ttl/overall_hit_age.csv new file mode 100644 index 0000000..ab804af --- /dev/null +++ b/experiments/No_Refresh_2_0s_ttl/overall_hit_age.csv @@ -0,0 +1,9 @@ +,hit_rate,avg_age +count,100.0,100.0 +mean,0.5381173912695726,0.966399936751214 +std,0.18361763609229173,0.17530494397945118 +min,0.0,0.0 +25%,0.47816297246137873,0.9537065918070284 +50%,0.6546302320537845,0.9949544516583623 +75%,0.667165303003057,1.0265184493014563 +max,0.6906377204884667,1.2375 diff --git a/experiments/No_Refresh_3_0s_ttl/details.csv b/experiments/No_Refresh_3_0s_ttl/details.csv new file mode 100644 index 0000000..bea6368 --- /dev/null +++ b/experiments/No_Refresh_3_0s_ttl/details.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,664,494,170,0,1,45.28 +2,212,96,116,0,3,74.15 +3,673,499,174,0,1,76.65 +4,711,545,166,0,1,60.0 +5,345,207,138,0,2,73.96 +6,649,480,169,0,1,38.69 +7,137,53,84,0,5,74.3 +8,681,506,175,0,1,74.6 +9,689,514,175,0,1,74.66 +10,667,498,169,0,1,60.37 +11,328,198,130,0,2,75.29 +12,692,521,171,0,1,74.96 +13,683,512,171,0,1,74.71 +14,696,520,176,0,1,60.76 +15,344,209,135,0,2,59.2 +16,326,193,133,0,2,75.47 +17,689,520,169,0,1,75.11 +18,691,519,172,0,1,51.6 +19,219,113,106,0,3,75.96 +20,732,556,176,0,1,76.32 +21,739,564,175,0,1,75.26 +22,683,514,169,0,1,74.78 +23,670,501,169,0,1,57.4 +24,331,190,141,0,2,75.83 +25,724,549,175,0,1,74.86 +26,692,518,174,0,1,75.74 +27,705,534,171,0,1,37.23 +28,137,51,86,0,5,75.15 +29,672,505,167,0,1,74.64 +30,694,518,176,0,1,74.78 +31,674,504,170,0,1,38.89 +32,144,56,88,0,4,74.93 +33,670,502,168,0,1,31.91 +34,141,45,96,0,4,74.66 +35,659,492,167,0,1,75.4 +36,691,521,170,0,1,76.12 +37,737,561,176,0,1,48.86 +38,219,107,112,0,3,28.0 +39,100,28,72,0,8,75.91 +40,714,542,172,0,1,42.39 +41,184,78,106,0,4,43.48 +42,161,70,91,0,4,61.88 +43,362,224,138,0,2,75.43 +44,696,525,171,0,1,73.21 +45,627,459,168,0,1,75.15 +46,648,487,161,0,1,22.64 +47,53,12,41,0,10,74.85 +48,676,506,170,0,1,73.98 +49,638,472,166,0,1,74.59 +50,673,502,171,0,1,39.06 +51,128,50,78,0,5,21.18 +52,85,18,67,0,9,76.57 +53,747,572,175,0,1,76.0 +54,700,532,168,0,1,75.25 +55,687,517,170,0,1,75.42 +56,720,543,177,0,1,75.36 +57,690,520,170,0,1,10.0 +58,40,4,36,0,17,60.69 +59,318,193,125,0,2,74.93 +60,674,505,169,0,1,21.74 +61,23,5,18,0,26,75.55 +62,724,547,177,0,1,74.2 +63,628,466,162,0,1,60.29 +64,345,208,137,0,2,74.89 +65,681,510,171,0,1,23.29 +66,73,17,56,0,10,74.35 +67,651,484,167,0,1,0.0 +68,10,0,10,0,69,73.9 +69,636,470,166,0,1,74.7 +70,656,490,166,0,1,61.56 +71,372,229,143,0,2,75.52 +72,678,512,166,0,1,73.51 +73,638,469,169,0,1,74.89 +74,685,513,172,0,1,44.28 +75,201,89,112,0,3,59.88 +76,344,206,138,0,2,61.45 +77,345,212,133,0,2,50.19 +78,261,131,130,0,3,10.64 +79,47,5,42,0,15,75.3 +80,660,497,163,0,1,74.29 +81,634,471,163,0,1,37.96 +82,137,52,85,0,5,57.28 +83,309,177,132,0,2,75.51 +84,686,518,168,0,1,74.63 +85,682,509,173,0,1,58.39 +86,322,188,134,0,2,74.7 +87,676,505,171,0,1,58.15 +88,325,189,136,0,2,75.62 +89,689,521,168,0,1,75.11 +90,695,522,173,0,1,62.35 +91,324,202,122,0,2,60.53 +92,337,204,133,0,2,47.75 +93,222,106,116,0,3,75.07 +94,686,515,171,0,1,62.39 +95,351,219,132,0,2,76.29 +96,717,547,170,0,1,74.4 +97,664,494,170,0,1,8.7 +98,23,2,21,0,37,46.96 +99,181,85,96,0,4,59.64 diff --git a/experiments/No_Refresh_3_0s_ttl/hit_age.csv b/experiments/No_Refresh_3_0s_ttl/hit_age.csv new file mode 100644 index 0000000..39f01c5 --- /dev/null +++ b/experiments/No_Refresh_3_0s_ttl/hit_age.csv @@ -0,0 +1,101 @@ +obj_id,hit_rate,avg_age +1,0.7439759036144579,1.45748987854251 +2,0.4528301886792453,1.5416666666666667 +3,0.7414561664190193,1.4909819639278556 +4,0.7665260196905767,1.6018348623853211 +5,0.6,1.5507246376811594 +6,0.7395993836671803,1.5833333333333333 +7,0.38686131386861317,1.6603773584905661 +8,0.7430249632892805,1.4703557312252964 +9,0.7460087082728593,1.461089494163424 +10,0.7466266866566716,1.4759036144578312 +11,0.6036585365853658,1.4444444444444444 +12,0.7528901734104047,1.4491362763915547 +13,0.7496339677891655,1.537109375 +14,0.7471264367816092,1.5596153846153846 +15,0.6075581395348837,1.5023923444976077 +16,0.5920245398773006,1.5803108808290156 +17,0.7547169811320755,1.6423076923076922 +18,0.7510853835021708,1.5260115606936415 +19,0.5159817351598174,1.6106194690265487 +20,0.7595628415300546,1.4460431654676258 +21,0.7631935047361299,1.5088652482269505 +22,0.7525622254758418,1.5291828793774318 +23,0.7477611940298508,1.403193612774451 +24,0.5740181268882175,1.563157894736842 +25,0.7582872928176796,1.5136612021857923 +26,0.7485549132947977,1.5347490347490347 +27,0.7574468085106383,1.4138576779026217 +28,0.3722627737226277,1.5098039215686274 +29,0.7514880952380952,1.506930693069307 +30,0.7463976945244957,1.555984555984556 +31,0.7477744807121661,1.5297619047619047 +32,0.3888888888888889,1.5 +33,0.7492537313432835,1.4302788844621515 +34,0.3191489361702128,1.3777777777777778 +35,0.7465857359635811,1.5142276422764227 +36,0.7539797395079595,1.5009596928982725 +37,0.7611940298507462,1.5080213903743316 +38,0.4885844748858447,1.5794392523364487 +39,0.28,1.6785714285714286 +40,0.7591036414565826,1.6199261992619927 +41,0.42391304347826086,1.7179487179487178 +42,0.43478260869565216,1.6857142857142857 +43,0.6187845303867403,1.3392857142857142 +44,0.7543103448275862,1.5447619047619048 +45,0.7320574162679426,1.5359477124183007 +46,0.7515432098765432,1.5010266940451746 +47,0.22641509433962265,1.9166666666666667 +48,0.7485207100591716,1.5118577075098814 +49,0.7398119122257053,1.4406779661016949 +50,0.7459138187221397,1.4760956175298805 +51,0.390625,1.44 +52,0.21176470588235294,1.2777777777777777 +53,0.7657295850066934,1.4912587412587412 +54,0.76,1.5432330827067668 +55,0.75254730713246,1.4700193423597678 +56,0.7541666666666667,1.3922651933701657 +57,0.7536231884057971,1.5288461538461537 +58,0.1,1.5 +59,0.6069182389937107,1.5025906735751295 +60,0.7492581602373887,1.508910891089109 +61,0.21739130434782608,0.6 +62,0.755524861878453,1.5045703839122486 +63,0.7420382165605095,1.4785407725321889 +64,0.6028985507246377,1.4519230769230769 +65,0.748898678414097,1.4843137254901961 +66,0.2328767123287671,1.588235294117647 +67,0.7434715821812596,1.493801652892562 +68,0.0,0.0 +69,0.7389937106918238,1.553191489361702 +70,0.7469512195121951,1.530612244897959 +71,0.6155913978494624,1.5327510917030567 +72,0.7551622418879056,1.484375 +73,0.7351097178683386,1.4179104477611941 +74,0.7489051094890511,1.557504873294347 +75,0.4427860696517413,1.5056179775280898 +76,0.5988372093023255,1.441747572815534 +77,0.6144927536231884,1.4433962264150944 +78,0.5019157088122606,1.4885496183206106 +79,0.10638297872340426,0.8 +80,0.753030303030303,1.5070422535211268 +81,0.7429022082018928,1.4692144373673035 +82,0.3795620437956204,1.5192307692307692 +83,0.5728155339805825,1.5197740112994351 +84,0.7551020408163265,1.494208494208494 +85,0.7463343108504399,1.3889980353634577 +86,0.5838509316770186,1.5106382978723405 +87,0.7470414201183432,1.4792079207920792 +88,0.5815384615384616,1.3915343915343916 +89,0.7561683599419449,1.5335892514395393 +90,0.7510791366906475,1.496168582375479 +91,0.6234567901234568,1.5792079207920793 +92,0.6053412462908012,1.392156862745098 +93,0.4774774774774775,1.4622641509433962 +94,0.750728862973761,1.5728155339805825 +95,0.6239316239316239,1.5342465753424657 +96,0.7629009762900977,1.4204753199268738 +97,0.7439759036144579,1.4412955465587045 +98,0.08695652173913043,3.0 +99,0.4696132596685083,1.411764705882353 +100,0.5964391691394659,1.328358208955224 diff --git a/experiments/No_Refresh_3_0s_ttl/lambda_distribution.pdf b/experiments/No_Refresh_3_0s_ttl/lambda_distribution.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6956e0c4384e0f4df0c512728b331243fd539a3a GIT binary patch literal 11740 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_3_0s_ttl/objects_in_cache_over_time.pdf b/experiments/No_Refresh_3_0s_ttl/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..5cb16b9f65d9f175708a857c6a8a5c15d625c123 GIT binary patch literal 18425 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 WwHNYin}7<#1%(LM*%h^v2>u`WE_9Iq literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_3_0s_ttl/overall_hit_age.csv b/experiments/No_Refresh_3_0s_ttl/overall_hit_age.csv new file mode 100644 index 0000000..466e8e4 --- /dev/null +++ b/experiments/No_Refresh_3_0s_ttl/overall_hit_age.csv @@ -0,0 +1,9 @@ +,hit_rate,avg_age +count,100.0,100.0 +mean,0.6224679450442043,1.4900421658850633 +std,0.18900729549961315,0.2559552015594171 +min,0.0,0.0 +25%,0.5737174786613087,1.4512263767901963 +50%,0.7429635857455866,1.5035805287436892 +75%,0.7511860614361519,1.5382486979166667 +max,0.7665260196905767,3.0 diff --git a/experiments/No_Refresh_4_0s_ttl/details.csv b/experiments/No_Refresh_4_0s_ttl/details.csv new file mode 100644 index 0000000..cb5e870 --- /dev/null +++ b/experiments/No_Refresh_4_0s_ttl/details.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,664,527,137,0,1,52.83 +2,212,112,100,0,3,79.79 +3,673,537,136,0,1,80.87 +4,711,575,136,0,1,68.99 +5,345,238,107,0,2,79.35 +6,649,515,134,0,1,43.8 +7,137,60,77,0,5,80.32 +8,681,547,134,0,1,79.97 +9,689,551,138,0,1,79.31 +10,667,529,138,0,1,68.29 +11,328,224,104,0,2,80.2 +12,692,555,137,0,1,80.09 +13,683,547,136,0,1,80.6 +14,696,561,135,0,1,67.15 +15,344,231,113,0,2,65.64 +16,326,214,112,0,2,80.12 +17,689,552,137,0,1,80.32 +18,691,555,136,0,1,55.71 +19,219,122,97,0,3,80.87 +20,732,592,140,0,1,81.33 +21,739,601,138,0,1,79.8 +22,683,545,138,0,1,79.85 +23,670,535,135,0,1,67.07 +24,331,222,109,0,2,80.66 +25,724,584,140,0,1,80.35 +26,692,556,136,0,1,80.85 +27,705,570,135,0,1,43.8 +28,137,60,77,0,5,79.76 +29,672,536,136,0,1,79.83 +30,694,554,140,0,1,79.82 +31,674,538,136,0,1,47.92 +32,144,69,75,0,4,79.55 +33,670,533,137,0,1,43.26 +34,141,61,80,0,4,79.51 +35,659,524,135,0,1,80.03 +36,691,553,138,0,1,80.73 +37,737,595,142,0,1,57.08 +38,219,125,94,0,3,37.0 +39,100,37,63,0,8,80.39 +40,714,574,140,0,1,50.54 +41,184,93,91,0,4,47.83 +42,161,77,84,0,4,68.51 +43,362,248,114,0,2,80.6 +44,696,561,135,0,1,78.63 +45,627,493,134,0,1,79.63 +46,648,516,132,0,1,24.53 +47,53,13,40,0,10,79.73 +48,676,539,137,0,1,78.68 +49,638,502,136,0,1,79.35 +50,673,534,139,0,1,42.97 +51,128,55,73,0,5,30.59 +52,85,26,59,0,9,81.12 +53,747,606,141,0,1,81.0 +54,700,567,133,0,1,80.2 +55,687,551,136,0,1,81.25 +56,720,585,135,0,1,79.57 +57,690,549,141,0,1,12.5 +58,40,5,35,0,17,65.72 +59,318,209,109,0,2,79.82 +60,674,538,136,0,1,21.74 +61,23,5,18,0,26,80.94 +62,724,586,138,0,1,78.34 +63,628,492,136,0,1,66.96 +64,345,231,114,0,2,80.62 +65,681,549,132,0,1,28.77 +66,73,21,52,0,10,79.57 +67,651,518,133,0,1,0.0 +68,10,0,10,0,69,78.46 +69,636,499,137,0,1,79.73 +70,656,523,133,0,1,67.74 +71,372,252,120,0,2,80.38 +72,678,545,133,0,1,79.31 +73,638,506,132,0,1,79.85 +74,685,547,138,0,1,52.24 +75,201,105,96,0,3,65.99 +76,344,227,117,0,2,68.41 +77,345,236,109,0,2,59.0 +78,261,154,107,0,3,14.89 +79,47,7,40,0,15,79.7 +80,660,526,134,0,1,79.02 +81,634,501,133,0,1,43.07 +82,137,59,78,0,5,65.05 +83,309,201,108,0,2,80.47 +84,686,552,134,0,1,79.47 +85,682,542,140,0,1,64.91 +86,322,209,113,0,2,79.14 +87,676,535,141,0,1,65.23 +88,325,212,113,0,2,80.41 +89,689,554,135,0,1,80.43 +90,695,559,136,0,1,67.59 +91,324,219,105,0,2,67.36 +92,337,227,110,0,2,56.76 +93,222,126,96,0,3,79.74 +94,686,547,139,0,1,68.38 +95,351,240,111,0,2,80.61 +96,717,578,139,0,1,79.52 +97,664,528,136,0,1,17.39 +98,23,4,19,0,37,53.04 +99,181,96,85,0,4,68.25 diff --git a/experiments/No_Refresh_4_0s_ttl/hit_age.csv b/experiments/No_Refresh_4_0s_ttl/hit_age.csv new file mode 100644 index 0000000..389db7b --- /dev/null +++ b/experiments/No_Refresh_4_0s_ttl/hit_age.csv @@ -0,0 +1,101 @@ +obj_id,hit_rate,avg_age +1,0.7936746987951807,1.9316888045540797 +2,0.5283018867924528,2.080357142857143 +3,0.7979197622585439,2.0242085661080074 +4,0.8087201125175809,2.1339130434782607 +5,0.6898550724637681,2.168067226890756 +6,0.7935285053929122,1.9300970873786407 +7,0.43795620437956206,1.9333333333333333 +8,0.8032305433186491,2.03290676416819 +9,0.7997097242380261,1.9945553539019965 +10,0.7931034482758621,2.007561436672968 +11,0.6829268292682927,1.9866071428571428 +12,0.8020231213872833,1.936936936936937 +13,0.8008784773060029,2.113345521023766 +14,0.8060344827586207,1.9946524064171123 +15,0.6715116279069767,1.8874458874458875 +16,0.656441717791411,2.046728971962617 +17,0.8011611030478955,1.9728260869565217 +18,0.8031837916063675,2.045045045045045 +19,0.5570776255707762,1.9344262295081966 +20,0.8087431693989071,2.0591216216216215 +21,0.8132611637347767,2.043261231281198 +22,0.7979502196193266,1.9064220183486238 +23,0.7985074626865671,1.97196261682243 +24,0.6706948640483383,2.1036036036036037 +25,0.8066298342541437,1.9777397260273972 +26,0.8034682080924855,2.1097122302158273 +27,0.8085106382978723,2.1070175438596492 +28,0.43795620437956206,2.1666666666666665 +29,0.7976190476190477,1.9011194029850746 +30,0.7982708933717579,1.96028880866426 +31,0.798219584569733,2.0780669144981414 +32,0.4791666666666667,2.1594202898550723 +33,0.7955223880597015,1.8818011257035647 +34,0.4326241134751773,2.2131147540983607 +35,0.795144157814871,2.068702290076336 +36,0.8002894356005789,1.9620253164556962 +37,0.8073270013568521,1.946218487394958 +38,0.5707762557077626,2.096 +39,0.37,2.27027027027027 +40,0.803921568627451,2.06794425087108 +41,0.5054347826086957,2.204301075268817 +42,0.4782608695652174,2.1948051948051948 +43,0.6850828729281768,1.8830645161290323 +44,0.8060344827586207,2.0089126559714794 +45,0.7862838915470495,1.997971602434077 +46,0.7962962962962963,2.0174418604651163 +47,0.24528301886792453,2.1538461538461537 +48,0.7973372781065089,1.9851576994434137 +49,0.786833855799373,2.0358565737051793 +50,0.7934621099554234,1.9194756554307115 +51,0.4296875,1.6363636363636365 +52,0.3058823529411765,1.8846153846153846 +53,0.8112449799196787,2.0132013201320134 +54,0.81,2.0 +55,0.8020378457059679,1.9310344827586208 +56,0.8125,1.982905982905983 +57,0.7956521739130434,2.0491803278688523 +58,0.125,2.2 +59,0.6572327044025157,1.9569377990430623 +60,0.798219584569733,2.029739776951673 +61,0.21739130434782608,0.6 +62,0.8093922651933702,1.9112627986348123 +63,0.7834394904458599,1.8333333333333333 +64,0.6695652173913044,1.948051948051948 +65,0.8061674008810573,2.034608378870674 +66,0.2876712328767123,2.0952380952380953 +67,0.7956989247311828,2.0656370656370657 +68,0.0,0.0 +69,0.7845911949685535,1.9799599198396793 +70,0.7972560975609756,2.0095602294455066 +71,0.6774193548387096,1.9722222222222223 +72,0.803834808259587,1.891743119266055 +73,0.7931034482758621,1.8893280632411067 +74,0.7985401459854015,2.043875685557587 +75,0.5223880597014925,2.2095238095238097 +76,0.6598837209302325,1.9955947136563876 +77,0.6840579710144927,2.0254237288135593 +78,0.5900383141762452,2.0064935064935066 +79,0.14893617021276595,1.5714285714285714 +80,0.796969696969697,2.0 +81,0.7902208201892744,2.0339321357285427 +82,0.4306569343065693,1.8644067796610169 +83,0.6504854368932039,2.2487562189054726 +84,0.8046647230320699,1.9909420289855073 +85,0.7947214076246334,1.985239852398524 +86,0.6490683229813664,1.8229665071770336 +87,0.7914201183431953,2.0261682242990653 +88,0.6523076923076923,1.9575471698113207 +89,0.8040638606676342,1.94043321299639 +90,0.8043165467625899,2.0697674418604652 +91,0.6759259259259259,1.9680365296803652 +92,0.6735905044510386,1.9162995594713657 +93,0.5675675675675675,1.9523809523809523 +94,0.7973760932944607,2.1316270566727606 +95,0.6837606837606838,2.0208333333333335 +96,0.806136680613668,2.0328719723183393 +97,0.7951807228915663,1.9109848484848484 +98,0.17391304347826086,3.0 +99,0.5303867403314917,1.8854166666666667 +100,0.6824925816023739,1.8956521739130434 diff --git a/experiments/No_Refresh_4_0s_ttl/lambda_distribution.pdf b/experiments/No_Refresh_4_0s_ttl/lambda_distribution.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6c3277685bf4f9d6cea81a0225dc6d73b7e6ac62 GIT binary patch literal 11740 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_4_0s_ttl/objects_in_cache_over_time.pdf b/experiments/No_Refresh_4_0s_ttl/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..10cce30cf8ded3322426fcaac8be2f52b82a16c2 GIT binary patch literal 18849 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 HYM}oI!dD#h literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_4_0s_ttl/overall_hit_age.csv b/experiments/No_Refresh_4_0s_ttl/overall_hit_age.csv new file mode 100644 index 0000000..4938a7f --- /dev/null +++ b/experiments/No_Refresh_4_0s_ttl/overall_hit_age.csv @@ -0,0 +1,9 @@ +,hit_rate,avg_age +count,100.0,100.0 +mean,0.6783420943812974,1.9802754170895376 +std,0.18732473237217517,0.28636988978093675 +min,0.0,0.0 +25%,0.6501311584152445,1.9341530054644809 +50%,0.7932827791156427,1.9989858012170385 +75%,0.800949133741476,2.0662138619455694 +max,0.8132611637347767,3.0 diff --git a/experiments/No_Refresh_5_0s_ttl/details.csv b/experiments/No_Refresh_5_0s_ttl/details.csv new file mode 100644 index 0000000..73d1056 --- /dev/null +++ b/experiments/No_Refresh_5_0s_ttl/details.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,664,550,114,0,1,58.49 +2,212,124,88,0,3,83.21 +3,673,560,113,0,1,84.11 +4,711,598,113,0,1,72.17 +5,345,249,96,0,2,82.43 +6,649,535,114,0,1,50.36 +7,137,69,68,0,5,83.41 +8,681,568,113,0,1,83.74 +9,689,577,112,0,1,82.91 +10,667,553,114,0,1,71.34 +11,328,234,94,0,2,83.67 +12,692,579,113,0,1,83.46 +13,683,570,113,0,1,83.48 +14,696,581,115,0,1,70.64 +15,344,243,101,0,2,71.78 +16,326,234,92,0,2,83.45 +17,689,575,114,0,1,83.65 +18,691,578,113,0,1,62.56 +19,219,137,82,0,3,84.29 +20,732,617,115,0,1,84.44 +21,739,624,115,0,1,83.31 +22,683,569,114,0,1,83.13 +23,670,557,113,0,1,71.3 +24,331,236,95,0,2,83.84 +25,724,607,117,0,1,83.38 +26,692,577,115,0,1,83.69 +27,705,590,115,0,1,48.18 +28,137,66,71,0,5,83.04 +29,672,558,114,0,1,83.43 +30,694,579,115,0,1,83.23 +31,674,561,113,0,1,51.39 +32,144,74,70,0,4,83.13 +33,670,557,113,0,1,48.94 +34,141,69,72,0,4,83.0 +35,659,547,112,0,1,83.36 +36,691,576,115,0,1,84.67 +37,737,624,113,0,1,62.56 +38,219,137,82,0,3,41.0 +39,100,41,59,0,8,83.61 +40,714,597,117,0,1,55.98 +41,184,103,81,0,4,57.14 +42,161,92,69,0,4,73.76 +43,362,267,95,0,2,83.91 +44,696,584,112,0,1,82.46 +45,627,517,110,0,1,82.72 +46,648,536,112,0,1,30.19 +47,53,16,37,0,10,83.14 +48,676,562,114,0,1,82.29 +49,638,525,113,0,1,83.06 +50,673,559,114,0,1,49.22 +51,128,63,65,0,5,34.12 +52,85,29,56,0,9,84.34 +53,747,630,117,0,1,83.86 +54,700,587,113,0,1,83.41 +55,687,573,114,0,1,83.75 +56,720,603,117,0,1,83.33 +57,690,575,115,0,1,17.5 +58,40,7,33,0,17,70.13 +59,318,223,95,0,2,82.94 +60,674,559,115,0,1,21.74 +61,23,5,18,0,26,83.84 +62,724,607,117,0,1,82.17 +63,628,516,112,0,1,71.59 +64,345,247,98,0,2,83.11 +65,681,566,115,0,1,31.51 +66,73,23,50,0,10,83.1 +67,651,541,110,0,1,0.0 +68,10,0,10,0,69,82.55 +69,636,525,111,0,1,82.62 +70,656,542,114,0,1,73.12 +71,372,272,100,0,2,83.48 +72,678,566,112,0,1,82.13 +73,638,524,114,0,1,82.92 +74,685,568,117,0,1,57.71 +75,201,116,85,0,3,72.67 +76,344,250,94,0,2,72.17 +77,345,249,96,0,2,64.75 +78,261,169,92,0,3,19.15 +79,47,9,38,0,15,83.48 +80,660,551,109,0,1,82.18 +81,634,521,113,0,1,51.09 +82,137,70,67,0,5,69.58 +83,309,215,94,0,2,83.53 +84,686,573,113,0,1,82.84 +85,682,565,117,0,1,71.12 +86,322,229,93,0,2,83.28 +87,676,563,113,0,1,68.62 +88,325,223,102,0,2,83.16 +89,689,573,116,0,1,83.31 +90,695,579,116,0,1,73.15 +91,324,237,87,0,2,72.11 +92,337,243,94,0,2,63.51 +93,222,141,81,0,3,83.09 +94,686,570,116,0,1,71.79 +95,351,252,99,0,2,84.66 +96,717,607,110,0,1,83.28 +97,664,553,111,0,1,21.74 +98,23,5,18,0,37,56.91 +99,181,103,78,0,4,70.62 diff --git a/experiments/No_Refresh_5_0s_ttl/hit_age.csv b/experiments/No_Refresh_5_0s_ttl/hit_age.csv new file mode 100644 index 0000000..782f75e --- /dev/null +++ b/experiments/No_Refresh_5_0s_ttl/hit_age.csv @@ -0,0 +1,101 @@ +obj_id,hit_rate,avg_age +1,0.8283132530120482,2.596363636363636 +2,0.5849056603773585,2.524193548387097 +3,0.8320950965824666,2.405357142857143 +4,0.8410689170182841,2.4013377926421406 +5,0.7217391304347827,2.4698795180722892 +6,0.8243451463790447,2.3906542056074764 +7,0.5036496350364964,2.739130434782609 +8,0.8340675477239354,2.433098591549296 +9,0.8374455732946299,2.5095320623916813 +10,0.8290854572713643,2.5750452079566 +11,0.7134146341463414,2.4188034188034186 +12,0.8367052023121387,2.5250431778929188 +13,0.8345534407027818,2.5526315789473686 +14,0.8347701149425287,2.495697074010327 +15,0.7063953488372093,2.522633744855967 +16,0.7177914110429447,2.7777777777777777 +17,0.8345428156748912,2.4991304347826087 +18,0.8364688856729378,2.48961937716263 +19,0.6255707762557078,2.562043795620438 +20,0.842896174863388,2.521880064829822 +21,0.8443843031123139,2.4759615384615383 +22,0.8330893118594437,2.4938488576449913 +23,0.8313432835820895,2.466786355475763 +24,0.7129909365558912,2.5466101694915255 +25,0.8383977900552486,2.3789126853377267 +26,0.8338150289017341,2.5753899480069324 +27,0.8368794326241135,2.422033898305085 +28,0.48175182481751827,2.5757575757575757 +29,0.8303571428571429,2.4408602150537635 +30,0.8342939481268011,2.597582037996546 +31,0.8323442136498517,2.443850267379679 +32,0.5138888888888888,2.554054054054054 +33,0.8313432835820895,2.443447037701975 +34,0.48936170212765956,2.6231884057971016 +35,0.8300455235204856,2.409506398537477 +36,0.8335745296671491,2.4444444444444446 +37,0.8466757123473542,2.3846153846153846 +38,0.6255707762557078,2.81021897810219 +39,0.41,2.5121951219512195 +40,0.8361344537815126,2.5008375209380236 +41,0.5597826086956522,2.5728155339805827 +42,0.5714285714285714,2.6847826086956523 +43,0.7375690607734806,2.397003745318352 +44,0.8390804597701149,2.4914383561643834 +45,0.8245614035087719,2.4545454545454546 +46,0.8271604938271605,2.5167910447761193 +47,0.3018867924528302,2.9375 +48,0.8313609467455622,2.597864768683274 +49,0.822884012539185,2.5238095238095237 +50,0.8306092124814265,2.4991055456171734 +51,0.4921875,2.3492063492063493 +52,0.3411764705882353,2.1724137931034484 +53,0.8433734939759037,2.5365079365079364 +54,0.8385714285714285,2.5792163543441227 +55,0.834061135371179,2.4223385689354275 +56,0.8375,2.527363184079602 +57,0.8333333333333334,2.3756521739130436 +58,0.175,3.0 +59,0.7012578616352201,2.506726457399103 +60,0.8293768545994066,2.4686940966010735 +61,0.21739130434782608,0.6 +62,0.8383977900552486,2.6227347611202636 +63,0.821656050955414,2.4108527131782944 +64,0.7159420289855073,2.42914979757085 +65,0.8311306901615272,2.57773851590106 +66,0.3150684931506849,2.782608695652174 +67,0.8310291858678955,2.478743068391867 +68,0.0,0.0 +69,0.8254716981132075,2.459047619047619 +70,0.8262195121951219,2.559040590405904 +71,0.7311827956989247,2.6544117647058822 +72,0.8348082595870207,2.487632508833922 +73,0.8213166144200627,2.427480916030534 +74,0.8291970802919708,2.482394366197183 +75,0.5771144278606966,2.7327586206896552 +76,0.7267441860465116,2.576 +77,0.7217391304347827,2.4859437751004014 +78,0.6475095785440613,2.5562130177514795 +79,0.19148936170212766,2.5555555555555554 +80,0.8348484848484848,2.6515426497277677 +81,0.8217665615141956,2.44721689059501 +82,0.5109489051094891,2.557142857142857 +83,0.6957928802588996,2.7209302325581395 +84,0.8352769679300291,2.4694589877835953 +85,0.8284457478005866,2.320353982300885 +86,0.7111801242236024,2.6026200873362444 +87,0.8328402366863905,2.644760213143872 +88,0.6861538461538461,2.4260089686098656 +89,0.8316400580551524,2.5095986038394416 +90,0.8330935251798561,2.542314335060449 +91,0.7314814814814815,2.261603375527426 +92,0.7210682492581603,2.316872427983539 +93,0.6351351351351351,2.5106382978723403 +94,0.8309037900874635,2.507017543859649 +95,0.717948717948718,2.373015873015873 +96,0.8465829846582985,2.4365733113673804 +97,0.8328313253012049,2.54249547920434 +98,0.21739130434782608,3.4 +99,0.569060773480663,2.320388349514563 +100,0.7062314540059347,2.3529411764705883 diff --git a/experiments/No_Refresh_5_0s_ttl/lambda_distribution.pdf b/experiments/No_Refresh_5_0s_ttl/lambda_distribution.pdf new file mode 100644 index 0000000000000000000000000000000000000000..3e695332f5a27f0dee7f53fedd2fc857f22d4665 GIT binary patch literal 11740 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_5_0s_ttl/objects_in_cache_over_time.pdf b/experiments/No_Refresh_5_0s_ttl/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b3fe0309fc63d8861d829d9c4ba2561407cc7a47 GIT binary patch literal 18713 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 literal 0 HcmV?d00001 diff --git a/experiments/No_Refresh_5_0s_ttl/overall_hit_age.csv b/experiments/No_Refresh_5_0s_ttl/overall_hit_age.csv new file mode 100644 index 0000000..668ce47 --- /dev/null +++ b/experiments/No_Refresh_5_0s_ttl/overall_hit_age.csv @@ -0,0 +1,9 @@ +,hit_rate,avg_age +count,100.0,100.0 +mean,0.7175225869007572,2.4791552890507336 +std,0.1841955218651161,0.35131346514105605 +min,0.0,0.0 +25%,0.6933831217326363,2.4321113930546847 +50%,0.8266900030111413,2.503781989168563 +75%,0.8338765555190953,2.573372952474587 +max,0.8466757123473542,3.4 diff --git a/experiments/README.md b/experiments/README.md new file mode 100644 index 0000000..6a56d20 --- /dev/null +++ b/experiments/README.md @@ -0,0 +1,15 @@ +# Experiments: No Refresh with variable TTL + +Explanation for files in each experiment: + +- `details.csv`: Access Count, Hit, Miss, Mu, Lambda and Hit Rate for each object +- `hit_age.csv`: Shows hit rate/average age at time of request for each object. +- `lambda_distribution.pdf`: Lambda Distribution across all objects/discrete + values of the Zipf distribution +- `objects_in_cache_over_time.pdf`: Amount of cache entries at given time. +- `overall_hit_age.csv`: Cumulative description of `hit_age.csv` + +Length of simulation doesn't change much since we're not touching the request +rate across the simulations. +Break condition for the simulation is when the each database object has been +requested at least `ACCESS_COUNT_LIMIT` (i.e. 10) times. diff --git a/export.csv b/export.csv index c27ac7f..73d1056 100644 --- a/export.csv +++ b/export.csv @@ -1,100 +1,100 @@ ,access_count,hits,misses,mu,lambda,hit_rate -1,338919,293278,45641,9.45073508577941,1,87.09 -2,339569,295735,43834,8.14036449596436,1,87.19 -3,339121,295683,43438,7.841130117448747,1,93.79 -4,339726,318616,21110,2.2674748477937965,1,78.47 -5,67728,53145,14583,1.9491614320948918,5,87.79 -6,339470,298026,41444,6.571586635600101,1,77.43 -7,170195,131783,38412,7.611334405003136,2,29.18 -8,16126,4705,11421,4.4496294204831255,21,88.2 -9,339776,299674,40102,5.998373656353862,1,87.76 -10,339314,297783,41531,6.636819845113485,1,77.12 -11,170006,131110,38896,8.045921601779977,2,92.35 -12,338799,312870,25929,2.811627158825997,1,87.45 -13,338380,295915,42465,7.143615488470383,1,95.62 -14,339295,324424,14871,1.765483508758194,1,78.89 -15,168900,133246,35654,5.959911292425263,2,41.86 -16,37792,15821,21971,9.445879641550164,9,71.36 -17,42276,30167,12109,1.835890334290284,8,73.65 -18,113327,83461,29866,4.648600564543203,3,78.27 -19,169939,133012,36927,6.632144547714242,2,96.59 -20,339409,327834,11575,1.5219711334160873,1,86.89 -21,339488,294970,44518,8.640804985015603,1,89.01 -22,338488,301286,37202,4.948940599763346,1,93.0 -23,339243,315511,23732,2.5215047387858385,1,93.5 -24,338961,316939,22022,2.364507987541101,1,87.79 -25,338323,297005,41318,6.599461843110775,1,78.51 -26,169708,133242,36466,6.367528014392565,2,89.0 -27,339195,301871,37324,5.003687539185309,1,86.83 -28,338836,294227,44609,8.69089847442159,1,89.4 -29,339057,303133,35924,4.636189613643649,1,79.99 -30,169136,135290,33846,5.071027599242191,2,89.99 -31,337940,304106,33834,4.08093995040424,1,23.8 -32,13512,3216,10296,5.389385006998066,25,76.19 -33,113049,86130,26919,3.6953335845304562,3,87.95 -34,339556,298625,40931,6.455201262262219,1,88.24 -35,339483,299569,39914,5.935488589201371,1,75.63 -36,113404,85767,27637,3.880596047884128,3,89.06 -37,339071,301962,37109,4.9810532504276015,1,68.83 -38,37623,25897,11726,1.842940132793361,9,89.4 -39,339457,303459,35998,4.646642146558106,1,90.35 -40,338193,305568,32625,3.841385277835048,1,90.52 -41,339194,307024,32170,3.755174466816314,1,62.3 -42,67848,42269,25579,4.791783523908462,5,68.62 -43,56919,39060,17859,2.5603665363948838,6,85.08 -44,169214,143969,25245,2.9501977292188872,2,86.87 -45,339975,295349,44626,8.660786623694852,1,92.94 -46,339167,315235,23932,2.5477162793599124,1,86.54 -47,339934,294192,45742,9.754540171481345,1,87.12 -48,339091,295408,43683,7.997429679411413,1,90.35 -49,339138,306397,32741,3.884597009502997,1,86.57 -50,339966,294305,45661,9.586637018141543,1,88.32 -51,84488,74624,9864,1.4658283776461758,4,97.73 -52,339140,331438,7702,1.2656689838300985,1,92.44 -53,339252,313600,25652,2.737252979299571,1,87.02 -54,339109,295087,44022,8.251086295714982,1,94.48 -55,339737,320982,18755,2.0610542552665496,1,87.81 -56,170131,149390,20741,2.3501661595459855,2,18.76 -57,12099,2270,9829,8.517893008102874,28,86.59 -58,339603,294064,45539,9.51973718760753,1,79.07 -59,169388,133936,35452,5.7533658385673965,2,73.65 -60,112783,83061,29722,4.660963074614197,3,87.12 -61,339803,296040,43763,8.03102930717676,1,77.07 -62,169490,130630,38860,8.20890898481475,2,59.28 -63,68277,40475,27802,6.460946859444955,5,87.65 -64,340043,298043,42000,6.997089517135705,1,95.75 -65,339335,324924,14411,1.7111982665882988,1,63.53 -66,84598,53748,30850,7.195239628139434,4,87.83 -67,337396,296343,41053,6.468823743568375,1,76.74 -68,168813,129539,39274,8.584449622455724,2,76.87 -69,168935,129852,39083,8.31382957264006,2,70.86 -70,112790,79928,32862,6.32689728463079,3,27.82 -71,18026,5015,13011,6.059882273135225,19,86.61 -72,339602,294144,45458,9.326244637290127,1,89.2 -73,337685,301201,36484,4.734530335572703,1,32.94 -74,10000,3294,6706,2.0953399483975383,34,96.77 -75,338999,328054,10945,1.4775733311410093,1,76.91 -76,169928,130689,39239,8.406951084575,2,87.2 -77,339808,296317,43491,7.860627209955007,1,91.27 -78,340016,310335,29681,3.295575301583255,1,89.97 -79,339322,305288,34034,4.1428568837538,1,61.61 -80,85030,52384,32646,9.612329081824885,4,64.08 -81,84888,54399,30489,6.8654731084167215,4,86.01 -82,169804,146055,23749,2.7190649943185607,2,86.62 -83,339457,294036,45421,9.374682516586324,1,79.3 -84,169248,134215,35033,5.59505906586539,2,86.85 -85,338584,294054,44530,8.791458898209017,1,88.42 -86,338920,299662,39258,5.68526209949427,1,86.69 -87,338880,293780,45100,9.141536447646898,1,73.22 -88,112317,82242,30075,4.8033650741674165,3,89.16 -89,169307,150951,18356,2.106599827358843,2,87.4 -90,338997,296291,42706,7.364331823831616,1,86.62 -91,339905,294417,45488,9.303831880532016,1,33.3 -92,26197,8723,17474,9.509741988265437,13,87.41 -93,112773,98573,14200,1.8012576813912844,3,49.96 -94,48507,24233,24274,7.076409771949383,7,87.43 -95,339988,297246,42742,7.388599144805513,1,88.05 -96,338400,297960,40440,6.1158358642271375,1,85.57 -97,168252,143969,24283,2.8133122321600794,2,87.44 -98,338729,296200,42529,7.193050310873352,1,95.99 -99,338235,324673,13562,1.6556673379589992,1,52.28 +1,664,550,114,0,1,58.49 +2,212,124,88,0,3,83.21 +3,673,560,113,0,1,84.11 +4,711,598,113,0,1,72.17 +5,345,249,96,0,2,82.43 +6,649,535,114,0,1,50.36 +7,137,69,68,0,5,83.41 +8,681,568,113,0,1,83.74 +9,689,577,112,0,1,82.91 +10,667,553,114,0,1,71.34 +11,328,234,94,0,2,83.67 +12,692,579,113,0,1,83.46 +13,683,570,113,0,1,83.48 +14,696,581,115,0,1,70.64 +15,344,243,101,0,2,71.78 +16,326,234,92,0,2,83.45 +17,689,575,114,0,1,83.65 +18,691,578,113,0,1,62.56 +19,219,137,82,0,3,84.29 +20,732,617,115,0,1,84.44 +21,739,624,115,0,1,83.31 +22,683,569,114,0,1,83.13 +23,670,557,113,0,1,71.3 +24,331,236,95,0,2,83.84 +25,724,607,117,0,1,83.38 +26,692,577,115,0,1,83.69 +27,705,590,115,0,1,48.18 +28,137,66,71,0,5,83.04 +29,672,558,114,0,1,83.43 +30,694,579,115,0,1,83.23 +31,674,561,113,0,1,51.39 +32,144,74,70,0,4,83.13 +33,670,557,113,0,1,48.94 +34,141,69,72,0,4,83.0 +35,659,547,112,0,1,83.36 +36,691,576,115,0,1,84.67 +37,737,624,113,0,1,62.56 +38,219,137,82,0,3,41.0 +39,100,41,59,0,8,83.61 +40,714,597,117,0,1,55.98 +41,184,103,81,0,4,57.14 +42,161,92,69,0,4,73.76 +43,362,267,95,0,2,83.91 +44,696,584,112,0,1,82.46 +45,627,517,110,0,1,82.72 +46,648,536,112,0,1,30.19 +47,53,16,37,0,10,83.14 +48,676,562,114,0,1,82.29 +49,638,525,113,0,1,83.06 +50,673,559,114,0,1,49.22 +51,128,63,65,0,5,34.12 +52,85,29,56,0,9,84.34 +53,747,630,117,0,1,83.86 +54,700,587,113,0,1,83.41 +55,687,573,114,0,1,83.75 +56,720,603,117,0,1,83.33 +57,690,575,115,0,1,17.5 +58,40,7,33,0,17,70.13 +59,318,223,95,0,2,82.94 +60,674,559,115,0,1,21.74 +61,23,5,18,0,26,83.84 +62,724,607,117,0,1,82.17 +63,628,516,112,0,1,71.59 +64,345,247,98,0,2,83.11 +65,681,566,115,0,1,31.51 +66,73,23,50,0,10,83.1 +67,651,541,110,0,1,0.0 +68,10,0,10,0,69,82.55 +69,636,525,111,0,1,82.62 +70,656,542,114,0,1,73.12 +71,372,272,100,0,2,83.48 +72,678,566,112,0,1,82.13 +73,638,524,114,0,1,82.92 +74,685,568,117,0,1,57.71 +75,201,116,85,0,3,72.67 +76,344,250,94,0,2,72.17 +77,345,249,96,0,2,64.75 +78,261,169,92,0,3,19.15 +79,47,9,38,0,15,83.48 +80,660,551,109,0,1,82.18 +81,634,521,113,0,1,51.09 +82,137,70,67,0,5,69.58 +83,309,215,94,0,2,83.53 +84,686,573,113,0,1,82.84 +85,682,565,117,0,1,71.12 +86,322,229,93,0,2,83.28 +87,676,563,113,0,1,68.62 +88,325,223,102,0,2,83.16 +89,689,573,116,0,1,83.31 +90,695,579,116,0,1,73.15 +91,324,237,87,0,2,72.11 +92,337,243,94,0,2,63.51 +93,222,141,81,0,3,83.09 +94,686,570,116,0,1,71.79 +95,351,252,99,0,2,84.66 +96,717,607,110,0,1,83.28 +97,664,553,111,0,1,21.74 +98,23,5,18,0,37,56.91 +99,181,103,78,0,4,70.62 diff --git a/graphs/objects_in_cache_over_time.pdf b/graphs/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d97a57b82dd58dc3a54f02c728f7a4af7940f671 GIT binary patch literal 20395 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 H$YA_GAgY=1 literal 0 HcmV?d00001 diff --git a/logs/export.csv b/logs/export.csv new file mode 100644 index 0000000..662cdc8 --- /dev/null +++ b/logs/export.csv @@ -0,0 +1,100 @@ +,access_count,hits,misses,mu,lambda,hit_rate +1,1053,968,85,2.7571868901824006,1,68.51 +2,362,248,114,7.502069037353548,3,90.93 +3,1047,952,95,3.526951261967702,1,98.1 +4,1107,1086,21,1.2188436978830846,1,78.25 +5,538,421,117,6.80925066316451,2,92.7 +6,1124,1042,82,2.5939961146634403,1,55.61 +7,205,114,91,9.464127259176228,5,85.77 +8,1075,922,153,9.585357193023286,1,86.16 +9,1084,934,150,9.233779511984036,1,89.6 +10,1106,991,115,4.331428302298999,1,95.9 +11,536,514,22,1.1391095487598069,2,85.53 +12,1009,863,146,9.354867063289529,1,88.57 +13,1076,953,123,4.8536573348558285,1,86.6 +14,1097,950,147,9.699893371393026,1,76.43 +15,543,415,128,9.672579793803276,2,76.4 +16,517,395,122,8.677085099206241,2,90.62 +17,1087,985,102,3.6500400286262713,1,89.63 +18,1090,977,113,4.465879557417328,1,72.41 +19,377,273,104,8.660230043651712,3,90.34 +20,1128,1019,109,3.852298046406499,1,93.49 +21,1137,1063,74,2.5254347201748324,1,87.43 +22,1042,911,131,6.0112113621251515,1,86.9 +23,1137,988,149,9.425392967447028,1,77.88 +24,547,426,121,7.264268170074757,2,88.12 +25,1027,905,122,6.1305505308042845,1,95.64 +26,1054,1008,46,1.8745884439369167,1,87.89 +27,1140,1002,138,6.535065040292528,1,53.92 +28,204,110,94,9.91048465093837,5,94.17 +29,1080,1017,63,2.260756137128716,1,89.02 +30,1138,1013,125,5.664966871273631,1,86.26 +31,1048,904,144,8.8963576473516,1,64.55 +32,268,173,95,7.66691755978784,4,86.83 +33,1071,930,141,7.273141668957412,1,62.7 +34,252,158,94,7.322356755883983,4,90.78 +35,1085,985,100,4.2354203609777965,1,91.22 +36,1059,966,93,3.64232659838044,1,87.16 +37,1067,930,137,8.284250399306622,1,69.41 +38,353,245,108,8.291020552112627,3,43.75 +39,128,56,72,8.803650867220934,8,86.82 +40,1077,935,142,9.219164973008242,1,65.84 +41,281,185,96,5.60208158974844,4,63.97 +42,247,158,89,5.513646652184796,4,78.62 +43,594,467,127,8.184656610700976,2,88.03 +44,1145,1008,137,6.849675376999887,1,88.24 +45,1131,998,133,7.31770189531933,1,86.75 +46,1087,943,144,8.16213402492491,1,46.15 +47,130,60,70,9.010048076358096,10,90.53 +48,1067,966,101,4.041956411663822,1,89.66 +49,1102,988,114,4.380246573759496,1,95.39 +50,1106,1055,51,1.845837458567821,1,57.4 +51,223,128,95,6.204521268965566,5,89.08 +52,119,106,13,1.3234804641706788,9,88.1 +53,1101,970,131,5.190382163192141,1,87.69 +54,1064,933,131,5.883801712368189,1,89.78 +55,1067,958,109,3.5788712691545594,1,88.12 +56,1094,964,130,6.317499345121097,1,97.01 +57,1038,1007,31,1.2745022494514449,1,67.12 +58,73,49,24,1.3361336987429298,17,77.12 +59,555,428,127,8.403405045936925,2,89.38 +60,1073,959,114,4.241715772701366,1,36.0 +61,50,18,32,2.143544613866963,26,87.54 +62,1027,899,128,5.700189340493239,1,86.95 +63,1050,913,137,7.9299419778874976,1,85.48 +64,544,465,79,2.9423892474715885,2,88.14 +65,1071,944,127,6.606014282371002,1,73.28 +66,116,85,31,1.768127184943912,10,96.89 +67,1094,1060,34,1.4651354905174694,1,20.0 +68,10,2,8,5.782191684113332,69,88.47 +69,1110,982,128,5.865716094490959,1,87.52 +70,1026,898,128,6.736869113483859,1,78.7 +71,554,436,118,7.534822003503954,2,87.38 +72,1125,983,142,9.782668715162812,1,88.33 +73,1088,961,127,5.646703134710758,1,90.57 +74,1082,980,102,3.9066082564712135,1,71.39 +75,346,247,99,8.156675752918332,3,82.14 +76,515,423,92,3.437490261358668,2,80.9 +77,602,487,115,4.950742786350725,2,89.05 +78,347,309,38,1.7061074320803935,3,69.09 +79,55,38,17,1.2281566907391177,15,85.73 +80,1093,937,156,9.663835732101326,1,85.45 +81,1010,863,147,8.523821084609853,1,55.03 +82,189,104,85,7.263767854843282,5,82.06 +83,602,494,108,4.680576499728429,2,92.34 +84,1044,964,80,2.559648880637612,1,93.88 +85,1078,1012,66,2.4079333840397745,1,83.67 +86,539,451,88,3.252186083481358,2,87.74 +87,1028,902,126,5.943039982355084,1,77.05 +88,549,423,126,7.431363304300561,2,87.84 +89,1069,939,130,6.941776390459581,1,91.73 +90,1113,1021,92,3.5194050725134858,1,76.14 +91,528,402,126,9.593787525968747,2,76.1 +92,544,414,130,7.641072250261916,2,70.49 +93,349,246,103,5.989186472602606,3,88.21 +94,1077,950,127,6.5054867161091705,1,79.77 +95,519,414,105,4.776400561850109,2,90.72 +96,1035,939,96,3.229578905510417,1,90.06 +97,1066,960,106,4.2037541078613545,1,27.59 +98,29,8,21,7.820614994179322,37,92.96 +99,270,251,19,1.1295413976678028,4,88.95 diff --git a/note.md b/note.md index 4e1491d..ba5a339 100644 --- a/note.md +++ b/note.md @@ -42,38 +42,45 @@ miss requests and cache updates should not go over the bandwidth ### Two versions -1. +- [x] Default -- Do Refresh -- Do Request + - Do Refresh + - Do Request -2. +- [x] No Refresh -- Just Request -- No Refresh + - Just Request + - No Refresh -3. +- [x] Infinite TTL -- LRU -- Infinite TTL -- No Refresh + - LRU + - Infinite TTL + - No Refresh -4. +- [x] Random Eviction -- Random eviction -- Regular TTL -- With Refresh - -5. - -- Random eviction -- Regular TTL -- Without Refresh + - Random eviction + - Regular TTL + - With Refresh +- [x] Random Eviction w/o Refresh + - Random eviction + - Regular TTL + - No Refresh +| Name | Cache Capacity | MAX_REFRESH_RATE | cache_type | CACHE_TTL | +| -------------------- | -------------------- | ---------------- | ------------------------- | --------- | +| Default | DATABASE_OBJECTS | 1< | CacheType.LRU | 5 | +| No Refresh | DATABASE_OBJECTS | 0 | CacheType.LRU | 5 | +| Infinite TTL | DATABASE_OBJECTS / 2 | 0 | CacheType.LRU | 0 | +| Random Eviction (RE) | DATABASE_OBJECTS / 2 | 1< | CacheType.RANDOM_EVICTION | 5 | +| RE without Refresh | DATABASE_OBJECTS / 2 | 0 | CacheType.RANDOM_EVICTION | 5 | ### Runtime CPU times: user 3min 46s, sys: 43 s, total: 4min 29s Wall time: 4min 29s -for ACCESS_COUNT_LIMIT = 10_000 # Total time to run the simulation \ No newline at end of file +for ACCESS_COUNT_LIMIT = 10_000 # Total time to run the simulation + +## Notes 11/27/2024 diff --git a/objects_in_cache_over_time.pdf b/objects_in_cache_over_time.pdf new file mode 100644 index 0000000000000000000000000000000000000000..64600b336921a2b13acd1da1c711397c3bb2e7a3 GIT binary patch literal 18713 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 literal 0 HcmV?d00001