{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving data in the background\n",
    "\n",
    "The QCoDeS Measurement allows for the actual data saving to take place in a background thread. This notebook provides an example of using that feature to reduce the overall time spent running the measurement.\n",
    "\n",
    "## Can I haz speedup?\n",
    "\n",
    "If the time you spend actually writing the data to disk is comparable to the time it takes you to acquire the data (e.g. by waiting for a lock-in amplifier to integrate or an algorithm to return a result), then you can indeed expect a speedup of up to a factor of 2. If your measurement time is clearly dominated by either the acquisition or the writing to the DB file, then writing the data in the background won't offer you much of a speedup. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example Measurement\n",
    "\n",
    "We'll acquire a 2D heatmap and pretend that the acquisition is fairly slow. We'll also print how long the acquisition and the saving takes. We have chosen a *fair* example showing *some* speed-up. It is indeed possible to tailor situations where the speed-up is larger, e.g. by saving big (smth like 3 x 100_000_000 points per save) numpy arrays, but such datasets are not easily visaulised. In this notebook we get a decent speed-up and two nice heatmaps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Logging hadn't been started.\n",
      "Activating auto-logging. Current session state plus future input saved.\n",
      "Filename       : C:\\Users\\wihpniel\\.qcodes\\logs\\command_history.log\n",
      "Mode           : append\n",
      "Output logging : True\n",
      "Raw input log  : False\n",
      "Timestamping   : True\n",
      "State          : active\n",
      "Qcodes Logfile : C:\\Users\\wihpniel\\.qcodes\\logs\\200218-2968-qcodes.log\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import tempfile\n",
    "import time\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from qcodes.dataset import (\n",
    "    Measurement,\n",
    "    initialise_or_create_database_at,\n",
    "    new_experiment,\n",
    "    plot_dataset,\n",
    ")\n",
    "from qcodes.parameters import Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Upgrading database; v0 -> v1: : 0it [00:00, ?it/s]\n",
      "Upgrading database; v1 -> v2: 100%|██████████| 1/1 [00:00<00:00, 333.04it/s]\n",
      "Upgrading database; v2 -> v3: : 0it [00:00, ?it/s]\n",
      "Upgrading database; v3 -> v4: : 0it [00:00, ?it/s]\n",
      "Upgrading database; v4 -> v5: 100%|██████████| 1/1 [00:00<00:00, 125.85it/s]\n",
      "Upgrading database; v5 -> v6: : 0it [00:00, ?it/s]\n",
      "Upgrading database; v6 -> v7: 100%|██████████| 1/1 [00:00<00:00, 37.02it/s]\n",
      "Upgrading database; v7 -> v8: 100%|██████████| 1/1 [00:00<00:00, 166.73it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "saving_data_in_bg#no_sample#1@C:\\Users\\wihpniel\\AppData\\Local\\Temp\\14b031008f76d1553ad16f23f3db67cd6435992af870e41e.db\n",
       "----------------------------------------------------------------------------------------------------------------------"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dbname = os.path.join(tempfile.gettempdir(), os.urandom(24).hex()) + \".db\"\n",
    "initialise_or_create_database_at(dbname)\n",
    "new_experiment(\"saving_data_in_bg\", \"no_sample\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gaussian(x, mu, sig):\n",
    "    return np.exp(-np.power(x - mu, 2.0) / (2 * np.power(sig, 2.0)))\n",
    "\n",
    "\n",
    "def get_response():\n",
    "    \"\"\"\n",
    "    Simulated slow instrument response\n",
    "    \"\"\"\n",
    "    freqs = frequency.get()\n",
    "    volt = voltage.get()\n",
    "    time.sleep(0.1)\n",
    "    volt += 0.2 * np.random.rand()\n",
    "    noise = 0.01 * np.random.randn(len(freqs))\n",
    "    return gaussian(freqs, volt, 2) + 0.01 * noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qcodes.dataset.measurements.Measurement at 0x1b038957948>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "voltage = Parameter(\"voltage\", unit=\"V\", set_cmd=None, get_cmd=None)\n",
    "frequency = Parameter(\"frequency\", unit=\"Hz\", set_cmd=None, get_cmd=None)\n",
    "response = Parameter(\"response\", unit=\"V^2/Hz\", get_cmd=get_response)\n",
    "\n",
    "meas = Measurement()\n",
    "meas.register_parameter(voltage)\n",
    "meas.register_parameter(frequency)\n",
    "meas.register_parameter(response, setpoints=[voltage, frequency])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 10_000\n",
    "M = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data saving in the main thread\n",
    "\n",
    "This is the default QCoDeS behaviour."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting experimental run with id: 1. \n",
      "Report:\n",
      "Number of data points saved: 10 x 10000 points\n",
      "Init time:            0.10182609999999936 s\n",
      "Data generation time: 1.0176166999999996 s\n",
      "Data saving time:     1.3395424999999994 s\n",
      "Total time:           2.4591814999999997 s\n"
     ]
    }
   ],
   "source": [
    "t0 = time.perf_counter()\n",
    "\n",
    "saving_time = 0\n",
    "generation_time = 0\n",
    "\n",
    "with meas.run() as datasaver:\n",
    "    init_time = time.perf_counter() - t0\n",
    "\n",
    "    for volt in np.sin(np.linspace(-np.pi, np.pi, M)):\n",
    "        t1 = time.perf_counter()\n",
    "\n",
    "        freqs = np.linspace(-10, 10, N)\n",
    "        frequency(freqs)\n",
    "        voltage(volt)\n",
    "\n",
    "        resp = response()\n",
    "\n",
    "        t2 = time.perf_counter()\n",
    "\n",
    "        generation_time += t2 - t1\n",
    "\n",
    "        datasaver.add_result((frequency, freqs), (voltage, volt), (response, resp))\n",
    "        t3 = time.perf_counter()\n",
    "\n",
    "        saving_time += t3 - t2\n",
    "t4 = time.perf_counter()\n",
    "saving_time += t4 - t3\n",
    "\n",
    "print(\"Report:\")\n",
    "print(f\"Number of data points saved: {M} x {N} points\")\n",
    "print(f\"Init time:            {init_time} s\")\n",
    "print(f\"Data generation time: {generation_time} s\")\n",
    "print(f\"Data saving time:     {saving_time} s\")\n",
    "print(f\"Total time:           {t4-t0} s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plot_dataset(datasaver.dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving in a background thread\n",
    "\n",
    "To save in a background thread, simply pass the `write_in_background` kwarg as you `run` the measurement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting experimental run with id: 2. \n",
      "Report:\n",
      "Number of data points saved: 10 x 10000 points\n",
      "Init time:            0.08158399999999943 s\n",
      "Data generation time: 1.0214090999999996 s\n",
      "Data saving time:     0.4508876000000015 s\n",
      "Total time:           1.5542139000000006 s\n"
     ]
    }
   ],
   "source": [
    "t0 = time.perf_counter()\n",
    "\n",
    "saving_time = 0\n",
    "generation_time = 0\n",
    "\n",
    "# ONLY DIFFERENCE IN THE NEXT LINE\n",
    "with meas.run(write_in_background=True) as datasaver:  # <---- THIS LINE DIFFERENT\n",
    "    # THE PREVIOUS LINE CHANGED\n",
    "\n",
    "    init_time = time.perf_counter() - t0\n",
    "\n",
    "    for volt in np.sin(np.linspace(-np.pi, np.pi, M)):\n",
    "        t1 = time.perf_counter()\n",
    "\n",
    "        freqs = np.linspace(-10, 10, N)\n",
    "        frequency(freqs)\n",
    "        voltage(volt)\n",
    "\n",
    "        resp = response()\n",
    "\n",
    "        t2 = time.perf_counter()\n",
    "\n",
    "        generation_time += t2 - t1\n",
    "\n",
    "        datasaver.add_result((frequency, freqs), (voltage, volt), (response, resp))\n",
    "        t3 = time.perf_counter()\n",
    "\n",
    "        saving_time += t3 - t2\n",
    "t4 = time.perf_counter()\n",
    "saving_time += t4 - t3\n",
    "\n",
    "print(\"Report:\")\n",
    "print(f\"Number of data points saved: {M} x {N} points\")\n",
    "print(f\"Init time:            {init_time} s\")\n",
    "print(f\"Data generation time: {generation_time} s\")\n",
    "print(f\"Data saving time:     {saving_time} s\")\n",
    "print(f\"Total time:           {t4-t0} s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plot_dataset(datasaver.dataset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that if you perform more than one measurement concurrently, they must all either perform the saving in the main thread on in the background. Mixing between foreground and background is not allowed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "For an example experiment saving 10 rows of 10,000 data points, out-of-thread data writing reduced the time spent in the main thread saving data by almost 70% and thus the overall measurement time by more than 35%."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}