2_CacheMemoryHierarchy/Cap_Cache_Mem_Hierarchy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tema: Jerarquía de Memoria y Caches\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escuela de Ingeniería Eléctrica "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Universidad de Costa Rica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### IE052 Estructuras de computadoras digitales II"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Brown, Belinda B61254"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esquivel, Brandon B52571 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenido"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ol>\n",
    "<li>Resumen</li>\n",
    "<li>Definiciones</li>\n",
    "<li>Localización</li>\n",
    "<li>Consideraciones:</li>\n",
    "- Colocación del bloque <br>\n",
    "- Identificación del bloque <br>\n",
    "<li>Ejemplos</li>\n",
    "<li>Propuesta de evaluación</li>\n",
    "<li>Referencias Bibliográficas</li>\n",
    "</ol>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Resumen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este documento forma parte de un cuaderno colaborativo, en este caso se analiza el tema de Jerarquía de memoria y caches. Es importante cosiderar que toda la información proviene mayoritamiente del libro *Computer Architecture A quantitative approach (5TH Edition)* [2],  así como del material brindado en clase."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Definiciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jerarquía de memoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se define como la forma en la que la memoria de la computadora está orgnizada, esta organización se realiza por medio de niveles dado que al tener niveles de memoria se logra mejorar el rendimiento de la misma. La importancia de la jerarquía se debe a que una memoria tiene capacidad de almacenamiento, una velocidad relacionada con el microprocesador dado que las instrucciones que se ejecutan implican cálculos y decisiones, así como el costo por bit. <br> <br> Es importante tomar en cuenta las siguientes relaciones: \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Relaciones | generales   |\n",
    "|------|------|\n",
    "|  *Mayor*   |  *Menor*  |\n",
    "|   Capacidad  | Costo por bit |\n",
    "|   Costo  | Tiempo |\n",
    "|   Capacidad  | Velocidad | "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente tabla es producto de la relación de la información proveniente del libro *Computer Architecture A quantitative approach (5TH Edition)* [2]."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Jerarquía de | memoria | de un servidor  |\n",
    "|------|------|------|\n",
    "| *Nivel de memoria* | *Capacidad* | *Velocidad* |\n",
    "| Registros del CPU | 1000 bytes | 300 ps |\n",
    "| Caché L1 | 64 kB | 1 ns |\n",
    "| Caché L2 | 256 kB | 3 ns  a 10 ns|\n",
    "| Caché L3 | 2 MB a 4 MB | 10 ns  a 20 ns|\n",
    "| Referencia de memoria | 4 GB a 16 GB | 50 ns  a 100 ns|\n",
    "| Disco Duro | 4 TB a 16 TB | 5 ms  a 10 ms|\n",
    "\n",
    "<br>\n",
    "\n",
    "| Jerarquía de | memoria de un | dispositivo móvil personal  |\n",
    "|------|------|------|\n",
    "| *Nivel de memoria* | *Capacidad* | *Velocidad* |\n",
    "| Registros del CPU | 500 bytes | 500 ps |\n",
    "| Caché L1 | 64 kB | 2 ns |\n",
    "| Caché L2 | 256 kB | 10 ns  a 20 ns|\n",
    "| Referencia de memoria | 256 MB a 512 MB | 50 ns  a 100 ns|\n",
    "| Disco Duro | 4 GB a 8 GB | 25 us  a 50 us|\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Memoria Caché"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es una memoria temporal, la cual es de rápido acceso. Esta memoria guarda los datos que fueron requeridos, o bien, utilizados recientemente. Es importante considerar los tiempos mostrados en las tablas anteriores dado que existen diferentes niveles por lo que la velocidad de acceso es distinta. \n",
    "\n",
    "<br>\n",
    "\n",
    "Importante considerar de manera general siguiente flujo de acceso: \n",
    "\n",
    "<br>\n",
    "\n",
    "~~~~~\n",
    "CPU -> Nivel 1 (L1) Caché -> Nivel 2 (L2) Caché -> Nivel 3 (L3) Caché -> Memoria principal ...\n",
    "CPU <-                    <-                    <-                    <- Memoria principal ...                 \n",
    "~~~~~\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Localización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de localidad de referencia:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante clarificar la Ley de Amdahl la cual dicta el siguiente estatuto:\n",
    "\n",
    "~~~\n",
    "\"La mejora obtenida en el rendimiento de un sistema debido a la alteración de uno de sus componentes está limitada por la fracción de tiempo que se utiliza dicho componente\" - Ley de Amdahl [1]\n",
    "~~~\n",
    "\n",
    "Matemáticamente expresado como:\n",
    "\n",
    "~~~~\n",
    "              T_ex_new = T_ex_old * ( (1 - Frac_opt) + Frac_opt/Ac_op )\n",
    "\n",
    "~~~~\n",
    "\n",
    "\n",
    "```\n",
    "              Ac_global = T_ex_old/T_ex_new\n",
    "\n",
    "```\n",
    "\n",
    "\n",
    "* T_ex_new:  Tiempo de ejecución nuevo\n",
    "\n",
    "* T_ex_old:  Tiempo de ejecución antiguo\n",
    "\n",
    "* Frac_opt:  Fracción mejorada\n",
    "\n",
    "* Ac_op:     Aceleración mejorada\n",
    "\n",
    "* Ac_op:     Aceleración global\n",
    "\n",
    "\n",
    "\n",
    "La localidad de referencia es alusivo de en dónde se encuentra lo que se requiere para poder proceder con una operación. Los tipos más conocidos de localidad son temporal y espacial, sin embargo existe uno adicional conocido como localidad algorítmica. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Obtener_Ac_global(Fra_op, Ac_op):\n",
    "    \n",
    "    T_ex_new = 1 * ( (1 - Fra_op) + Fra_op/Ac_op )\n",
    "    R_Ac_global = 1/T_ex_new\n",
    "\n",
    "    return R_Ac_global\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Localidad Temporal  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un punto de referencia significa la ubicación específica de memoria en donde se encuentra la información que se necesita, como tendencia se espera que que esta mismo punto vuelva a ser requerido conforme las operaciones transcurren. Temporal quiere decir que depende del tiempo, una localidad temporal tiende a funcionar para almacenar la información con tiende a ser solicitada con mayor frecuencia con el fn de facilidarla con una mayor velocidad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Localidad Espacial "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta tipo de localidad hace referencia al hecho de que aquellas direcciones que se encuentran juntas o cerca tienden a ser requeridas en el futuro al mismo tiempo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Localidad Algorítmica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este tipo de localidad surge del comportamiento del algoritmo, considera cuando el programa accede de manera repetida la data o bien ejecuta bloques de código los cuales so distribuidos de de diversa manera en el espacio de memoria."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Consideraciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dentro de las consideraciones a tomar se tienen las siguientes: ¿Dónde coloca el bloque? y ¿Cómo se identifica?. Lo cual será explicado a continuación:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Colocación del bloque "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para esto se utiliza una función de Hash locual significa que una función cualquier es utilizada para mapear datos de gran tamaño arbitario a uno de menor tamaño. Para las caches lo que se realiza es un mapeo de la dirrección a un set de índices. \n",
    "\n",
    "<br>\n",
    "Se considera una función de mapeo de modo que la dirección del bloque viene dada por el modo del número de bloques o bien cantidad de sets que se poseen en la cache. Dicho de otra forma el bloque donde coloco la información viene dado por tomar la dirección que solicta el CPU y hacerle el modulo entre la cantidad de bloques totales de la cache:\n",
    "\n",
    "~~~~\n",
    "               Loc_Block = Dir_CPU % Total_Cache\n",
    "\n",
    "Siendo esto:\n",
    "\n",
    "                 &.##    =    Dir_CPU  /    Total_Cache \n",
    "                   @     =    &        *    Total_Cache \n",
    "               Loc_Block =    Dir_CPU  -       @ \n",
    "~~~~\n",
    "\n",
    "* Loc_Block: Bloque donde coloca la información. \n",
    "\n",
    "<br>\n",
    "\n",
    "* Dir_CPU: Dirección solicidada por el CPU.\n",
    "\n",
    "<br>\n",
    "\n",
    "* Total_Cache: Cantidad de bloques totales de la caché\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def modulo(dir_cpu, total_cache):\n",
    "    value_just_hole_part = dir_cpu // total_cache \n",
    "    another = value_just_hole_part * total_cache \n",
    "    loc_block = dir_cpu - another\n",
    "    return loc_block\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dentro de esto, se puede considerar que existe fucniones de mapeo que son totalmente asociativas, mapeo directo y de set asociativo. De forma que totalmente asociativo refiere a que el bloque puede ir a cualquier dirección de la caché, el mapeo directo es como el ejemplo mencionado y el set asociativo funciona como el ejemplo mencionado solo que en vez de ir a una solo bloque se refiere a un set de bloques, de decir, un grupo de bloques a asociados a un índice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Por ejemplo:** \n",
    "\n",
    "Si el CPU solciita la dirección 8  y se poseen 4 bloques totales en la cache, la localización de esta dirección sería igual a:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La dirección de bloque donde se coloca la información es el:    1\n"
     ]
    }
   ],
   "source": [
    "direccion = modulo(9, 2)\n",
    "\n",
    "\n",
    "print(\"La dirección de bloque donde se coloca la información es el:   \", direccion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Identificación del bloque "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta sección, se analiza como se puede indentificar un bloque en caché. La principl idea es saber si se encuentra o no, para esto se utiliza lo que es el ínidce y el tag. El tag se encarga de chequear lo bits más significativos.\n",
    "\n",
    "\n",
    "De modo general se tiene que:\n",
    "\n",
    "~~~\n",
    "\n",
    "|          Dirección de memoria          |\n",
    "\n",
    "|  Dirección del bloque |      Offset    |\n",
    "\n",
    "|    Tag    |    Index  |      Offset    |\n",
    "\n",
    "~~~\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tome en cuenta los siguientes ejemplos tomados como referencia del libro [2] solo que se ajustaron los valores con el fin de que se resuelvan a modo práctica.\n",
    "\n",
    "**Ejemplo extra 1:**\n",
    "\n",
    "Se considera una  mejora que corra once veces más rápido que la máquina original, pero sólo es utilizable el 50 por 100 del tiempo. ¿Cuál es la aceleración global lograda al incorporar la mejora?\n",
    "\n",
    "\n",
    "\n",
    "*Respuesta:*\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La aceleración global lograda es de:      1.8333333333333335\n"
     ]
    }
   ],
   "source": [
    "aceleracion_g = Obtener_Ac_global(0.5, 11)\n",
    "\n",
    "print(\"La aceleración global lograda es de:     \", aceleracion_g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo extra 2:**\n",
    "\n",
    "Supongamos que se quiere mejorar la velocidad de la CPU de nuestra máquina en un factor de siete (sin afectar al rendimiento de E/S) por siete veces el coste. Supongamos también que la CPU se utiliza el 70 por 100 del tiempo, y que el tiempo restante la CPU está esperando las E/S. Si la CPU supone un tercio del coste total del computador, ¿el incremento de la velocidad de la CPU en un factor de siete es una buena inversión desde un punto de vista coste/rendimiento?\n",
    "\n",
    "Calculando la aceleración:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La aceleración global lograda es de:      2.5\n"
     ]
    }
   ],
   "source": [
    "aceleracion_g = Obtener_Ac_global(0.7, 7)\n",
    "\n",
    "print(\"La aceleración global lograda es de:     \", aceleracion_g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se sigue que para el análisis de inversión:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "La inversión necesaria para llevar a cabo el proyecto sería de:      2.9999999999999996\n"
     ]
    }
   ],
   "source": [
    "Inversion = 2/3 * 1 + 1/3 * 7 \n",
    "\n",
    "print(\"La inversión necesaria para llevar a cabo el proyecto sería de:     \", Inversion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "R/ Considerando que la inversión es mayor a la mejora, se concluye que no es una buena opción desde el punto de vista coste/rendimiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Propuesta de evaluación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio 1:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considere el siguiente ejercicio como una pregunta abierta de la cual se espera que a partir de la información presenta se pueda tomar una decisión. \n",
    "\n",
    "Gabi es una dueña de la empresa G+T, dadas las funciones que realiza Gabi en la empresa debe de cambiar de computadora. Pero ella no comprende muy bien ciertas especificaciones de la ficha de venta de la computadora, en especial las relativas a memoria. \n",
    "\n",
    "**Pregunta** \n",
    "\n",
    "Realice un ejemplo corto con el fin de explicarle a Gabi las diferenetes especificaciones que se relacionan con memoria en una computadora. \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio 2:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pregunta**\n",
    "\n",
    "Calcule el bloque donde se coloca la información, si la caché del servidor es la L2 y siguiendo la analogía de la explicación de colocación del bloque en su primer paso ( &.##    =    Dir_CPU  /  Total_Cache ) da 4.59."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias Bibliográficas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] Ortega J., Anguita, M., y Prieto,A.(2005). Arquitectura de Computadores.España: Ed. Paraninfo S.A./ Arquitectura de Computadores\n",
    "\n",
    "[2] Computer Organization and Design: The Hardware/Software Interface 5th Edition · Patterson, David A.; Hennessy, John L. ELSEVIER / 978-0-12-407726"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}