Lec22.deadlock.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deadlock\n",
    "\n",
    "In concurrent computing, a deadlock is a state in which each **member of a group is waiting for another member, including itself**, to take action, such as sending a message or more commonly releasing a lock.\n",
    "\n",
    "* Conditions for deadlock\n",
    "  * Two/more parties\n",
    "  * Mutual exclusion\n",
    "  * Hold and wait\n",
    "  * No preemption\n",
    "  * Circular wait\n",
    "\n",
    "Visually, this is cycle(s) in a dependency graph.\n",
    "\n",
    "The simplest deadlock occurs with two processes and 2 resources.\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/2/28/Process_deadlock.svg/440px-Process_deadlock.svg.png\" width=256 />\n",
    "\n",
    "In the above, *Process 1* is holding onto resource 1 (R1) while waiting for R2. *Process 2* is holding onto R2 while waiting for R1. Each process waits for a resource that is never released, and never releases its current resource to the other.\n",
    "\n",
    "<img src=\"https://upload.wikimedia.org/wikipedia/commons/d/df/Two_processes%2C_two_resources.gif\" width=256 />\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that in the gif, the **deadlock is resolved by restarting the top process**.  This violates the \"hold and wait\" principle.\n",
    "\n",
    "## Creating a Deadlock in Ray\n",
    "\n",
    "We will build an example in Ray that pushes and pulls data betweeen two actors. This is designed to mimic MPI messaging, which is an awkward way to use Ray.\n",
    "\n",
    "But as we saw earlier, we can create deadlocks with remote procedure calls on Actors. Messages are a simpler example.\n",
    "\n",
    "Note that each Ray actor is a single-threaded process."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-12-05 16:55:52,819\tINFO worker.py:1528 -- Started a local Ray instance.\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "    <div style=\"margin-left: 50px;display: flex;flex-direction: row;align-items: center\">\n",
       "        <h3 style=\"color: var(--jp-ui-font-color0)\">Ray</h3>\n",
       "        <svg version=\"1.1\" id=\"ray\" width=\"3em\" viewBox=\"0 0 144.5 144.6\" style=\"margin-left: 3em;margin-right: 3em\">\n",
       "            <g id=\"layer-1\">\n",
       "                <path fill=\"#00a2e9\" class=\"st0\" d=\"M97.3,77.2c-3.8-1.1-6.2,0.9-8.3,5.1c-3.5,6.8-9.9,9.9-17.4,9.6S58,88.1,54.8,81.2c-1.4-3-3-4-6.3-4.1\n",
       "                    c-5.6-0.1-9.9,0.1-13.1,6.4c-3.8,7.6-13.6,10.2-21.8,7.6C5.2,88.4-0.4,80.5,0,71.7c0.1-8.4,5.7-15.8,13.8-18.2\n",
       "                    c8.4-2.6,17.5,0.7,22.3,8c1.3,1.9,1.3,5.2,3.6,5.6c3.9,0.6,8,0.2,12,0.2c1.8,0,1.9-1.6,2.4-2.8c3.5-7.8,9.7-11.8,18-11.9\n",
       "                    c8.2-0.1,14.4,3.9,17.8,11.4c1.3,2.8,2.9,3.6,5.7,3.3c1-0.1,2,0.1,3,0c2.8-0.5,6.4,1.7,8.1-2.7s-2.3-5.5-4.1-7.5\n",
       "                    c-5.1-5.7-10.9-10.8-16.1-16.3C84,38,81.9,37.1,78,38.3C66.7,42,56.2,35.7,53,24.1C50.3,14,57.3,2.8,67.7,0.5\n",
       "                    C78.4-2,89,4.7,91.5,15.3c0.1,0.3,0.1,0.5,0.2,0.8c0.7,3.4,0.7,6.9-0.8,9.8c-1.7,3.2-0.8,5,1.5,7.2c6.7,6.5,13.3,13,19.8,19.7\n",
       "                    c1.8,1.8,3,2.1,5.5,1.2c9.1-3.4,17.9-0.6,23.4,7c4.8,6.9,4.6,16.1-0.4,22.9c-5.4,7.2-14.2,9.9-23.1,6.5c-2.3-0.9-3.5-0.6-5.1,1.1\n",
       "                    c-6.7,6.9-13.6,13.7-20.5,20.4c-1.8,1.8-2.5,3.2-1.4,5.9c3.5,8.7,0.3,18.6-7.7,23.6c-7.9,5-18.2,3.8-24.8-2.9\n",
       "                    c-6.4-6.4-7.4-16.2-2.5-24.3c4.9-7.8,14.5-11,23.1-7.8c3,1.1,4.7,0.5,6.9-1.7C91.7,98.4,98,92.3,104.2,86c1.6-1.6,4.1-2.7,2.6-6.2\n",
       "                    c-1.4-3.3-3.8-2.5-6.2-2.6C99.8,77.2,98.9,77.2,97.3,77.2z M72.1,29.7c5.5,0.1,9.9-4.3,10-9.8c0-0.1,0-0.2,0-0.3\n",
       "                    C81.8,14,77,9.8,71.5,10.2c-5,0.3-9,4.2-9.3,9.2c-0.2,5.5,4,10.1,9.5,10.3C71.8,29.7,72,29.7,72.1,29.7z M72.3,62.3\n",
       "                    c-5.4-0.1-9.9,4.2-10.1,9.7c0,0.2,0,0.3,0,0.5c0.2,5.4,4.5,9.7,9.9,10c5.1,0.1,9.9-4.7,10.1-9.8c0.2-5.5-4-10-9.5-10.3\n",
       "                    C72.6,62.3,72.4,62.3,72.3,62.3z M115,72.5c0.1,5.4,4.5,9.7,9.8,9.9c5.6-0.2,10-4.8,10-10.4c-0.2-5.4-4.6-9.7-10-9.7\n",
       "                    c-5.3-0.1-9.8,4.2-9.9,9.5C115,72.1,115,72.3,115,72.5z M19.5,62.3c-5.4,0.1-9.8,4.4-10,9.8c-0.1,5.1,5.2,10.4,10.2,10.3\n",
       "                    c5.6-0.2,10-4.9,9.8-10.5c-0.1-5.4-4.5-9.7-9.9-9.6C19.6,62.3,19.5,62.3,19.5,62.3z M71.8,134.6c5.9,0.2,10.3-3.9,10.4-9.6\n",
       "                    c0.5-5.5-3.6-10.4-9.1-10.8c-5.5-0.5-10.4,3.6-10.8,9.1c0,0.5,0,0.9,0,1.4c-0.2,5.3,4,9.8,9.3,10\n",
       "                    C71.6,134.6,71.7,134.6,71.8,134.6z\"/>\n",
       "            </g>\n",
       "        </svg>\n",
       "        <table>\n",
       "            <tr>\n",
       "                <td style=\"text-align: left\"><b>Python version:</b></td>\n",
       "                <td style=\"text-align: left\"><b>3.10.6</b></td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                <td style=\"text-align: left\"><b>Ray version:</b></td>\n",
       "                <td style=\"text-align: left\"><b> 2.1.0</b></td>\n",
       "            </tr>\n",
       "            \n",
       "        </table>\n",
       "    </div>\n",
       "</div>\n"
      ],
      "text/plain": [
       "RayContext(dashboard_url='', python_version='3.10.6', ray_version='2.1.0', ray_commit='be49bde7ee4f6adb3f8710aee0665c27f9f0bb62', address_info={'node_ip_address': '127.0.0.1', 'raylet_ip_address': '127.0.0.1', 'redis_address': None, 'object_store_address': '/tmp/ray/session_2022-12-05_16-55-50_432868_3882/sockets/plasma_store', 'raylet_socket_name': '/tmp/ray/session_2022-12-05_16-55-50_432868_3882/sockets/raylet', 'webui_url': '', 'session_dir': '/tmp/ray/session_2022-12-05_16-55-50_432868_3882', 'metrics_export_port': 64588, 'gcs_address': '127.0.0.1:64680', 'address': '127.0.0.1:64680', 'dashboard_agent_listen_port': 52365, 'node_id': '23bf6196ca4d6ecc62fcf19fdedfe2f9de91d5da4e968b34f89ac8cd'})"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import ray\n",
    "import time \n",
    "\n",
    "@ray.remote\n",
    "class PairedSendReceive(object):\n",
    "    \"\"\"\n",
    "    Paired send and receive. This mimics the deadlock breaking behavior of MPI.\n",
    "    \"\"\"\n",
    "    msg = \"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        None\n",
    "\n",
    "    def set_message(self, msg):\n",
    "        \"\"\"set the message to be sent\"\"\"\n",
    "        self.msg = msg\n",
    "\n",
    "    def push_send(self, ooid):\n",
    "        \"\"\"initiate message from the sender\"\"\"\n",
    "        # sleep to make sure both actors are started before messaging\n",
    "        time.sleep(1)\n",
    "        return ray.get(ooid.recv.remote(self.msg))\n",
    "\n",
    "    def recv(self, msg):\n",
    "        \"\"\"remote function called by sender\"\"\"\n",
    "        return msg\n",
    "\n",
    "    def pull_recv(self, ooid):\n",
    "        \"\"\"initiate message from the receiver\"\"\"\n",
    "        # sleep to make sure both actors are starte\n",
    "        time.sleep(1)\n",
    "        return ray.get(ooid.send.remote())\n",
    "\n",
    "    def send(self):\n",
    "        \"\"\"remote function called by receiver\"\"\"\n",
    "        return self.msg\n",
    "\n",
    "ray.init(num_cpus=4, ignore_reinit_error=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sending (push) messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "push_send test from Actor(PairedSendReceive, 8737be3a79746b0f46628f1d01000000)\n",
      "push_send test from Actor(PairedSendReceive, 5e467172e759223312b8b98701000000)\n"
     ]
    }
   ],
   "source": [
    "# Create Send/Recv objects\n",
    "sr0 = PairedSendReceive.remote()\n",
    "sr1 = PairedSendReceive.remote()\n",
    "\n",
    "# set messages\n",
    "roid0 = sr0.set_message.remote(f\"push_send test from {sr0}\")\n",
    "roid1 = sr1.set_message.remote(f\"push_send test from {sr1}\")\n",
    "ray.get(roid0)\n",
    "ray.get(roid1)\n",
    "\n",
    "# At this point, message is set but NOT YET SENT\n",
    "\n",
    "# synchronized (one after the other) push\n",
    "roid0 = sr0.push_send.remote(sr1)\n",
    "print(ray.get(roid0))\n",
    "roid1 = sr1.push_send.remote(sr0)\n",
    "print(ray.get(roid1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Receiving (pull) messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pull_recv test from Actor(PairedSendReceive, 5e467172e759223312b8b98701000000)\n",
      "pull_recv test from Actor(PairedSendReceive, 8737be3a79746b0f46628f1d01000000)\n"
     ]
    }
   ],
   "source": [
    "# set new messages\n",
    "roid0 = sr0.set_message.remote(f\"pull_recv test from {sr0}\")\n",
    "roid1 = sr1.set_message.remote(f\"pull_recv test from {sr1}\")\n",
    "ray.get(roid0)\n",
    "ray.get(roid1)\n",
    "\n",
    "# synchronized (one after the other) pull\n",
    "roid0 = sr0.pull_recv.remote(sr1)\n",
    "print(ray.get(roid0))\n",
    "roid1 = sr1.pull_recv.remote(sr0)\n",
    "print(ray.get(roid1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, so far so good.  We can send and receive messages by:\n",
    "  * send: create a message call remote to receive \n",
    "  * receive: call remote to get its message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deadlock\n",
    "\n",
    "Both of these examples are serial with the `get` function creating a synchronization point between the wtwo messages.\n",
    "\n",
    "What happens with concurrent messages?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# synchronized (one after the other) pull\n",
    "# roid0 = sr0.pull_recv.remote(sr1)\n",
    "#roid1 = sr1.pull_recv.remote(sr0)\n",
    "\n",
    "# function initiates as soon as .remote() is called. \n",
    "# Therefore there is concurrent execution\n",
    "\n",
    "# ray.get([roid0,roid1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OK, that's a deadlock. Comment this out and then restart the kernel. Why is it a deadlock?\n",
    "\n",
    "**Intuitive explanation**\n",
    "\n",
    "Actor 0 is waiting for execution context of actor 1 to return in order to begin.\n",
    "\n",
    "Actor 1 is waiting for execution context of actor 0 to return in order to begin\n",
    "\n",
    "\n",
    "**Formal explanation**\n",
    "\n",
    "Because each Ray actor only has a single execution context.  So, it meets the deadlock criteria.\n",
    "  * two resources -- execution context of actor 0 and actor 1\n",
    "  * two holders -- `pull_recv` function on each actor\n",
    "  * two waiters -- remotely invoked `send` function\n",
    "  \n",
    "We can see it meets all the criteria.\n",
    "  * circular dependency\n",
    "  * hold and wait\n",
    "  * no preemption\n",
    "  * mutual exclusion\n",
    "  \n",
    "This deadlock persists indefinitely until we restart the kernel (breaking the deadlock with preemption).\n",
    "\n",
    "#### Resolving the Deadlock\n",
    "\n",
    "The idea here is to **pair senders and receivers** so that one is sending while the other is receiving.\n",
    "\n",
    "This ends up invoking both the send and the receive from the same node. However, this the send and receive steps occur sequentially."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "paired push_send test from Actor(PairedSendReceive, 8737be3a79746b0f46628f1d01000000)\n",
      "paired pull_recv test from Actor(PairedSendReceive, 5e467172e759223312b8b98701000000)\n"
     ]
    }
   ],
   "source": [
    "# set new messages\n",
    "roid0 = sr0.set_message.remote(f\"paired push_send test from {sr0}\")\n",
    "roid1 = sr1.set_message.remote(f\"paired pull_recv test from {sr1}\")\n",
    "ray.get(roid0)\n",
    "ray.get(roid1)\n",
    "\n",
    "# concurrent paired send and receive\n",
    "roid0 = sr0.push_send.remote(sr1)\n",
    "roid1 = sr0.pull_recv.remote(sr1)\n",
    "print(ray.get(roid0))\n",
    "print(ray.get(roid1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doing this with only two actors makes sequential. It becomes more interesting (and actually concurrent) when we do it with more actors. Let's try 4 actors organized in a ring."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "message actor 0: Actor(PairedSendReceive, 758f7902d001df4ade9f457b01000000)\n",
      "message actor 1: Actor(PairedSendReceive, d2fe30f4b22cf4bea2d15ecd01000000)\n",
      "message actor 0: Actor(PairedSendReceive, 758f7902d001df4ade9f457b01000000)\n",
      "message actor 3: Actor(PairedSendReceive, cda8fd25978ee06e5e2a2c8301000000)\n",
      "message actor 2: Actor(PairedSendReceive, c769b275f0c3d932658fa95f01000000)\n",
      "message actor 1: Actor(PairedSendReceive, d2fe30f4b22cf4bea2d15ecd01000000)\n",
      "message actor 2: Actor(PairedSendReceive, c769b275f0c3d932658fa95f01000000)\n",
      "message actor 3: Actor(PairedSendReceive, cda8fd25978ee06e5e2a2c8301000000)\n"
     ]
    }
   ],
   "source": [
    "# Create Send/Recv objects\n",
    "sr0 = PairedSendReceive.remote()\n",
    "sr1 = PairedSendReceive.remote()\n",
    "sr2 = PairedSendReceive.remote()\n",
    "sr3 = PairedSendReceive.remote()\n",
    "\n",
    "# set new messages\n",
    "roid0 = sr0.set_message.remote(f\"message actor 0: {sr0}\")\n",
    "roid1 = sr1.set_message.remote(f\"message actor 1: {sr1}\")\n",
    "roid2 = sr2.set_message.remote(f\"message actor 2: {sr2}\")\n",
    "roid3 = sr3.set_message.remote(f\"message actor 3: {sr3}\")\n",
    "ray.get([roid0,roid1,roid2,roid3])\n",
    "\n",
    "# concurrent paired send and receive\n",
    "roid0 = sr0.push_send.remote(sr1)\n",
    "roid1 = sr0.pull_recv.remote(sr1)\n",
    "roid2 = sr0.push_send.remote(sr3)\n",
    "roid3 = sr0.pull_recv.remote(sr3)\n",
    "roid4 = sr2.push_send.remote(sr1)\n",
    "roid5 = sr2.pull_recv.remote(sr1)\n",
    "roid6 = sr2.push_send.remote(sr3)\n",
    "roid7 = sr2.pull_recv.remote(sr3)\n",
    "print(ray.get(roid0))\n",
    "print(ray.get(roid1))\n",
    "print(ray.get(roid2))\n",
    "print(ray.get(roid3))\n",
    "print(ray.get(roid4))\n",
    "print(ray.get(roid5))\n",
    "print(ray.get(roid6))\n",
    "print(ray.get(roid7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this case, `roid0` - `roid4` are all called on `sr0`. Since `sr0` is a single-threaded process, there is no concurrency. Furthermore, `sr0` and `sr3` have no interdependencies. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This ends up being an hard way to think about it.  It is easier to conceive of this as even/odd nodes that are sending and receiving. And that sending and receiving occurs in pairs.\n",
    "\n",
    "<img src=./images/pairedsr.png>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sr0' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[1;32mIn [1]\u001b[0m, in \u001b[0;36m<cell line: 6>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m# concurrent paired send and receive\u001b[39;00m\n\u001b[0;32m      2\u001b[0m \u001b[38;5;66;03m# group nodes into groups A and B\u001b[39;00m\n\u001b[0;32m      3\u001b[0m \u001b[38;5;66;03m# we run A->B, Barrier, B->A \u001b[39;00m\n\u001b[0;32m      4\u001b[0m \n\u001b[0;32m      5\u001b[0m \u001b[38;5;66;03m# send from even to odd\u001b[39;00m\n\u001b[1;32m----> 6\u001b[0m roid0 \u001b[38;5;241m=\u001b[39m \u001b[43msr0\u001b[49m\u001b[38;5;241m.\u001b[39mpush_send\u001b[38;5;241m.\u001b[39mremote(sr1)\n\u001b[0;32m      7\u001b[0m roid1 \u001b[38;5;241m=\u001b[39m sr0\u001b[38;5;241m.\u001b[39mpush_send\u001b[38;5;241m.\u001b[39mremote(sr3)\n\u001b[0;32m      8\u001b[0m roid2 \u001b[38;5;241m=\u001b[39m sr2\u001b[38;5;241m.\u001b[39mpush_send\u001b[38;5;241m.\u001b[39mremote(sr3)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'sr0' is not defined"
     ]
    }
   ],
   "source": [
    "# concurrent paired send and receive\n",
    "# group nodes into groups A and B\n",
    "# we run A->B, Barrier, B->A \n",
    "\n",
    "# send from even to odd\n",
    "roid0 = sr0.push_send.remote(sr1)\n",
    "roid1 = sr0.push_send.remote(sr3)\n",
    "roid2 = sr2.push_send.remote(sr3)\n",
    "roid3 = sr2.push_send.remote(sr1)\n",
    "print(ray.get(roid0))\n",
    "print(ray.get(roid1))\n",
    "print(ray.get(roid2))\n",
    "print(ray.get(roid3))\n",
    "\n",
    "# send from odd to even\n",
    "roid0 = sr1.push_send.remote(sr0)\n",
    "roid1 = sr1.push_send.remote(sr2)\n",
    "roid2 = sr3.push_send.remote(sr0)\n",
    "roid3 = sr3.push_send.remote(sr2)\n",
    "print(ray.get(roid0))\n",
    "print(ray.get(roid1))\n",
    "print(ray.get(roid2))\n",
    "print(ray.get(roid3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graphically, this process eliminates cycles from the dependency graph. Solving this problem optimally *might* be NP-hard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Breaking Deadlock with Timeout\n",
    "\n",
    "This is brute force but it works. We detect lack of progress, and kill concurrent processes one by one until it starts working"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Breaking Deadlock with Queuing\n",
    "\n",
    "If we buffer messages in queues, we can make sending  asynchronous.  The sending process now buffers a message in memory and the receiver retrieves it from memory. **Send doesn't wait for receive**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "@ray.remote\n",
    "class QueuedSendReceive(object):\n",
    "    \"\"\"\n",
    "    Send and receive through queues.\n",
    "    Queues make the send call asynchronous.\n",
    "\n",
    "    # RB note the queue breaks the send/send deadlock\n",
    "    # RB note how many queues are needed?  why inferior to push model\n",
    "    \"\"\"\n",
    "    msg = \"\"\n",
    "\n",
    "    def __init__(self, squeue, rqueue):\n",
    "        \"\"\"Create an inbound and outbound queue for each actor.\"\"\"\n",
    "        self.recvQ = rqueue\n",
    "        self.sendQ = squeue\n",
    "\n",
    "    def set_message(self, msg):\n",
    "        \"\"\"set the message to be sent\"\"\"\n",
    "        self.msg = msg\n",
    "\n",
    "    def _qsend(self):\n",
    "        \"\"\"Helper: enqueue a message\"\"\"\n",
    "        ### TODO\n",
    "        self.sendQ.put(self.msg)\n",
    "\n",
    "    def _qreceive(self):\n",
    "        \"\"\"Helper: dequeue a message\"\"\"\n",
    "        ### TODO\n",
    "        msg = self.recvQ.get()\n",
    "        return msg\n",
    "\n",
    "    def rs_exchange(self):\n",
    "        \"\"\"receive first then send\"\"\"\n",
    "        ### TODO\n",
    "        msg = self._qreceive()\n",
    "        self._qsend()\n",
    "        return msg\n",
    "    \n",
    "    def sr_exchange(self):\n",
    "        \"\"\"send first then receive\"\"\"\n",
    "        ### TODO\n",
    "        self._qsend()\n",
    "        return self._qreceive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2022-12-05 17:19:10,063\tINFO worker.py:1360 -- Calling ray.init() again after it has already been called.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Send first. No deadlock\n",
      "Message from Actor(QueuedSendReceive, 6e8ec5713fa4923fa42f62c701000000)\n",
      "Message from Actor(QueuedSendReceive, adaf35413540450dc527b37d01000000)\n"
     ]
    }
   ],
   "source": [
    "from ray.util.queue import Queue\n",
    "\n",
    "# script to drive parallel program\n",
    "ray.init(num_cpus=4, ignore_reinit_error=True)\n",
    "\n",
    "# create messaging queues\n",
    "q0to1 = Queue(maxsize=100)\n",
    "q1to0 = Queue(maxsize=100)\n",
    "\n",
    "# objects with paired queues\n",
    "sr0 = QueuedSendReceive.remote(q0to1,q1to0)\n",
    "sr1 = QueuedSendReceive.remote(q1to0,q0to1)\n",
    "\n",
    "# set messages\n",
    "roid0 = sr0.set_message.remote(f\"Message from {sr0}\")\n",
    "roid1 = sr1.set_message.remote(f\"Message from {sr1}\")\n",
    "ray.get(roid0)\n",
    "ray.get(roid1)\n",
    "\n",
    "print(\"Send first. No deadlock\")\n",
    "oid0 = sr0.sr_exchange.remote()\n",
    "oid1 = sr1.sr_exchange.remote()\n",
    "print(ray.get(oid0))\n",
    "print(ray.get(oid1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "HOWEVER, **attempting receiving first will cause deadlock**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Receive first, deadlock\n"
     ]
    }
   ],
   "source": [
    "print(\"Receive first, deadlock\")\n",
    "oid0 = sr0.rs_exchange.remote()\n",
    "oid1 = sr1.rs_exchange.remote()\n",
    "print(ray.get(oid0))\n",
    "print(ray.get(oid1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Queuing Tradeoffs\n",
    "\n",
    "Buffering is a powerful technique for enabling concurrency. It can time shift the delivery of data from sending and receiving processes. It plays a similar role as caching with processes trying to write to devices. \n",
    "\n",
    "Sophisticated implementations allow for one physical queue per actor/process by tagging messages with sender data and allowing receivers to receive messages from specific senders.\n",
    "\n",
    "The problem with queueing is one of scale. When queues run out of memory or storage, the send process becomes synchronous. It must wait for queue space before returning. \n",
    "\n",
    "This means that deadlock can occur even in queueing systems, particularly when they scale to many parties or heavy workloads.\n",
    "\n",
    "**Conclusion**: It is important to use deadlock-free messaging disciplines even with buffering."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}