XX_memory_management.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Python memeory management\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## C memory management\n",
    "\n",
    "Static vs Dynamic memory alloccation.\n",
    "\n",
    "Static:\n",
    "- You know all amount of memory you need in advance\n",
    "- So you allocate it befor eprogram execution\n",
    "\n",
    "Dynamic:\n",
    "- You dynamically demand memory for the new objects\n",
    "- Allocated memory can be released and reused.\n",
    "\n",
    "\n",
    "You allocate new memory from Operation System by usinbg `malloc` method or similar\n",
    "and `free` to release.\n",
    "\n",
    "### Memory leak - when you allocate memory, but forgot to release it.\n",
    "So you don't have any object that uses it, but OS still thinks that you need it. If it\n",
    "continue to happen your app will eat all available memory. And OS probably will kill it.\n",
    "\n",
    "### Life is too short to know C very well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Python memory manager\n",
    "\n",
    "In python you don't need to bother with memory allocation and releasing. There is\n",
    "python memory manager that does it for you in the optimal way, so you don't need to think\n",
    "about it.\n",
    "\n",
    "Allocation of memory for the object is not a problem, but it's much harder to figure\n",
    "out when to release it.\n",
    "\n",
    "Python has two mechanisms of memory management for the objects:\n",
    "\n",
    "### Reference counter\n",
    "\n",
    "The simplest mechanism that you can came up to is to: count amount of references to\n",
    "the object and if it's = 0 - it's no longer accessible and hence we can release memory.\n",
    "\n",
    "How does it look?\n",
    "\n",
    "This is PyObject declaration, which is base structure for all other types of objects like int, list, function etc.\n",
    "\n",
    "https://docs.python.org/dev/c-api/structures.html#c.PyObject\n",
    "\n",
    "https://github.com/python/cpython/blob/master/Include/object.h#L105\n",
    "\n",
    "```\n",
    "typedef struct _object {\n",
    "    _PyObject_HEAD_EXTRA\n",
    "    Py_ssize_t ob_refcnt;\n",
    "    PyTypeObject *ob_type;\n",
    "} PyObject;\n",
    "```\n",
    "\n",
    "Every object in python contains `ob_refcnt`\n",
    "\n",
    "And you can see how this counter is being incremented or decremented with C function\n",
    "`Py_INCREF`, `Py_DECREF`\n",
    "\n",
    "```\n",
    "static inline void _Py_INCREF(PyObject *op)\n",
    "{\n",
    "#ifdef Py_REF_DEBUG\n",
    "    _Py_RefTotal++;\n",
    "#endif\n",
    "    op->ob_refcnt++;\n",
    "}\n",
    "\n",
    "#define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op))\n",
    "```\n",
    "\n",
    "\n",
    "Here is the example for  `list.append(v)`\n",
    "\n",
    "https://github.com/python/cpython/blob/master/Objects/listobject.c#L304\n",
    "\n",
    "```\n",
    "static int\n",
    "app1(PyListObject *self, PyObject *v)\n",
    "{\n",
    "    Py_ssize_t n = PyList_GET_SIZE(self);\n",
    "\n",
    "    assert (v != NULL);\n",
    "    assert((size_t)n + 1 < PY_SSIZE_T_MAX);\n",
    "    if (list_resize(self, n+1) < 0)\n",
    "        return -1;\n",
    "\n",
    "    Py_INCREF(v);\n",
    "    PyList_SET_ITEM(self, n, v);\n",
    "    return 0;\n",
    "}\n",
    "```\n",
    "\n",
    "So in this chunk of the code when we add new object `v` into the list we increment\n",
    "amount of references to the object `v`.\n",
    "\n",
    "Same think is happens when we create new variables, send object as function argument,\n",
    "or when function finished the execution and we destroy to scope and etc.\n",
    "\n",
    "This is the code for `_Py_DECREF`\n",
    "\n",
    "https://github.com/python/cpython/blob/master/Include/object.h#L431\n",
    "\n",
    "```\n",
    "static inline void _Py_DECREF(\n",
    "#ifdef Py_REF_DEBUG\n",
    "    const char *filename, int lineno,\n",
    "#endif\n",
    "    PyObject *op)\n",
    "{\n",
    "#ifdef Py_REF_DEBUG\n",
    "    _Py_RefTotal--;\n",
    "#endif\n",
    "    if (--op->ob_refcnt != 0) {\n",
    "#ifdef Py_REF_DEBUG\n",
    "        if (op->ob_refcnt < 0) {\n",
    "            _Py_NegativeRefcount(filename, lineno, op);\n",
    "        }\n",
    "#endif\n",
    "    }\n",
    "    else {\n",
    "        _Py_Dealloc(op);\n",
    "    }\n",
    "}\n",
    "```\n",
    "\n",
    "As soon as we have 0 reference counter we deallocate memory immediately and we\n",
    "also decrease amount of references to all other objects that current one referenced to.\n",
    "So it deletes all objects recursively if necessary."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "You can check reference count in the python using `sys.getrefcount`,\n",
    "but keep in mind that in jupyter-notebook or ipython it will show other numbers, cause that environments\n",
    "does a lot of additional things. So check it in pure python interpreter!\n",
    "\n",
    "And remember that `sys.getrefcount` function call also increased amount of references\n",
    "to the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "a = 1000\n",
    "print(sys.getrefcount(a))\n",
    "b = [1, 2, a]\n",
    "print(sys.getrefcount(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Quick knowledge checking, what value you expect in this case?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "c = 3\n",
    "print(sys.getrefcount(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Surprised? Check 02_int_caching topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "So Reference counter is super efficient mechanism! It happens only when amount of\n",
    "references are changed and only for the that specific objects.\n",
    "\n",
    "But it cant handle some cases =\\"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Cyclic reference problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "d = []  # 1 reference to list1: variable d\n",
    "e = [d]  # 1 reference to list2: variable e; 2 references to list1: variable d and list2\n",
    "d.append(e) # 2 references to list2: variable e and list1\n",
    "\n",
    "del d, e  # deleting variables\n",
    "# 1 reference to list1: list2\n",
    "# 1 reference to list2: list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Garbage collector\n",
    "\n",
    "### Mark and Sweep algorithm\n",
    "\n",
    "1. Build a graph from your entrypoint and mark all objects that are reachable from the entrypoint.\n",
    "2. Delete all unreachable objects.\n",
    "\n",
    "Python doesn't use it.\n",
    "\n",
    "### Generational Garbage collector\n",
    "\n",
    "Decrement reference counter of the objects from the same generation and if it's become 0 then they are unreachable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### When it starts?\n",
    "\n",
    "When amount of allocations of new objects more than de-allocations on 700.\n",
    "\n",
    "### Optimizing with generations\n",
    "\n",
    "There are 3 generations by default!\n",
    "\n",
    "Instead of checking all objects for cyclic references we check only objects from specific generation.\n",
    "\n",
    "- New objects go to generation 0.\n",
    "- If object survives garbage collection of his generation, it will be moved to the generation + 1, unless it's already\n",
    "in the last.\n",
    "- GC of generation 0 is triggered when there are `700` more allocations then de-allocations\n",
    "- GC of generation 1 is triggered when GC of generation 0 happened `10` times.\n",
    "- GC of generation 2 is triggered when GC of generation 1 happened `10` times, all objects survived stay here.\n",
    "\n",
    "So it 's the way - the most recent objects has more changes of being collected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "334"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.get_threshold()  # get current thresholds\n",
    "gc.set_threshold(1000, 20, 20)  # change them\n",
    "gc.disable()  # disable gc\n",
    "gc.enable()  # enable\n",
    "gc.collect(generation=2)  # forcibly trigger collection\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### What will happen if we disable GC?\n",
    "\n",
    "https://instagram-engineering.com/dismissing-python-garbage-collection-at-instagram-4dca40b29172\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Does all objects are tracked by garbage collection?\n",
    "\n",
    "No. It tracks only \"container\" objects. Objects that can contain reference to other objects, like list, class, dict.\n",
    "\n",
    "It doesn't track such objects as: int, str, float - because they can't make cyclic reference,\n",
    "they are handled by reference counter.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### Weak references\n",
    "\n",
    "Weakrefs - it's a references that does not stop object from being destroyed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.World object at 0x10b1b4040>\n",
      "<__main__.World object at 0x10b1b4040>\n"
     ]
    }
   ],
   "source": [
    "class World:\n",
    "    def __init__(self):\n",
    "        self.animals = []\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, world):\n",
    "        self.world = world\n",
    "\n",
    "world = World()\n",
    "a1 = Animal(world)\n",
    "world.animals.append(a1)\n",
    "\n",
    "print(a1.world)\n",
    "del world\n",
    "print(a1.world)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<weakref at 0x10f0081d0; to 'World' at 0x10f006640>\n",
      "<__main__.World object at 0x10f006640>\n",
      "<weakref at 0x10f0081d0; dead>\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "import weakref\n",
    "\n",
    "class World:\n",
    "    def __init__(self):\n",
    "        self.animals = []\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, world):\n",
    "        self.world = weakref.ref(world)\n",
    "\n",
    "world = World()\n",
    "a1 = Animal(world)\n",
    "world.animals.append(a1)\n",
    "\n",
    "print(a1.world)\n",
    "print(a1.world())\n",
    "del world\n",
    "print(a1.world)\n",
    "print(a1.world())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Study links:\n",
    "\n",
    "- https://pythonpedia.com/en/tutorial/2532/garbage-collection\n",
    "- https://scoutapm.com/blog/python-garbage-collection\n",
    "- https://towardsdatascience.com/memory-management-and-garbage-collection-in-python-c1cb51d1612c\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "todo\n",
    "\n",
    "`__del__` problem"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todo exercise / interview task\n"
   ]
  }
 ],
 "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.8.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}