{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Background Low-density Parity-check Codes\n",
    "\n",
    "We start with a Python version of the 5G NR LDPC decoder architecture, which is then used as blueprint for the later CUDA implementation. \n",
    "If you are already familiar with the concept of belief propagation (BP) decoding, you can skip this part of the tutorial.\n",
    "\n",
    "![LDPC Basics](../../../doc/source/figs/tutorial_ldpc_basics.png)\n",
    "<p style=\"text-align: center;\">Fig. 1: Parity-check matrix and decoding graph of the (7,4) Hamming code.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background: Channel Coding in 5G\n",
    "\n",
    "In 5G NR, there are two major channel coding schemes: [Low-density Parity-check (LDPC)](https://en.wikipedia.org/wiki/Low-density_parity-check_code) and Polar codes. LDPC codes are used for the data channels while Polar codes are used for the control channels. This tutorial focuses only on the LDPC decoder as this is one of the most compute-intensive components in the 5G stack.\n",
    "\n",
    "LDPC codes have been invented in 1963 by Robert G. Gallager but were long forgotten due to their high decoding complexity. After their rediscovery by MacKay in 1996, they have become the workhorse of many modern communication standards, including 5G NR.\n",
    "\n",
    "The core idea of LDPC decoding is an iterative algorithm based on belief propagation. These iterations can be easily parallelized as each processing node is independent of the others, making them an ideal candidate for GPU acceleration. For further details on LDPC codes in OAI, we refer to [Romani2020].\n",
    "\n",
    "A machine learning enhanced version of the LDPC decoder has been proposed in [Nachmani2016] and is available as [Sionna Tutorial on Weighted Belief Propagation Decoding](https://nvlabs.github.io/sionna/phy/tutorials/Weighted_BP_Algorithm.html).\n",
    "\n",
    "\n",
    "## Overview Decoder Implementation\n",
    "\n",
    "![LDPC Acceleration Overview](../../../doc/source/figs/tutorial_ldpc_kernel.png)\n",
    "<p style=\"text-align: center;\">Fig. 2: Overview of the LDPC BP decoding algorithm.</p>\n",
    "\n",
    "An overview of the LDPC BP decoding algorithm is shown in Fig. 2 above.\n",
    "The core decoding algorithm is implemented in the *update_cn_kernel(.)* and *update_vn_kernel(.)* functions. Both kernels are iteratively executed and perform the check node (CN) and variable node (VN) updates, respectively. The decoder stops when the maximum number of iterations is reached. An additional early stopping condition could also be applied to reduce the average number of iterations.\n",
    "\n",
    "*pack_bits_kernel(.)* maps the soft-values to hard-decided bits and packs them into a more compact byte-representation which is required for the OAI processing pipeline.\n",
    "\n",
    "Note that the decoder is implemented using `int` datatypes instead of `float`. This ensures compatibility with OAI.\n",
    "\n",
    "The Python code of this tutorial can be also found in [plugins/ldpc_cuda/src/python/numpy_decoder.py](https://github.com/NVlabs/sionna-rk/blob/main/plugins/ldpc_cuda/src/python/numpy_decoder.py)\n",
    "\n",
    "### Python Imports\n",
    "\n",
    "Let us now import the relevant libraries. We use the `LDPC5GEncoder` from Sionna to simplify the code construction. Sionna is not required to run the final CUDA decoder."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the required libraries\n",
    "import os # Configure which GPU\n",
    "if os.getenv(\"CUDA_VISIBLE_DEVICES\") is None:\n",
    "    gpu_num = 0 # Use \"\" to use the CPU\n",
    "    os.environ[\"CUDA_VISIBLE_DEVICES\"] = f\"{gpu_num}\"\n",
    "\n",
    "# Set the TF log level to only show errors\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Import Sionna LDPCEncoder LDPC code definitions\n",
    "from sionna.phy.fec.ldpc import LDPC5GEncoder, LDPC5GDecoder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basegraph selection\n",
    "\n",
    "In 5G NR, the LDPC code is defined by two basegraphs (`bg`) each with 8 different realizations (selected by the lifting set index `ils`) depending on the code length and rate. The basegraph selection must be done during each decoding execution as the code parameters can dynamically change.\n",
    "\n",
    "The LDPC code construction itself is a quasi-cyclic (QC) LDPC code with lifting factor $Z$ which takes values between 2,...,384. For details see [Richardson2018]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_bg(ils, bg, verbose=False):\n",
    "    \"\"\"Pre-generates basegraph description for the given lifting set index and basegraph number.\n",
    "\n",
    "    This can be precomputed and stored before the decoding process.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    ils : int | 0,...,7\n",
    "        lifting set index of bg as defined in 38.212 Tab 5.3.2-1.\n",
    "    bg : int | 1,2\n",
    "        Basegraph number\n",
    "    verbose : bool\n",
    "        If True, additional information is printed\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    bg_vn : list of tuples\n",
    "        Each tuple contains the variable node index, the check node index, the cyclic shift and the offset for the memory access of the message.\n",
    "    bg_cn : list of tuples\n",
    "        Each tuple contains the check node index, the variable node index, the cyclic shift and the offset for the memory access of the message.\n",
    "    bg_vn_degree : list\n",
    "        List of variable node degrees.\n",
    "    bg_cn_degree : list\n",
    "        List of check node degrees.\n",
    "    \"\"\"\n",
    "\n",
    "    if bg==1:\n",
    "        bg = \"bg1\"\n",
    "    else:\n",
    "        bg = \"bg2\"\n",
    "    # Use sionna to load the basegraph\n",
    "    enc = LDPC5GEncoder(12, 24) # dummy encoder\n",
    "    mat_ref = enc._load_basegraph(ils, bg)\n",
    "\n",
    "    #########################################################\n",
    "    # Generate bg compact description\n",
    "    #########################################################\n",
    "\n",
    "    # From VN perspective\n",
    "    bg_vn = []\n",
    "    msg_offset = 0 # Counter how many messages blocks have been passed already\n",
    "    for idx_vn in range(mat_ref.shape[1]):\n",
    "        t = []\n",
    "        for idx_cn in range(mat_ref.shape[0]):\n",
    "            if mat_ref[idx_cn, idx_vn] != -1:\n",
    "                t.append((idx_vn, idx_cn, int(mat_ref[idx_cn, idx_vn]),\n",
    "                          msg_offset))\n",
    "                msg_offset += 1\n",
    "        bg_vn.append(t)\n",
    "\n",
    "    if verbose:\n",
    "        print(bg_vn)\n",
    "\n",
    "    # From CN perspective\n",
    "    bg_cn = []\n",
    "    for idx_cn in range(mat_ref.shape[0]):\n",
    "        t = []\n",
    "        for idx_vn in range(mat_ref.shape[1]):\n",
    "            if mat_ref[idx_cn, idx_vn] != -1:\n",
    "                # Find message offset from VN perspective\n",
    "                # Find matching entry in bg_vn to get message offset\n",
    "                for vn_entry in bg_vn[idx_vn]:\n",
    "                    if vn_entry[1] == idx_cn:\n",
    "                        msg_offset = vn_entry[3]\n",
    "                        break\n",
    "                t.append((idx_cn, idx_vn, int(mat_ref[idx_cn, idx_vn]),\n",
    "                          msg_offset))\n",
    "        bg_cn.append(t)\n",
    "    if verbose:\n",
    "        print(bg_cn)\n",
    "\n",
    "    bg_vn_degree = [len(bg_vn[i]) for i in range(len(bg_vn))]\n",
    "    bg_cn_degree = [len(bg_cn[i]) for i in range(len(bg_cn))]\n",
    "\n",
    "    if verbose:\n",
    "        print(bg_vn_degree)\n",
    "        print(bg_cn_degree)\n",
    "\n",
    "    return bg_vn, bg_cn, bg_vn_degree, bg_cn_degree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This can be be precomputed for $bg=1$ and $bg=2$ and for all possible values of $ils=0,...,7$ leading to 14 different code definitions. For the sake of readability of this Python implementation, we re-run the above function during each call of the decoding function.\n",
    "\n",
    "Before decoding, the decoder needs to load the exact code configuration for the given basegraph $bg$ and lifting factor $z$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def init_basegraph(bg, z):\n",
    "    \"\"\"Initializes the basegraph, its dimensions and number of edges/messages.\n",
    "\n",
    "    Parameters\n",
    "    ----------\n",
    "    bg : int | 1,2\n",
    "        Basegraph number\n",
    "    z : int | 2,...,384\n",
    "        Lifting factor\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    bg_vn : list of tuples\n",
    "        Each tuple contains the variable node index, the check node index, the cyclic shift and the offset for the memory access of the message.\n",
    "    bg_cn : list of tuples\n",
    "        Each tuple contains the check node index, the variable node index, the cyclic shift and the offset for the memory access of the message.\n",
    "    bg_vn_degree : list\n",
    "        List of variable node degrees.\n",
    "    bg_cn_degree : list\n",
    "        List of check node degrees.\n",
    "    num_cols : int\n",
    "        Number of variable nodes.\n",
    "    num_rows : int\n",
    "        Number of check nodes.\n",
    "    num_edges : int\n",
    "        Number of edges/messages in the graph.\n",
    "    \"\"\"\n",
    "\n",
    "    # These values are hard-coded for the basegraphs bg1 and bg2\n",
    "    # They are defined the 38.212.\n",
    "    if bg == 1:\n",
    "        num_rows = 46\n",
    "        num_cols = 68\n",
    "        num_nnz = 316 # Num non-zero elements in bg\n",
    "    else: # bg2\n",
    "        num_rows = 42\n",
    "        num_cols = 52\n",
    "        num_nnz = 197 # Num non-zero elements in bg\n",
    "\n",
    "    # Number of variable nodes\n",
    "    num_vns = num_cols * z\n",
    "    # Number of check nodes\n",
    "    num_cns = num_rows * z\n",
    "\n",
    "    # Number of edges/messages in the graph\n",
    "    num_edges = num_nnz * z\n",
    "\n",
    "    # Lifting set according to 38.212 Tab 5.3.2-1\n",
    "    s_val = [[2, 4, 8, 16, 32, 64, 128, 256],\n",
    "             [3, 6, 12, 24, 48, 96, 192, 384],\n",
    "             [5, 10, 20, 40, 80, 160, 320],\n",
    "             [7, 14, 28, 56, 112, 224],\n",
    "             [9, 18, 36, 72, 144, 288],\n",
    "             [11, 22, 44, 88, 176, 352],\n",
    "             [13, 26, 52, 104, 208],\n",
    "             [15, 30, 60, 120, 240]]\n",
    "\n",
    "    # Find lifting set index\n",
    "    ils = -1\n",
    "    for i in range(len(s_val)):\n",
    "        for j in range(len(s_val[i])):\n",
    "            if z == s_val[i][j]:\n",
    "                ils = i\n",
    "                break\n",
    "    # This case should not happen\n",
    "    assert ils != -1, \"Lifting factor not found in lifting set\"\n",
    "\n",
    "    # Load base graph; this will become a lookup table in CUDA\n",
    "    bg_vn, bg_cn, bg_vn_degree, bg_cn_degree = get_bg(ils, bg)\n",
    "\n",
    "    return bg_vn, bg_cn, bg_vn_degree, bg_cn_degree, num_cols, num_rows, num_edges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Memory Layout\n",
    "\n",
    "The resulting parity-check matrix after lifting can be visualized using the code below. Each blue dot represents a connection from a check node to a variable node and, thus, an outgoing message from a check node to a variable node which needs to be stored in the message buffer.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    " # Example code construction\n",
    "k = 8448\n",
    "n = 368*68\n",
    "enc = LDPC5GEncoder(k, n)\n",
    "dec = LDPC5GDecoder(enc)\n",
    "\n",
    "plt.spy(dec._pcm, markersize=0.3);\n",
    "plt.xlabel('Variable Nodes');\n",
    "plt.ylabel('Check Nodes');\n",
    "plt.title(f'Basegraph {enc._bg}, Lifting factor: {enc._z}');\n",
    "plt.show();\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During decoding, it requires to update three different message buffers:\n",
    "\n",
    "1. **llr_channel**: This buffer stores the LLRs from the channel. This is of size $Z*68$ for $bg=1$ and $Z*52$ for $bg=2$.\n",
    "2. **llr_total **: This buffer accumulates the LLRs from the variable nodes. This is of size $Z*68$ for $bg=1$ and $Z*52$ for $bg=2$.\n",
    "3. **llr_msg**: This buffer stores the messages from the check nodes to the variable nodes. This is of size $Z*316$ for $bg=1$ and $Z*197$ for $bg=2$.\n",
    "\n",
    "In practice, many VNs are punctured due to rate-matching, allowing decoders to skip updates for these unused nodes and operate more efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CN Update Function\n",
    "\n",
    "We are using the *min-sum* approximation for the check node update, given as \n",
    "\n",
    "$$\\qquad y_{j \\to i} = \\alpha_{j \\to i} \\cdot \\beta \\cdot {min}_{i' \\in \\mathcal{N}(j) \\setminus i} \\left(|x_{i' \\to j}| \\right)$$\n",
    "\n",
    "where $y_{j \\to i}$ denotes the message from\n",
    "check node (CN) $j$ to variable node (VN) $i$ and $x_{i \\to j}$ from\n",
    "VN $i$ to CN $j$, respectively. Further, $\\mathcal{N}(j)$ denotes\n",
    "all indices of connected VNs to CN $j$ and\n",
    "\n",
    "$$\\alpha_{j \\to i} = \\prod_{i' \\in \\mathcal{N}(j) \\setminus i} \\operatorname{sign}(x_{i' \\to j})$$\n",
    "\n",
    "is the sign of the outgoing message. The parameter $\\beta$  defines the damping factor which is used to scale the outgoing CN messages.\n",
    "For further details we refer to [Chen2005]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In the later CUDA implementation, we use int8 dtypes for the LLRs.\n",
    "# Thus, we need to clip the LLRs to the range [-127, 127]\n",
    "MAX_LLR_VALUE = 127 # depends on dtype\n",
    "\n",
    "# Damping(=scaling) factor of the outgoing LLRs to improve the decoding performance.\n",
    "# This is a heuristic value and typically a good choice.\n",
    "DAMPING_FACTOR = 0.75\n",
    "\n",
    "def update_cn(llr_msg, llr_total, z, bg_cn, bg_cn_degree, num_rows, first_iter):\n",
    "    \"\"\"\n",
    "    Inputs\n",
    "    ------\n",
    "    llr_msg: np.array [num_edges]\n",
    "        Incoming LLRs from variable nodes\n",
    "    llr_total: np.array [num_vns]\n",
    "        Accumulated LLRs from variable nodes\n",
    "    z: int | 2,...,384\n",
    "        Lifting factor\n",
    "    bg_cn: list of tuples\n",
    "        Check node configuration\n",
    "    bg_cn_degree: list\n",
    "        Check node degree\n",
    "    num_rows: int\n",
    "        Number of rows in the base graph\n",
    "    first_iter: bool\n",
    "        Whether this is the first iteration\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    llr_msg: np.array [num_edges]\n",
    "        Updated LLRs from check nodes\n",
    "    \"\"\"\n",
    "    # Check node update function\n",
    "\n",
    "    # These two loops can be parallelized in CUDA\n",
    "    for i in range(z): # between 2 and 384\n",
    "        for idx_row in range(num_rows): # Either 46 or 42\n",
    "\n",
    "            cn_degree = bg_cn_degree[idx_row] # Check node degree\n",
    "\n",
    "            # List of tuples (idx_row, idx_col, s, msg_offset)\n",
    "            cn = bg_cn[idx_row] # len(cn) = cn_degree\n",
    "\n",
    "            # Search the \"extrinsic\" min of all incoming LLRs\n",
    "            # This means we need to find the min and the second min of all incoming LLRs\n",
    "            min_1 = MAX_LLR_VALUE\n",
    "            min_2 = MAX_LLR_VALUE\n",
    "            idx_min = -1\n",
    "            node_sign = 1\n",
    "\n",
    "            # Temp buffer for signs\n",
    "            msg_sign = np.ones((19,)) # Max CN degree is 19\n",
    "\n",
    "            for ii in range(cn_degree):\n",
    "\n",
    "                # Calculate the index of the message in the LLR array\n",
    "                msg_offset = cn[ii][3]\n",
    "                s = cn[ii][2]\n",
    "                idx_col = cn[ii][1]\n",
    "                msg_idx = msg_offset * z + i\n",
    "\n",
    "                # Total VN message\n",
    "                t = llr_total[idx_col*z + (i+s)%z]\n",
    "\n",
    "                # Make extrinsic by subtracting the previous msg\n",
    "                if not first_iter: # Ignore in first iteration\n",
    "                    t -= llr_msg[msg_idx]\n",
    "\n",
    "                # Store sign for 2nd recursion\n",
    "                sign = 1 if np.abs(t) == 0 else np.sign(t)\n",
    "\n",
    "                # Could be also used for syndrome-based check or early termination\n",
    "                node_sign *= sign\n",
    "                msg_sign[ii] = sign # For later sign calculation\n",
    "\n",
    "                # Find min and second min\n",
    "                t_abs = np.abs(t)\n",
    "\n",
    "                if t_abs < min_1:\n",
    "                    min_2 = min_1\n",
    "                    min_1 = t_abs\n",
    "                    idx_min = msg_idx\n",
    "                elif t_abs < min_2:\n",
    "                    min_2 = t_abs\n",
    "\n",
    "            # Apply damping factor\n",
    "            min_1 *= DAMPING_FACTOR\n",
    "            min_2 *= DAMPING_FACTOR\n",
    "\n",
    "            # Clip min_val to MAX_LLR_VALUE\n",
    "            min_1 = np.clip(min_1, -MAX_LLR_VALUE, MAX_LLR_VALUE)\n",
    "            min_2 = np.clip(min_2, -MAX_LLR_VALUE, MAX_LLR_VALUE)\n",
    "\n",
    "            # Apply min and second min to the outgoing LLR\n",
    "            for ii in range(cn_degree):\n",
    "                msg_offset = cn[ii][3]\n",
    "\n",
    "                msg_idx = msg_offset * z + i\n",
    "                if msg_idx == idx_min:\n",
    "                    min_val = min_2\n",
    "                else:\n",
    "                    min_val = min_1\n",
    "\n",
    "                # And update outgoing msg including sign\n",
    "                llr_msg[msg_idx] = min_val * node_sign * msg_sign[ii]\n",
    "\n",
    "    return llr_msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## VN Update Function\n",
    "\n",
    "The variable node update function sums all incoming messages from the check nodes and adds the channel LLRs\n",
    "\n",
    "$$x_{i \\to j} = \\sum_{j' \\in \\mathcal{M}(i) \\setminus j} y_{j' \\to i} + \\lambda_i$$\n",
    "\n",
    "where $\\lambda_i$ denotes the channel LLR associated to the $i$-th VN and $\\mathcal{M}(i) \\setminus j$ denotes the set of check nodes connected to VN $i$ excluding the check node $j$ itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update_vn(llr_msg, llr_ch, llr_total, z, bg_vn, bg_vn_degree, num_cols):\n",
    "    \"\"\"\n",
    "    Inputs\n",
    "    ------\n",
    "    llr_msg: np.array [num_edges]\n",
    "        Incoming LLRs from check nodes\n",
    "    llr_ch: np.array [num_vns]\n",
    "        Channel LLRs\n",
    "    llr_total: np.array [num_vns]\n",
    "        Accumulated LLRs from variable nodes\n",
    "    z: int | 2,...,384\n",
    "        Lifting factor\n",
    "    bg_vn: list of tuples\n",
    "        Variable node configuration\n",
    "    bg_vn_degree: list\n",
    "        Variable node degree\n",
    "    num_cols: int\n",
    "        Number of variable nodes\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    llr_total: np.array [num_vns]\n",
    "        Updated LLRs from variable nodes\n",
    "\n",
    "    \"\"\"\n",
    "\n",
    "    # This can be parallelized in CUDA\n",
    "    for i in range(z): # Between 2 and 384\n",
    "        for idx_col in range(num_cols): # Either 52 or 68\n",
    "\n",
    "            vn_degree = bg_vn_degree[idx_col] # Variable node degree\n",
    "\n",
    "            # List of tuples (idx_col, idx_row, s, msg_offset)\n",
    "            vn = bg_vn[idx_col] # len(vn) = vn_degree\n",
    "\n",
    "            # Accumulate all incoming LLRs\n",
    "            msg_sum = 0 # Should be int16\n",
    "            for j in range(vn_degree):\n",
    "\n",
    "                msg_offset = vn[j][3]\n",
    "                s = vn[j][2]\n",
    "\n",
    "                # Index of the msg in the LLR array\n",
    "                # It is the idx_col-th variable node, and the j-th message from the idx_row-th check node\n",
    "                msg_idx = msg_offset * z + (i-s)%z\n",
    "                # Accumulate all incoming LLRs\n",
    "                msg_sum += llr_msg[msg_idx].astype(np.int16)\n",
    "\n",
    "            # Add the channel LLRs\n",
    "            msg_sum += llr_ch[idx_col*z + i].astype(np.int16)\n",
    "\n",
    "            llr_total[idx_col*z + i] = msg_sum\n",
    "\n",
    "    return llr_total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hard-decision\n",
    "\n",
    "The final LLRs can now be hard-decided to bits. Further, OAI requires to return bytes instead of bit values.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pack_bits(llr_total, block_length, pack_bits=False):\n",
    "    \"\"\"\n",
    "    Inputs\n",
    "    ------\n",
    "    llr_total: np.array [num_vns]\n",
    "        LLRs from variable nodes\n",
    "    block_length: int\n",
    "        Number of payload bits that are returned after decoding\n",
    "    pack_bits: bool\n",
    "        If True, the bits are packed into a byte array\n",
    "\n",
    "    Returns\n",
    "    -------\n",
    "    bits: np.array [block_length]\n",
    "        Decoded bits\n",
    "    \"\"\"\n",
    "\n",
    "    # OAI wants the bits in a byte array\n",
    "    if pack_bits:\n",
    "        # Round length to the nearest multiple of 8\n",
    "        block_length = int(np.ceil(block_length/8)*8)\n",
    "        bits = (llr_total[:block_length]<0).astype(np.uint8)\n",
    "        bits = np.packbits(bits)\n",
    "    else:\n",
    "        bits = (llr_total[:block_length]<0).astype(np.uint8)\n",
    "\n",
    "    return bits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main Decoding Function\n",
    "\n",
    "We can now run the full LDPC decoder by iteratively updating VN and CN update functions as depicted in Fig. 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decode_ldpc(bg, z, block_length, num_iter, llr_ch):\n",
    "    \"\"\"\n",
    "    Inputs\n",
    "    ------\n",
    "    bg: int | 1,2\n",
    "        Basegraph used for decoding\n",
    "\n",
    "    z: int | 2,...,384\n",
    "        Lifting factor\n",
    "\n",
    "    block_length: int\n",
    "        Number of payload bits that are returned after decoding\n",
    "\n",
    "    num_iter: int\n",
    "        Max number of decoding iterations\n",
    "\n",
    "    llr_ch: np.array [68+z] or [52*z] for bg1 and bg2, respectively\n",
    "        Received channel LLRs\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "    ############################\n",
    "    # Initialize Variables\n",
    "    ############################\n",
    "\n",
    "    bg_vn, bg_cn, bg_vn_degree, bg_cn_degree, num_cols, num_rows, num_edges = init_basegraph(bg, z)\n",
    "\n",
    "    # Temporary message buffer\n",
    "    # Max size is 316*384\n",
    "    llr_msg = np.zeros((num_edges,), dtype=np.int8) # No need to initialize to 0\n",
    "\n",
    "    # VN accumulator\n",
    "    # We always init the max size of the LLR array given as 68*384\n",
    "    # The accumulator needs higher precision than the message buffer\n",
    "\n",
    "    llr_ch = llr_ch.astype(np.int8)\n",
    "\n",
    "    ############################\n",
    "    # Main Decoding Loop\n",
    "    ############################\n",
    "    llr_total = np.copy(llr_ch).astype(np.int16) # llr_total will be updated in the VN update\n",
    "\n",
    "    for i in range(num_iter):\n",
    "\n",
    "        # CN update\n",
    "        # llr_msg not read, only written to in first iteration; will be filled with outputs of this function\n",
    "        llr_msg = update_cn(llr_msg, llr_total, z, bg_cn, bg_cn_degree, num_rows, i==0)\n",
    "\n",
    "        # VN update\n",
    "        llr_total = update_vn(llr_msg, llr_ch, llr_total, z, bg_vn, bg_vn_degree, num_cols)\n",
    "\n",
    "    # Pack bits\n",
    "    bits = pack_bits(llr_total, block_length, pack_bits=True)\n",
    "\n",
    "    # [optional] apply syndrome check and if not successful return `num_iter+=1``\n",
    "\n",
    "    return bits, llr_total"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run and Test the Decoder\n",
    "\n",
    "We can now run an end-to-end test of the decoder using the Sionna `LDPC5GEncoder`. Note that de-rate matching at the receiver must be done manually before decoding. This will be handled by the OAI stack in the future.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All payload bits decoded correctly!\n",
      "Shape of LLR input: (6656,)\n",
      "Shape of decoded bytes: (160,)\n"
     ]
    }
   ],
   "source": [
    "# Parameters\n",
    "k = 1280 # Payload size\n",
    "n = 2560 # Codeword size after rate matching\n",
    "num_iter = 8 # Number of decoding iterations\n",
    "llr_mag = 10 # LLR magnitude\n",
    "\n",
    "# Use Sionna for BG selection\n",
    "enc = LDPC5GEncoder(k, n)\n",
    "bg = 1 if enc._bg == \"bg1\" else 2\n",
    "z = enc._z\n",
    "\n",
    "# Draw random bits\n",
    "u = np.random.randint(0,2,k)\n",
    "\n",
    "# Encode using Sionna\n",
    "c = enc(np.expand_dims(u.astype(np.float32),0))[0].numpy()\n",
    "\n",
    "# Map to LLRs\n",
    "x = 1-2*c\n",
    "\n",
    "# Clip to max LLR value due to int8 representation\n",
    "llr_ch = np.clip((llr_mag * x),-127,127).astype(np.int8)\n",
    "\n",
    "# Get code parameters\n",
    "num_vn = 68*z if bg == 1 else 52*z\n",
    "parity_start = 22*z if bg == 1 else 10*z\n",
    "\n",
    "# Apply rate matching\n",
    "llr_input = np.zeros(num_vn,dtype=np.int8) # Takes care of the punctured bits (initialized to 0 LLR)\n",
    "llr_input[2*z:k] =  llr_ch[:k-2*z] # Unpunctured message bits\n",
    "llr_input[k:parity_start] = 127      # Shortened bits\n",
    "llr_input[parity_start:parity_start+n-k+2*z] = llr_ch[k-2*z:] # parity bits\n",
    "\n",
    "# Run decoder\n",
    "decoder_outputs,_ = decode_ldpc(bg, z, k, num_iter, llr_input)\n",
    "\n",
    "# Evaluate results\n",
    "u_hat = np.unpackbits(decoder_outputs.astype(np.uint8))[:k] # There may be a couple of extra bits if k is not a multiple of 8\n",
    "if np.all(u == u_hat):\n",
    "    print(\"All payload bits decoded correctly!\")\n",
    "else:\n",
    "    print(\"Decoding failed!\")\n",
    "\n",
    "print(f\"Shape of LLR input: {llr_input.shape}\")\n",
    "print(f\"Shape of decoded bytes: {decoder_outputs.shape}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now ready to start with the CUDA implementation!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "python3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}