From d1c82b59963572df5fbabbc05627500b9e759483 Mon Sep 17 00:00:00 2001 From: mcbarton <150042563+mcbarton@users.noreply.github.com> Date: Thu, 9 Oct 2025 09:46:46 +0100 Subject: [PATCH 1/7] Add c++17,c++20 and c++23 kernels all with openmp --- .../jupyter/kernels/xcpp17-omp/kernel.json.in | 6 ++--- .../jupyter/kernels/xcpp20-omp/kernel.json.in | 18 +++++++++++++ .../jupyter/kernels/xcpp20-omp/logo-32x32.png | Bin 0 -> 1520 bytes .../jupyter/kernels/xcpp20-omp/logo-64x64.png | Bin 0 -> 3113 bytes share/jupyter/kernels/xcpp20-omp/logo-svg.svg | 25 ++++++++++++++++++ .../jupyter/kernels/xcpp23-omp/kernel.json.in | 18 +++++++++++++ .../jupyter/kernels/xcpp23-omp/logo-32x32.png | Bin 0 -> 1520 bytes .../jupyter/kernels/xcpp23-omp/logo-64x64.png | Bin 0 -> 3113 bytes share/jupyter/kernels/xcpp23-omp/logo-svg.svg | 25 ++++++++++++++++++ 9 files changed, 89 insertions(+), 3 deletions(-) create mode 100644 share/jupyter/kernels/xcpp20-omp/kernel.json.in create mode 100644 share/jupyter/kernels/xcpp20-omp/logo-32x32.png create mode 100644 share/jupyter/kernels/xcpp20-omp/logo-64x64.png create mode 100644 share/jupyter/kernels/xcpp20-omp/logo-svg.svg create mode 100644 share/jupyter/kernels/xcpp23-omp/kernel.json.in create mode 100644 share/jupyter/kernels/xcpp23-omp/logo-32x32.png create mode 100644 share/jupyter/kernels/xcpp23-omp/logo-64x64.png create mode 100644 share/jupyter/kernels/xcpp23-omp/logo-svg.svg diff --git a/share/jupyter/kernels/xcpp17-omp/kernel.json.in b/share/jupyter/kernels/xcpp17-omp/kernel.json.in index f74379f1..6ffc8423 100644 --- a/share/jupyter/kernels/xcpp17-omp/kernel.json.in +++ b/share/jupyter/kernels/xcpp17-omp/kernel.json.in @@ -1,8 +1,8 @@ { - "display_name": "C++17 (xcpp+OpenMP)", + "display_name": "C++17 + OpenMP", "env": { "PATH":"@XEUS_CPP_PATH@", - "LD_LIBRARY_PATH":"@XEUS_CPP_LD_LIBRARY_PATH@" + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" }, "argv": [ "@XEUS_CPP_KERNELSPEC_PATH@xcpp", @@ -10,7 +10,7 @@ "{connection_file}", "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@", "-I", "@XEUS_CPP_INCLUDE_DIR@", - "-std=c++17"@XEUS_CPP_OMP@ + "-std=c++17","@XEUS_CPP_OMP@" ], "language": "cpp", "metadata": {"debugger": false diff --git a/share/jupyter/kernels/xcpp20-omp/kernel.json.in b/share/jupyter/kernels/xcpp20-omp/kernel.json.in new file mode 100644 index 00000000..f9546231 --- /dev/null +++ b/share/jupyter/kernels/xcpp20-omp/kernel.json.in @@ -0,0 +1,18 @@ +{ + "display_name": "C++20 + OpenMP", + "env": { + "PATH":"@XEUS_CPP_PATH@", + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" + }, + "argv": [ + "@XEUS_CPP_KERNELSPEC_PATH@xcpp", + "-f", + "{connection_file}", + "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@", + "-I", "@XEUS_CPP_INCLUDE_DIR@", + "-std=c++20","@XEUS_CPP_OMP@" + ], + "language": "cpp", + "metadata": {"debugger": false + } +} diff --git a/share/jupyter/kernels/xcpp20-omp/logo-32x32.png b/share/jupyter/kernels/xcpp20-omp/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..c09c458544bb83b9e3ff4d38f5758bda10ceebe8 GIT binary patch literal 1520 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 + + + + + + + + + + + + + + + + diff --git a/share/jupyter/kernels/xcpp23-omp/kernel.json.in b/share/jupyter/kernels/xcpp23-omp/kernel.json.in new file mode 100644 index 00000000..abcdf6cc --- /dev/null +++ b/share/jupyter/kernels/xcpp23-omp/kernel.json.in @@ -0,0 +1,18 @@ +{ + "display_name": "C++23 + OpenMP", + "env": { + "PATH":"@XEUS_CPP_PATH@", + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" + }, + "argv": [ + "@XEUS_CPP_KERNELSPEC_PATH@xcpp", + "-f", + "{connection_file}", + "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@", + "-I", "@XEUS_CPP_INCLUDE_DIR@", + "-std=c++23","@XEUS_CPP_OMP@" + ], + "language": "cpp", + "metadata": {"debugger": false + } +} diff --git a/share/jupyter/kernels/xcpp23-omp/logo-32x32.png b/share/jupyter/kernels/xcpp23-omp/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..c09c458544bb83b9e3ff4d38f5758bda10ceebe8 GIT binary patch literal 1520 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 + + + + + + + + + + + + + + + + From 9d4a18ca9949941caafcee88904acd490c68611b Mon Sep 17 00:00:00 2001 From: mcbarton <150042563+mcbarton@users.noreply.github.com> Date: Thu, 9 Oct 2025 09:47:20 +0100 Subject: [PATCH 2/7] Update cmake to configure added c++ + openmp kernels + add llvm-openmp to native conda environment --- CMakeLists.txt | 15 +++++++++++++++ environment-dev.yml | 1 + 2 files changed, 16 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 9e1648fd..1ab00cf1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -107,6 +107,13 @@ endif() find_package(argparse REQUIRED) find_package(pugixml REQUIRED) +find_package(OpenMP) + +# Used to configure OpenMP kernels such that Cpp::loadlibrary knows where OpenMP library is +if (NOT WIN32) + list(GET OpenMP_CXX_LIBRARIES 0 FirstOpenMPLibrary) + get_filename_component(OpenMPLibraryDir "${FirstOpenMPLibrary}" DIRECTORY) +endif() # Configuration # ============= @@ -127,6 +134,9 @@ function(configure_kernel kernel) set(XEUS_CPP_PATH "$ENV{PATH}") set(XEUS_CPP_LD_LIBRARY_PATH "$ENV{LD_LIBRARY_PATH}") set(XEUS_CPP_INCLUDE_DIR ${CMAKE_INSTALL_PREFIX}/include) + if(${kernel} MATCHES "omp/$") + set(XEUS_CPP_OMP "${OpenMP_CXX_FLAGS}") + endif() endif() if (WIN32) string(REPLACE "\\" "/" kernel "${kernel}") @@ -163,6 +173,11 @@ configure_kernel("/share/jupyter/kernels/xcpp23/") configure_kernel("/share/jupyter/kernels/xc11/") configure_kernel("/share/jupyter/kernels/xc17/") configure_kernel("/share/jupyter/kernels/xc23/") +if(NOT EMSCRIPTEN) + configure_kernel("/share/jupyter/kernels/xcpp17-omp/") + configure_kernel("/share/jupyter/kernels/xcpp20-omp/") + configure_kernel("/share/jupyter/kernels/xcpp23-omp/") +endif() # Source files # ============ diff --git a/environment-dev.yml b/environment-dev.yml index a6a7cf58..d56a37c5 100644 --- a/environment-dev.yml +++ b/environment-dev.yml @@ -14,6 +14,7 @@ dependencies: - CppInterOp - pugixml - cpp-argparse + - llvm-openmp # Test dependencies - pytest - jupyter_kernel_test<0.8 From baad01b8cb996c1aefb40bef900a365b47aca183 Mon Sep 17 00:00:00 2001 From: mcbarton <150042563+mcbarton@users.noreply.github.com> Date: Thu, 9 Oct 2025 09:48:58 +0100 Subject: [PATCH 3/7] Add example notebooks for c++ + openmp kernels --- notebooks/openmp-notebooks/hello_world.ipynb | 93 ++++++++ notebooks/openmp-notebooks/linked_list.ipynb | 234 +++++++++++++++++++ notebooks/openmp-notebooks/mandel.ipynb | 144 ++++++++++++ notebooks/openmp-notebooks/openmp-demo.ipynb | 231 ++++++++++++++++++ notebooks/openmp-notebooks/pi_integral.ipynb | 121 ++++++++++ 5 files changed, 823 insertions(+) create mode 100644 notebooks/openmp-notebooks/hello_world.ipynb create mode 100644 notebooks/openmp-notebooks/linked_list.ipynb create mode 100644 notebooks/openmp-notebooks/mandel.ipynb create mode 100644 notebooks/openmp-notebooks/openmp-demo.ipynb create mode 100644 notebooks/openmp-notebooks/pi_integral.ipynb diff --git a/notebooks/openmp-notebooks/hello_world.ipynb b/notebooks/openmp-notebooks/hello_world.ipynb new file mode 100644 index 00000000..3d23faef --- /dev/null +++ b/notebooks/openmp-notebooks/hello_world.ipynb @@ -0,0 +1,93 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "73cbab37-71dd-477d-981b-f2ec28c01bd6", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ef1cd58a-672c-4a6f-843a-6c88fc4911f3", + "metadata": {}, + "outputs": [], + "source": [ + "Cpp::LoadLibrary(\"libomp\");\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c2b754ad-9553-4a42-b990-f990a9a269ed", + "metadata": {}, + "outputs": [], + "source": [ + "int main() {\n", + " int max_threads = omp_get_max_threads();\n", + "\n", + " printf(\"max threads: %d\\n\", max_threads);\n", + " omp_set_num_threads(max_threads);\n", + "\n", + "#pragma omp parallel\n", + " {\n", + " int id = omp_get_thread_num();\n", + " printf(\"Hello World from thread = %d with %d threads\\n\", id, omp_get_num_threads());\n", + " }\n", + "\n", + " printf(\"all done, with hopefully %d threads\\n\", max_threads);\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a37a13d4-fc82-496e-8f42-9e718a8c2aa0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max threads: 8\n", + "Hello World from thread = 0 with 8 threads\n", + "Hello World from thread = 3 with 8 threads\n", + "Hello World from thread = 4 with 8 threads\n", + "Hello World from thread = 2 with 8 threads\n", + "Hello World from thread = 7 with 8 threads\n", + "Hello World from thread = 1 with 8 threads\n", + "Hello World from thread = 6 with 8 threads\n", + "Hello World from thread = 5 with 8 threads\n", + "all done, with hopefully 8 threads\n" + ] + } + ], + "source": [ + "main();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++17 (xcpp+OpenMP)", + "language": "cpp", + "name": "xcpp17-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "version": "17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/openmp-notebooks/linked_list.ipynb b/notebooks/openmp-notebooks/linked_list.ipynb new file mode 100644 index 00000000..607ceb18 --- /dev/null +++ b/notebooks/openmp-notebooks/linked_list.ipynb @@ -0,0 +1,234 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "156447d2-9279-45a0-890b-4e519d2c796b", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c96fdeb0-817d-48c0-af8e-20a52947d60b", + "metadata": {}, + "outputs": [], + "source": [ + "#ifndef N\n", + "#define N 5\n", + "#endif\n", + "#ifndef FS\n", + "#define FS 38\n", + "#endif" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8da842e1-db02-49e0-929d-4e67cbc08172", + "metadata": {}, + "outputs": [], + "source": [ + "Cpp::LoadLibrary(\"libomp\");" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "22f97c49-78d1-496e-ac7c-978aed95331a", + "metadata": {}, + "outputs": [], + "source": [ + "struct node {\n", + " int data;\n", + " int fibdata;\n", + " struct node *next;\n", + "};" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b16b1e8a-8831-4b8d-9d57-09deeaaa88ee", + "metadata": {}, + "outputs": [], + "source": [ + "struct node *init_list(struct node *p);\n", + "void processwork(struct node *p);\n", + "int fib(int n);" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0ef8af6c-1d6f-4c68-84bc-3dd1d8092b06", + "metadata": {}, + "outputs": [], + "source": [ + "int fib(int n) {\n", + " int x, y;\n", + " if (n < 2) {\n", + " return (n);\n", + " } else {\n", + " x = fib(n - 1);\n", + " y = fib(n - 2);\n", + " return (x + y);\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "1fa0307d-fdc9-4503-95cb-1c6448791354", + "metadata": {}, + "outputs": [], + "source": [ + "void processwork(struct node *p) {\n", + " int n, temp;\n", + " n = p->data;\n", + " temp = fib(n);\n", + "\n", + " p->fibdata = temp;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "03acb599-9329-49ff-8aff-c0902adb6c3c", + "metadata": {}, + "outputs": [], + "source": [ + "struct node *init_list(struct node *p) {\n", + " int i;\n", + " struct node *head = NULL;\n", + " struct node *temp = NULL;\n", + "\n", + " head = (struct node*) malloc(sizeof(struct node));\n", + " p = head;\n", + " p->data = FS;\n", + " p->fibdata = 0;\n", + " for (i = 0; i < N; i++) {\n", + " temp = (struct node*) malloc(sizeof(struct node));\n", + " p->next = temp;\n", + " p = temp;\n", + " p->data = FS + i + 1;\n", + " p->fibdata = i + 1;\n", + " }\n", + "\n", + " p->next = NULL;\n", + " return head;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "f2dfb41b-e55f-43c0-b7f6-546a1697acb1", + "metadata": {}, + "outputs": [], + "source": [ + "int main() {\n", + " double start, end;\n", + " struct node *p = NULL;\n", + " struct node *temp = NULL;\n", + " struct node *head = NULL;\n", + "\n", + " printf(\"Process linked list\\n\");\n", + " printf(\" Each linked list node will be processed by function 'processwork()'\\n\");\n", + " printf(\" Each ll node will compute %d fibonacci numbers beginning with %d\\n\", N, FS);\n", + "\n", + " omp_set_num_threads(omp_get_max_threads());\n", + "\n", + " p = init_list(p);\n", + " head = p;\n", + "\n", + " start = omp_get_wtime();\n", + "\n", + "#pragma omp parallel\n", + " {\n", + "#pragma omp master\n", + " printf(\"Threads: %d\\n\", omp_get_num_threads());\n", + "\n", + "#pragma omp single\n", + " {\n", + " p = head;\n", + " while (p) {\n", + "#pragma omp task firstprivate(p) // first private is required\n", + " {\n", + " processwork(p);\n", + " }\n", + " p = p->next;\n", + " }\n", + " }\n", + " }\n", + "\n", + " end = omp_get_wtime();\n", + " p = head;\n", + " while (p != NULL) {\n", + " printf(\"%d : %d\\n\", p->data, p->fibdata);\n", + " temp = p->next;\n", + " free(p);\n", + " p = temp;\n", + " }\n", + "\n", + " free(p);\n", + " printf(\"Compute Time: %f seconds\\n\", end - start);\n", + "\n", + " return 0;\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "353e5dfd-fcae-43e6-97e3-ec98070811a1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Process linked list\n", + " Each linked list node will be processed by function 'processwork()'\n", + " Each ll node will compute 5 fibonacci numbers beginning with 38\n", + "Threads: 8\n", + "38 : 39088169\n", + "39 : 63245986\n", + "40 : 102334155\n", + "41 : 165580141\n", + "42 : 267914296\n", + "43 : 433494437\n", + "Compute Time: 2.617225 seconds\n" + ] + } + ], + "source": [ + "main();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++17 (xcpp+OpenMP)", + "language": "cpp", + "name": "xcpp17-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "version": "17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/openmp-notebooks/mandel.ipynb b/notebooks/openmp-notebooks/mandel.ipynb new file mode 100644 index 00000000..2d5f8a33 --- /dev/null +++ b/notebooks/openmp-notebooks/mandel.ipynb @@ -0,0 +1,144 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5059dbdd-821d-498a-8716-eb0fcf8a8f5f", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include \n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4e037323-fbc6-43c8-a17f-6044997bf49b", + "metadata": {}, + "outputs": [], + "source": [ + "Cpp::LoadLibrary(\"libomp\");" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8b66f96a-14ef-4f23-8024-bcfc42b31e4e", + "metadata": {}, + "outputs": [], + "source": [ + "#define NPOINTS 1000\n", + "#define MAXITER 1000" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d89dd57c-fe19-4233-a33a-df9b24fae98a", + "metadata": {}, + "outputs": [], + "source": [ + "int numoutside = 0;" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5c35c479-2f79-46b7-bc66-24be6b1694e0", + "metadata": {}, + "outputs": [], + "source": [ + "void testpoint(double creal, double cimag) {\n", + " // iterate z=z*z+c, until |z| > 2 when point is known to be outside set\n", + " // If loop count reaches MAXITER, point is considered to be inside the set\n", + "\n", + " double zreal, zimag, temp;\n", + " int iter;\n", + " zreal = creal;\n", + " zimag = cimag;\n", + "\n", + " for (iter = 0; iter < MAXITER; iter++) {\n", + " temp = (zreal * zreal) - (zimag * zimag) + creal;\n", + " zimag = zreal * zimag * 2 + cimag;\n", + " zreal = temp;\n", + " if ((zreal * zreal + zimag * zimag) > 4.0) {\n", + " numoutside++;\n", + " break;\n", + " }\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ea116fef-7d05-4e29-97a1-55c85c7241d8", + "metadata": {}, + "outputs": [], + "source": [ + "int main() {\n", + " int i, j;\n", + " double area, error, eps = 1.0e-5;\n", + " double cimag, creal;\n", + " // Loop over grid of points in the complex plane which contains the Mandelbrot set,\n", + " // testing each point to see whether it is inside or outside the set.\n", + "\n", + "#pragma omp parallel for private(eps)\n", + " for (i = 0; i < NPOINTS; i++) {\n", + " for (j = 0; j < NPOINTS; j++) {\n", + " creal = -2.0 + 2.5 * (double) (i) / (double) (NPOINTS) + eps;\n", + " cimag = 1.125 * (double) (j) / (double) (NPOINTS) + eps;\n", + " testpoint(creal, cimag);\n", + " }\n", + " }\n", + "\n", + " // Calculate area of set and error estimate and output the results\n", + " area = 2.0 * 2.5 * 1.125 * (double) (NPOINTS * NPOINTS - numoutside) / (double) (NPOINTS * NPOINTS);\n", + " error = area / (double) NPOINTS;\n", + "\n", + " printf(\"Area of Mandlebrot set = %12.8f +/- %12.8f\\n\", area, error);\n", + " printf(\"Correct answer should be around 1.510659\\n\");\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "39cf129c-8106-4e67-a2f1-1a7fff17cd38", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Area of Mandlebrot set = 3.80247750 +/- 0.00380248\n", + "Correct answer should be around 1.510659\n" + ] + } + ], + "source": [ + "main();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++17 (xcpp+OpenMP)", + "language": "cpp", + "name": "xcpp17-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "version": "17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/openmp-notebooks/openmp-demo.ipynb b/notebooks/openmp-notebooks/openmp-demo.ipynb new file mode 100644 index 00000000..fbc24f6f --- /dev/null +++ b/notebooks/openmp-notebooks/openmp-demo.ipynb @@ -0,0 +1,231 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b0c15570-ee24-42ed-b61f-11a3fc858b2d", + "metadata": {}, + "outputs": [], + "source": [ + "#include \n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1b4dac8e-3ad2-46eb-b801-ba717e664b93", + "metadata": {}, + "outputs": [], + "source": [ + "Cpp::LoadLibrary(\"libomp\");" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5001e441-1fa5-4bdc-9fa5-2ca103ae484f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!\n" + ] + } + ], + "source": [ + "void example1() {\n", + " std::cout << \"Hello World!\" << std::endl;\n", + "}\n", + "example1();" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53fb7656-b72e-42bc-ade7-2ae2077142da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World!Hello World!\n", + "Hello World!Hello World!\n", + "Hello World!\n", + "\n", + "Hello World!\n", + "\n", + "Hello World!\n", + "Hello World!\n" + ] + } + ], + "source": [ + "void example2() {\n", + " #pragma omp parallel\n", + " {\n", + " std::cout << \"Hello World!\" << std::endl;\n", + " }\n", + "}\n", + "example2();" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "efcdfdb6-a60b-46af-8194-75ef9cc0e27f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World! (Hello World! (Hello World! (Hello World! (34)\n", + "Hello World! (7)\n", + "0)\n", + "2Hello World! (6))\n", + "\n", + ")\n", + "Hello World! (5)\n", + "Hello World! (1)\n" + ] + } + ], + "source": [ + "void example3() {\n", + " #pragma omp parallel\n", + " {\n", + " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + "}\n", + "example3();" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d86a9efa-ba28-4cb6-bbfc-abc00ee63506", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello World! (Hello World! (34))\n", + "Hello World! (0)\n", + "Hello World! (2)\n", + "Hello World! (Hello World! (1)\n", + "\n", + "7)Hello World! (\n", + "6)\n", + "Hello World! (5)\n", + "This is another message! (0)\n", + "Goodbye World! (0)\n", + "Goodbye World! (1)\n" + ] + } + ], + "source": [ + "void example4() {\n", + " #pragma omp parallel\n", + " {\n", + " std::cout << \"Hello World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + "\n", + " std::cout << \"This is another message! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + "\n", + " #pragma omp parallel num_threads(2)\n", + " {\n", + " std::cout << \"Goodbye World! (\" << omp_get_thread_num() << \")\" << std::endl;\n", + " }\n", + "}\n", + "example4();" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5557e01a-7c7d-4b54-8545-962ad11027df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initialize a[] time: 0.588681\n", + "Initialize b[] time: 0.513927\n", + "Add arrays time: 1.58928\n", + "Average result time: 0.637053\n", + "Average: 5e+08\n", + "Total time: 3.33191\n" + ] + } + ], + "source": [ + "void example5() {\n", + " double start_time = omp_get_wtime();\n", + " double start_loop;\n", + " \n", + " const int N = 1000000000;\n", + " int* a = new int[N];\n", + " int* b = new int[N];\n", + " \n", + " start_loop = omp_get_wtime();\n", + " #pragma omp parallel for\n", + " for (int i=0; i\n", + "#include \n", + "#include " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "93b89565-44fe-4729-980b-d4f897161b0b", + "metadata": {}, + "outputs": [], + "source": [ + "Cpp::LoadLibrary(\"libomp\");" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9078ac79-ca50-4fef-b785-37f35fec3cab", + "metadata": {}, + "outputs": [], + "source": [ + "static long num_steps = 100000000;\n", + "double step;" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f3c10995-6f29-4d71-9e61-1993ca9d1cc9", + "metadata": {}, + "outputs": [], + "source": [ + "int main() {\n", + " int i, j, num_threads_allocated;\n", + " double x, pi, sum = 0.0;\n", + " double start_time, run_time;\n", + "\n", + " step = 1.0 / (double)num_steps;\n", + " printf(\"Num threads available: %d\\n\", omp_get_max_threads());\n", + " for (i = 1; i <= 4; i++) {\n", + " sum = 0.0;\n", + " omp_set_num_threads(i);\n", + " start_time = omp_get_wtime();\n", + "#pragma omp parallel\n", + " {\n", + " num_threads_allocated = omp_get_num_threads();\n", + "#pragma omp single\n", + " printf(\"Num threads allocated for this run: %d\\n\", num_threads_allocated);\n", + "\n", + "#pragma omp for reduction(+ : sum)\n", + " for (j = 1; j <= num_steps; j++) {\n", + " x = (j - 0.5) * step;\n", + " sum = sum + 4.0 / (1.0 + x * x);\n", + " }\n", + " }\n", + "\n", + " pi = step * sum;\n", + " run_time = omp_get_wtime() - start_time;\n", + " printf(\"pi is %f in %f seconds using %d threads\\n\\n\", pi, run_time, num_threads_allocated);\n", + " }\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0f84442a-d947-4860-bd3c-aeeea963b419", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num threads available: 8\n", + "Num threads allocated for this run: 1\n", + "pi is 3.141593 in 0.179501 seconds using 1 threads\n", + "\n", + "Num threads allocated for this run: 2\n", + "pi is 3.141592 in 0.184605 seconds using 2 threads\n", + "\n", + "Num threads allocated for this run: 3\n", + "pi is 3.141593 in 0.097145 seconds using 3 threads\n", + "\n", + "Num threads allocated for this run: 4\n", + "pi is 3.141593 in 0.071473 seconds using 4 threads\n", + "\n" + ] + } + ], + "source": [ + "main();" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "C++17 (xcpp+OpenMP)", + "language": "cpp", + "name": "xcpp17-omp" + }, + "language_info": { + "codemirror_mode": "text/x-c++src", + "file_extension": ".cpp", + "mimetype": "text/x-c++src", + "name": "C++", + "version": "17" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a70d4a53306d0abc6934c88ff4577794d9f48af6 Mon Sep 17 00:00:00 2001 From: mcbarton <150042563+mcbarton@users.noreply.github.com> Date: Thu, 9 Oct 2025 11:49:09 +0100 Subject: [PATCH 4/7] Add c + openmp kernels --- share/jupyter/kernels/xc11-omp/kernel.json.in | 18 ++++++ share/jupyter/kernels/xc11-omp/logo-32x32.png | Bin 0 -> 1440 bytes share/jupyter/kernels/xc11-omp/logo-64x64.png | Bin 0 -> 2869 bytes share/jupyter/kernels/xc11-omp/logo-svg.svg | 59 ++++++++++++++++++ share/jupyter/kernels/xc17-omp/kernel.json.in | 18 ++++++ share/jupyter/kernels/xc17-omp/logo-32x32.png | Bin 0 -> 1440 bytes share/jupyter/kernels/xc17-omp/logo-64x64.png | Bin 0 -> 2869 bytes share/jupyter/kernels/xc17-omp/logo-svg.svg | 59 ++++++++++++++++++ share/jupyter/kernels/xc23-omp/kernel.json.in | 18 ++++++ share/jupyter/kernels/xc23-omp/logo-32x32.png | Bin 0 -> 1440 bytes share/jupyter/kernels/xc23-omp/logo-64x64.png | Bin 0 -> 2869 bytes share/jupyter/kernels/xc23-omp/logo-svg.svg | 59 ++++++++++++++++++ 12 files changed, 231 insertions(+) create mode 100644 share/jupyter/kernels/xc11-omp/kernel.json.in create mode 100644 share/jupyter/kernels/xc11-omp/logo-32x32.png create mode 100644 share/jupyter/kernels/xc11-omp/logo-64x64.png create mode 100644 share/jupyter/kernels/xc11-omp/logo-svg.svg create mode 100644 share/jupyter/kernels/xc17-omp/kernel.json.in create mode 100644 share/jupyter/kernels/xc17-omp/logo-32x32.png create mode 100644 share/jupyter/kernels/xc17-omp/logo-64x64.png create mode 100644 share/jupyter/kernels/xc17-omp/logo-svg.svg create mode 100644 share/jupyter/kernels/xc23-omp/kernel.json.in create mode 100644 share/jupyter/kernels/xc23-omp/logo-32x32.png create mode 100644 share/jupyter/kernels/xc23-omp/logo-64x64.png create mode 100644 share/jupyter/kernels/xc23-omp/logo-svg.svg diff --git a/share/jupyter/kernels/xc11-omp/kernel.json.in b/share/jupyter/kernels/xc11-omp/kernel.json.in new file mode 100644 index 00000000..fc5dbbbd --- /dev/null +++ b/share/jupyter/kernels/xc11-omp/kernel.json.in @@ -0,0 +1,18 @@ +{ + "display_name": "C11 + OpenMP", + "env": { + "PATH":"@XEUS_CPP_PATH@", + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" + }, + "argv": [ + "@XEUS_CPP_KERNELSPEC_PATH@xcpp", + "-f", + "{connection_file}", + "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@","-xc", + "-I", "@XEUS_CPP_INCLUDE_DIR@", + "-std=c11","@XEUS_CPP_OMP@" + ], + "language": "c", + "metadata": {"debugger": false + } +} diff --git a/share/jupyter/kernels/xc11-omp/logo-32x32.png b/share/jupyter/kernels/xc11-omp/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..18f36dffdc7fe0b1987a01636703bc7eb96913f0 GIT binary patch literal 1440 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 T3_h + + + + + + + + + + + + diff --git a/share/jupyter/kernels/xc17-omp/kernel.json.in b/share/jupyter/kernels/xc17-omp/kernel.json.in new file mode 100644 index 00000000..44676999 --- /dev/null +++ b/share/jupyter/kernels/xc17-omp/kernel.json.in @@ -0,0 +1,18 @@ +{ + "display_name": "C17 + OpenMP", + "env": { + "PATH":"@XEUS_CPP_PATH@", + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" + }, + "argv": [ + "@XEUS_CPP_KERNELSPEC_PATH@xcpp", + "-f", + "{connection_file}", + "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@","-xc", + "-I", "@XEUS_CPP_INCLUDE_DIR@", + "-std=c17","@XEUS_CPP_OMP@" + ], + "language": "c", + "metadata": {"debugger": false + } +} diff --git a/share/jupyter/kernels/xc17-omp/logo-32x32.png b/share/jupyter/kernels/xc17-omp/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..18f36dffdc7fe0b1987a01636703bc7eb96913f0 GIT binary patch literal 1440 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 T3_h + + + + + + + + + + + + diff --git a/share/jupyter/kernels/xc23-omp/kernel.json.in b/share/jupyter/kernels/xc23-omp/kernel.json.in new file mode 100644 index 00000000..9e7b0a7a --- /dev/null +++ b/share/jupyter/kernels/xc23-omp/kernel.json.in @@ -0,0 +1,18 @@ +{ + "display_name": "C23 + OpenMP", + "env": { + "PATH":"@XEUS_CPP_PATH@", + "LD_LIBRARY_PATH":"@OpenMPLibraryDir@" + }, + "argv": [ + "@XEUS_CPP_KERNELSPEC_PATH@xcpp", + "-f", + "{connection_file}", + "-resource-dir", "@XEUS_CPP_RESOURCE_DIR@","-xc", + "-I", "@XEUS_CPP_INCLUDE_DIR@", + "-std=c23","@XEUS_CPP_OMP@" + ], + "language": "c", + "metadata": {"debugger": false + } +} diff --git a/share/jupyter/kernels/xc23-omp/logo-32x32.png b/share/jupyter/kernels/xc23-omp/logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..18f36dffdc7fe0b1987a01636703bc7eb96913f0 GIT binary patch literal 1440 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 T3_h + + + + + + + + + + + + From 2545f10c2123c2cc7c21c84d1234eecc85bd02ee Mon Sep 17 00:00:00 2001 From: mcbarton <150042563+mcbarton@users.noreply.github.com> Date: Thu, 9 Oct 2025 11:56:55 +0100 Subject: [PATCH 5/7] Configure c + openmp kernels cmake --- CMakeLists.txt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1ab00cf1..40e10e26 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -177,6 +177,9 @@ if(NOT EMSCRIPTEN) configure_kernel("/share/jupyter/kernels/xcpp17-omp/") configure_kernel("/share/jupyter/kernels/xcpp20-omp/") configure_kernel("/share/jupyter/kernels/xcpp23-omp/") + configure_kernel("/share/jupyter/kernels/xc11-omp/") + configure_kernel("/share/jupyter/kernels/xc17-omp/") + configure_kernel("/share/jupyter/kernels/xc23-omp/") endif() # Source files From e3a948471ab4fb600dc24115d8db49c99b411cce Mon Sep 17 00:00:00 2001 From: mcbarton Date: Thu, 9 Oct 2025 13:01:28 +0100 Subject: [PATCH 6/7] Run existing tests for OpenMP kernels Add export LD_LIBRARY_PATH="$CONDA_PREFIX/lib/:$LD_LIBRARY_PATH" to ci --- test/test_xcpp_kernel.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_xcpp_kernel.py b/test/test_xcpp_kernel.py index 69a9e69e..4d1b839c 100644 --- a/test/test_xcpp_kernel.py +++ b/test/test_xcpp_kernel.py @@ -63,7 +63,7 @@ def test_continuation(self) -> None: self.assertEqual(str(reply["content"]["indent"]), "") self.assertEqual(reply["content"]["status"], "complete") -kernel_names = ['xcpp17', 'xcpp20', 'xcpp23'] +kernel_names = ['xcpp17', 'xcpp20', 'xcpp23','xcpp17-omp', 'xcpp20-omp', 'xcpp23-omp'] for name in kernel_names: class_name = f"XCppCompleteTests_{name}" From 47157b6a37989085b98bb9250850a927a754f11f Mon Sep 17 00:00:00 2001 From: mcbarton Date: Thu, 9 Oct 2025 12:51:39 +0100 Subject: [PATCH 7/7] Add Simple OpenMP kernel test --- test/test_xcpp_kernel.py | 55 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/test/test_xcpp_kernel.py b/test/test_xcpp_kernel.py index 4d1b839c..2c0e88f5 100644 --- a/test/test_xcpp_kernel.py +++ b/test/test_xcpp_kernel.py @@ -225,5 +225,60 @@ class BaseXCppTests2(jupyter_kernel_test.KernelTests): } ) +if platform.system() != 'Windows': + class BaseXCppOpenMPTests(jupyter_kernel_test.KernelTests): + __test__ = False + + # language_info.name in a kernel_info_reply should match this + language_name = 'C++' + + # OpenMP test that creates 2 threads, and gets them to output their thread + # number in descending order + code_omp=""" + #include + #include + #include + Cpp::LoadLibrary("libomp"); + """ + + code_omp_2=""" + int main() { + omp_set_num_threads(2); + #pragma omp parallel + { + if (omp_get_thread_num() == 1) { + printf("1"); + #pragma omp barrier + } + else if (omp_get_thread_num() == 0) { + #pragma omp barrier + printf("0"); + } + } + } + main(); + """ + + def test_xcpp_omp(self): + self.flush_channels() + reply, output_msgs = self.execute_helper(code=self.code_omp,timeout=20) + reply, output_msgs = self.execute_helper(code=self.code_omp_2,timeout=20) + self.assertEqual(output_msgs[0]['msg_type'], 'stream') + self.assertEqual(output_msgs[0]['content']['name'], 'stdout') + self.assertEqual(output_msgs[0]['content']['text'], '10') + + kernel_names = ['xcpp17-omp', 'xcpp20-omp', 'xcpp23-omp'] + + for name in kernel_names: + class_name = f"XCppOpenMPTests_{name}" + globals()[class_name] = type( + class_name, + (BaseXCppOpenMPTests,), + { + 'kernel_name': name, + '__test__': True + } + ) + if __name__ == '__main__': unittest.main()