age_cache_simulation/aoi_cache_simulation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "920665b8-9204-42df-ab59-1b9324387750",
   "metadata": {},
   "outputs": [],
   "source": [
    "import simpy\n",
    "import random\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\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",
    "\n",
    "\n",
    "# Set random seeds\n",
    "random.seed(SEED)\n",
    "np.random.seed(SEED)\n",
    "\n",
    "# Initialize simulation environment\n",
    "env = simpy.Environment()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5cea042f-e9fc-4a1e-9750-de212ca70601",
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "\n",
    "\n",
    "    def get_object(self, obj_id):\n",
    "        # print(f\"[{env.now:.2f}] Database: Fetched {self.data.get(obj_id, 'Unknown')} for ID {obj_id}\")\n",
    "        return self.data.get(obj_id, None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "499bf543-b2c6-4e4d-afcc-0a6665ce3ae1",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cache:\n",
    "    def __init__(self, env, db):\n",
    "        self.env = env\n",
    "        self.db = db\n",
    "        self.storage = {}  # Dictionary to store cached objects\n",
    "        self.ttl = {}      # Dictionary to store TTLs\n",
    "        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.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",
    "            # 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",
    "            self.access_count[obj_id] += 1\n",
    "        else:\n",
    "            # Cache miss: increment miss count\n",
    "            self.misses[obj_id] += 1\n",
    "            self.access_count[obj_id] += 1\n",
    "            \n",
    "            # Fetch the object from the database if it’s not in cache\n",
    "            obj = self.db.get_object(obj_id)\n",
    "            \n",
    "            # If the cache is full, evict the oldest object\n",
    "            if len(self.storage) >= CACHE_CAPACITY:\n",
    "                self.evict_oldest()\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",
    "            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",
    "\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",
    "        del self.storage[oldest_id]\n",
    "        del self.ttl[oldest_id]\n",
    "        del self.age[oldest_id]\n",
    "        \n",
    "    def refresh_object(self, obj_id):\n",
    "        \"\"\"Refresh the object from the database to keep it up-to-date.\"\"\"\n",
    "        obj = self.db.get_object(obj_id)\n",
    "        self.storage[obj_id] = obj\n",
    "        self.ttl[obj_id] = env.now + CACHE_TTL\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",
    "            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",
    "                \n",
    "    def record_cache_state(self):\n",
    "        \"\"\"Record the current cache state (number of objects in cache) over time.\"\"\"\n",
    "        self.cache_size_over_time.append((env.now, len(self.storage)))\n",
    "        self.cache_next_request_over_time.append((env.now, self.db.next_request.copy()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7286d498-aa6c-4efb-bb28-fe29736eab64",
   "metadata": {},
   "outputs": [],
   "source": [
    "def age_cache_process(env, cache):\n",
    "    \"\"\"Process that ages cache objects over time, removes expired items, and refreshes based on object-specific intervals.\"\"\"\n",
    "    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",
    "        cache.record_cache_state()  # Record cache state at each time step\n",
    "        yield env.timeout(1)  # Run every second\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "687f5634-8edf-4337-b42f-bbb292d47f0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def client_request_process(env, cache, event):\n",
    "    \"\"\"Client process that makes requests for objects from the cache.\"\"\"\n",
    "    lowest_lambda_object = max(cache.db.lambda_values.items(), key=lambda x: x[1])\n",
    "    lowest_lambda_object = [lowest_lambda_object] if isinstance(lowest_lambda_object, int) else lowest_lambda_object\n",
    "    while True:\n",
    "        obj_id, next_request = min(cache.db.next_request.items(), key=lambda x: x[1])\n",
    "        yield env.timeout(next_request - env.now)\n",
    "        if env.now >= next_request:\n",
    "            # print(f\"[{env.now:.2f}] Client: Requesting object {obj_id}\")\n",
    "            cache.get(obj_id)\n",
    "            \n",
    "            # print(f\"[{env.now:.2f}] Client: Schedule next request for {obj_id}\")\n",
    "            next_request = env.now + np.random.exponential(cache.db.lambda_values[obj_id])\n",
    "            cache.request_log[obj_id].append(next_request)\n",
    "            cache.db.next_request[obj_id] = next_request\n",
    "        if all(cache.access_count[obj] >= ACCESS_COUNT_LIMIT for obj in lowest_lambda_object):\n",
    "            event.succeed()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c8516830-9880-4d9e-a91b-000338baf9d6",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Instantiate components\n",
    "db = Database()\n",
    "cache = Cache(env, db)\n",
    "stop_event = env.event()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ba34b36-9ed5-4996-9600-11dfd25d8e60",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# Start processes\n",
    "env.process(age_cache_process(env, cache))\n",
    "env.process(client_request_process(env, cache, stop_event))\n",
    "\n",
    "# Run the simulation\n",
    "env.run(until=stop_event)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3b6f7c1f-ea54-4496-bb9a-370cee2d2751",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Calculate and print hit rate and average age for each object\n",
    "for obj_id in range(1, CACHE_CAPACITY + 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}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01f8f9ee-c278-4a22-8562-ba02e77f5ddd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract recorded data for plotting\n",
    "times, cache_sizes = zip(*cache.cache_size_over_time)\n",
    "\n",
    "# Plot the cache size over time\n",
    "plt.figure(figsize=(30, 5))\n",
    "plt.plot(times, cache_sizes, label=\"Objects in Cache\")\n",
    "plt.xlabel(\"Time (s)\")\n",
    "plt.ylabel(\"Number of Cached Objects\")\n",
    "plt.title(\"Number of Objects in Cache Over Time\")\n",
    "plt.legend()\n",
    "plt.grid(True)\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,
   "id": "f30a0497-9b2e-4ea9-8ebf-6687de19aaa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "# Count occurrences of each number\n",
    "count = Counter(list(db.lambda_values.values()))\n",
    "\n",
    "# Separate the counts into two lists for plotting\n",
    "x = list(count.keys())  # List of unique numbers\n",
    "y = list(count.values())  # List of their respective counts\n",
    "\n",
    "# Plot the data\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.bar(x, y, color='skyblue')\n",
    "\n",
    "# Adding labels and title\n",
    "plt.xlabel('Number')\n",
    "plt.ylabel('Occurrences')\n",
    "plt.title('Occurance of each lambda in db')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00a12eea-c805-4209-9143-48fa65619873",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "# Count occurrences of each number\n",
    "count = Counter(np.array(list(db.mu_values.values())).round(0))\n",
    "\n",
    "# Separate the counts into two lists for plotting\n",
    "x = list(count.keys())  # List of unique numbers\n",
    "y = list(count.values())  # List of their respective counts\n",
    "\n",
    "# Plot the data\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.bar(x, y, color='skyblue')\n",
    "\n",
    "# Adding labels and title\n",
    "plt.xlabel('Number')\n",
    "plt.ylabel('Occurrences')\n",
    "plt.title('Occurance of each mu in db (rounded)')\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adbfeb40-76bd-4224-ac45-65c7b2b2cb7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_requests(object_id: int):\n",
    "    mu = db.mu_values[object_id]\n",
    "    lmb = db.lambda_values[object_id]\n",
    "    rq_log = np.array(cache.request_log[object_id])\n",
    "    df = rq_log[1:] - rq_log[:-1]\n",
    "    pd.DataFrame(df, columns=[f\"{object_id}, mu:{mu:.2f}, lambda: {lmb:.2f}\"]).plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f550686-3463-4e50-be83-ceafb27512b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_rate(object_id: int):\n",
    "    # Calculate time intervals between consecutive events\n",
    "    intervals = np.diff(np.array(cache.request_log[object_id]))  # Differences between each event time\n",
    "    \n",
    "    # Calculate the rate per second for each interval\n",
    "    rates = 1 / intervals  # Inverse of the time interval gives rate per second\n",
    "    \n",
    "    # Optional: Calculate the average event rate over all intervals\n",
    "    average_rate = np.mean(rates)\n",
    "    print(\"Average event rate per second:\", average_rate)\n",
    "    print(\"The mu is: \", db.lambda_values[object_id])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f246dc61-f131-4d17-80c9-ccff1c4fec64",
   "metadata": {},
   "outputs": [],
   "source": [
    "[(print_rate(i),plot_requests(i)) for i in range(1,10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2d18372-cdba-4151-ae32-5bf45466bf94",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "graphs",
   "language": "python",
   "name": "graphs"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}