scan_pattern_OpenMP.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"XBh9dtQm5FKE"},"source":["# Parallel Scan Pattern with OpenMP"]},{"cell_type":"markdown","metadata":{"id":"XBnvGyh85P_I"},"source":["- **Author:** *Mariusz Wiśniewski*"]},{"cell_type":"markdown","metadata":{},"source":["## Task\n","\n","- Implement a scan function that adds to each element of the input vector all the previous elements in the same vector.\n","- The implementation should use an *upsweep* + *downsweep* approach in order to efficiently compute the results in a parallel execution.\n","- Implement a second function for checking the correctness of the result if the original vector of size *n* contained, in order, all the values from *0* to *n-1*.\n","- After obtaining a working parallel implementation, evaluate the speedup offered by each parallel construct in your solution (tip: perform evaluation on a reasonably large vector)."]},{"cell_type":"code","execution_count":1,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":3410,"status":"ok","timestamp":1640574223192,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"-eMORuvI5ETC","outputId":"651cc393-913e-4f4c-8b2a-03676afb5e1e"},"outputs":[{"name":"stdout","output_type":"stream","text":["Reading package lists... Done\n","Building dependency tree       \n","Reading state information... Done\n","libomp-dev is already the newest version (5.0.1-1).\n","0 upgraded, 0 newly installed, 0 to remove and 37 not upgraded.\n"]}],"source":["!apt install libomp-dev\n","\n","!mkdir /home/OpenMP\n","!mkdir /home/OpenMP/build/\n","!mkdir /home/OpenMP/output"]},{"cell_type":"markdown","metadata":{"id":"NdBPflkkaoib"},"source":["## Serial scan\n","\n","*OpenMP* was used here only to get consistent time measurements using *omp_get_wtime()* across the whole notebook."]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":60,"status":"ok","timestamp":1640574223193,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"Ol7fKaI5an_e","outputId":"bef55540-bb54-4ed7-f0ac-52b4c07bbb8e"},"outputs":[{"name":"stdout","output_type":"stream","text":["Writing /home/OpenMP/serial_scan.c\n"]}],"source":["%%writefile /home/OpenMP/serial_scan.c\n","\n","#include <stdio.h>\n","#include <inttypes.h>\n","#include <stdbool.h>\n","#include <time.h>\n","\n","#include <omp.h>\n","\n","void scan(const uint64_t *in, uint64_t *out, const uint64_t size) {\n","    out[0] = in[0];\n","    for (uint64_t i = 1; i < size; i++) {\n","        out[i] = out[i - 1] + in[i];\n","        nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","    }\n","}\n","\n","bool check_result(const uint64_t *res, uint64_t size) {\n","    bool result = true;\n","\n","    for (uint64_t i = 0; i < size; i++) {\n","        if (res[i] != i * (i + 1) / 2) {\n","            result = false;\n","        }\n","        nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","    }\n","\n","    return result;\n","}\n","\n","int main(int argc, char *argv[]) {\n","    if (argc != 2) {\n","        printf(\"Expected 1 output but got %d\\n\", argc - 1);\n","        return 0;\n","    }\n","\n","    uint64_t vecSize = strtoumax(argv[1], NULL, 10);\n","    uint64_t initialVals[vecSize], finalVals[vecSize];\n","\n","    /* the input vector of size vecSize will contain all the integers\n","     * from 0 to vecSize - 1\n","     */\n","    for (uint64_t i = 0; i <= vecSize; i++) {\n","        initialVals[i] = i;\n","    }\n","\n","    double start = omp_get_wtime();\n","\n","    scan(initialVals, finalVals, vecSize);\n","    bool result = check_result(finalVals, vecSize);\n","\n","    double end = omp_get_wtime();\n","\n","    printf(\"The execution time is %fs.\\n\", end - start);\n","    printf(\"The result is %s.\\n\", result ? \"correct\" : \"incorrect\");\n","\n","    return 0;\n","}"]},{"cell_type":"markdown","metadata":{"id":"kYEywRpW50zr"},"source":["## Parallel scan"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":47,"status":"ok","timestamp":1640574223193,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"nrZo4UGx5g7H","outputId":"5fe0ec10-1d67-4f92-b842-337981422077"},"outputs":[{"name":"stdout","output_type":"stream","text":["Writing /home/OpenMP/scan.c\n"]}],"source":["%%writefile /home/OpenMP/scan.c\n","\n","#include <stdio.h>\n","#include <inttypes.h>\n","#include <stdbool.h>\n","#include <time.h>\n","\n","#include <omp.h>\n","\n","int scan(const uint64_t *in, uint64_t *out, uint64_t size) {\n","    int n_threads = 1;\n","\n","#if defined(PARALLEL1) || defined(PARALLEL)\n","    // initialize the output array with the elements from the input array\n","#pragma omp parallel default(none) shared(in, out, size, n_threads)\n","    {\n","        n_threads = omp_get_num_threads();\n","#pragma omp for schedule(guided)\n","#endif\n","        for (uint64_t i = 0; i < size; i++) {\n","            out[i] = in[i];\n","            nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","        }\n","#if defined(PARALLEL1) || defined(PARALLEL)\n","    }\n","#endif\n","\n","    // upsweep (compute reduction)\n","    for (uint64_t stride = 1; stride < size; stride <<= 1) {\n","#if defined(PARALLEL2) || defined(PARALLEL)\n","#pragma omp parallel default(none) shared(in, out, size, stride, n_threads)\n","        {\n","            n_threads = omp_get_num_threads();\n","#pragma omp for schedule(guided)\n","#endif\n","            for (uint64_t i = 0; i < size; i += 2 * stride) {\n","                out[2 * stride + i - 1] = out[2 * stride + i - 1] + out[stride + i - 1];\n","                nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","            }\n","#if defined(PARALLEL2) || defined(PARALLEL)      \n","        }\n","#endif\n","    }\n","\n","    // clear the last element\n","    uint64_t last = out[size - 1];\n","    out[size - 1] = 0;\n","\n","    // downsweep (compute intermediate values)\n","    for (uint64_t stride = size / 2; stride > 0; stride >>= 1) {\n","#if defined(PARALLEL3) || defined(PARALLEL)\n","#pragma omp parallel default(none) shared(in, out, size, stride, n_threads)\n","        {\n","            n_threads = omp_get_num_threads();\n","#pragma omp for schedule(guided)\n","#endif\n","            for (uint64_t i = 0; i < size; i += 2 * stride) {\n","                uint64_t temp = out[stride + i - 1];\n","                out[stride + i - 1] = out[2 * stride + i - 1];\n","                out[2 * stride + i - 1] = temp + out[2 * stride + i - 1];\n","                nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","            }\n","#if defined(PARALLEL3) || defined(PARALLEL)\n","        }\n","#endif\n","    }\n","\n","    // shift left for performing the inclusive scan and add the last element\n","    for (uint64_t i = 0; i < size - 1; i++) {\n","        out[i] = out[i + 1];\n","    }\n","    out[size - 1] = last;\n","\n","    return n_threads;\n","}\n","\n","bool check_result(const uint64_t *res, uint64_t size) {\n","    bool result = true;\n","\n","#if defined(PARALLEL4) || defined(PARALLEL)\n","#pragma omp parallel for schedule(guided) default(none) shared(res, size, result)\n","#endif\n","    for (uint64_t i = 0; i < size; i++) {\n","        if (res[i] != i * (i + 1ul) / 2ul) {\n","            result = false;\n","        }\n","        nanosleep(&(struct timespec) {.tv_sec=0, .tv_nsec=1}, NULL);\n","    }\n","\n","    return result;\n","}\n","\n","int main(int argc, char *argv[]) {\n","    if (argc != 2) {\n","        printf(\"Expected 1 output but got %d\\n\", argc - 1);\n","        return 0;\n","    }\n","\n","    uint64_t vecSize = strtoumax(argv[1], NULL, 10);\n","    uint64_t initialVals[vecSize], finalVals[vecSize];\n","\n","    /* the input vector of size vecSize will contain all the integers\n","     * from 0 to vecSize - 1\n","     */\n","    for (uint64_t i = 0; i <= vecSize; i++) {\n","        initialVals[i] = i;\n","    }\n","\n","    double start = omp_get_wtime();\n","\n","    int n_threads = scan(initialVals, finalVals, vecSize);\n","    bool result = check_result(finalVals, vecSize);\n","\n","    double end = omp_get_wtime();\n","\n","    printf(\"The number of threads is %d.\\n\", n_threads);\n","    printf(\"The execution time is %fs.\\n\", end - start);\n","    printf(\"The result is %s.\\n\", result ? \"correct\" : \"incorrect\");\n","\n","    return 0;\n","}"]},{"cell_type":"markdown","metadata":{"id":"L9kaHPNE55LK"},"source":["## Building code"]},{"cell_type":"code","execution_count":4,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":356,"status":"ok","timestamp":1640574223523,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"2M0KATHM56nM","outputId":"b12a901d-ebe0-443f-8cf3-d92576fcbde9"},"outputs":[{"name":"stdout","output_type":"stream","text":["/home/OpenMP\n"]}],"source":["%cd /home/OpenMP\n","!gcc -fopenmp serial_scan.c -o build/serial_scan -lm\n","!gcc -fopenmp scan.c -o build/scan_np -lm"]},{"cell_type":"code","execution_count":5,"metadata":{"executionInfo":{"elapsed":2020,"status":"ok","timestamp":1640574225540,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"Hq__oXOgBwhg"},"outputs":[],"source":["!gcc -fopenmp -DPARALLEL1 scan.c -o build/scan_p1 -lm\n","!gcc -fopenmp -DPARALLEL2 scan.c -o build/scan_p2 -lm\n","!gcc -fopenmp -DPARALLEL3 scan.c -o build/scan_p3 -lm\n","!gcc -fopenmp -DPARALLEL4 scan.c -o build/scan_p4 -lm\n","!gcc -fopenmp -DPARALLEL scan.c -o build/scan_fp"]},{"cell_type":"markdown","metadata":{"id":"dLS2lPnz6TWL"},"source":["## Running experiments"]},{"cell_type":"markdown","metadata":{"id":"HenFUzRTdg5a"},"source":["### Serial scan"]},{"cell_type":"code","execution_count":6,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":33142,"status":"ok","timestamp":1640574258679,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"Xo-D8vJgbH4S","outputId":"94e556c6-b3fc-4f70-f347-2041f18dc91b"},"outputs":[{"name":"stdout","output_type":"stream","text":["The execution time is 33.632808s.\n","The result is correct.\n"]}],"source":["!./build/serial_scan 262144 | tee /home/OpenMP/output/serial.log"]},{"cell_type":"markdown","metadata":{"id":"KExfuQolYrg4"},"source":["### No paralellization"]},{"cell_type":"code","execution_count":7,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":65204,"status":"ok","timestamp":1640574323869,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"iPOjEPSeChHa","outputId":"b98905f6-c410-4af8-c8ed-e48ae6ec0b53"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 1.\n","The execution time is 65.056693s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=1 ./build/scan_np 262144 | tee /home/OpenMP/output/np.log"]},{"cell_type":"markdown","metadata":{"id":"OGcFySMrYxSs"},"source":["### Output array initialization parallelization"]},{"cell_type":"code","execution_count":8,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":211485,"status":"ok","timestamp":1640574535343,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"wNm6G5NoCpAG","outputId":"85612181-d78b-4925-9c69-1d79b7c0452d"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 2.\n","The execution time is 57.782748s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 52.921742s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 50.609610s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 49.739254s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=2 ./build/scan_p1 262144 | tee /home/OpenMP/output/p1.log\n","!OMP_NUM_THREADS=4 ./build/scan_p1 262144 | tee -a /home/OpenMP/output/p1.log\n","!OMP_NUM_THREADS=8 ./build/scan_p1 262144 | tee -a /home/OpenMP/output/p1.log\n","!OMP_NUM_THREADS=16 ./build/scan_p1 262144 | tee -a /home/OpenMP/output/p1.log"]},{"cell_type":"markdown","metadata":{"id":"Ga74lB4mY4m-"},"source":["### Upsweep parallelization"]},{"cell_type":"code","execution_count":9,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":212050,"status":"ok","timestamp":1640574747379,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"xEM1jeVxCsBy","outputId":"79f46cdf-d74a-493e-e3e1-e0c7dc7e1656"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 2.\n","The execution time is 57.928061s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 53.201097s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 50.852335s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 49.777099s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=2 ./build/scan_p2 262144 | tee /home/OpenMP/output/p2.log\n","!OMP_NUM_THREADS=4 ./build/scan_p2 262144 | tee -a /home/OpenMP/output/p2.log\n","!OMP_NUM_THREADS=8 ./build/scan_p2 262144 | tee -a /home/OpenMP/output/p2.log\n","!OMP_NUM_THREADS=16 ./build/scan_p2 262144 | tee -a /home/OpenMP/output/p2.log"]},{"cell_type":"markdown","metadata":{"id":"53Cv0zT_Y8X0"},"source":["### Downsweep parallelization"]},{"cell_type":"code","execution_count":10,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":212566,"status":"ok","timestamp":1640574959931,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"5XBq5dkbCyYN","outputId":"ebc48200-91bd-4c7c-9acf-1ff53b9887f4"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 2.\n","The execution time is 57.826980s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 53.164321s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 50.932711s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 50.229992s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=2 ./build/scan_p3 262144 | tee /home/OpenMP/output/p3.log\n","!OMP_NUM_THREADS=4 ./build/scan_p3 262144 | tee -a /home/OpenMP/output/p3.log\n","!OMP_NUM_THREADS=8 ./build/scan_p3 262144 | tee -a /home/OpenMP/output/p3.log\n","!OMP_NUM_THREADS=16 ./build/scan_p3 262144 | tee -a /home/OpenMP/output/p3.log"]},{"cell_type":"markdown","metadata":{"id":"ow1hF9SFZA_d"},"source":["### Result verification parallelization\n","\n","The number of threads is set to 1 here because the function *check_results* does not set that variable."]},{"cell_type":"code","execution_count":11,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":212375,"status":"ok","timestamp":1640575172291,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"AaBUVSjICz_k","outputId":"0de9ea5c-8d93-4e9f-f40f-9fc4cb188f28"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 1.\n","The execution time is 58.219114s.\n","The result is correct.\n","The number of threads is 1.\n","The execution time is 52.891824s.\n","The result is correct.\n","The number of threads is 1.\n","The execution time is 51.155068s.\n","The result is correct.\n","The number of threads is 1.\n","The execution time is 49.833155s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=2 ./build/scan_p4 262144 | tee /home/OpenMP/output/p4.log\n","!OMP_NUM_THREADS=4 ./build/scan_p4 262144 | tee -a /home/OpenMP/output/p4.log\n","!OMP_NUM_THREADS=8 ./build/scan_p4 262144 | tee -a /home/OpenMP/output/p4.log\n","!OMP_NUM_THREADS=16 ./build/scan_p4 262144 | tee -a /home/OpenMP/output/p4.log"]},{"cell_type":"markdown","metadata":{"id":"gMfl8YDjZGKo"},"source":["### Full parallelization"]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":68982,"status":"ok","timestamp":1640575241253,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"-jLe-5ljC2uH","outputId":"16683240-0713-4686-f068-1c7834601928"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 2.\n","The execution time is 36.847159s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 17.316232s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 9.376328s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 5.081094s.\n","The result is correct.\n"]}],"source":["!OMP_NUM_THREADS=2 ./build/scan_fp 262144 | tee /home/OpenMP/output/fp.log\n","!OMP_NUM_THREADS=4 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp.log\n","!OMP_NUM_THREADS=8 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp.log\n","!OMP_NUM_THREADS=16 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp.log"]},{"cell_type":"markdown","metadata":{"id":"q436yE_Sd0mz"},"source":["### Visualizing results"]},{"cell_type":"code","execution_count":13,"metadata":{"cellView":"form","executionInfo":{"elapsed":17,"status":"ok","timestamp":1640575241254,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"9Qpx9pr5d5o2"},"outputs":[],"source":["#@title\n","import re\n","from itertools import repeat\n","\n","%matplotlib inline\n","import matplotlib.pyplot as plt\n","\n","plt.rcParams[\"figure.figsize\"] = (15, 40)\n","plt.style.use('seaborn-whitegrid')"]},{"cell_type":"code","execution_count":14,"metadata":{"cellView":"form","executionInfo":{"elapsed":16,"status":"ok","timestamp":1640575241254,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"NtCU_Oo9d-sf"},"outputs":[],"source":["#@title\n","OUTPUT_DIR = '/home/OpenMP/output'\n","PARALLELIZATION_BLOCKS = ['Output array initialization', 'Upsweep', 'Downsweep', 'Result verification']\n","\n","serial = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/serial.log')] for item in sublist]\n","np = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/np.log')] for item in sublist]\n","p1 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/p1.log')] for item in sublist]\n","p2 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/p2.log')] for item in sublist]\n","p3 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/p3.log')] for item in sublist]\n","p4 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/p4.log')] for item in sublist]\n","fp = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/fp.log')] for item in sublist]"]},{"cell_type":"code","execution_count":15,"metadata":{"cellView":"form","colab":{"base_uri":"https://localhost:8080/","height":1000},"executionInfo":{"elapsed":2132,"status":"ok","timestamp":1640575243371,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"8BZWSsVNeEVf","outputId":"64caa462-324f-44b6-b043-1017614beddf"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 1080x2880 with 7 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["#@title\n","N_THREADS = [2, 4, 8, 16]\n","\n","plt.suptitle('Parallelization experiments')\n","\n","plt.subplot(7, 1, 1)\n","plt.title('Serial scan')\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o')\n","\n","plt.subplot(7, 1, 2)\n","plt.title('No parallelization')\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.subplot(7, 1, 3)\n","plt.title(PARALLELIZATION_BLOCKS[0])\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, p1, linestyle='', marker='o', label='Parallelized')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.subplot(7, 1, 4)\n","plt.title(PARALLELIZATION_BLOCKS[1])\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, p2, linestyle='', marker='o', label='Parallelized')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.subplot(7, 1, 5)\n","plt.title(PARALLELIZATION_BLOCKS[2])\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, p3, linestyle='', marker='o', label='Parallelized')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.subplot(7, 1, 6)\n","plt.title(PARALLELIZATION_BLOCKS[3])\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, p4, linestyle='', marker='o', label='Parallelized')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.subplot(7, 1, 7)\n","plt.title('Full parallelization')\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, fp, linestyle='', marker='o', label='Parallelized')\n","plt.plot(N_THREADS, [x for item in np for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='No parallelization')\n","plt.plot(N_THREADS, [x for item in serial for x in repeat(item, len(N_THREADS))], \n","         linestyle='', marker='o', label='Serial scan')\n","plt.legend()\n","\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"G2_TIedt6rQM"},"source":["### Full parallelization experiments"]},{"cell_type":"code","execution_count":16,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":405,"status":"ok","timestamp":1640575243759,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"YDmsKZ546U7S","outputId":"ecb7aa22-00ef-4ed4-965c-8456bb08132b"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 1.\n","The execution time is 0.009757s.\n","The result is correct.\n","The number of threads is 2.\n","The execution time is 0.002984s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 0.002503s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 0.004231s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 0.002864s.\n","The result is correct.\n"]}],"source":["#@title\n","!OMP_NUM_THREADS=1 ./build/scan_fp 16 | tee /home/OpenMP/output/fp16_threads.log\n","!OMP_NUM_THREADS=2 ./build/scan_fp 16 | tee -a /home/OpenMP/output/fp16_threads.log\n","!OMP_NUM_THREADS=4 ./build/scan_fp 16 | tee -a /home/OpenMP/output/fp16_threads.log\n","!OMP_NUM_THREADS=8 ./build/scan_fp 16 | tee -a /home/OpenMP/output/fp16_threads.log\n","!OMP_NUM_THREADS=16 ./build/scan_fp 16 | tee -a /home/OpenMP/output/fp16_threads.log"]},{"cell_type":"code","execution_count":17,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":538,"status":"ok","timestamp":1640575244285,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"Je8aQZXJ6bn1","outputId":"41a3fea0-00a8-4ced-fa5d-fa9fcae43979"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 1.\n","The execution time is 0.263991s.\n","The result is correct.\n","The number of threads is 2.\n","The execution time is 0.147992s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 0.083043s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 0.043550s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 0.027584s.\n","The result is correct.\n"]}],"source":["#@title\n","!OMP_NUM_THREADS=1 ./build/scan_fp 1024 | tee /home/OpenMP/output/fp1024_threads.log\n","!OMP_NUM_THREADS=2 ./build/scan_fp 1024 | tee -a /home/OpenMP/output/fp1024_threads.log\n","!OMP_NUM_THREADS=4 ./build/scan_fp 1024 | tee -a /home/OpenMP/output/fp1024_threads.log\n","!OMP_NUM_THREADS=8 ./build/scan_fp 1024 | tee -a /home/OpenMP/output/fp1024_threads.log\n","!OMP_NUM_THREADS=16 ./build/scan_fp 1024 | tee -a /home/OpenMP/output/fp1024_threads.log"]},{"cell_type":"code","execution_count":18,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":133382,"status":"ok","timestamp":1640575377663,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"AE0_8R4o6egZ","outputId":"24ee91b4-96a6-4f9f-a708-0bf9be760900"},"outputs":[{"name":"stdout","output_type":"stream","text":["The number of threads is 1.\n","The execution time is 64.677387s.\n","The result is correct.\n","The number of threads is 2.\n","The execution time is 36.623543s.\n","The result is correct.\n","The number of threads is 4.\n","The execution time is 17.033845s.\n","The result is correct.\n","The number of threads is 8.\n","The execution time is 9.521113s.\n","The result is correct.\n","The number of threads is 16.\n","The execution time is 5.156563s.\n","The result is correct.\n"]}],"source":["#@title\n","!OMP_NUM_THREADS=1 ./build/scan_fp 262144 | tee /home/OpenMP/output/fp262144_threads.log\n","!OMP_NUM_THREADS=2 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp262144_threads.log\n","!OMP_NUM_THREADS=4 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp262144_threads.log\n","!OMP_NUM_THREADS=8 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp262144_threads.log\n","!OMP_NUM_THREADS=16 ./build/scan_fp 262144 | tee -a /home/OpenMP/output/fp262144_threads.log"]},{"cell_type":"markdown","metadata":{"id":"Rleg36OfeLBw"},"source":["### Visualizing results"]},{"cell_type":"code","execution_count":19,"metadata":{"cellView":"form","colab":{"base_uri":"https://localhost:8080/","height":454},"executionInfo":{"elapsed":472,"status":"ok","timestamp":1640575378127,"user":{"displayName":"Mariusz Wiśniewski","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gg_IeAJpVSaiMhAxm2r5KV5zNkZckImPPErDcA9=s64","userId":"16430494439187333102"},"user_tz":-60},"id":"2K3uvmiligYU","outputId":"46e74bf8-a455-4b67-9661-de6db47dbec6"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 720x504 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["#@title\n","fp16 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/fp16_threads.log')] for item in sublist]\n","fp1024 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/fp1024_threads.log')] for item in sublist]\n","fp262144 = [float(item) for sublist in [re.findall(r'(\\d+\\.\\d+)', line)\n","            for line in open(f'{OUTPUT_DIR}/fp262144_threads.log')] for item in sublist]\n","\n","N_THREADS = [1, 2, 4, 8, 16]\n","plt.rcParams[\"figure.figsize\"] = (10, 7)\n","\n","plt.title('Full Parallelization - comparison')\n","plt.xlabel('Number of threads')\n","plt.ylabel('Execution time[s]')\n","plt.plot(N_THREADS, fp16, linestyle='', marker='o', label='16 elements')\n","plt.plot(N_THREADS, fp1024, linestyle='', marker='o', label='1024 elements')\n","plt.plot(N_THREADS, fp262144, linestyle='', marker='o', label='262144 elements')\n","plt.legend()\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"MUnZRCKjeLbN"},"source":["## Comments\n","\n","The scan algorithm was parallelized in four places:\n","- output array initialization,\n","- upsweep,\n","- downsweep,\n","- result verification.\n","\n","Each parallelization increased algorithm's performance, which can be observed in the provided visualizations. Furthermore, fully parallelized algorithm using 16 threads executes on 262144 elements about 6.6 times faster than the serial approach. It can be also noticed that the greater the number of threads, the faster the execution time."]}],"metadata":{"colab":{"authorship_tag":"ABX9TyO2ZGayDhTnysuDUpeJVuRZ","collapsed_sections":[],"name":"OpenMP_Mariusz_Wiśniewski.ipynb","provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}