cppnow2021.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "71d92085",
   "metadata": {},
   "source": [
    "<img width=100% src=\"files/images/cppnow.png\" alt=\"C++ Now Title Slide\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e635dee",
   "metadata": {},
   "source": [
    "## Once Upon a Time...\n",
    "* A colleague and I wanted to teach C++\n",
    "* We wanted to make it easier to get started, so we used\n",
    "  - Cling (an Interpreted version of Clang)\n",
    "  - Jupyter/JupyterHub\n",
    "  - Docker (a container environment that leverages the kernel)\n",
    "* We created a tool called C++Explorer for teaching C++(https://github.com/stevenrbrandt/CxxExplorer). But this talk isn't about that..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a67ab95",
   "metadata": {},
   "source": [
    "## But first, a prologue..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "386b7a67",
   "metadata": {},
   "source": [
    "## Notebooks!\n",
    "Have you met Jupyter Notebooks?\n",
    "* Notebooks are great for experimenting/playing with code.\n",
    "* Each cell is a distinct evaluation with distinct results that build on each other.\n",
    "* They persist the output of each cell action\n",
    "* Great teaching tool!\n",
    "* Usually, they are based on Python. They don't have to be.\n",
    "* Through \"magicks,\" i.e. cells beginning with %%, a cell may do something other than a Python command."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f70588e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.magic import register_cell_magic\n",
    "@register_cell_magic\n",
    "def bash(line, cell): get_ipython().system(cell)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c96ac93",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "echo Hello, world!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c0d7200",
   "metadata": {},
   "source": [
    "## Docker!\n",
    "\n",
    "Have you met Docker?\n",
    "\n",
    "* Lightweight container that makes use of the Linux kernel\n",
    "* Simple to use\n",
    "* Encapsulates complex builds / installations\n",
    "* This notebook environment is available on dockerhub as stevenrbrandt/clangmi\n",
    "    - docker pull stevenrbrandt/clangmi\n",
    "* Usually run through a related tool called docker-compose\n",
    "    - git clone https://github.com/stevenrbrandt/module-interactive.git\n",
    "    - docker-compose up -d\n",
    "    - docker-compose logs (shows the URL)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e50e464",
   "metadata": {},
   "source": [
    "## Our story begins..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ca09fbb",
   "metadata": {},
   "source": [
    "## Cling!\n",
    "\n",
    "Have you met Cling?\n",
    "\n",
    "* C++Explorer is based on Cling.\n",
    "* Cling is great!\n",
    "  - based on clang (i.e. it's interpreted clang)\n",
    "  - provides incremental compilation and execution\n",
    "  - works well most of the time\n",
    "* Cling, like any complex tool, has a few problems...\n",
    "  - LLVM bug means no std::async() https://bugs.llvm.org/show_bug.cgi?id=21431#c5\n",
    "  - When segfaults kill a notebook kernel, it's a bummer\n",
    "  - Syntax errors can sometimes kill a cling kernel\n",
    "  - Other funny problems (https://github.com/root-project/root/issues/7952)\n",
    "  - Based on Clang 5.0.0 (Cling reports version 0.8~dev)\n",
    "* Is there an alternative?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1c7ebf9",
   "metadata": {},
   "source": [
    "## Modules!\n",
    "* Modules provide incremental compilation\n",
    "* can be chained, each importing and exporting the previous one\n",
    "* so make two types of cells\n",
    "  - **def_code** to define code, functions, variables\n",
    "  - **run_code** to produce output\n",
    "* works well most of the time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0905ff5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile aloha.cppm\n",
    "export module aloha;\n",
    "#include <iostream>\n",
    "export {\n",
    "    void aloha_world() {\n",
    "        std::cout << \"Aloha, world!\" << std::endl;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "442e0691",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "rm -f aloha.pcm aloha.o\n",
    "clang++ -std=c++2a -fmodules-ts \\\n",
    "        --precompile -x c++-module -c aloha.cppm \\\n",
    "        -fimplicit-modules -fimplicit-module-maps \\\n",
    "        -stdlib=libc++ # create .pcm file\n",
    "clang++ -std=c++2a -fmodules-ts -c aloha.cppm \\\n",
    "        -fimplicit-modules -fimplicit-module-maps \\\n",
    "        -stdlib=libc++ # create .o file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d102c41",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile aloha.cpp\n",
    "import aloha;\n",
    "\n",
    "int main() {\n",
    "   aloha_world();\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "22edd4ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "clang++ -std=c++2a -fmodules-ts -o aloha aloha.cpp \\\n",
    "        aloha.o -fimplicit-modules -fimplicit-module-maps \\\n",
    "        -stdlib=libc++ -fmodule-file=aloha.pcm\n",
    "./aloha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "tutorial-zimbabwe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import runcode\n",
    "\n",
    "# verbosity levels are:\n",
    "# 0: no debug output\n",
    "# 1: show all compilations\n",
    "# 2: show generated source code\n",
    "runcode.verbosity = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ec67357",
   "metadata": {},
   "source": [
    "Our first code module. Note that string and iostream are included by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5499307b",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "std::string hello = \"Hello\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16c72bb1",
   "metadata": {},
   "source": [
    "Our second module. Note that it incorporates the first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c56c4c8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "std::string world = \"world\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "991b2c5f",
   "metadata": {},
   "source": [
    "Our first time running code. Note that we make use of the two previous modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "55c6b074",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "std::cout << hello << \", \" << world << \".\" << std::endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ef56d36",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We no longer need to see all this debug output\n",
    "runcode.verbosity = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "significant-essence",
   "metadata": {},
   "source": [
    "The runcode module has two functions, def_code (which saves the symbols you define) and run_code (which does not)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "digital-overhead",
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a flag in an environment variable\n",
    "dem = \"-DM=1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "laughing-airline",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code {dem} -DV=2 \n",
    "std::cout << \"hello M=\" << M << \" V=\" << V << \"\\n\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d36c3b6",
   "metadata": {},
   "source": [
    "We use the most innefficient form of the Fibonacci function as a proxy for work that takes a lot of time and effort. If we're using a notebook to do calculations, this is a likely situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lonely-manor",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "int fib(int n) {\n",
    "    if(n < 2)\n",
    "        return n;\n",
    "    return fib(n-1)+fib(n-2);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "constant-shower",
   "metadata": {},
   "source": [
    "The code below takes a while to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "endangered-overview",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "std::cout << fib(42) << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "733abb58",
   "metadata": {},
   "source": [
    "Naively, we try to save the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "photographic-alias",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "int n42=fib(42);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "multiple-spread",
   "metadata": {},
   "source": [
    "Of course, this results in fib42 being called in every piece of code we run that contains n42."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "young-washington",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "std::cout << \"n42=\" << n42 << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "perceived-prompt",
   "metadata": {},
   "source": [
    "Even though the symbol n42 is still defined inside a module we are importing, this code is fast. Apparently, lazy optimization works well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "false-partner",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "std::cout << \"n10=\" << fib(10) << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interested-pressure",
   "metadata": {},
   "source": [
    "We can, potentially, fix this problem by using constexpr."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "unique-arkansas",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%def_code\n",
    "constexpr int fibc(int n) {\n",
    "    if(n < 2) {\n",
    "        return n;\n",
    "    } else {\n",
    "        return fibc(n-1)+fibc(n-2);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "prostate-deadline",
   "metadata": {},
   "outputs": [],
   "source": [
    "cexpr_flags = \"-fconstexpr-steps=5000000 -fconstexpr-depth=40\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deluxe-junction",
   "metadata": {},
   "source": [
    "Unfortunately, setting of constexpr inside a module doesn't work at the moment, so we introduce %%lib to mark code that goes in the .o file, but not the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "institutional-vinyl",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code {cexpr_flags}\n",
    "extern int fc28;\n",
    "%%lib\n",
    "constexpr int fc28_ = fibc(28);\n",
    "int fc28 = fc28_;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "frequent-soundtrack",
   "metadata": {},
   "source": [
    "This retrieves the value quickly..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "violent-conjunction",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "\n",
    "std::cout << \"fc28=\" << fc28 << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c647669a",
   "metadata": {},
   "source": [
    "Maybe someday this facility will be easier to use. We note, however, that this technique essentially copies our result to a file (the object file) and retrieves it for us when we use it in subsequent calculations. This is fine if we just have an int, but not fine if we have a gigantic array that would be expensive to copy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "atmospheric-cooking",
   "metadata": {},
   "source": [
    "Fortunately, there's another way to store values between cell evaluations: shared memory. Let's create a basic counter class to put in shared memory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "short-accreditation",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "struct Counter {\n",
    "    int n;\n",
    "    Counter() : n(0) {}\n",
    "    ~Counter() { std::cout << \"reset counter\" << std::endl; }\n",
    "    void count() {\n",
    "        std::cout << \"n=\" << (n++) << std::endl;\n",
    "    }\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b020e003",
   "metadata": {},
   "source": [
    "The Boost shared memory headers don't compile at the moment. To work around this issue, I made a smaller, simpler class to access shared memory: Seg."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8b29fa4",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "Seg seg(\"mem\");\n",
    "Counter *c = seg.allocate<Counter>(\"counter\");\n",
    "c->count();\n",
    "if(c->n == 5)\n",
    "   seg.remove(c);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43b9a799",
   "metadata": {},
   "source": [
    "Seg has some special code for arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "distributed-swaziland",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%run_code\n",
    "Seg seg(\"mem\");\n",
    "Array<double>& arr=*seg.allocate_array<double>(\"data\", 100);\n",
    "if(arr.init()) std::cout << \"init\" << std::endl;\n",
    "seg.remove(&arr);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ecd317a",
   "metadata": {},
   "source": [
    "This code simply creates two arrays and populates them with data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "based-cement",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "#include <math.h>\n",
    "\n",
    "Seg seg(\"mem\");\n",
    "const int N=100;\n",
    "Array<double>& a = *seg.allocate_array<double>(\"data\",N);\n",
    "Array<double>& b = *seg.allocate_array<double>(\"data2\",N);\n",
    "double dx = 15.0/a.size();\n",
    "for(int i=0;i<a.size();i++) {\n",
    "    double x = i*dx;\n",
    "    a[i] = x;\n",
    "    b[i] = sin(x);\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b8b5a18",
   "metadata": {},
   "source": [
    "Because my toy class, Seg, implements Pybind11's buffer protocol, we can load the data arrays above, reinterpret them as numpy arrays, and plot them with matplotlib. Plotting is simple and convenient and already supported inside notebooks, so loading the shared memory segment into Python is probably the easiest way to visualize our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "seventh-landscape",
   "metadata": {},
   "outputs": [],
   "source": [
    "import clangmi\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "abuf = clangmi.allocate_array(\"mem\",\"data\",100)\n",
    "a = np.asarray(abuf)\n",
    "\n",
    "bbuf = clangmi.allocate_array(\"mem\",\"data2\",100)\n",
    "b = np.asarray(bbuf)\n",
    "\n",
    "plt.plot(a,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "religious-prairie",
   "metadata": {},
   "source": [
    "Parallel execution is straighforward. We can just call std::async()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "yellow-output",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "import <future>;\n",
    "auto a = std::async(std::launch::async, [](){ return 42; });\n",
    "std::cout << \"a=\" << a.get() << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7a2bac",
   "metadata": {},
   "source": [
    "We can, however, still use hpx parallelism. This may be necessary if we want to demonstrated cutting edge parallelism features which may be implemented in hpx but not yet supported by the compiler. To do this, we need to add some default flags to our compilations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fresh-insurance",
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import os\n",
    "\n",
    "def rmitem(item_pattern,items):\n",
    "    new_items = []\n",
    "    for item in items:\n",
    "        if not re.match(item_pattern, item):\n",
    "            new_items += [item]\n",
    "    return new_items\n",
    "\n",
    "os.environ[\"LD_LIBRARY_PATH\"]=\"/usr/local/lib64\"\n",
    "os.environ[\"PKG_CONFIG_PATH\"]=\"/usr/local/lib64/pkgconfig\"\n",
    "runcode.verbose = True\n",
    "from subprocess import Popen, PIPE\n",
    "p = Popen(\"pkg-config --cflags --libs hpx_application_release\".split(\" \"),\n",
    "          stdout=PIPE,stderr=PIPE,universal_newlines=True)\n",
    "out, err = p.communicate()\n",
    "# Set the application flags\n",
    "runcode.appflags = rmitem(r'-std=.*',re.sub(' -pthread','',out.strip()).split(' '))\n",
    "\n",
    "p = Popen(\"pkg-config --cflags hpx_application_release\".split(\" \"),\n",
    "          stdout=PIPE,stderr=PIPE,universal_newlines=True)\n",
    "out, err = p.communicate()\n",
    "# Set the module flags\n",
    "runcode.modflags = rmitem(r'-std=.*',re.sub(' -pthread','',out.strip()).split(' '))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "spoken-reporter",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%run_code\n",
    "#include <hpx/hpx.hpp>\n",
    "#include <hpx/hpx_main.hpp>\n",
    "\n",
    "auto a = hpx::async([](){ return 42; });\n",
    "std::cout << a.get() << std::endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2e68f30",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%def_code\n",
    "import <vector>;\n",
    "std::vector<int> v = { 1, 2, 3, 4, 5, 6 };"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0df0e9f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the parallelism for HPX\n",
    "runcode.runflags = [\"-t\",\"4\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "067a34a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "\n",
    "#include <hpx/hpx_main.hpp>\n",
    "#include <hpx/algorithm.hpp>\n",
    "#include <hpx/execution.hpp>\n",
    "\n",
    "hpx::experimental::for_loop(\n",
    "   hpx::execution::par, 0, v.size(),\n",
    "   [](std::size_t n) { std::cout << \"n=\" << n << std::endl;});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa94cf77",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "#include <hpx/hpx.hpp>\n",
    "#include <hpx/hpx_main.hpp>\n",
    "\n",
    "auto result1 = [](){ return 41; };\n",
    "auto result2 = [](hpx::future<int> s){ return 1+s.get(); };\n",
    "\n",
    "hpx::future<int> t = hpx::async(result1);\n",
    "hpx::future<int> t2 = t.then(result2);\n",
    "std::cout << t2.get() << std::endl;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f75c0dcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%run_code\n",
    "#include <hpx/hpx_main.hpp>\n",
    "#include <hpx/parallel/algorithms/reverse.hpp>\n",
    "hpx::reverse(hpx::execution::par,\n",
    "                       v.begin(),v.end());\n",
    "for(auto i = v.begin(); i != v.end(); ++i)\n",
    "    std::cout << *i << std::endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "identified-return",
   "metadata": {},
   "source": [
    "Running HPX requires that we set up some stuff..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peaceful-screen",
   "metadata": {},
   "source": [
    "Some things don't work yet. As mentioned before, the boost shared memory header doesn't work. Also, the hpx headers don't work in a module. The \"cxxabi.h\" header simply doesn't work, and that's one of the things hpx uses.\n",
    "\n",
    "Conclusion: Using modules for interactive computing is not quite ready for production use, but once boost and other headers compile, it could be a viable alternative to Cling in our teaching modules."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c5808a8",
   "metadata": {},
   "source": [
    "<h2>Thank you!</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3c35e1a",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}