artifact.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "enormous-insured",
   "metadata": {},
   "source": [
    "## Zeph\n",
    "\n",
    "This repository contains the artifact for the OSDI 2021 submission [\"Zeph: Cryptographic Enforcement of End-to-End Data Privacy\"](osdi21-paper210-zeph.pdf). \n",
    "\n",
    "The current implementation of Zeph is an academic proof-of-concept prototype. The prototype is designed to focus on evaluating the overheads of enforcing privacy transformations on encrypted data streams in Apache Kafka/Kafka Streams. The current prototype is not meant to be directly used for applications in productions. Note that currently - and as we mentioned in our submission - the orchestration of transformation, i.e., the policy manager's role is emulated with ansible scripts that run the end-to-end benchmark. \n",
    "\n",
    "This repository is structured as follows.\n",
    "For more information, see the individual README files in the corresponding folders.\n",
    "\n",
    "#### Zeph Components\n",
    "\n",
    "- [**Zeph-client**](zeph-client/README.md): This folder contains Zeph's client library's implementation. It contains the data producer and privacy controller implementation.\n",
    "\n",
    "- [**Zeph-server**](zeph-server/README.md): This folder contains Kafka's server library implementation. In its essence, the data transformer is a stream processor that performs privacy-preserving transformations on encrypted data streams by leveraging a stream of privacy transformation tokens.\n",
    "\n",
    "#### Zeph Utility\n",
    "\n",
    "- [**Zeph-crypto**](zeph-crypto/README.md): This folder holds the implementation of the cryptographic material for Zeph. It contains the native implementation of the secure aggregation protocol for the Strawman, Dream, and Zeph Optimization and the implementation of the stream encryption.\n",
    "\n",
    "- [**Zeph-shared**](zeph-shared/README.md): This folder holds the implementations of the shared components of the client and the server of Zeph (e.g., Avro record, pojo, serde).\n",
    "\n",
    "#### Zeph Benchmarks and Evaluation\n",
    "\n",
    "- [**Zeph-benchmarks**](zeph-benchmarks/README.md): This folder holds all the material relevant to the microbenchmarks and the end-to-end evaluation of Zeph. Zeph Dashboard and a demo of Zeph as well can be found in this folder.\n",
    "\n",
    "- [**Ansible**](ansible/README.md): The ansible playbooks we made to help and assist in navigating and automatically setting up and running the benchmarks on AWS for Zeph."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "passive-dietary",
   "metadata": {},
   "source": [
    "## Experiments\n",
    "\n",
    "We provide a [JupyterLab](https://jupyterlab.readthedocs.io/en/stable/) environment to run the experiments and evaluate the artifact of Zeph.\n",
    "Our JupyterLab environment contains further documentation, runnable code cells to run benchmarks locally or on AWS (using `!` to run shell commands), and runnable code cells to recreate the plots from the paper. \n",
    "\n",
    "To execute a selected cell, either click on the run button in the toolbar or use `Ctrl + Enter`.\n",
    "To keep the JupyterLab readable, cells containing longer code sections to create plots are initially collapsed (indicated by three dots). However, by clicking on the dots, the cell containing the code expands (`View/Collapse Selected Code` to collapse the code again).\n",
    "\n",
    "**Note that the shell commands to execute benchmarks are by default commented out. Uncomment to initiate the runs for these benchmarks.** (remove `#` before or `\"\"\"` enclosing the shell command)\n",
    "\n",
    "#### AWS\n",
    "AWS login information can be found in the Artifact submission system. This will allow the  Artifact reviewers to run the evaluation on the same resources stated in the paper submission. The experiments on AWS are automated with ansible-playbooks and can be called from the JupyterLab environment.\n",
    "\n",
    "**Please ensure that the AWS resources are cleaned up if they are not used in the artifact**  \n",
    "If the playbook terminates normally (i.e., without error and is not interrupted), then the playbook ensures that the created resources are also cleaned up.\n",
    "When in doubt, please run the `ansible/awscleanup.yml` playbook with the command below or contact the authors to avoid unnecessary costs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "welcome-architect",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4 µs, sys: 0 ns, total: 4 µs\n",
      "Wall time: 8.82 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Uncomment and run to terminate all resources on AWS (in case of an error, try to repeat and otherwise contact the authors) \n",
    "\n",
    "#!ansible-playbook ansible/awscleanup.yml -i ansible/inventory --private-key ~/.ssh/id_rsa_zeph"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "junior-blake",
   "metadata": {},
   "source": [
    "## Getting Started (Zeph JupyterLab)\n",
    "\n",
    "### Initial Steps (~20 min)\n",
    "1. Clone the code from GitHub [Zeph](https://github.com/pps-lab/zeph)\n",
    "\n",
    "2. Reviewers should have received a private key: `id_rsa_zeph` and AWS credentials \n",
    "     1. move the provided private key `id_rsa_zeph` to the `aws-material` folder of the cloned project (reviewers should have received the key, otherwise contact us) \n",
    "     2. Copy/Paste the provided AWS credentials in `aws-material/boto`: \n",
    "    ```\n",
    "    [Credentials]\n",
    "    aws_access_key_id = {YOUR_AWS_ACCESS_KEY_ID}\n",
    "    aws_secret_access_key = {YOUR_AWS_ACCESS_KEY}\n",
    "    ```\n",
    "\n",
    "3. Build the docker Image (~7 min)\n",
    "```\n",
    "docker build --rm -t jupyter/zeph .\n",
    "```\n",
    "\n",
    "4. `[Optional]` Create a docker volume to persist potential benchmark results.\n",
    "```\n",
    "docker volume create zeph-data\n",
    "```\n",
    "\n",
    "5. Start JupyterLab, which launches the guide for the artifact evaluation:\n",
    "```\n",
    "docker run -it --rm -p 8888:8888 -v zeph-data:/home/jovyan/results/review-results:Z jupyter/zeph start.sh jupyter lab\n",
    "```\n",
    "```\n",
    "# Without a volume\n",
    "docker run -it --rm -p 8888:8888 jupyter/zeph start.sh jupyter lab\n",
    "```\n",
    "\n",
    "6. Access JupyterLab via a web browser with the link outputted in the console  \n",
    "\n",
    "7. In JupyterLab, open `artifact.ipynb`. The documentation in the notebook guides through the different parts of the artifact. **Continue from here in JupyterLab (same text as in the readme)**\n",
    "\n",
    "8. Run all cells with `Run / Run All Cells` (~ 10 sec). Note that the (long-running) shell commands are initially commented out.  \n",
    "\n",
    "9. Test the JupyterLab setup by running the two commands below to check whether things are configured properly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "labeled-former",
   "metadata": {},
   "source": [
    "#### Imports and Initialization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bearing-nepal",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# ensure review results directories are present\n",
    "!mkdir -p results/review-results/aws\n",
    "!mkdir -p results/review-results/local\n",
    "\n",
    "# imports and path handling of files\n",
    "import os, json, math, glob\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import statistics as stat\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as plticker\n",
    "from IPython.display import display, Markdown, HTML, clear_output\n",
    "\n",
    "pd.set_option('display.max_colwidth', None)\n",
    "\n",
    "def get_result_path(source, file_d={\"paper\": \"\", \"aws\": \"\", \"local\": \"\"}):\n",
    "    if source == \"paper\":\n",
    "        return os.path.join(\"results/paper\", file_d[\"paper\"])\n",
    "    elif source == \"aws\":\n",
    "        return os.path.join(\"results/review-results/aws\", file_d[\"aws\"])\n",
    "    elif source == \"local\":\n",
    "        return os.path.join(\"results/review-results/local\", file_d[\"local\"])\n",
    "    else:\n",
    "        raise ValueError(\"unknown source: must be one of [paper, aws, local]\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "binary-tanzania",
   "metadata": {},
   "source": [
    "#### Running all Microbenchmarks locally with minimal configuration (~2 min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "systematic-annotation",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_minimal.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.35 ms, sys: 646 µs, total: 5.99 ms\n",
      "Wall time: 5.1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Running all Microbenchmarks locally with minimal configuration to check that the local setup works. (~2 min) \n",
    "\n",
    "\"\"\"\n",
    "!java -jar zeph-benchmarks/zeph-microbenchmarks/target/zeph-microbenchmarks-1.0.jar \\\n",
    "    testEncode$ testEncodeEncrypt$ testECDH$ testErdosRenyiNative$ testDreamNative$ testStrawmanNative$ testUniverseDelta$ \\\n",
    "    -foe true -f 0 -wi 0 -i 1 -rf json -rff results/review-results/local/minimal.json -p dataDir=data \\\n",
    "    -p encoderConfig=avg \\\n",
    "    -p size_win=100_256 \\\n",
    "    -p universeSize=1000 -p addE_addNE_dropE_dropNE=0_10_0_10 \\\n",
    "    2>&1 | tee logs/mbench_minimal.log\n",
    "\"\"\"\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_minimal.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "varying-conference",
   "metadata": {},
   "source": [
    "#### Check Configuration to run Zeph on AWS (~3 min)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sustained-nowhere",
   "metadata": {},
   "source": [
    "Before executing the command we recommend to login to the [AWS Management Console](https://226594459110.signin.aws.amazon.com/console) with the provided credentials.\n",
    "In the management console select the London region (eu-west-2) and open the EC2 service. This allows to observe what the minimal ansible playbook does.\n",
    "\n",
    "The minimal playbook will:\n",
    "1. create a VPC\n",
    "2. start one EC2 instance\n",
    "3. clone Zeph from GitHub\n",
    "4. reset the AWS environment (terminate instance, remove VPC)\n",
    "\n",
    "In case something fails, ensure that the provided aws material (private key and credentials) are placed as described above.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "horizontal-jackson",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/aws_minimal.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 841 µs, sys: 2.51 ms, total: 3.35 ms\n",
      "Wall time: 2.77 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "#!ansible-playbook ansible/minimal.yml -i ansible/inventory --private-key ~/.ssh/id_rsa_zeph --ssh-common-args='-o StrictHostKeyChecking=no' 2>&1 | tee logs/aws_minimal.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/aws_minimal.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "further-firewall",
   "metadata": {
    "tags": [
     "Test"
    ]
   },
   "source": [
    "## Running Experiments\n",
    "We assume that the following steps are followed within the JupyterLab environment. \n",
    "For each result shown in the paper, we have a separate section.\n",
    "Each section contains:\n",
    "\n",
    "1. Code to produce the results in form of a table based on the output files from the benchmarks\n",
    "\n",
    "2. Code to create the plot shown in the paper from the results table\n",
    "\n",
    "3. Code that displays both the results and the figure and allows you to switch between the results from the paper and the reproduced results\n",
    "\n",
    "4. The command to reproduce the results (locally / on aws for microbenchmarks, and on aws for the end-to-end benchmark. You can uncomment the command and run the cell with `Ctrl + Enter`.\n",
    "\n",
    "Note that for improved readability, the code for creating the table and the plot is initially collapsed but can be openend by clicking on the three dots. To collapse the code again, select the cell by clicking on it and then go to `View/Collapse Selected Code`.\n",
    "\n",
    "JupyterLab code cells are blocking which means that when executing a cell (e.g., run a benchmark), we cannot run another cell until the previous cell finished.\n",
    "As a result, it might be to better for long running commands to copy the shell command (excluding the comment and  `!`) and execute it in a Jupyter terminal.\n",
    "\n",
    "In any case, while running a benchmark in a cell or a terminal, keep the JupyterLab session open and ensure that the internet connection is stable (for AWS)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ignored-design",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       " <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(' <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a>')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "velvet-billion",
   "metadata": {},
   "source": [
    "### Microbenchmarks (Figure 5,6,7,8 and Table 1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ongoing-naples",
   "metadata": {},
   "source": [
    "#### Running all Microbenchmarks on AWS EC2 (3h 20min)\n",
    "All microbenchmarks in the paper run on a single AWS EC2 instance.\n",
    "Since running all microbenchmarks takes quite a bit of time, we provide two ansible playbook commands to help with the process.\n",
    "\n",
    "1. The ansible playbook with the tag \"start\" initializes the AWS environment (e.g., creates a VPC, creates a single EC2 instance), fetches the current version of the code from GitHub, and builds Zeph. Afterwards it starts a systemd service `microbenchmark.service` on the remote machine to run all the microbenchmarks.\n",
    "\n",
    "2. The ansible playbook with the tag \"result\" checks repeatedly (up to 100 times with a 15s delay in between) whether the `microbenchmark.service` is still running. As soon as the service stopped, the playbook fetches the benchmark result file into the local folder (`results/review-results/aws`). From there we can reproduce the figures from the paper as described below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cooperative-meter",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       " <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(' <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "weekly-bishop",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_aws_start.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.4 ms, sys: 1.56 ms, total: 4.96 ms\n",
      "Wall time: 5.26 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Command to start all microbenchmarks (~ 14 min)\n",
    "\n",
    "# Note `-o StrictHostKeyChecking=no` allows to directly connect to the newly created ec2 machine\n",
    "\n",
    "#!ansible-playbook ansible/mbenchpaper.yml -i ansible/inventory -e \"run_id=0\" --private-key ~/.ssh/id_rsa_zeph --ssh-common-args='-o StrictHostKeyChecking=no' --tags \"start\" 2>&1 | tee logs/mbench_aws_start.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_aws_start.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "surgical-holocaust",
   "metadata": {},
   "source": [
    "Running all microbenchmarks on EC2 takes ~ 3h 20min. \n",
    "The playbook below checks whether the microbenchmarks are finished and fetches the result file.\n",
    "\n",
    "Note to observe the progress manually, use ssh to connect to the ec2 instance and look at the files in: `~/logs`. \n",
    "(`ssh ubuntu@<Public IPv4 DNS> -i ~/.ssh/id_rsa_zeph`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "modular-visitor",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_aws_result.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.14 ms, sys: 2.68 ms, total: 3.82 ms\n",
      "Wall time: 3.06 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Command that waits for the microbenchmarks to finish and then fetches the result file. \n",
    "# (It waits for a maximum of 25 minutes before it aborts but you can also abort manually if the results are not ready yet and retry later)\n",
    "\n",
    "# between ~ 2 min and 25 min depending on whether benchmark is complete. \n",
    "\n",
    "#!ansible-playbook ansible/mbenchpaper.yml -i ansible/inventory --private-key ~/.ssh/id_rsa_zeph --tags \"result\" 2>&1 | tee logs/mbench_aws_result.log\n",
    "\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/mbench_aws_result.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "preceding-classroom",
   "metadata": {},
   "source": [
    "#### `Optional:` Running Microbenchmarks Locally\n",
    "\n",
    "Before running microbenchmarks locally, you have to build Zeph (in the Standard Application) with the command `mvn clean install` as shown below.\n",
    "Note, that Zeph in the standard application is already built when building the Docker container. So only rebuild Zeph if you switch the application or something fails. \n",
    "For each of the figures, we provide the command to run the corresponding microbenchmark."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "victorian-courage",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_standard.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4 ms, sys: 12 µs, total: 4.01 ms\n",
      "Wall time: 3.49 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "# Build Zeph (in the Standard Application)  (~6 min)\n",
    "#!mvn clean install 2>&1 | tee logs/build_zeph_standard.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_standard.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blessed-andrew",
   "metadata": {},
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "worthy-survey",
   "metadata": {},
   "source": [
    "### Data Producer (Figure 5)\n",
    "\n",
    "Code Marker: [EncoderBenchmark.java](zeph-benchmarks/zeph-microbenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/EncoderBenchmark.java)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "billion-luther",
   "metadata": {},
   "source": [
    "#### `Optional:` Run the Microbenchmark for Figure 5 locally (~40min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "desperate-affiliation",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/figure5.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.79 ms, sys: 368 µs, total: 5.16 ms\n",
      "Wall time: 5.21 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "#!java -jar zeph-benchmarks/zeph-microbenchmarks/target/zeph-microbenchmarks-1.0.jar testEncode testEncodeEncrypt -rf json -rff results/review-results/local/figure5_out.json -p encoderConfig=count,sum,avg,var,hist_10,reg 2>&1 | tee logs/figure5.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/figure5.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "productive-dance",
   "metadata": {},
   "source": [
    "#### Description\n",
    "\n",
    "The overhead of the data producer consists of encoding and encrypting records in Zeph's symmetric additive homomorphic encryption scheme. We measure the computational overhead with a microbenchmark and we show analytically how the bandwidth requirements depends on the applied encoding.\n",
    "\n",
    "For the benchmark run on the Raspberry Pi, we only provide the results from the paper. (However, you could build Zeph on the Raspberry Pi and run the benchmark with the comand below)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "geographic-frame",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure5_df(file):\n",
    "    try:\n",
    "        with open(file) as json_file:\n",
    "            data = json.load(json_file)\n",
    "    except (FileNotFoundError, ValueError) as e:\n",
    "        return None\n",
    "    \n",
    "    res_encode = []\n",
    "    res_encode_encrypt = []\n",
    "\n",
    "    for exp in data:\n",
    "        benchmark = exp['benchmark'].split(\".\")[-1]\n",
    "        \n",
    "        if benchmark not in [\"testEncode\", \"testEncodeEncrypt\"]:\n",
    "            continue\n",
    "    \n",
    "        exp[\"primaryMetric\"][\"rawData\"]\n",
    "    \n",
    "        if \"Raspbian\" in exp[\"vmVersion\"]:\n",
    "            system = \"raspbian\"\n",
    "        elif \"Ubuntu\" in exp[\"vmVersion\"]:\n",
    "            system = \"ubuntu\"\n",
    "        else:\n",
    "            raise ValueError(f\"unknown vm version {exp['vmVersion']}\")\n",
    "\n",
    "\n",
    "\n",
    "        rt_us = 1/(exp[\"primaryMetric\"][\"score\"]/1000000)\n",
    "        rts_us = [1/(x/1000000) for x in exp[\"primaryMetric\"][\"rawData\"][0]]\n",
    "        rt_stddev_us = stat.stdev(rts_us)\n",
    "\n",
    "        tp_stddev = stat.stdev(exp[\"primaryMetric\"][\"rawData\"][0])\n",
    "\n",
    "        if benchmark == \"testEncode\":\n",
    "\n",
    "            parts = exp[\"params\"][\"encoderConfig\"].split(\"_\")\n",
    "            config = parts[1] if len(parts)> 1 else \"-\"\n",
    "\n",
    "            d = {\n",
    "                \"system\": system,\n",
    "                \"encoding\": parts[0],\n",
    "                \"config\": config,\n",
    "                \"tp_encode\": int(exp[\"primaryMetric\"][\"score\"]),\n",
    "                \"tp_encode_stdev\": tp_stddev,\n",
    "                \"rt_encode_us\": rt_us,\n",
    "                \"rt_encode_stdev_us\": rt_stddev_us\n",
    "            }\n",
    "            res_encode.append(d)\n",
    "\n",
    "        elif benchmark == \"testEncodeEncrypt\":\n",
    "            parts = exp[\"params\"][\"encoderConfig\"].split(\"_\")\n",
    "            config = parts[1] if len(parts)> 1 else \"-\"\n",
    "            d = {\n",
    "                \"system\": system,\n",
    "                \"encoding\": parts[0],\n",
    "                \"config\": config,\n",
    "                \"tp_encode_encrypt\": int(exp[\"primaryMetric\"][\"score\"]),\n",
    "                \"tp_encode_encrypt_stdev\": tp_stddev,\n",
    "                \"rt_encode_encrypt_us\": rt_us,\n",
    "                \"rt_encode_encrypt_stdev_us\": rt_stddev_us\n",
    "            }\n",
    "            res_encode_encrypt.append(d)\n",
    "\n",
    "\n",
    "    df_encode = pd.DataFrame(res_encode)\n",
    "    df_encode_encrypt = pd.DataFrame(res_encode_encrypt)\n",
    "\n",
    "    df = df_encode.merge(df_encode_encrypt, how='outer', on=['system', 'encoding', 'config'])\n",
    "    \n",
    "    \n",
    "    df[\"rt_encrypt_us\"] = df[\"rt_encode_encrypt_us\"] - df[\"rt_encode_us\"]\n",
    "    df[\"encode_percent\"] = df[\"rt_encode_us\"] / df[\"rt_encode_encrypt_us\"]\n",
    "    df[\"encrypt_percent\"] = 1 - df[\"encode_percent\"] \n",
    "\n",
    "    df = df.round({'encode_percent': 2, 'encrypt_percent': 2})\n",
    "\n",
    "    df = df.sort_values([\"system\",\"rt_encode_encrypt_us\"])    \n",
    "    \n",
    "    # select the presented encodings\n",
    "    encodings =  [\"count\", \"sum\", \"avg\", \"var\", \"reg\", \"hist\"]\n",
    "    df = df[df[\"encoding\"].isin(encodings) & ((df[\"config\"]==\"-\")|(df[\"config\"]==\"10\"))]\n",
    "    \n",
    "    # project \n",
    "    df = df[[\"system\", \"encoding\", \"rt_encode_us\", \"rt_encrypt_us\", \"rt_encode_encrypt_stdev_us\", \"tp_encode_encrypt\"]]\n",
    "    return df\n",
    "\n",
    "def build_figure_5a(data, format_plot):\n",
    "    print(\"Figure 5a: EC2 Instance\")\n",
    "    df1 = data[data[\"system\"]==\"ubuntu\"]\n",
    "    df1 = df1[df1.encoding.isin([\"sum\", \"avg\", \"var\", \"reg\", \"hist\"])]\n",
    "    _build_stacked_barchart(values1=df1[\"rt_encode_us\"], label1=\"Encode\",\n",
    "                            values2=df1[\"rt_encrypt_us\"], label2=\"Encrypt\",\n",
    "                            err=df1[\"rt_encode_encrypt_stdev_us\"],\n",
    "                            labels=df1[\"encoding\"], y_label=\"Computation [μs]\", ytick_base=0.4, format_plot=format_plot)\n",
    "    \n",
    "\n",
    "def build_figure_5b(data):\n",
    "    print(\"Figure 5b: EC2 Raspberry Pi\")\n",
    "    \n",
    "    df1 = data[data[\"system\"]==\"raspbian\"] \n",
    "    df1 = df1[df1.encoding.isin([\"sum\", \"avg\", \"var\", \"reg\", \"hist\"])]\n",
    "\n",
    "    _build_stacked_barchart(values1=df1[\"rt_encode_us\"], label1=\"Encode\",\n",
    "                            values2=df1[\"rt_encrypt_us\"], label2=\"Encrypt\",\n",
    "                            err=df1[\"rt_encode_encrypt_stdev_us\"],\n",
    "                            labels=df1[\"encoding\"], y_label=\"Computation [μs]\", ytick_base=20)\n",
    "    \n",
    "def build_producer_bandwidth_df(timestamp_bytes=8, value_bytes=8, num_buckets=10):\n",
    "    # both the timestamp and a value is represented by a long (8 bytes)\n",
    "    # for encodings based on buckets (hist, max, min), we use as stated by default 10 buckets\n",
    "\n",
    "    encodings = [(\"sum\", 1), (\"count\", 1), (\"avg\", 2), (\"var\", 3), (\"hist\", num_buckets), (\"max\", num_buckets), (\"min\", num_buckets), (\"reg\", 5)]\n",
    "    results = []\n",
    "\n",
    "    plaintext_bytes  = value_bytes + timestamp_bytes\n",
    "\n",
    "    for name, fields in encodings:\n",
    "        d = {\n",
    "            \"encoding\": name,\n",
    "            \"fields\": fields,\n",
    "            \"size_bytes\": fields * value_bytes + 2 * timestamp_bytes,\n",
    "        }\n",
    "        results.append(d)\n",
    "\n",
    "    df = pd.DataFrame(results)\n",
    "    df[\"expansion_factor\"] = df[\"size_bytes\"] / plaintext_bytes\n",
    "    \n",
    "    df = df[df.encoding.isin([\"sum\", \"avg\", \"var\", \"reg\", \"hist\"])]\n",
    "    df = df.transpose()\n",
    "    return df\n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "def _build_stacked_barchart(values1, label1, values2, label2, labels, err, y_label, ytick_base=1, x_label=None, format_plot=True):\n",
    "    \n",
    "    \n",
    "    plt_params = {'backend': 'ps',\n",
    "              'axes.labelsize': 20,\n",
    "              'legend.fontsize': 16,\n",
    "              'xtick.labelsize': 18,\n",
    "              'ytick.labelsize': 18,\n",
    "              'font.size': 18,\n",
    "              'figure.figsize': [4.151100041511, 2.736555644111891],\n",
    "              'font.family': 'times new roman'}\n",
    "    \n",
    "    plt.rc('pdf', fonttype=42) \n",
    "    plt.rcParams.update(plt_params)\n",
    "    \n",
    "    colors=['0.3', '0.6']\n",
    "    \n",
    "    \n",
    "    f, ax1 = plt.subplots()\n",
    "\n",
    "    \n",
    "    ind = np.arange(0, len(labels)) * 1.2\n",
    "    width = 0.8\n",
    "    \n",
    "    bars1 = ax1.bar(ind, values1, width, label=label1, zorder=3)\n",
    "    bars2 = ax1.bar(ind, values2, width, yerr=err ,bottom=values1, label=label2, zorder=3, capsize=3)\n",
    "\n",
    "    for id, bar in enumerate(bars1):\n",
    "        bar.set_facecolor(colors[0])\n",
    "    \n",
    "    for id, bar in enumerate(bars2):\n",
    "        bar.set_facecolor(colors[1])\n",
    "    \n",
    "            \n",
    "    ax1.legend()\n",
    "    \n",
    "    # format x axis\n",
    "    ax1.set_xlabel(x_label)\n",
    "    ax1.set_xticks(ind)\n",
    "    ax1.set_xticklabels(labels, rotation=345)\n",
    "    \n",
    "    # format y axis\n",
    "    ax1.set_ylabel(y_label)\n",
    "    ax1.set_ylim(ymin=0)\n",
    "\n",
    "    \n",
    "    ax1.yaxis.grid(True, linestyle=':', color='0.6', zorder=0, linewidth=1.2)\n",
    "    \n",
    "    if ytick_base is not None and format_plot:\n",
    "        loc = plticker.MultipleLocator(base=ytick_base)\n",
    "        ax1.yaxis.set_major_locator(loc)\n",
    "    \n",
    "    plt.show()\n",
    "    print(\"\\n\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "animal-heating",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Paper Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure 5a: EC2 Instance\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Figure 5b: EC2 Raspberry Pi\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>system</th>\n",
       "      <th>encoding</th>\n",
       "      <th>rt_encode_us</th>\n",
       "      <th>rt_encrypt_us</th>\n",
       "      <th>rt_encode_encrypt_stdev_us</th>\n",
       "      <th>tp_encode_encrypt</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>count</td>\n",
       "      <td>0.142254</td>\n",
       "      <td>12.913445</td>\n",
       "      <td>1.186721</td>\n",
       "      <td>76594</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>sum</td>\n",
       "      <td>0.196692</td>\n",
       "      <td>15.404380</td>\n",
       "      <td>0.464332</td>\n",
       "      <td>64098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>avg</td>\n",
       "      <td>0.252038</td>\n",
       "      <td>21.346736</td>\n",
       "      <td>2.917521</td>\n",
       "      <td>46298</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>var</td>\n",
       "      <td>0.393480</td>\n",
       "      <td>29.369783</td>\n",
       "      <td>3.549119</td>\n",
       "      <td>33598</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>reg</td>\n",
       "      <td>0.569529</td>\n",
       "      <td>63.558873</td>\n",
       "      <td>3.478552</td>\n",
       "      <td>15593</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>raspbian</td>\n",
       "      <td>hist</td>\n",
       "      <td>1.083401</td>\n",
       "      <td>93.985279</td>\n",
       "      <td>13.259081</td>\n",
       "      <td>10518</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>count</td>\n",
       "      <td>0.006086</td>\n",
       "      <td>0.181359</td>\n",
       "      <td>0.000120</td>\n",
       "      <td>5334897</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>sum</td>\n",
       "      <td>0.009204</td>\n",
       "      <td>0.181986</td>\n",
       "      <td>0.000872</td>\n",
       "      <td>5230389</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>avg</td>\n",
       "      <td>0.013471</td>\n",
       "      <td>0.369522</td>\n",
       "      <td>0.000307</td>\n",
       "      <td>2611013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>var</td>\n",
       "      <td>0.017864</td>\n",
       "      <td>0.557062</td>\n",
       "      <td>0.000272</td>\n",
       "      <td>1739354</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>reg</td>\n",
       "      <td>0.025515</td>\n",
       "      <td>0.901807</td>\n",
       "      <td>0.009513</td>\n",
       "      <td>1078373</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>ubuntu</td>\n",
       "      <td>hist</td>\n",
       "      <td>0.092393</td>\n",
       "      <td>1.771365</td>\n",
       "      <td>0.017900</td>\n",
       "      <td>536550</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      system encoding  rt_encode_us  rt_encrypt_us  \\\n",
       "12  raspbian    count      0.142254      12.913445   \n",
       "11  raspbian      sum      0.196692      15.404380   \n",
       "13  raspbian      avg      0.252038      21.346736   \n",
       "14  raspbian      var      0.393480      29.369783   \n",
       "21  raspbian      reg      0.569529      63.558873   \n",
       "16  raspbian     hist      1.083401      93.985279   \n",
       "1     ubuntu    count      0.006086       0.181359   \n",
       "0     ubuntu      sum      0.009204       0.181986   \n",
       "2     ubuntu      avg      0.013471       0.369522   \n",
       "3     ubuntu      var      0.017864       0.557062   \n",
       "10    ubuntu      reg      0.025515       0.901807   \n",
       "5     ubuntu     hist      0.092393       1.771365   \n",
       "\n",
       "    rt_encode_encrypt_stdev_us  tp_encode_encrypt  \n",
       "12                    1.186721              76594  \n",
       "11                    0.464332              64098  \n",
       "13                    2.917521              46298  \n",
       "14                    3.549119              33598  \n",
       "21                    3.478552              15593  \n",
       "16                   13.259081              10518  \n",
       "1                     0.000120            5334897  \n",
       "0                     0.000872            5230389  \n",
       "2                     0.000307            2611013  \n",
       "3                     0.000272            1739354  \n",
       "10                    0.009513            1078373  \n",
       "5                     0.017900             536550  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### AWS Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Local Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Bandwidth"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>encoding</th>\n",
       "      <td>sum</td>\n",
       "      <td>avg</td>\n",
       "      <td>var</td>\n",
       "      <td>hist</td>\n",
       "      <td>reg</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fields</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>size_bytes</th>\n",
       "      <td>24</td>\n",
       "      <td>32</td>\n",
       "      <td>40</td>\n",
       "      <td>96</td>\n",
       "      <td>56</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>expansion_factor</th>\n",
       "      <td>1.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.5</td>\n",
       "      <td>6.0</td>\n",
       "      <td>3.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    0    2    3     4    7\n",
       "encoding          sum  avg  var  hist  reg\n",
       "fields              1    2    3    10    5\n",
       "size_bytes         24   32   40    96   56\n",
       "expansion_factor  1.5  2.0  2.5   6.0  3.5"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "file_d = {\"paper\": \"figure5_out.json\", \"aws\": \"jmh-microbenchmark-results_0.json\", \"local\": \"figure5_out.json\"}\n",
    "\n",
    "def output(source):\n",
    "    \n",
    "    df = build_figure5_df(file=get_result_path(source.lower(), file_d))\n",
    "    \n",
    "    display(Markdown(f\"#### {source} Results\"))\n",
    "    \n",
    "    if df is None:\n",
    "        print(\"does not exist yet\")\n",
    "    else:\n",
    "        build_figure_5a(data=df, format_plot=source!=\"Local\")\n",
    "        if source == \"Paper\": # raspberry pi only for paper\n",
    "            build_figure_5b(data=df)\n",
    "        display(df)\n",
    "    \n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "for source in [\"Paper\",\"AWS\",\"Local\"]:\n",
    "    output(source)\n",
    "\n",
    "display(Markdown(f\"#### Bandwidth\"))\n",
    "df_bandwidth = build_producer_bandwidth_df()\n",
    "display(df_bandwidth)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "innocent-engineering",
   "metadata": {},
   "source": [
    "### Privacy Controller - Setup Phase (Table 1)\n",
    "\n",
    "Code Marker: [ECDHBenchmark.java](zeph-benchmarks/zeph-microbenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/crypto/ECDHBenchmark.java)\n",
    "\n",
    "#### `Optional:` Run the Microbenchmark for Table 1 locally (~10 min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "musical-ethernet",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/table1.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.58 ms, sys: 182 µs, total: 4.76 ms\n",
      "Wall time: 4.24 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Run the Microbenchmark for Table 1 locally (~10 min)\n",
    "\n",
    "#!java -jar zeph-benchmarks/zeph-microbenchmarks/target/zeph-microbenchmarks-1.0.jar testECDH -rf json -rff results/review-results/local/table1_out.json 2>&1 | tee logs/table1.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/table1.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seventh-trial",
   "metadata": {},
   "source": [
    "#### Description \n",
    "In the setup phase of the secure aggregation protocol, all involved privacy controllers participate in a Diffie-Hellman Key Exchange (ECDH).  \n",
    "We benchmark the computational cost for a single key exchange and extrapolate the cost for all key exchanges. \n",
    "The bandwidth and storage requirements are estimated based on the size of the keys that need to be distributed and stored. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "unusual-tuning",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_table1_df(file, config):\n",
    "    \n",
    "    n_privacy_controllers = [100, 1000, 10000, 100000]\n",
    "    \n",
    "    df_ecdh = load_ecdh(n_privacy_controllers=n_privacy_controllers, result_file=file)\n",
    "    \n",
    "    if df_ecdh is None:\n",
    "        return None\n",
    "    df_size = load_size_estimates(n_privacy_controllers=n_privacy_controllers, config=config)\n",
    "\n",
    "    df = df_ecdh.merge(df_size, how='outer', on=['n_privacy_controller'])\n",
    "    df['others'] = df['n_privacy_controller']-1\n",
    "    \n",
    "    \n",
    "    df = df[['n_privacy_controller', 'ecdh_public_key_bytes', 'ecdh_public_key_mb_global', 'shared_keys_bytes', 'ecdh_latency_ms', 'ecdh_latency_global_ms']]\n",
    "    \n",
    "    df = df.rename(columns={\"ecdh_public_key_bytes\": \"Bandwidth [bytes]\", \"ecdh_public_key_mb_global\": \"Bandwidth Total [MB]\", \"shared_keys_bytes\": \"Shared Keys [bytes]\", 'ecdh_latency_ms': \"ECDH [ms]\", 'ecdh_latency_global_ms': \"ECDH Total [ms]\"})\n",
    "\n",
    "    return df\n",
    "\n",
    "\n",
    "def load_ecdh(n_privacy_controllers, result_file):\n",
    "    try:\n",
    "        with open(result_file) as json_file:\n",
    "            data = json.load(json_file)\n",
    "    except (FileNotFoundError, ValueError) as e:\n",
    "        return None\n",
    "    \n",
    "    results = []\n",
    "    \n",
    "    for exp in data:\n",
    "        benchmark = exp['benchmark'].split(\".\")[-1]\n",
    "        if benchmark == \"testECDH\" and exp['mode']==\"avgt\":\n",
    "            ms_per_op = exp[\"primaryMetric\"][\"score\"] * 1000  \n",
    "            for n_pc in n_privacy_controllers:\n",
    "                d = {\n",
    "                    \"n_privacy_controller\": n_pc,\n",
    "                    \"ecdh_latency_ms\": (n_pc-1) * ms_per_op,\n",
    "                    \"ecdh_latency_global_ms\": n_pc*(n_pc-1) * ms_per_op\n",
    "                }\n",
    "                results.append(d)\n",
    "    df = pd.DataFrame(results)\n",
    "    return df\n",
    "\n",
    "\n",
    "def load_size_estimates(n_privacy_controllers, config):\n",
    "    \n",
    "    results = []\n",
    "    for n_pc in n_privacy_controllers:\n",
    "        d = {\n",
    "            \"n_privacy_controller\": n_pc,\n",
    "            \"certs_bytes\": config[\"x509_ecdh_certificate_bytes\"] * (n_pc-1),\n",
    "            \"ecdh_public_key_bytes\": config[\"ecdh_public_key_bytes\"] * (n_pc-1),\n",
    "            \"shared_keys_bytes\": config[\"shared_key_bytes\"] * (n_pc-1),\n",
    "            \"private_key_bytes\": config[\"ecdh_private_key_bytes\"],\n",
    "            #\"token_per_window_bytes\": config[\"number_of_fields\"] * config[\"field_bytes\"] * n_pc,\n",
    "            #\"values_per_window_mb\": config[\"number_of_fields\"] * config[\"field_bytes\"] * n_pc * config[\"number_of_values_per_window\"] * 10**(-6)\n",
    "        }\n",
    "        results.append(d)\n",
    "\n",
    "    df = pd.DataFrame(results)\n",
    "\n",
    "    df['shared_keys_mb'] =  df['shared_keys_bytes'] * 10**(-6)\n",
    "    df['certs_mb'] =  df['certs_bytes'] * 10**(-6)\n",
    "\n",
    "    df['certs_mb_global'] =  df['certs_bytes'] * 10**(-6) * df['n_privacy_controller']\n",
    "    df['certs_gb_global'] =  df['certs_bytes'] * 10**(-9) * df['n_privacy_controller']\n",
    "\n",
    "    df['ecdh_public_key_mb_global'] =  df['ecdh_public_key_bytes'] * 10**(-6) * df['n_privacy_controller']\n",
    "    \n",
    "    return df\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bored-stake",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Paper Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_privacy_controller</th>\n",
       "      <th>Bandwidth [bytes]</th>\n",
       "      <th>Bandwidth Total [MB]</th>\n",
       "      <th>Shared Keys [bytes]</th>\n",
       "      <th>ECDH [ms]</th>\n",
       "      <th>ECDH Total [ms]</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100</td>\n",
       "      <td>9009</td>\n",
       "      <td>0.9009</td>\n",
       "      <td>3168</td>\n",
       "      <td>24.691225</td>\n",
       "      <td>2.469123e+03</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1000</td>\n",
       "      <td>90909</td>\n",
       "      <td>90.9090</td>\n",
       "      <td>31968</td>\n",
       "      <td>249.156907</td>\n",
       "      <td>2.491569e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10000</td>\n",
       "      <td>909909</td>\n",
       "      <td>9099.0900</td>\n",
       "      <td>319968</td>\n",
       "      <td>2493.813727</td>\n",
       "      <td>2.493814e+07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>100000</td>\n",
       "      <td>9099909</td>\n",
       "      <td>909990.9000</td>\n",
       "      <td>3199968</td>\n",
       "      <td>24940.381926</td>\n",
       "      <td>2.494038e+09</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_privacy_controller  Bandwidth [bytes]  Bandwidth Total [MB]  \\\n",
       "0                   100               9009                0.9009   \n",
       "1                  1000              90909               90.9090   \n",
       "2                 10000             909909             9099.0900   \n",
       "3                100000            9099909           909990.9000   \n",
       "\n",
       "   Shared Keys [bytes]     ECDH [ms]  ECDH Total [ms]  \n",
       "0                 3168     24.691225     2.469123e+03  \n",
       "1                31968    249.156907     2.491569e+05  \n",
       "2               319968   2493.813727     2.493814e+07  \n",
       "3              3199968  24940.381926     2.494038e+09  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### AWS Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Local Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "file_d = {\"paper\": \"table1_out.json\", \"aws\": \"jmh-microbenchmark-results_0.json\", \"local\": \"table1_out.json\"}\n",
    "\n",
    "# numbers for ecdh_curve secp256r1 in Java\n",
    "config = {\n",
    "    \"ecdh_private_key_bytes\": 150,\n",
    "    \"ecdh_public_key_bytes\": 91,\n",
    "    \"x509_ecdh_certificate_bytes\": 366,\n",
    "    \"shared_key_bytes\": 32,\n",
    "}\n",
    "\n",
    "\n",
    "def output(source):\n",
    "    \n",
    "    df = build_table1_df(file=get_result_path(source.lower(), file_d), config=config)\n",
    "    \n",
    "    display(Markdown(f\"#### {source} Results\"))\n",
    "    \n",
    "    if df is None:\n",
    "        print(\"does not exist yet\")\n",
    "    else:\n",
    "        display(df)\n",
    "    \n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "for source in [\"Paper\",\"AWS\",\"Local\"]:\n",
    "    output(source)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "immune-zealand",
   "metadata": {},
   "source": [
    "### Privacy Controller - Transformation Phase: Secure Aggregation Optimization  (Figure 6)\n",
    "\n",
    "Code Marker: [TransformationTokenNativeBenchmark.java](zeph-benchmarks/zeph-microbenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/crypto/TransformationTokenNativeBenchmark.java)\n",
    "\n",
    "#### `Optional:` Run the Microbenchmark for Figure 6 locally (~3h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "settled-anaheim",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       " <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(' <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "moderate-assault",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/figure6.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.23 ms, sys: 0 ns, total: 6.23 ms\n",
      "Wall time: 5.56 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "#!java -jar zeph-benchmarks/zeph-microbenchmarks/target/zeph-microbenchmarks-1.0.jar testErdosRenyiNative testDreamNative testStrawmanNative -rf json -rff results/review-results/local/figure6_out.json -p dataDir=data -p size_win=100_256,1000_512,2000_800,5000_1344,10000_2304,1000_1,1000_8,1000_16,1000_64,1000_128 2>&1 | tee logs/figure6.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/figure6.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "material-revolution",
   "metadata": {},
   "source": [
    "#### Description\n",
    "\n",
    "In the transformation phase, a privacy controller creates a token to authorize a transformation. \n",
    "For multi-stream aggregations, this involves a secure aggregation protocol to hide the decrpytion key with a mask.\n",
    "\n",
    "We benchmark the computational cost involved in creating such a token with the Strawman Secure Aggregation protocol, the Dream optimization, and the new Zeph optimization (in the code called `erdos_renyi (er)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "informative-creator",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure6_df(file):\n",
    "    \n",
    "    try:\n",
    "        with open(file) as json_file:\n",
    "            data = json.load(json_file)\n",
    "    except (FileNotFoundError, ValueError) as e:\n",
    "        return None\n",
    "    \n",
    "    erdos_renyi = []\n",
    "    dream = []\n",
    "    strawman = []\n",
    "\n",
    "    optimal_w = {\n",
    "        \"100\": \"256\",\n",
    "        \"200\": \"256\",\n",
    "        \"500\": \"336\",\n",
    "        \"1000\": \"512\",\n",
    "        \"2000\": \"800\",\n",
    "        \"5000\": \"1344\",\n",
    "        \"10000\": \"2304\"\n",
    "    }\n",
    "\n",
    "    for x in data:\n",
    "        benchmark = x['benchmark'].split(\".\")[-1]\n",
    "\n",
    "        if benchmark not in ['testErdosRenyiNative', 'testStrawmanNative', 'testDreamNative']:\n",
    "            continue\n",
    "\n",
    "        size_win = x['params']['size_win'].split(\"_\")\n",
    "        parties = size_win[0]\n",
    "        rounds = size_win[1]\n",
    "        tp = x['secondaryMetrics']['count']['score']\n",
    "\n",
    "        avg_time_ms = 1 / (tp/1000)\n",
    "\n",
    "        rt_ms = 1/(x['secondaryMetrics']['count'][\"score\"]/1000)\n",
    "        rts_ms = [1/(x1/1000) for x1 in x['secondaryMetrics']['count'][\"rawData\"][0]]\n",
    "        rt_stddev_ms = stat.stdev(rts_ms)\n",
    "\n",
    "        tp_stddev = stat.stdev(x['secondaryMetrics']['count'][\"rawData\"][0])\n",
    "\n",
    "        d = {\"parties\": int(parties), \n",
    "             \"rounds\": int(rounds), \n",
    "             \"tp_rps\": float(tp), \n",
    "             \"avg_time_ms\": avg_time_ms,\n",
    "             \"tp_stddev\": tp_stddev,\n",
    "             \"avg_time_stddev\":rt_stddev_ms\n",
    "            }\n",
    "\n",
    "        if benchmark == 'testErdosRenyiNative':\n",
    "            d[\"opt_er\"] = optimal_w[parties] == rounds\n",
    "            erdos_renyi.append(d)\n",
    "        elif benchmark == 'testStrawmanNative':\n",
    "            strawman.append(d) \n",
    "        elif benchmark == 'testDreamNative':\n",
    "            dream.append(d)\n",
    "    \n",
    "    \n",
    "    df_dream = pd.DataFrame(dream).rename(columns={\"tp_rps\": \"tp_dream\", \"avg_time_ms\": \"avg_time_dream_ms\", \"tp_stddev\": \"tp_stddev_dream\", \"avg_time_stddev\": \"avg_time_stddev_dream\"})\n",
    "    df_strawman = pd.DataFrame(strawman).rename(columns={\"tp_rps\": \"tp_strawman\", \"avg_time_ms\": \"avg_time_strawman_ms\", \"tp_stddev\": \"tp_stddev_strawman\", \"avg_time_stddev\": \"avg_time_stddev_strawman\"})\n",
    "    df_erdos_renyi = pd.DataFrame(erdos_renyi).rename(columns={\"tp_rps\": \"tp_er\", \"avg_time_ms\": \"avg_time_er_ms\" ,\"tp_stddev\": \"tp_stddev_er\", \"avg_time_stddev\": \"avg_time_stddev_er\"})\n",
    "\n",
    "    df_prev = df_dream.merge(df_strawman, how='outer', on=['parties', 'rounds'])\n",
    "\n",
    "\n",
    "    df = df_prev.merge(df_erdos_renyi, how='outer', on=['parties', 'rounds'])\n",
    "    df.sort_values(by=['parties', 'rounds'], inplace=True)\n",
    "    \n",
    "    df = df[[\"parties\", \"rounds\", \"opt_er\", \n",
    "             \"avg_time_er_ms\", \"avg_time_stddev_er\", \n",
    "            \"avg_time_dream_ms\", \"avg_time_stddev_dream\",\n",
    "            \"avg_time_strawman_ms\", \"avg_time_stddev_strawman\"]]\n",
    "    \n",
    "    df[\"er_vs_strawman\"] = (df[\"avg_time_strawman_ms\"]/df[\"avg_time_er_ms\"]).apply(lambda x: f\"{int(round(x))}x\")\n",
    "    df[\"er_vs_dream\"] = (df[\"avg_time_dream_ms\"]/df[\"avg_time_er_ms\"]).apply(lambda x: f\"{int(round(x))}x\")\n",
    "    \n",
    "    return df\n",
    "    \n",
    "def build_figure_6a(data, format_plot):\n",
    "    \n",
    "    labels = []\n",
    "    for l in data[\"parties\"]:\n",
    "        if l >= 1000:\n",
    "            labels.append(str(int(l/1000)) + \"k\")\n",
    "        else:\n",
    "            labels.append(l)\n",
    "    \n",
    "    _barchart(labels=labels, x_label=\"Parties\", \n",
    "                values1=data['avg_time_er_ms'], label1=\"Zeph\", err1=data['avg_time_stddev_er'],\n",
    "                values2=data['avg_time_dream_ms'], label2=\"Dream\", err2=data['avg_time_stddev_dream'],\n",
    "                values3=data['avg_time_strawman_ms'], label3=\"Strawman\", err3=data['avg_time_stddev_strawman'],\n",
    "                ytick_base=0.5, format_plot=format_plot)\n",
    "    \n",
    "\n",
    "def build_figure_6b(data, format_plot):\n",
    "    labels = []\n",
    "    for l in data[\"rounds\"]:\n",
    "        if l >= 1000:\n",
    "            labels.append(str(int(l/1000)) + \"k\")\n",
    "        else:\n",
    "            labels.append(l)\n",
    "    \n",
    "    _barchart(labels=labels, x_label=\"Rounds\", \n",
    "                values1=data['avg_time_er_ms'], label1=\"Zeph\", err1=data['avg_time_stddev_er'],\n",
    "                values2=data['avg_time_dream_ms'], label2=\"Dream\", err2=data['avg_time_stddev_dream'],\n",
    "                values3=data['avg_time_strawman_ms'], label3=\"Strawman\", err3=data['avg_time_stddev_strawman'],\n",
    "                ytick_base=0.05, format_plot=format_plot)\n",
    "    \n",
    "    \n",
    "def _barchart(labels, x_label, \n",
    "                values1, label1, err1,\n",
    "                values2, label2, err2,\n",
    "                values3, label3, err3,\n",
    "                ytick_base=None,format_plot=True):\n",
    "\n",
    "    colors=['0.1', '0.45', '0.7']\n",
    "    \n",
    "    plt_params = {'backend': 'ps',\n",
    "              'axes.labelsize': 20,\n",
    "              'legend.fontsize': 16,\n",
    "              'xtick.labelsize': 18,\n",
    "              'ytick.labelsize': 18,\n",
    "              'font.size': 18,\n",
    "              'figure.figsize': [4.151100041511, 2.736555644111891],\n",
    "              'font.family': 'times new roman'}\n",
    "    \n",
    "    plt.rc('pdf', fonttype=42) \n",
    "    plt.rcParams.update(plt_params)\n",
    "    \n",
    "    f, ax1 = plt.subplots()\n",
    "    \n",
    "    ind = np.arange(0, len(labels)) * 1.2\n",
    "    bars1 = bars2 = bars3 = None\n",
    "    \n",
    "    capsize = 3\n",
    "    \n",
    "    width = 0.3  # the width of the bars\n",
    "    offset = width\n",
    "    bars1 = ax1.bar(ind - width, values1, width, label=label1, zorder=3, yerr=err1, capsize=capsize)\n",
    "    bars2 = ax1.bar(ind,         values2, width, label=label2, zorder=3, yerr=err2, capsize=capsize)\n",
    "    bars3 = ax1.bar(ind + width, values3, width, label=label3, zorder=3, yerr=err3, capsize=capsize)\n",
    "    min_value = min(values1 + values2 + values3)\n",
    "    max_value = max(values1 + values2 + values3) \n",
    "    \n",
    "\n",
    "    for id, bar in enumerate(bars1):\n",
    "        bar.set_facecolor(colors[0])\n",
    "    \n",
    "    if bars2:\n",
    "        for id, bar in enumerate(bars2):\n",
    "            bar.set_facecolor(colors[1])\n",
    "    \n",
    "    if bars3:\n",
    "        for id, bar in enumerate(bars3):\n",
    "            bar.set_facecolor(colors[2])\n",
    "    \n",
    "            \n",
    "    # format x axis\n",
    "    ax1.set_xlabel(x_label)\n",
    "    ax1.set_xticks(ind)\n",
    "    ax1.set_xticklabels(labels, rotation=345)\n",
    "    \n",
    "    legend = plt.legend(bbox_to_anchor=(0, 1.02,1, 0.2), loc=\"lower left\", mode=\"expand\")\n",
    "    \n",
    "    # format y axis\n",
    "    ax1.set_ylabel(\"Computation [ms]\")\n",
    "    if min_value > 400000 and max_value > 2000000:\n",
    "        ax1.yaxis.set_major_formatter(ticker.FuncFormatter(lambda y, pos: '%.1fM' % (y * 1e-6)))\n",
    "    \n",
    "    plt.gca().yaxis.grid(True, linestyle=':', color='0.6', zorder=0, linewidth=1.2)\n",
    "    \n",
    "    ax1.set_ylim(ymin=0, ymax=None)\n",
    "    \n",
    "    if format_plot:\n",
    "        loc = plticker.MultipleLocator(base=ytick_base)\n",
    "        ax1.yaxis.set_major_locator(loc)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "public-ivory",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Paper Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Figure 6a: Average per Round\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parties</th>\n",
       "      <th>rounds</th>\n",
       "      <th>opt_er</th>\n",
       "      <th>avg_time_er_ms</th>\n",
       "      <th>avg_time_stddev_er</th>\n",
       "      <th>avg_time_dream_ms</th>\n",
       "      <th>avg_time_stddev_dream</th>\n",
       "      <th>avg_time_strawman_ms</th>\n",
       "      <th>avg_time_stddev_strawman</th>\n",
       "      <th>er_vs_strawman</th>\n",
       "      <th>er_vs_dream</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>100</td>\n",
       "      <td>256</td>\n",
       "      <td>True</td>\n",
       "      <td>0.014882</td>\n",
       "      <td>0.000049</td>\n",
       "      <td>0.020858</td>\n",
       "      <td>0.000067</td>\n",
       "      <td>0.024648</td>\n",
       "      <td>0.000081</td>\n",
       "      <td>2x</td>\n",
       "      <td>1x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1000</td>\n",
       "      <td>512</td>\n",
       "      <td>True</td>\n",
       "      <td>0.018208</td>\n",
       "      <td>0.000099</td>\n",
       "      <td>0.133560</td>\n",
       "      <td>0.000591</td>\n",
       "      <td>0.221207</td>\n",
       "      <td>0.000084</td>\n",
       "      <td>12x</td>\n",
       "      <td>7x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>2000</td>\n",
       "      <td>800</td>\n",
       "      <td>True</td>\n",
       "      <td>0.018379</td>\n",
       "      <td>0.000074</td>\n",
       "      <td>0.250294</td>\n",
       "      <td>0.001180</td>\n",
       "      <td>0.441289</td>\n",
       "      <td>0.001595</td>\n",
       "      <td>24x</td>\n",
       "      <td>14x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>5000</td>\n",
       "      <td>1344</td>\n",
       "      <td>True</td>\n",
       "      <td>0.022417</td>\n",
       "      <td>0.000098</td>\n",
       "      <td>0.622989</td>\n",
       "      <td>0.002355</td>\n",
       "      <td>1.089592</td>\n",
       "      <td>0.003651</td>\n",
       "      <td>49x</td>\n",
       "      <td>28x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>10000</td>\n",
       "      <td>2304</td>\n",
       "      <td>True</td>\n",
       "      <td>0.023130</td>\n",
       "      <td>0.000028</td>\n",
       "      <td>1.263283</td>\n",
       "      <td>0.013793</td>\n",
       "      <td>2.227773</td>\n",
       "      <td>0.016268</td>\n",
       "      <td>96x</td>\n",
       "      <td>55x</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    parties  rounds  opt_er  avg_time_er_ms  avg_time_stddev_er  \\\n",
       "25      100     256    True        0.014882            0.000049   \n",
       "10     1000     512    True        0.018208            0.000099   \n",
       "28     2000     800    True        0.018379            0.000074   \n",
       "29     5000    1344    True        0.022417            0.000098   \n",
       "23    10000    2304    True        0.023130            0.000028   \n",
       "\n",
       "    avg_time_dream_ms  avg_time_stddev_dream  avg_time_strawman_ms  \\\n",
       "25           0.020858               0.000067              0.024648   \n",
       "10           0.133560               0.000591              0.221207   \n",
       "28           0.250294               0.001180              0.441289   \n",
       "29           0.622989               0.002355              1.089592   \n",
       "23           1.263283               0.013793              2.227773   \n",
       "\n",
       "    avg_time_stddev_strawman er_vs_strawman er_vs_dream  \n",
       "25                  0.000081             2x          1x  \n",
       "10                  0.000084            12x          7x  \n",
       "28                  0.001595            24x         14x  \n",
       "29                  0.003651            49x         28x  \n",
       "23                  0.016268            96x         55x  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "\n",
      "Figure 6b: Varied Rounds for 1k Parties\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parties</th>\n",
       "      <th>rounds</th>\n",
       "      <th>opt_er</th>\n",
       "      <th>avg_time_er_ms</th>\n",
       "      <th>avg_time_stddev_er</th>\n",
       "      <th>avg_time_dream_ms</th>\n",
       "      <th>avg_time_stddev_dream</th>\n",
       "      <th>avg_time_strawman_ms</th>\n",
       "      <th>avg_time_stddev_strawman</th>\n",
       "      <th>er_vs_strawman</th>\n",
       "      <th>er_vs_dream</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000</td>\n",
       "      <td>8</td>\n",
       "      <td>False</td>\n",
       "      <td>0.180647</td>\n",
       "      <td>0.001689</td>\n",
       "      <td>0.132006</td>\n",
       "      <td>0.000519</td>\n",
       "      <td>0.221286</td>\n",
       "      <td>0.000152</td>\n",
       "      <td>1x</td>\n",
       "      <td>1x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1000</td>\n",
       "      <td>16</td>\n",
       "      <td>False</td>\n",
       "      <td>0.099266</td>\n",
       "      <td>0.000382</td>\n",
       "      <td>0.131152</td>\n",
       "      <td>0.000601</td>\n",
       "      <td>0.220955</td>\n",
       "      <td>0.000066</td>\n",
       "      <td>2x</td>\n",
       "      <td>1x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1000</td>\n",
       "      <td>64</td>\n",
       "      <td>False</td>\n",
       "      <td>0.036403</td>\n",
       "      <td>0.000168</td>\n",
       "      <td>0.133543</td>\n",
       "      <td>0.000558</td>\n",
       "      <td>0.221561</td>\n",
       "      <td>0.000065</td>\n",
       "      <td>6x</td>\n",
       "      <td>4x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1000</td>\n",
       "      <td>128</td>\n",
       "      <td>False</td>\n",
       "      <td>0.025973</td>\n",
       "      <td>0.000005</td>\n",
       "      <td>0.133021</td>\n",
       "      <td>0.000474</td>\n",
       "      <td>0.221238</td>\n",
       "      <td>0.000126</td>\n",
       "      <td>9x</td>\n",
       "      <td>5x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>1000</td>\n",
       "      <td>512</td>\n",
       "      <td>True</td>\n",
       "      <td>0.018208</td>\n",
       "      <td>0.000099</td>\n",
       "      <td>0.133560</td>\n",
       "      <td>0.000591</td>\n",
       "      <td>0.221207</td>\n",
       "      <td>0.000084</td>\n",
       "      <td>12x</td>\n",
       "      <td>7x</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    parties  rounds  opt_er  avg_time_er_ms  avg_time_stddev_er  \\\n",
       "4      1000       8   False        0.180647            0.001689   \n",
       "5      1000      16   False        0.099266            0.000382   \n",
       "7      1000      64   False        0.036403            0.000168   \n",
       "8      1000     128   False        0.025973            0.000005   \n",
       "10     1000     512    True        0.018208            0.000099   \n",
       "\n",
       "    avg_time_dream_ms  avg_time_stddev_dream  avg_time_strawman_ms  \\\n",
       "4            0.132006               0.000519              0.221286   \n",
       "5            0.131152               0.000601              0.220955   \n",
       "7            0.133543               0.000558              0.221561   \n",
       "8            0.133021               0.000474              0.221238   \n",
       "10           0.133560               0.000591              0.221207   \n",
       "\n",
       "    avg_time_stddev_strawman er_vs_strawman er_vs_dream  \n",
       "4                   0.000152             1x          1x  \n",
       "5                   0.000066             2x          1x  \n",
       "7                   0.000065             6x          4x  \n",
       "8                   0.000126             9x          5x  \n",
       "10                  0.000084            12x          7x  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " First Round:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parties</th>\n",
       "      <th>rounds</th>\n",
       "      <th>opt_er</th>\n",
       "      <th>avg_time_er_ms</th>\n",
       "      <th>avg_time_stddev_er</th>\n",
       "      <th>avg_time_dream_ms</th>\n",
       "      <th>avg_time_stddev_dream</th>\n",
       "      <th>avg_time_strawman_ms</th>\n",
       "      <th>avg_time_stddev_strawman</th>\n",
       "      <th>er_vs_strawman</th>\n",
       "      <th>er_vs_dream</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1000</td>\n",
       "      <td>1</td>\n",
       "      <td>False</td>\n",
       "      <td>1.333075</td>\n",
       "      <td>0.00746</td>\n",
       "      <td>0.130519</td>\n",
       "      <td>0.000487</td>\n",
       "      <td>0.220113</td>\n",
       "      <td>0.000078</td>\n",
       "      <td>0x</td>\n",
       "      <td>0x</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   parties  rounds  opt_er  avg_time_er_ms  avg_time_stddev_er  \\\n",
       "3     1000       1   False        1.333075             0.00746   \n",
       "\n",
       "   avg_time_dream_ms  avg_time_stddev_dream  avg_time_strawman_ms  \\\n",
       "3           0.130519               0.000487              0.220113   \n",
       "\n",
       "   avg_time_stddev_strawman er_vs_strawman er_vs_dream  \n",
       "3                  0.000078             0x          0x  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### AWS Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Local Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "file_d = {\"paper\": \"figure6_out.json\", \"aws\": \"jmh-microbenchmark-results_0.json\", \"local\": \"figure6_out.json\"}\n",
    "\n",
    "def output(source):\n",
    "    \n",
    "    df = build_figure6_df(file=get_result_path(source.lower(), file_d))\n",
    "    \n",
    "    display(Markdown(f\"#### {source} Results\"))\n",
    "\n",
    "    if df is None:\n",
    "        print(\"does not exist yet\")\n",
    "    else:\n",
    "        print(\"Figure 6a: Average per Round\")\n",
    "        parties = [100, 1000, 2000, 5000, 10000]\n",
    "        df_6a = df[df[\"parties\"].isin(parties) & (df[\"opt_er\"]==1)]\n",
    "        build_figure_6a(data=df_6a, format_plot=source!=\"Local\")\n",
    "\n",
    "        display(df_6a)\n",
    "\n",
    "        print(\"\\n\\n\\nFigure 6b: Varied Rounds for 1k Parties\")\n",
    "        rounds =  [8, 16, 64, 128, 512]\n",
    "        df_6b = df[df[\"rounds\"].isin(rounds) & (df[\"parties\"]==1000)]\n",
    "        build_figure_6b(data=df_6b, format_plot=source!=\"Local\")\n",
    "\n",
    "        display(df_6b)\n",
    "        \n",
    "        print(\"\\n First Round:\")\n",
    "        df_1st = df[(df[\"rounds\"]==1) & (df[\"parties\"]==1000)]\n",
    "        display(df_1st)\n",
    "        \n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "for source in [\"Paper\",\"AWS\",\"Local\"]:\n",
    "    output(source)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "champion-spank",
   "metadata": {},
   "source": [
    "### Privacy Controller - Transformation Phase: Bandwidth (Figure 7a)\n",
    "The bandwidth analysis of the privacy controller during the transformation phase includes coordination information about the transformation (e.g., which participant dropped out) and the transformation token itself. If more participants drop out, this means that the messages that include this information grow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "aboriginal-committee",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure7a_df(config):\n",
    "    \n",
    "    results = []\n",
    "    for diff_percentage in config[\"diff_percentages\"]:\n",
    "        \n",
    "        for num_controllers in config[\"controller_options\"]:\n",
    "\n",
    "            bandwidth_per_controller = _get_conroller_mpc_bandwidth_bytes(universe_size=num_controllers, diff_percentage=diff_percentage, encoding_size=3)\n",
    "\n",
    "            d = {\n",
    "                \"num_controllers\": num_controllers,\n",
    "                \"diff_percentage\": diff_percentage,\n",
    "                \"diffs\":  int(num_controllers * diff_percentage),\n",
    "                \"bandwidth_per_controller_KB\": bandwidth_per_controller / 1000,\n",
    "                \"bandwidth_KB\" : num_controllers * bandwidth_per_controller / 1000\n",
    "            }\n",
    "\n",
    "            results.append(d)\n",
    "\n",
    "    df = pd.DataFrame(results)\n",
    "    \n",
    "    return df\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "def build_figure_7a(data):\n",
    "    \n",
    "    diff_percentages = data[\"diff_percentage\"].unique()\n",
    "    \n",
    "    # we show three lines\n",
    "    \n",
    "    df0 = data[data[\"diff_percentage\"] == diff_percentages[0]]\n",
    "    df1 = data[data[\"diff_percentage\"] == diff_percentages[1]]\n",
    "    df2 = data[data[\"diff_percentage\"] == diff_percentages[2]]\n",
    "    \n",
    "    labels = df0[\"num_controllers\"]   \n",
    "    \n",
    "    colors = [\"0.6\", \"0.3\", \"0.1\"]\n",
    "    linestyles = ['-', '--',':']\n",
    "    \n",
    "    plt_params = {'backend': 'ps',\n",
    "              'axes.labelsize': 20,\n",
    "              'legend.fontsize': 16,\n",
    "              'xtick.labelsize': 18,\n",
    "              'ytick.labelsize': 18,\n",
    "              'font.size': 18,\n",
    "              'figure.figsize': [4.151100041511, 2.736555644111891],\n",
    "              'font.family': 'times new roman'}\n",
    "    \n",
    "    plt.rc('pdf', fonttype=42) \n",
    "    plt.rcParams.update(plt_params)\n",
    "    \n",
    "    f, ax1 = plt.subplots()    \n",
    "    \n",
    "    capsize = 5\n",
    "    \n",
    "    \n",
    "    plt.errorbar(labels, df0[\"bandwidth_per_controller_KB\"],  yerr=None, label=f\"pΔ = {diff_percentages[0]}\", color=colors[0], marker=None, linestyle=linestyles[0], linewidth=2, capsize=capsize)\n",
    "\n",
    "    plt.errorbar(labels, df1[\"bandwidth_per_controller_KB\"],  yerr=None, label=f\"pΔ = {diff_percentages[1]}\", color=colors[1], marker=None, linestyle=linestyles[1], linewidth=2, capsize=capsize)\n",
    "    \n",
    "    plt.errorbar(labels, df2[\"bandwidth_per_controller_KB\"],  yerr=None, label=f\"pΔ = {diff_percentages[2]}\", color=colors[2], marker=None, linestyle=linestyles[2], linewidth=2, capsize=capsize)\n",
    "    \n",
    "    \n",
    "    plt.gca().grid(True, linestyle=':', axis=\"y\", color='0.6', zorder=0, linewidth=1)\n",
    "    \n",
    "    plt.xlabel(\"Number of Data Streams\")\n",
    "    plt.ylabel(\"Traffic [KB]\")\n",
    "  \n",
    "    plt.ylim(ymin=0, ymax=10)\n",
    "\n",
    "\n",
    "    handles, labels = ax1.get_legend_handles_labels()\n",
    "    handles = [h[0] for h in handles]\n",
    "    ax1.legend(handles, labels ,numpoints=1, title=None ,labelspacing=.08)\n",
    "\n",
    "    \n",
    "    loc = plticker.MultipleLocator(base=2)\n",
    "    ax1.yaxis.set_major_locator(loc)        \n",
    "\n",
    "    loc = plticker.MultipleLocator(base=2000)\n",
    "    ax1.xaxis.set_major_locator(loc)\n",
    "    \n",
    "    ax1.xaxis.set_major_formatter(lambda x, pos: f\"{int(x/1000)}k\")\n",
    "      \n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "def _get_conroller_mpc_bandwidth_bytes(universe_size, diff_percentage=0.0, encoding_size=3):\n",
    "    timestamp_size = 8\n",
    "    value_size = 8\n",
    "    digest_size = encoding_size * value_size\n",
    "    window_size = 2 * timestamp_size\n",
    "    id_size = 8\n",
    "\n",
    "    diff_size = id_size\n",
    "    trigger_commit_msg_size = window_size\n",
    "    commit_msg_size =  window_size + id_size\n",
    "    \n",
    "    diffs = int(universe_size * diff_percentage)\n",
    "    trigger_transformation_token_msg_size = window_size + diffs * diff_size\n",
    "\n",
    "    transformation_token_msg_size = id_size + window_size + digest_size\n",
    "\n",
    "    bandwidth_per_controller = trigger_commit_msg_size + commit_msg_size + trigger_transformation_token_msg_size + transformation_token_msg_size\n",
    "\n",
    "    \n",
    "    return bandwidth_per_controller"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "incoming-throw",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Show every 3rd row of data:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>num_controllers</th>\n",
       "      <th>diff_percentage</th>\n",
       "      <th>diffs</th>\n",
       "      <th>bandwidth_per_controller_KB</th>\n",
       "      <th>bandwidth_KB</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>1.04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>300</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>31.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>600</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>62.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>2000</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>208.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>5000</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>520.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>8000</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>832.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>10</td>\n",
       "      <td>0.05</td>\n",
       "      <td>0</td>\n",
       "      <td>0.104</td>\n",
       "      <td>1.04</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>300</td>\n",
       "      <td>0.05</td>\n",
       "      <td>15</td>\n",
       "      <td>0.224</td>\n",
       "      <td>67.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>600</td>\n",
       "      <td>0.05</td>\n",
       "      <td>30</td>\n",
       "      <td>0.344</td>\n",
       "      <td>206.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>2000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>100</td>\n",
       "      <td>0.904</td>\n",
       "      <td>1808.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>5000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>250</td>\n",
       "      <td>2.104</td>\n",
       "      <td>10520.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>8000</td>\n",
       "      <td>0.05</td>\n",
       "      <td>400</td>\n",
       "      <td>3.304</td>\n",
       "      <td>26432.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>10</td>\n",
       "      <td>0.10</td>\n",
       "      <td>1</td>\n",
       "      <td>0.112</td>\n",
       "      <td>1.12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>300</td>\n",
       "      <td>0.10</td>\n",
       "      <td>30</td>\n",
       "      <td>0.344</td>\n",
       "      <td>103.20</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>600</td>\n",
       "      <td>0.10</td>\n",
       "      <td>60</td>\n",
       "      <td>0.584</td>\n",
       "      <td>350.40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>2000</td>\n",
       "      <td>0.10</td>\n",
       "      <td>200</td>\n",
       "      <td>1.704</td>\n",
       "      <td>3408.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>5000</td>\n",
       "      <td>0.10</td>\n",
       "      <td>500</td>\n",
       "      <td>4.104</td>\n",
       "      <td>20520.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>51</th>\n",
       "      <td>8000</td>\n",
       "      <td>0.10</td>\n",
       "      <td>800</td>\n",
       "      <td>6.504</td>\n",
       "      <td>52032.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    num_controllers  diff_percentage  diffs  bandwidth_per_controller_KB  \\\n",
       "0                10             0.00      0                        0.104   \n",
       "3               300             0.00      0                        0.104   \n",
       "6               600             0.00      0                        0.104   \n",
       "9              2000             0.00      0                        0.104   \n",
       "12             5000             0.00      0                        0.104   \n",
       "15             8000             0.00      0                        0.104   \n",
       "18               10             0.05      0                        0.104   \n",
       "21              300             0.05     15                        0.224   \n",
       "24              600             0.05     30                        0.344   \n",
       "27             2000             0.05    100                        0.904   \n",
       "30             5000             0.05    250                        2.104   \n",
       "33             8000             0.05    400                        3.304   \n",
       "36               10             0.10      1                        0.112   \n",
       "39              300             0.10     30                        0.344   \n",
       "42              600             0.10     60                        0.584   \n",
       "45             2000             0.10    200                        1.704   \n",
       "48             5000             0.10    500                        4.104   \n",
       "51             8000             0.10    800                        6.504   \n",
       "\n",
       "    bandwidth_KB  \n",
       "0           1.04  \n",
       "3          31.20  \n",
       "6          62.40  \n",
       "9         208.00  \n",
       "12        520.00  \n",
       "15        832.00  \n",
       "18          1.04  \n",
       "21         67.20  \n",
       "24        206.40  \n",
       "27       1808.00  \n",
       "30      10520.00  \n",
       "33      26432.00  \n",
       "36          1.12  \n",
       "39        103.20  \n",
       "42        350.40  \n",
       "45       3408.00  \n",
       "48      20520.00  \n",
       "51      52032.00  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config = {\n",
    "    \"diff_percentages\": [0, 0.05, 0.1],\n",
    "    \"controller_options\": [10, 100, 200, 300, 400, 500, 600, 700, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000]\n",
    "}\n",
    "\n",
    "df = build_figure7a_df(config=config)\n",
    "\n",
    "build_figure_7a(data=df)\n",
    "\n",
    "print(\"\\n\\nShow every 3rd row of data:\")\n",
    "display(df[df.index % 3 == 0])\n",
    "\n",
    "# uncomment to show the full data:\n",
    "# display(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changing-imagination",
   "metadata": {},
   "source": [
    "### Privacy Controller - Transformation Phase: Storage (Figure 7b) \n",
    "During the privacy transformation phase, a privacy controller needs to store the pre-computed secure aggregation graphs and all the shared keys of the other participants.\n",
    "We show analytically how the storage requirements grow as we increase the number of involved parties.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "beneficial-being",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure7b_df(config):\n",
    "    \n",
    "    params = []\n",
    "    # Note: see later a more descriptive version of how to get the optimal parameters\n",
    "    \n",
    "    for N in range(100, config[\"N_limit\"]+1, config[\"N_step_size\"]):\n",
    "        k = _get_k(N=N, alpha=config[\"alpha\"], delta=config[\"delta\"])\n",
    "        if k:\n",
    "            w = 2**k\n",
    "            n = int(config[\"alpha\"] * N)\n",
    "            W = int(128/k) * w\n",
    "            p = 1 / w\n",
    "            d ={\n",
    "                    \"N\": N, \"n\": n, \"k\": k, \"w\": w, \"W\": W, \"p\": p,\n",
    "                    \"fail_bound\": W * er_probability_bound(n=n, p=p),\n",
    "                    \"e_degree\": (N-1) / w,\n",
    "                    \"alpha\": config[\"alpha\"],\n",
    "                    \"delta\": config[\"delta\"]\n",
    "            }\n",
    "            params.append(d)\n",
    "        else:\n",
    "            d ={\n",
    "                \"N\": N,\n",
    "                \"alpha\": config[\"alpha\"],\n",
    "                \"delta\": config[\"delta\"]\n",
    "            }\n",
    "            params.append(d)\n",
    "\n",
    "    df = pd.DataFrame(params)\n",
    "    \n",
    "    # 128 bit ouput of prf, have k-bit segements => have 128/k segments\n",
    "    df[\"storage\"] = 128 / df[\"k\"]\n",
    "\n",
    "    df[\"storage_sharedkeys_kb\"] =  df[\"N\"] * 32 / 1000\n",
    "\n",
    "    # df[\"storage\"] is the number of segments, for each segment we need to store the id of every participant once (*N), each id is a long (*8)\n",
    "    df[\"storage_kb\"] = df[\"storage_sharedkeys_kb\"] + df[\"storage\"] * df[\"N\"] * 8 / 1000\n",
    "    \n",
    "    \n",
    "    df = df[[\"N\", \"k\", \"storage_kb\", \"storage_sharedkeys_kb\"]]\n",
    "    \n",
    "    return df\n",
    "\n",
    "    \n",
    "def build_figure_7b(data):\n",
    "\n",
    "    plt_params = {'backend': 'ps',\n",
    "              'axes.labelsize': 20,\n",
    "              'legend.fontsize': 16,\n",
    "              'xtick.labelsize': 18,\n",
    "              'ytick.labelsize': 18,\n",
    "              'font.size': 18,\n",
    "              'figure.figsize': [4.151100041511, 2.736555644111891],\n",
    "              'font.family': 'times new roman'}\n",
    "    \n",
    "    plt.rc('pdf', fonttype=42) \n",
    "    plt.rcParams.update(plt_params)\n",
    "    \n",
    "    f, ax1 = plt.subplots()    \n",
    "    \n",
    "    capsize = 5\n",
    "    \n",
    "\n",
    "    plt.errorbar(data[\"N\"], data[\"storage_kb\"],  yerr=None, label=\"Shared Keys + Graphs\", color=\"0.1\", marker=None, linestyle=':', linewidth=2, capsize=capsize)\n",
    "\n",
    "    plt.errorbar(data[\"N\"], data[\"storage_sharedkeys_kb\"],  yerr=None, label=\"Shared Keys\", color=\"0.3\", marker=None, linestyle='-', linewidth=2, capsize=capsize)\n",
    "    \n",
    "    \n",
    "    \n",
    "    plt.gca().grid(True, linestyle=':', axis=\"y\", color='0.6', zorder=0, linewidth=1)\n",
    "    \n",
    "    plt.xlabel(\"Parties\")\n",
    "    plt.ylabel(\"Storage [KB]\")\n",
    "  \n",
    "    plt.ylim(ymin=0, ymax=2999)\n",
    "\n",
    "\n",
    "    handles, labels = ax1.get_legend_handles_labels()\n",
    "    handles = [h[0] for h in handles]\n",
    "    ax1.legend(handles, labels ,numpoints=1, title=None ,labelspacing=.08)\n",
    "\n",
    "    \n",
    "    loc = plticker.MultipleLocator(base=500)\n",
    "    ax1.yaxis.set_major_locator(loc)        \n",
    "\n",
    "    loc = plticker.MultipleLocator(base=2000)\n",
    "    ax1.xaxis.set_major_locator(loc)\n",
    "    \n",
    "    ax1.xaxis.set_major_formatter(lambda x, pos: f\"{int(x/1000)}k\")\n",
    "      \n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "\n",
    "def er_probability_bound(n, p):\n",
    "    bound = 0.0\n",
    "    for j in range(1, int(n/2) + 1):\n",
    "        uj = ((math.e * n)/j * (1-p) ** (n-j))**j\n",
    "        bound += uj\n",
    "    return bound\n",
    "\n",
    "def _get_k(N, alpha, delta):\n",
    "    n = int(alpha * N)\n",
    "         \n",
    "    for k in range(1, 20):\n",
    "        w = 2**k\n",
    "        W = int(128/k) * w\n",
    "        \n",
    "        p = 1 / w\n",
    "\n",
    "        fail_bound = W * er_probability_bound(n=n, p=p)\n",
    "        \n",
    "        if fail_bound > delta:\n",
    "            if k-1 > 0:\n",
    "                return k-1\n",
    "            else:\n",
    "                return None\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "scientific-sentence",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Show every 50'th row of data:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>N</th>\n",
       "      <th>k</th>\n",
       "      <th>storage_kb</th>\n",
       "      <th>storage_sharedkeys_kb</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100</td>\n",
       "      <td>1</td>\n",
       "      <td>105.600000</td>\n",
       "      <td>3.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>600</td>\n",
       "      <td>3</td>\n",
       "      <td>224.000000</td>\n",
       "      <td>19.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>1100</td>\n",
       "      <td>4</td>\n",
       "      <td>316.800000</td>\n",
       "      <td>35.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>150</th>\n",
       "      <td>1600</td>\n",
       "      <td>4</td>\n",
       "      <td>460.800000</td>\n",
       "      <td>51.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>200</th>\n",
       "      <td>2100</td>\n",
       "      <td>5</td>\n",
       "      <td>497.280000</td>\n",
       "      <td>67.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>250</th>\n",
       "      <td>2600</td>\n",
       "      <td>5</td>\n",
       "      <td>615.680000</td>\n",
       "      <td>83.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>300</th>\n",
       "      <td>3100</td>\n",
       "      <td>5</td>\n",
       "      <td>734.080000</td>\n",
       "      <td>99.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>350</th>\n",
       "      <td>3600</td>\n",
       "      <td>5</td>\n",
       "      <td>852.480000</td>\n",
       "      <td>115.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>400</th>\n",
       "      <td>4100</td>\n",
       "      <td>6</td>\n",
       "      <td>830.933333</td>\n",
       "      <td>131.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>450</th>\n",
       "      <td>4600</td>\n",
       "      <td>6</td>\n",
       "      <td>932.266667</td>\n",
       "      <td>147.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>500</th>\n",
       "      <td>5100</td>\n",
       "      <td>6</td>\n",
       "      <td>1033.600000</td>\n",
       "      <td>163.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>550</th>\n",
       "      <td>5600</td>\n",
       "      <td>6</td>\n",
       "      <td>1134.933333</td>\n",
       "      <td>179.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>600</th>\n",
       "      <td>6100</td>\n",
       "      <td>6</td>\n",
       "      <td>1236.266667</td>\n",
       "      <td>195.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>650</th>\n",
       "      <td>6600</td>\n",
       "      <td>6</td>\n",
       "      <td>1337.600000</td>\n",
       "      <td>211.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>700</th>\n",
       "      <td>7100</td>\n",
       "      <td>6</td>\n",
       "      <td>1438.933333</td>\n",
       "      <td>227.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>750</th>\n",
       "      <td>7600</td>\n",
       "      <td>6</td>\n",
       "      <td>1540.266667</td>\n",
       "      <td>243.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>800</th>\n",
       "      <td>8100</td>\n",
       "      <td>6</td>\n",
       "      <td>1641.600000</td>\n",
       "      <td>259.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>850</th>\n",
       "      <td>8600</td>\n",
       "      <td>7</td>\n",
       "      <td>1533.257143</td>\n",
       "      <td>275.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>900</th>\n",
       "      <td>9100</td>\n",
       "      <td>7</td>\n",
       "      <td>1622.400000</td>\n",
       "      <td>291.2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>950</th>\n",
       "      <td>9600</td>\n",
       "      <td>7</td>\n",
       "      <td>1711.542857</td>\n",
       "      <td>307.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        N  k   storage_kb  storage_sharedkeys_kb\n",
       "0     100  1   105.600000                    3.2\n",
       "50    600  3   224.000000                   19.2\n",
       "100  1100  4   316.800000                   35.2\n",
       "150  1600  4   460.800000                   51.2\n",
       "200  2100  5   497.280000                   67.2\n",
       "250  2600  5   615.680000                   83.2\n",
       "300  3100  5   734.080000                   99.2\n",
       "350  3600  5   852.480000                  115.2\n",
       "400  4100  6   830.933333                  131.2\n",
       "450  4600  6   932.266667                  147.2\n",
       "500  5100  6  1033.600000                  163.2\n",
       "550  5600  6  1134.933333                  179.2\n",
       "600  6100  6  1236.266667                  195.2\n",
       "650  6600  6  1337.600000                  211.2\n",
       "700  7100  6  1438.933333                  227.2\n",
       "750  7600  6  1540.266667                  243.2\n",
       "800  8100  6  1641.600000                  259.2\n",
       "850  8600  7  1533.257143                  275.2\n",
       "900  9100  7  1622.400000                  291.2\n",
       "950  9600  7  1711.542857                  307.2"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config = {\n",
    "    \"alpha\": 0.5,\n",
    "    \"delta\": 1.0E-7,\n",
    "    \"N_limit\": 10000,\n",
    "    \"N_step_size\": 10\n",
    "}\n",
    "\n",
    "df = build_figure7b_df(config=config)\n",
    "\n",
    "build_figure_7b(data=df)\n",
    "\n",
    "print(\"\\n\\nShow every 50'th row of data:\")\n",
    "display(df[df.index % 50 == 0])\n",
    "\n",
    "# uncomment to show the full data:\n",
    "#display(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "surrounded-australian",
   "metadata": {},
   "source": [
    "### Privacy Controller - Transformation Phase: Drop-Outs (Figure 8)\n",
    "\n",
    "Code Marker: [PrivacyControllerBenchmark.java](zeph-benchmarks/zeph-microbenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/PrivacyControllerBenchmark.java)\n",
    "\n",
    "#### `Optional:` Run the Microbenchmark for Figure 8 locally (~1h 10min)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "comprehensive-moore",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/figure8.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.58 ms, sys: 0 ns, total: 3.58 ms\n",
      "Wall time: 2.9 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# addE_addNE_dropE_dropNE: addE-> number of returning parties with which we share a mask in the token (edge), addNE-> number of returning parties with which we don't share a mask (edge) in the token\n",
    "\n",
    "# added: 0_10_0_0,0_50_0_0,0_100_0_0,0_200_0_0,0_300_0_0,0_400_0_0,0_500_0_0\n",
    "# dropped: 0_0_0_10,0_0_0_50,0_0_0_100,0_0_0_200,0_0_0_300,0_0_0_400,0_0_0_500\n",
    "# combined: 0_10_0_10,0_50_0_50,0_100_0_100,0_200_0_200,0_300_0_300,0_400_0_400,0_500_0_500\n",
    "\n",
    "#!java -jar zeph-benchmarks/zeph-microbenchmarks/target/zeph-microbenchmarks-1.0.jar testUniverseDelta -rf json -rff results/review-results/local/figure8_out.json -p dataDir=data -p universeSize=1000 -p addE_addNE_dropE_dropNE=0_10_0_0,0_50_0_0,0_100_0_0,0_200_0_0,0_300_0_0,0_400_0_0,0_500_0_0,0_0_0_10,0_0_0_50,0_0_0_100,0_0_0_200,0_0_0_300,0_0_0_400,0_0_0_500,0_10_0_10,0_50_0_50,0_100_0_100,0_200_0_200,0_300_0_300,0_400_0_400 2>&1 | tee logs/figure8.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/figure8.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "initial-vertical",
   "metadata": {},
   "source": [
    "#### Description \n",
    "\n",
    "Parties can dynamically dropout or return from a previous dropout. Incorporating these changes into the transformation token has a small overhead depending on the number of changes (delta). \n",
    "As a first step, we benchmarked the difference between a return/dropout from a participant with and without a shared mask in the token. We observed that the difference was marginal and thus we only focus the benchmark on reacting to changes from participants that do not share a pairwise mask in the token. The reason for this is that, the number of pairwise shared masks is small and hence the number of parties that could return or dropout (x-axis) would be limited. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "industrial-union",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure8_df(file):\n",
    "    \n",
    "    try:\n",
    "        with open(file) as json_file:\n",
    "            data = json.load(json_file)\n",
    "    except (FileNotFoundError, ValueError) as e:\n",
    "        return None\n",
    "\n",
    "    results = []\n",
    "\n",
    "    for x in data:\n",
    "        benchmark_class = x['benchmark'].split(\".\")[-1]\n",
    "\n",
    "        if benchmark_class != \"testUniverseDelta\":\n",
    "            continue\n",
    "\n",
    "        benchmark = x['benchmark'].split(\".\")[-1]\n",
    "\n",
    "        parts = x['params']['addE_addNE_dropE_dropNE'].split(\"_\")\n",
    "        score = x['primaryMetric']['score']\n",
    "        unit = x['primaryMetric']['scoreUnit']\n",
    "\n",
    "        stddev = stat.stdev(x['primaryMetric']['rawData'][0])\n",
    "\n",
    "        d = {\n",
    "            \"n_parties\": x['params']['universeSize'],\n",
    "            \"addE\": parts[0],\n",
    "            \"addNE\": parts[1],\n",
    "            \"dropE\": parts[2],\n",
    "            \"dropNE\": parts[3],\n",
    "            \"latency\": score,\n",
    "            \"stddev\": stddev,\n",
    "            \"unit\": unit,\n",
    "            \"maxDelta\": max(map(lambda x: int(x), parts))\n",
    "        }\n",
    "\n",
    "        results.append(d)\n",
    "\n",
    "\n",
    "    df = pd.DataFrame(results)\n",
    "    df = df.drop_duplicates(['n_parties', 'addE', 'addNE', 'dropE', 'dropNE']).sort_values(['maxDelta'])\n",
    "\n",
    "\n",
    "    df = df[df['maxDelta'].astype(int)<500]\n",
    "\n",
    "    df = df[[\"n_parties\", \"addNE\", \"dropNE\", \"latency\", \"stddev\", \"unit\", \"maxDelta\"]]\n",
    "    df = df.rename(columns={\"addNE\": \"n_parties_added\", \"dropNE\": \"n_parties_dropped\"})\n",
    "    \n",
    "\n",
    "    \n",
    "    def _get_type(row):\n",
    "        n_parties_added = int(row[\"n_parties_added\"])\n",
    "        n_parties_dropped = int(row[\"n_parties_dropped\"])\n",
    "        \n",
    "        \n",
    "        if n_parties_added == 0 and n_parties_dropped  > 0:\n",
    "            return \"dropped\"\n",
    "        elif n_parties_added > 0 and n_parties_dropped==0:\n",
    "            return \"returned\"\n",
    "        elif n_parties_added > 0 and n_parties_dropped>0:\n",
    "            return \"combined\"\n",
    "        else:\n",
    "            return \"none\"\n",
    "    \n",
    "    \n",
    "    df[\"type\"] = df.apply(lambda x: _get_type(x), axis=1)\n",
    "    \n",
    "    df = df[df[\"type\"] != \"none\"]\n",
    "    \n",
    "    df = df.sort_values([\"type\",\"maxDelta\"])    \n",
    "\n",
    "\n",
    "    return df\n",
    "\n",
    "def build_figure_8(data, format_plot):\n",
    "    \n",
    "\n",
    "    colors=[\"0.1\", \"0.3\", \"0.6\"]\n",
    "    linestyles=[\":\", \"--\", \"-\"]\n",
    "\n",
    "    df_dropped = data[data[\"type\"]==\"dropped\"]\n",
    "    df_returned = data[data[\"type\"]==\"returned\"]\n",
    "    df_combined = data[data[\"type\"]==\"combined\"]\n",
    "\n",
    "    plt_params = {'backend': 'ps',\n",
    "              'axes.labelsize': 20,\n",
    "              'legend.fontsize': 16,\n",
    "              'xtick.labelsize': 18,\n",
    "              'ytick.labelsize': 18,\n",
    "              'font.size': 18,\n",
    "              'figure.figsize': [4.151100041511, 2.736555644111891],\n",
    "              'font.family': 'times new roman'}\n",
    "    \n",
    "    plt.rc('pdf', fonttype=42) \n",
    "    plt.rcParams.update(plt_params)\n",
    "\n",
    "    f, ax1 = plt.subplots()    \n",
    "    \n",
    "    capsize = 5\n",
    "    \n",
    "    plt.errorbar(df_dropped[\"maxDelta\"], df_dropped[\"latency\"]/1000,  yerr=df_dropped[\"stddev\"]/1000, label=\"Dropped\", color=colors[0], marker=None, linestyle=linestyles[0], linewidth=2, capsize=capsize)\n",
    "    plt.errorbar(df_returned[\"maxDelta\"], df_returned[\"latency\"]/1000,  yerr=df_returned[\"stddev\"]/1000, label=\"Returned\", color=colors[1], marker=None, linestyle=linestyles[1], linewidth=2, capsize=capsize)\n",
    "    plt.errorbar(df_combined[\"maxDelta\"], df_combined[\"latency\"]/1000,  yerr=df_combined[\"stddev\"]/1000, label=\"Combined\", color=colors[2], marker=None, linestyle=linestyles[2], linewidth=2, capsize=capsize)\n",
    "    \n",
    "    \n",
    "    plt.gca().grid(True, linestyle=':', axis=\"y\", color='0.6', zorder=0, linewidth=1)\n",
    "    \n",
    "    plt.xlabel(\"Parties [Δ]\")\n",
    "    plt.ylabel(\"Computation [ms]\")\n",
    "  \n",
    "    ymax = None\n",
    "    if format_plot:\n",
    "        ymax= 0.75\n",
    "        \n",
    "        loc = plticker.MultipleLocator(base=0.2)\n",
    "        ax1.yaxis.set_major_locator(loc)        \n",
    "\n",
    "        loc = plticker.MultipleLocator(base=100)\n",
    "        ax1.xaxis.set_major_locator(loc)\n",
    "\n",
    "    plt.ylim(ymin=0, ymax=ymax)\n",
    "\n",
    "    handles, labels = ax1.get_legend_handles_labels()\n",
    "    handles = [h[0] for h in handles]\n",
    "    ax1.legend(handles, labels ,numpoints=1, title=None ,labelspacing=.08)\n",
    "    \n",
    "          \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "purple-harvey",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Paper Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 298.879x197.032 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>n_parties</th>\n",
       "      <th>n_parties_added</th>\n",
       "      <th>n_parties_dropped</th>\n",
       "      <th>latency</th>\n",
       "      <th>stddev</th>\n",
       "      <th>unit</th>\n",
       "      <th>maxDelta</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>1000</td>\n",
       "      <td>10</td>\n",
       "      <td>10</td>\n",
       "      <td>34.050341</td>\n",
       "      <td>0.580871</td>\n",
       "      <td>us/op</td>\n",
       "      <td>10</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>1000</td>\n",
       "      <td>50</td>\n",
       "      <td>50</td>\n",
       "      <td>86.797568</td>\n",
       "      <td>0.560283</td>\n",
       "      <td>us/op</td>\n",
       "      <td>50</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>1000</td>\n",
       "      <td>100</td>\n",
       "      <td>100</td>\n",
       "      <td>149.250568</td>\n",
       "      <td>1.428473</td>\n",
       "      <td>us/op</td>\n",
       "      <td>100</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>1000</td>\n",
       "      <td>200</td>\n",
       "      <td>200</td>\n",
       "      <td>269.877543</td>\n",
       "      <td>2.062880</td>\n",
       "      <td>us/op</td>\n",
       "      <td>200</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>1000</td>\n",
       "      <td>300</td>\n",
       "      <td>300</td>\n",
       "      <td>374.864016</td>\n",
       "      <td>2.519177</td>\n",
       "      <td>us/op</td>\n",
       "      <td>300</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>1000</td>\n",
       "      <td>400</td>\n",
       "      <td>400</td>\n",
       "      <td>500.109543</td>\n",
       "      <td>2.725325</td>\n",
       "      <td>us/op</td>\n",
       "      <td>400</td>\n",
       "      <td>combined</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>10</td>\n",
       "      <td>21.421411</td>\n",
       "      <td>0.316984</td>\n",
       "      <td>us/op</td>\n",
       "      <td>10</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>27.498522</td>\n",
       "      <td>0.523997</td>\n",
       "      <td>us/op</td>\n",
       "      <td>50</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>100</td>\n",
       "      <td>32.270630</td>\n",
       "      <td>0.514671</td>\n",
       "      <td>us/op</td>\n",
       "      <td>100</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>200</td>\n",
       "      <td>45.046231</td>\n",
       "      <td>0.608595</td>\n",
       "      <td>us/op</td>\n",
       "      <td>200</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>300</td>\n",
       "      <td>53.176812</td>\n",
       "      <td>1.098796</td>\n",
       "      <td>us/op</td>\n",
       "      <td>300</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>1000</td>\n",
       "      <td>0</td>\n",
       "      <td>400</td>\n",
       "      <td>72.238111</td>\n",
       "      <td>0.862732</td>\n",
       "      <td>us/op</td>\n",
       "      <td>400</td>\n",
       "      <td>dropped</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1000</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>32.264201</td>\n",
       "      <td>0.561894</td>\n",
       "      <td>us/op</td>\n",
       "      <td>10</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1000</td>\n",
       "      <td>50</td>\n",
       "      <td>0</td>\n",
       "      <td>79.994675</td>\n",
       "      <td>0.867837</td>\n",
       "      <td>us/op</td>\n",
       "      <td>50</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>1000</td>\n",
       "      <td>100</td>\n",
       "      <td>0</td>\n",
       "      <td>137.222261</td>\n",
       "      <td>0.949562</td>\n",
       "      <td>us/op</td>\n",
       "      <td>100</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>1000</td>\n",
       "      <td>200</td>\n",
       "      <td>0</td>\n",
       "      <td>238.711441</td>\n",
       "      <td>0.882989</td>\n",
       "      <td>us/op</td>\n",
       "      <td>200</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>1000</td>\n",
       "      <td>300</td>\n",
       "      <td>0</td>\n",
       "      <td>339.741157</td>\n",
       "      <td>1.660750</td>\n",
       "      <td>us/op</td>\n",
       "      <td>300</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>1000</td>\n",
       "      <td>400</td>\n",
       "      <td>0</td>\n",
       "      <td>447.180082</td>\n",
       "      <td>2.303378</td>\n",
       "      <td>us/op</td>\n",
       "      <td>400</td>\n",
       "      <td>returned</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   n_parties n_parties_added n_parties_dropped     latency    stddev   unit  \\\n",
       "19      1000              10                10   34.050341  0.580871  us/op   \n",
       "20      1000              50                50   86.797568  0.560283  us/op   \n",
       "21      1000             100               100  149.250568  1.428473  us/op   \n",
       "22      1000             200               200  269.877543  2.062880  us/op   \n",
       "27      1000             300               300  374.864016  2.519177  us/op   \n",
       "28      1000             400               400  500.109543  2.725325  us/op   \n",
       "11      1000               0                10   21.421411  0.316984  us/op   \n",
       "13      1000               0                50   27.498522  0.523997  us/op   \n",
       "16      1000               0               100   32.270630  0.514671  us/op   \n",
       "17      1000               0               200   45.046231  0.608595  us/op   \n",
       "25      1000               0               300   53.176812  1.098796  us/op   \n",
       "26      1000               0               400   72.238111  0.862732  us/op   \n",
       "2       1000              10                 0   32.264201  0.561894  us/op   \n",
       "4       1000              50                 0   79.994675  0.867837  us/op   \n",
       "7       1000             100                 0  137.222261  0.949562  us/op   \n",
       "8       1000             200                 0  238.711441  0.882989  us/op   \n",
       "23      1000             300                 0  339.741157  1.660750  us/op   \n",
       "24      1000             400                 0  447.180082  2.303378  us/op   \n",
       "\n",
       "    maxDelta      type  \n",
       "19        10  combined  \n",
       "20        50  combined  \n",
       "21       100  combined  \n",
       "22       200  combined  \n",
       "27       300  combined  \n",
       "28       400  combined  \n",
       "11        10   dropped  \n",
       "13        50   dropped  \n",
       "16       100   dropped  \n",
       "17       200   dropped  \n",
       "25       300   dropped  \n",
       "26       400   dropped  \n",
       "2         10  returned  \n",
       "4         50  returned  \n",
       "7        100  returned  \n",
       "8        200  returned  \n",
       "23       300  returned  \n",
       "24       400  returned  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### AWS Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### Local Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "file_d = {\"paper\": \"figure8_out.json\", \"aws\": \"jmh-microbenchmark-results_0.json\", \"local\": \"figure8_out.json\"}\n",
    "\n",
    "def output(source):\n",
    "    \n",
    "    df = build_figure8_df(file=get_result_path(source.lower(), file_d))\n",
    "    \n",
    "    display(Markdown(f\"#### {source} Results\"))\n",
    "    \n",
    "    if df is None:\n",
    "        print(\"does not exist yet\")\n",
    "    else:\n",
    "        build_figure_8(data=df, format_plot=source!=\"Local\")\n",
    "        display(df)\n",
    "    \n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "for source in [\"Paper\",\"AWS\",\"Local\"]:\n",
    "    output(source)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charming-frank",
   "metadata": {},
   "source": [
    "### Privacy Controller - Secure Aggregation Optimization\n",
    "\n",
    "The Zeph Secure Aggregation optimization constructs a series of random graphs. The number of graphs (rounds per epochs) depends on the number of parties (`N`), the assumption on the maximum fraction of colluding parties (`alpha`), and a failure probability bound (`delta`). (Details can be found in the supplementary material of the paper)\n",
    "\n",
    "We show how many graphs we can construct with a given configuration and the resulting number of prf evaluations and  additions in comparison to Dream and Strawman."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "imported-macro",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_secure_aggregation_comparison_df(config):\n",
    "    \n",
    "    optimal_k = _get_opt_k(N=config[\"N\"], alpha=config[\"alpha\"], delta=config[\"delta\"])\n",
    "    \n",
    "    if optimal_k is None:\n",
    "        print(f\"The config={config} cannot be satisfied.\")\n",
    "        return None\n",
    "    \n",
    "    num_graphs_per_segment = 2**optimal_k\n",
    "    min_num_honest_clients = int(config[\"alpha\"] * config[\"N\"])\n",
    "    \n",
    "    num_graphs = int(128/optimal_k) * num_graphs_per_segment # number of rounds in epoch\n",
    "    \n",
    "    d = {\n",
    "        \"N\": config[\"N\"],\n",
    "        \"alpha\": config[\"alpha\"],\n",
    "        \"delta\": config[\"delta\"],\n",
    "        \"b\": optimal_k,\n",
    "        \"n_rounds_per_epoch\": num_graphs,\n",
    "        \"small_graph_expected_degree\": round((config[\"N\"]-1) / num_graphs_per_segment),\n",
    "        \"clique_graph_degree\": config[\"N\"] -1\n",
    "    }\n",
    "    \n",
    "    num_fields_per_event = 1\n",
    "    \n",
    "    d[\"zeph_num_prf\"] =  num_fields_per_event * d[\"n_rounds_per_epoch\"] * d[\"small_graph_expected_degree\"] +  config[\"N\"] -1\n",
    "    d[\"zeph_num_add\"] =  num_fields_per_event * d[\"n_rounds_per_epoch\"] * d[\"small_graph_expected_degree\"]\n",
    "    \n",
    "    # dream creates in each round a new small graph. Deriving and adding the mask has to be done in each round on the small graph\n",
    "    d[\"dream_num_add\"] =  num_fields_per_event * d[\"n_rounds_per_epoch\"] * d[\"small_graph_expected_degree\"] \n",
    "    d[\"dream_num_prf\"] = d[\"n_rounds_per_epoch\"] * (num_fields_per_event * d[\"small_graph_expected_degree\"] +  config[\"N\"] - 1)\n",
    "    \n",
    "    d[\"strawman_num_prf\"] = num_fields_per_event * d[\"n_rounds_per_epoch\"] * d[\"clique_graph_degree\"] \n",
    "    d[\"strawman_num_add\"] = num_fields_per_event * d[\"n_rounds_per_epoch\"] * d[\"clique_graph_degree\"] \n",
    "    \n",
    "    df = pd.DataFrame([d])\n",
    "    \n",
    "    return df.set_index([\"N\", \"alpha\", \"delta\"])\n",
    "    \n",
    "    \n",
    "def _er_probability_bound(n, p):\n",
    "    # bound on probability that erdos renyi graph G(n,p) is disconnected\n",
    "    bound = 0.0\n",
    "    for j in range(1, int(n/2) + 1):\n",
    "        uj = ((math.e * n)/j * (1-p) ** (n-j))**j\n",
    "        bound += uj\n",
    "    return bound\n",
    "\n",
    "def _get_opt_k(N, alpha, delta):\n",
    "    min_num_honest_clients = int(alpha * N)\n",
    "         \n",
    "    # try to find largest k such that failure probability threshold delta is satisfied\n",
    "    for k in range(1, 20):\n",
    "        \n",
    "        num_graphs_per_segment = 2**k \n",
    "        num_graphs = int(128/k) * num_graphs_per_segment\n",
    "        \n",
    "        # each graph (of honest clients) is erdos renyi graph with:\n",
    "        p = 1 / num_graphs_per_segment\n",
    "\n",
    "        # union bound over the number of graphs\n",
    "        fail_bound = num_graphs * er_probability_bound(n=min_num_honest_clients, p=p)\n",
    "        \n",
    "        # if fail bound is greater than delta, then the previous k is the max k that satisfies the bound\n",
    "        if fail_bound > delta:\n",
    "            if k-1 > 0:\n",
    "                return k-1\n",
    "            else:\n",
    "                return None\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "structured-fireplace",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>b</th>\n",
       "      <th>n_rounds_per_epoch</th>\n",
       "      <th>small_graph_expected_degree</th>\n",
       "      <th>clique_graph_degree</th>\n",
       "      <th>zeph_num_prf</th>\n",
       "      <th>zeph_num_add</th>\n",
       "      <th>dream_num_add</th>\n",
       "      <th>dream_num_prf</th>\n",
       "      <th>strawman_num_prf</th>\n",
       "      <th>strawman_num_add</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>N</th>\n",
       "      <th>alpha</th>\n",
       "      <th>delta</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>10000</th>\n",
       "      <th>0.5</th>\n",
       "      <th>1.000000e-09</th>\n",
       "      <td>7</td>\n",
       "      <td>2304</td>\n",
       "      <td>78</td>\n",
       "      <td>9999</td>\n",
       "      <td>189711</td>\n",
       "      <td>179712</td>\n",
       "      <td>179712</td>\n",
       "      <td>23217408</td>\n",
       "      <td>23037696</td>\n",
       "      <td>23037696</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                          b  n_rounds_per_epoch  small_graph_expected_degree  \\\n",
       "N     alpha delta                                                              \n",
       "10000 0.5   1.000000e-09  7                2304                           78   \n",
       "\n",
       "                          clique_graph_degree  zeph_num_prf  zeph_num_add  \\\n",
       "N     alpha delta                                                           \n",
       "10000 0.5   1.000000e-09                 9999        189711        179712   \n",
       "\n",
       "                          dream_num_add  dream_num_prf  strawman_num_prf  \\\n",
       "N     alpha delta                                                          \n",
       "10000 0.5   1.000000e-09         179712       23217408          23037696   \n",
       "\n",
       "                          strawman_num_add  \n",
       "N     alpha delta                           \n",
       "10000 0.5   1.000000e-09          23037696  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "config = {\n",
    "    \"N\": 10000, # number of parties (privacy controllers)\n",
    "    \"alpha\": 0.5, # max fraction of parties colluding with adversary\n",
    "    \"delta\": 1.0E-9# failure probability threshold\n",
    "}\n",
    "\n",
    "df = build_secure_aggregation_comparison_df(config=config)\n",
    "\n",
    "display(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "extraordinary-thomson",
   "metadata": {},
   "source": [
    "## End-to-End Application Scenarios (Figure 9)\n",
    "Since in the end-to-end setting, Zeph relies on and is comprised of multiple components (distributed data producers, distributed privacy controllers, Kafka cluster, Kafka Streams data transformer), we run Zeph in this setting only on AWS.\n",
    "The transformations in the end-to-end experiments aggregate over all attributes and encodings to show the worst-case performance for the specific application.\n",
    "\n",
    "**Note that you cannot run the end-to-end benchmark while the microbenchmarks are running on AWS**\n",
    "\n",
    "#### Running **All** End-to-End Benchmarks on AWS (2h 30min~ min)\n",
    "The complete end-to-end benchmark for figure 9 can be run with the command below.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "automotive-portland",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       " <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(' <a href=\"\", data-commandlinker-command=\"terminal:create-new\" >Open new Terminal</a> (alternative to execute shell command in a blocking cell)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "sustainable-dining",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/e2e_full.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 0 ns, sys: 3.47 ms, total: 3.47 ms\n",
      "Wall time: 2.71 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Execute the full benchmark with all three applications and 300 and 1200 parties:\n",
    "\n",
    "#!ansible-playbook ansible/e2epaper.yml -i ansible/inventory --private-key ~/.ssh/id_rsa_zeph --ssh-common-args='-o StrictHostKeyChecking=no' --forks=24 2>&1 | tee logs/e2e_full.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/e2e_full.log))\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "realistic-theology",
   "metadata": {},
   "source": [
    "#### Running **a single** End-to-End Benchmark on AWS (~ 1h 10min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "grand-egyptian",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/e2e_single.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.71 ms, sys: 0 ns, total: 3.71 ms\n",
      "Wall time: 2.91 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Execute the benchmark (plaintext vs zeph) for a fix number of clients and for only one application.\n",
    "\n",
    "# application one of [polar, web, car]\n",
    "# num_parties must be a multiple of 300 (due to the three client regions and 100er partitioning)\n",
    "# forks: the provided number of forks only supports up to 1200 clients.\n",
    "\n",
    "# Advanced: if you want to run two or more experiments with this command, you could comment out the \"Cleanup AWS\" in ansible/e2esingle.yml and in the end use the command at the top of the JupyterLab to cleanup all resources. \n",
    "# (has the advantage that in between two runs, we don't terminate all resources and have to start them again for the next run) \n",
    "\n",
    "\n",
    "#!ansible-playbook ansible/e2esingle.yml -i ansible/inventory -e \"application=car num_parties=300\" --forks 24 --private-key ~/.ssh/id_rsa_zeph --ssh-common-args='-o StrictHostKeyChecking=no' 2>&1 | tee logs/e2e_single.log\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/e2e_single.log))\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "satellite-terminology",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def build_figure9_df(dir):\n",
    "\n",
    "    folder = dir\n",
    "    experiments = [\"e2e_plaintext_polar\", \"e2e_plaintext_web\", \"e2e_plaintext_car\", \"e2e_zeph_polar\", \"e2e_zeph_web\", \"e2e_zeph_car\"] \n",
    "\n",
    "    files = []\n",
    "    for exp in experiments:\n",
    "        f = glob.glob(folder + f\"/{exp}_*.json\")\n",
    "        f = [(x, exp) for x in f]\n",
    "        files += f\n",
    "\n",
    "    zeph = []\n",
    "    plaintext = []\n",
    "\n",
    "    grace = 5000 # the earliest possible moment where the data transformer could output the result is when the 5s grace period is over (after window closes)\n",
    "\n",
    "    for file, exp in files:\n",
    "        with open(file) as json_file:\n",
    "            data = json.load(json_file)\n",
    "\n",
    "        latency = 0\n",
    "        count = 0\n",
    "\n",
    "        latencies = []\n",
    "\n",
    "        for res in data[\"data\"][2:-2]: # exclude a warmup period and a cool down period\n",
    "            latency += res[\"latency\"] \n",
    "            count += 1\n",
    "            latencies.append(res[\"latency\"]- grace)\n",
    "\n",
    "        if count < 8:\n",
    "            print(f\"not enough data points: {file}\")\n",
    "            continue\n",
    "\n",
    "\n",
    "        avg_latency = latency / count - grace\n",
    "\n",
    "        parties = data[\"config\"][\"universeSize\"]\n",
    "        expo_delay_mean = data[\"config\"][\"expoDelayMean\"]\n",
    "\n",
    "        d = {\n",
    "                \"parties\": int(parties),\n",
    "                \"latency\": int(avg_latency),\n",
    "                \"expo_delay_mean\": expo_delay_mean,\n",
    "                \"latencies\": np.array(latencies),\n",
    "                \"median_latency\": stat.median(latencies),\n",
    "                \"exp_id\": exp,\n",
    "                \"application\": exp.split(\"_\")[-1]\n",
    "            }\n",
    "        \n",
    "\n",
    "        benchmarkType = data['config']['benchmarkType']\n",
    "\n",
    "        if benchmarkType == 'zeph'or benchmarkType == 'policycrypt':\n",
    "            zeph.append(d)\n",
    "        elif benchmarkType == 'plaintext':\n",
    "            plaintext.append(d)\n",
    "        else:\n",
    "            print(f\"unknown benchmark type: {file}\")\n",
    "\n",
    "    if len(zeph) == 0:\n",
    "        return None\n",
    "    \n",
    "    df_zeph = pd.DataFrame(zeph).rename(columns={\"median_latency\": \"median_latency_zeph_ms\" ,\"latency\": \"mean_latency_zeph_ms\", \"latencies\": \"latencies_zeph_ms\"})\n",
    "    df_zeph = df_zeph.sort_values(by=['exp_id']) \n",
    "    df_zeph =   df_zeph.drop_duplicates(subset=['parties', 'application'], keep=\"last\") # for duplicates, keep element with highest exp_id (i.e. later result file)\n",
    "    \n",
    "    df_plaintext = pd.DataFrame(plaintext).rename(columns={\"median_latency\": \"median_latency_plaintext_ms\", \"latency\": \"mean_latency_plaintext_ms\", \"latencies\": \"latencies_plaintext_ms\"}) #.drop_duplicates()\n",
    "    df_plaintext = df_plaintext.sort_values(by=['exp_id']) \n",
    "    df_plaintext =   df_plaintext.drop_duplicates(subset=['parties', 'application'], keep=\"last\")\n",
    "    \n",
    "    df = df_zeph.merge(df_plaintext, how='outer', on=['parties', 'expo_delay_mean', 'application']).sort_values(by=['application', 'parties'])  \n",
    "    df = df.drop(columns=['exp_id_x', 'exp_id_y'])\n",
    "    df[\"median_difference_ms\"] = df[\"median_latency_zeph_ms\"] - df[\"median_latency_plaintext_ms\"]\n",
    "    \n",
    "    \n",
    "    df[\"overhead_factor_median\"] = df[\"median_latency_zeph_ms\"] / df[\"median_latency_plaintext_ms\"]\n",
    "    try:\n",
    "        df[\"overhead_factor_median\"] = df[\"overhead_factor_median\"].apply(lambda x: f\"{int(round(x))}x\")\n",
    "    except ValueError:\n",
    "        pass\n",
    "    \n",
    "    return df\n",
    "\n",
    "def build_figure_9(data, plot_format):\n",
    "    \n",
    "    fig_width_pt = 300.0  # Get this from LaTeX using \\showthe\n",
    "    inches_per_pt = 1.0 / 72.27 * 2  # Convert pt to inches\n",
    "    golden_mean = ((np.math.sqrt(5) - 1.0) / 2.0) * .8  # Aesthetic ratio\n",
    "    fig_width = fig_width_pt * inches_per_pt  # width in inches\n",
    "    fig_height = (fig_width * golden_mean)  # height in inches\n",
    "    fig_size =  [fig_width, fig_height]\n",
    "\n",
    "    colors=[\"0.1\", \"0.45\", \"0.7\"]\n",
    "    linestyles=[\":\", \"--\", \"-\"]\n",
    "    \n",
    "    figsize=[fig_size[0], 2/3 * fig_size[1]]\n",
    "\n",
    "    plt_params = {'backend': 'ps',\n",
    "                  'axes.labelsize': 20,\n",
    "                  'legend.fontsize': 16,\n",
    "                  'xtick.labelsize': 18,\n",
    "                  'ytick.labelsize': 18,\n",
    "                  'font.size': 18,\n",
    "                  'figure.figsize': fig_size,\n",
    "                  'font.family': 'times new roman'}\n",
    "    \n",
    "\n",
    "    plt_params_bp = plt_params\n",
    "    plt_params_bp['figure.figsize'] = figsize\n",
    "    \n",
    "    plt.rcParams.update(plt_params_bp)\n",
    "    plt.rc('pdf', fonttype=42)\n",
    "\n",
    "    def set_box_color(bp, color):\n",
    "        plt.setp(bp['boxes'], color=color)\n",
    "        plt.setp(bp['whiskers'], color=color)\n",
    "        plt.setp(bp['caps'], color=color)\n",
    "        plt.setp(bp['medians'], color=color)\n",
    "        plt.setp(bp['fliers'], color=color)\n",
    "        #plt.setp(bp['outliers'], color=color)\n",
    "\n",
    "    scale = 2\n",
    "    widths = 0.5\n",
    "    \n",
    "\n",
    "    fig, axes = plt.subplots(ncols=3, sharey=True)\n",
    "    fig.subplots_adjust(wspace=0)\n",
    "    \n",
    "    \n",
    "  \n",
    "    for i, ax, app, name in zip(range(3), axes, [\"polar\", \"web\", \"car\"], [\"Fitness App\", \"Web Analytics\", \"Car Sensors\"]):\n",
    "        df_exp = data[(data[\"application\"] == app)]\n",
    "        \n",
    "        if i == 0:\n",
    "            ax.set_ylabel(\"Latency [sec]\")\n",
    "\n",
    "        if i == 1:\n",
    "            ax.set_xlabel(\"Data Producers / Privacy Controllers\")\n",
    "\n",
    "\n",
    "        \n",
    "        if df_exp.empty and i == 2:\n",
    "            ax.legend([bp1[\"boxes\"][0], bp2[\"boxes\"][0]], [\"Plaintext\", \"Zeph\"])\n",
    "            continue\n",
    "        elif df_exp.empty:\n",
    "            continue\n",
    "\n",
    "        labels = df_exp[\"parties\"].values\n",
    "        values1 = df_exp[\"latencies_plaintext_ms\"].values / 1000\n",
    "        values2 = df_exp[\"latencies_zeph_ms\"].values / 1000\n",
    "    \n",
    "        positions1 = np.array(range(len(values1))) * scale - 0.3\n",
    "        positions2 = np.array(range(len(values2))) * scale + 0.3\n",
    "    \n",
    "        bp1 = ax.boxplot(values1, False, '+', positions=positions1, patch_artist=True, widths=widths)\n",
    "        set_box_color(bp1, colors[0])   \n",
    "   \n",
    "        bp2 = ax.boxplot(values2, False, '+', positions=positions2, patch_artist=True, widths=widths)\n",
    "        set_box_color(bp2, colors[1])\n",
    "\n",
    "        if i == 2:\n",
    "            ax.legend([bp1[\"boxes\"][0], bp2[\"boxes\"][0]], [\"Plaintext\", \"Zeph\"])\n",
    "        \n",
    "        \n",
    "\n",
    "        ax.set_xlim(-1, len(labels) * scale - 1)\n",
    "\n",
    "        ax.set_ylim(ymin=0)\n",
    "        ax.set_xticks(range(0, len(labels) * scale, scale))\n",
    "        ax.set(xticklabels=labels)\n",
    "        \n",
    "        if plot_format:\n",
    "            ax.yaxis.set_major_locator(plticker.MultipleLocator(0.5))\n",
    "\n",
    "        ax.grid(True, axis=\"y\", linestyle=':', color='0.6', zorder=0, linewidth=1.2)\n",
    "\n",
    "        ax2 = ax.twiny()\n",
    "        ax2.set_xticks([])\n",
    "        ax2.set_xlabel(name)\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "appropriate-paris",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "#### Paper Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 597.758x197.032 with 6 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>parties</th>\n",
       "      <th>mean_latency_zeph_ms</th>\n",
       "      <th>expo_delay_mean</th>\n",
       "      <th>latencies_zeph_ms</th>\n",
       "      <th>median_latency_zeph_ms</th>\n",
       "      <th>application</th>\n",
       "      <th>mean_latency_plaintext_ms</th>\n",
       "      <th>latencies_plaintext_ms</th>\n",
       "      <th>median_latency_plaintext_ms</th>\n",
       "      <th>median_difference_ms</th>\n",
       "      <th>overhead_factor_median</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>300</td>\n",
       "      <td>412</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[511, 436, 505, 414, 399, 287, 378, 460, 349, 427, 302, 365, 504, 440]</td>\n",
       "      <td>420.5</td>\n",
       "      <td>car</td>\n",
       "      <td>114</td>\n",
       "      <td>[80, 128, 135, 110, 132, 153, 109, 63, 152, 97, 107, 112, 105]</td>\n",
       "      <td>110.0</td>\n",
       "      <td>310.5</td>\n",
       "      <td>4x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1200</td>\n",
       "      <td>857</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[1196, 2126, 1222, 912, 757, 758, 692, 806, 743, 496, 469, 531, 433]</td>\n",
       "      <td>757.0</td>\n",
       "      <td>car</td>\n",
       "      <td>307</td>\n",
       "      <td>[315, 247, 295, 374, 296, 355, 325, 311, 315, 274, 259, 315, 360, 270]</td>\n",
       "      <td>313.0</td>\n",
       "      <td>444.0</td>\n",
       "      <td>2x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>300</td>\n",
       "      <td>728</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[2137, 1835, 452, 492, 575, 506, 471, 521, 427, 562, 481, 522, 487]</td>\n",
       "      <td>506.0</td>\n",
       "      <td>polar</td>\n",
       "      <td>122</td>\n",
       "      <td>[121, 160, 134, 105, 176, 137, 168, 96, 98, 102, 98, 85, 108]</td>\n",
       "      <td>108.0</td>\n",
       "      <td>398.0</td>\n",
       "      <td>5x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1200</td>\n",
       "      <td>1145</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[2253, 2001, 889, 955, 761, 973, 1056, 895, 880, 1232, 805, 1361, 829]</td>\n",
       "      <td>955.0</td>\n",
       "      <td>polar</td>\n",
       "      <td>314</td>\n",
       "      <td>[345, 344, 318, 268, 338, 305, 305, 341, 305, 317, 319, 298, 285]</td>\n",
       "      <td>317.0</td>\n",
       "      <td>638.0</td>\n",
       "      <td>3x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>300</td>\n",
       "      <td>605</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[806, 661, 492, 511, 583, 452, 466, 1197, 437, 591, 600, 574, 531, 574]</td>\n",
       "      <td>574.0</td>\n",
       "      <td>web</td>\n",
       "      <td>115</td>\n",
       "      <td>[84, 113, 122, 105, 115, 115, 87, 142, 93, 221, 75, 95, 132]</td>\n",
       "      <td>113.0</td>\n",
       "      <td>461.0</td>\n",
       "      <td>5x</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>1200</td>\n",
       "      <td>1193</td>\n",
       "      <td>0.5</td>\n",
       "      <td>[2310, 1179, 1005, 1031, 1001, 983, 1008, 1055, 2051, 1027, 996, 989, 1001, 1068]</td>\n",
       "      <td>1017.5</td>\n",
       "      <td>web</td>\n",
       "      <td>461</td>\n",
       "      <td>[509, 410, 441, 420, 427, 394, 438, 459, 647, 441, 602, 413, 395]</td>\n",
       "      <td>438.0</td>\n",
       "      <td>579.5</td>\n",
       "      <td>2x</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   parties  mean_latency_zeph_ms  expo_delay_mean  \\\n",
       "1      300                   412              0.5   \n",
       "0     1200                   857              0.5   \n",
       "2      300                   728              0.5   \n",
       "3     1200                  1145              0.5   \n",
       "5      300                   605              0.5   \n",
       "4     1200                  1193              0.5   \n",
       "\n",
       "                                                                   latencies_zeph_ms  \\\n",
       "1             [511, 436, 505, 414, 399, 287, 378, 460, 349, 427, 302, 365, 504, 440]   \n",
       "0               [1196, 2126, 1222, 912, 757, 758, 692, 806, 743, 496, 469, 531, 433]   \n",
       "2                [2137, 1835, 452, 492, 575, 506, 471, 521, 427, 562, 481, 522, 487]   \n",
       "3             [2253, 2001, 889, 955, 761, 973, 1056, 895, 880, 1232, 805, 1361, 829]   \n",
       "5            [806, 661, 492, 511, 583, 452, 466, 1197, 437, 591, 600, 574, 531, 574]   \n",
       "4  [2310, 1179, 1005, 1031, 1001, 983, 1008, 1055, 2051, 1027, 996, 989, 1001, 1068]   \n",
       "\n",
       "   median_latency_zeph_ms application  mean_latency_plaintext_ms  \\\n",
       "1                   420.5         car                        114   \n",
       "0                   757.0         car                        307   \n",
       "2                   506.0       polar                        122   \n",
       "3                   955.0       polar                        314   \n",
       "5                   574.0         web                        115   \n",
       "4                  1017.5         web                        461   \n",
       "\n",
       "                                                   latencies_plaintext_ms  \\\n",
       "1          [80, 128, 135, 110, 132, 153, 109, 63, 152, 97, 107, 112, 105]   \n",
       "0  [315, 247, 295, 374, 296, 355, 325, 311, 315, 274, 259, 315, 360, 270]   \n",
       "2           [121, 160, 134, 105, 176, 137, 168, 96, 98, 102, 98, 85, 108]   \n",
       "3       [345, 344, 318, 268, 338, 305, 305, 341, 305, 317, 319, 298, 285]   \n",
       "5            [84, 113, 122, 105, 115, 115, 87, 142, 93, 221, 75, 95, 132]   \n",
       "4       [509, 410, 441, 420, 427, 394, 438, 459, 647, 441, 602, 413, 395]   \n",
       "\n",
       "   median_latency_plaintext_ms  median_difference_ms overhead_factor_median  \n",
       "1                        110.0                 310.5                     4x  \n",
       "0                        313.0                 444.0                     2x  \n",
       "2                        108.0                 398.0                     5x  \n",
       "3                        317.0                 638.0                     3x  \n",
       "5                        113.0                 461.0                     5x  \n",
       "4                        438.0                 579.5                     2x  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/markdown": [
       "#### AWS Results"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "does not exist yet\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "---"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def output(source):\n",
    "    df = build_figure9_df(dir=get_result_path(source.lower()))\n",
    "    display(Markdown(f\"#### {source} Results\"))\n",
    "    \n",
    "    if df is None or df.empty:\n",
    "        print(\"does not exist yet\")\n",
    "    else:\n",
    "        build_figure_9(data=df, plot_format=source==\"Paper\")\n",
    "        \n",
    "        display(df)\n",
    "    \n",
    "    display(Markdown(\"---\"))\n",
    "\n",
    "for source in [\"Paper\",\"AWS\"]:\n",
    "    output(source)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blocked-vegetation",
   "metadata": {},
   "source": [
    "### Troubleshooting End-to-End\n",
    "\n",
    "If the AWS Results plot does not show all expected results:\n",
    "\n",
    "1. check the end of the [Cell Output](logs/e2e_full.log) to verify that the play recap shows `unreachable=0` and `failed=0` for all hosts. (if `unreachable=0` it is possible that the ssh connection between JupyterLab and a host machine was interrupted)\n",
    "2. check the results folder `results/review-results/aws` to verify that there is a file for each application `polar, web, car` both for `plaintext, zeph` and for `300, 1200`participants. If a file is empty, re-run the specific configuration with the command above.   "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "headed-greenhouse",
   "metadata": {},
   "source": [
    "### Further Details about End-to-End Experiments \n",
    "\n",
    "#### Data Producer and Privacy Controller (Client)\n",
    "The data producers and the privacy controllers are grouped into partitions (either 100 producers or 100 privacy controllers).\n",
    "Each partition uses the [E2EBenchmarkRunner.java](zeph-benchmarks/zeph-macrobenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/macro/e2e/E2EBenchmarkRunner.java) to run the benchmark and performs these basic steps:\n",
    "1. wait until all partitions are ready \n",
    "2. execute the benchmark by either producing a data stream or producing a token stream \n",
    "3. report performance\n",
    "\n",
    "The [e2eclient role](ansible/roles/e2eclient/tasks/main.yml) in the ansible playbook is responsible for starting the partitions involved in a benchmark on the ec2 machines.\n",
    "\n",
    "#### Data Transformer (Server)\n",
    "The data transformer (stream processor) that executes the privacy transformation consists of a master ([MasterApp.java](zeph-server/zeph-server-master/src/main/java/ch/ethz/infk/pps/zeph/server/master/MasterApp.java)) that is shared between transformations and a worker ([WorkerApp.java](zeph-server/zeph-server-worker/src/main/java/ch/ethz/infk/pps/zeph/server/worker/WorkerApp.java)) that is specific for a privacy transformation. Both the master and the worker application can be started multiple times and Kafka Streams ensures to distribute the workload among the available instances. In the end-to-end benchmark, we benchmark a single transformation running on two worker instances and one master instance.\n",
    "\n",
    "The [zephmaster role](ansible/roles/zephmaster/tasks/main.yml) and the [zephworker role](ansible/roles/zephworker/tasks/main.yml) start the components as a systemd service.\n",
    "\n",
    "#### Plaintext Baseline\n",
    "\n",
    "In the plaintext baseline there are only data producers (i.e., no privacy controllers) and a single type of data transformer ([PlaintextApp.java](zeph-server/zeph-server-worker/src/main/java/ch/ethz/infk/pps/zeph/server/worker/PlaintextApp.java)). Note, the available computational resources are the same as in Zeph (same number of server machines, data producers run on the same instances). The plaintext data producer are also operated by [E2EBenchmarkRunner.java](zeph-benchmarks/zeph-macrobenchmarks/src/main/java/ch/ethz/infk/pps/zeph/benchmark/macro/e2e/E2EBenchmarkRunner.java).\n",
    "\n",
    "The [plaintextworker role](ansible/roles/plaintextworker/tasks/main.yml) starts the plaintext worker as a systemd service and the [e2eclient role](ansible/roles/e2eclient/tasks/main.yml) handles the data producers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "viral-introduction",
   "metadata": {},
   "source": [
    "#### Switching between Applications\n",
    "Running benchmark with different applications requires to re-compile Zeph and setting the build profile as shown below.\n",
    "\n",
    "The Zeph applications are defined in `zeph-shared/applications`. Each application requires a `schema.avsc` file that describes an Input and a Digest.\n",
    "The input lists how a single event of the application looks in the plaintext case (i.e., the regular stream schema). The digest describes the encoding of this input in Zeph. In the current prototype of Zeph the encoding (containing only lists of longs) has to be defined manually. In addition, the prototype requires an `ApplicationAdapter.java` that defines how to encode an Input into a Digest among minor other things.\n",
    "\n",
    "Adding support for a new application requires defining such a schema and ApplicationAdapter and in addition register the application in form of a new Maven profile in `zeph-shared/pom.xml`. The Maven build of Zeph ensures that the files of the selected application are moved to the proper location."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "psychological-terry",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_standard.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 9.67 ms, sys: 227 µs, total: 9.89 ms\n",
      "Wall time: 3.57 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Switch to the Standard Application that uses an encoding of [x, x², 1] (~ 6 min)\n",
    "#!mvn clean install 2>&1 | tee logs/build_zeph_standard.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_standard.log))\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "anticipated-hamburg",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_polar.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 6.25 ms, sys: 18.6 ms, total: 24.9 ms\n",
      "Wall time: 9.81 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Switch to the Polar Application (~ 6 min)\n",
    "#!mvn clean install -P polar-application 2>&1 | tee logs/build_zeph_standard.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_polar.log))\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "extraordinary-country",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_web.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.93 ms, sys: 131 µs, total: 5.06 ms\n",
      "Wall time: 4.05 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Switch to the Web Application (~ 6 min)\n",
    "#!mvn clean install -P web-application 2>&1 | tee logs/build_zeph_standard.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_web.log))\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "canadian-joyce",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_car.log))"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 141 µs, sys: 3.45 ms, total: 3.6 ms\n",
      "Wall time: 2.89 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Switch to the Car Application (~ 6 min)\n",
    "#!mvn clean install -P car-application 2>&1 | tee logs/build_zeph_standard.log\n",
    "\n",
    "clear_output()\n",
    "display(Markdown(\"Done! Cleared output for conciseness ([Show Cell Output](logs/build_zeph_car.log))\"))"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}