{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c38240c3-7646-497b-a3ac-d9cfa6c974f2",
   "metadata": {},
   "source": [
    "# Parallel processing of a stack of data stored in HDF5 with multi-threading\n",
    "\n",
    "This tutorial explains how it is possible to treat in parallel a large HDF5 dataset which does not fit into the computer memory.\n",
    "\n",
    "![Typical workflow](workflow.png)\n",
    "\n",
    "For this tutorial, a recent version of pyFAI is needed (>=0.22, summer 2022).\n",
    "\n",
    "This tutorial explains how to benefit from multi-threading. This framework is not very popular in the Python world due to the [Global Interpreter Lock (GIL)](https://wiki.python.org/moin/GlobalInterpreterLock), but properly written C-code which does release the GIL can be very fast, sometimes as fast as GPU code (on large computers).\n",
    "\n",
    "**Credits:**\n",
    "\n",
    "* Thomas Vincent (ESRF) for the parallel decompression of HDF5 chunks and the Jupyter-slurm\n",
    "* Pierre Paleo (ESRF) for struggling with this kind of stuff with GPUs\n",
    "* Jon Wright (ESRF) for the CSC integrator, while implemented in serial is multithreading friendly + HDF5 investigation\n",
    "* The French-CRG for providing a manycore computer (2 x 32-core AMD EPYC 75F3)\n",
    "\n",
    "**Nota:** No GPU is needed for this tutorial!\n",
    "\n",
    "**Important:** the `bitshuffle` module needs to be compiled without OpenMP, since the tutorial aims at demonstrating that Python threads can be almost as efficient as OpenMP. If you have a doubt about OpenMP, please uncomment the environment variable OMP_NUM_THREADS reset in the second cell. This will unfortunately bias the performance measurement of pyFAI with the CSR sparse-matrix multiplication.\n",
    "\n",
    "## 1. Description of the computer.\n",
    "\n",
    "The results obtained vary a lot as function of the computer and its topology. This section details some internal details about the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5eb5f112-bf32-4413-85ea-67eb88bf7ee9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:42.106301Z",
     "iopub.status.busy": "2026-09-15T08:20:42.106227Z",
     "iopub.status.idle": "2026-09-15T08:20:42.450049Z",
     "shell.execute_reply": "2026-09-15T08:20:42.449489Z"
    }
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "# use `widget` for better user experience; `inline` is for documentation generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "638e4966-b05e-47e2-a4b0-5843b1b5ff93",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:42.452016Z",
     "iopub.status.busy": "2026-09-15T08:20:42.451888Z",
     "iopub.status.idle": "2026-09-15T08:20:42.588670Z",
     "shell.execute_reply": "2026-09-15T08:20:42.588082Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working on computer lintaillefer.\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "import os\n",
    "import collections\n",
    "import struct\n",
    "import time\n",
    "import socket\n",
    "import gc\n",
    "# Ensure OpenMP is disabled\n",
    "os.environ[\"OMP_NUM_THREADS\"] = \"1\"\n",
    "import numpy\n",
    "import pyFAI\n",
    "import h5py\n",
    "import hdf5plugin\n",
    "from queue import Queue\n",
    "import threading\n",
    "import bitshuffle\n",
    "from matplotlib.pyplot import subplots\n",
    "from fabio.utils.cli import relax_ulimit; relax_ulimit()\n",
    "start_time = time.time()\n",
    "Item = collections.namedtuple(\"Item\", \"index data\")\n",
    "print(f\"Working on computer {socket.gethostname()}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "210e4de4-184b-4c64-872e-5c1aaf080501",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:42.590591Z",
     "iopub.status.busy": "2026-09-15T08:20:42.590409Z",
     "iopub.status.idle": "2026-09-15T08:20:42.593012Z",
     "shell.execute_reply": "2026-09-15T08:20:42.592472Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Working with 64 threads. Mind OpenMP needs to be disabled in the bitshuffle code !\n"
     ]
    }
   ],
   "source": [
    "nbthreads = len(os.sched_getaffinity(0))\n",
    "print(f\"Working with {nbthreads} threads. Mind OpenMP needs to be disabled in the bitshuffle code !\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8e649b79-f024-4635-ac8f-fc68827c60aa",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:42.594343Z",
     "iopub.status.busy": "2026-09-15T08:20:42.594262Z",
     "iopub.status.idle": "2026-09-15T08:20:42.824149Z",
     "shell.execute_reply": "2026-09-15T08:20:42.823380Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Architecture:                x86_64\r\n",
      "  CPU op-mode(s):            32-bit, 64-bit\r\n",
      "  Address sizes:             43 bits physical, 48 bits virtual\r\n",
      "  Byte Order:                Little Endian\r\n",
      "CPU(s):                      64\r\n",
      "  On-line CPU(s) list:       0-63\r\n",
      "Vendor ID:                   AuthenticAMD\r\n",
      "  Model name:                AMD Ryzen Threadripper PRO 3975WX 32-Cores\r\n",
      "    CPU family:              23\r\n",
      "    Model:                   49\r\n",
      "    Thread(s) per core:      2\r\n",
      "    Core(s) per socket:      32\r\n",
      "    Socket(s):               1\r\n",
      "    Stepping:                0\r\n",
      "    Frequency boost:         enabled\r\n",
      "    CPU(s) scaling MHz:      56%\r\n",
      "    CPU max MHz:             4368.1641\r\n",
      "    CPU min MHz:             2200.0000\r\n",
      "    BogoMIPS:                6986.45\r\n",
      "    Flags:                   fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pg\r\n",
      "                             e mca cmov pat pse36 clflush mmx fxsr sse sse2 ht s\r\n",
      "                             yscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constan\r\n",
      "                             t_tsc rep_good nopl xtopology nonstop_tsc cpuid ext\r\n",
      "                             d_apicid aperfmperf rapl pni pclmulqdq monitor ssse\r\n",
      "                             3 fma cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx\r\n",
      "                              f16c rdrand lahf_lm cmp_legacy svm extapic cr8_leg\r\n",
      "                             acy abm sse4a misalignsse 3dnowprefetch osvw ibs sk\r\n",
      "                             init wdt tce topoext perfctr_core perfctr_nb bpext \r\n",
      "                             perfctr_llc mwaitx cpb cat_l3 cdp_l3 hw_pstate ssbd\r\n",
      "                              mba ibpb stibp vmmcall fsgsbase bmi1 avx2 smep bmi\r\n",
      "                             2 cqm rdt_a rdseed adx smap clflushopt clwb sha_ni \r\n",
      "                             xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_ll\r\n",
      "                             c cqm_mbm_total cqm_mbm_local clzero irperf xsaveer\r\n",
      "                             ptr rdpru wbnoinvd arat npt lbrv svm_lock nrip_save\r\n",
      "                              tsc_scale vmcb_clean flushbyasid decodeassists pau\r\n",
      "                             sefilter pfthreshold avic v_vmsave_vmload vgif v_sp\r\n",
      "                             ec_ctrl umip rdpid overflow_recov succor smca sev s\r\n",
      "                             ev_es\r\n",
      "Virtualization features:     \r\n",
      "  Virtualization:            AMD-V\r\n",
      "Caches (sum of all):         \r\n",
      "  L1d:                       1 MiB (32 instances)\r\n",
      "  L1i:                       1 MiB (32 instances)\r\n",
      "  L2:                        16 MiB (32 instances)\r\n",
      "  L3:                        128 MiB (8 instances)\r\n",
      "NUMA:                        \r\n",
      "  NUMA node(s):              4\r\n",
      "  NUMA node0 CPU(s):         0-7,32-39\r\n",
      "  NUMA node1 CPU(s):         8-15,40-47\r\n",
      "  NUMA node2 CPU(s):         16-23,48-55\r\n",
      "  NUMA node3 CPU(s):         24-31,56-63\r\n",
      "Vulnerabilities:             \r\n",
      "  Gather data sampling:      Not affected\r\n",
      "  Indirect target selection: Not affected\r\n",
      "  Itlb multihit:             Not affected\r\n",
      "  L1tf:                      Not affected\r\n",
      "  Mds:                       Not affected\r\n",
      "  Meltdown:                  Not affected\r\n",
      "  Mmio stale data:           Not affected\r\n",
      "  Reg file data sampling:    Not affected\r\n",
      "  Retbleed:                  Mitigation; untrained return thunk; SMT enabled wit\r\n",
      "                             h STIBP protection\r\n",
      "  Spec rstack overflow:      Mitigation; Safe RET\r\n",
      "  Spec store bypass:         Mitigation; Speculative Store Bypass disabled via p\r\n",
      "                             rctl\r\n",
      "  Spectre v1:                Mitigation; usercopy/swapgs barriers and __user poi\r\n",
      "                             nter sanitization\r\n",
      "  Spectre v2:                Mitigation; Retpolines; IBPB conditional; STIBP alw\r\n",
      "                             ays-on; RSB filling; PBRSB-eIBRS Not affected; BHI \r\n",
      "                             Not affected\r\n",
      "  Srbds:                     Not affected\r\n",
      "  Tsa:                       Not affected\r\n",
      "  Tsx async abort:           Not affected\r\n",
      "  Vmscape:                   Mitigation; IBPB before exit to userspace\r\n"
     ]
    }
   ],
   "source": [
    "!lscpu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "97da69b1-f59d-4bf7-99ff-19b426cdccce",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:42.826110Z",
     "iopub.status.busy": "2026-09-15T08:20:42.825904Z",
     "iopub.status.idle": "2026-09-15T08:20:43.035214Z",
     "shell.execute_reply": "2026-09-15T08:20:43.034395Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "available: 4 nodes (0-3)\r\n",
      "node 0 cpus: 0 1 2 3 4 5 6 7 32 33 34 35 36 37 38 39\r\n",
      "node 0 size: 128815 MB\r\n",
      "node 0 free: 18109 MB\r\n",
      "node 1 cpus: 8 9 10 11 12 13 14 15 40 41 42 43 44 45 46 47\r\n",
      "node 1 size: 129019 MB\r\n",
      "node 1 free: 1032 MB\r\n",
      "node 2 cpus: 16 17 18 19 20 21 22 23 48 49 50 51 52 53 54 55\r\n",
      "node 2 size: 129019 MB\r\n",
      "node 2 free: 785 MB\r\n",
      "node 3 cpus: 24 25 26 27 28 29 30 31 56 57 58 59 60 61 62 63\r\n",
      "node 3 size: 128966 MB\r\n",
      "node 3 free: 2425 MB\r\n",
      "node distances:\r\n",
      "node     0    1    2    3 \r\n",
      "   0:   10   12   12   12 \r\n",
      "   1:   12   10   12   12 \r\n",
      "   2:   12   12   10   12 \r\n",
      "   3:   12   12   12   10 \r\n"
     ]
    }
   ],
   "source": [
    "!numactl --hardware"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "345903ed-e336-4b37-b520-34790b95252d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:43.037234Z",
     "iopub.status.busy": "2026-09-15T08:20:43.037065Z",
     "iopub.status.idle": "2026-09-15T08:20:43.380117Z",
     "shell.execute_reply": "2026-09-15T08:20:43.379296Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine (504GB total)\r\n",
      "  Package L#0\r\n",
      "    Group0 L#0\r\n",
      "      NUMANode L#0 (P#0 126GB)\r\n",
      "      L3 L#0 (16MB)\r\n",
      "        L2 L#0 (512KB) + L1d L#0 (32KB) + L1i L#0 (32KB) + Core L#0\r\n",
      "          PU L#0 (P#0)\r\n",
      "          PU L#1 (P#32)\r\n",
      "        L2 L#1 (512KB) + L1d L#1 (32KB) + L1i L#1 (32KB) + Core L#1\r\n",
      "          PU L#2 (P#1)\r\n",
      "          PU L#3 (P#33)\r\n",
      "        L2 L#2 (512KB) + L1d L#2 (32KB) + L1i L#2 (32KB) + Core L#2\r\n",
      "          PU L#4 (P#2)\r\n",
      "          PU L#5 (P#34)\r\n",
      "        L2 L#3 (512KB) + L1d L#3 (32KB) + L1i L#3 (32KB) + Core L#3\r\n",
      "          PU L#6 (P#3)\r\n",
      "          PU L#7 (P#35)\r\n",
      "      L3 L#1 (16MB)\r\n",
      "        L2 L#4 (512KB) + L1d L#4 (32KB) + L1i L#4 (32KB) + Core L#4\r\n",
      "          PU L#8 (P#4)\r\n",
      "          PU L#9 (P#36)\r\n",
      "        L2 L#5 (512KB) + L1d L#5 (32KB) + L1i L#5 (32KB) + Core L#5\r\n",
      "          PU L#10 (P#5)\r\n",
      "          PU L#11 (P#37)\r\n",
      "        L2 L#6 (512KB) + L1d L#6 (32KB) + L1i L#6 (32KB) + Core L#6\r\n",
      "          PU L#12 (P#6)\r\n",
      "          PU L#13 (P#38)\r\n",
      "        L2 L#7 (512KB) + L1d L#7 (32KB) + L1i L#7 (32KB) + Core L#7\r\n",
      "          PU L#14 (P#7)\r\n",
      "          PU L#15 (P#39)\r\n",
      "    Group0 L#1\r\n",
      "      NUMANode L#1 (P#1 126GB)\r\n",
      "      L3 L#2 (16MB)\r\n",
      "        L2 L#8 (512KB) + L1d L#8 (32KB) + L1i L#8 (32KB) + Core L#8\r\n",
      "          PU L#16 (P#8)\r\n",
      "          PU L#17 (P#40)\r\n",
      "        L2 L#9 (512KB) + L1d L#9 (32KB) + L1i L#9 (32KB) + Core L#9\r\n",
      "          PU L#18 (P#9)\r\n",
      "          PU L#19 (P#41)\r\n",
      "        L2 L#10 (512KB) + L1d L#10 (32KB) + L1i L#10 (32KB) + Core L#10\r\n",
      "          PU L#20 (P#10)\r\n",
      "          PU L#21 (P#42)\r\n",
      "        L2 L#11 (512KB) + L1d L#11 (32KB) + L1i L#11 (32KB) + Core L#11\r\n",
      "          PU L#22 (P#11)\r\n",
      "          PU L#23 (P#43)\r\n",
      "      L3 L#3 (16MB)\r\n",
      "        L2 L#12 (512KB) + L1d L#12 (32KB) + L1i L#12 (32KB) + Core L#12\r\n",
      "          PU L#24 (P#12)\r\n",
      "          PU L#25 (P#44)\r\n",
      "        L2 L#13 (512KB) + L1d L#13 (32KB) + L1i L#13 (32KB) + Core L#13\r\n",
      "          PU L#26 (P#13)\r\n",
      "          PU L#27 (P#45)\r\n",
      "        L2 L#14 (512KB) + L1d L#14 (32KB) + L1i L#14 (32KB) + Core L#14\r\n",
      "          PU L#28 (P#14)\r\n",
      "          PU L#29 (P#46)\r\n",
      "        L2 L#15 (512KB) + L1d L#15 (32KB) + L1i L#15 (32KB) + Core L#15\r\n",
      "          PU L#30 (P#15)\r\n",
      "          PU L#31 (P#47)\r\n",
      "    Group0 L#2\r\n",
      "      NUMANode L#2 (P#2 126GB)\r\n",
      "      L3 L#4 (16MB)\r\n",
      "        L2 L#16 (512KB) + L1d L#16 (32KB) + L1i L#16 (32KB) + Core L#16\r\n",
      "          PU L#32 (P#16)\r\n",
      "          PU L#33 (P#48)\r\n",
      "        L2 L#17 (512KB) + L1d L#17 (32KB) + L1i L#17 (32KB) + Core L#17\r\n",
      "          PU L#34 (P#17)\r\n",
      "          PU L#35 (P#49)\r\n",
      "        L2 L#18 (512KB) + L1d L#18 (32KB) + L1i L#18 (32KB) + Core L#18\r\n",
      "          PU L#36 (P#18)\r\n",
      "          PU L#37 (P#50)\r\n",
      "        L2 L#19 (512KB) + L1d L#19 (32KB) + L1i L#19 (32KB) + Core L#19\r\n",
      "          PU L#38 (P#19)\r\n",
      "          PU L#39 (P#51)\r\n",
      "      L3 L#5 (16MB)\r\n",
      "        L2 L#20 (512KB) + L1d L#20 (32KB) + L1i L#20 (32KB) + Core L#20\r\n",
      "          PU L#40 (P#20)\r\n",
      "          PU L#41 (P#52)\r\n",
      "        L2 L#21 (512KB) + L1d L#21 (32KB) + L1i L#21 (32KB) + Core L#21\r\n",
      "          PU L#42 (P#21)\r\n",
      "          PU L#43 (P#53)\r\n",
      "        L2 L#22 (512KB) + L1d L#22 (32KB) + L1i L#22 (32KB) + Core L#22\r\n",
      "          PU L#44 (P#22)\r\n",
      "          PU L#45 (P#54)\r\n",
      "        L2 L#23 (512KB) + L1d L#23 (32KB) + L1i L#23 (32KB) + Core L#23\r\n",
      "          PU L#46 (P#23)\r\n",
      "          PU L#47 (P#55)\r\n",
      "    Group0 L#3\r\n",
      "      NUMANode L#3 (P#3 126GB)\r\n",
      "      L3 L#6 (16MB)\r\n",
      "        L2 L#24 (512KB) + L1d L#24 (32KB) + L1i L#24 (32KB) + Core L#24\r\n",
      "          PU L#48 (P#24)\r\n",
      "          PU L#49 (P#56)\r\n",
      "        L2 L#25 (512KB) + L1d L#25 (32KB) + L1i L#25 (32KB) + Core L#25\r\n",
      "          PU L#50 (P#25)\r\n",
      "          PU L#51 (P#57)\r\n",
      "        L2 L#26 (512KB) + L1d L#26 (32KB) + L1i L#26 (32KB) + Core L#26\r\n",
      "          PU L#52 (P#26)\r\n",
      "          PU L#53 (P#58)\r\n",
      "        L2 L#27 (512KB) + L1d L#27 (32KB) + L1i L#27 (32KB) + Core L#27\r\n",
      "          PU L#54 (P#27)\r\n",
      "          PU L#55 (P#59)\r\n",
      "      L3 L#7 (16MB)\r\n",
      "        L2 L#28 (512KB) + L1d L#28 (32KB) + L1i L#28 (32KB) + Core L#28\r\n",
      "          PU L#56 (P#28)\r\n",
      "          PU L#57 (P#60)\r\n",
      "        L2 L#29 (512KB) + L1d L#29 (32KB) + L1i L#29 (32KB) + Core L#29\r\n",
      "          PU L#58 (P#29)\r\n",
      "          PU L#59 (P#61)\r\n",
      "        L2 L#30 (512KB) + L1d L#30 (32KB) + L1i L#30 (32KB) + Core L#30\r\n",
      "          PU L#60 (P#30)\r\n",
      "          PU L#61 (P#62)\r\n",
      "        L2 L#31 (512KB) + L1d L#31 (32KB) + L1i L#31 (32KB) + Core L#31\r\n",
      "          PU L#62 (P#31)\r\n",
      "          PU L#63 (P#63)\r\n",
      "  HostBridge\r\n",
      "    PCIBridge\r\n",
      "      PCI 01:00.0 (Ethernet)\r\n",
      "        Net \"enp1s0\"\r\n",
      "    PCIBridge\r\n",
      "      PCIBridge\r\n",
      "        PCIBridge\r\n",
      "          PCI 04:00.0 (Ethernet)\r\n",
      "            Net \"enp4s0\"\r\n",
      "        PCIBridge\r\n",
      "          PCI 06:00.0 (SATA)\r\n",
      "            Block(Disk) \"sda\"\r\n",
      "        PCIBridge\r\n",
      "          PCI 07:00.0 (SATA)\r\n",
      "            Block(Disk) \"sdd\"\r\n",
      "            Block(Disk) \"sdb\"\r\n",
      "            Block(Disk) \"sdc\"\r\n",
      "  HostBridge\r\n",
      "    PCIBridge\r\n",
      "      PCI 21:00.0 (NVMExp)\r\n",
      "        Block(Disk) \"nvme0n1\"\r\n",
      "    PCIBridge\r\n",
      "      PCI 22:00.0 (NVMExp)\r\n",
      "        Block(Disk) \"nvme2n1\"\r\n",
      "    PCIBridge\r\n",
      "      PCI 23:00.0 (Ethernet)\r\n",
      "        Net \"eth4\"\r\n",
      "  HostBridge\r\n",
      "    PCIBridge\r\n",
      "      PCI 41:00.0 (VGA)\r\n",
      "        CoProc(OpenCL) \"opencl0d1\"\r\n",
      "        GPU(Display) \":0.0\"\r\n",
      "    PCIBridge\r\n",
      "      PCI 42:00.0 (NVMExp)\r\n",
      "        Block(Disk) \"nvme1n1\"\r\n",
      "  HostBridge\r\n",
      "    PCIBridge\r\n",
      "      PCI 61:00.0 (VGA)\r\n",
      "        CoProc(OpenCL) \"opencl0d0\"\r\n"
     ]
    }
   ],
   "source": [
    "!lstopo --of console"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c54705-4b6c-444b-b9f1-b763f6a8d915",
   "metadata": {},
   "source": [
    "## 2. Setup the environment:\n",
    "\n",
    "This is a purely virtual experiment, the tutorial tries to be representative of the processing for the beamline of Jon Wright: ESRF-ID11 this is why we will use an Eiger 4M detector with data integrated over 1000 bins. Those parameters can be tuned.\n",
    "\n",
    "Random data are generated to mimic the scattering of a liquid with Poisson noise. The input file is fairly small, since those data compress nicely. The speed of the drive used for temporary storage is likely to have a huge impact, especially if all data do not hold in memory !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1cd22d82-d4fb-4d28-9960-0442989ca18c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:43.382228Z",
     "iopub.status.busy": "2026-09-15T08:20:43.382052Z",
     "iopub.status.idle": "2026-09-15T08:20:44.406287Z",
     "shell.execute_reply": "2026-09-15T08:20:44.405088Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HDF5PluginBuildConfig(openmp=False, native=False, bmi2=False, sse2=True, ssse3=False, avx2=False, avx512=False, cpp11=True, cpp14=True, cpp20=True, ipp=False, filter_file_extension='.so', embedded_filters=('blosc', 'blosc2', 'bshuf', 'bzip2', 'fcidecomp', 'htj2k', 'lz4', 'sperr', 'sz', 'sz3', 'zfp', 'zstd'))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "det = pyFAI.detector_factory(\"eiger_4M\")\n",
    "shape = det.shape\n",
    "dtype = numpy.dtype(\"uint32\")\n",
    "filename = \"/tmp/big.h5\"\n",
    "h5path = \"data\"\n",
    "nbins = 1000\n",
    "cmp = hdf5plugin.Bitshuffle()\n",
    "hdf5plugin.get_config().build_config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "daf4eec8-e364-43b6-b5af-8f279c6aed38",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:44.409288Z",
     "iopub.status.busy": "2026-09-15T08:20:44.408715Z",
     "iopub.status.idle": "2026-09-15T08:20:44.413050Z",
     "shell.execute_reply": "2026-09-15T08:20:44.412372Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of frames the computer can host in memory: 30144.536\n"
     ]
    }
   ],
   "source": [
    "mem_bytes = os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES')\n",
    "print(f\"Number of frames the computer can host in memory: {mem_bytes/(numpy.prod(shape)*dtype.itemsize):.3f}\")\n",
    "if os.environ.get('SLURM_MEM_PER_NODE'):\n",
    "    print(f\"Number of frames the computer can host in memory with SLURM restrictions: {int(os.environ['SLURM_MEM_PER_NODE'])*(1<<20)/(numpy.prod(shape)*dtype.itemsize):.3f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bd038dc8-1e6d-4bd6-95b3-303f2d0f250b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:44.414669Z",
     "iopub.status.busy": "2026-09-15T08:20:44.414576Z",
     "iopub.status.idle": "2026-09-15T08:20:44.416790Z",
     "shell.execute_reply": "2026-09-15T08:20:44.416250Z"
    }
   },
   "outputs": [],
   "source": [
    "#The computer being limited to 64G of RAM, the number of frames actually possible is 3800.\n",
    "nbframes = 4096 # slightly larger than the maximum achievable ! Such a dataset should not host in memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a32bd8fb-9b64-4564-9a69-67a759bf3427",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:44.418591Z",
     "iopub.status.busy": "2026-09-15T08:20:44.418500Z",
     "iopub.status.idle": "2026-09-15T08:20:45.061444Z",
     "shell.execute_reply": "2026-09-15T08:20:45.060620Z"
    }
   },
   "outputs": [],
   "source": [
    "#Prepare a frame with little count so that it compresses well\n",
    "geo = {\"detector\": det, \n",
    "       \"wavelength\": 1e-10}\n",
    "ai = pyFAI.load(geo)\n",
    "q = numpy.arange(15)\n",
    "img = ai.calcfrom1d(q, 100/(1+q*q))\n",
    "frame = numpy.random.poisson(img).astype(dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "53b49350-6b0c-4c3b-ba5b-ece50cd6fe98",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:45.063454Z",
     "iopub.status.busy": "2026-09-15T08:20:45.063214Z",
     "iopub.status.idle": "2026-09-15T08:20:45.679122Z",
     "shell.execute_reply": "2026-09-15T08:20:45.678486Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f4e9c31f8c0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# display the image\n",
    "fig,ax = subplots()\n",
    "ax.imshow(frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "17e3d7e2-de22-4d40-8230-39295f04e239",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:45.680924Z",
     "iopub.status.busy": "2026-09-15T08:20:45.680828Z",
     "iopub.status.idle": "2026-09-15T08:20:52.833028Z",
     "shell.execute_reply": "2026-09-15T08:20:52.832009Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Performances of the different algorithms for azimuthal integration of Eiger 4M image\n",
      "Using algorithm histogram : "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "610 ms ± 11.4 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "Using algorithm csc       : "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.3 ms ± 45.9 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "Using algorithm csr       : "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50 ms ± 40.1 μs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "print(\"Performances of the different algorithms for azimuthal integration of Eiger 4M image\")\n",
    "for algo in (\"histogram\", \"csc\", \"csr\"):\n",
    "    print(f\"Using algorithm {algo:10s}:\", end=\" \")\n",
    "    %timeit ai.integrate1d(img, nbins, method=(\"full\", algo, \"cython\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22969c56-1d10-4950-aebe-699da628858e",
   "metadata": {},
   "source": [
    "**Note:** The full pixel splitting is time consuming and handicaps the histogram algorithm while both sparse-matrix methods are much faster since they cache this calculation in the sparse matrix.\n",
    "\n",
    "The compared performances of sparse-matrix methods is rather surprising since the CSC algorithm, single threaded, is faster than the CSR which runs in parallel over 2x32 cores.\n",
    "This result is the combination of two factors:\n",
    "\n",
    "1. The computer is built with two processors/sockets controlling each its own memory. We call this a **Non Uniform Memory Access** computer and can be checked with `numactrl --hardware`. The CSR matrix multiplication will dispatch work on both processors and thus, needs to transfer part of the image from one NUMA subsystem (socket) to the other, which is slow (3.2x slower compared to a single-socket access, according to the output of numactl). \n",
    "\n",
    "2. The very large cache of this processor: 512MB are reported by `lscpu`, but a more precise tool, `lstopo` describes them as 32MB of L3 cache shared between 4 cores. This very large cache allows the complete frame and the sparse matrix to be pre-fetched which is a great advantage for the CSC algorithm.\n",
    "\n",
    "Running the very same benchmark on an Intel 2-socket server would remove the point 2, while running on a single socket intel workstation would remove both points and the normal results would be that CSR should be faster than CSC. The best performances one can get with the CSR algorithm should be obtained when using 4 cores (sharing the same cache L3) out of 64 on this computer. This can be done by setting the environment variable **OMP_NUM_THREADS**. Unfortunately, it also requires to restart the process, thus cannot be demonstrated easily in the notebook (without restarting). \n",
    "\n",
    "**The first message to take home is that without the knowledge of the actual computer, no high-performance computing is possible**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a98654ed-372a-4886-9292-32b31ae4ec2a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:52.835926Z",
     "iopub.status.busy": "2026-09-15T08:20:52.835783Z",
     "iopub.status.idle": "2026-09-15T08:20:52.838815Z",
     "shell.execute_reply": "2026-09-15T08:20:52.838145Z"
    }
   },
   "outputs": [],
   "source": [
    "#Does not work unless one restarts the process\n",
    "\n",
    "# print(\"Performances of the different algorithms for azimuthal integration of Eiger 4M image when using only 4 cores\")\n",
    "# mask = os.sched_getaffinity(0)\n",
    "# os.sched_setaffinity(0, [0,1,2,3])\n",
    "# for algo in (\"histogram\", \"csc\", \"csr\"):\n",
    "#     print(f\"Using algorithm {algo}:\", end=\" \")\n",
    "#     %timeit ai.integrate1d(img, nbins, method=(\"full\", algo, \"cython\"))\n",
    "# os.sched_setaffinity(0, mask)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63768a00-0b9e-4c55-a55e-efe6a8a17358",
   "metadata": {},
   "source": [
    "## 3. Writing the test dataset on disk."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "32d5ebc6-3473-49a2-93e7-76e7bb8f17f1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:52.840492Z",
     "iopub.status.busy": "2026-09-15T08:20:52.840406Z",
     "iopub.status.idle": "2026-09-15T08:20:52.845269Z",
     "shell.execute_reply": "2026-09-15T08:20:52.844726Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 19.5 μs ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Saving of a HDF5 file with many frames ...\n",
    "if not os.path.exists(filename):\n",
    "    with h5py.File(filename, \"w\") as h:\n",
    "        ds = h.create_dataset(h5path, shape=(nbframes,)+shape, chunks=(1,)+shape, dtype=dtype, **cmp) \n",
    "        for i in range(nbframes):\n",
    "            ds[i] = frame + i%500 #Each frame has a different value to prevent caching effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f82b2daf-77c2-4720-9848-6ca9c273707f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:52.847129Z",
     "iopub.status.busy": "2026-09-15T08:20:52.847042Z",
     "iopub.status.idle": "2026-09-15T08:20:52.850564Z",
     "shell.execute_reply": "2026-09-15T08:20:52.849879Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "File size 9.215 GB with a compression ratio of 7.428x\n",
      "Write speed: 3769523657.961 MB/s of uncompressed data, or 210086054.652 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_write = _\n",
    "size=os.stat(filename).st_size\n",
    "print(f\"File size {size/(1024**3):.3f} GB with a compression ratio of {nbframes*numpy.prod(shape)*dtype.itemsize/size:.3f}x\")\n",
    "print(f\"Write speed: {nbframes*numpy.prod(shape)*dtype.itemsize/(1e6*timing_write.best):.3f} MB/s of uncompressed data, or {nbframes/timing_write.best:.3f} fps.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc086333-96da-47eb-8477-9a0a5f60bc20",
   "metadata": {},
   "source": [
    "No optimisation is done for writing: this tutorial is focused on reading & processing speed.\n",
    "We keep nevertheless those figures for reference.\n",
    "\n",
    "## 4. Reading the dataset using the h5py/HDF5 library:\n",
    "### 4.1 Using the `h5py` API in a natural way\n",
    "We start with the simplest way to read back all those data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "889b740b-2ba4-4677-a8d6-346608d90158",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:20:52.852261Z",
     "iopub.status.busy": "2026-09-15T08:20:52.852173Z",
     "iopub.status.idle": "2026-09-15T08:21:40.849346Z",
     "shell.execute_reply": "2026-09-15T08:21:40.848436Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 48 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading all frames and decompressing them, the natural way way\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    for i in range(nbframes):\n",
    "        frame = ds[i][...]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "c748fcbe-128d-46ab-9aa7-149c9a5b31fd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:21:40.851790Z",
     "iopub.status.busy": "2026-09-15T08:21:40.851674Z",
     "iopub.status.idle": "2026-09-15T08:21:40.855275Z",
     "shell.execute_reply": "2026-09-15T08:21:40.854575Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed: 1531.397 MB/s of uncompressed data, or 85.349 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_read0 = _\n",
    "print(f\"Read speed: {nbframes*numpy.prod(shape)*dtype.itemsize/(1e6*timing_read0.best):.3f} MB/s of uncompressed data,\\\n",
    " or {nbframes/timing_read0.best:.3f} fps.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f95dca1-0301-4a04-b397-a9358816ee50",
   "metadata": {},
   "source": [
    "Reading all data from HDF5 file is as slow as (if not slower than) writing. \n",
    "This is mostly due to the decompression and to the many memory allocation performed.\n",
    "\n",
    "### 4.2 Pre-allocate the output buffer (for `h5py`)\n",
    "\n",
    "Now, we can try to pre-allocate the output buffer and check if it helps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a643e63d-1709-45b1-aaad-a542792b5a62",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:21:40.856940Z",
     "iopub.status.busy": "2026-09-15T08:21:40.856854Z",
     "iopub.status.idle": "2026-09-15T08:22:24.156007Z",
     "shell.execute_reply": "2026-09-15T08:22:24.155132Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 43.3 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading all frames and decompressing them\n",
    "buffer = numpy.zeros(shape, dtype=dtype)\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    for i in range(nbframes):\n",
    "        ds.read_direct(buffer, numpy.s_[i,:,:], numpy.s_[:,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "847240c6-f9df-4626-b1a3-2197f535897c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:24.158421Z",
     "iopub.status.busy": "2026-09-15T08:22:24.158305Z",
     "iopub.status.idle": "2026-09-15T08:22:24.161801Z",
     "shell.execute_reply": "2026-09-15T08:22:24.161232Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed: 1697.597 MB/s of uncompressed data, or 94.612 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_read1 = _\n",
    "print(f\"Read speed: {nbframes*numpy.prod(shape)*dtype.itemsize/(1e6*timing_read1.best):.3f} MB/s of uncompressed data,\\\n",
    " or {nbframes/timing_read1.best:.3f} fps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "8613536f-6bd7-42ff-b401-f8ed80cdd8da",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:24.163680Z",
     "iopub.status.busy": "2026-09-15T08:22:24.163593Z",
     "iopub.status.idle": "2026-09-15T08:22:24.166406Z",
     "shell.execute_reply": "2026-09-15T08:22:24.165704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Speed-up: 10.9 %\n"
     ]
    }
   ],
   "source": [
    "print(f\" Speed-up: {(timing_read0.best/timing_read1.best-1)*100:.1f} %\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9267a3-d056-4f91-a183-3dcfa0053885",
   "metadata": {},
   "source": [
    "The gain exists but it is not huge (10%).\n",
    "\n",
    "## 5. Decouple HDF5 chunk reading from decompression.\n",
    "\n",
    "We will benchmark separately the file reading (i.e. reading chunks one by one) and decompressing to check the maximum achievable read speed.\n",
    "\n",
    "### 5.1 Benchmarking of the chunk reading using the `read_direct_chunk` from `h5py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3492bfe6-c71e-40a2-98c4-7fd2cd7d7560",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:24.168192Z",
     "iopub.status.busy": "2026-09-15T08:22:24.168108Z",
     "iopub.status.idle": "2026-09-15T08:22:25.506568Z",
     "shell.execute_reply": "2026-09-15T08:22:25.505907Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 1.33 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading all frames without decompressing them\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    for i in range(ds.id.get_num_chunks()):\n",
    "        filter_mask, chunk = ds.id.read_direct_chunk(ds.id.get_chunk_info(i).chunk_offset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "95cccf4c-f63f-4ecb-9155-41e2a1821380",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:25.508471Z",
     "iopub.status.busy": "2026-09-15T08:22:25.508377Z",
     "iopub.status.idle": "2026-09-15T08:22:25.511406Z",
     "shell.execute_reply": "2026-09-15T08:22:25.510744Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed: 7414.635 MB/s of compressed data.\n",
      "HDF5 direct chunk read speed: 3069.549 fps (without decompression).\n"
     ]
    }
   ],
   "source": [
    "timing_read2 = _\n",
    "print(f\"Read speed: {size/(1e6*timing_read2.best):.3f} MB/s of compressed data.\")\n",
    "print(f\"HDF5 direct chunk read speed: {nbframes/timing_read2.best:.3f} fps (without decompression).\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1a4654-45d3-4ade-bda5-1d33ebd125a0",
   "metadata": {},
   "source": [
    "The reading of the data is really fast, it is apparently mostly limited by the disk speed or by the memory (if the compressed dataset stays in memory). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8969804e-77af-464e-8f9e-11e0e35541bd",
   "metadata": {},
   "source": [
    "### 5.2 Benchmarking of the decompression (single threaded)\n",
    "\n",
    "The function `decompress_bslz4_chunk` can be used to decompress one chunk.\n",
    "We benchmark it on one chunk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "341d4b27-bbc3-4010-a577-820d20f89d72",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:25.513324Z",
     "iopub.status.busy": "2026-09-15T08:22:25.513240Z",
     "iopub.status.idle": "2026-09-15T08:22:25.516129Z",
     "shell.execute_reply": "2026-09-15T08:22:25.515441Z"
    }
   },
   "outputs": [],
   "source": [
    "def decompress_bslz4_chunk(payload, dtype, chunk_shape):\n",
    "    \"\"\"This function decompresses ONE chunk with bitshuffle-LZ4. \n",
    "    The library needs to be compiled without OpenMP when using threads !\n",
    "    \n",
    "    :param payload: string with the compressed data as read by h5py.\n",
    "    :param dtype: data type of the stored content\n",
    "    :param chunk_shape: shape of one chunk\n",
    "    :return: decompressed chunk\"\"\"\n",
    "    _total_nbytes, block_nbytes = struct.unpack(\">QI\", payload[:12])\n",
    "    block_size = block_nbytes // dtype.itemsize\n",
    "\n",
    "    arr = numpy.frombuffer(payload, dtype=numpy.uint8, offset=12)  # No copy here\n",
    "    chunk_data = bitshuffle.decompress_lz4(arr, chunk_shape, dtype, block_size)\n",
    "    return chunk_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e836bd52-7b5f-4535-81d4-2bfc1a5dfaf9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:25.517676Z",
     "iopub.status.busy": "2026-09-15T08:22:25.517586Z",
     "iopub.status.idle": "2026-09-15T08:22:31.723729Z",
     "shell.execute_reply": "2026-09-15T08:22:31.722914Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read chunk #123 which is 2604278 bytes long.\n",
      "The decompressed frame is 17942760 bytes long\n",
      "This frame is compressed with a ratio of 6.9 x.\n",
      "Benchmarking the decompression: "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.63 ms ± 16.4 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "Decompression speed (single threaded): 131.310 fps\n",
      "Maximum read+decompression speed (single threaded): 125.923 fps\n",
      "Maximum read+decompression speed (64-threads): 2248.332 fps\n"
     ]
    }
   ],
   "source": [
    "frame_id = 123\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    filter_mask, chunk = ds.id.read_direct_chunk(ds.id.get_chunk_info(frame_id).chunk_offset)\n",
    "    \n",
    "print(f\"Read chunk #{frame_id} which is {len(chunk)} bytes long.\")\n",
    "frame = decompress_bslz4_chunk(chunk, dtype, shape)\n",
    "print(f\"The decompressed frame is {frame.nbytes} bytes long\")\n",
    "print(f\"This frame is compressed with a ratio of {frame.nbytes/len(chunk):.1f} x.\")\n",
    "print(\"Benchmarking the decompression: \", end=\"\")\n",
    "timing_decompression = %timeit -o decompress_bslz4_chunk(chunk, dtype, shape)\n",
    "print(f\"Decompression speed (single threaded): {1/timing_decompression.best:.3f} fps\")\n",
    "print(f\"Maximum read+decompression speed (single threaded): {1/(timing_decompression.best+timing_read2.best/nbframes):.3f} fps\")\n",
    "print(f\"Maximum read+decompression speed ({nbthreads}-threads): {1/(timing_decompression.best/nbthreads+timing_read2.best/nbframes):.3f} fps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec96510d-1648-4e59-8d34-cdf37997e711",
   "metadata": {},
   "source": [
    "At this stage it is interesting to compare the maximum achievable speed in parallel and the raw read speed.\n",
    "\n",
    "This difference is known as [Amdahl's law](https://en.wikipedia.org/wiki/Amdahl%27s_law) which states that performances of a parallel program become limited by the serial part of it when the number of threads increases. In other words, find all the serial sections and squeeze them to get performances.\n",
    "\n",
    "Some parts of the code are made serial to prevent data corruption. One typical example are the commands seek+read in file. If several threads are doing this at the same time, the file-pointer is likely to be changed and the read will return the wrong data. Serializing this section, for example by using locks, mutex, semaphores, ...  is a simple way to prevent such issues. Let's list some of the lock we have in this example:\n",
    "\n",
    "- `h5py` has a lock called `phil` which serializes the access to the HDF5 library\n",
    "- `HDF5` has a global lock preventing files from being modified from different processes\n",
    "- `Python` has a global interpreter lock `GIL` which ensures only one Python object is manipulated at a time.\n",
    "\n",
    "The latter is widely commented and an urban legend says it prevents multithreading in Python. \n",
    "You will at the end of the tutorial how much this is True (or not). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc5939d1-5c25-4f35-9b46-e9684110dfc9",
   "metadata": {},
   "source": [
    "### 5.3 Benchmark the analysis of the HDF5 file\n",
    "\n",
    "To come back on the parallel reading, the different locks from `h5py` and `HDF5` are preventing us from a parallel access to the data.\n",
    "Can we dive deeper into the `HDF5` file and retrieve the position of the different chunks and their size ? \n",
    "If so, it would be possible read chunks without the `h5py`/`HDF5` library, working around their different locks.\n",
    "\n",
    "Let's check the parsing of the HDF5 structure of the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "b301837a-9f6c-43d7-b1cc-f3dc64998bad",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:31.725769Z",
     "iopub.status.busy": "2026-09-15T08:22:31.725665Z",
     "iopub.status.idle": "2026-09-15T08:22:32.206827Z",
     "shell.execute_reply": "2026-09-15T08:22:32.206162Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Each chunk descriptor is an object like: \n",
      "StoreInfo(chunk_offset=(0, 0, 0), filter_mask=0, byte_offset=4536, size=1972604)\n",
      "It represents a very small amount of data: 72 bytes.\n",
      "All 4096 frames, weighting 9894.073 MB, can be represented by 327.960 kB\n"
     ]
    }
   ],
   "source": [
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    res = [ds.id.get_chunk_info(i) for i in range(ds.id.get_num_chunks())]\n",
    "print(f\"Each chunk descriptor is an object like: \\n{res[0]}\")\n",
    "print(f\"It represents a very small amount of data: {sys.getsizeof(res[0])} bytes.\")\n",
    "print(f\"All {nbframes} frames, weighting {size/1e6:.3f} MB, can be represented by {(sys.getsizeof(res)+sys.getsizeof(res[0])*nbframes)/1000:.3f} kB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "5201a9dd-fd9e-4e87-a2bf-f045b8029c08",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:32.208352Z",
     "iopub.status.busy": "2026-09-15T08:22:32.208266Z",
     "iopub.status.idle": "2026-09-15T08:22:32.687946Z",
     "shell.execute_reply": "2026-09-15T08:22:32.687421Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 476 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Parsing speed\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    res = [ds.id.get_chunk_info(i) for i in range(ds.id.get_num_chunks())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "27a4d511-7aa0-491a-8f01-37125c9e2fe5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:32.689930Z",
     "iopub.status.busy": "2026-09-15T08:22:32.689843Z",
     "iopub.status.idle": "2026-09-15T08:22:32.692624Z",
     "shell.execute_reply": "2026-09-15T08:22:32.692025Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Parse speed: 20795.507 MB/s of compressed data.\n",
      "HDF5 parse speed (without reading): 8609.032 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_parse = _\n",
    "print(f\"Parse speed: {size/(1e6*timing_parse.best):.3f} MB/s of compressed data.\")\n",
    "print(f\"HDF5 parse speed (without reading): {nbframes/timing_parse.best:.3f} fps.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e112c3a7-060b-4cce-a6e1-6bb060bb21b8",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:32.694432Z",
     "iopub.status.busy": "2026-09-15T08:22:32.694348Z",
     "iopub.status.idle": "2026-09-15T08:22:33.175528Z",
     "shell.execute_reply": "2026-09-15T08:22:33.174725Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8fc80d8fc41e3425198f780573e655b544c040bc using HDF5\n",
      "8fc80d8fc41e3425198f780573e655b544c040bc using direct file access\n"
     ]
    }
   ],
   "source": [
    "# Validation that the data read by HDF5 and via the file interface matches\n",
    "import hashlib\n",
    "idx = 10\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    indexes = [ds.id.get_chunk_info(i) for i in range(ds.id.get_num_chunks())]\n",
    "    filter_mask, ref = ds.id.read_direct_chunk(indexes[idx].chunk_offset)\n",
    "# and validate the indexes\n",
    "with open(filename, \"rb\") as f:\n",
    "    item = indexes[idx]\n",
    "    f.seek(item.byte_offset)\n",
    "    res = f.read(item.size)\n",
    "print(f\"{hashlib.sha1(ref).hexdigest()} using HDF5\\n{hashlib.sha1(res).hexdigest()} using direct file access\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cebd4b8d-f11c-4f65-9a8e-6f270ce0a9f4",
   "metadata": {},
   "source": [
    "So the HDF5 chunk parsing is the only part of the code needing to be serial, so the maximum achievable speed is very high: 9 kfps.\n",
    "\n",
    "If Amdahl's law is providing us with the upper performance limit, one should take care to optimize all the code to be run in parallel. \n",
    "\n",
    "Here are two ways to read the different chunks, either using the `Python file` interface or `numpy.memmap`. \n",
    "Their performances are expected to be similar to what `HDF5 direct chunk read` provides, the idea is to use them to bypass the locks in `HDF5`.\n",
    "\n",
    "### 5.4 Benchmark the chunk reading using the `h5py` direct chunk read"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4f5a31a7-b5ab-4d68-b55f-76f3159f3cb7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:33.177306Z",
     "iopub.status.busy": "2026-09-15T08:22:33.177214Z",
     "iopub.status.idle": "2026-09-15T08:22:34.035011Z",
     "shell.execute_reply": "2026-09-15T08:22:34.034400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 854 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading all frames without decompressing them\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    for chunk_descr in indexes:\n",
    "        filter_mask, chunk = ds.id.read_direct_chunk(chunk_descr.chunk_offset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "64a1861b-e09b-4753-afe0-16db72131408",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:34.037048Z",
     "iopub.status.busy": "2026-09-15T08:22:34.036957Z",
     "iopub.status.idle": "2026-09-15T08:22:34.040068Z",
     "shell.execute_reply": "2026-09-15T08:22:34.039338Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed (h5py direct chunk read): 11586.719 MB/s of compressed data.\n",
      "Chunk read (from h5py) speed (without decompression): 4796.730 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_read2a = _\n",
    "print(f\"Read speed (h5py direct chunk read): {size/(1e6*timing_read2a.best):.3f} MB/s of compressed data.\")\n",
    "print(f\"Chunk read (from h5py) speed (without decompression): {nbframes/timing_read2a.best:.3f} fps.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "177bd11f-1a31-4965-9ae1-23985a2ed084",
   "metadata": {},
   "source": [
    "### 5.5 Benchmark the chunk reading using the Python file interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e06a3939-fe2a-485f-b774-229c75565334",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:34.041641Z",
     "iopub.status.busy": "2026-09-15T08:22:34.041557Z",
     "iopub.status.idle": "2026-09-15T08:22:34.893219Z",
     "shell.execute_reply": "2026-09-15T08:22:34.892550Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 848 ms ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading all frames without using the HDF5 library (neither decompressing them)\n",
    "with open(filename, \"rb\") as f:\n",
    "    for chunk_descr in indexes:\n",
    "        f.seek(chunk_descr.byte_offset)\n",
    "        chunk = f.read(chunk_descr.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "ae59eaeb-0b0b-4f36-a4f7-990b7c61100f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:34.895278Z",
     "iopub.status.busy": "2026-09-15T08:22:34.895188Z",
     "iopub.status.idle": "2026-09-15T08:22:34.898373Z",
     "shell.execute_reply": "2026-09-15T08:22:34.897720Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed (Python file): 11669.404 MB/s of compressed data.\n",
      "File read (from Python) speed (without decompression): 4830.961 fps.\n",
      "Pure reading using the Python (file interface) is 0.7 % faster than HDF5 direct chunk read.\n",
      "But it removes the file-locking issue from HDF5 !\n"
     ]
    }
   ],
   "source": [
    "timing_read3 = _\n",
    "print(f\"Read speed (Python file): {size/(1e6*timing_read3.best):.3f} MB/s of compressed data.\")\n",
    "print(f\"File read (from Python) speed (without decompression): {nbframes/timing_read3.best:.3f} fps.\")\n",
    "print(f\"Pure reading using the Python (file interface) is {100*timing_read2a.best/(timing_read3.best)-100:.1f} % faster than HDF5 direct chunk read.\")\n",
    "print(\"But it removes the file-locking issue from HDF5 !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47590db3-de63-4179-9921-1d88d6a0a64b",
   "metadata": {},
   "source": [
    "### 5.5 Benchmark the chunk reading using `numpy.memmap`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "59e6da20-bc46-42dd-830c-6f9b46c6e367",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:34.900254Z",
     "iopub.status.busy": "2026-09-15T08:22:34.900169Z",
     "iopub.status.idle": "2026-09-15T08:22:36.269218Z",
     "shell.execute_reply": "2026-09-15T08:22:36.268316Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 1.36 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -r1 -n1 -o -q\n",
    "#Reading positions via HDF5 but chunks are read via numpy.memmap\n",
    "f = numpy.memmap(filename, mode=\"r\")\n",
    "for chunk_descr in indexes:\n",
    "    chunk = numpy.array(f[chunk_descr.byte_offset:chunk_descr.byte_offset+chunk_descr.size])\n",
    "del f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "06209e35-1813-44f4-b340-b3e60b359a8d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:36.271404Z",
     "iopub.status.busy": "2026-09-15T08:22:36.271295Z",
     "iopub.status.idle": "2026-09-15T08:22:36.274851Z",
     "shell.execute_reply": "2026-09-15T08:22:36.274218Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read speed (numpy.memmap): 7256.515 MB/s of compressed data.\n",
      "File read (numpy.memmap) speed (without decompression): 3004.090 fps.\n",
      "Pure reading using the numpy.memmap is -37.4 % faster than using the h5py/HDF5 interface\n",
      "This removes the file-locking issue from HDF5 !\n"
     ]
    }
   ],
   "source": [
    "timing_read4 = _\n",
    "print(f\"Read speed (numpy.memmap): {size/(1e6*timing_read4.best):.3f} MB/s of compressed data.\")\n",
    "print(f\"File read (numpy.memmap) speed (without decompression): {nbframes/timing_read4.best:.3f} fps.\")\n",
    "print(f\"Pure reading using the numpy.memmap is {100*timing_read2a.best/(timing_read4.best)-100:.1f} % faster than using the h5py/HDF5 interface\")\n",
    "print(\"This removes the file-locking issue from HDF5 !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cdcc158-260c-445c-acbb-8da51e3be6ca",
   "metadata": {},
   "source": [
    "NumPy's memmap appears to be much slower than the equivalent Python file read.\n",
    "\n",
    "We found out that the reading of data, initially in the order of 1 minute can be decomposed into:\n",
    "\n",
    " * 0.3s for the reading of the chunk description\n",
    " * 1s for the reading of the chunks themselves\n",
    " * 1 minute for the decompression of the data.\n",
    "\n",
    "Two parallelization schemes appear clearly:\n",
    "1. read chunks in serial mode with h5py and decompress+integrate in parallel.\n",
    "2. read chunk descriptors in serial mode with h5py and parallelize the reading, decompression and integration.\n",
    "\n",
    "But before we can investigate those two routes, we first need to establish some baseline for the complete serial processing: read, decompress, integrate.\n",
    "\n",
    "## 6. Azimuthal integration\n",
    "\n",
    "### 6.1 Serial workflow"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fccb178-94db-4bb4-a5e1-9cab60af0aeb",
   "metadata": {},
   "source": [
    "#### 6.1.1 Prepare the azimuthal integrator\n",
    "To allow the full parallelization of different integrators working in parallel, one must limit the number of Python calls performed, this is why we need to extract the Cython integrator from AzimuthalIntegrator. The integrator used here is a sparse matrix multiplication one with a CSC representation which is single-threaded. This engine is usually not the fastest but it is multithreading friendly.\n",
    "\n",
    "The figures obtained should be similar to the one obtained in chapter 2, the overhead from the azimuthal integrator being tuned to be minimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "0814ccb4-2906-44e6-9061-bb36c5139b3e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:36.276644Z",
     "iopub.status.busy": "2026-09-15T08:22:36.276560Z",
     "iopub.status.idle": "2026-09-15T08:22:40.146682Z",
     "shell.execute_reply": "2026-09-15T08:22:40.145871Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timing for the direct azimuthal integration: "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33.9 ms ± 25.7 μs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n",
      "The maximum achievable integration speed on a single core is 29.512 fps which does not look fancy.\n",
      "But parallelized over 64 threads, it could reach: 1888.740 fps!\n"
     ]
    }
   ],
   "source": [
    "geo = {\"detector\": det, \n",
    "       \"wavelength\": 1e-10}\n",
    "ai = pyFAI.load(geo)\n",
    "omega = ai.solidAngleArray()\n",
    "res0 = ai.integrate1d(frame, nbins, method=(\"full\", \"csc\", \"cython\"))\n",
    "engine = ai.engines[res0.method].engine\n",
    "#This is how the engine works:\n",
    "res1 = engine.integrate_ng(frame, solidangle=omega)\n",
    "assert numpy.allclose(res0.intensity, res1.intensity)  # validates the equivalence of both approaches:\n",
    "print(\"Timing for the direct azimuthal integration: \", end=\"\")\n",
    "timing_integration = %timeit -o engine.integrate_ng(frame, solidangle=omega)\n",
    "print(f\"The maximum achievable integration speed on a single core is {1/timing_integration.best:.3f} fps which does not look fancy.\")\n",
    "print(f\"But parallelized over {nbthreads} threads, it could reach: {nbthreads/timing_integration.best:.3f} fps!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6178d4b3-86f0-4428-a147-90cff651ebd3",
   "metadata": {},
   "source": [
    "### 6.1.2 Benchmarking of the serial workflow\n",
    "\n",
    "This code tries to be simple and elegant. \n",
    "It provides the reference values on the one hand and the baseline performances on the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "59e5bc41-f960-47a3-a9d2-133c2131e60d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:22:40.148332Z",
     "iopub.status.busy": "2026-09-15T08:22:40.148235Z",
     "iopub.status.idle": "2026-09-15T08:25:48.798321Z",
     "shell.execute_reply": "2026-09-15T08:25:48.797545Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<TimeitResult : 3min 8s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%timeit -o -r1 -n1 -q\n",
    "#Naive implementation ... read+integrate\n",
    "result0 = numpy.empty((nbframes, nbins), dtype=numpy.float32)\n",
    "method = (\"full\", \"csc\", \"cython\")\n",
    "\n",
    "with h5py.File(filename, \"r\") as h:\n",
    "    ds = h[h5path]\n",
    "    for i, frame in enumerate(ds):\n",
    "        result0[i] = ai.integrate1d(frame, nbins, method=method).intensity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "ce61a7ec-577e-4e6a-bf59-e0cc8f60478d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.800670Z",
     "iopub.status.busy": "2026-09-15T08:25:48.800561Z",
     "iopub.status.idle": "2026-09-15T08:25:48.803656Z",
     "shell.execute_reply": "2026-09-15T08:25:48.802989Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A naive implementation provides only 21.713 fps.\n"
     ]
    }
   ],
   "source": [
    "timing_naive = _\n",
    "# print(f\"The maximum achievable decompression+integration speed is {1/(timing_decompress.best+timing_integration.best):.3f} fps in serial \\n\\\n",
    "# and {nbthreads*1/(timing_decompress.best+timing_integration.best):.3f} fps in parallel on {nbthreads} threads\\n\\\n",
    "print(f\"A naive implementation provides only {nbframes/(timing_naive.best):.3f} fps.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0131a856-0a8b-4845-91a8-287abc0edf01",
   "metadata": {},
   "source": [
    "## 6.2 Pool of threads, queues, \n",
    "\n",
    "Unlike processes, threads share the same memory space (with the GIL preventing read/write collision).\n",
    "Threads are a great idea which allow multiple flow of execution to occur in parallel but threads come with a cost.\n",
    "Thus it is stupid to have as many threads as tasks to perform. \n",
    "It is better to have a limited number of threads, on the order of the number of cores, and have them processing several frames.\n",
    "\n",
    "We will define a pool of threads, a list of threads, started and ready to crunch some data.\n",
    "Communication between threads can be made via `Queues`.\n",
    "Each worker waits on the input-queue (`qin`) for something to process and puts the result into the output queue (`qout`).\n",
    "Since we want the processing to tidy up at the end, if a worker gets a `None` this means it is time to end the thread. \n",
    "This is sometimes called a \"kill-pill\". \n",
    "The `end_pool` function distributes as many \"kill-pills\" as needed to end all threads in the pool. \n",
    "\n",
    "In this section we define some tools to create and stop a pool of worker and also a dummy_worker which does nothing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "def90b10-3d93-4051-98c4-6de6e7db3e37",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.805279Z",
     "iopub.status.busy": "2026-09-15T08:25:48.805191Z",
     "iopub.status.idle": "2026-09-15T08:25:48.811189Z",
     "shell.execute_reply": "2026-09-15T08:25:48.810526Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "None\n",
      "None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# a few of utility functions\n",
    "def dummy_worker(qin, qout, funct=lambda item: item):\n",
    "    \"\"\"Dummy worker which takes something in qin, applies funct on it and puts the result in qout\"\"\"\n",
    "    while True:\n",
    "        item = qin.get()\n",
    "        if item is None:\n",
    "            qout.put(None)\n",
    "            qin.task_done()\n",
    "            return\n",
    "        qout.put(funct(item))\n",
    "        qin.task_done()\n",
    "\n",
    "def build_pool(nbthreads, qin, qout, worker=None, funct=None):\n",
    "    \"\"\"Build a pool of threads with workers, and starts them\"\"\"\n",
    "    pool = []\n",
    "    for i in range(nbthreads):\n",
    "        if funct is not None:\n",
    "            worker = dummy_worker\n",
    "            thread = threading.Thread(target=worker, name=f\"{worker.__name__}_{i:02d}\", args=(qin, qout, funct))\n",
    "        elif worker is None:\n",
    "            worker = dummy_worker\n",
    "            thread = threading.Thread(target=worker, name=f\"{worker.__name__}_{i:02d}\", args=(qin, qout))\n",
    "        else:\n",
    "            thread = threading.Thread(target=worker, name=f\"{worker.__name__}_{i:02d}\", args=(qin, qout, filename))\n",
    "        thread.start()\n",
    "        pool.append(thread)\n",
    "    return pool\n",
    "\n",
    "def end_pool(pool):\n",
    "    \"\"\"Ends all threads from a pool by sending them a \"kill-pill\"\"\"\n",
    "    for thread in pool:\n",
    "        qin.put(None)\n",
    "\n",
    "\n",
    "#Small validation to check it works: \n",
    "qin = Queue()\n",
    "qout = Queue()\n",
    "pool=build_pool(4, qin, qout, dummy_worker)\n",
    "end_pool(pool)\n",
    "qin.join()\n",
    "while not qout.empty():\n",
    "    print(qout.get())\n",
    "    qout.task_done()\n",
    "qout.join()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc93cd8b-3f93-4f21-b8a9-97e4bd08ca93",
   "metadata": {},
   "source": [
    "### 6.3 Parallelize decompression + processing\n",
    "\n",
    "In this example, all chunks are read by the HDF5 library and put in a queue for the processing.\n",
    "As a consequence, all chunks are likely to be held in memory at the same time, which is equivalent of the size of the compressed HDF5 file, 10GB. \n",
    "This could be a problem on many computer and we choose to limit the number of chunks in memory to ~10x more than the number of threads.\n",
    "The implementation of the slow-down mechanism is done via the size of the input queue (into which the reader puts chunks)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "b0cffcf6-ede0-4cf0-8e38-f247e8c15352",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.812961Z",
     "iopub.status.busy": "2026-09-15T08:25:48.812875Z",
     "iopub.status.idle": "2026-09-15T08:25:48.815951Z",
     "shell.execute_reply": "2026-09-15T08:25:48.815251Z"
    }
   },
   "outputs": [],
   "source": [
    "def reader_chunks(filename, h5path, queue):\n",
    "    \"\"\"Function reading the HDF5 file and enqueuing raw-chunks into the queue.\n",
    "    \n",
    "    :param filename: name of the HDF5 file\n",
    "    :param h5path: path to the dataset within the HDF5 file\n",
    "    :param queue: queue where to put read chunks\n",
    "    :return: number of chunks\"\"\"\n",
    "    with h5py.File(filename, \"r\") as h:\n",
    "        ds = h[h5path]\n",
    "        for i in range(ds.id.get_num_chunks()):\n",
    "            filter_mask, chunk = ds.id.read_direct_chunk(ds.id.get_chunk_info(i).chunk_offset)\n",
    "            if filter_mask==0:\n",
    "                while queue.full():\n",
    "                    # slow down to prevent filling up memory\n",
    "                    os.sched_yield()\n",
    "                queue.put(Item(i, chunk))\n",
    "    return i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "098b0fc0-4c60-4e73-80a6-3a1e3f5ed867",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.817541Z",
     "iopub.status.busy": "2026-09-15T08:25:48.817455Z",
     "iopub.status.idle": "2026-09-15T08:25:48.819917Z",
     "shell.execute_reply": "2026-09-15T08:25:48.819276Z"
    }
   },
   "outputs": [],
   "source": [
    "def decompress_integrate_funct(item):\n",
    "    \"function to be used within a dummy_worker: takes an item and returns an item\"\n",
    "    frame = decompress_bslz4_chunk(item.data, dtype, shape)\n",
    "    return Item(item.index, engine.integrate_ng(frame, solidangle=omega).intensity)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "bf81e2e9-a2d0-45fb-8108-446549a27ba0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.821633Z",
     "iopub.status.busy": "2026-09-15T08:25:48.821549Z",
     "iopub.status.idle": "2026-09-15T08:25:48.824447Z",
     "shell.execute_reply": "2026-09-15T08:25:48.823857Z"
    }
   },
   "outputs": [],
   "source": [
    "def parallel_decompress_integrate(filename, h5path, nbthreads):\n",
    "    qin = Queue(nbthreads*10)\n",
    "    qout = Queue()\n",
    "    pool = build_pool(nbthreads, qin, qout, funct=decompress_integrate_funct)\n",
    "    nchunks = reader_chunks(filename, h5path, qin)\n",
    "    output = numpy.empty((nchunks, nbins), numpy.float32)\n",
    "    end_pool(pool)\n",
    "    qin.join()\n",
    "    while not qout.empty():\n",
    "        item = qout.get()\n",
    "        if item is not None:\n",
    "            output[item.index] = item.data\n",
    "        qout.task_done()\n",
    "    qout.join()\n",
    "    return output\n",
    "    \n",
    "# parallel_decompress_integrate(filename, h5path, nbthreads)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3b510f2f-49b3-41a2-8b71-81a41f725ec0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:25:48.826050Z",
     "iopub.status.busy": "2026-09-15T08:25:48.825958Z",
     "iopub.status.idle": "2026-09-15T08:26:05.453783Z",
     "shell.execute_reply": "2026-09-15T08:26:05.453163Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timimg of serial read (h5py direct) and 64x(decompression+integration): \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Direct read + // integration reaches 246.405 fps.\n",
      "The speed-up is 11.348x for a computer with 64 threads.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Timimg of serial read (h5py direct) and {nbthreads}x(decompression+integration): \")\n",
    "timing_dcr = %timeit -o -r1 -n1 parallel_decompress_integrate(filename, h5path, nbthreads)\n",
    "print(f\"Direct read + // integration reaches {nbframes/(timing_dcr.best):.3f} fps.\")\n",
    "print(f\"The speed-up is {timing_naive.best/timing_dcr.best:.3f}x for a computer with {nbthreads} threads.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8cdf7557-f6fe-46d7-bdca-770e2e62c194",
   "metadata": {},
   "source": [
    "### 6.3 Parallelize read + decompression + processing\n",
    "We will now investigate the case where even the reading is made in the worker thread.\n",
    "One advantage is that all chunk-descriptions can be hosted in memory (hundreds of kilobytes) and one does not need to take care of memory filling up with raw data.\n",
    "\n",
    "Here is the reader for such type of processing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "82e58870-ebb0-45ff-aec2-f203f25a9f44",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:05.455587Z",
     "iopub.status.busy": "2026-09-15T08:26:05.455469Z",
     "iopub.status.idle": "2026-09-15T08:26:05.458569Z",
     "shell.execute_reply": "2026-09-15T08:26:05.458020Z"
    }
   },
   "outputs": [],
   "source": [
    "def reader_descr(filename, h5path, queue):\n",
    "    \"\"\"Function reading the HDF5 file and enqueuing chunk-descriptor into the queue.\n",
    "    \n",
    "    :param filename: name of the HDF5 file\n",
    "    :param h5path: path to the dataset within the HDF5 file\n",
    "    :param queue: queue where to put read chunks\n",
    "    :return: number of chunks\"\"\"\n",
    "    with h5py.File(filename, \"r\") as h:\n",
    "        ds = h[h5path]\n",
    "        for i in range(ds.id.get_num_chunks()):\n",
    "            queue.put(Item(i, ds.id.get_chunk_info(i)))\n",
    "    return i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "24158f69-2577-42c6-9cc1-8e9a1ad74581",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:05.459836Z",
     "iopub.status.busy": "2026-09-15T08:26:05.459745Z",
     "iopub.status.idle": "2026-09-15T08:26:09.334016Z",
     "shell.execute_reply": "2026-09-15T08:26:09.333240Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The reader is providing performances close to those benchmarked at section #5.3:\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "483 ms ± 5.42 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
      "It is measured 0.376 % slower.\n",
      "The reader is able to reach 8576.760 fps\n"
     ]
    }
   ],
   "source": [
    "print(\"The reader is providing performances close to those benchmarked at section #5.3:\")\n",
    "timing_reader_descr = %timeit -o reader_descr(filename, h5path, Queue())\n",
    "print(f\"It is measured {100*(timing_reader_descr.best/timing_parse.best-1):.3f} % slower.\")\n",
    "print(f\"The reader is able to reach {nbframes/timing_reader_descr.best:.3f} fps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fee001e-da99-4e3d-b266-0dd8fd18e08f",
   "metadata": {},
   "source": [
    "#### 6.3.1 Parallelize read + decompression + processing using the Python file interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "13b0dd04-9f28-412f-98d6-1511eb163698",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:09.336560Z",
     "iopub.status.busy": "2026-09-15T08:26:09.336440Z",
     "iopub.status.idle": "2026-09-15T08:26:09.340013Z",
     "shell.execute_reply": "2026-09-15T08:26:09.339358Z"
    }
   },
   "outputs": [],
   "source": [
    "def worker_python(qin, qout, filename):\n",
    "    with open(filename, \"rb\") as f:\n",
    "        while True:\n",
    "            item = qin.get()                \n",
    "            qin.task_done()\n",
    "            if item is None:\n",
    "                return\n",
    "            idx, chunk_descr = item\n",
    "            f.seek(chunk_descr.byte_offset)\n",
    "            chunk = f.read(chunk_descr.size)\n",
    "            frame = decompress_bslz4_chunk(chunk, dtype, shape)\n",
    "            qout.put(Item(idx, engine.integrate_ng(frame, solidangle=omega).intensity))\n",
    "            del chunk, frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1147ec52-99be-474e-b7c8-1c456c05e091",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:09.341863Z",
     "iopub.status.busy": "2026-09-15T08:26:09.341771Z",
     "iopub.status.idle": "2026-09-15T08:26:09.344890Z",
     "shell.execute_reply": "2026-09-15T08:26:09.344221Z"
    }
   },
   "outputs": [],
   "source": [
    "def parallel_read_decompress_integrate(filename, h5path, nbthreads, worker):\n",
    "    qin = Queue()\n",
    "    qout = Queue()\n",
    "    pool = build_pool(nbthreads, qin, qout, worker=worker)\n",
    "    nchunks = reader_descr(filename, h5path, qin)\n",
    "    output = numpy.empty((nchunks, nbins), numpy.float32)\n",
    "    end_pool(pool)\n",
    "    qin.join()\n",
    "    while not qout.empty():\n",
    "        item = qout.get()\n",
    "        if item is not None:\n",
    "            output[item.index] = item.data\n",
    "        qout.task_done()\n",
    "    qout.join()\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "72ee1bc4-5d8a-4eaf-99e8-a9323b0d1c93",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:09.346625Z",
     "iopub.status.busy": "2026-09-15T08:26:09.346536Z",
     "iopub.status.idle": "2026-09-15T08:26:27.825436Z",
     "shell.execute_reply": "2026-09-15T08:26:27.824676Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timimg of serial descriptor read and 64x(read+decompression+integration): \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.5 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Parallel read+integration reaches 221.716 fps.\n",
      "The speed-up is 10.211x for a computer with 64 threads.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Timimg of serial descriptor read and {nbthreads}x(read+decompression+integration): \")\n",
    "timing_python_file = %timeit -o -r1 -n1 parallel_read_decompress_integrate(filename, h5path, nbthreads, worker_python)\n",
    "print(f\"Parallel read+integration reaches {nbframes/(timing_python_file.best):.3f} fps.\")\n",
    "print(f\"The speed-up is {timing_naive.best/timing_python_file.best:.3f}x for a computer with {nbthreads} threads.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa63fdcd-1d58-4ca1-b51f-6d0ab3bbaf0a",
   "metadata": {},
   "source": [
    "#### 6.3.1 Parallelize read + decompression + processing using the `numpy.memmap` interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "8001b38d-1837-45a5-838c-15e12abd0995",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:27.827051Z",
     "iopub.status.busy": "2026-09-15T08:26:27.826930Z",
     "iopub.status.idle": "2026-09-15T08:26:27.830691Z",
     "shell.execute_reply": "2026-09-15T08:26:27.829828Z"
    }
   },
   "outputs": [],
   "source": [
    "def worker_numpy(qin, qout, filename):\n",
    "    f = numpy.memmap(filename, mode=\"r\")\n",
    "    while True:\n",
    "        item = qin.get()                \n",
    "        qin.task_done()\n",
    "        if item is None:\n",
    "            del f\n",
    "            return\n",
    "        idx, chunk_descr = item\n",
    "        chunk = f[chunk_descr.byte_offset:chunk_descr.byte_offset+chunk_descr.size]\n",
    "        frame = decompress_bslz4_chunk(chunk, dtype, shape)\n",
    "        qout.put(Item(idx, engine.integrate_ng(frame, solidangle=omega).intensity))\n",
    "        del chunk, frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a0906da8-4b10-452b-b4a5-9fa0f49159a9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:27.832513Z",
     "iopub.status.busy": "2026-09-15T08:26:27.832422Z",
     "iopub.status.idle": "2026-09-15T08:26:45.248549Z",
     "shell.execute_reply": "2026-09-15T08:26:45.247873Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timimg of serial descriptor read and 64x(read+decompression+integration): \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Parallel read+integration reaches 235.242 fps.\n",
      "The speed-up is 10.834x for a computer with 64 threads.\n"
     ]
    }
   ],
   "source": [
    "print(f\"Timimg of serial descriptor read and {nbthreads}x(read+decompression+integration): \")\n",
    "timing_numpy_file = %timeit -o -r1 -n1 parallel_read_decompress_integrate(filename, h5path, nbthreads, worker_numpy)\n",
    "print(f\"Parallel read+integration reaches {nbframes/(timing_numpy_file.best):.3f} fps.\")\n",
    "print(f\"The speed-up is {timing_naive.best/timing_numpy_file.best:.3f}x for a computer with {nbthreads} threads.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c314a9d6-4878-480a-8625-ba6b295bf96f",
   "metadata": {},
   "source": [
    "Effective implementation using multithreading:\n",
    "* One reader which reads the dataset chunk-by-chunk or descriptor by descriptor and makes them available via an input-queue, called `qin`.\n",
    "* A pool of workers: pool of the size of the number of cores. Each worker is doing the (reading of one chunk if needed), decompression of one chunk into one frame and the azimuthal integration of that frame. The integrated result is put into an output-queue, called `qout`.\n",
    "* 2 queues: `qin` and `qout`, the former could need to be limited in size to prevent the filling-up of the memory when complete chunks are put into it.\n",
    "* The gathering of the data is performed in the main thread (as does the reader). Each piece of data is associated with its index in the dataset using the Item named-tuple.\n",
    "\n",
    "Nota: I had a hard time to perform both reading and writing with HDF5 (even in different files). This is why the result is reconstructed in memory and the saving performed at the very end. Could be a bug in h5py."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "769fd274-e668-4065-ba8f-681a56906838",
   "metadata": {},
   "source": [
    "## 7. Display some results\n",
    "Since the input data were all synthetic and similar, no great science is expected from this... but one can ensure each frame differs slightly from the neighbors with a pattern of 500 frames. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "478cf30b-a1ca-4c62-8031-c364c2543816",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:26:45.250465Z",
     "iopub.status.busy": "2026-09-15T08:26:45.250350Z",
     "iopub.status.idle": "2026-09-15T08:27:03.629312Z",
     "shell.execute_reply": "2026-09-15T08:27:03.628464Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 11min 18s, sys: 46.3 s, total: 12min 4s\n",
      "Wall time: 18 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f4e644142d0>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%time result = parallel_read_decompress_integrate(filename, h5path, nbthreads, worker_numpy)\n",
    "fig,ax = subplots(figsize=(8,8))\n",
    "ax.imshow(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d52a13fe-3265-4e74-866e-8056e105dce5",
   "metadata": {},
   "source": [
    "## 7. Evolution of the performances with the number of threads"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "a89e908a-d950-48d6-8ff2-2b39cdda629e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:27:03.631139Z",
     "iopub.status.busy": "2026-09-15T08:27:03.631028Z",
     "iopub.status.idle": "2026-09-15T08:55:35.634419Z",
     "shell.execute_reply": "2026-09-15T08:55:35.633549Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using 64 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.3 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.1 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 56 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.9 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14.9 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 48 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 40 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.9 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 36 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 32 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15.3 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 28 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.9 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 24 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 20 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.6 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.8 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 16 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "19.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 12 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.3 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.3 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 8 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "28.7 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33.4 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 4 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1min 1s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1min 15s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "46.9 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 2 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1min 43s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1min 33s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1min 26s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n",
      "Using 1 threads\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3min 3s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3min 7s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2min 52s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "performances_h5py = {}\n",
    "performances_file = {}\n",
    "performances_memmap = {}\n",
    "for i in (64, 56, 48, 40, 36, 32, 28, 24, 20,16, 12, 8, 4, 2, 1):\n",
    "    print(f\"Using {i} threads\")\n",
    "    \n",
    "    t = %timeit -r1 -n1 -o parallel_decompress_integrate(filename, h5path, i)\n",
    "    performances_h5py[i] = nbframes/t.best\n",
    "\n",
    "    t = %timeit -r1 -n1 -o parallel_read_decompress_integrate(filename, h5path, i, worker_python)\n",
    "    performances_file[i] = nbframes/t.best\n",
    "\n",
    "    t = %timeit -r1 -n1 -o parallel_read_decompress_integrate(filename, h5path, i, worker_numpy)\n",
    "    performances_memmap[i] = nbframes/t.best\n",
    "    gc.collect()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1d6c9040-6de2-47b4-b598-528b96833de3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:55:35.636487Z",
     "iopub.status.busy": "2026-09-15T08:55:35.636390Z",
     "iopub.status.idle": "2026-09-15T08:55:35.799272Z",
     "shell.execute_reply": "2026-09-15T08:55:35.798379Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = subplots(figsize=(10,8))\n",
    "ax.plot(list(performances_h5py.keys()),list(performances_h5py.values()), \"o-\", label=\"h5py direct chunk\")\n",
    "ax.plot(list(performances_file.keys()),list(performances_file.values()), \"o-\", label=\"python file\")\n",
    "ax.plot(list(performances_memmap.keys()),list(performances_memmap.values()), \"o-\", label=\"numpy memmap\")\n",
    "ax.legend()\n",
    "ax.set_xlabel(\"Number of threads\")\n",
    "ax.set_ylabel(\"Number of frames processed by second (fps)\")\n",
    "ax.set_title(\"Performances to read HDF5 + azimuthal integration of 4Mpix images\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "094b673d-f373-431b-92ed-4c9ef9ff3c79",
   "metadata": {},
   "source": [
    "## 8. Conclusion\n",
    "\n",
    "Reading Bitshuffle-LZ4 data can be parallelized using multi-threading in Python. \n",
    "\n",
    "The procedure is a bit tedious but not out of reach for a Python programmer: few threads and a couple of queues. \n",
    "This burden is worth when coupling decompression with azimuthal integration to reduce the amount of data  stored in memory.\n",
    "\n",
    "The performances obtained on a 64-core computer are close to what can be obtained from a GPU: ~500 fps\n",
    "The speed-up obtained with the procedure is 30x on a 64-core computer versus single threaded implementation, which demonstrates multithreading is worth the burden.\n",
    "\n",
    "One notices the effort for going around the different locks from `HDF5` and `h5py` did not bring much more performances. This could be linked to a common limiting factor: the `GIL`. \n",
    "This demonstration shows multithreaded Python is possible but the number of effectively parallel threads is \n",
    "limited around 40-48 threads on the 2x32 core computer. \n",
    "Other methods exist to have more simultaneous cores: multiprocessing, but also GPU processing which is exposed in other notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2b8105-71d9-4440-93f9-0a30f8f507cc",
   "metadata": {},
   "source": [
    "Thanks again to the French-CRG for the computer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "b90f5458-9fd4-4d83-bfbd-017e3a9365dd",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-09-15T08:55:35.800952Z",
     "iopub.status.busy": "2026-09-15T08:55:35.800854Z",
     "iopub.status.idle": "2026-09-15T08:55:35.803602Z",
     "shell.execute_reply": "2026-09-15T08:55:35.802977Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total processing time: 2093.215 s\n"
     ]
    }
   ],
   "source": [
    "print(f\"Total processing time: {time.time()-start_time:.3f} s\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}