Pycuda_chp_4_1.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "cuda_chp_4_1.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOuPtOI0VG6WE71qmnQ2DcD",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/nile649/CUDA_Tutorials/blob/master/cuda_chp_4_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-C79OgCZneK"
      },
      "source": [
        "#4 | 1\n",
        "## Kernels, Threads, Blocks, and Grids\n",
        "\n",
        "\n",
        "---\n",
        "The learning outcomes for this chapter are as follows:\n",
        "1. Understanding the difference between a kernel and a device function\n",
        "2. How to compile and launch a kernel in PyCUDA and use a device function\n",
        "within a kernel\n",
        "3. Effectively using threads, blocks, and grids in the context of launching a kernel\n",
        "and how to use threadIdx and blockIdx within a kernel\n",
        "4. How and why to synchronize threads within a kernel, using both\n",
        "__syncthreads() for synchronizing all threads among a single block and the\n",
        "host to synchronize all threads among an entire grid of blocks\n",
        "5. How to use device global and shared memory for intra-thread communication\n",
        "6. How to use all of our newly acquired knowledge about kernels to properly\n",
        "implement a GPU version of the parallel prefix sum\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E2cIOUELZXFa",
        "outputId": "ad9111bc-0a2b-4f1f-e3be-27c6aa177a38",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 445
        }
      },
      "source": [
        "!lscpu\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Architecture:        x86_64\n",
            "CPU op-mode(s):      32-bit, 64-bit\n",
            "Byte Order:          Little Endian\n",
            "CPU(s):              2\n",
            "On-line CPU(s) list: 0,1\n",
            "Thread(s) per core:  2\n",
            "Core(s) per socket:  1\n",
            "Socket(s):           1\n",
            "NUMA node(s):        1\n",
            "Vendor ID:           GenuineIntel\n",
            "CPU family:          6\n",
            "Model:               79\n",
            "Model name:          Intel(R) Xeon(R) CPU @ 2.20GHz\n",
            "Stepping:            0\n",
            "CPU MHz:             2200.000\n",
            "BogoMIPS:            4400.00\n",
            "Hypervisor vendor:   KVM\n",
            "Virtualization type: full\n",
            "L1d cache:           32K\n",
            "L1i cache:           32K\n",
            "L2 cache:            256K\n",
            "L3 cache:            56320K\n",
            "NUMA node0 CPU(s):   0,1\n",
            "Flags:               fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss ht syscall nx pdpe1gb rdtscp lm constant_tsc rep_good nopl xtopology nonstop_tsc cpuid tsc_known_freq pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt aes xsave avx f16c rdrand hypervisor lahf_lm abm 3dnowprefetch invpcid_single ssbd ibrs ibpb stibp fsgsbase tsc_adjust bmi1 hle avx2 smep bmi2 erms invpcid rtm rdseed adx smap xsaveopt arat md_clear arch_capabilities\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWariYr2ZuCd"
      },
      "source": [
        "Check free memory : !free -g"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U_evcjAoZZnG",
        "outputId": "645cb89c-b8db-492e-c17b-1f4300b27e1c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "!free -g"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "              total        used        free      shared  buff/cache   available\n",
            "Mem:             12           0          10           0           2          11\n",
            "Swap:             0           0           0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mX_DxcmtaHO-"
      },
      "source": [
        "Check GPu card"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eQ68rbTHZtGR",
        "outputId": "2aee8f14-07ef-4725-8362-e6bef80689f3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 357
        }
      },
      "source": [
        "!nvidia-smi"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sun Nov  1 05:21:10 2020       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 455.32.00    Driver Version: 418.67       CUDA Version: 10.1     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   34C    P8     9W /  70W |      0MiB / 15079MiB |      0%      Default |\n",
            "|                               |                      |                 ERR! |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bcH6GFV5aHX0"
      },
      "source": [
        "# Querying your GPU"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BodN6v2HaHbF"
      },
      "source": [
        "# Installing PyCUDA (Linux)\n",
        "\n",
        "\n",
        "---\n",
        "!pip install PyCUDA\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HO31A76EcfU1",
        "outputId": "60989d36-decd-41fd-da69-05dfb9cadea4",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 479
        }
      },
      "source": [
        "!pip install PyCUDA"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting PyCUDA\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/46/61/47d3235a4c13eec5a5f03594ddb268f4858734e02980afbcd806e6242fa5/pycuda-2020.1.tar.gz (1.6MB)\n",
            "\u001b[K     |████████████████████████████████| 1.6MB 5.5MB/s \n",
            "\u001b[?25hCollecting pytools>=2011.2\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/b7/30/c9362a282ef89106768cba9d884f4b2e4f5dc6881d0c19b478d2a710b82b/pytools-2020.4.3.tar.gz (62kB)\n",
            "\u001b[K     |████████████████████████████████| 71kB 11.1MB/s \n",
            "\u001b[?25hRequirement already satisfied: decorator>=3.2.0 in /usr/local/lib/python3.6/dist-packages (from PyCUDA) (4.4.2)\n",
            "Collecting appdirs>=1.4.0\n",
            "  Downloading https://files.pythonhosted.org/packages/3b/00/2344469e2084fb287c2e0b57b72910309874c3245463acd6cf5e3db69324/appdirs-1.4.4-py2.py3-none-any.whl\n",
            "Collecting mako\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/a6/37/0e706200d22172eb8fa17d68a7ae22dec7631a0a92266634fb518a88a5b2/Mako-1.1.3-py2.py3-none-any.whl (75kB)\n",
            "\u001b[K     |████████████████████████████████| 81kB 12.2MB/s \n",
            "\u001b[?25hRequirement already satisfied: six>=1.8.0 in /usr/local/lib/python3.6/dist-packages (from pytools>=2011.2->PyCUDA) (1.15.0)\n",
            "Requirement already satisfied: numpy>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from pytools>=2011.2->PyCUDA) (1.18.5)\n",
            "Requirement already satisfied: dataclasses>=0.7 in /usr/local/lib/python3.6/dist-packages (from pytools>=2011.2->PyCUDA) (0.7)\n",
            "Requirement already satisfied: MarkupSafe>=0.9.2 in /usr/local/lib/python3.6/dist-packages (from mako->PyCUDA) (1.1.1)\n",
            "Building wheels for collected packages: PyCUDA, pytools\n",
            "  Building wheel for PyCUDA (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for PyCUDA: filename=pycuda-2020.1-cp36-cp36m-linux_x86_64.whl size=621567 sha256=f7ebe150029c6326a5245a71d4d1af7ff8e3ad36f549cacc347c57a6368350f9\n",
            "  Stored in directory: /root/.cache/pip/wheels/8f/78/d1/5bb826f81d9d490297a348d818ff3ee6dd6f2075b06dde6ea0\n",
            "  Building wheel for pytools (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pytools: filename=pytools-2020.4.3-py2.py3-none-any.whl size=61374 sha256=ee998ac06fe77f38102d338526b0ca89e6436730ad8a5fb11352198d370b27e3\n",
            "  Stored in directory: /root/.cache/pip/wheels/af/c7/81/a22edb90b0b09a880468b2253bb1df8e9f503337ee15432c64\n",
            "Successfully built PyCUDA pytools\n",
            "Installing collected packages: appdirs, pytools, mako, PyCUDA\n",
            "Successfully installed PyCUDA-2020.1 appdirs-1.4.4 mako-1.1.3 pytools-2020.4.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o_cp4-bakPGM",
        "outputId": "c00e4494-198e-4dc0-ecd1-549e814a104b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "!sudo apt update\n",
        "!sudo add-apt-repository ppa:graphics-drivers\n",
        "!sudo apt-key adv --fetch-keys  http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub\n",
        "!sudo bash -c 'echo \"deb http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64 /\" > /etc/apt/sources.list.d/cuda.list'\n",
        "!sudo bash -c 'echo \"deb http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64 /\" > /etc/apt/sources.list.d/cuda_learn.list'"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\u001b[33m\r0% [Working]\u001b[0m\r            \rGet:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease [3,626 B]\n",
            "\u001b[33m\r0% [Connecting to archive.ubuntu.com (91.189.88.152)] [Connecting to security.u\u001b[0m\u001b[33m\r0% [Connecting to archive.ubuntu.com (91.189.88.152)] [Connecting to security.u\u001b[0m\u001b[33m\r0% [1 InRelease gpgv 3,626 B] [Connecting to archive.ubuntu.com (91.189.88.152)\u001b[0m\r                                                                               \rIgn:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
            "\u001b[33m\r0% [1 InRelease gpgv 3,626 B] [Connecting to archive.ubuntu.com (91.189.88.152)\u001b[0m\r                                                                               \rIgn:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Get:4 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release [697 B]\n",
            "Hit:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Get:6 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release.gpg [836 B]\n",
            "Hit:8 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Get:9 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease [15.9 kB]\n",
            "Ign:10 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages\n",
            "Get:10 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Packages [405 kB]\n",
            "Get:11 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]\n",
            "Get:12 http://archive.ubuntu.com/ubuntu bionic-updates InRelease [88.7 kB]\n",
            "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Get:14 http://archive.ubuntu.com/ubuntu bionic-backports InRelease [74.6 kB]\n",
            "Get:15 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main Sources [1,686 kB]\n",
            "Get:16 http://security.ubuntu.com/ubuntu bionic-security/main amd64 Packages [1,748 kB]\n",
            "Get:17 http://archive.ubuntu.com/ubuntu bionic-updates/main amd64 Packages [2,165 kB]\n",
            "Get:18 http://archive.ubuntu.com/ubuntu bionic-updates/universe amd64 Packages [2,118 kB]\n",
            "Get:19 http://security.ubuntu.com/ubuntu bionic-security/universe amd64 Packages [1,353 kB]\n",
            "Get:20 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic/main amd64 Packages [863 kB]\n",
            "Fetched 10.6 MB in 3s (3,368 kB/s)\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "17 packages can be upgraded. Run 'apt list --upgradable' to see them.\n",
            " Fresh drivers from upstream, currently shipping Nvidia.\n",
            "\n",
            "## Current Status\n",
            "\n",
            "Current long-lived branch release: `nvidia-430` (430.40)\n",
            "Dropped support for Fermi series (https://nvidia.custhelp.com/app/answers/detail/a_id/4656)\n",
            "\n",
            "Old long-lived branch release: `nvidia-390` (390.129)\n",
            "\n",
            "For GF1xx GPUs use `nvidia-390` (390.129)\n",
            "For G8x, G9x and GT2xx GPUs use `nvidia-340` (340.107)\n",
            "For NV4x and G7x GPUs use `nvidia-304` (304.137) End-Of-Life!\n",
            "\n",
            "Support timeframes for Unix legacy GPU releases:\n",
            "https://nvidia.custhelp.com/app/answers/detail/a_id/3142\n",
            "\n",
            "## What we're working on right now:\n",
            "\n",
            "- Normal driver updates\n",
            "- Help Wanted: Mesa Updates for Intel/AMD users, ping us if you want to help do this work, we're shorthanded.\n",
            "\n",
            "## WARNINGS:\n",
            "\n",
            "This PPA is currently in testing, you should be experienced with packaging before you dive in here:\n",
            "\n",
            "Volunteers welcome!\n",
            "\n",
            "### How you can help:\n",
            "\n",
            "## Install PTS and benchmark your gear:\n",
            "\n",
            "    sudo apt-get install phoronix-test-suite\n",
            "\n",
            "Run the benchmark:\n",
            "\n",
            "    phoronix-test-suite default-benchmark openarena xonotic tesseract gputest unigine-valley\n",
            "\n",
            "and then say yes when it asks you to submit your results to openbechmarking.org. Then grab a cup of coffee, it takes a bit for the benchmarks to run. Depending on the version of Ubuntu you're using it might preferable for you to grabs PTS from upstream directly: http://www.phoronix-test-suite.com/?k=downloads\n",
            "\n",
            "## Share your results with the community:\n",
            "\n",
            "Post a link to your results (or any other feedback to): https://launchpad.net/~graphics-drivers-testers\n",
            "\n",
            "Remember to rerun and resubmit the benchmarks after driver upgrades, this will allow us to gather a bunch of data on performance that we can share with everybody.\n",
            "\n",
            "If you run into old documentation referring to other PPAs, you can help us by consolidating references to this PPA.\n",
            "\n",
            "If someone wants to go ahead and start prototyping on `software-properties-gtk` on what the GUI should look like, please start hacking!\n",
            "\n",
            "## Help us Help You!\n",
            "\n",
            "We use the donation funds to get the developers hardware to test and upload these drivers, please consider donating to the \"community\" slider on the donation page if you're loving this PPA:\n",
            "\n",
            "http://www.ubuntu.com/download/desktop/contribute\n",
            " More info: https://launchpad.net/~graphics-drivers/+archive/ubuntu/ppa\n",
            "Press [ENTER] to continue or Ctrl-c to cancel adding it.\n",
            "\n",
            "Hit:1 https://cloud.r-project.org/bin/linux/ubuntu bionic-cran40/ InRelease\n",
            "Ign:2 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  InRelease\n",
            "Ign:3 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease\n",
            "Hit:4 https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64  Release\n",
            "Hit:5 https://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release\n",
            "Hit:7 http://security.ubuntu.com/ubuntu bionic-security InRelease\n",
            "Hit:8 http://archive.ubuntu.com/ubuntu bionic InRelease\n",
            "Hit:9 http://ppa.launchpad.net/c2d4u.team/c2d4u4.0+/ubuntu bionic InRelease\n",
            "Hit:11 http://archive.ubuntu.com/ubuntu bionic-updates InRelease\n",
            "Hit:12 http://archive.ubuntu.com/ubuntu bionic-backports InRelease\n",
            "Hit:13 http://ppa.launchpad.net/graphics-drivers/ppa/ubuntu bionic InRelease\n",
            "Reading package lists... Done\n",
            "Executing: /tmp/apt-key-gpghome.l6dK9K2uEU/gpg.1.sh --fetch-keys http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub\n",
            "gpg: requesting key from 'http://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/7fa2af80.pub'\n",
            "gpg: key F60F4B3D7FA2AF80: \"cudatools <cudatools@nvidia.com>\" not changed\n",
            "gpg: Total number processed: 1\n",
            "gpg:              unchanged: 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rhHtl8u1Mil9",
        "outputId": "9897ffb7-7d03-4d8b-ce92-cd0007d6a3e2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 323
        }
      },
      "source": [
        "!sudo apt install cuda-10-1\n",
        "!sudo apt install libcudnn7\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "cuda-10-1 is already the newest version (10.1.243-1).\n",
            "0 upgraded, 0 newly installed, 0 to remove and 17 not upgraded.\n",
            "W: Target Packages (Packages) is configured multiple times in /etc/apt/sources.list.d/cuda_learn.list:1 and /etc/apt/sources.list.d/nvidia-ml.list:1\n",
            "Reading package lists... Done\n",
            "Building dependency tree       \n",
            "Reading state information... Done\n",
            "The following additional packages will be installed:\n",
            "  libcudnn7-dev\n",
            "The following held packages will be changed:\n",
            "  libcudnn7\n",
            "The following packages will be upgraded:\n",
            "  libcudnn7 libcudnn7-dev\n",
            "2 upgraded, 0 newly installed, 0 to remove and 15 not upgraded.\n",
            "W: Target Packages (Packages) is configured multiple times in /etc/apt/sources.list.d/cuda_learn.list:1 and /etc/apt/sources.list.d/nvidia-ml.list:1\n",
            "E: Held packages were changed and -y was used without --allow-change-held-packages.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jduX33bXe99u"
      },
      "source": [
        "code to check GPU specification"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ih48_HeK1nwk"
      },
      "source": [
        "# Kernels\n",
        "\n",
        "\n",
        "---\n",
        "As in the last chapter, we'll be learning how to write CUDA kernel functions as inline\n",
        "CUDA C in our Python code and launch them onto our GPU using PyCUDA. In the last\n",
        "chapter, we used templates provided by PyCUDA to write kernels that fall into particular\n",
        "design patterns; in contrast, we'll now see how to write our own kernels from the ground\n",
        "up, so that we can write a versatile variety of kernels that may not fall into any particular\n",
        "design pattern covered by PyCUDA, and so that we may get a more fine-tuned control over\n",
        "our kernels. Of course, these gains will come at the expense of greater complexity in\n",
        "programming; we'll especially have to get an understanding of threads, blocks, and grids\n",
        "and their role in kernels, as well as how to synchronize the threads in which our kernel is\n",
        "executing, as well as understand how to exchange data among threads.\n",
        "\n",
        "---\n",
        "\n",
        "Let's start simple and try to re-create some of the element-wise operations we saw in the\n",
        "last chapter, but this time without using the ElementwiseKernel function; we'll now be\n",
        "using the <b>SourceModule</b> function. This is a very powerful function in PyCUDA that allows\n",
        "us to build a kernel from scratch, so as usual it's best to start simple.\n",
        "\n",
        "---\n",
        "\n",
        "# The PyCUDA SourceModule function\n",
        "We'll use the SourceModule function from PyCUDA to compile raw inline CUDA C code\n",
        "into usable kernels that we can launch from Python. We should note that SourceModule\n",
        "actually compiles code into a CUDA module, this is like a Python module or Windows\n",
        "DLL, only it contains a collection of compiled CUDA code. This means we'll have to \"pull\n",
        "out\" a reference to the kernel we want to use with PyCUDA's get_function, before we\n",
        "can actually launch it. Let's start with a basic example of how to use a CUDA kernel with\n",
        "SourceModule.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QB7eKUhQ0u05"
      },
      "source": [
        "import pycuda.autoinit\n",
        "import numpy as np\n",
        "import pycuda\n",
        "import pycuda.driver as drv\n",
        "from pycuda import gpuarray\n",
        "from pycuda.compiler import SourceModule\n"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YBOemVKS49t9"
      },
      "source": [
        "ker = SourceModule(\"\"\"\n",
        "__global__ void scalar_multiply_kernel(float *outvec, float scalar, float\n",
        "*vec)\n",
        "{\n",
        "int i = threadIdx.x;\n",
        "outvec[i] = scalar*vec[i];\n",
        "}\n",
        "\"\"\")"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5ghksHAw6Odd"
      },
      "source": [
        "1. we declare a kernel function in CUDA C proper, we precede it with the <b>__global __</b> keyword. This will distinguish the function as a kernel to the compiler.\n",
        "\n",
        "2. We'll always just\n",
        "declare this as a void function, because we'll always get our output values by passing a\n",
        "pointer to some empty chunk of memory that we pass in as a parameter.\n",
        "\n",
        "3. We can declare the\n",
        "parameters as we would with any standard C function: first we have outvec, which will be\n",
        "our output scaled vector, which is of course a floating-point array pointer. Next, we have\n",
        "scalar, which is represented with a mere float; notice that this is not a pointer! If we\n",
        "wish to pass simple singleton input values to our kernel, we can always do so without\n",
        "using pointers. Finally, we have our input vector, vec, which is of course another floatingpoint\n",
        "array pointer.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "<i>Let's peer into the kernel before we continue with testing it. We recall that\n",
        "<b>ElementwiseKernel</b> automatically parallelized over multiple GPU threads by a value, i,\n",
        "which was set for us by PyCUDA; the identification of each individual thread is given by\n",
        "the <b><i>threadIdx value</i></b>, which we retrieve as follows: \n",
        "\n",
        "int i = threadIdx.x;.</i>\n",
        "\n",
        "\n",
        "---\n",
        "<p style=\"color:red;\">threadIdx is used to tell each individual thread its identity.\n",
        "\n",
        " This is\n",
        "usually used to determine an index for what values should be processed\n",
        "on the input and output data arrays. (This can also be used for assigning\n",
        "particular threads different tasks than others with standard C control flow\n",
        "statements such as if or switch.)</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "D-EmLLFANvUz"
      },
      "source": [
        "scalar_multiply_gpu = ker.get_function(\"scalar_multiply_kernel\")"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jFdAyO659FdM"
      },
      "source": [
        "a_host = np.random.randn(512).astype(np.float32)\n",
        "b_host = 123\n",
        "a_device = gpuarray.to_gpu(a_host)\n",
        "c_device = gpuarray.zeros_like(a_device)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IbwYPoBgADgd"
      },
      "source": [
        "scalar_multiply_gpu( c_device, np.float32(b_host), a_device,\n",
        "block=(512,1,1), grid=(1,1,1))"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZDDkJGYVAWz0",
        "outputId": "0ebb0ae6-9535-4ba9-b874-d4df767fb166",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(\"Does our kernel work correctly? : {}\".format(np.allclose(c_device.get() , b_host*a_host) ))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Does our kernel work correctly? : True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Za2xe7CAvde"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "Now we are starting to remove the training wheels of the PyCUDA kernel templates we\n",
        "learned in the previous chapter—we can now directly write a kernel in pure CUDA C and\n",
        "launch it to use a specific number of threads on our GPU. However, we'll have to learn a bit\n",
        "more about how CUDA structures threads into collections of abstract units known as\n",
        "blocks and grids before we can continue with kernels.\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BY42yg4eA1Uz"
      },
      "source": [
        "# Threads, blocks, and grids\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GUXU0ieFAhnf"
      },
      "source": [
        "import pycuda.autoinit\n",
        "import pycuda.driver as drv\n",
        "from pycuda import gpuarray\n",
        "from pycuda.compiler import SourceModule\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.animation as animation"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7kn77FiA2_Of"
      },
      "source": [
        "When you execute the kernel, you determine how many threads each block will have (in 3D) and how many blocks there are in a 3D grid. In the following code:\n",
        "\n",
        "dim3 threads(tX, tY, tZ);\n",
        "dim3 blocks(gX, gY, gZ);\n",
        "\n",
        "kernel_function<<<blocks, threads>>>(kernel_parameters);\n",
        "You are launching the kernel function named kernel_function so that the CUDA runtime launches a 3D grid of blocks of dimensions gXxgYxgZ. Each of those blocks will contain threads organized in a 3D structure of size tXxtYxtZ.\n",
        "\n",
        "If the size of the 3rd dimension is 0 (i.e. it is a 2D mapping), the picture of the official documentation shows it better:\n",
        "\n",
        "Official CUDA thread hierarchy\n",
        "![image.png](data:image/png;base64,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)\n",
        "\n",
        "What this means is that the following will be true for every thread executing your kernel:\n",
        "\n",
        "\n",
        "blockDim.x = tX\n",
        "\n",
        "blockDim.y = tY\n",
        "\n",
        "blockDim.z = tZ\n",
        "\n",
        "gridDim.x = gX\n",
        "\n",
        "gridDim.y = gY\n",
        "\n",
        "gridDim.z = gZ\n",
        "\n",
        "And every thread will have its own coordinates within those parameters. Mathematically:\n",
        "\n",
        "0 <= threadIdx.x < blockDim.x = tX\n",
        "\n",
        "0 <= threadIdx.y < blockDim.y = tY\n",
        "\n",
        "0 <= threadIdx.z < blockDim.z = tZ\n",
        "\n",
        "0 <= blockIdx.x < gridDim.x = gX\n",
        "\n",
        "0 <= blockIdx.y < gridDim.y = gY\n",
        "\n",
        "0 <= blockIdx.z < gridDim.z = gZ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NYCvQ-Jn5Fgt"
      },
      "source": [
        "\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cRe3hvFR5PZe"
      },
      "source": [
        "1. Each threadIdx represents 3D lattics inside a block.\n",
        "2. Block can have maximum of 1024 threads each max size of 32x32.\n",
        "3. To overcome the limitation we need more Blocks over the grids.\n",
        "![image.png](data:image/png;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AQ-NBvDeMOtH",
        "outputId": "a998a353-9f2b-4857-a642-88dbe7e5fed2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        }
      },
      "source": [
        "import pycuda.autoinit\n",
        "import pycuda.driver as drv\n",
        "from pycuda import gpuarray\n",
        "from pycuda.compiler import SourceModule\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt \n",
        "import matplotlib.animation as animation\n",
        "\n",
        "ker = SourceModule(\"\"\"\n",
        "#define _X  ( threadIdx.x + blockIdx.x * blockDim.x )\n",
        "#define _Y  ( threadIdx.y + blockIdx.y * blockDim.y )\n",
        "#define _WIDTH  ( blockDim.x * gridDim.x )\n",
        "#define _HEIGHT ( blockDim.y * gridDim.y  )\n",
        "#define _XM(x)  ( (x + _WIDTH) % _WIDTH )\n",
        "#define _YM(y)  ( (y + _HEIGHT) % _HEIGHT )\n",
        "#define _INDEX(x,y)  ( _XM(x)  + _YM(y) * _WIDTH )\n",
        "// return the number of living neighbors for a given cell                \n",
        "__device__ int nbrs(int x, int y, int * in)\n",
        "{\n",
        "     return ( in[ _INDEX(x -1, y+1) ] + in[ _INDEX(x-1, y) ] + in[ _INDEX(x-1, y-1) ] \\\n",
        "                   + in[ _INDEX(x, y+1)] + in[_INDEX(x, y - 1)] \\\n",
        "                   + in[ _INDEX(x+1, y+1) ] + in[ _INDEX(x+1, y) ] + in[ _INDEX(x+1, y-1) ] );\n",
        "}\n",
        "__global__ void conway_ker(int * lattice_out, int * lattice  )\n",
        "{\n",
        "   // x, y are the appropriate values for the cell covered by this thread\n",
        "   int x = _X, y = _Y;\n",
        "   \n",
        "   // count the number of neighbors around the current cell\n",
        "   int n = nbrs(x, y, lattice);\n",
        "                   \n",
        "    \n",
        "    // if the current cell is alive, then determine if it lives or dies for the next generation.\n",
        "    if ( lattice[_INDEX(x,y)] == 1)\n",
        "       switch(n)\n",
        "       {\n",
        "          // if the cell is alive: it remains alive only if it has 2 or 3 neighbors.\n",
        "          case 3: lattice_out[_INDEX(x,y)] = 1;\n",
        "                  break;\n",
        "          default: lattice_out[_INDEX(x,y)] = 0;                   \n",
        "       }\n",
        "    else if( lattice[_INDEX(x,y)] == 0 )\n",
        "         switch(n)\n",
        "         {\n",
        "            // a dead cell comes to life only if it has 3 neighbors that are alive.\n",
        "            case 3: lattice_out[_INDEX(x,y)] = 1;\n",
        "                    break;\n",
        "            default: lattice_out[_INDEX(x,y)] = 0;         \n",
        "         }\n",
        "         \n",
        "}\n",
        "\"\"\")\n",
        "\n",
        "\n",
        "conway_ker = ker.get_function(\"conway_ker\")\n",
        "     \n",
        "\n",
        "def update_gpu(frameNum, img, newLattice_gpu, lattice_gpu, N):\n",
        "    \n",
        "    conway_ker(newLattice_gpu, lattice_gpu, grid=(N//32,N//32,1), block=(32,32,1)   )\n",
        "    \n",
        "    img.set_data(newLattice_gpu.get() )\n",
        "    \n",
        "    \n",
        "    lattice_gpu[:] = newLattice_gpu[:]\n",
        "    \n",
        "    return img\n",
        "    \n",
        "\n",
        "if __name__ == '__main__':\n",
        "    # set lattice size\n",
        "    N = 128\n",
        "    \n",
        "    lattice = np.int32( np.random.choice([1,0], N*N, p=[0.25, 0.75]).reshape(N, N) )\n",
        "    lattice_gpu = gpuarray.to_gpu(lattice)\n",
        "    \n",
        "    newLattice_gpu = gpuarray.empty_like(lattice_gpu)        \n",
        "\n",
        "    fig, ax = plt.subplots()\n",
        "    img = ax.imshow(lattice_gpu.get(), interpolation='nearest')\n",
        "    ani = animation.FuncAnimation(fig, update_gpu, fargs=(img, newLattice_gpu, lattice_gpu, N, ) , interval=0, frames=1000, save_count=1000)    \n",
        "     \n",
        "    plt.show()"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8pR9qd3pNigW"
      },
      "source": [
        "We launch the kernel with the appropriate parameters and set the block and grid sizes as\n",
        "follows:\n",
        "conway_ker(newLattice_gpu, lattice_gpu, grid=(N/32,N/32,1),\n",
        "block=(32,32,1) )\n",
        "We'll set the block sizes as 32 x 32 with (32, 32, 1); since we are only using two\n",
        "dimensions for our cell lattice, we can just set the z-dimension as one. Remember that\n",
        "blocks are limited to 1,024 threads—32 x 32 = 1024, so this will work. (Keep in mind that\n",
        "there is nothing special here about 32 x 32; we could use values such as 16 x 64 or 10 x 10 if\n",
        "we wanted to, as long as the total number of threads does not exceed 1,024.)\n",
        "The number of threads in a CUDA block is limited to a maximum of 1,024.\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "We now look at grid value—here, since we are working with dimensions of 32, it should be\n",
        "clear that N (in this case) should be divisible by 32. That means that in this case, we are\n",
        "limited to lattices such as 64 x 64, 96 x 96, 128 x 128, and 1024 x 1024. Again, if we want to\n",
        "use lattices of a different size, then we'll have to alter the dimensions of the blocks. (If this\n",
        "doesn't make sense, then please look at the previous diagrams and review how we defined\n",
        "the width and height macros in our kernel.)\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1NTvrak4WiCd"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}