From 71224dc3cde445f2400e7d7e05c9d362086b85d9 Mon Sep 17 00:00:00 2001 From: "Bruno P. Kinoshita" Date: Tue, 22 Aug 2023 15:35:11 +0200 Subject: [PATCH] Add first performance test case created using the profiler --- .gitignore | 4 + .../profiler-tests/profiler-tests.ipynb | 510 ++++++++++++++++++ .../profiler-tests/requirements.txt | 3 + 3 files changed, 517 insertions(+) create mode 100644 test/performance/profiler-tests/profiler-tests.ipynb create mode 100644 test/performance/profiler-tests/requirements.txt diff --git a/.gitignore b/.gitignore index 40e7cb3ec..c74035e8d 100644 --- a/.gitignore +++ b/.gitignore @@ -23,3 +23,7 @@ test/coverage.xml dockerfiles/id_rsa* dockerfiles/authorized_keys + +# Jupyter +.ipynb_checkpoints/ +test/performance/profiler-tests/scenario* diff --git a/test/performance/profiler-tests/profiler-tests.ipynb b/test/performance/profiler-tests/profiler-tests.ipynb new file mode 100644 index 000000000..3be8dcb4a --- /dev/null +++ b/test/performance/profiler-tests/profiler-tests.ipynb @@ -0,0 +1,510 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "55294041-dd6e-4e20-bd2f-596d3d34ac93", + "metadata": {}, + "source": [ + "# Autosubmit profiler tests\n", + "\n", + "This notebook contains the first tests performed with the new Autosubmit profiler.\n", + "The test scenarios listed here are described in [this issue][issue].\n", + "\n", + "[issue]: https://earth.bsc.es/gitlab/es/autosubmit/-/issues/1120" + ] + }, + { + "cell_type": "markdown", + "id": "80ed8592-a8d9-4a69-995e-a5a79c08a8e7", + "metadata": {}, + "source": [ + "## 1. A workflow configuration similar to what Dani used to profile memory issues\n", + "\n", + "The configuration used by Daniel Beltran to profile memory issues in Autosubmit\n", + "configuration is based on this:\n", + "\n", + "```yaml\n", + "EXPERIMENT:\n", + " DATELIST: '20000101 20000102'\n", + " MEMBERS: 'fc0 fc1'\n", + " CHUNKSIZEUNIT: month\n", + " CHUNK: '4'\n", + " NUMCHUNKS: '400000' # 13000 max cap 1000000 jobs...\n", + " CHUNKINI: ''\n", + " CALENDAR: standard\n", + " RUN_ONLY_MEMBERS: ''\n", + "```\n", + "\n", + "Then we can change the amount of splits, or split and chunks, or just chunks.\n", + "Dani does that depending on which part he is trying to optimize." + ] + }, + { + "cell_type": "markdown", + "id": "4798a1e6-0553-4170-ab86-dba4c913bf14", + "metadata": {}, + "source": [ + "### Steps to reproduce it\n", + "\n", + "```bash\n", + "$ autosubmit expid -H local -d test -min\n", + "```\n", + "\n", + "Open `~/autosubmit//conf/minimal.yml`, set the project type to `LOCAL`,\n", + "and update the `LOCAL` project key accordingly:\n", + "\n", + "```yaml\n", + "CONFIG:\n", + " # Current version of Autosubmit.\n", + " AUTOSUBMIT_VERSION: \"4.0.87\"\n", + " # Total number of jobs in the workflow.\n", + " TOTALJOBS: 20\n", + " # Maximum number of jobs permitted in the waiting status.\n", + " MAXWAITINGJOBS: 20\n", + "DEFAULT:\n", + " # Job experiment ID.\n", + " EXPID: \"a003\"\n", + " # Default HPC platform name.\n", + " HPCARCH: \"local\"\n", + " #hint: use %PROJDIR% to point to the project folder (where the project is cloned)\n", + " # Custom configuration location.\n", + " CUSTOM_CONFIG: \"%PROJDIR%/\"\n", + "PROJECT:\n", + " # Type of the project.\n", + " PROJECT_TYPE: local\n", + " # Folder to hold the project sources.\n", + " PROJECT_DESTINATION: 'local_project'\n", + "PLATFORMS:\n", + " LOCAL:\n", + " TYPE: ps\n", + " HOST: localhost\n", + " PROJECT: \n", + " USER:\n", + " QUEUE: debug\n", + " SCRATCH_DIR: /tmp/\n", + " ADD_PROJECT_TO_HOST: false\n", + " MAX_WALLCLOCK: 48:00\n", + " TEMP_DIR: ''\n", + "EXPERIMENT:\n", + " DATELIST: '20000101 20000102'\n", + " MEMBERS: 'fc0 fc1'\n", + " CHUNKSIZEUNIT: month\n", + " CHUNKSIZE: '4'\n", + " NUMCHUNKS: '1' # 13000 max cap 1000000 jobs...\n", + " CHUNKINI: ''\n", + " CALENDAR: standard\n", + " RUN_ONLY_MEMBERS: ''\n", + "LOCAL:\n", + " PROJECT_PATH: '/tmp/project'\n", + "JOBS:\n", + " TEST:\n", + " FILE: TEMPLATE.sh\n", + " RUNNING: once\n", + "```\n", + "\n", + "Then run the profiler.\n", + "\n", + "```bash\n", + "$ autosubmit create --profile -np \n", + "```\n", + "\n", + "Then save the two files created in `~/autosubmit//tmp/profile/`\n", + "to `./scenario1/`.\n", + "\n", + "Now modify `EXPERIMENT.NUMCHUNKS` to `1000` and run the profiler again,\n", + "saving the new files to `./scenario1/` as well. Repeat it to `10000`,\n", + "`100000`, `1000000`, and `10000000`." + ] + }, + { + "cell_type": "markdown", + "id": "954b8a92-8818-4b46-8c26-39e101033767", + "metadata": {}, + "source": [ + "### Memory" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "608d0759-1286-4b9f-a04a-7700031fe5c2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Processing 6 test cases...\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "scenario_path = Path('./scenario1/')\n", + "result_files = sorted([result_file for result_file in scenario_path.iterdir() if result_file.is_file()])\n", + "\n", + "if len(result_files) % 2 != 0:\n", + " raise ValueError(f'Incorrect number of result files in {scenario_path}: {len(result_files)}')\n", + "\n", + "cases = [1, 1000, 10000, 100000, 1000000, 10000000]\n", + "pairs = [(prof, txt) for prof, txt in zip(result_files[0::2], result_files[1::2])]\n", + "pair_cases = [(case, *pair) for case, pair in zip(cases, pairs)]\n", + "\n", + "print(f'Processing {len(pair_cases)} test cases...')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8af096ae-4f62-43ad-9bb2-7f4c89541941", + "metadata": {}, + "outputs": [], + "source": [ + "# %matplotlib notebook\n", + "%matplotlib inline \n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "65df4b6d-7060-4a1b-a0c1-f98eee3fd635", + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "MEM_REGEX = re.compile(r'MEMORY CONSUMPTION: (.*)')\n", + "\n", + "def get_memory(txt):\n", + " # memory\n", + " with open(txt) as txt_file:\n", + " m = MEM_REGEX.search(txt_file.read())\n", + " # These are all in MiB.\n", + " memory = float(m.group(1).strip(' .').split(' ')[0])\n", + " return memory\n", + "\n", + "\n", + "memories = list(map(get_memory, [case[2] for case in pair_cases]))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "372f7ac2-67fa-4448-a621-49ac43568451", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 1000, 10000, 100000, 1000000, 10000000]\n", + "[2.015625, 2.08203125, 2.7890625, 9.71484375, 79.29296875, 774.8515625]\n" + ] + } + ], + "source": [ + "print(cases)\n", + "print(memories)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2fe175d1-09fa-4088-8bcd-940d6e0876e2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar(list(map(str, cases)), memories)\n", + "plt.title('Memory')\n", + "plt.ylabel('MiB')\n", + "plt.xlabel('NUMCHUNKS')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3e7b9ea2-b731-40b9-b59e-76d931c88b89", + "metadata": {}, + "source": [ + "### cProfile" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "06749131-bf6e-4e0a-b902-41edfd6e658b", + "metadata": {}, + "outputs": [], + "source": [ + "# There are 7 lines before the functions listing appears...\n", + "N=10\n", + "\n", + "import pstats\n", + "import io\n", + "from IPython.display import display, Markdown" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "99f6b137-3664-4aa6-9f2c-f2a6c616518f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=1\n", + "```bash\n", + "Tue Aug 22 13:34:57 2023 scenario1/a003_profile_20230822-133457.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.153 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 10 0.044 0.004 0.044 0.004 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.040 0.002 0.040 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.038 0.038 job_package_persistence.py:83(reset_table)\n", + " 2 0.000 0.000 0.029 0.015 job_list.py:178(generate)\n", + " 2 0.000 0.000 0.028 0.014 configcommon.py:1343(reload)\n", + " 2 0.000 0.000 0.028 0.014 job_list.py:2447(update_genealogy)\n", + " 1 0.000 0.000 0.026 0.026 db_structure.py:120(save_structure)\n", + " 4 0.000 0.000 0.024 0.006 constructor.py:116(get_single_data)\n", + " 2 0.000 0.000 0.023 0.011 configcommon.py:1391(load_last_run)\n", + " 1 0.000 0.000 0.022 0.022 experiment_history.py:191(process_status_changes)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=1000\n", + "```bash\n", + "Tue Aug 22 13:42:43 2023 scenario1/a003_profile_20230822-134243.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.150 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 10 0.044 0.004 0.044 0.004 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.041 0.002 0.041 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.038 0.038 job_package_persistence.py:83(reset_table)\n", + " 2 0.000 0.000 0.029 0.015 job_list.py:178(generate)\n", + " 2 0.000 0.000 0.028 0.014 job_list.py:2447(update_genealogy)\n", + " 1 0.000 0.000 0.027 0.027 db_structure.py:120(save_structure)\n", + " 2 0.000 0.000 0.026 0.013 configcommon.py:1343(reload)\n", + " 4 0.000 0.000 0.023 0.006 constructor.py:116(get_single_data)\n", + " 1 0.000 0.000 0.022 0.022 experiment_history.py:191(process_status_changes)\n", + " 2 0.000 0.000 0.021 0.011 configcommon.py:1391(load_last_run)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=10000\n", + "```bash\n", + "Tue Aug 22 13:43:11 2023 scenario1/a003_profile_20230822-134311.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.155 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 10 0.049 0.005 0.049 0.005 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.041 0.002 0.041 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.038 0.038 job_package_persistence.py:83(reset_table)\n", + " 2 0.000 0.000 0.029 0.015 job_list.py:178(generate)\n", + " 2 0.000 0.000 0.028 0.014 job_list.py:2447(update_genealogy)\n", + " 1 0.000 0.000 0.027 0.027 experiment_history.py:191(process_status_changes)\n", + " 1 0.000 0.000 0.026 0.026 db_structure.py:120(save_structure)\n", + " 2 0.000 0.000 0.026 0.013 configcommon.py:1343(reload)\n", + " 1 0.000 0.000 0.026 0.026 experiment_history.py:259(create_new_experiment_run)\n", + " 4 0.000 0.000 0.023 0.006 constructor.py:116(get_single_data)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=100000\n", + "```bash\n", + "Tue Aug 22 13:43:23 2023 scenario1/a003_profile_20230822-134323.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.149 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 10 0.043 0.004 0.043 0.004 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.036 0.002 0.036 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.035 0.035 job_package_persistence.py:83(reset_table)\n", + " 2 0.004 0.002 0.033 0.016 job_list.py:178(generate)\n", + " 2 0.000 0.000 0.030 0.015 configcommon.py:1343(reload)\n", + " 2 0.000 0.000 0.028 0.014 job_list.py:2447(update_genealogy)\n", + " 4 0.000 0.000 0.026 0.007 constructor.py:116(get_single_data)\n", + " 1 0.000 0.000 0.026 0.026 db_structure.py:120(save_structure)\n", + " 2 0.000 0.000 0.025 0.013 configcommon.py:1391(load_last_run)\n", + " 2 0.000 0.000 0.025 0.012 main.py:1059(load)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=1000000\n", + "```bash\n", + "Tue Aug 22 13:43:33 2023 scenario1/a003_profile_20230822-134333.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.177 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 2 0.035 0.018 0.065 0.032 job_list.py:178(generate)\n", + " 10 0.043 0.004 0.043 0.004 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.037 0.002 0.037 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.035 0.035 job_package_persistence.py:83(reset_table)\n", + " 2 0.000 0.000 0.028 0.014 job_list.py:2447(update_genealogy)\n", + " 2 0.000 0.000 0.027 0.013 configcommon.py:1343(reload)\n", + " 1 0.000 0.000 0.026 0.026 db_structure.py:120(save_structure)\n", + " 1 0.000 0.000 0.024 0.024 autosubmit.py:5833(load_job_list)\n", + " 4 0.000 0.000 0.023 0.006 constructor.py:116(get_single_data)\n", + " 2 0.000 0.000 0.022 0.011 configcommon.py:1391(load_last_run)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "## NUMCHUNKS=10000000\n", + "```bash\n", + "Tue Aug 22 13:44:03 2023 scenario1/a003_profile_20230822-134403.prof\n", + "\n", + " 107526 function calls (104387 primitive calls) in 0.545 seconds\n", + "\n", + " Ordered by: cumulative time\n", + "\n", + " ncalls tottime percall cumtime percall filename:lineno(function)\n", + " 2 0.366 0.183 0.397 0.198 job_list.py:178(generate)\n", + " 1 0.000 0.000 0.167 0.167 autosubmit.py:5833(load_job_list)\n", + " 10 0.050 0.005 0.050 0.005 {method 'commit' of 'sqlite3.Connection' objects}\n", + " 20 0.041 0.002 0.041 0.002 {method 'execute' of 'sqlite3.Cursor' objects}\n", + " 1 0.000 0.000 0.038 0.038 job_package_persistence.py:83(reset_table)\n", + " 2 0.000 0.000 0.037 0.019 subprocess.py:332(call)\n", + " 2 0.000 0.000 0.034 0.017 subprocess.py:732(__init__)\n", + " 1 0.000 0.000 0.034 0.034 autosubmit.py:4263(database_backup)\n", + " 2 0.000 0.000 0.034 0.017 subprocess.py:1550(_execute_child)\n", + " 2 0.000 0.000 0.029 0.014 job_list.py:2447(update_genealogy)\n", + "...\n", + "```" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sort_by = pstats.SortKey.CUMULATIVE\n", + "\n", + "def process_cumtime(prof):\n", + " stream = io.StringIO()\n", + " stats = pstats.Stats(str(prof), stream=stream)\n", + " stats.strip_dirs().sort_stats(sort_by).print_stats()\n", + "\n", + " output = stream.getvalue()\n", + " return '\\n'.join(output.split('\\n')[0:(N + 7)])\n", + "\n", + "for case in pair_cases:\n", + " header = f\"## NUMCHUNKS={str(case[0])}\"\n", + " cprofile_truncated = process_cumtime(case[1])\n", + " text = f\"{header}\\n```bash\\n{cprofile_truncated}\\n...\\n```\"\n", + " display(Markdown(text))" + ] + }, + { + "cell_type": "markdown", + "id": "98c03c99-261e-4b6b-9d42-75fcab9290b3", + "metadata": {}, + "source": [ + "### Notes\n", + "\n", + "WIP" + ] + } + ], + "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.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/test/performance/profiler-tests/requirements.txt b/test/performance/profiler-tests/requirements.txt new file mode 100644 index 000000000..94bfe2e6c --- /dev/null +++ b/test/performance/profiler-tests/requirements.txt @@ -0,0 +1,3 @@ +jupyterlab==4.0.* +pandas==2.0.* +pandoc==2.3.* -- GitLab