From 6150dd6e30cdc606920dd7b3442234e0fe8e3931 Mon Sep 17 00:00:00 2001 From: Yanli Date: Thu, 15 Jun 2023 13:12:53 -0500 Subject: [PATCH 01/11] add multi log scratchpad notebook --- .../examples/multi-log-scratchpad.ipynb | 818 ++++++++++++++++++ 1 file changed, 818 insertions(+) create mode 100644 darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb diff --git a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb new file mode 100644 index 000000000..1fa327f7f --- /dev/null +++ b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb @@ -0,0 +1,818 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "acc17ec9", + "metadata": {}, + "outputs": [], + "source": [ + "import darshan" + ] + }, + { + "cell_type": "markdown", + "id": "9dc378c3", + "metadata": {}, + "source": [ + "#### Open Darshan log file and read in data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0449a558", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['__add__',\n", + " '__class__',\n", + " '__deepcopy__',\n", + " '__del__',\n", + " '__delattr__',\n", + " '__dict__',\n", + " '__dir__',\n", + " '__doc__',\n", + " '__enter__',\n", + " '__eq__',\n", + " '__exit__',\n", + " '__format__',\n", + " '__ge__',\n", + " '__getattribute__',\n", + " '__gt__',\n", + " '__hash__',\n", + " '__init__',\n", + " '__init_subclass__',\n", + " '__le__',\n", + " '__lt__',\n", + " '__module__',\n", + " '__ne__',\n", + " '__new__',\n", + " '__reduce__',\n", + " '__reduce_ex__',\n", + " '__repr__',\n", + " '__setattr__',\n", + " '__sizeof__',\n", + " '__str__',\n", + " '__subclasshook__',\n", + " '__weakref__',\n", + " '_cleanup',\n", + " '_counters',\n", + " '_heatmaps',\n", + " '_metadata',\n", + " '_modules',\n", + " '_mounts',\n", + " 'automatic_summary',\n", + " 'converted_records',\n", + " 'counters',\n", + " 'data',\n", + " 'data_revision',\n", + " 'dtype',\n", + " 'end_time',\n", + " 'filename',\n", + " 'heatmaps',\n", + " 'info',\n", + " 'log',\n", + " 'lookup_name_records',\n", + " 'metadata',\n", + " 'mod_read_all_apmpi_records',\n", + " 'mod_read_all_apxc_records',\n", + " 'mod_read_all_dxt_records',\n", + " 'mod_read_all_lustre_records',\n", + " 'mod_read_all_records',\n", + " 'mod_records',\n", + " 'modules',\n", + " 'mounts',\n", + " 'name_records',\n", + " 'open',\n", + " 'provenance_enabled',\n", + " 'provenance_graph',\n", + " 'provenance_reports',\n", + " 'read_all',\n", + " 'read_all_dxt_records',\n", + " 'read_all_generic_records',\n", + " 'read_all_heatmap_records',\n", + " 'read_metadata',\n", + " 'rebase_timestamps',\n", + " 'records',\n", + " 'start_time',\n", + " 'summary',\n", + " 'summary_revision',\n", + " 'timebase',\n", + " 'to_dict',\n", + " 'to_json',\n", + " 'update_name_records']" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "logfile = \"example_logs/example.darshan\"\n", + "# obtain a report object containing all data for the input log\n", + "report = darshan.DarshanReport(logfile, read_all=True)\n", + "# for reference, print all attributes associated with the report object\n", + "dir(report)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c46d71a3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Filename: example_logs/example.darshan\n", + "Executable: /global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32\n", + "Times: 2017-03-20 04:07:47 to 2017-03-20 04:09:43\n", + "Run time: 117.0000 (s)\n", + "Processes: 2048\n", + "JobID: 4478544\n", + "UID: 69615\n", + "Modules in Log: ['POSIX', 'MPI-IO', 'LUSTRE', 'STDIO']\n", + "Loaded Records: {'POSIX': 1, 'MPI-IO': 1, 'STDIO': 129, 'LUSTRE': 1}\n", + "Name Records: 4\n", + "Darshan/Hints: {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}\n", + "DarshanReport: id(140222677424160) (tmp)\n" + ] + } + ], + "source": [ + "# quickly display some info about the log data\n", + "report.info()" + ] + }, + { + "cell_type": "markdown", + "id": "c1fb1e2d", + "metadata": {}, + "source": [ + "#### Convert some record data to a DataFrame" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1e1059de", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'POSIX': {'len': 186,\n", + " 'ver': 3,\n", + " 'idx': 1,\n", + " 'partial_flag': False,\n", + " 'num_records': 1},\n", + " 'MPI-IO': {'len': 154,\n", + " 'ver': 2,\n", + " 'idx': 2,\n", + " 'partial_flag': False,\n", + " 'num_records': 1},\n", + " 'LUSTRE': {'len': 87,\n", + " 'ver': 1,\n", + " 'idx': 8,\n", + " 'partial_flag': False,\n", + " 'num_records': 1},\n", + " 'STDIO': {'len': 3234,\n", + " 'ver': 1,\n", + " 'idx': 9,\n", + " 'partial_flag': False,\n", + " 'num_records': 129}}" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# the log may contain data from multiple modules\n", + "report.modules" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "27d88766", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'counters': rank id POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", + "0 -1 6301063301082038805 2049 -1 -1 \n", + "\n", + " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", + "0 0 16402 16404 0 0 ... \n", + "\n", + " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", + "0 544 328 16384 \n", + "\n", + " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", + "0 8 2 2 \n", + "\n", + " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", + "0 597 1073741824 1312 \n", + "\n", + " POSIX_SLOWEST_RANK_BYTES \n", + "0 1073741824 \n", + "\n", + "[1 rows x 71 columns], 'fcounters': rank id POSIX_F_OPEN_START_TIMESTAMP \\\n", + "0 -1 6301063301082038805 3.919141 \n", + "\n", + " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", + "0 0.0 3.940064 \n", + "\n", + " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", + "0 3.927094 3.93658 \n", + "\n", + " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", + "0 0.0 115.078166 \n", + "\n", + " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", + "0 115.770358 0.0 100397.600422 \n", + "\n", + " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", + "0 11.300842 0.0 17.940946 \n", + "\n", + " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", + "0 20.4361 85.47495 \n", + "\n", + " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", + "0 0.0 0.0 }\n" + ] + } + ], + "source": [ + "# we can extract data for a specific module (e.g., POSIX)\n", + "# in DataFrame format using the 'records' attribute and\n", + "# the 'to_df()' method\n", + "# NOTE: the returned type here is actually a dictionary, with\n", + "# 2 separate DataFrames: 'counters' (for integer record data)\n", + "# and 'fcounters' (for floating point record data)\n", + "posix_recs = report.records['POSIX'].to_df()\n", + "print(posix_recs)" + ] + }, + { + "cell_type": "markdown", + "id": "90b2c2fe", + "metadata": {}, + "source": [ + "#### Reproduce a job summary \"operation counts\" figure" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5484b720", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'DarshanReport' object is not subscriptable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'POSIX'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: 'DarshanReport' object is not subscriptable" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# import routine for plotting op counts and enable experimental mode\n", + "from darshan.experimental.plots import plot_opcounts\n", + "darshan.enable_experimental()\n", + "\n", + "# this plotting routine expects some input about what data to plot\n", + "# (in this case, a report object and a module name)\n", + "plot_opcounts(report, \"POSIX\")" + ] + }, + { + "cell_type": "markdown", + "id": "42f600fd", + "metadata": {}, + "source": [ + " As you can see above from the `plot_opcounts()` signature, it takes a single report object as input. Internally, this plotting routine has logic to combine all of the records in the report object to plot total number of operations across all file records.\n", + " \n", + " Since a report object corresponds to a single Darshan log, we can't use this function to plot\n", + " data from multiple Darshan logs." + ] + }, + { + "cell_type": "markdown", + "id": "7e9b0b38", + "metadata": {}, + "source": [ + "#### Darshan accumulator API" + ] + }, + { + "cell_type": "markdown", + "id": "035551f0", + "metadata": {}, + "source": [ + "PyDarshan includes an \"accumulator\" API, which allows multiple records (perhaps coming from different log files) to be aggregated into a single \"summary\" record." + ] + }, + { + "cell_type": "markdown", + "id": "12f2adfd", + "metadata": {}, + "source": [ + "To resolve the plotting issue mentioned above, one option would be to update the plotting routine to take a single record as input (rather than a report object). We can ultimately use the \"summary\" record generated by the accumulator interface above as input to handle the use case where we want to plot data from multiple log files." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "28515908", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", + "0 6301063301082038805 -1 2049 -1 -1 \n", + "\n", + " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", + "0 0 16402 16404 0 0 ... \n", + "\n", + " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", + "0 544 328 16384 \n", + "\n", + " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", + "0 8 2 2 \n", + "\n", + " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", + "0 597 1073741824 1312 \n", + "\n", + " POSIX_SLOWEST_RANK_BYTES \n", + "0 1073741824 \n", + "\n", + "[1 rows x 71 columns]\n", + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "from darshan.backend.cffi_backend import accumulate_records\n", + "\n", + "# accumulate all records in posix_recs, and then print out the \"summary\" record\n", + "acc = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", + "# print(type(acc))\n", + "# print(type(acc.summary_record))\n", + "# print(acc.summary_record, end='\\n\\n\\n\\n')\n", + "print(acc.summary_record['counters'], end='\\n\\n\\n\\n')\n", + "# print(acc.summary_record['counters'][\"POSIX_OPENS\"], end='\\n\\n\\n\\n')\n", + "# printint(dir(acc.summary_record))\n", + "# print(acc.summary_record.summary)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "fd3c32dd", + "metadata": {}, + "source": [ + "### First Step\n", + "\n", + "Our first step is to modify the plotting code `plot_opcounts()` (in file darshan/experimental/plots/plot_opcounts.py) to take a single record as input rather than a report object. Ultimately, we should be able to pass in the summary record from above and get an identical plot to the one generated previously in this notebook (i.e., based on the old code)." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9c28b46b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '_asdict', '_field_defaults', '_fields', '_make', '_replace', 'count', 'derived_metrics', 'index', 'summary_record']\n" + ] + } + ], + "source": [ + "print(dir(acc))" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "341c1545", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "acc: AccumulatedRecords(derived_metrics=, summary_record={'id': 6301063301082038805, 'rank': -1, 'counters': id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", + "0 6301063301082038805 -1 2049 -1 -1 \n", + "\n", + " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", + "0 0 16402 16404 0 0 ... \n", + "\n", + " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", + "0 544 328 16384 \n", + "\n", + " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", + "0 8 2 2 \n", + "\n", + " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", + "0 597 1073741824 1312 \n", + "\n", + " POSIX_SLOWEST_RANK_BYTES \n", + "0 1073741824 \n", + "\n", + "[1 rows x 71 columns], 'fcounters': id rank POSIX_F_OPEN_START_TIMESTAMP \\\n", + "0 6301063301082038805 -1.0 3.919141 \n", + "\n", + " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", + "0 0.0 3.940064 \n", + "\n", + " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", + "0 3.927094 3.93658 \n", + "\n", + " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", + "0 0.0 115.078166 \n", + "\n", + " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", + "0 115.770358 0.0 100397.600422 \n", + "\n", + " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", + "0 11.300842 0.0 17.940946 \n", + "\n", + " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", + "0 20.4361 85.47495 \n", + "\n", + " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", + "0 0.0 0.0 })\n", + "\n", + "\n", + "\n", + "acc.summary_record: {'id': 6301063301082038805, 'rank': -1, 'counters': id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", + "0 6301063301082038805 -1 2049 -1 -1 \n", + "\n", + " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", + "0 0 16402 16404 0 0 ... \n", + "\n", + " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", + "0 544 328 16384 \n", + "\n", + " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", + "0 8 2 2 \n", + "\n", + " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", + "0 597 1073741824 1312 \n", + "\n", + " POSIX_SLOWEST_RANK_BYTES \n", + "0 1073741824 \n", + "\n", + "[1 rows x 71 columns], 'fcounters': id rank POSIX_F_OPEN_START_TIMESTAMP \\\n", + "0 6301063301082038805 -1.0 3.919141 \n", + "\n", + " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", + "0 0.0 3.940064 \n", + "\n", + " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", + "0 3.927094 3.93658 \n", + "\n", + " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", + "0 0.0 115.078166 \n", + "\n", + " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", + "0 115.770358 0.0 100397.600422 \n", + "\n", + " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", + "0 11.300842 0.0 17.940946 \n", + "\n", + " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", + "0 20.4361 85.47495 \n", + "\n", + " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", + "0 0.0 0.0 }\n", + "\n", + "\n", + "\n", + "acc.count: \n", + "\n", + "\n", + "\n", + "acc.derived_metrics: \n", + "\n", + "\n", + "\n", + "acc.index: \n", + "\n", + "\n", + "\n", + "acc.summary_record['counters']: id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", + "0 6301063301082038805 -1 2049 -1 -1 \n", + "\n", + " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", + "0 0 16402 16404 0 0 ... \n", + "\n", + " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", + "0 544 328 16384 \n", + "\n", + " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", + "0 8 2 2 \n", + "\n", + " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", + "0 597 1073741824 1312 \n", + "\n", + " POSIX_SLOWEST_RANK_BYTES \n", + "0 1073741824 \n", + "\n", + "[1 rows x 71 columns]\n", + "\n", + "\n", + "\n", + "acc.summary_record['counters']['POSIX_OPENS']: 0 2049\n", + "Name: POSIX_OPENS, dtype: int64\n", + "\n", + "acc.summary_record['counters']['POSIX_OPENS'][0]: 2049\n" + ] + } + ], + "source": [ + "print(\"acc: \", acc, end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.summary_record: \", acc.summary_record, end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.count: \", acc.count, end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.derived_metrics: \", acc.derived_metrics, end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.index: \", acc.index, end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.summary_record['counters']: \", acc.summary_record['counters'], end=\"\\n\\n\\n\\n\")\n", + "print(\"acc.summary_record['counters']['POSIX_OPENS']: \", acc.summary_record['counters'][\"POSIX_OPENS\"], end=\"\\n\\n\")\n", + "print(\"acc.summary_record['counters']['POSIX_OPENS'][0]: \", acc.summary_record['counters'][\"POSIX_OPENS\"][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3ac2ed27", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEZCAYAAADCJLEQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmXElEQVR4nO3dfZxVZbn/8c83kCcN5GFUBAxU4ghoR0VF+/2sNBOzwjxaYz6Q+Tqkh59lmh2wY55O4cMvy1LTI6mBysE4pokPkIZleUQQHxGUJDEZQSFFIgwEvM4f6x7dDMOwB2b2Wnv4vl+vee21r7XWnmvrZl+z7vte962IwMzMrGg+kHcCZmZmjXGBMjOzQnKBMjOzQnKBMjOzQnKBMjOzQnKBMjOzQnKBMjOzQnKBMjOzQnKBshYlqVOD58orF6s+kvr6M2P1XKCsxUj6FPDfkn4q6esA4alKrEyS9gMWA7WSuuSdj+XPBcpahKQRwI+BycB9wPGSPplrUlZtNgArgFrgs5I655yP5ax93glY9ZPUDfg0cEFETJfUHjgSqMk3M6smEfGipJ8BdcAY4E1JrwNvRMSr+WZnefAVlG23iFgF3Aw8JUkRsQFYCnwi38ysWijTCegHzCUrUD8AZgN75Zmb5cdXULbNJB0EfIjsC+WFiFgrqR2wEVgJ7JyOqwU2RMQduSVrhZM+P/2Ap8mukv4m6X5gD+CPwG7AQqCHpE4RsTa3ZC0Xch+2bQtJnwOuJPtyeRtYDVwaEcvS/uHAp4A5wPeB0yLihXyytaLZwudnPNAXmALsBJwJBHAB2ednVS7JWm5coGybSLoemBERd6e/hE8ABgFfj4jXJB0O/A/ZF9DpETE/t2StcBr5/Hwe2BsYTVaQ5kXEXenYD0bE6vyytby4D8qaTdIHgHbAfgAR8STwM+AF4MI0RHgNWXH6oouTldrC52cC2RDz7wA/iIi7JLVL90T9LbdkLVcuUFa2dBNlt4h4F7iO7H6Vk9PuOmA6sDuwc0Q8C3wqIl7MKV0rmDI+P/cCfYBuABGxMZJ8Mra8uUBZWVIzzBPAVyTtERFPA98FzpT0hfQ98hjZl8vB6bQ38snWiqaZn5/9c0zVCsSj+KxcS4CXgR7AFyT9V2qG2Qh8T9Igso7ufYH54FkkbBPN+fx4MI0BvoKyMqQ+gw3Aa8DfgYHAcZIOAeYBpwC7kI3Aqo2IJXnlasXjz49tK4/isy1KTTGvlTw/H/gVsCtZZ/ZwsuG/v8klQSs0f35se/kKyhol6Tjgakn7lIQ7A4eR3YB7KPA4sLekXjmkaAXmz4+1BPdB2WYkHQbcAHw5Iv5Usut+4CLgIOCrwDtk0xm9W/EkrbD8+bGW4gJljRkI3BoRD0naEzgQ+CDwS7J7Ur4REfcASJoVEX/NL1UrIH9+rEW4QFlj6oDDJfUD7gYeAEYAH4uIMwEktY+IDf5ysUb482Mtwn1QBoCkD5c8XUk2iecZwG0RMTYi/hE4UNJ5AGnGcjPAnx9rHS5QhqTPAE9LmgIQEc+Q9RecBQxI6z0B3Al4wk7bhD8/1lo8zHwHJ2lnsr6BO4EjgA4R8aW075+Bk8imMOoOfAH4vGclt3r+/Fhr2uEK1IgRI2LGjBl5p1EoS5cupWvXrqxdu5azzz6bnXbaiSlTpgDwyCOPsHLlSmbPns3pp5/OoEGDcs7WisafH2sBajS4oxWoYcOGxdy5c/NOo7DeeOMNRo8eTYcOHZgyZQrPPvssPXv2pE+fPnmnZlXAnx/bRo0WKPdB2SZ69uzJDTfcQKdOnRg0aBAnnngiO9ofMbbt/PmxluQCZZvp1asXBxxwAKtWreKuu+6ib9++eadkVcSfH2spLlC2mZUrV3L//ffzwAMPsP/+XvnAmsefH2sp7oOyRq1du5ZOnTrlnYZVKX9+rJncB2Xl85eLbQ9/fqwluECZmVkhuUCZmVkhebJYMytb/7H35Z1Co16+/Pi8U7BW4AK1g/EXjJlVi1Zr4pN0s6Tlkp5rED9X0kJJ8yX9/5L4OEmL0r5jS+IHS5qX9l0tSSneUdIvUny2pP6t9V7MzKzyWrMPaiLZGjDvkfQJYCRwQEQMAa5M8cFALTAknXOdpHbptOuB0WSLoA0sec2zgJURsS9wFXBFK74XMzOrsFYrUBHxe+DNBuFzgMsjYl06ZnmKjwRuj4h1EbEYWAQcKqk30DUiZkV2w9YtwAkl50xK23cAR9dfXZmZWfWr9Ci+DwP/NzXJPSzpkBTvAywpOa4uxfqk7YbxTc5Ji5+tAno29ksljZY0V9LcFStWtNibMTOz1lPpAtWebF2Y4cCFwNR01dPYlU80EWcr+zYNRkyIiGERMaympqb5WZuZWcVVukDVAXdGZg7wLtArxfuVHNcXWJrifRuJU3qOpPZANzZvUjQzsypV6QL1K+AoAEkfBjoAfwGmAbVpZN4AssEQcyJiGbBa0vB0pXUGcHd6rWnAqLR9EvBQ7GgTC5qZtWGtdh+UpCnAx4FekuqAS4CbgZvT0PN3gFGpqMyXNBVYAGwAxkTExvRS55CNCOxMtnT09BS/CbhV0iKyK6fa1novZmZWea1WoCLilC3sOm0Lx48HxjcSnwsMbSS+Fjh5e3I0M7Pi8lx8ZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSC5QZmZWSK1WoCTdLGl5Wpyw4b5vSgpJvUpi4yQtkrRQ0rEl8YMlzUv7rk4r65JW3/1Fis+W1L+13ouZmVVea15BTQRGNAxK6gccA7xSEhtMtiLukHTOdZLapd3XA6PJloEfWPKaZwErI2Jf4CrgilZ5F2ZmlotWK1AR8Xuypdgbugr4FhAlsZHA7RGxLiIWA4uAQyX1BrpGxKy0NPwtwAkl50xK23cAR9dfXZmZWfWraB+UpM8Br0bEMw129QGWlDyvS7E+abthfJNzImIDsArouYXfO1rSXElzV6xYsd3vw8zMWl/FCpSkLsC3ge80truRWDQRb+qczYMREyJiWEQMq6mpKSddMzPLWSWvoPYBBgDPSHoZ6As8KWkPsiujfiXH9gWWpnjfRuKUniOpPdCNxpsUzcysClWsQEXEvIjYLSL6R0R/sgJzUES8BkwDatPIvAFkgyHmRMQyYLWk4al/6Qzg7vSS04BRafsk4KHUT2VmZm1Aaw4znwLMAgZJqpN01paOjYj5wFRgATADGBMRG9Puc4AbyQZO/AmYnuI3AT0lLQLOB8a2yhsxM7NctG+tF46IU7ayv3+D5+OB8Y0cNxcY2kh8LXDy9mVpZmZF5ZkkzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFygzMyskFpzwcKbJS2X9FxJ7AeSXpD0rKS7JO1asm+cpEWSFko6tiR+sKR5ad/VaWVd0uq7v0jx2ZL6t9Z7MTOzymvNK6iJwIgGsQeBoRFxAPBHYByApMFALTAknXOdpHbpnOuB0WTLwA8sec2zgJURsS9wFXBFq70TMzOruFYrUBHxe+DNBrEHImJDevoY0DdtjwRuj4h1EbGYbHn3QyX1BrpGxKyICOAW4ISScyal7TuAo+uvrszMrPrl2Qf1FWB62u4DLCnZV5difdJ2w/gm56Sitwro2dgvkjRa0lxJc1esWNFib8DMzFpPLgVK0reBDcDk+lAjh0UT8abO2TwYMSEihkXEsJqamuama2ZmOah4gZI0CvgMcGpqtoPsyqhfyWF9gaUp3reR+CbnSGoPdKNBk6KZmVWvihYoSSOAfwU+FxFvl+yaBtSmkXkDyAZDzImIZcBqScNT/9IZwN0l54xK2ycBD5UUPDMzq3LtW+uFJU0BPg70klQHXEI2aq8j8GAaz/BYRJwdEfMlTQUWkDX9jYmIjemlziEbEdiZrM+qvt/qJuBWSYvIrpxqW+u9mJlZ5bVagYqIUxoJ39TE8eOB8Y3E5wJDG4mvBU7enhzNzKy4PJOEmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVkguUmZkVUqsVKEk3S1ou6bmSWA9JD0p6MT12L9k3TtIiSQslHVsSP1jSvLTv6rSyLmn13V+k+GxJ/VvrvZiZWeW15hXURGBEg9hYYGZEDARmpudIGky2Iu6QdM51ktqlc64HRpMtAz+w5DXPAlZGxL7AVcAVrfZOzMys4lqtQEXE78mWYi81EpiUticBJ5TEb4+IdRGxGFgEHCqpN9A1ImZFRAC3NDin/rXuAI6uv7oyM7PqV+k+qN0jYhlAetwtxfsAS0qOq0uxPmm7YXyTcyJiA7AK6NnYL5U0WtJcSXNXrFjRQm/FzMxaU1EGSTR25RNNxJs6Z/NgxISIGBYRw2pqarYxRTMzq6RKF6jXU7Md6XF5itcB/UqO6wssTfG+jcQ3OUdSe6AbmzcpmplZlap0gZoGjErbo4C7S+K1aWTeALLBEHNSM+BqScNT/9IZDc6pf62TgIdSP5WZmbUBZRUoSR8tJ9Zg/xRgFjBIUp2ks4DLgWMkvQgck54TEfOBqcACYAYwJiI2ppc6B7iRbODEn4DpKX4T0FPSIuB80ohAMzNrG9qXedw1wEFlxN4TEadsYdfRWzh+PDC+kfhcYGgj8bXAyVv6/WZmVt2aLFCSDgeOAGoknV+yqyvQrvGzzMzMtt/WrqA6ALuk4z5YEv8rWb+PmZlZq2iyQEXEw8DDkiZGxJ8rlJOZmVnZfVAdJU0A+peeExFHtUZSZmZm5Rao/wb+k2w03catHGtmZrbdyi1QGyLi+lbNxMzMrES5N+reI+lfJPVOS2b0kNSjVTMzM7MdWrlXUPUzNlxYEgtg75ZNx8zMLFNWgYqIAa2diJmZWamyCpSkMxqLR8QtLZuOmZlZptwmvkNKtjuRTVf0JNkCgmZmZi2u3Ca+c0ufS+oG3NoqGZmZmbHty228TbYkhpmZWasotw/qHt5frbYdsB/Z8hhmZmatotw+qCtLtjcAf46IulbIx8zMDCiziS9NGvsC2Yzm3YF3tueXSvqGpPmSnpM0RVKndPPvg5JeTI/dS44fJ2mRpIWSji2JHyxpXtp3dVp118zM2oByV9T9AjCHbIHALwCzJW3TchuS+gBfA4ZFxFCyJsNashVxZ0bEQGBmeo6kwWn/EGAEcJ2k+rWorgdGk/WHDUz7zcysDSh3kMS3gUMiYlREnAEcCly8Hb+3PdBZUnugC7AUGAlMSvsnASek7ZHA7RGxLiIWky39fqik3kDXiJgVEUE25P0EzMysTSi3QH0gIpaXPH+jGeduIiJeJevTegVYBqyKiAeA3SNiWTpmGbBbOqUPsKTkJepSrE/abhjfjKTRkuZKmrtixYptSdvMzCqs3CIzQ9KvJX1Z0peB+4D7t+UXpr6lkcAAYE9gZ0mnNXVKI7FoIr55MGJCRAyLiGE1NTXNTdnMzHLQ5Cg+SfuSXdlcKOlE4P+QFYZZwORt/J2fBBZHxIr0O+4EjgBel9Q7Ipal5rv6K7Y6oF/J+X3JmgTr0nbDuJmZtQFbu4L6MbAaICLujIjzI+IbZFdPP97G3/kKMFxSlzTq7mjgeWAa78+aPgq4O21PA2oldZQ0gGwwxJzUDLha0vD0OmeUnGNmZlVua/dB9Y+IZxsGI2KupP7b8gsjYrakO8jm8tsAPAVMAHYBpko6i6yInZyOny9pKrAgHT8mIupX9T0HmAh0BqanHzMzawO2VqA6NbGv87b+0oi4BLikQXgd2dVUY8ePB8Y3Ep8LDN3WPMzMrLi21sT3uKR/bhhMVzlPtE5KZmZmW7+COg+4S9KpvF+QhgEdgM+3Yl5mZraDa7JARcTrwBGSPsH7TWn3RcRDrZ6ZmZnt0MpdD+q3wG9bORczM7P3bOt6UGZmZq3KBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzAoplwIlaVdJd0h6QdLzkg6X1EPSg5JeTI/dS44fJ2mRpIWSji2JHyxpXtp3dVpZ18zM2oC8rqB+AsyIiH8APkK25PtYYGZEDARmpudIGgzUAkOAEcB1ktql17keGE22DPzAtN/MzNqAihcoSV2BI4GbACLinYh4CxgJTEqHTQJOSNsjgdsjYl1ELAYWAYdK6g10jYhZERHALSXnmJlZlcvjCmpvYAXwc0lPSbpR0s7A7hGxDCA97paO7wMsKTm/LsX6pO2G8c1IGi1prqS5K1asaNl3Y2ZmrSKPAtUeOAi4PiIOBNaQmvO2oLF+pWgivnkwYkJEDIuIYTU1Nc3N18zMcpBHgaoD6iJidnp+B1nBej0125Eel5cc36/k/L7A0hTv20jczMzagIoXqIh4DVgiaVAKHQ0sAKYBo1JsFHB32p4G1ErqKGkA2WCIOakZcLWk4Wn03hkl55iZWZUra8n3VnAuMFlSB+Al4EyyYjlV0lnAK8DJABExX9JUsiK2ARgTERvT65wDTAQ6A9PTj5mZtQG5FKiIeBoY1siuo7dw/HhgfCPxucDQFk3OzMwKwTNJmJlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIblAmZlZIeVWoCS1k/SUpHvT8x6SHpT0YnrsXnLsOEmLJC2UdGxJ/GBJ89K+q9PKumbbLCLyTsHMkjyvoL4OPF/yfCwwMyIGAjPTcyQNBmqBIcAI4DpJ7dI51wOjyZaBH5j2mzVbXV0dq1atYuPGjVs/2MwqIpcCJakvcDxwY0l4JDApbU8CTiiJ3x4R6yJiMbAIOFRSb6BrRMyK7M/eW0rOMSvbtGnTOP300znnnHO48sormTFjRt4pmRk5LfkO/Bj4FvDBktjuEbEMICKWSdotxfsAj5UcV5di69N2w/hmJI0mu9Jir732aoH0ra145ZVXuPjii5k8eTI77bQT999/P5dddhnr1q1j5MiReadntkOr+BWUpM8AyyPiiXJPaSQWTcQ3D0ZMiIhhETGspqamzF9rO4LVq1fTq1cvhg4dyqBBgzj88MPp3r07kyZN4uGHH847PbMdWh5NfB8FPifpZeB24ChJtwGvp2Y70uPydHwd0K/k/L7A0hTv20jcbKvWrFkDwJAhQ+jWrRtf/epXWbNmDffccw/77rsvRx55JC+//HK+SZrt4CpeoCJiXET0jYj+ZIMfHoqI04BpwKh02Cjg7rQ9DaiV1FHSALLBEHNSc+BqScPT6L0zSs4x26Lp06dz9tlnM2vWLAB++MMfsnz5cs4880wWLlzIlVdeydChQ7nvvvs8aMIsR3n1QTXmcmCqpLOAV4CTASJivqSpwAJgAzAmIuq/Nc4BJgKdgenpx6xJCxcuZMGCBfzmN78hIjjiiCO46667WLNmDR07dgSyUX0777yzh52b5SjXAhURvwN+l7bfAI7ewnHjgfGNxOcCQ1svQ2uL9tprL3r16kVEMG3aNLp160a/fv3o3Lkz7du3Z8KECfz0pz/l1ltvpX37Iv0NZ7Zj8UwStsOovxo65phj+NjHPkZtbS277ror3//+9zn55JN58803AejYsSNTp07lgAMOyDNdsx2eC5S1eUuWLOGdd97h7bffBmDdunXMmDGDvffemw996ENMnz6dXXbZhddffx2AUaNGMWjQoDxTNjNcoKyNu++++zjuuOM499xzOfPMM3n++efp1asXX/rSl7jiiiu4+OKLGT9+PPvvvz+/+tWv3itiZpY/N7BbmxQR1NXVMXbsWK699lr2228/brvtNo466igefvhh9tlnHy6//HKuueYaPvvZz7Jw4UK6d+9Oly5d8k7dzBIXKGuTJLHnnnty+OGHM3DgQHbbbTcuuOAC2rVrxzHHHMOcOXNYsGABXbp0ISLcpGdWQG7iszZn0aJFPP7447z11lusWrWKyZMnUz/R/XnnncfZZ5/N2LFjAXj33XfzTNXMmuArKGtT7r33Xi666CK6d+/O/vvvz6mnnsrXvvY1Nm7cyLhx4wA45ZRTuOyyy9ycZ1ZwLlDWZjz66KN885vfZMqUKRx44IGMHj2aOXPm8OijjzJ8+HA2btxIbW0tjzzyCE888QQrV66ke/fuW39hM8uFm/isTRk7diwHHnggAOPHj+epp55izz335He/+x0vvfQSP/rRj7j22mv5+c9/7uJkVnC+grI247DDDmPo0GxikY0bN7Ju3TqWLl3KsmXL2Hvvvbnkkkvo06cPa9asoVu3bjlna2Zb4ysoazPatWtH165dgWyY+a677kqPHj3o3bs3t912G5deeinr1693cTKrEr6Csjapffv27LLLLvTr149x48bxwAMPMHHiRDp37px3amZWJhcoa5MigvXr1/OHP/yB9evXM3PmTAYOHJh3WmbWDC5Q1iZJokOHDlx88cUccsghLk5mVcgFytq0UaNGvXeTrplVl4oPkpDUT9JvJT0vab6kr6d4D0kPSnoxPXYvOWecpEWSFko6tiR+sKR5ad/V8jeRNeCPhFn1ymMU3wbggojYDxgOjJE0GBgLzIyIgcDM9Jy0rxYYAowArpPULr3W9cBosmXgB6b9ZmbWBlS8QEXEsoh4Mm2vBp4H+gAjgUnpsEnACWl7JHB7RKyLiMXAIuBQSb2BrhExK7KV6G4pOcfMzKpcrn1QkvoDBwKzgd0jYhlkRUzSbumwPsBjJafVpdj6tN0w3tjvGU12pcVee+3Vgu/AKq3/2PvyTqFRL19+fN4pmLU5ud2oK2kX4JfAeRHx16YObSQWTcQ3D0ZMiIhhETGspqam+cmamVnF5VKgJO1EVpwmR8SdKfx6arYjPS5P8TqgX8npfYGlKd63kbiZmbUBeYziE3AT8HxE/Khk1zRgVNoeBdxdEq+V1FHSALLBEHNSc+BqScPTa55Rco6ZmVW5PPqgPgqcDsyT9HSKXQRcDkyVdBbwCnAyQETMlzQVWEA2AnBMRGxM550DTAQ6A9PTj5mZtQEVL1AR8QiN9x8BHL2Fc8YD4xuJzwWGtlx2ZmZWFJ7N3MzMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCqnqC5SkEZIWSlokaWze+ZiZWcuo6gIlqR3wU+A4YDBwiqTB+WZlZmYtoaoLFHAosCgiXoqId4DbgZE552RmZi2g2gtUH2BJyfO6FDMzsypX8SXfW1hjS8fHZgdJo4HR6enfJC1s1azK1wv4S95JbIcWy19XtMSrNJvzz1c1//f3f/uWNSMiRjQMVnuBqgP6lTzvCyxteFBETAAmVCqpckmaGxHD8s5jWzn/fDn//FRz7lA9+Vd7E9/jwEBJAyR1AGqBaTnnZGZmLaCqr6AiYoOk/wf8GmgH3BwR83NOy8zMWkBVFyiAiLgfuD/vPLZR4Zodm8n558v556eac4cqyV8Rm40pMDMzy12190GZmVkb5QJlZmaF5AJlZmaFVPWDJKqFpB5N7Y+INyuVi1lRSOoYEevyzqM5JHUFIiJW551Lc0jaGfh7RLybnn8A6BQRb+eb2Zb5CqpyngDmpscVwB+BF9P2Eznm1SySdpd0k6Tp6flgSWflnVe5JNVIukjSBEk31//knVc5JM0sJ1ZUDf87S9qFKhqBK2mYpHnAs8Bzkp6RdHDeeTXDTKBLyfMuwG9yyqUsLlAVEhEDImJvsnu2PhsRvSKiJ/AZ4M58s2uWiWTvYc/0/I/AeXklsw3uBrqR/cO8r+SnsCR1SlfgvSR1l9Qj/fTn/f8P1eBVSdcDSOoOPADclm9KzXIz8C8R0T8iPgSMAX6ec07N0Ski/lb/JG13aeL43LmJr/IOiYiz659ExHRJ38szoWbqFRFTJY2D926W3ph3Us3QJSL+Ne8kmumrZH8E7El2tV0/B+VfyZabqQoRcbGkKyT9J3AwcHlE/DLvvJphdUT8of5JRDwiqZqa+dZIOigingRIV39/zzmnJrlAVd5fJP0b2V+OAZwGvJFvSs2yRlJP0qS8koYDq/JNqVnulfTpdIN3VYiInwA/kXRuRFyTdz7NJenEkqdzgIvTY0g6MSKqpQVhjqQbgClkn/8vAr+TdBBA/Rd/gZ0H/Lek+vlKe5O9h8LyjboVlppqLgGOTKHfA9+tlkES6R/jNcBQ4DmgBjg5Ip7JNbEypb94dwbeST8i6/DummtiZZI0lGxxzk71sYi4Jb+Mtk5SU81gERFfqVgy20HSb5vYHRFxVMWS2UaSdgIGkX3uX4iI9Tmn1CQXKGsWSR2Bjbz/IV8IfKDaRmJVI0mXAB8nK1D3k60k/UhEnJRnXlY9JB0B9Kek9azIf+C4QFWYpBrgW8AQNv0ruPB/fQFIejIiDtparKgkCTgVGBAR35PUD+gdEXNyTm2r0giyjwBPRcRHJO0O3BgRn805tbJI+jBwPbB7RAyVdADwuYj4fs6plU3S8Wz+b/c/8suofJJuBfYBnib7IxOyK7+v5ZbUVrgPqvImA78gG713NjCKbKh5oUnag2y14s6SDuT9jvquFHwkUAPXAe8CRwHfA/5GNtDgkDyTKtPfI+JdSRvSvTjLgb3zTqoZfgZcCNwAEBHPSvovoCoKVBrc0QX4BHAjcBJZX1q1GAYMjiq6KnGBqryeEXGTpK9HxMPAw5IezjupMhwLfJlsUcgflcRXAxflkdA2OiwiDpL0FEBErExriVWDuZJ2Jfuif4KsuFbTF2SXiJiTXcS+Z0NeyWyDIyLiAEnPRsR3Jf2Q6rpF5DlgD2BZ3omUywWq8uo7JZel5oKlZF/6hRYRk4BJkv6pyoYGN7ReUjveH4VYQ3ZFVXgR8S9p8z8lzQC6RsSzeebUTH+RtA/v/7c/iSr6suT9IdlvS9qTbPTtgBzzaa5ewAJJc4D3+owj4nP5pdQ0F6jK+76kbsAFZKPhugLfyDelrZN0WkTcBvSXdH7D/RHxo0ZOK6KrgbuA3SWNJ2um+bd8UyqPpJkRcTRARLzcMFYFxpCtQ/QPkl4FFpPdZlEt7k1XsD8AniQrtDfmmlHz/HveCTSXC1SFRcS9aXMVWVt2tdg5Pe6SaxbbKSImS3oCqP9SPyEins8zp62R1Ims76NXmoGhtP+vamaSiIiXgE+mOeE+UG1z2UVE/Q31v5R0L9nMDNV0D+D+wOSIWJl3IuVygaqwah3JFBE3pKaxv0bEVXnns526APXNfJ1zzqUcDWeSqLeaKppJIo06vBTYMyKOkzQYODwibso5tbKkz//xlAzTllRNrQd7AI9LepJs2qZfF33AhOfiq7yfAeNIfVGpD6E214zKFBEbgcK2V5dD0neASUAPsjb5n6eZPYrsUeAI4JtpPsfvknV4Pwz8V56JNdNEqnsex3vIBgr1BD5Y8lMVIuLfgIHATWTv40VJl6Z+wULyFVTlVftIpkclXUs2VH5NfbAKpnmpdwpwYESsBZB0OVl/QpGvYG8APhkR10g6ErgMOBf4R7I+nWq5Ubfa53HsGxEH5J3E9oiIkPQa8BrZ90534A5JD0bEt/LNbnMuUJVXlSOZJJ0H/A/wMbIpgr5bv4vsvVTFjcbAy2Q3Wa5NzzsCf8otm/K0K5kK64vAhDSS8peSns4vrWar9nkcp0v6VEQ8kHci20LS18juu/wL2eCOCyNivbJ1oV4km0CgUFygKq+xkUyn5ptSWfoCPwH2I1sP51HgEWBWtcwjmKwD5kt6MD3/JPCIpKsBCnpXfTtJ7SNiA9ngjtEl+6rp3/D5wDRgH0n/QzaPY7Vc/QE8BtyVvtDXU2XzOJI1aZ8YEX8uDaabvz+TU05N8lRHOakfyUR2b8UXI2JyzimVJd3UOoysT+Tw9PNWRAzONbEySTqH7Ev9XbLpXjZZbiDd71Uokr4NfJrsL9+9gINSU82+wKSI+GiuCW6FpEOAJRHxmqT2ZIM+/glYAHynWv7AkfQScAIwr+iDCxqTWm7qImKdpI8DBwC3RMRbeebVFBeoCklT04whmy7obrIF88YA3wSeiYiROaZXtnQP1+HAR9PjrmT/YM/MM6+tSV+MlwJfAf5M9sdBP7IF5y4q/KzOWXNYb+CBiFiTYh8Gdil6/18aNfbJiHgz9aHdzvt9aPtVy2S3kn4NHBdpyfRqk5qDh5GNQvw12dXsoIj4dI5pNckFqkIk3Q2sBGaRNdN0BzoAX4+Ip3NMrSySJpBNkrkamE3W3PFYtdxTIekqshFX36i//yb90XAl8HZEnJdjem2apGci4iNp+6fAioj49/T86Yj4xxzTK5ukiWRzH05n05kYqmKYef2kzpIuBNamQTdPRcSBeee2JdXUfl3t9o6I/QEk3UhqrqmimxX3IhtQ8CLwKlAHvJVnQs30GeDDpU0zEfHX1OT3AtU13LnatJU+tMXpp0P6qTbrJZ1CNlCifgb8nXLMZ6uq6cNR7d5rQoqIjZIWV1FxIiJGpKUqhpD1P10ADJX0JtlAiUtyTXDrorF+g/T/ws0IrWsK2aTIfyHr8/sDQOpDq5pRfBHx3a0fVWhnkq2gMD4iFksaQLayd2G5ia9C0v0e9fcNiWwGg7epvpFASOpL1gd1BNmVSc+I2DXXpLZC0q+AO6PB4mySTgO+UOQJM9uCKu9Dm9bU/qJ/diTtFRGv5J3HtnCBsrKkeyiOICtM68nuiZqVHucVveNYUh+ypRH+TjZdUJCtAdUZ+HxEvJpjelZgklYAS8iuBGfz/lyIAKRlcwpLJQuKSvplRPxT3jmVy018Vq7+wB1kgwwKf2NxQ6kAHSbpKLJmSgHTI2JmvplZFdgDOIZsFpIvAfcBUyJifq5Zla+0oFbTApe+gjIzK5ekjmSF6gfAf0TENTmntFUNrqDe264GLlBmZluRCtPxZMWpP9k9RDdXQ9NwSf93ad83VEH/twuUmVkTJE0ChpLd/3R7RDyXc0o7DBcoM7MmSHqX90fgln5hFv4KpNq5QJmZWSF5wUIzMyskFygzMyskFygzMyskFygzMyskFygzMyuk/wU5lzc1vUhRZAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Test for plot_opcounts POSIX\n", + "from darshan.experimental.plots import plot_opcounts\n", + "darshan.enable_experimental()\n", + "plot_opcounts(acc.summary_record, \"POSIX\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "64d4ae6d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Test for plot_opcounts MPI-IO\n", + "from darshan.experimental.plots import plot_opcounts\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "print(acc_MPIIO.summary_record['counters'][\"MPIIO_INDEP_READS\"][0])\n", + "darshan.enable_experimental()\n", + "plot_opcounts(acc_MPIIO.summary_record, \"MPI-IO\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "0d57a7da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-1\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Test for plot_opcounts STDIO\n", + "from darshan.experimental.plots import plot_opcounts\n", + "acc_STDIO = accumulate_records(posix_recs, \"STDIO\", report.metadata['job']['nprocs'])\n", + "print(acc_STDIO.summary_record['counters'][\"STDIO_READS\"][0])\n", + "darshan.enable_experimental()\n", + "plot_opcounts(acc_STDIO.summary_record, \"STDIO\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6881d549", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Error: plot_opcounts not supported for module H5F", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/138928280.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdarshan\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menable_experimental\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module H5F" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Test for plot_opcounts H5F\n", + "from darshan.experimental.plots import plot_opcounts\n", + "# acc_H5F = accumulate_records(posix_recs, \"H5F\", report.metadata['job']['nprocs'])\n", + "# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\n", + "darshan.enable_experimental()\n", + "plot_opcounts(report, \"H5F\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "862437d8", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Error: plot_opcounts not supported for module PNETCDF_FILE", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module PNETCDF_FILE" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Test for plot_opcounts PNETCDF_FILE\n", + "from darshan.experimental.plots import plot_opcounts\n", + "# acc_PNETCDF_FILE = accumulate_records(posix_recs, \"PNETCDF_FILE\", report.metadata['job']['nprocs'])\n", + "# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\n", + "# darshan.enable_experimental()\n", + "plot_opcounts(report, \"PNETCDF_FILE\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "dece9aaa", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Test for plot_posix_access_pattern\n", + "from darshan.experimental.plots import plot_posix_access_pattern\n", + "darshan.enable_experimental()\n", + "plot_posix_access_pattern(acc.summary_record)" + ] + } + ], + "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.9.7" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From aedaa9bfb3aabb3608b4e111cd4fc5899f84a0ae Mon Sep 17 00:00:00 2001 From: Yanli Date: Fri, 16 Jun 2023 10:28:41 -0500 Subject: [PATCH 02/11] change plot_opcounts.py to use a record input --- .../experimental/plots/plot_opcounts.py | 212 +++++++++--------- 1 file changed, 101 insertions(+), 111 deletions(-) diff --git a/darshan-util/pydarshan/darshan/experimental/plots/plot_opcounts.py b/darshan-util/pydarshan/darshan/experimental/plots/plot_opcounts.py index 1d648c610..6b0843a5e 100644 --- a/darshan-util/pydarshan/darshan/experimental/plots/plot_opcounts.py +++ b/darshan-util/pydarshan/darshan/experimental/plots/plot_opcounts.py @@ -20,34 +20,26 @@ def autolabel(ax, rects): rotation=45, ) -def gather_count_data(report, mod): + +def gather_count_data(record, mod): """ Collect the module counts and labels for the I/O Operation Count plot. """ - # TODO: change to report.summary - if 'agg_ioops' in dir(report): - report.agg_ioops() - else: - print( - "Cannot create summary, agg_ioops aggregator is not " - "registered with the report class. Be sure to call " - "darshan.experimental() once before invoking this plot." - ) - - mod_data = report.summary['agg_ioops'][mod] - + if mod in ['H5F', 'H5D', 'PNETCDF_FILE', 'PNETCDF_VAR']: + raise ValueError(f"Error: plot_opcounts not supported for module {mod}") + mod_data = record['counters'] # Gather POSIX if mod == 'POSIX': labels = ['Read', 'Write', 'Open', 'Stat', 'Seek', 'Mmap', 'Fsync'] counts = [ - mod_data['POSIX_READS'], - mod_data['POSIX_WRITES'], - mod_data['POSIX_OPENS'], - mod_data['POSIX_STATS'], - mod_data['POSIX_SEEKS'], + mod_data['POSIX_READS'][0], + mod_data['POSIX_WRITES'][0], + mod_data['POSIX_OPENS'][0], + mod_data['POSIX_STATS'][0], + mod_data['POSIX_SEEKS'][0], 0, # faulty? mod_data['POSIX_MMAPS'], - mod_data['POSIX_FSYNCS'] + mod_data['POSIX_FDSYNCS'] + mod_data['POSIX_FSYNCS'][0] + mod_data['POSIX_FDSYNCS'][0] ] # Gather MPIIO @@ -56,114 +48,114 @@ def gather_count_data(report, mod): 'Ind. Read', 'Ind. Write', 'Ind. Open', 'Col. Read', 'Col. Write', 'Col. Open', 'Sync'] counts = [ - mod_data['MPIIO_INDEP_READS'], - mod_data['MPIIO_INDEP_WRITES'], - mod_data['MPIIO_INDEP_OPENS'], - mod_data['MPIIO_COLL_READS'], - mod_data['MPIIO_COLL_WRITES'], - mod_data['MPIIO_COLL_OPENS'], - mod_data['MPIIO_SYNCS'], + mod_data['MPIIO_INDEP_READS'][0], + mod_data['MPIIO_INDEP_WRITES'][0], + mod_data['MPIIO_INDEP_OPENS'][0], + mod_data['MPIIO_COLL_READS'][0], + mod_data['MPIIO_COLL_WRITES'][0], + mod_data['MPIIO_COLL_OPENS'][0], + mod_data['MPIIO_SYNCS'][0], ] # Gather Stdio elif mod == 'STDIO': labels = ['Read', 'Write', 'Open', 'Seek', 'Flush'] counts = [ - mod_data['STDIO_READS'], - mod_data['STDIO_WRITES'], - mod_data['STDIO_OPENS'], - mod_data['STDIO_SEEKS'], - mod_data['STDIO_FLUSHES'] + mod_data['STDIO_READS'][0], + mod_data['STDIO_WRITES'][0], + mod_data['STDIO_OPENS'][0], + mod_data['STDIO_SEEKS'][0], + mod_data['STDIO_FLUSHES'][0] ] - elif mod == 'H5F': - labels = [ - 'H5D Read', 'H5D Write', 'H5D Open', - 'H5D Flush', 'H5F Open', 'H5F Flush', - ] - counts = [ - # set H5D counters to zero - 0, 0, 0, 0, - mod_data['H5F_OPENS'], - mod_data['H5F_FLUSHES'], - ] - - elif mod == 'H5D': - labels = [ - 'H5D Read', 'H5D Write', 'H5D Open', - 'H5D Flush', 'H5F Open', 'H5F Flush', - ] +# elif mod == 'H5F': +# labels = [ +# 'H5D Read', 'H5D Write', 'H5D Open', +# 'H5D Flush', 'H5F Open', 'H5F Flush', +# ] +# counts = [ +# # set H5D counters to zero +# 0, 0, 0, 0, +# mod_data['H5F_OPENS'][0], +# mod_data['H5F_FLUSHES'][0], +# ] + +# elif mod == 'H5D': +# labels = [ +# 'H5D Read', 'H5D Write', 'H5D Open', +# 'H5D Flush', 'H5F Open', 'H5F Flush', +# ] # H5F is not necessarily available following # gh-703 - if not "H5F" in report.summary["agg_ioops"]: - report.summary['agg_ioops']['H5F'] = defaultdict(lambda: 0) - - counts = [ - report.summary['agg_ioops']['H5D']['H5D_READS'], - report.summary['agg_ioops']['H5D']['H5D_WRITES'], - report.summary['agg_ioops']['H5D']['H5D_OPENS'], - report.summary['agg_ioops']['H5D']['H5D_FLUSHES'], - report.summary['agg_ioops']['H5F']['H5F_OPENS'], - report.summary['agg_ioops']['H5F']['H5F_FLUSHES'], - ] - - elif mod == 'PNETCDF_FILE': - labels = [ - 'Var Ind Read', 'Var Ind Write', 'Var Open', - 'Var Coll Read', 'Var Coll Write', - 'Var NB Read', 'Var NB Write', - 'File Open', - 'File Sync', - 'File Ind Waits', - 'File Coll Waits', - ] - counts = [ - # most of the counters will all get set in PNETCDF_VAR - 0, 0, 0, 0, 0, 0, 0, - mod_data["PNETCDF_FILE_OPENS"] + mod_data["PNETCDF_FILE_CREATES"], - mod_data["PNETCDF_FILE_SYNCS"], - mod_data['PNETCDF_FILE_INDEP_WAITS'], - mod_data['PNETCDF_FILE_COLL_WAITS'], - ] - - elif mod == 'PNETCDF_VAR': - labels = [ - 'Var Ind Read', 'Var Ind Write', 'Var Open', - 'Var Coll Read', 'Var Coll Write', - 'Var NB Read', 'Var NB Write', - 'File Open', - 'File Sync', - 'File Ind Waits', - 'File Coll Waits', - ] - counts = [ - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_INDEP_READS'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_INDEP_WRITES'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_OPENS'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_COLL_READS'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_COLL_WRITES'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_NB_READS'], - report.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_NB_WRITES'], - # NOTE: should handle cases where only 1/2 PNETCDF mods - # are present? - (report.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_OPENS'] + - report.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_CREATES'] - ), - report.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_SYNCS'], - report.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_INDEP_WAITS'], - report.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_COLL_WAITS'], - ] +# if not "H5F" in record.summary["agg_ioops"]: +# record.summary['agg_ioops']['H5F'] = defaultdict(lambda: 0) + +# counts = [ +# record.summary['agg_ioops']['H5D']['H5D_READS'], +# record.summary['agg_ioops']['H5D']['H5D_WRITES'], +# record.summary['agg_ioops']['H5D']['H5D_OPENS'], +# record.summary['agg_ioops']['H5D']['H5D_FLUSHES'], +# record.summary['agg_ioops']['H5F']['H5F_OPENS'], +# record.summary['agg_ioops']['H5F']['H5F_FLUSHES'], +# ] + +# elif mod == 'PNETCDF_FILE': +# labels = [ +# 'Var Ind Read', 'Var Ind Write', 'Var Open', +# 'Var Coll Read', 'Var Coll Write', +# 'Var NB Read', 'Var NB Write', +# 'File Open', +# 'File Sync', +# 'File Ind Waits', +# 'File Coll Waits', +# ] +# counts = [ +# # most of the counters will all get set in PNETCDF_VAR +# 0, 0, 0, 0, 0, 0, 0, +# mod_data["PNETCDF_FILE_OPENS"][0] + mod_data["PNETCDF_FILE_CREATES"][0], +# mod_data["PNETCDF_FILE_SYNCS"][0], +# mod_data['PNETCDF_FILE_INDEP_WAITS'][0], +# mod_data['PNETCDF_FILE_COLL_WAITS'][0], +# ] + +# elif mod == 'PNETCDF_VAR': +# labels = [ +# 'Var Ind Read', 'Var Ind Write', 'Var Open', +# 'Var Coll Read', 'Var Coll Write', +# 'Var NB Read', 'Var NB Write', +# 'File Open', +# 'File Sync', +# 'File Ind Waits', +# 'File Coll Waits', +# ] +# counts = [ +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_INDEP_READS'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_INDEP_WRITES'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_OPENS'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_COLL_READS'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_COLL_WRITES'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_NB_READS'], +# record.summary['agg_ioops']['PNETCDF_VAR']['PNETCDF_VAR_NB_WRITES'], +# # NOTE: should handle cases where only 1/2 PNETCDF mods +# # are present? +# (record.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_OPENS'] + +# record.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_CREATES'] +# ), +# record.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_SYNCS'], +# record.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_INDEP_WAITS'], +# record.summary['agg_ioops']['PNETCDF_FILE']['PNETCDF_FILE_COLL_WAITS'], +# ] return labels, counts -def plot_opcounts(report, mod, ax=None): +def plot_opcounts(record, mod, ax=None): """ Generates a bar chart summary for operation counts. Parameters ---------- - report (DarshanReport): darshan report object to plot + record: darshan record object to plot mod: the module to plot operation counts for (i.e. "POSIX", "MPI-IO", "STDIO", "H5F", "H5D"). If "H5D" is input the returned @@ -176,11 +168,10 @@ def plot_opcounts(report, mod, ax=None): else: fig = None - labels, counts = gather_count_data(report=report, mod=mod) + labels, counts = gather_count_data(record=record, mod=mod) x = np.arange(len(labels)) # the label locations rects = ax.bar(x, counts) - # Add some text for labels, title and custom x-axis tick labels, etc. ax.set_ylabel('Count') ax.set_xticks(x) @@ -190,7 +181,6 @@ def plot_opcounts(report, mod, ax=None): ax.spines[['right', 'top']].set_visible(False) autolabel(ax=ax, rects=rects) - plt.tight_layout() if fig is not None: From f63839c5f28016382f15c1b5e2cb8f4ef2b1db2b Mon Sep 17 00:00:00 2001 From: Yanli Date: Fri, 16 Jun 2023 14:08:00 -0500 Subject: [PATCH 03/11] update test_xticks_and_labels --- .../pydarshan/darshan/tests/test_plot_exp_common.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py b/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py index 8e29828dc..d04f97c76 100644 --- a/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py +++ b/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py @@ -6,6 +6,7 @@ import darshan from darshan.experimental.plots import plot_opcounts, plot_access_histogram from darshan.log_utils import get_log_path +from darshan.backend.cffi_backend import accumulate_records darshan.enable_experimental() @@ -147,8 +148,9 @@ def test_xticks_and_labels(log_path, func, expected_xticklabels, mod): # labels log_path = get_log_path(log_path) with darshan.DarshanReport(log_path) as report: - - fig = func(report=report, mod=mod) + recs = report.records[mod].to_df() + acc = accumulate_records(recs, mod, report.metadata['job']['nprocs']) + fig = func(record=acc.summary_record, mod=mod) # retrieve the x-axis tick mark locations and labels # from the output figure object From 721c9828d0ea0b32a3f0dcf8a3fa6cb671ee4677 Mon Sep 17 00:00:00 2001 From: Shane Snyder Date: Fri, 16 Jun 2023 14:24:39 -0500 Subject: [PATCH 04/11] add xfails for some tests using HDF5/PNETCDF --- .../pydarshan/darshan/tests/test_plot_exp_common.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py b/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py index d04f97c76..1fa674e13 100644 --- a/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py +++ b/darshan-util/pydarshan/darshan/tests/test_plot_exp_common.py @@ -144,6 +144,9 @@ ], ) def test_xticks_and_labels(log_path, func, expected_xticklabels, mod): + if mod in ['H5F', 'H5D', 'PNETCDF_FILE', 'PNETCDF_VAR']: + pytest.xfail(reason="module not supported") + # check the x-axis tick mark locations and # labels log_path = get_log_path(log_path) @@ -388,6 +391,9 @@ def test_xticks_and_labels(log_path, func, expected_xticklabels, mod): ], ) def test_bar_heights(filename, mod, fig_func, expected_heights): + if mod in ['H5F', 'H5D', 'PNETCDF_FILE', 'PNETCDF_VAR']: + pytest.xfail(reason="module not supported") + # check bar graph heights log_path = get_log_path(filename) with darshan.DarshanReport(log_path) as report: From c7c8a1edff6d80bcade9fe6f499cf2585e38006f Mon Sep 17 00:00:00 2001 From: Yanli Date: Wed, 21 Jun 2023 13:29:38 -0600 Subject: [PATCH 05/11] update multi log scratchpad notebook --- .../examples/multi-log-scratchpad.ipynb | 503 +++++++++++------- 1 file changed, 312 insertions(+), 191 deletions(-) diff --git a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb index 1fa327f7f..dab03f01a 100644 --- a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb +++ b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb @@ -122,6 +122,30 @@ { "cell_type": "code", "execution_count": 3, + "id": "634efe0c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'POSIX': ,\n", + " 'MPI-IO': ,\n", + " 'STDIO': ,\n", + " 'LUSTRE': }" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "report.records" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "id": "c46d71a3", "metadata": {}, "outputs": [ @@ -131,7 +155,7 @@ "text": [ "Filename: example_logs/example.darshan\n", "Executable: /global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32\n", - "Times: 2017-03-20 04:07:47 to 2017-03-20 04:09:43\n", + "Times: 2017-03-20 03:07:47 to 2017-03-20 03:09:43\n", "Run time: 117.0000 (s)\n", "Processes: 2048\n", "JobID: 4478544\n", @@ -140,7 +164,7 @@ "Loaded Records: {'POSIX': 1, 'MPI-IO': 1, 'STDIO': 129, 'LUSTRE': 1}\n", "Name Records: 4\n", "Darshan/Hints: {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}\n", - "DarshanReport: id(140222677424160) (tmp)\n" + "DarshanReport: id(140591674498928) (tmp)\n" ] } ], @@ -159,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "1e1059de", "metadata": {}, "outputs": [ @@ -188,7 +212,7 @@ " 'num_records': 129}}" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -200,7 +224,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "27d88766", "metadata": {}, "outputs": [ @@ -273,7 +297,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "5484b720", "metadata": {}, "outputs": [ @@ -284,9 +308,9 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 32\u001b[0;31m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 34\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'POSIX'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'POSIX'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: 'DarshanReport' object is not subscriptable" ] }, @@ -350,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "28515908", "metadata": { "scrolled": true @@ -387,17 +411,16 @@ ], "source": [ "from darshan.backend.cffi_backend import accumulate_records\n", - "\n", "# accumulate all records in posix_recs, and then print out the \"summary\" record\n", "acc = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", + "# print(acc)\n", "# print(type(acc))\n", "# print(type(acc.summary_record))\n", "# print(acc.summary_record, end='\\n\\n\\n\\n')\n", "print(acc.summary_record['counters'], end='\\n\\n\\n\\n')\n", "# print(acc.summary_record['counters'][\"POSIX_OPENS\"], end='\\n\\n\\n\\n')\n", "# printint(dir(acc.summary_record))\n", - "# print(acc.summary_record.summary)\n", - "\n" + "# print(acc.summary_record.summary)" ] }, { @@ -410,172 +433,23 @@ "Our first step is to modify the plotting code `plot_opcounts()` (in file darshan/experimental/plots/plot_opcounts.py) to take a single record as input rather than a report object. Ultimately, we should be able to pass in the summary record from above and get an identical plot to the one generated previously in this notebook (i.e., based on the old code)." ] }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9c28b46b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__slots__', '__str__', '__subclasshook__', '_asdict', '_field_defaults', '_fields', '_make', '_replace', 'count', 'derived_metrics', 'index', 'summary_record']\n" - ] - } - ], - "source": [ - "print(dir(acc))" - ] - }, { "cell_type": "code", "execution_count": 9, "id": "341c1545", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "acc: AccumulatedRecords(derived_metrics=, summary_record={'id': 6301063301082038805, 'rank': -1, 'counters': id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", - "0 6301063301082038805 -1 2049 -1 -1 \n", - "\n", - " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", - "0 0 16402 16404 0 0 ... \n", - "\n", - " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", - "0 544 328 16384 \n", - "\n", - " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", - "0 8 2 2 \n", - "\n", - " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", - "0 597 1073741824 1312 \n", - "\n", - " POSIX_SLOWEST_RANK_BYTES \n", - "0 1073741824 \n", - "\n", - "[1 rows x 71 columns], 'fcounters': id rank POSIX_F_OPEN_START_TIMESTAMP \\\n", - "0 6301063301082038805 -1.0 3.919141 \n", - "\n", - " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", - "0 0.0 3.940064 \n", - "\n", - " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", - "0 3.927094 3.93658 \n", - "\n", - " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", - "0 0.0 115.078166 \n", - "\n", - " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", - "0 115.770358 0.0 100397.600422 \n", - "\n", - " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", - "0 11.300842 0.0 17.940946 \n", - "\n", - " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", - "0 20.4361 85.47495 \n", - "\n", - " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", - "0 0.0 0.0 })\n", - "\n", - "\n", - "\n", - "acc.summary_record: {'id': 6301063301082038805, 'rank': -1, 'counters': id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", - "0 6301063301082038805 -1 2049 -1 -1 \n", - "\n", - " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", - "0 0 16402 16404 0 0 ... \n", - "\n", - " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", - "0 544 328 16384 \n", - "\n", - " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", - "0 8 2 2 \n", - "\n", - " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", - "0 597 1073741824 1312 \n", - "\n", - " POSIX_SLOWEST_RANK_BYTES \n", - "0 1073741824 \n", - "\n", - "[1 rows x 71 columns], 'fcounters': id rank POSIX_F_OPEN_START_TIMESTAMP \\\n", - "0 6301063301082038805 -1.0 3.919141 \n", - "\n", - " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", - "0 0.0 3.940064 \n", - "\n", - " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", - "0 3.927094 3.93658 \n", - "\n", - " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", - "0 0.0 115.078166 \n", - "\n", - " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", - "0 115.770358 0.0 100397.600422 \n", - "\n", - " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", - "0 11.300842 0.0 17.940946 \n", - "\n", - " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", - "0 20.4361 85.47495 \n", - "\n", - " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", - "0 0.0 0.0 }\n", - "\n", - "\n", - "\n", - "acc.count: \n", - "\n", - "\n", - "\n", - "acc.derived_metrics: \n", - "\n", - "\n", - "\n", - "acc.index: \n", - "\n", - "\n", - "\n", - "acc.summary_record['counters']: id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", - "0 6301063301082038805 -1 2049 -1 -1 \n", - "\n", - " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", - "0 0 16402 16404 0 0 ... \n", - "\n", - " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", - "0 544 328 16384 \n", - "\n", - " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", - "0 8 2 2 \n", - "\n", - " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", - "0 597 1073741824 1312 \n", - "\n", - " POSIX_SLOWEST_RANK_BYTES \n", - "0 1073741824 \n", - "\n", - "[1 rows x 71 columns]\n", - "\n", - "\n", - "\n", - "acc.summary_record['counters']['POSIX_OPENS']: 0 2049\n", - "Name: POSIX_OPENS, dtype: int64\n", - "\n", - "acc.summary_record['counters']['POSIX_OPENS'][0]: 2049\n" - ] - } - ], + "outputs": [], "source": [ - "print(\"acc: \", acc, end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.summary_record: \", acc.summary_record, end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.count: \", acc.count, end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.derived_metrics: \", acc.derived_metrics, end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.index: \", acc.index, end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.summary_record['counters']: \", acc.summary_record['counters'], end=\"\\n\\n\\n\\n\")\n", - "print(\"acc.summary_record['counters']['POSIX_OPENS']: \", acc.summary_record['counters'][\"POSIX_OPENS\"], end=\"\\n\\n\")\n", - "print(\"acc.summary_record['counters']['POSIX_OPENS'][0]: \", acc.summary_record['counters'][\"POSIX_OPENS\"][0])" + "# print(dir(acc))\n", + "# print(dir(acc.summary_record))\n", + "# print(\"acc: \", acc, end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.summary_record: \", acc.summary_record, end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.count: \", acc.count, end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.derived_metrics: \", acc.derived_metrics, end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.index: \", acc.index, end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.summary_record['counters']: \", acc.summary_record['counters'], end=\"\\n\\n\\n\\n\")\n", + "# print(\"acc.summary_record['counters']['POSIX_OPENS']: \", acc.summary_record['counters'][\"POSIX_OPENS\"], end=\"\\n\\n\")\n", + "# print(\"acc.summary_record['counters']['POSIX_OPENS'][0]: \", acc.summary_record['counters'][\"POSIX_OPENS\"][0])" ] }, { @@ -608,19 +482,19 @@ { "cell_type": "code", "execution_count": 11, - "id": "64d4ae6d", + "id": "e004f112", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-1\n" + "0\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEaCAYAAABEsMO+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqj0lEQVR4nO3dfZhd473/8fdHIpLQEMnQyEMThIpIqSDooaUqPShVNKpHlJ85Um1oSyXaHu1p09K6yGkdIS0SD1dQDwchSqONOlIR9RBCiMcEJTQiJzQkvr8/1j2yMyaTmWT2XmtNPq/rmmuv/V1r7fludua773vd674VEZiZmRXNRnknYGZm1hQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMrDEl9JCnvPKwYXKDMrBAk7QQ8D4yQ1DXvfCx/LlBmVhQrgEXACOAwSV1yzsdy1jHvBMzMACLiGUm/BRYCpwL/kPQa8GZEvJxvdpYHt6DMrBBSi6kvMJusQP0KeADol2delh+3oMwsF5L2B/YAFgB/iIi3JN0GfBx4GtgKmAdsKalzRPwzv2wtDy5QZlZzkg4DfgrcDewK/CNtLwUmABsDxwEBfA+4D3CB2sC4QJlZTaURescDJ0fEg5LGATtLeh74MzAJeCoi/pSOfygiluaVr+XHBcrMai2AHsD+khYCXwXmAEMBAd+JiNcldQA+AP4vt0wtV/KKumZWC2kQxEYRsUzSMOAi4E1gdkT8QFJ/YAwwNSKm5piqFYRH8ZlZ1Uk6FLgamCbpixHxV+BfgD8CzwFExAtkvTq98srTisVdfGZWVZIOIRsQ8W1ge2CcpHtTS+pPwC9Sd94SYDfg3PyytSJxF5+ZVY2kzsDPgWkRcbekbYHLgXvJRubNAvYDvgUsBsZFxGN55WvF4gJlZlUh6eMR8XdJ3SLibUndgKnAQ8CDwP8DLomI6yVtAhARy3NM2QrGXXxm1uYkfRE4UdJZEfFcCgfwzYh4PB0DcLykW1yYrCkuUGbWpiTtBVwKnFBRnIiIpZLmSlJkXTcdgTeAlTmlagXnAmVmbW0gcFVE3CNpG7KBDz0i4sqI+ABA0glk8+19IyJW5JeqFZmHmZtZW1sIbCGpL9k1p38BRku6FkDSYOBzwIkN3X1mTfEgCTNbb5J2iIin0/anyIaVPwC8GxEXpPhM4Eqy7r+uEeEZIqxZbkGZ2XpJN+E+ImkKQEQ8CtwBnAQMkLR5OvRm4L2I+MDFyVrCLSgzW2eSNgVuBG4C9gE6RcTX0r6TgaOAaUB34BjgyxHxVE7pWsm4QJnZekkDId4GOgOXAO9HxLFp32fIitNeZAMn5uWWqJXOBleghg8fHnfeeWfeaZi1S2+++Sb19fV06tSJKVOm8Nhjj9GjRw969+6dd2pWbGoquMFdg3rjjTfyTsGs3erRoweXXnopnTt3Zscdd+TII49kQ/sSbG1ngytQZlZdPXv2ZMiQISxZsoSbb76ZPn365J2SlZQLlJm1qcWLF3PHHXdw1113scsuu+SdjpWYZ5IwszbVvXt3brvtNjp37px3KlZybkGZWZtzcbK24AJlZmaF5AJlZmaF5AJlZmaFVLVBEpIuBw4FXo+IwRXxb5Mt77wCuD0ivp/iY8nm7loJjI6IP6T47sAkoAvZ/F6nRUSkFTivBHYH3gS+GhEvVOv9mBn0H3N73ik06YVzD8k7BauCaragJgHDKwOSPgccDgyJiJ2B81N8EDAC2Dmdc7GkDum0CUA92RozAyte8yRgcURsD1wInFfF92JmZjVWtQIVEfcC/2gUHgWc27C8c0S8nuKHA9dGxPKIeB6YD+wpqRfQLSJmphU4rwSOqDhnctq+AThQaQ1pMzMrv1pfg9oB+BdJD0iaIWmPFO8NLKg4bmGK9U7bjeOrnZNW5FwC9Khi7mZmVkO1vlG3I9nMxsOAPYDrJW1L0xMFRjNx1rJvNZLqyboJ6devXytTNjOzPNS6BbUQuCkys4APgJ4p3rfiuD7AKynep4k4ledI6ghszke7FAGIiIkRMTQihtbV1bXh2zEzs2qpdYH6H+AAyJaIBjoBbwC3AiMkbSJpANlgiFkR8SqwVNKwdH3peOCW9Fq3AiPT9lHAPeFpk83M2o1qDjOfAnwW6ClpIXAOcDlwuaTHgfeAkamoPCHpemAu2fDzUyNiZXqpUawaZj4t/QBcBlwlaT5Zy2lEtd6LmZnVXtUKVMOKmk34+hqOHweMayI+GxjcRPyfwNHrk6OZmRWXZ5IwM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCcoEyM7NCqlqBknS5pNfT0hqN950hKST1rIiNlTRf0jxJB1fEd5c0J+37dVoXirR21HUp/oCk/tV6L2ZmVnvVbEFNAoY3DkrqCxwEvFQRG0S2ntPO6ZyLJXVIuyeQLdc+MP00vOZJwOKI2B64EDivKu/CzMxyUbUCFRH30vQS7BcC3wcqV789HLg2IpZHxPPAfGBPSb2AbhExMy1seCVwRMU5k9P2DcCBDa0rMzMrv5peg5L0JeDliHi00a7ewIKK5wtTrHfabhxf7ZyIWAEsAXpUIW0zM8tB1VbUbUxSV+AHwBea2t1ELJqJN3dOU7+7nqybkH79+q01VzMzy18tW1DbAQOARyW9APQB/ibp42Qto74Vx/YBXknxPk3EqTxHUkdgc5ruUiQiJkbE0IgYWldX12ZvyMzMqqdmBSoi5kTEVhHRPyL6kxWYT0fE34FbgRFpZN4AssEQsyLiVWCppGHp+tLxwC3pJW8FRqbto4B70nUqMzNrB6o5zHwKMBPYUdJCSSet6diIeAK4HpgL3AmcGhEr0+5RwO/IBk48C0xL8cuAHpLmA98FxlTljZiZWS6qdg0qIo5dy/7+jZ6PA8Y1cdxsYHAT8X8CR69flmZmVlSeScLMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzArJBcrMzAqpmsttXC7pdUmPV8R+JekpSY9JulnSFhX7xkqaL2mepIMr4rtLmpP2/TqtC0VaO+q6FH9AUv9qvRczM6u9aragJgHDG8XuBgZHxBDgaWAsgKRBwAhg53TOxZI6pHMmkC3XPjD9NLzmScDiiNgeuBA4r2rvxMzMaq5qBSoi7qXREuwRcVdErEhP/8qq5dwPB66NiOUR8TzZ4oR7SuoFdIuImWm13CuBIyrOmZy2bwAObGhdmZlZ+eV5DepEVq2O2xtYULFvYYr1TtuN46udk4reEqBHFfM1M7MayqVASfoBsAK4piHUxGHRTLy5c5r6ffWSZkuavWjRotama2ZmOah5gZI0EjgUOC5120HWMupbcVgf4JUU79NEfLVzJHUENqdRl2KDiJgYEUMjYmhdXV1bvRUzM6uimhYoScOBs4AvRcQ7FbtuBUakkXkDyAZDzIqIV4Glkoal60vHA7dUnDMybR8F3FNR8MzMrOQ6VuuFJU0BPgv0lLQQOIds1N4mwN1pPMNfI+KUiHhC0vXAXLKuv1MjYmV6qVFkIwK7kF2zarhudRlwlaT5ZC2nEdV6L2ZmVntVK1ARcWwT4cuaOX4cMK6J+GxgcBPxfwJHr0+OZmZWXJ5JwszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCskFyszMCqlqBUrS5ZJel/R4RWxLSXdLeiY9dq/YN1bSfEnzJB1cEd9d0py079dpXSjS2lHXpfgDkvpX672YmVntVbMFNQkY3ig2BpgeEQOB6ek5kgaRree0czrnYkkd0jkTgHqyRQwHVrzmScDiiNgeuBA4r2rvxMzMaq5qBSoi7uWjS7AfDkxO25OBIyri10bE8oh4HpgP7CmpF9AtImam1XKvbHROw2vdABzY0LoyM7Pyq/U1qK3TMu6kx61SvDewoOK4hSnWO203jq92TkSsAJYAPaqWuZmZ1VRRBkk01fKJZuLNnfPRF5fqJc2WNHvRokXrmKKZmdVSrQvUa6nbjvT4eoovBPpWHNcHeCXF+zQRX+0cSR2BzflolyIAETExIoZGxNC6uro2eitmZlZNLSpQkvZtSawFbgVGpu2RwC0V8RFpZN4AssEQs1I34FJJw9L1peMbndPwWkcB96TrVGZm1g60tAX1mxbGPiRpCjAT2FHSQkknAecCB0l6BjgoPScingCuB+YCdwKnRsTK9FKjgN+RDZx4FpiW4pcBPSTNB75LGhFoZmbtQ8fmdkraG9gHqJP03Ypd3YAOTZ+ViYhj17DrwDUcPw4Y10R8NjC4ifg/gaOby8HMzMqr2QIFdAI2S8d9rCL+Nlm3mpmZWVU0W6AiYgYwQ9KkiHixRjmZmZmttQXVYBNJE4H+ledExAHVSMrMzKylBer3wCVkgxVWruVYMzOz9dbSArUiIiZUNRMzM7MKLR1mfpukb0rqlWYk31LSllXNzMzMNmgtbUE13BB7ZkUsgG3bNh0zM7NMiwpURAyodiJmZmaVWlSgJB3fVDwirmzbdMzMzDIt7eLbo2K7M9lsEH8jW5/JzMyszbW0i+/blc8lbQ5cVZWMzMzMWPflNt4hm3HczMysKlp6Deo2Vi0G2AHYiWz2cTMzs6po6TWo8yu2VwAvRsTCNR28NpK+A/w/sqI3B/gG0BW4jmw6pReAYyJicTp+LHAS2SwWoyPiDym+OzAJ6ALcAZzmNaHMzNqHFnXxpUljnyKb0bw78N66/kJJvYHRwNCIGEzWIhtBtp7T9IgYCExPz5E0KO3fGRgOXCypYamPCUA9WXfjwLTfzMzagZauqHsMMIts/aVjgAckrc9yGx2BLmmp9q5ky7gfDkxO+ycDR6Ttw4FrI2J5RDxPtnDhnmnJ+G4RMTO1mq6sOMfMzEqupV18PwD2iIjXASTVAX8EbmjtL4yIlyWdD7wEvAvcFRF3Sdo6LfFORLwqaat0Sm/grxUvsTDF3k/bjeNmZtYOtHQU30YNxSl5sxXnrkZSd7JW0QBgG2BTSV9v7pQmYtFMvKnfWS9ptqTZixYtam3KZmaWg5YWmTsl/UHSCZJOAG4nG5SwLj4PPB8RiyLifeAmsmXlX0vddqTHhoK4EOhbcX4fsi7BhWm7cfwjImJiRAyNiKF1dXXrmLaZmdVSswVK0vaS9o2IM4FLgSHAp4CZwMR1/J0vAcMkdZUkslkpngRuZdWktCOBW9L2rcAISZtIGkA2GGJW6g5cKmlYep3jK84xM7OSW9s1qPHA2QARcRNZawdJQ9O+w1r7CyPiAUk3kE2VtAJ4mKzYbQZcL+kksiJ2dDr+CUnXA3PT8adGRMOiiaNYNcx8WvoxM7N2YG0Fqn9EPNY4GBGzJfVf118aEecA5zQKLydrTTV1/DhgXFN5AIPXNQ8zMyuutV2D6tzMvi5tmYiZmVmltRWoByWd3DiYuuEeqk5KZmZma+/iOx24WdJxrCpIQ4FOwJermJeZmW3gmi1QEfEasI+kz7HqWs/tEXFP1TMzM7MNWkvXg/oT8Kcq52JmZvahdV0PyszMrKpcoMzMrJBcoMzMrJBcoMzMrJBcoMzMrJBcoMzMrJBcoMzMrJBcoMzMrJByKVCStpB0g6SnJD0paW9JW0q6W9Iz6bF7xfFjJc2XNE/SwRXx3SXNSft+ndaFMjOzdiCvFtR/AXdGxCfJFkB8EhgDTI+IgcD09BxJg4ARwM7AcOBiSR3S60wA6skWMRyY9puZWTtQ8wIlqRuwH3AZQES8FxFvAYcDk9Nhk4Ej0vbhwLURsTwingfmA3umZeG7RcTMiAjgyopzzMys5PJoQW0LLAKukPSwpN9J2hTYOi3jTnrcKh3fG1hQcf7CFOudthvHP0JSvaTZkmYvWrSobd+NmZlVRR4FqiPwaWBCROwGLCN1561BU9eVopn4R4MREyNiaEQMraura22+ZmaWgzwK1EJgYUQ8kJ7fQFawXkvddqTH1yuO71txfh/glRTv00TczMzagZoXqIj4O7BA0o4pdCAwF7gVGJliI4Fb0vatwAhJm0gaQDYYYlbqBlwqaVgavXd8xTlmZlZyLVoPqgq+DVwjqRPwHPANsmJ5fVpO/iXgaICIeELS9WRFbAVwakSsTK8zCpgEdAGmpR8zM2sHcilQEfEI2dLxjR24huPHAeOaiM9m1Uq/ZmbWjngmCTMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzKyQXKDMzK6S8Jos1M2sXHn30UTbeeGM6duzIDjvskHc67YoLlJnZOpo6dSpnn302u+22G507d+Y//uM/6NWrFxtt5M6ptpDbf0VJHdKS71PT8y0l3S3pmfTYveLYsZLmS5on6eCK+O6S5qR9v07rQpmZVd2LL77I2WefzeTJk/nlL3/J8uXLAXj33Xdzzqz9yLPMnwY8WfF8DDA9IgYC09NzJA0CRgA7A8OBiyV1SOdMAOrJFjEcmPabmVXd0qVLqaur+7D1dN999zF69GhGjRrFlClT8k6vXcilQEnqAxwC/K4ifDgwOW1PBo6oiF8bEcsj4nlgPrBnWha+W0TMjIgArqw4x8ysKpYtWwbA4MGDWbFiBZ/5zGfYcccdqa+vZ/z48Xz5y1/m97//PS+++GLOmZZfXi2o8cD3gQ8qYlunZdxJj1uleG9gQcVxC1Osd9puHP8ISfWSZkuavWjRojZ5A2a24Zk2bRqnnHIKM2fOBGDGjBlceumlHHnkkZx55pn07duX/fbbj44dfXm/LdS8QEk6FHg9Ih5q6SlNxKKZ+EeDERMjYmhEDK2rq2vhrzUzW928efOYO3cu06dPZ8aMGQDsvPPOdOjQgVGjRgFw33338dJLL7HxxhvnmWq7kEeZ3xf4kqR/BToD3SRdDbwmqVdEvJq6715Pxy8E+lac3wd4JcX7NBE3M6uKfv360bNnTz744AOmTZtGz549GTBgAKeccgpnnXUW++23H0uWLOHqq69mm222yTvd0qt5CyoixkZEn4joTzb44Z6I+DpwKzAyHTYSuCVt3wqMkLSJpAFkgyFmpW7ApZKGpdF7x1ecY2bWZrLL3HDQQQex//77M2LECLbYYgt+9rOf8ZWvfIWtt96aqVOnMmHCBKZPn84uu+ySc8btQ5EG658LHCTpGeCg9JyIeAK4HpgL3AmcGhEr0zmjyAZazAeeBabVOmkza78WLFjAe++9xzvvvAPA8uXLufPOO9l22235xCc+wbRp0+jatSsvv/wykHX39ezZM8+U2xU1fDPYUAwdOjRmz56ddxpmpdR/zO15p9CkF849pM1f8/bbb+ess85i3333ZfHixfzkJz9hp5124pJLLuHNN9/kiiuu4Dvf+Q6LFi1io4024owzzqBr165tnscGosl7WD3UxMysQkSwcOFCxowZw0UXXcROO+3E1VdfzQEHHMCMGTPYbrvtOPfcc/nNb37DYYcdxrx58+jevbuLUxW4QJmZVZDENttsw957783AgQPZaqut+N73vkeHDh046KCDmDVrFnPnzqVr165EBDvuuGPeKbdbRboGZWaWq/nz5/Pggw/y1ltvsWTJEq655hoaZlA7/fTTOeWUUxgzZgwAH3zwQXMvZW3ALSgzM1ZN/Nq9e3d22WUXjjvuOEaPHs3KlSsZO3YsAMceeyy/+MUv3J1XIy5QZrbBu//++znjjDOYMmUKu+22G/X19cyaNYv777+fYcOGsXLlSkaMGMF9993HQw89xOLFi+nevfvaX9jWi7v4zMyAMWPGsNtuuwEwbtw4Hn74YbbZZhv+/Oc/89xzz3HBBRdw0UUXccUVV7g41YhbUGa2wdtrr70YPHgwACtXrmT58uW88sorvPrqq2y77bacc8459O7dm2XLlrH55pvnnO2Gwy0oM9vgdejQgW7dugHZMPMtttiCLbfckl69enH11Vfz85//nPfff9/FqcbcgjIzq9CxY0c222wz+vbty9ixY7nrrruYNGkSXbp0yTu1DY4LlJlZhYjg/fff5y9/+Qvvv/8+06dPZ+DAgXmntUFygTIzqyCJTp068aMf/Yg99tjDxSlHLlBmZk0YOXLkhzfpWj7yWLCwr6Q/SXpS0hOSTkvxLSXdLemZ9Ni94pyxkuZLmifp4Ir47pLmpH2/lj9NZtZG/Ockf3mM4lsBfC8idgKGAadKGgSMAaZHxEBgenpO2jcC2BkYDlwsqUN6rQlAPdkaUQPTfjMzawfyWLDw1Yj4W9peCjwJ9AYOByanwyYDR6Ttw4FrI2J5RDxPtvbTnmnV3W4RMTOyNUOurDjHzMxKLtf7oCT1B3YDHgC2Tqvkkh63Sof1BhZUnLYwxXqn7cZxMzNrB3IbJCFpM+BG4PSIeLuZ/t6mdkQz8aZ+Vz1ZVyD9+vVrfbJmVnpFXWwRqrPgYnuQSwtK0sZkxemaiLgphV9L3Xakx9dTfCHQt+L0PsArKd6nifhHRMTEiBgaEUPr6ura7o2YmVnV5DGKT8BlwJMRcUHFrluBkWl7JHBLRXyEpE0kDSAbDDErdQMulTQsvebxFeeYmVnJ5dHFty/wb8AcSY+k2NnAucD1kk4CXgKOBoiIJyRdD8wlGwF4akSsTOeNAiYBXYBp6cfMzNqBmheoiLiPpq8fARy4hnPGAeOaiM8GBrdddmZmVhSezdzWWzbK38ysbXmqI2u1e+65h2effRaAk08+2Xfcm1lVuAVlrTJt2jRGjx7NkiVLuOaaa5gyZcqH+9ySMrO25BaUtdiyZcsYP3485513HocccgidO3cGYPbs2QwdOhRJRIRbVGbWJlygrFV69eoFwCOPPML555/PXnvtxYIFC+jVqxc33niji5OZtRl38dlaPf300wBsuumm7LrrrkyaNIn6+nqOOeYYrrvuOu6//34WLFiwWnefmdn6coGyZk2dOpVdd92VESNGAHD66aczefJkvvWtb/GFL3zhw+M++9nPsvHGG+eVppm1Qy5QtkbLli3joosuYvz48XTu3Jmvfe1rAHTt2pWI4MQTT2TWrFlMnDiRu+++myFDhuScsZm1J74GZWu06aabcvnll9OtWzeOPPJITjnlFI477jiuueYaRo4cyUsvvcT48eN5++23ueqqq9hhhx3yTtnM2hEXKGvWNttsA8Bmm23GpZdeSn19PSNGjODaa6/luOOO4+2332bQoEF06tQp50zNrL1xF5+1WI8ePbj00kvp0qULO+ywAwcffDA9e/Z0cTKzqnCBslbp2bMnQ4YM4e233+amm26iT58+az/JzGwduEBZqyxevJg77riDu+66i1122SXvdMysHSt9gZI0XNI8SfMljck7n/aue/fu3HbbbR6xZ2ZVV+oCJakD8N/AF4FBwLGSBuWbVfvXMMWRmVk1lbpAAXsC8yPiuYh4D7gWODznnMzMrA2UvUD1BhZUPF+YYmZmVnJlvw+qqZlJP7Lmg6R6oD49/T9J86qaVcv1BN7IO4n14Pzz5fwTndcWr9Iqbfrfvuz5t4E7I2J442DZC9RCoG/F8z7AK40PioiJwMRaJdVSkmZHxNC881hXzj9fzj8/Zc4dypN/2bv4HgQGShogqRMwArg155zMzKwNlLoFFRErJH0L+APQAbg8Ip7IOS0zM2sDpS5QABFxB3BH3nmso8J1O7aS88+X889PmXOHkuSviI+MKTAzM8td2a9BmZlZO+UCZWZmhVT6a1BlIGnL5vZHxD9qlYuVj6RPN7c/Iv5Wq1zMasnXoGpA0vNkNxAL6AcsTttbAC9FxID8sms5SVsDPwe2iYgvpnkP946Iy3JOrUUk1QEnA/2p+HIWESfmlVNLSPpT2uwMDAUeJfv8DAEeiIjP5JVba0jaAZgAbB0RgyUNAb4UET/LObW1SrmfCXyC1T87B+SWVCtJGgY8ERFL0/OPAYMi4oF8M1szF6gaknQJcGsaeYikLwKfj4jv5ZtZy0iaBlwB/CAiPiWpI/BwRJRi3Q1J9wN/AR4CVjbEI+LG3JJqBUnXAuMiYk56Phg4IyJOyDWxFpI0g+yP/KURsVuKPR4Rg/PNbO0kPQpcwkc/Ow/lllQrSXoY+HSkP/qSNgJmR0SzLfQ8uYuvtvaIiFMankTENEk/zTOhVuoZEddLGgsf3oe2cm0nFUjXiDgr7yTWwycbihNARDwuadcc82mtrhExS1pthrIVeSXTSisiYkLeSawnRUWLJCI+SF8yC8uDJGrrDUk/lNRf0ick/QB4M++kWmGZpB6k+Q5Tl8GSfFNqlamS/jXvJNbDk5J+J+mzkvaX9FvgybyTaoU3JG3Hqs/PUcCr+abUYrdJ+qakXpK2bPjJO6lWek7SaEkbp5/TgOfyTqo57uKrofSBPgfYL4XuBX5SlkES6WL9b4DBwONAHXB0RDyaa2ItJGkpsCnwXvoREBHRLdfEWkhSZ2AUq39+JkTEP/PLquUkbUt2g+g+ZNdhnweOi4gXc02sBdJ15MYiIrateTLrSNJWwK+BA8i+JEwHTo+I13NNrBkuUNZikjYh63/fkeyP+zxgo4hYnmtiVgqSBkTE85I2JfvcLG2I5Z2bFZMLVA2lUWTfB3YmG5EFlGckkKS/Nb6g2lSsqJRd/DgOGBARP5XUF+gVEbNyTq1FJA0EfkG2enTl56cU3+LX8Pl5KCJ2zyunlpLUFfgu0C8i6tP/ix0jYmrOqbVYGUexFvoCWTt0DXAdcChwCjASWJRrRi0g6eNkC0F2kbQbq9bh6gZ0zS2x1rsY+ICsi+OnwP8B/w3skWdSrXAFWRfxhcDngG/Q9JpohSLpk2RfyjaXdGTFrm5UFNqCu4JsBN8+6flC4PdAaQoUcAvZKNY/UjESschcoGqrR0RcJum0iJgBzEhDb4vuYOAEsvW2LqiILwXOziOhdbRXRHw6DbclIhanZVrKoktETJekdN3mx5L+Qla0imxHsi9lWwCHVcSXkn2jL4PtIuKrko4FiIh31Wg4YgmUbhSrC1RtvZ8eX5V0CNniin1yzKdFImIyMFnSV8pyz9AavC+pA6tGkdWRtajK4p/p3pVn0jIzLwNb5ZzTWkXELcAtkvaOiJl557OO3pPUhVWfne2Asl17nSrpXxvuwywDX4OqIUmHkjWx+5KNhutGNoqv0IssSvp6RFwt6Xukf6CVIuKCJk4rHEnHAV8FdgcmAUcBP4yI3+eZV0tJ2oNsWPkWZF2U3YBfRcRf88xrbSR9PyJ+Kek3NP35GZ1DWq0i6SDgh2TX/+4C9gVOiIg/55lXa1SMYl1O9mW58KNY3YKqoYoLqkvIriGUxabpcbNcs1hPEXGNpIeAA1PoiIgozX1EEfEgQNbDF9/IO59WaPhvPDvXLNZDRNwt6W/AMLI/7KdFxBs5p9UqEfGxvHNoLReoGirrXGQRcWnqGns7Ii7MO5/11JVs9eUAuuScS6tI2hu4jOyLQj9JnwL+PSK+mW9mzYuI29LnZ3BEnJl3Puthf+AzZJ+djYGb802ndSTdAFwO3BkRpeja9kwStfVbYCzpWlREPAaMyDWjFoqIlcCX8s5jfUj6D2AysCXQE7hC0g/zzapVxpMNWHkTIN0gvV9zJxRF+vwUfjj5mki6mGzk7Ryym9T/XdJ/55tVq11CdpvFM5LOTaMrC80tqNoq81xkAPdLuohsqPyyhmCJlns4FtitYeYFSecCfwMK3YKtFBELGn1+SjFcOHlY0q1kw7MrPz835ZdSi+1P1gJsGCQxmaxYlUZE/BH4o6TNyf4t3C1pAdkX56sj4v1mXyAHLlC1Vea5yGDVPSD/WRELsvuKyuAFsvtuGqYG2gR4NrdsWm+BpH2ASMPjR1Ouufi2JGv9VX5eAihDgZpHtlROw7RMfYHH8ktn3aS5NL8O/BvwMNm9mZ8huyfzs/ll1jSP4quhss5FJul04H/JltYoU4tvNZL+h+ym3LvJ/jAeBNwHvA7FH00mqSfwX8DnyS7U3wWMLvpcjpLGk31+7o+Il3NOZ52k+xX3ABpmHdkDmAm8AxARhe/+lnQT8EngKuCKiPh7xb7ZETE0t+TWwAUqBw1zkQHvAl+NiGtyTqlZks4nK6qfJPvWeD/ZH5yZRf/jWEnSyOb2p/u9SkNSd+CbETEu71yak+7Z2odVLfCGz8/9wKNluGAvaf/m9qcb7wsp3Z6wENgpIu5J/w6OJGsN/rjI/4ZdoGpAUjfgVLLpgm4hm2rkVOAMsn+gh+eYXoulbqWhZH9o9k4/b0XEoFwTa6E0G/j2ZK2nZ0s0C3hf4EfANmQjx6aQdbMeD0yJiNNyTK9VJPUiu4doH+BwoK7I9+E0kDSAbLqmAJ6MiEIvU1EpDY//fET8Q9J+wLXAt4FdyYrWUXnm1xxfg6qNq8i69GaSTe3yfaAT2X04j+SYV2t1Ibs5dPP08woluFCsbFG2nwMnkn1r3AjoI6lhdeDCXRxu5EpgBnAjMBz4K/AEMKSym6bI0rRAu5AVpn3Jbnh9huy9FVb6cvk7shGIj5J1rX4q3U93UkS8nWd+LdShopX0VWBimhHmRkmP5JfW2rkFVQOS5kRaFj3dD/IG2azIS/PNrGUkTST79rgUeIDsD+RfI2Jxrom1kKQLgY8B32n4b57+8JwPvFv0FoikRyPiUxXPXyP7/JRiqh1Jd5N9sXmEVZ+dUgzukDSJbHDNfzZ0RaZi+yNg+4g4Pr/sWkbS48Cuka2A/RRQHxH3NuyLiMH5ZrhmbkHVxoff0CNipaTny1Kckn5kI96eIZv/bSHwVp4JtdKhwA4Rqy13/bakUcBTQKELFHx4valhfPnfga7pWiZFvoaQPAd8ChhINorvDUmLSjITw74RcUJlIH2O/lPSM/mk1GpTyCamfoPsuvdfACRtT8FXxHYLqgYkrWTVfR8i6yp7hxLMhdUgfWvcmVUXuwcD/yAbKFHo2bQlPR0RO7R2X1FIeoFsUtumZs+OKM96UN3IpgraJz3WAY9HRLODV/IkaX5EbL+Gfc9ExMBa57QuJA0DegF3RcSyFNsB2KzI9zG6BVUDEdEh7xzWV/rW+Likt8i+dS0ha5nsSfGXe5gr6fiIWO16h6Svk7WgCi0i+uedQxtZTvbF7N203YfsWmyR/W+ageSnlS1wST8i664shaYmFI6Ip/PIpTXcgrK1kjSaVRe33ycNMU+Pc4o+TFhSb7KbQd8lW3QuyO5j6QJ8uaz35pRFuga4D1kX3yNkw8vvJ7sv6q38Mlu71Oq7DPg0We4B7EZ2k+tJEVHoLrKyc4GytZJ0AenelYgo08wXq5F0AFk3pYAnImJ6ziltENIXnPvJbvQu09RMH0ozwAxi1WenTDOQlJYLlJmZFZJnMzczs0JygcpZusfIbJ1Imrr2o8zKyV18OZO0e0Q8lHceVk6SepX5uqBZc9yCylnZi1PZW4Blz7/sxanMLcAy514WbkHVgKTbSGtANaUMU/WvSdlbgGXIX9Icmv78NNzoPaTGKbWZMrcAy5x7WbhA1UDFVP1HAh8Hrk7PjwVeiIizc0nMSkHSJ5rbX/T1xMzWlQtUDUm6NyL2W1usaMreAix7/pUkbU12kzHArIh4Pc98WqLMLcAy594eeKqj2qqTtG3DWjJpjZm6nHNqifPTY5MtwDwSaqWy5w+ApGOAXwF/JvsD+RtJZ0bEDbkmtnaH5p3Aeihz7qXnFlQNSRpOtuR7w2Jn/YF/j4g/5JZUK5S1BdigHeT/KHBQQ6tJUh3wx8qlOIqujC3ABmXOvaw8iq+GIuJOsvnITks/O5alOCV1kj6cObtELcAGZc9/o0Z/FN+kRP+GUwtwFnA0cAzwgKTCruZaqcy5l5m7+Gpvd7KWU0eylTlpPMt2gX0H+LOk1VqA+aXTamXP/05JfyBb3wey1VGn5ZhPa/0A2KNxCxAoehcllDv30nIXXw1JugrYjmxW5IZJMyMiRueWVCtJ2gT4ZHr6VFlWdW3QDvI/EvgM2TWoeyPi5pxTarHKlaXT842ARytjRVXm3MvMBaqGJD0JDIoS/0eXtA+rWoAAZWoBljL/tPLp1hHxv43i+wEvl2VmbUm/AoawegtwTkR8P7+sWqbMuZeZC1QNSfo9MLqsN/eVvQVY1vzTjAVnR8RjjeJDgXMi4rB8Mmu9krcAS5t7WblA1ZCkPwG7kl1s/bBrqSz34ZS9BVjW/CU9HhGD17BvTtG7mcrcAixz7u2BB0nU1o/zTmA9PU52H1EpW4CUN//OzezrUrMs1t14oKnZUt5J+4rcAhxPeXMvPReoGoqIGXnnsJ56AnMllbIFSHnzf1DSyRHx28qgpJPIlrAvuv6NuycBImK2pP455NMaZc699FygakDSUpqfLqVbjVNaVz/OO4H19OO8E1hHpwM3SzqOVQVpKNAJ+HJeSbVCmVuAZc699HwNyqwkJH0OaLgW9URE3JNnPi0laQpwzxpagF+IiK/mk9nalTn39sAFytaq7C3AsudfdmmKoJuB92iiBRgRf88rt7Upc+7tgQuUmdVEWVuAUO7cy8wFyszMCqk0E02amdmGxQXKzMwKyQXKzMwKyQXKzMwKyQXKzMwK6f8D1vnegUbrfZcAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -633,6 +507,7 @@ "source": [ "# Test for plot_opcounts MPI-IO\n", "from darshan.experimental.plots import plot_opcounts\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", "print(acc_MPIIO.summary_record['counters'][\"MPIIO_INDEP_READS\"][0])\n", "darshan.enable_experimental()\n", @@ -642,19 +517,19 @@ { "cell_type": "code", "execution_count": 12, - "id": "0d57a7da", + "id": "591eb3ed", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "-1\n" + "0\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -667,6 +542,7 @@ "source": [ "# Test for plot_opcounts STDIO\n", "from darshan.experimental.plots import plot_opcounts\n", + "posix_recs = report.records['STDIO'].to_df()\n", "acc_STDIO = accumulate_records(posix_recs, \"STDIO\", report.metadata['job']['nprocs'])\n", "print(acc_STDIO.summary_record['counters'][\"STDIO_READS\"][0])\n", "darshan.enable_experimental()\n", @@ -675,7 +551,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, "id": "6881d549", "metadata": {}, "outputs": [ @@ -686,9 +562,9 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/138928280.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdarshan\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0menable_experimental\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/1299849547.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module H5F" ] }, @@ -710,7 +586,7 @@ "from darshan.experimental.plots import plot_opcounts\n", "# acc_H5F = accumulate_records(posix_recs, \"H5F\", report.metadata['job']['nprocs'])\n", "# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\n", - "darshan.enable_experimental()\n", + "# darshan.enable_experimental()\n", "plot_opcounts(report, \"H5F\")" ] }, @@ -727,9 +603,9 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_23155/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 173\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 174\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module PNETCDF_FILE" ] }, @@ -759,7 +635,9 @@ "cell_type": "code", "execution_count": 15, "id": "dece9aaa", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -774,11 +652,249 @@ } ], "source": [ - "# Test for plot_posix_access_pattern\n", + "# Test for plot_posix_access_pattern POSIX\n", "from darshan.experimental.plots import plot_posix_access_pattern\n", "darshan.enable_experimental()\n", + "# print(acc)\n", "plot_posix_access_pattern(acc.summary_record)" ] + }, + { + "cell_type": "markdown", + "id": "e0872862", + "metadata": {}, + "source": [ + "### Second Step\n", + "Modify the plotting code plot_access_histogram( ) (in file darshan/experimental/plots/plot_access_histogram.py) to take a single record as input rather than a report object. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f7b9d300", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Extract data for a specific module (POSIX or MPI-IO)\n", + "# in DataFrame format using the 'records' attribute and\n", + "# the 'to_df()' method\n", + "# NOTE: the returned type here is actually a dictionary, with\n", + "# 2 separate DataFrames: 'counters' (for integer record data)\n", + "# and 'fcounters' (for floating point record data)\n", + "from darshan.experimental.plots import plot_access_histogram\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", + "## Aggregated multiple log files into a single \"summary\" record.\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "## Plotting\n", + "plot_access_histogram(acc_MPIIO.summary_record, \"MPI-IO\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3409d42c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from darshan.experimental.plots import plot_access_histogram\n", + "posix_recs = report.records['POSIX'].to_df()\n", + "acc_MPIIO = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", + "plot_access_histogram(acc_MPIIO.summary_record, \"POSIX\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cb5566d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'version': 1, 'metadata': {'job': {'uid': 69615, 'start_time_sec': 1490000867, 'start_time_nsec': 0, 'end_time_sec': 1490000983, 'end_time_nsec': 0, 'nprocs': 2048, 'jobid': 4478544, 'run_time': 117.0, 'log_ver': '3.10', 'metadata': {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}}, 'exe': '/global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32'}, 'records': {'POSIX': , 'MPI-IO': , 'STDIO': , 'LUSTRE': }, 'summary': {}, 'modules': {'POSIX': {'len': 186, 'ver': 3, 'idx': 1, 'partial_flag': False, 'num_records': 1}, 'MPI-IO': {'len': 154, 'ver': 2, 'idx': 2, 'partial_flag': False, 'num_records': 1}, 'LUSTRE': {'len': 87, 'ver': 1, 'idx': 8, 'partial_flag': False, 'num_records': 1}, 'STDIO': {'len': 3234, 'ver': 1, 'idx': 9, 'partial_flag': False, 'num_records': 129}}, 'counters': {'POSIX': {'counters': ['POSIX_OPENS', 'POSIX_FILENOS', 'POSIX_DUPS', 'POSIX_READS', 'POSIX_WRITES', 'POSIX_SEEKS', 'POSIX_STATS', 'POSIX_MMAPS', 'POSIX_FSYNCS', 'POSIX_FDSYNCS', 'POSIX_RENAME_SOURCES', 'POSIX_RENAME_TARGETS', 'POSIX_RENAMED_FROM', 'POSIX_MODE', 'POSIX_BYTES_READ', 'POSIX_BYTES_WRITTEN', 'POSIX_MAX_BYTE_READ', 'POSIX_MAX_BYTE_WRITTEN', 'POSIX_CONSEC_READS', 'POSIX_CONSEC_WRITES', 'POSIX_SEQ_READS', 'POSIX_SEQ_WRITES', 'POSIX_RW_SWITCHES', 'POSIX_MEM_NOT_ALIGNED', 'POSIX_MEM_ALIGNMENT', 'POSIX_FILE_NOT_ALIGNED', 'POSIX_FILE_ALIGNMENT', 'POSIX_MAX_READ_TIME_SIZE', 'POSIX_MAX_WRITE_TIME_SIZE', 'POSIX_SIZE_READ_0_100', 'POSIX_SIZE_READ_100_1K', 'POSIX_SIZE_READ_1K_10K', 'POSIX_SIZE_READ_10K_100K', 'POSIX_SIZE_READ_100K_1M', 'POSIX_SIZE_READ_1M_4M', 'POSIX_SIZE_READ_4M_10M', 'POSIX_SIZE_READ_10M_100M', 'POSIX_SIZE_READ_100M_1G', 'POSIX_SIZE_READ_1G_PLUS', 'POSIX_SIZE_WRITE_0_100', 'POSIX_SIZE_WRITE_100_1K', 'POSIX_SIZE_WRITE_1K_10K', 'POSIX_SIZE_WRITE_10K_100K', 'POSIX_SIZE_WRITE_100K_1M', 'POSIX_SIZE_WRITE_1M_4M', 'POSIX_SIZE_WRITE_4M_10M', 'POSIX_SIZE_WRITE_10M_100M', 'POSIX_SIZE_WRITE_100M_1G', 'POSIX_SIZE_WRITE_1G_PLUS', 'POSIX_STRIDE1_STRIDE', 'POSIX_STRIDE2_STRIDE', 'POSIX_STRIDE3_STRIDE', 'POSIX_STRIDE4_STRIDE', 'POSIX_STRIDE1_COUNT', 'POSIX_STRIDE2_COUNT', 'POSIX_STRIDE3_COUNT', 'POSIX_STRIDE4_COUNT', 'POSIX_ACCESS1_ACCESS', 'POSIX_ACCESS2_ACCESS', 'POSIX_ACCESS3_ACCESS', 'POSIX_ACCESS4_ACCESS', 'POSIX_ACCESS1_COUNT', 'POSIX_ACCESS2_COUNT', 'POSIX_ACCESS3_COUNT', 'POSIX_ACCESS4_COUNT', 'POSIX_FASTEST_RANK', 'POSIX_FASTEST_RANK_BYTES', 'POSIX_SLOWEST_RANK', 'POSIX_SLOWEST_RANK_BYTES'], 'fcounters': ['POSIX_F_OPEN_START_TIMESTAMP', 'POSIX_F_READ_START_TIMESTAMP', 'POSIX_F_WRITE_START_TIMESTAMP', 'POSIX_F_CLOSE_START_TIMESTAMP', 'POSIX_F_OPEN_END_TIMESTAMP', 'POSIX_F_READ_END_TIMESTAMP', 'POSIX_F_WRITE_END_TIMESTAMP', 'POSIX_F_CLOSE_END_TIMESTAMP', 'POSIX_F_READ_TIME', 'POSIX_F_WRITE_TIME', 'POSIX_F_META_TIME', 'POSIX_F_MAX_READ_TIME', 'POSIX_F_MAX_WRITE_TIME', 'POSIX_F_FASTEST_RANK_TIME', 'POSIX_F_SLOWEST_RANK_TIME', 'POSIX_F_VARIANCE_RANK_TIME', 'POSIX_F_VARIANCE_RANK_BYTES']}, 'MPI-IO': {'counters': ['MPIIO_INDEP_OPENS', 'MPIIO_COLL_OPENS', 'MPIIO_INDEP_READS', 'MPIIO_INDEP_WRITES', 'MPIIO_COLL_READS', 'MPIIO_COLL_WRITES', 'MPIIO_SPLIT_READS', 'MPIIO_SPLIT_WRITES', 'MPIIO_NB_READS', 'MPIIO_NB_WRITES', 'MPIIO_SYNCS', 'MPIIO_HINTS', 'MPIIO_VIEWS', 'MPIIO_MODE', 'MPIIO_BYTES_READ', 'MPIIO_BYTES_WRITTEN', 'MPIIO_RW_SWITCHES', 'MPIIO_MAX_READ_TIME_SIZE', 'MPIIO_MAX_WRITE_TIME_SIZE', 'MPIIO_SIZE_READ_AGG_0_100', 'MPIIO_SIZE_READ_AGG_100_1K', 'MPIIO_SIZE_READ_AGG_1K_10K', 'MPIIO_SIZE_READ_AGG_10K_100K', 'MPIIO_SIZE_READ_AGG_100K_1M', 'MPIIO_SIZE_READ_AGG_1M_4M', 'MPIIO_SIZE_READ_AGG_4M_10M', 'MPIIO_SIZE_READ_AGG_10M_100M', 'MPIIO_SIZE_READ_AGG_100M_1G', 'MPIIO_SIZE_READ_AGG_1G_PLUS', 'MPIIO_SIZE_WRITE_AGG_0_100', 'MPIIO_SIZE_WRITE_AGG_100_1K', 'MPIIO_SIZE_WRITE_AGG_1K_10K', 'MPIIO_SIZE_WRITE_AGG_10K_100K', 'MPIIO_SIZE_WRITE_AGG_100K_1M', 'MPIIO_SIZE_WRITE_AGG_1M_4M', 'MPIIO_SIZE_WRITE_AGG_4M_10M', 'MPIIO_SIZE_WRITE_AGG_10M_100M', 'MPIIO_SIZE_WRITE_AGG_100M_1G', 'MPIIO_SIZE_WRITE_AGG_1G_PLUS', 'MPIIO_ACCESS1_ACCESS', 'MPIIO_ACCESS2_ACCESS', 'MPIIO_ACCESS3_ACCESS', 'MPIIO_ACCESS4_ACCESS', 'MPIIO_ACCESS1_COUNT', 'MPIIO_ACCESS2_COUNT', 'MPIIO_ACCESS3_COUNT', 'MPIIO_ACCESS4_COUNT', 'MPIIO_FASTEST_RANK', 'MPIIO_FASTEST_RANK_BYTES', 'MPIIO_SLOWEST_RANK', 'MPIIO_SLOWEST_RANK_BYTES'], 'fcounters': ['MPIIO_F_OPEN_START_TIMESTAMP', 'MPIIO_F_READ_START_TIMESTAMP', 'MPIIO_F_WRITE_START_TIMESTAMP', 'MPIIO_F_CLOSE_START_TIMESTAMP', 'MPIIO_F_OPEN_END_TIMESTAMP', 'MPIIO_F_READ_END_TIMESTAMP', 'MPIIO_F_WRITE_END_TIMESTAMP', 'MPIIO_F_CLOSE_END_TIMESTAMP', 'MPIIO_F_READ_TIME', 'MPIIO_F_WRITE_TIME', 'MPIIO_F_META_TIME', 'MPIIO_F_MAX_READ_TIME', 'MPIIO_F_MAX_WRITE_TIME', 'MPIIO_F_FASTEST_RANK_TIME', 'MPIIO_F_SLOWEST_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_BYTES']}, 'STDIO': {'counters': ['STDIO_OPENS', 'STDIO_FDOPENS', 'STDIO_READS', 'STDIO_WRITES', 'STDIO_SEEKS', 'STDIO_FLUSHES', 'STDIO_BYTES_WRITTEN', 'STDIO_BYTES_READ', 'STDIO_MAX_BYTE_READ', 'STDIO_MAX_BYTE_WRITTEN', 'STDIO_FASTEST_RANK', 'STDIO_FASTEST_RANK_BYTES', 'STDIO_SLOWEST_RANK', 'STDIO_SLOWEST_RANK_BYTES'], 'fcounters': ['STDIO_F_META_TIME', 'STDIO_F_WRITE_TIME', 'STDIO_F_READ_TIME', 'STDIO_F_OPEN_START_TIMESTAMP', 'STDIO_F_CLOSE_START_TIMESTAMP', 'STDIO_F_WRITE_START_TIMESTAMP', 'STDIO_F_READ_START_TIMESTAMP', 'STDIO_F_OPEN_END_TIMESTAMP', 'STDIO_F_CLOSE_END_TIMESTAMP', 'STDIO_F_WRITE_END_TIMESTAMP', 'STDIO_F_READ_END_TIMESTAMP', 'STDIO_F_FASTEST_RANK_TIME', 'STDIO_F_SLOWEST_RANK_TIME', 'STDIO_F_VARIANCE_RANK_TIME', 'STDIO_F_VARIANCE_RANK_BYTES']}, 'LUSTRE': {'counters': ['LUSTRE_OSTS', 'LUSTRE_MDTS', 'LUSTRE_STRIPE_OFFSET', 'LUSTRE_STRIPE_SIZE', 'LUSTRE_STRIPE_WIDTH']}}, 'name_records': {14734109647742566553: '', 15920181672442173319: '', 7238257241479193519: '', 6301063301082038805: '/scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5'}, 'mounts': [('/.shared/base/default/etc/dat.conf', 'dvs'), ('/usr/lib64/libibverbs.so.1.0.0', 'dvs'), ('/usr/lib64/librdmacm.so.1.0.0', 'dvs'), ('/usr/lib64/libibumad.so.3.0.2', 'dvs'), ('/usr/lib64/libibgni.so.1.0.0', 'dvs'), ('/global/cscratch1', 'lustre'), ('/global/projectb', 'dvs'), ('/global/projecta', 'dvs'), ('/usr/sbin/ibstat', 'dvs'), ('/global/project', 'dvs'), ('/global/common', 'dvs'), ('/global/syscom', 'dvs'), ('/global/dna', 'dvs'), ('/global/u2', 'dvs'), ('/opt/slurm', 'dvs'), ('/global/u1', 'dvs'), ('/scratch1', 'lustre'), ('/scratch3', 'lustre'), ('/scratch2', 'lustre'), ('/etc', 'dvs'), ('/', 'rootfs'), ('/', 'dvs')]}\n" + ] + } + ], + "source": [ + "# print(report.mod_agg_iohist, end=\"\\n\\n\")\n", + "# print(report.records, end=\"\\n\\n\")\n", + "# print(report.summary, end=\"\\n\\n\")\n", + "# print(dir(report.summary), end=\"\\n\\n\")\n", + "# print(dir(report.mod_agg_iohist), end=\"\\n\\n\")\n", + "print(report.data)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "bfeefac6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "READ:\n", + "0\n", + "WRITE:\n", + "4\n" + ] + } + ], + "source": [ + "from darshan.experimental.plots import plot_access_histogram\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "print(\"READ:\")\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_0_100'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100_1K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1K_10K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_10K_100K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100K_1M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1M_4M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_4M_10M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_10M_100M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100M_1G'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1G_PLUS'][0]) \n", + "print(\"WRITE:\") \n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_0_100'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100_1K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1K_10K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_10K_100K'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100K_1M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1M_4M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_4M_10M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_10M_100M'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100M_1G'][0])\n", + "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1G_PLUS'][0]) " + ] + }, + { + "cell_type": "markdown", + "id": "f652d5bf", + "metadata": {}, + "source": [ + "### Third Step\n", + "Modify the plotting code plot_common_access_table( ) (in file darshan/experimental/plots/plot_common_access_table.py) to take a single record as input rather than a report object.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4e33d65b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "134217728\n", + "16384\n", + "\n" + ] + } + ], + "source": [ + "from darshan.experimental.plots import plot_common_access_table\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'][0])\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_COUNT'][0])\n", + "print(type(acc_MPIIO.summary_record))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "e5feae5d", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'module' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/234895852.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0macc_MPIIO\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccumulate_records\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mposix_recs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreport\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'job'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'nprocs'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m## Plotting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable" + ] + } + ], + "source": [ + "## Extract data for a specific module (POSIX or MPI-IO)\n", + "# in DataFrame format using the 'records' attribute and\n", + "# the 'to_df()' method\n", + "# NOTE: the returned type here is actually a dictionary, with\n", + "# 2 separate DataFrames: 'counters' (for integer record data)\n", + "# and 'fcounters' (for floating point record data)\n", + "from darshan.experimental.plots import plot_common_access_table\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", + "## Aggregated multiple log files into a single \"summary\" record.\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "## Plotting\n", + "plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "8aa13558", + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "'module' object is not callable", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/1553793853.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0macc_MPIIO\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccumulate_records\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mposix_recs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreport\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'job'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'nprocs'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m## Plotting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable" + ] + } + ], + "source": [ + "from darshan.experimental.plots import plot_common_access_table\n", + "posix_recs = report.records['POSIX'].to_df()\n", + "## Aggregated multiple log files into a single \"summary\" record.\n", + "acc_MPIIO = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", + "## Plotting\n", + "plot_common_access_table(acc_MPIIO.summary_record, \"POSIX\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0d45b369", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -808,9 +924,14 @@ "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, - "toc_position": {}, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "165px" + }, "toc_section_display": true, - "toc_window_display": false + "toc_window_display": true } }, "nbformat": 4, From 0097625c1b3452887f3a818aee1fad5ccd646583 Mon Sep 17 00:00:00 2001 From: Yanli Date: Mon, 26 Jun 2023 11:44:14 -0600 Subject: [PATCH 06/11] update multi-log-scratchpad.ipynb --- .../examples/multi-log-scratchpad.ipynb | 214 ++++++++++++++---- 1 file changed, 171 insertions(+), 43 deletions(-) diff --git a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb index dab03f01a..c474860e5 100644 --- a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb +++ b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb @@ -128,10 +128,10 @@ { "data": { "text/plain": [ - "{'POSIX': ,\n", - " 'MPI-IO': ,\n", - " 'STDIO': ,\n", - " 'LUSTRE': }" + "{'POSIX': ,\n", + " 'MPI-IO': ,\n", + " 'STDIO': ,\n", + " 'LUSTRE': }" ] }, "execution_count": 3, @@ -164,7 +164,7 @@ "Loaded Records: {'POSIX': 1, 'MPI-IO': 1, 'STDIO': 129, 'LUSTRE': 1}\n", "Name Records: 4\n", "Darshan/Hints: {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}\n", - "DarshanReport: id(140591674498928) (tmp)\n" + "DarshanReport: id(140494821728112) (tmp)\n" ] } ], @@ -308,7 +308,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'POSIX'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: 'DarshanReport' object is not subscriptable" @@ -562,7 +562,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/1299849547.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/1299849547.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module H5F" @@ -603,7 +603,7 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module PNETCDF_FILE" @@ -736,7 +736,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'version': 1, 'metadata': {'job': {'uid': 69615, 'start_time_sec': 1490000867, 'start_time_nsec': 0, 'end_time_sec': 1490000983, 'end_time_nsec': 0, 'nprocs': 2048, 'jobid': 4478544, 'run_time': 117.0, 'log_ver': '3.10', 'metadata': {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}}, 'exe': '/global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32'}, 'records': {'POSIX': , 'MPI-IO': , 'STDIO': , 'LUSTRE': }, 'summary': {}, 'modules': {'POSIX': {'len': 186, 'ver': 3, 'idx': 1, 'partial_flag': False, 'num_records': 1}, 'MPI-IO': {'len': 154, 'ver': 2, 'idx': 2, 'partial_flag': False, 'num_records': 1}, 'LUSTRE': {'len': 87, 'ver': 1, 'idx': 8, 'partial_flag': False, 'num_records': 1}, 'STDIO': {'len': 3234, 'ver': 1, 'idx': 9, 'partial_flag': False, 'num_records': 129}}, 'counters': {'POSIX': {'counters': ['POSIX_OPENS', 'POSIX_FILENOS', 'POSIX_DUPS', 'POSIX_READS', 'POSIX_WRITES', 'POSIX_SEEKS', 'POSIX_STATS', 'POSIX_MMAPS', 'POSIX_FSYNCS', 'POSIX_FDSYNCS', 'POSIX_RENAME_SOURCES', 'POSIX_RENAME_TARGETS', 'POSIX_RENAMED_FROM', 'POSIX_MODE', 'POSIX_BYTES_READ', 'POSIX_BYTES_WRITTEN', 'POSIX_MAX_BYTE_READ', 'POSIX_MAX_BYTE_WRITTEN', 'POSIX_CONSEC_READS', 'POSIX_CONSEC_WRITES', 'POSIX_SEQ_READS', 'POSIX_SEQ_WRITES', 'POSIX_RW_SWITCHES', 'POSIX_MEM_NOT_ALIGNED', 'POSIX_MEM_ALIGNMENT', 'POSIX_FILE_NOT_ALIGNED', 'POSIX_FILE_ALIGNMENT', 'POSIX_MAX_READ_TIME_SIZE', 'POSIX_MAX_WRITE_TIME_SIZE', 'POSIX_SIZE_READ_0_100', 'POSIX_SIZE_READ_100_1K', 'POSIX_SIZE_READ_1K_10K', 'POSIX_SIZE_READ_10K_100K', 'POSIX_SIZE_READ_100K_1M', 'POSIX_SIZE_READ_1M_4M', 'POSIX_SIZE_READ_4M_10M', 'POSIX_SIZE_READ_10M_100M', 'POSIX_SIZE_READ_100M_1G', 'POSIX_SIZE_READ_1G_PLUS', 'POSIX_SIZE_WRITE_0_100', 'POSIX_SIZE_WRITE_100_1K', 'POSIX_SIZE_WRITE_1K_10K', 'POSIX_SIZE_WRITE_10K_100K', 'POSIX_SIZE_WRITE_100K_1M', 'POSIX_SIZE_WRITE_1M_4M', 'POSIX_SIZE_WRITE_4M_10M', 'POSIX_SIZE_WRITE_10M_100M', 'POSIX_SIZE_WRITE_100M_1G', 'POSIX_SIZE_WRITE_1G_PLUS', 'POSIX_STRIDE1_STRIDE', 'POSIX_STRIDE2_STRIDE', 'POSIX_STRIDE3_STRIDE', 'POSIX_STRIDE4_STRIDE', 'POSIX_STRIDE1_COUNT', 'POSIX_STRIDE2_COUNT', 'POSIX_STRIDE3_COUNT', 'POSIX_STRIDE4_COUNT', 'POSIX_ACCESS1_ACCESS', 'POSIX_ACCESS2_ACCESS', 'POSIX_ACCESS3_ACCESS', 'POSIX_ACCESS4_ACCESS', 'POSIX_ACCESS1_COUNT', 'POSIX_ACCESS2_COUNT', 'POSIX_ACCESS3_COUNT', 'POSIX_ACCESS4_COUNT', 'POSIX_FASTEST_RANK', 'POSIX_FASTEST_RANK_BYTES', 'POSIX_SLOWEST_RANK', 'POSIX_SLOWEST_RANK_BYTES'], 'fcounters': ['POSIX_F_OPEN_START_TIMESTAMP', 'POSIX_F_READ_START_TIMESTAMP', 'POSIX_F_WRITE_START_TIMESTAMP', 'POSIX_F_CLOSE_START_TIMESTAMP', 'POSIX_F_OPEN_END_TIMESTAMP', 'POSIX_F_READ_END_TIMESTAMP', 'POSIX_F_WRITE_END_TIMESTAMP', 'POSIX_F_CLOSE_END_TIMESTAMP', 'POSIX_F_READ_TIME', 'POSIX_F_WRITE_TIME', 'POSIX_F_META_TIME', 'POSIX_F_MAX_READ_TIME', 'POSIX_F_MAX_WRITE_TIME', 'POSIX_F_FASTEST_RANK_TIME', 'POSIX_F_SLOWEST_RANK_TIME', 'POSIX_F_VARIANCE_RANK_TIME', 'POSIX_F_VARIANCE_RANK_BYTES']}, 'MPI-IO': {'counters': ['MPIIO_INDEP_OPENS', 'MPIIO_COLL_OPENS', 'MPIIO_INDEP_READS', 'MPIIO_INDEP_WRITES', 'MPIIO_COLL_READS', 'MPIIO_COLL_WRITES', 'MPIIO_SPLIT_READS', 'MPIIO_SPLIT_WRITES', 'MPIIO_NB_READS', 'MPIIO_NB_WRITES', 'MPIIO_SYNCS', 'MPIIO_HINTS', 'MPIIO_VIEWS', 'MPIIO_MODE', 'MPIIO_BYTES_READ', 'MPIIO_BYTES_WRITTEN', 'MPIIO_RW_SWITCHES', 'MPIIO_MAX_READ_TIME_SIZE', 'MPIIO_MAX_WRITE_TIME_SIZE', 'MPIIO_SIZE_READ_AGG_0_100', 'MPIIO_SIZE_READ_AGG_100_1K', 'MPIIO_SIZE_READ_AGG_1K_10K', 'MPIIO_SIZE_READ_AGG_10K_100K', 'MPIIO_SIZE_READ_AGG_100K_1M', 'MPIIO_SIZE_READ_AGG_1M_4M', 'MPIIO_SIZE_READ_AGG_4M_10M', 'MPIIO_SIZE_READ_AGG_10M_100M', 'MPIIO_SIZE_READ_AGG_100M_1G', 'MPIIO_SIZE_READ_AGG_1G_PLUS', 'MPIIO_SIZE_WRITE_AGG_0_100', 'MPIIO_SIZE_WRITE_AGG_100_1K', 'MPIIO_SIZE_WRITE_AGG_1K_10K', 'MPIIO_SIZE_WRITE_AGG_10K_100K', 'MPIIO_SIZE_WRITE_AGG_100K_1M', 'MPIIO_SIZE_WRITE_AGG_1M_4M', 'MPIIO_SIZE_WRITE_AGG_4M_10M', 'MPIIO_SIZE_WRITE_AGG_10M_100M', 'MPIIO_SIZE_WRITE_AGG_100M_1G', 'MPIIO_SIZE_WRITE_AGG_1G_PLUS', 'MPIIO_ACCESS1_ACCESS', 'MPIIO_ACCESS2_ACCESS', 'MPIIO_ACCESS3_ACCESS', 'MPIIO_ACCESS4_ACCESS', 'MPIIO_ACCESS1_COUNT', 'MPIIO_ACCESS2_COUNT', 'MPIIO_ACCESS3_COUNT', 'MPIIO_ACCESS4_COUNT', 'MPIIO_FASTEST_RANK', 'MPIIO_FASTEST_RANK_BYTES', 'MPIIO_SLOWEST_RANK', 'MPIIO_SLOWEST_RANK_BYTES'], 'fcounters': ['MPIIO_F_OPEN_START_TIMESTAMP', 'MPIIO_F_READ_START_TIMESTAMP', 'MPIIO_F_WRITE_START_TIMESTAMP', 'MPIIO_F_CLOSE_START_TIMESTAMP', 'MPIIO_F_OPEN_END_TIMESTAMP', 'MPIIO_F_READ_END_TIMESTAMP', 'MPIIO_F_WRITE_END_TIMESTAMP', 'MPIIO_F_CLOSE_END_TIMESTAMP', 'MPIIO_F_READ_TIME', 'MPIIO_F_WRITE_TIME', 'MPIIO_F_META_TIME', 'MPIIO_F_MAX_READ_TIME', 'MPIIO_F_MAX_WRITE_TIME', 'MPIIO_F_FASTEST_RANK_TIME', 'MPIIO_F_SLOWEST_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_BYTES']}, 'STDIO': {'counters': ['STDIO_OPENS', 'STDIO_FDOPENS', 'STDIO_READS', 'STDIO_WRITES', 'STDIO_SEEKS', 'STDIO_FLUSHES', 'STDIO_BYTES_WRITTEN', 'STDIO_BYTES_READ', 'STDIO_MAX_BYTE_READ', 'STDIO_MAX_BYTE_WRITTEN', 'STDIO_FASTEST_RANK', 'STDIO_FASTEST_RANK_BYTES', 'STDIO_SLOWEST_RANK', 'STDIO_SLOWEST_RANK_BYTES'], 'fcounters': ['STDIO_F_META_TIME', 'STDIO_F_WRITE_TIME', 'STDIO_F_READ_TIME', 'STDIO_F_OPEN_START_TIMESTAMP', 'STDIO_F_CLOSE_START_TIMESTAMP', 'STDIO_F_WRITE_START_TIMESTAMP', 'STDIO_F_READ_START_TIMESTAMP', 'STDIO_F_OPEN_END_TIMESTAMP', 'STDIO_F_CLOSE_END_TIMESTAMP', 'STDIO_F_WRITE_END_TIMESTAMP', 'STDIO_F_READ_END_TIMESTAMP', 'STDIO_F_FASTEST_RANK_TIME', 'STDIO_F_SLOWEST_RANK_TIME', 'STDIO_F_VARIANCE_RANK_TIME', 'STDIO_F_VARIANCE_RANK_BYTES']}, 'LUSTRE': {'counters': ['LUSTRE_OSTS', 'LUSTRE_MDTS', 'LUSTRE_STRIPE_OFFSET', 'LUSTRE_STRIPE_SIZE', 'LUSTRE_STRIPE_WIDTH']}}, 'name_records': {14734109647742566553: '', 15920181672442173319: '', 7238257241479193519: '', 6301063301082038805: '/scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5'}, 'mounts': [('/.shared/base/default/etc/dat.conf', 'dvs'), ('/usr/lib64/libibverbs.so.1.0.0', 'dvs'), ('/usr/lib64/librdmacm.so.1.0.0', 'dvs'), ('/usr/lib64/libibumad.so.3.0.2', 'dvs'), ('/usr/lib64/libibgni.so.1.0.0', 'dvs'), ('/global/cscratch1', 'lustre'), ('/global/projectb', 'dvs'), ('/global/projecta', 'dvs'), ('/usr/sbin/ibstat', 'dvs'), ('/global/project', 'dvs'), ('/global/common', 'dvs'), ('/global/syscom', 'dvs'), ('/global/dna', 'dvs'), ('/global/u2', 'dvs'), ('/opt/slurm', 'dvs'), ('/global/u1', 'dvs'), ('/scratch1', 'lustre'), ('/scratch3', 'lustre'), ('/scratch2', 'lustre'), ('/etc', 'dvs'), ('/', 'rootfs'), ('/', 'dvs')]}\n" + "{'version': 1, 'metadata': {'job': {'uid': 69615, 'start_time_sec': 1490000867, 'start_time_nsec': 0, 'end_time_sec': 1490000983, 'end_time_nsec': 0, 'nprocs': 2048, 'jobid': 4478544, 'run_time': 117.0, 'log_ver': '3.10', 'metadata': {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}}, 'exe': '/global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32'}, 'records': {'POSIX': , 'MPI-IO': , 'STDIO': , 'LUSTRE': }, 'summary': {}, 'modules': {'POSIX': {'len': 186, 'ver': 3, 'idx': 1, 'partial_flag': False, 'num_records': 1}, 'MPI-IO': {'len': 154, 'ver': 2, 'idx': 2, 'partial_flag': False, 'num_records': 1}, 'LUSTRE': {'len': 87, 'ver': 1, 'idx': 8, 'partial_flag': False, 'num_records': 1}, 'STDIO': {'len': 3234, 'ver': 1, 'idx': 9, 'partial_flag': False, 'num_records': 129}}, 'counters': {'POSIX': {'counters': ['POSIX_OPENS', 'POSIX_FILENOS', 'POSIX_DUPS', 'POSIX_READS', 'POSIX_WRITES', 'POSIX_SEEKS', 'POSIX_STATS', 'POSIX_MMAPS', 'POSIX_FSYNCS', 'POSIX_FDSYNCS', 'POSIX_RENAME_SOURCES', 'POSIX_RENAME_TARGETS', 'POSIX_RENAMED_FROM', 'POSIX_MODE', 'POSIX_BYTES_READ', 'POSIX_BYTES_WRITTEN', 'POSIX_MAX_BYTE_READ', 'POSIX_MAX_BYTE_WRITTEN', 'POSIX_CONSEC_READS', 'POSIX_CONSEC_WRITES', 'POSIX_SEQ_READS', 'POSIX_SEQ_WRITES', 'POSIX_RW_SWITCHES', 'POSIX_MEM_NOT_ALIGNED', 'POSIX_MEM_ALIGNMENT', 'POSIX_FILE_NOT_ALIGNED', 'POSIX_FILE_ALIGNMENT', 'POSIX_MAX_READ_TIME_SIZE', 'POSIX_MAX_WRITE_TIME_SIZE', 'POSIX_SIZE_READ_0_100', 'POSIX_SIZE_READ_100_1K', 'POSIX_SIZE_READ_1K_10K', 'POSIX_SIZE_READ_10K_100K', 'POSIX_SIZE_READ_100K_1M', 'POSIX_SIZE_READ_1M_4M', 'POSIX_SIZE_READ_4M_10M', 'POSIX_SIZE_READ_10M_100M', 'POSIX_SIZE_READ_100M_1G', 'POSIX_SIZE_READ_1G_PLUS', 'POSIX_SIZE_WRITE_0_100', 'POSIX_SIZE_WRITE_100_1K', 'POSIX_SIZE_WRITE_1K_10K', 'POSIX_SIZE_WRITE_10K_100K', 'POSIX_SIZE_WRITE_100K_1M', 'POSIX_SIZE_WRITE_1M_4M', 'POSIX_SIZE_WRITE_4M_10M', 'POSIX_SIZE_WRITE_10M_100M', 'POSIX_SIZE_WRITE_100M_1G', 'POSIX_SIZE_WRITE_1G_PLUS', 'POSIX_STRIDE1_STRIDE', 'POSIX_STRIDE2_STRIDE', 'POSIX_STRIDE3_STRIDE', 'POSIX_STRIDE4_STRIDE', 'POSIX_STRIDE1_COUNT', 'POSIX_STRIDE2_COUNT', 'POSIX_STRIDE3_COUNT', 'POSIX_STRIDE4_COUNT', 'POSIX_ACCESS1_ACCESS', 'POSIX_ACCESS2_ACCESS', 'POSIX_ACCESS3_ACCESS', 'POSIX_ACCESS4_ACCESS', 'POSIX_ACCESS1_COUNT', 'POSIX_ACCESS2_COUNT', 'POSIX_ACCESS3_COUNT', 'POSIX_ACCESS4_COUNT', 'POSIX_FASTEST_RANK', 'POSIX_FASTEST_RANK_BYTES', 'POSIX_SLOWEST_RANK', 'POSIX_SLOWEST_RANK_BYTES'], 'fcounters': ['POSIX_F_OPEN_START_TIMESTAMP', 'POSIX_F_READ_START_TIMESTAMP', 'POSIX_F_WRITE_START_TIMESTAMP', 'POSIX_F_CLOSE_START_TIMESTAMP', 'POSIX_F_OPEN_END_TIMESTAMP', 'POSIX_F_READ_END_TIMESTAMP', 'POSIX_F_WRITE_END_TIMESTAMP', 'POSIX_F_CLOSE_END_TIMESTAMP', 'POSIX_F_READ_TIME', 'POSIX_F_WRITE_TIME', 'POSIX_F_META_TIME', 'POSIX_F_MAX_READ_TIME', 'POSIX_F_MAX_WRITE_TIME', 'POSIX_F_FASTEST_RANK_TIME', 'POSIX_F_SLOWEST_RANK_TIME', 'POSIX_F_VARIANCE_RANK_TIME', 'POSIX_F_VARIANCE_RANK_BYTES']}, 'MPI-IO': {'counters': ['MPIIO_INDEP_OPENS', 'MPIIO_COLL_OPENS', 'MPIIO_INDEP_READS', 'MPIIO_INDEP_WRITES', 'MPIIO_COLL_READS', 'MPIIO_COLL_WRITES', 'MPIIO_SPLIT_READS', 'MPIIO_SPLIT_WRITES', 'MPIIO_NB_READS', 'MPIIO_NB_WRITES', 'MPIIO_SYNCS', 'MPIIO_HINTS', 'MPIIO_VIEWS', 'MPIIO_MODE', 'MPIIO_BYTES_READ', 'MPIIO_BYTES_WRITTEN', 'MPIIO_RW_SWITCHES', 'MPIIO_MAX_READ_TIME_SIZE', 'MPIIO_MAX_WRITE_TIME_SIZE', 'MPIIO_SIZE_READ_AGG_0_100', 'MPIIO_SIZE_READ_AGG_100_1K', 'MPIIO_SIZE_READ_AGG_1K_10K', 'MPIIO_SIZE_READ_AGG_10K_100K', 'MPIIO_SIZE_READ_AGG_100K_1M', 'MPIIO_SIZE_READ_AGG_1M_4M', 'MPIIO_SIZE_READ_AGG_4M_10M', 'MPIIO_SIZE_READ_AGG_10M_100M', 'MPIIO_SIZE_READ_AGG_100M_1G', 'MPIIO_SIZE_READ_AGG_1G_PLUS', 'MPIIO_SIZE_WRITE_AGG_0_100', 'MPIIO_SIZE_WRITE_AGG_100_1K', 'MPIIO_SIZE_WRITE_AGG_1K_10K', 'MPIIO_SIZE_WRITE_AGG_10K_100K', 'MPIIO_SIZE_WRITE_AGG_100K_1M', 'MPIIO_SIZE_WRITE_AGG_1M_4M', 'MPIIO_SIZE_WRITE_AGG_4M_10M', 'MPIIO_SIZE_WRITE_AGG_10M_100M', 'MPIIO_SIZE_WRITE_AGG_100M_1G', 'MPIIO_SIZE_WRITE_AGG_1G_PLUS', 'MPIIO_ACCESS1_ACCESS', 'MPIIO_ACCESS2_ACCESS', 'MPIIO_ACCESS3_ACCESS', 'MPIIO_ACCESS4_ACCESS', 'MPIIO_ACCESS1_COUNT', 'MPIIO_ACCESS2_COUNT', 'MPIIO_ACCESS3_COUNT', 'MPIIO_ACCESS4_COUNT', 'MPIIO_FASTEST_RANK', 'MPIIO_FASTEST_RANK_BYTES', 'MPIIO_SLOWEST_RANK', 'MPIIO_SLOWEST_RANK_BYTES'], 'fcounters': ['MPIIO_F_OPEN_START_TIMESTAMP', 'MPIIO_F_READ_START_TIMESTAMP', 'MPIIO_F_WRITE_START_TIMESTAMP', 'MPIIO_F_CLOSE_START_TIMESTAMP', 'MPIIO_F_OPEN_END_TIMESTAMP', 'MPIIO_F_READ_END_TIMESTAMP', 'MPIIO_F_WRITE_END_TIMESTAMP', 'MPIIO_F_CLOSE_END_TIMESTAMP', 'MPIIO_F_READ_TIME', 'MPIIO_F_WRITE_TIME', 'MPIIO_F_META_TIME', 'MPIIO_F_MAX_READ_TIME', 'MPIIO_F_MAX_WRITE_TIME', 'MPIIO_F_FASTEST_RANK_TIME', 'MPIIO_F_SLOWEST_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_BYTES']}, 'STDIO': {'counters': ['STDIO_OPENS', 'STDIO_FDOPENS', 'STDIO_READS', 'STDIO_WRITES', 'STDIO_SEEKS', 'STDIO_FLUSHES', 'STDIO_BYTES_WRITTEN', 'STDIO_BYTES_READ', 'STDIO_MAX_BYTE_READ', 'STDIO_MAX_BYTE_WRITTEN', 'STDIO_FASTEST_RANK', 'STDIO_FASTEST_RANK_BYTES', 'STDIO_SLOWEST_RANK', 'STDIO_SLOWEST_RANK_BYTES'], 'fcounters': ['STDIO_F_META_TIME', 'STDIO_F_WRITE_TIME', 'STDIO_F_READ_TIME', 'STDIO_F_OPEN_START_TIMESTAMP', 'STDIO_F_CLOSE_START_TIMESTAMP', 'STDIO_F_WRITE_START_TIMESTAMP', 'STDIO_F_READ_START_TIMESTAMP', 'STDIO_F_OPEN_END_TIMESTAMP', 'STDIO_F_CLOSE_END_TIMESTAMP', 'STDIO_F_WRITE_END_TIMESTAMP', 'STDIO_F_READ_END_TIMESTAMP', 'STDIO_F_FASTEST_RANK_TIME', 'STDIO_F_SLOWEST_RANK_TIME', 'STDIO_F_VARIANCE_RANK_TIME', 'STDIO_F_VARIANCE_RANK_BYTES']}, 'LUSTRE': {'counters': ['LUSTRE_OSTS', 'LUSTRE_MDTS', 'LUSTRE_STRIPE_OFFSET', 'LUSTRE_STRIPE_SIZE', 'LUSTRE_STRIPE_WIDTH']}}, 'name_records': {14734109647742566553: '', 15920181672442173319: '', 7238257241479193519: '', 6301063301082038805: '/scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5'}, 'mounts': [('/.shared/base/default/etc/dat.conf', 'dvs'), ('/usr/lib64/libibverbs.so.1.0.0', 'dvs'), ('/usr/lib64/librdmacm.so.1.0.0', 'dvs'), ('/usr/lib64/libibumad.so.3.0.2', 'dvs'), ('/usr/lib64/libibgni.so.1.0.0', 'dvs'), ('/global/cscratch1', 'lustre'), ('/global/projectb', 'dvs'), ('/global/projecta', 'dvs'), ('/usr/sbin/ibstat', 'dvs'), ('/global/project', 'dvs'), ('/global/common', 'dvs'), ('/global/syscom', 'dvs'), ('/global/dna', 'dvs'), ('/global/u2', 'dvs'), ('/opt/slurm', 'dvs'), ('/global/u1', 'dvs'), ('/scratch1', 'lustre'), ('/scratch3', 'lustre'), ('/scratch2', 'lustre'), ('/etc', 'dvs'), ('/', 'rootfs'), ('/', 'dvs')]}\n" ] } ], @@ -806,67 +806,178 @@ { "cell_type": "code", "execution_count": 20, - "id": "4e33d65b", + "id": "e5feae5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## Extract data for a specific module (POSIX or MPI-IO)\n", + "# in DataFrame format using the 'records' attribute and\n", + "# the 'to_df()' method\n", + "# NOTE: the returned type here is actually a dictionary, with\n", + "# 2 separate DataFrames: 'counters' (for integer record data)\n", + "# and 'fcounters' (for floating point record data)\n", + "from darshan.experimental.plots import plot_common_access_table\n", + "posix_recs = report.records['MPI-IO'].to_df()\n", + "## Aggregated multiple log files into a single \"summary\" record.\n", + "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", + "## Obtaining DarshanReportTable object\n", + "plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", + "# print(plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record,\"MPI-IO\"), end=\"\\n\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "8aa13558", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "# POSIX Module\n", + "from darshan.experimental.plots import plot_common_access_table\n", + "posix_recs = report.records['POSIX'].to_df()\n", + "## Aggregated multiple log files into a single \"summary\" record.\n", + "acc_POSIX = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", + "## Plotting\n", + "plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\")\n", + "print(plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\"))\n", + "print(type(plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "041a8507", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " id rank MPIIO_INDEP_OPENS MPIIO_COLL_OPENS \\\n", + "0 6301063301082038805 -1 0 2048 \n", + "\n", + " MPIIO_INDEP_READS MPIIO_INDEP_WRITES MPIIO_COLL_READS MPIIO_COLL_WRITES \\\n", + "0 0 18 0 16384 \n", + "\n", + " MPIIO_SPLIT_READS MPIIO_SPLIT_WRITES ... MPIIO_ACCESS3_ACCESS \\\n", + "0 0 0 ... 544 \n", + "\n", + " MPIIO_ACCESS4_ACCESS MPIIO_ACCESS1_COUNT MPIIO_ACCESS2_COUNT \\\n", + "0 328 16384 8 \n", + "\n", + " MPIIO_ACCESS3_COUNT MPIIO_ACCESS4_COUNT MPIIO_FASTEST_RANK \\\n", + "0 2 2 597 \n", + "\n", + " MPIIO_FASTEST_RANK_BYTES MPIIO_SLOWEST_RANK MPIIO_SLOWEST_RANK_BYTES \n", + "0 1073741824 1312 1073741824 \n", + "\n", + "[1 rows x 53 columns]\n", + "\n", + "0 134217728\n", + "Name: MPIIO_ACCESS1_ACCESS, dtype: int64\n", + "\n", "134217728\n", + "\n", "16384\n", - "\n" + "\n", + "\n", + "\n", + "\n" ] } ], "source": [ + "#Test the indexing and type of dataset\n", "from darshan.experimental.plots import plot_common_access_table\n", "posix_recs = report.records['MPI-IO'].to_df()\n", "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'][0])\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_COUNT'][0])\n", - "print(type(acc_MPIIO.summary_record))" + "print(acc_MPIIO.summary_record['counters'], end=\"\\n\\n\")\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'], end=\"\\n\\n\")\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'][0], end=\"\\n\\n\")\n", + "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_COUNT'][0], end=\"\\n\\n\")\n", + "print(type(acc_MPIIO.summary_record))\n", + "print(type(acc_MPIIO.summary_record['counters']))\n", + "print(type(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS']))" ] }, { "cell_type": "code", "execution_count": 23, - "id": "e5feae5d", + "id": "8094bbba", "metadata": {}, "outputs": [ { - "ename": "TypeError", - "evalue": "'module' object is not callable", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/234895852.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0macc_MPIIO\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccumulate_records\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mposix_recs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreport\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'job'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'nprocs'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0;31m## Plotting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable" + "name": "stdout", + "output_type": "stream", + "text": [ + " Access Size Count\n", + "0 134217728 16384\n", + "1 272 8\n", + "2 544 2\n", + "3 328 2\n", + "\n", + " Access Size Count\n", + "0 272 8\n", + "1 328 2\n", + "2 544 2\n", + "3 134217728 16384\n", + "\n", + " Access Size Count\n", + "0 134217728 16384\n", + "1 272 8\n", + "2 328 2\n", + "3 544 2\n", + "\n", + "html: \n", + "\n" ] } ], "source": [ - "## Extract data for a specific module (POSIX or MPI-IO)\n", - "# in DataFrame format using the 'records' attribute and\n", - "# the 'to_df()' method\n", - "# NOTE: the returned type here is actually a dictionary, with\n", - "# 2 separate DataFrames: 'counters' (for integer record data)\n", - "# and 'fcounters' (for floating point record data)\n", - "from darshan.experimental.plots import plot_common_access_table\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "## Aggregated multiple log files into a single \"summary\" record.\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "## Plotting\n", - "plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")" + "#Test the functions in plot_common_access_table.py\n", + "df=plot_common_access_table.get_access_count_df(acc_MPIIO.summary_record['counters'],\"MPIIO\")\n", + "print(df, end=\"\\n\\n\")\n", + "df=df.groupby(\"Access Size\").sum().reset_index()\n", + "print(df, end=\"\\n\\n\")\n", + "df=df.sort_values(by=\"Count\", ascending=False, ignore_index=True).head(n=4)\n", + "print(df, end=\"\\n\\n\")\n", + "store_fig=plot_common_access_table.DarshanReportTable(df=df, index=False, border=0)\n", + "print(\"html: \", store_fig, end=\"\\n\\n\")" ] }, { "cell_type": "code", "execution_count": 24, - "id": "8aa13558", + "id": "7b635a83", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, { "ename": "TypeError", "evalue": "'module' object is not callable", @@ -874,24 +985,41 @@ "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_42780/1553793853.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0macc_MPIIO\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0maccumulate_records\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mposix_recs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreport\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'job'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'nprocs'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m## Plotting\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/3743950526.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0msummary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;31m# summary.ReportFigure()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable" ] } ], "source": [ + "# Generating table ?\n", + "from darshan.cli import summary\n", "from darshan.experimental.plots import plot_common_access_table\n", - "posix_recs = report.records['POSIX'].to_df()\n", - "## Aggregated multiple log files into a single \"summary\" record.\n", - "acc_MPIIO = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", - "## Plotting\n", - "plot_common_access_table(acc_MPIIO.summary_record, \"POSIX\")" + "self=plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", + "print(type(self))\n", + "summary.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", + "# summary.ReportFigure()" ] }, { "cell_type": "code", "execution_count": null, - "id": "0d45b369", + "id": "56b88412", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "02589ca3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efc48722", "metadata": {}, "outputs": [], "source": [] From 4cf1aaec8eb0d9c8336aadfe5700bb81ec624a0e Mon Sep 17 00:00:00 2001 From: Yanli Date: Mon, 26 Jun 2023 11:45:19 -0600 Subject: [PATCH 07/11] change plot_access_histogram.py to use a record input --- .../plots/plot_access_histogram.py | 92 +++++++++++-------- 1 file changed, 56 insertions(+), 36 deletions(-) diff --git a/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py b/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py index cfb8c75e4..7a5bd5be5 100644 --- a/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py +++ b/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py @@ -18,12 +18,12 @@ def autolabel(ax, rects): rotation=45, ) -def plot_access_histogram(report, mod, ax=None): +def plot_access_histogram(record, mod, ax=None): """ Plots a histogram of access sizes for specified module. Args: - report (darshan.DarshanReport): report to generate plot from + record: record to generate plot from mod (str): mod-string for which to generate access_histogram """ @@ -33,44 +33,64 @@ def plot_access_histogram(report, mod, ax=None): else: fig = None - # TODO: change to report.summary - if 'mod_agg_iohist' in dir(report): - report.mod_agg_iohist(mod) - else: - print("Cannot create summary, mod_agg_iohist aggregator is not registered with the report class.") # defaults labels = ['0-100', '101-1K', '1K-10K', '10K-100K', '100K-1M', '1M-4M', '4M-10M', '10M-100M', '100M-1G', '1G+'] - agg = report.summary['agg_iohist'][mod] - # TODO: can simplify the read/write vals below after - # support for python 3.6 is dropped - read_vals = [ - agg['READ_0_100'], - agg['READ_100_1K'], - agg['READ_1K_10K'], - agg['READ_10K_100K'], - agg['READ_100K_1M'], - agg['READ_1M_4M'], - agg['READ_4M_10M'], - agg['READ_10M_100M'], - agg['READ_100M_1G'], - agg['READ_1G_PLUS'] - ] - - write_vals = [ - agg['WRITE_0_100'], - agg['WRITE_100_1K'], - agg['WRITE_1K_10K'], - agg['WRITE_10K_100K'], - agg['WRITE_100K_1M'], - agg['WRITE_1M_4M'], - agg['WRITE_4M_10M'], - agg['WRITE_10M_100M'], - agg['WRITE_100M_1G'], - agg['WRITE_1G_PLUS'] - ] - + agg=record['counters'] + if mod == 'POSIX': + read_vals = [ + agg['POSIX_SIZE_READ_0_100'][0], + agg['POSIX_SIZE_READ_100_1K'][0], + agg['POSIX_SIZE_READ_1K_10K'][0], + agg['POSIX_SIZE_READ_10K_100K'][0], + agg['POSIX_SIZE_READ_100K_1M'][0], + agg['POSIX_SIZE_READ_1M_4M'][0], + agg['POSIX_SIZE_READ_4M_10M'][0], + agg['POSIX_SIZE_READ_10M_100M'][0], + agg['POSIX_SIZE_READ_100M_1G'][0], + agg['POSIX_SIZE_READ_1G_PLUS'][0] + ] + + write_vals = [ + agg['POSIX_SIZE_WRITE_0_100'][0], + agg['POSIX_SIZE_WRITE_100_1K'][0], + agg['POSIX_SIZE_WRITE_1K_10K'][0], + agg['POSIX_SIZE_WRITE_10K_100K'][0], + agg['POSIX_SIZE_WRITE_100K_1M'][0], + agg['POSIX_SIZE_WRITE_1M_4M'][0], + agg['POSIX_SIZE_WRITE_4M_10M'][0], + agg['POSIX_SIZE_WRITE_10M_100M'][0], + agg['POSIX_SIZE_WRITE_100M_1G'][0], + agg['POSIX_SIZE_WRITE_1G_PLUS'][0] + ] + elif mod == 'MPI-IO': + read_vals = [ + agg['MPIIO_SIZE_READ_AGG_0_100'][0], + agg['MPIIO_SIZE_READ_AGG_100_1K'][0], + agg['MPIIO_SIZE_READ_AGG_1K_10K'][0], + agg['MPIIO_SIZE_READ_AGG_10K_100K'][0], + agg['MPIIO_SIZE_READ_AGG_100K_1M'][0], + agg['MPIIO_SIZE_READ_AGG_1M_4M'][0], + agg['MPIIO_SIZE_READ_AGG_4M_10M'][0], + agg['MPIIO_SIZE_READ_AGG_10M_100M'][0], + agg['MPIIO_SIZE_READ_AGG_100M_1G'][0], + agg['MPIIO_SIZE_READ_AGG_1G_PLUS'][0] + ] + + write_vals = [ + agg['MPIIO_SIZE_WRITE_AGG_0_100'][0], + agg['MPIIO_SIZE_WRITE_AGG_100_1K'][0], + agg['MPIIO_SIZE_WRITE_AGG_1K_10K'][0], + agg['MPIIO_SIZE_WRITE_AGG_10K_100K'][0], + agg['MPIIO_SIZE_WRITE_AGG_100K_1M'][0], + agg['MPIIO_SIZE_WRITE_AGG_1M_4M'][0], + agg['MPIIO_SIZE_WRITE_AGG_4M_10M'][0], + agg['MPIIO_SIZE_WRITE_AGG_10M_100M'][0], + agg['MPIIO_SIZE_WRITE_AGG_100M_1G'][0], + agg['MPIIO_SIZE_WRITE_AGG_1G_PLUS'][0] + ] + #TODO: add support for HDF5/PnetCDF modules x = np.arange(len(labels)) # the label locations width = 0.35 # the width of the bars From 75cc536e3c191bab556d31fae4d78a21241d3446 Mon Sep 17 00:00:00 2001 From: Yanli Date: Mon, 26 Jun 2023 11:46:13 -0600 Subject: [PATCH 08/11] change plot_common_access_table.py to use a record input --- .../experimental/plots/plot_common_access_table.py | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py b/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py index 6a1d50bb1..9e4f8ed57 100644 --- a/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py +++ b/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py @@ -83,7 +83,7 @@ def get_access_count_df(mod_df: Any, mod: str) -> Any: Parameters ---------- mod_df: "counters" dataframe for the input - module `mod` from a ``darshan.DarshanReport``. + module `mod` from a record. mod: the module to obtain the common accesses table for (i.e "POSIX", "MPI-IO", "H5D"). @@ -102,7 +102,6 @@ def get_access_count_df(mod_df: Any, mod: str) -> Any: df = mod_df.filter(filter_keys) df = collapse_access_cols(df=df, col_name=col_name) df_list.append(df) - return pd.concat(df_list, axis=1) @@ -122,14 +121,14 @@ def __init__(self, df: Any, **kwargs): self.html = self.df.to_html(**kwargs) -def plot_common_access_table(report: darshan.DarshanReport, mod: str, n_rows: int = 4) -> DarshanReportTable: +def plot_common_access_table(record: dict, mod: str, n_rows: int = 4) -> DarshanReportTable: """ Creates a table containing the most common access sizes and their counts. Parameters ---------- - report: a ``darshan.DarshanReport``. + record: a dict. mod: the module to obtain the common access size table for (i.e "POSIX", "MPI-IO", "H5D"). @@ -145,8 +144,7 @@ def plot_common_access_table(report: darshan.DarshanReport, mod: str, n_rows: in the `df` or `html` attributes, respectively. """ - mod_df = report.records[mod].to_df(attach=None)["counters"] - + mod_df=record['counters'] if mod == "MPI-IO": mod = "MPIIO" From f1917f35020479185e3b50f63a70b25ba36f4c79 Mon Sep 17 00:00:00 2001 From: Yanli Date: Mon, 26 Jun 2023 14:46:31 -0600 Subject: [PATCH 09/11] "delete multi-log-scratchpad.ipynb" --- .../examples/multi-log-scratchpad.ipynb | 1067 ----------------- 1 file changed, 1067 deletions(-) delete mode 100644 darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb diff --git a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb b/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb deleted file mode 100644 index c474860e5..000000000 --- a/darshan-util/pydarshan/darshan/examples/multi-log-scratchpad.ipynb +++ /dev/null @@ -1,1067 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "acc17ec9", - "metadata": {}, - "outputs": [], - "source": [ - "import darshan" - ] - }, - { - "cell_type": "markdown", - "id": "9dc378c3", - "metadata": {}, - "source": [ - "#### Open Darshan log file and read in data" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "0449a558", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['__add__',\n", - " '__class__',\n", - " '__deepcopy__',\n", - " '__del__',\n", - " '__delattr__',\n", - " '__dict__',\n", - " '__dir__',\n", - " '__doc__',\n", - " '__enter__',\n", - " '__eq__',\n", - " '__exit__',\n", - " '__format__',\n", - " '__ge__',\n", - " '__getattribute__',\n", - " '__gt__',\n", - " '__hash__',\n", - " '__init__',\n", - " '__init_subclass__',\n", - " '__le__',\n", - " '__lt__',\n", - " '__module__',\n", - " '__ne__',\n", - " '__new__',\n", - " '__reduce__',\n", - " '__reduce_ex__',\n", - " '__repr__',\n", - " '__setattr__',\n", - " '__sizeof__',\n", - " '__str__',\n", - " '__subclasshook__',\n", - " '__weakref__',\n", - " '_cleanup',\n", - " '_counters',\n", - " '_heatmaps',\n", - " '_metadata',\n", - " '_modules',\n", - " '_mounts',\n", - " 'automatic_summary',\n", - " 'converted_records',\n", - " 'counters',\n", - " 'data',\n", - " 'data_revision',\n", - " 'dtype',\n", - " 'end_time',\n", - " 'filename',\n", - " 'heatmaps',\n", - " 'info',\n", - " 'log',\n", - " 'lookup_name_records',\n", - " 'metadata',\n", - " 'mod_read_all_apmpi_records',\n", - " 'mod_read_all_apxc_records',\n", - " 'mod_read_all_dxt_records',\n", - " 'mod_read_all_lustre_records',\n", - " 'mod_read_all_records',\n", - " 'mod_records',\n", - " 'modules',\n", - " 'mounts',\n", - " 'name_records',\n", - " 'open',\n", - " 'provenance_enabled',\n", - " 'provenance_graph',\n", - " 'provenance_reports',\n", - " 'read_all',\n", - " 'read_all_dxt_records',\n", - " 'read_all_generic_records',\n", - " 'read_all_heatmap_records',\n", - " 'read_metadata',\n", - " 'rebase_timestamps',\n", - " 'records',\n", - " 'start_time',\n", - " 'summary',\n", - " 'summary_revision',\n", - " 'timebase',\n", - " 'to_dict',\n", - " 'to_json',\n", - " 'update_name_records']" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "logfile = \"example_logs/example.darshan\"\n", - "# obtain a report object containing all data for the input log\n", - "report = darshan.DarshanReport(logfile, read_all=True)\n", - "# for reference, print all attributes associated with the report object\n", - "dir(report)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "634efe0c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'POSIX': ,\n", - " 'MPI-IO': ,\n", - " 'STDIO': ,\n", - " 'LUSTRE': }" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "report.records" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "c46d71a3", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Filename: example_logs/example.darshan\n", - "Executable: /global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32\n", - "Times: 2017-03-20 03:07:47 to 2017-03-20 03:09:43\n", - "Run time: 117.0000 (s)\n", - "Processes: 2048\n", - "JobID: 4478544\n", - "UID: 69615\n", - "Modules in Log: ['POSIX', 'MPI-IO', 'LUSTRE', 'STDIO']\n", - "Loaded Records: {'POSIX': 1, 'MPI-IO': 1, 'STDIO': 129, 'LUSTRE': 1}\n", - "Name Records: 4\n", - "Darshan/Hints: {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}\n", - "DarshanReport: id(140494821728112) (tmp)\n" - ] - } - ], - "source": [ - "# quickly display some info about the log data\n", - "report.info()" - ] - }, - { - "cell_type": "markdown", - "id": "c1fb1e2d", - "metadata": {}, - "source": [ - "#### Convert some record data to a DataFrame" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "1e1059de", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'POSIX': {'len': 186,\n", - " 'ver': 3,\n", - " 'idx': 1,\n", - " 'partial_flag': False,\n", - " 'num_records': 1},\n", - " 'MPI-IO': {'len': 154,\n", - " 'ver': 2,\n", - " 'idx': 2,\n", - " 'partial_flag': False,\n", - " 'num_records': 1},\n", - " 'LUSTRE': {'len': 87,\n", - " 'ver': 1,\n", - " 'idx': 8,\n", - " 'partial_flag': False,\n", - " 'num_records': 1},\n", - " 'STDIO': {'len': 3234,\n", - " 'ver': 1,\n", - " 'idx': 9,\n", - " 'partial_flag': False,\n", - " 'num_records': 129}}" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# the log may contain data from multiple modules\n", - "report.modules" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "27d88766", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'counters': rank id POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", - "0 -1 6301063301082038805 2049 -1 -1 \n", - "\n", - " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", - "0 0 16402 16404 0 0 ... \n", - "\n", - " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", - "0 544 328 16384 \n", - "\n", - " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", - "0 8 2 2 \n", - "\n", - " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", - "0 597 1073741824 1312 \n", - "\n", - " POSIX_SLOWEST_RANK_BYTES \n", - "0 1073741824 \n", - "\n", - "[1 rows x 71 columns], 'fcounters': rank id POSIX_F_OPEN_START_TIMESTAMP \\\n", - "0 -1 6301063301082038805 3.919141 \n", - "\n", - " POSIX_F_READ_START_TIMESTAMP POSIX_F_WRITE_START_TIMESTAMP \\\n", - "0 0.0 3.940064 \n", - "\n", - " POSIX_F_CLOSE_START_TIMESTAMP POSIX_F_OPEN_END_TIMESTAMP \\\n", - "0 3.927094 3.93658 \n", - "\n", - " POSIX_F_READ_END_TIMESTAMP POSIX_F_WRITE_END_TIMESTAMP \\\n", - "0 0.0 115.078166 \n", - "\n", - " POSIX_F_CLOSE_END_TIMESTAMP POSIX_F_READ_TIME POSIX_F_WRITE_TIME \\\n", - "0 115.770358 0.0 100397.600422 \n", - "\n", - " POSIX_F_META_TIME POSIX_F_MAX_READ_TIME POSIX_F_MAX_WRITE_TIME \\\n", - "0 11.300842 0.0 17.940946 \n", - "\n", - " POSIX_F_FASTEST_RANK_TIME POSIX_F_SLOWEST_RANK_TIME \\\n", - "0 20.4361 85.47495 \n", - "\n", - " POSIX_F_VARIANCE_RANK_TIME POSIX_F_VARIANCE_RANK_BYTES \n", - "0 0.0 0.0 }\n" - ] - } - ], - "source": [ - "# we can extract data for a specific module (e.g., POSIX)\n", - "# in DataFrame format using the 'records' attribute and\n", - "# the 'to_df()' method\n", - "# NOTE: the returned type here is actually a dictionary, with\n", - "# 2 separate DataFrames: 'counters' (for integer record data)\n", - "# and 'fcounters' (for floating point record data)\n", - "posix_recs = report.records['POSIX'].to_df()\n", - "print(posix_recs)" - ] - }, - { - "cell_type": "markdown", - "id": "90b2c2fe", - "metadata": {}, - "source": [ - "#### Reproduce a job summary \"operation counts\" figure" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "5484b720", - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "'DarshanReport' object is not subscriptable", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/3775996570.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# this plotting routine expects some input about what data to plot\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[0;31m# (in this case, a report object and a module name)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"POSIX\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 33\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'POSIX'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: 'DarshanReport' object is not subscriptable" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# import routine for plotting op counts and enable experimental mode\n", - "from darshan.experimental.plots import plot_opcounts\n", - "darshan.enable_experimental()\n", - "\n", - "# this plotting routine expects some input about what data to plot\n", - "# (in this case, a report object and a module name)\n", - "plot_opcounts(report, \"POSIX\")" - ] - }, - { - "cell_type": "markdown", - "id": "42f600fd", - "metadata": {}, - "source": [ - " As you can see above from the `plot_opcounts()` signature, it takes a single report object as input. Internally, this plotting routine has logic to combine all of the records in the report object to plot total number of operations across all file records.\n", - " \n", - " Since a report object corresponds to a single Darshan log, we can't use this function to plot\n", - " data from multiple Darshan logs." - ] - }, - { - "cell_type": "markdown", - "id": "7e9b0b38", - "metadata": {}, - "source": [ - "#### Darshan accumulator API" - ] - }, - { - "cell_type": "markdown", - "id": "035551f0", - "metadata": {}, - "source": [ - "PyDarshan includes an \"accumulator\" API, which allows multiple records (perhaps coming from different log files) to be aggregated into a single \"summary\" record." - ] - }, - { - "cell_type": "markdown", - "id": "12f2adfd", - "metadata": {}, - "source": [ - "To resolve the plotting issue mentioned above, one option would be to update the plotting routine to take a single record as input (rather than a report object). We can ultimately use the \"summary\" record generated by the accumulator interface above as input to handle the use case where we want to plot data from multiple log files." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "28515908", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " id rank POSIX_OPENS POSIX_FILENOS POSIX_DUPS \\\n", - "0 6301063301082038805 -1 2049 -1 -1 \n", - "\n", - " POSIX_READS POSIX_WRITES POSIX_SEEKS POSIX_STATS POSIX_MMAPS ... \\\n", - "0 0 16402 16404 0 0 ... \n", - "\n", - " POSIX_ACCESS3_ACCESS POSIX_ACCESS4_ACCESS POSIX_ACCESS1_COUNT \\\n", - "0 544 328 16384 \n", - "\n", - " POSIX_ACCESS2_COUNT POSIX_ACCESS3_COUNT POSIX_ACCESS4_COUNT \\\n", - "0 8 2 2 \n", - "\n", - " POSIX_FASTEST_RANK POSIX_FASTEST_RANK_BYTES POSIX_SLOWEST_RANK \\\n", - "0 597 1073741824 1312 \n", - "\n", - " POSIX_SLOWEST_RANK_BYTES \n", - "0 1073741824 \n", - "\n", - "[1 rows x 71 columns]\n", - "\n", - "\n", - "\n" - ] - } - ], - "source": [ - "from darshan.backend.cffi_backend import accumulate_records\n", - "# accumulate all records in posix_recs, and then print out the \"summary\" record\n", - "acc = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", - "# print(acc)\n", - "# print(type(acc))\n", - "# print(type(acc.summary_record))\n", - "# print(acc.summary_record, end='\\n\\n\\n\\n')\n", - "print(acc.summary_record['counters'], end='\\n\\n\\n\\n')\n", - "# print(acc.summary_record['counters'][\"POSIX_OPENS\"], end='\\n\\n\\n\\n')\n", - "# printint(dir(acc.summary_record))\n", - "# print(acc.summary_record.summary)" - ] - }, - { - "cell_type": "markdown", - "id": "fd3c32dd", - "metadata": {}, - "source": [ - "### First Step\n", - "\n", - "Our first step is to modify the plotting code `plot_opcounts()` (in file darshan/experimental/plots/plot_opcounts.py) to take a single record as input rather than a report object. Ultimately, we should be able to pass in the summary record from above and get an identical plot to the one generated previously in this notebook (i.e., based on the old code)." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "341c1545", - "metadata": {}, - "outputs": [], - "source": [ - "# print(dir(acc))\n", - "# print(dir(acc.summary_record))\n", - "# print(\"acc: \", acc, end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.summary_record: \", acc.summary_record, end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.count: \", acc.count, end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.derived_metrics: \", acc.derived_metrics, end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.index: \", acc.index, end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.summary_record['counters']: \", acc.summary_record['counters'], end=\"\\n\\n\\n\\n\")\n", - "# print(\"acc.summary_record['counters']['POSIX_OPENS']: \", acc.summary_record['counters'][\"POSIX_OPENS\"], end=\"\\n\\n\")\n", - "# print(\"acc.summary_record['counters']['POSIX_OPENS'][0]: \", acc.summary_record['counters'][\"POSIX_OPENS\"][0])" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "3ac2ed27", - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Test for plot_opcounts POSIX\n", - "from darshan.experimental.plots import plot_opcounts\n", - "darshan.enable_experimental()\n", - "plot_opcounts(acc.summary_record, \"POSIX\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e004f112", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Test for plot_opcounts MPI-IO\n", - "from darshan.experimental.plots import plot_opcounts\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "print(acc_MPIIO.summary_record['counters'][\"MPIIO_INDEP_READS\"][0])\n", - "darshan.enable_experimental()\n", - "plot_opcounts(acc_MPIIO.summary_record, \"MPI-IO\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "591eb3ed", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Test for plot_opcounts STDIO\n", - "from darshan.experimental.plots import plot_opcounts\n", - "posix_recs = report.records['STDIO'].to_df()\n", - "acc_STDIO = accumulate_records(posix_recs, \"STDIO\", report.metadata['job']['nprocs'])\n", - "print(acc_STDIO.summary_record['counters'][\"STDIO_READS\"][0])\n", - "darshan.enable_experimental()\n", - "plot_opcounts(acc_STDIO.summary_record, \"STDIO\")" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "6881d549", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Error: plot_opcounts not supported for module H5F", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/1299849547.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"H5F\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module H5F" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Test for plot_opcounts H5F\n", - "from darshan.experimental.plots import plot_opcounts\n", - "# acc_H5F = accumulate_records(posix_recs, \"H5F\", report.metadata['job']['nprocs'])\n", - "# print(acc_H5F.summary_record['counters'][\"H5F_FLUSHES\"][0])\n", - "# darshan.enable_experimental()\n", - "plot_opcounts(report, \"H5F\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "862437d8", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Error: plot_opcounts not supported for module PNETCDF_FILE", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/651463565.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;31m# darshan.enable_experimental()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_opcounts\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreport\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"PNETCDF_FILE\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mplot_opcounts\u001b[0;34m(record, mod, ax)\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 171\u001b[0;31m \u001b[0mlabels\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcounts\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgather_count_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrecord\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmod\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 172\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# the label locations\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/darshan/experimental/plots/plot_opcounts.py\u001b[0m in \u001b[0;36mgather_count_data\u001b[0;34m(record, mod)\u001b[0m\n\u001b[1;32m 28\u001b[0m \"\"\"\n\u001b[1;32m 29\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmod\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'H5F'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'H5D'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_FILE'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'PNETCDF_VAR'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 30\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mf\"Error: plot_opcounts not supported for module {mod}\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 31\u001b[0m \u001b[0mmod_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrecord\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'counters'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 32\u001b[0m \u001b[0;31m# Gather POSIX\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mValueError\u001b[0m: Error: plot_opcounts not supported for module PNETCDF_FILE" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Test for plot_opcounts PNETCDF_FILE\n", - "from darshan.experimental.plots import plot_opcounts\n", - "# acc_PNETCDF_FILE = accumulate_records(posix_recs, \"PNETCDF_FILE\", report.metadata['job']['nprocs'])\n", - "# print(acc_PNETCDF_FILE.summary_record['counters'][\"PNETCDF_FILE_SYNCS\"][0])\n", - "# darshan.enable_experimental()\n", - "plot_opcounts(report, \"PNETCDF_FILE\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "dece9aaa", - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Test for plot_posix_access_pattern POSIX\n", - "from darshan.experimental.plots import plot_posix_access_pattern\n", - "darshan.enable_experimental()\n", - "# print(acc)\n", - "plot_posix_access_pattern(acc.summary_record)" - ] - }, - { - "cell_type": "markdown", - "id": "e0872862", - "metadata": {}, - "source": [ - "### Second Step\n", - "Modify the plotting code plot_access_histogram( ) (in file darshan/experimental/plots/plot_access_histogram.py) to take a single record as input rather than a report object. " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "f7b9d300", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Extract data for a specific module (POSIX or MPI-IO)\n", - "# in DataFrame format using the 'records' attribute and\n", - "# the 'to_df()' method\n", - "# NOTE: the returned type here is actually a dictionary, with\n", - "# 2 separate DataFrames: 'counters' (for integer record data)\n", - "# and 'fcounters' (for floating point record data)\n", - "from darshan.experimental.plots import plot_access_histogram\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "## Aggregated multiple log files into a single \"summary\" record.\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "## Plotting\n", - "plot_access_histogram(acc_MPIIO.summary_record, \"MPI-IO\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "3409d42c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from darshan.experimental.plots import plot_access_histogram\n", - "posix_recs = report.records['POSIX'].to_df()\n", - "acc_MPIIO = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", - "plot_access_histogram(acc_MPIIO.summary_record, \"POSIX\")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "cb5566d5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'version': 1, 'metadata': {'job': {'uid': 69615, 'start_time_sec': 1490000867, 'start_time_nsec': 0, 'end_time_sec': 1490000983, 'end_time_nsec': 0, 'nprocs': 2048, 'jobid': 4478544, 'run_time': 117.0, 'log_ver': '3.10', 'metadata': {'lib_ver': '3.1.3', 'h': 'romio_no_indep_rw=true;cb_nodes=4'}}, 'exe': '/global/project/projectdirs/m888/glock/tokio-abc-results/bin.edison/vpicio_uni /scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5 32'}, 'records': {'POSIX': , 'MPI-IO': , 'STDIO': , 'LUSTRE': }, 'summary': {}, 'modules': {'POSIX': {'len': 186, 'ver': 3, 'idx': 1, 'partial_flag': False, 'num_records': 1}, 'MPI-IO': {'len': 154, 'ver': 2, 'idx': 2, 'partial_flag': False, 'num_records': 1}, 'LUSTRE': {'len': 87, 'ver': 1, 'idx': 8, 'partial_flag': False, 'num_records': 1}, 'STDIO': {'len': 3234, 'ver': 1, 'idx': 9, 'partial_flag': False, 'num_records': 129}}, 'counters': {'POSIX': {'counters': ['POSIX_OPENS', 'POSIX_FILENOS', 'POSIX_DUPS', 'POSIX_READS', 'POSIX_WRITES', 'POSIX_SEEKS', 'POSIX_STATS', 'POSIX_MMAPS', 'POSIX_FSYNCS', 'POSIX_FDSYNCS', 'POSIX_RENAME_SOURCES', 'POSIX_RENAME_TARGETS', 'POSIX_RENAMED_FROM', 'POSIX_MODE', 'POSIX_BYTES_READ', 'POSIX_BYTES_WRITTEN', 'POSIX_MAX_BYTE_READ', 'POSIX_MAX_BYTE_WRITTEN', 'POSIX_CONSEC_READS', 'POSIX_CONSEC_WRITES', 'POSIX_SEQ_READS', 'POSIX_SEQ_WRITES', 'POSIX_RW_SWITCHES', 'POSIX_MEM_NOT_ALIGNED', 'POSIX_MEM_ALIGNMENT', 'POSIX_FILE_NOT_ALIGNED', 'POSIX_FILE_ALIGNMENT', 'POSIX_MAX_READ_TIME_SIZE', 'POSIX_MAX_WRITE_TIME_SIZE', 'POSIX_SIZE_READ_0_100', 'POSIX_SIZE_READ_100_1K', 'POSIX_SIZE_READ_1K_10K', 'POSIX_SIZE_READ_10K_100K', 'POSIX_SIZE_READ_100K_1M', 'POSIX_SIZE_READ_1M_4M', 'POSIX_SIZE_READ_4M_10M', 'POSIX_SIZE_READ_10M_100M', 'POSIX_SIZE_READ_100M_1G', 'POSIX_SIZE_READ_1G_PLUS', 'POSIX_SIZE_WRITE_0_100', 'POSIX_SIZE_WRITE_100_1K', 'POSIX_SIZE_WRITE_1K_10K', 'POSIX_SIZE_WRITE_10K_100K', 'POSIX_SIZE_WRITE_100K_1M', 'POSIX_SIZE_WRITE_1M_4M', 'POSIX_SIZE_WRITE_4M_10M', 'POSIX_SIZE_WRITE_10M_100M', 'POSIX_SIZE_WRITE_100M_1G', 'POSIX_SIZE_WRITE_1G_PLUS', 'POSIX_STRIDE1_STRIDE', 'POSIX_STRIDE2_STRIDE', 'POSIX_STRIDE3_STRIDE', 'POSIX_STRIDE4_STRIDE', 'POSIX_STRIDE1_COUNT', 'POSIX_STRIDE2_COUNT', 'POSIX_STRIDE3_COUNT', 'POSIX_STRIDE4_COUNT', 'POSIX_ACCESS1_ACCESS', 'POSIX_ACCESS2_ACCESS', 'POSIX_ACCESS3_ACCESS', 'POSIX_ACCESS4_ACCESS', 'POSIX_ACCESS1_COUNT', 'POSIX_ACCESS2_COUNT', 'POSIX_ACCESS3_COUNT', 'POSIX_ACCESS4_COUNT', 'POSIX_FASTEST_RANK', 'POSIX_FASTEST_RANK_BYTES', 'POSIX_SLOWEST_RANK', 'POSIX_SLOWEST_RANK_BYTES'], 'fcounters': ['POSIX_F_OPEN_START_TIMESTAMP', 'POSIX_F_READ_START_TIMESTAMP', 'POSIX_F_WRITE_START_TIMESTAMP', 'POSIX_F_CLOSE_START_TIMESTAMP', 'POSIX_F_OPEN_END_TIMESTAMP', 'POSIX_F_READ_END_TIMESTAMP', 'POSIX_F_WRITE_END_TIMESTAMP', 'POSIX_F_CLOSE_END_TIMESTAMP', 'POSIX_F_READ_TIME', 'POSIX_F_WRITE_TIME', 'POSIX_F_META_TIME', 'POSIX_F_MAX_READ_TIME', 'POSIX_F_MAX_WRITE_TIME', 'POSIX_F_FASTEST_RANK_TIME', 'POSIX_F_SLOWEST_RANK_TIME', 'POSIX_F_VARIANCE_RANK_TIME', 'POSIX_F_VARIANCE_RANK_BYTES']}, 'MPI-IO': {'counters': ['MPIIO_INDEP_OPENS', 'MPIIO_COLL_OPENS', 'MPIIO_INDEP_READS', 'MPIIO_INDEP_WRITES', 'MPIIO_COLL_READS', 'MPIIO_COLL_WRITES', 'MPIIO_SPLIT_READS', 'MPIIO_SPLIT_WRITES', 'MPIIO_NB_READS', 'MPIIO_NB_WRITES', 'MPIIO_SYNCS', 'MPIIO_HINTS', 'MPIIO_VIEWS', 'MPIIO_MODE', 'MPIIO_BYTES_READ', 'MPIIO_BYTES_WRITTEN', 'MPIIO_RW_SWITCHES', 'MPIIO_MAX_READ_TIME_SIZE', 'MPIIO_MAX_WRITE_TIME_SIZE', 'MPIIO_SIZE_READ_AGG_0_100', 'MPIIO_SIZE_READ_AGG_100_1K', 'MPIIO_SIZE_READ_AGG_1K_10K', 'MPIIO_SIZE_READ_AGG_10K_100K', 'MPIIO_SIZE_READ_AGG_100K_1M', 'MPIIO_SIZE_READ_AGG_1M_4M', 'MPIIO_SIZE_READ_AGG_4M_10M', 'MPIIO_SIZE_READ_AGG_10M_100M', 'MPIIO_SIZE_READ_AGG_100M_1G', 'MPIIO_SIZE_READ_AGG_1G_PLUS', 'MPIIO_SIZE_WRITE_AGG_0_100', 'MPIIO_SIZE_WRITE_AGG_100_1K', 'MPIIO_SIZE_WRITE_AGG_1K_10K', 'MPIIO_SIZE_WRITE_AGG_10K_100K', 'MPIIO_SIZE_WRITE_AGG_100K_1M', 'MPIIO_SIZE_WRITE_AGG_1M_4M', 'MPIIO_SIZE_WRITE_AGG_4M_10M', 'MPIIO_SIZE_WRITE_AGG_10M_100M', 'MPIIO_SIZE_WRITE_AGG_100M_1G', 'MPIIO_SIZE_WRITE_AGG_1G_PLUS', 'MPIIO_ACCESS1_ACCESS', 'MPIIO_ACCESS2_ACCESS', 'MPIIO_ACCESS3_ACCESS', 'MPIIO_ACCESS4_ACCESS', 'MPIIO_ACCESS1_COUNT', 'MPIIO_ACCESS2_COUNT', 'MPIIO_ACCESS3_COUNT', 'MPIIO_ACCESS4_COUNT', 'MPIIO_FASTEST_RANK', 'MPIIO_FASTEST_RANK_BYTES', 'MPIIO_SLOWEST_RANK', 'MPIIO_SLOWEST_RANK_BYTES'], 'fcounters': ['MPIIO_F_OPEN_START_TIMESTAMP', 'MPIIO_F_READ_START_TIMESTAMP', 'MPIIO_F_WRITE_START_TIMESTAMP', 'MPIIO_F_CLOSE_START_TIMESTAMP', 'MPIIO_F_OPEN_END_TIMESTAMP', 'MPIIO_F_READ_END_TIMESTAMP', 'MPIIO_F_WRITE_END_TIMESTAMP', 'MPIIO_F_CLOSE_END_TIMESTAMP', 'MPIIO_F_READ_TIME', 'MPIIO_F_WRITE_TIME', 'MPIIO_F_META_TIME', 'MPIIO_F_MAX_READ_TIME', 'MPIIO_F_MAX_WRITE_TIME', 'MPIIO_F_FASTEST_RANK_TIME', 'MPIIO_F_SLOWEST_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_TIME', 'MPIIO_F_VARIANCE_RANK_BYTES']}, 'STDIO': {'counters': ['STDIO_OPENS', 'STDIO_FDOPENS', 'STDIO_READS', 'STDIO_WRITES', 'STDIO_SEEKS', 'STDIO_FLUSHES', 'STDIO_BYTES_WRITTEN', 'STDIO_BYTES_READ', 'STDIO_MAX_BYTE_READ', 'STDIO_MAX_BYTE_WRITTEN', 'STDIO_FASTEST_RANK', 'STDIO_FASTEST_RANK_BYTES', 'STDIO_SLOWEST_RANK', 'STDIO_SLOWEST_RANK_BYTES'], 'fcounters': ['STDIO_F_META_TIME', 'STDIO_F_WRITE_TIME', 'STDIO_F_READ_TIME', 'STDIO_F_OPEN_START_TIMESTAMP', 'STDIO_F_CLOSE_START_TIMESTAMP', 'STDIO_F_WRITE_START_TIMESTAMP', 'STDIO_F_READ_START_TIMESTAMP', 'STDIO_F_OPEN_END_TIMESTAMP', 'STDIO_F_CLOSE_END_TIMESTAMP', 'STDIO_F_WRITE_END_TIMESTAMP', 'STDIO_F_READ_END_TIMESTAMP', 'STDIO_F_FASTEST_RANK_TIME', 'STDIO_F_SLOWEST_RANK_TIME', 'STDIO_F_VARIANCE_RANK_TIME', 'STDIO_F_VARIANCE_RANK_BYTES']}, 'LUSTRE': {'counters': ['LUSTRE_OSTS', 'LUSTRE_MDTS', 'LUSTRE_STRIPE_OFFSET', 'LUSTRE_STRIPE_SIZE', 'LUSTRE_STRIPE_WIDTH']}}, 'name_records': {14734109647742566553: '', 15920181672442173319: '', 7238257241479193519: '', 6301063301082038805: '/scratch2/scratchdirs/glock/tokioabc-s.4478544/vpicio/vpicio.hdf5'}, 'mounts': [('/.shared/base/default/etc/dat.conf', 'dvs'), ('/usr/lib64/libibverbs.so.1.0.0', 'dvs'), ('/usr/lib64/librdmacm.so.1.0.0', 'dvs'), ('/usr/lib64/libibumad.so.3.0.2', 'dvs'), ('/usr/lib64/libibgni.so.1.0.0', 'dvs'), ('/global/cscratch1', 'lustre'), ('/global/projectb', 'dvs'), ('/global/projecta', 'dvs'), ('/usr/sbin/ibstat', 'dvs'), ('/global/project', 'dvs'), ('/global/common', 'dvs'), ('/global/syscom', 'dvs'), ('/global/dna', 'dvs'), ('/global/u2', 'dvs'), ('/opt/slurm', 'dvs'), ('/global/u1', 'dvs'), ('/scratch1', 'lustre'), ('/scratch3', 'lustre'), ('/scratch2', 'lustre'), ('/etc', 'dvs'), ('/', 'rootfs'), ('/', 'dvs')]}\n" - ] - } - ], - "source": [ - "# print(report.mod_agg_iohist, end=\"\\n\\n\")\n", - "# print(report.records, end=\"\\n\\n\")\n", - "# print(report.summary, end=\"\\n\\n\")\n", - "# print(dir(report.summary), end=\"\\n\\n\")\n", - "# print(dir(report.mod_agg_iohist), end=\"\\n\\n\")\n", - "print(report.data)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "bfeefac6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "READ:\n", - "0\n", - "WRITE:\n", - "4\n" - ] - } - ], - "source": [ - "from darshan.experimental.plots import plot_access_histogram\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "print(\"READ:\")\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_0_100'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100_1K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1K_10K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_10K_100K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100K_1M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1M_4M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_4M_10M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_10M_100M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_100M_1G'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_READ_AGG_1G_PLUS'][0]) \n", - "print(\"WRITE:\") \n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_0_100'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100_1K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1K_10K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_10K_100K'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100K_1M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1M_4M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_4M_10M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_10M_100M'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_100M_1G'][0])\n", - "# print(acc_MPIIO.summary_record['counters']['MPIIO_SIZE_WRITE_AGG_1G_PLUS'][0]) " - ] - }, - { - "cell_type": "markdown", - "id": "f652d5bf", - "metadata": {}, - "source": [ - "### Third Step\n", - "Modify the plotting code plot_common_access_table( ) (in file darshan/experimental/plots/plot_common_access_table.py) to take a single record as input rather than a report object.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "e5feae5d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## Extract data for a specific module (POSIX or MPI-IO)\n", - "# in DataFrame format using the 'records' attribute and\n", - "# the 'to_df()' method\n", - "# NOTE: the returned type here is actually a dictionary, with\n", - "# 2 separate DataFrames: 'counters' (for integer record data)\n", - "# and 'fcounters' (for floating point record data)\n", - "from darshan.experimental.plots import plot_common_access_table\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "## Aggregated multiple log files into a single \"summary\" record.\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "## Obtaining DarshanReportTable object\n", - "plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", - "# print(plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record,\"MPI-IO\"), end=\"\\n\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "8aa13558", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "# POSIX Module\n", - "from darshan.experimental.plots import plot_common_access_table\n", - "posix_recs = report.records['POSIX'].to_df()\n", - "## Aggregated multiple log files into a single \"summary\" record.\n", - "acc_POSIX = accumulate_records(posix_recs, \"POSIX\", report.metadata['job']['nprocs'])\n", - "## Plotting\n", - "plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\")\n", - "print(plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\"))\n", - "print(type(plot_common_access_table.plot_common_access_table(acc_POSIX.summary_record, \"POSIX\")))" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "041a8507", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " id rank MPIIO_INDEP_OPENS MPIIO_COLL_OPENS \\\n", - "0 6301063301082038805 -1 0 2048 \n", - "\n", - " MPIIO_INDEP_READS MPIIO_INDEP_WRITES MPIIO_COLL_READS MPIIO_COLL_WRITES \\\n", - "0 0 18 0 16384 \n", - "\n", - " MPIIO_SPLIT_READS MPIIO_SPLIT_WRITES ... MPIIO_ACCESS3_ACCESS \\\n", - "0 0 0 ... 544 \n", - "\n", - " MPIIO_ACCESS4_ACCESS MPIIO_ACCESS1_COUNT MPIIO_ACCESS2_COUNT \\\n", - "0 328 16384 8 \n", - "\n", - " MPIIO_ACCESS3_COUNT MPIIO_ACCESS4_COUNT MPIIO_FASTEST_RANK \\\n", - "0 2 2 597 \n", - "\n", - " MPIIO_FASTEST_RANK_BYTES MPIIO_SLOWEST_RANK MPIIO_SLOWEST_RANK_BYTES \n", - "0 1073741824 1312 1073741824 \n", - "\n", - "[1 rows x 53 columns]\n", - "\n", - "0 134217728\n", - "Name: MPIIO_ACCESS1_ACCESS, dtype: int64\n", - "\n", - "134217728\n", - "\n", - "16384\n", - "\n", - "\n", - "\n", - "\n" - ] - } - ], - "source": [ - "#Test the indexing and type of dataset\n", - "from darshan.experimental.plots import plot_common_access_table\n", - "posix_recs = report.records['MPI-IO'].to_df()\n", - "acc_MPIIO = accumulate_records(posix_recs, \"MPI-IO\", report.metadata['job']['nprocs'])\n", - "print(acc_MPIIO.summary_record['counters'], end=\"\\n\\n\")\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'], end=\"\\n\\n\")\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS'][0], end=\"\\n\\n\")\n", - "print(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_COUNT'][0], end=\"\\n\\n\")\n", - "print(type(acc_MPIIO.summary_record))\n", - "print(type(acc_MPIIO.summary_record['counters']))\n", - "print(type(acc_MPIIO.summary_record['counters']['MPIIO_ACCESS1_ACCESS']))" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "8094bbba", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Access Size Count\n", - "0 134217728 16384\n", - "1 272 8\n", - "2 544 2\n", - "3 328 2\n", - "\n", - " Access Size Count\n", - "0 272 8\n", - "1 328 2\n", - "2 544 2\n", - "3 134217728 16384\n", - "\n", - " Access Size Count\n", - "0 134217728 16384\n", - "1 272 8\n", - "2 328 2\n", - "3 544 2\n", - "\n", - "html: \n", - "\n" - ] - } - ], - "source": [ - "#Test the functions in plot_common_access_table.py\n", - "df=plot_common_access_table.get_access_count_df(acc_MPIIO.summary_record['counters'],\"MPIIO\")\n", - "print(df, end=\"\\n\\n\")\n", - "df=df.groupby(\"Access Size\").sum().reset_index()\n", - "print(df, end=\"\\n\\n\")\n", - "df=df.sort_values(by=\"Count\", ascending=False, ignore_index=True).head(n=4)\n", - "print(df, end=\"\\n\\n\")\n", - "store_fig=plot_common_access_table.DarshanReportTable(df=df, index=False, border=0)\n", - "print(\"html: \", store_fig, end=\"\\n\\n\")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "7b635a83", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "ename": "TypeError", - "evalue": "'module' object is not callable", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/var/folders/2v/w7p2schn28lghkn75xm2g8d00000gn/T/ipykernel_59538/3743950526.py\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0msummary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_common_access_table\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_MPIIO\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary_record\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"MPI-IO\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;31m# summary.ReportFigure()\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mTypeError\u001b[0m: 'module' object is not callable" - ] - } - ], - "source": [ - "# Generating table ?\n", - "from darshan.cli import summary\n", - "from darshan.experimental.plots import plot_common_access_table\n", - "self=plot_common_access_table.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", - "print(type(self))\n", - "summary.plot_common_access_table(acc_MPIIO.summary_record, \"MPI-IO\")\n", - "# summary.ReportFigure()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "56b88412", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "02589ca3", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "efc48722", - "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.9.7" - }, - "toc": { - "base_numbering": 1, - "nav_menu": {}, - "number_sections": true, - "sideBar": true, - "skip_h1_title": false, - "title_cell": "Table of Contents", - "title_sidebar": "Contents", - "toc_cell": false, - "toc_position": { - "height": "calc(100% - 180px)", - "left": "10px", - "top": "150px", - "width": "165px" - }, - "toc_section_display": true, - "toc_window_display": true - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 0f626ac6ace3fa1139e34aa3fef08bc95e6ae7cf Mon Sep 17 00:00:00 2001 From: Yanli Date: Fri, 7 Jul 2023 15:09:06 -0600 Subject: [PATCH 10/11] Use f-strings to extract the data --- .../plots/plot_access_histogram.py | 86 +++++++------------ 1 file changed, 32 insertions(+), 54 deletions(-) diff --git a/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py b/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py index 7a5bd5be5..4d6b28477 100644 --- a/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py +++ b/darshan-util/pydarshan/darshan/experimental/plots/plot_access_histogram.py @@ -23,7 +23,7 @@ def plot_access_histogram(record, mod, ax=None): Plots a histogram of access sizes for specified module. Args: - record: record to generate plot from + record: a dictionary with 2 separate DataFrames: 'counters' and 'fcounters' mod (str): mod-string for which to generate access_histogram """ @@ -37,59 +37,37 @@ def plot_access_histogram(record, mod, ax=None): # defaults labels = ['0-100', '101-1K', '1K-10K', '10K-100K', '100K-1M', '1M-4M', '4M-10M', '10M-100M', '100M-1G', '1G+'] - agg=record['counters'] - if mod == 'POSIX': - read_vals = [ - agg['POSIX_SIZE_READ_0_100'][0], - agg['POSIX_SIZE_READ_100_1K'][0], - agg['POSIX_SIZE_READ_1K_10K'][0], - agg['POSIX_SIZE_READ_10K_100K'][0], - agg['POSIX_SIZE_READ_100K_1M'][0], - agg['POSIX_SIZE_READ_1M_4M'][0], - agg['POSIX_SIZE_READ_4M_10M'][0], - agg['POSIX_SIZE_READ_10M_100M'][0], - agg['POSIX_SIZE_READ_100M_1G'][0], - agg['POSIX_SIZE_READ_1G_PLUS'][0] - ] - - write_vals = [ - agg['POSIX_SIZE_WRITE_0_100'][0], - agg['POSIX_SIZE_WRITE_100_1K'][0], - agg['POSIX_SIZE_WRITE_1K_10K'][0], - agg['POSIX_SIZE_WRITE_10K_100K'][0], - agg['POSIX_SIZE_WRITE_100K_1M'][0], - agg['POSIX_SIZE_WRITE_1M_4M'][0], - agg['POSIX_SIZE_WRITE_4M_10M'][0], - agg['POSIX_SIZE_WRITE_10M_100M'][0], - agg['POSIX_SIZE_WRITE_100M_1G'][0], - agg['POSIX_SIZE_WRITE_1G_PLUS'][0] - ] - elif mod == 'MPI-IO': - read_vals = [ - agg['MPIIO_SIZE_READ_AGG_0_100'][0], - agg['MPIIO_SIZE_READ_AGG_100_1K'][0], - agg['MPIIO_SIZE_READ_AGG_1K_10K'][0], - agg['MPIIO_SIZE_READ_AGG_10K_100K'][0], - agg['MPIIO_SIZE_READ_AGG_100K_1M'][0], - agg['MPIIO_SIZE_READ_AGG_1M_4M'][0], - agg['MPIIO_SIZE_READ_AGG_4M_10M'][0], - agg['MPIIO_SIZE_READ_AGG_10M_100M'][0], - agg['MPIIO_SIZE_READ_AGG_100M_1G'][0], - agg['MPIIO_SIZE_READ_AGG_1G_PLUS'][0] - ] - - write_vals = [ - agg['MPIIO_SIZE_WRITE_AGG_0_100'][0], - agg['MPIIO_SIZE_WRITE_AGG_100_1K'][0], - agg['MPIIO_SIZE_WRITE_AGG_1K_10K'][0], - agg['MPIIO_SIZE_WRITE_AGG_10K_100K'][0], - agg['MPIIO_SIZE_WRITE_AGG_100K_1M'][0], - agg['MPIIO_SIZE_WRITE_AGG_1M_4M'][0], - agg['MPIIO_SIZE_WRITE_AGG_4M_10M'][0], - agg['MPIIO_SIZE_WRITE_AGG_10M_100M'][0], - agg['MPIIO_SIZE_WRITE_AGG_100M_1G'][0], - agg['MPIIO_SIZE_WRITE_AGG_1G_PLUS'][0] - ] + counters=record['counters'] + if mod == 'MPI-IO': + rd_counter_prefix = f'MPIIO_SIZE_READ_AGG_' + wr_counter_prefix = f'MPIIO_SIZE_WRITE_AGG_' + else: + rd_counter_prefix = f'{mod}_SIZE_READ_' + wr_counter_prefix = f'{mod}_SIZE_WRITE_' + read_vals = [ + counters[f'{rd_counter_prefix}0_100'][0], + counters[f'{rd_counter_prefix}100_1K'][0], + counters[f'{rd_counter_prefix}1K_10K'][0], + counters[f'{rd_counter_prefix}10K_100K'][0], + counters[f'{rd_counter_prefix}100K_1M'][0], + counters[f'{rd_counter_prefix}1M_4M'][0], + counters[f'{rd_counter_prefix}4M_10M'][0], + counters[f'{rd_counter_prefix}10M_100M'][0], + counters[f'{rd_counter_prefix}100M_1G'][0], + counters[f'{rd_counter_prefix}1G_PLUS'][0] + ] + write_vals = [ + counters[f'{wr_counter_prefix}0_100'][0], + counters[f'{wr_counter_prefix}100_1K'][0], + counters[f'{wr_counter_prefix}1K_10K'][0], + counters[f'{wr_counter_prefix}10K_100K'][0], + counters[f'{wr_counter_prefix}100K_1M'][0], + counters[f'{wr_counter_prefix}1M_4M'][0], + counters[f'{wr_counter_prefix}4M_10M'][0], + counters[f'{wr_counter_prefix}10M_100M'][0], + counters[f'{wr_counter_prefix}100M_1G'][0], + counters[f'{wr_counter_prefix}1G_PLUS'][0] + ] #TODO: add support for HDF5/PnetCDF modules x = np.arange(len(labels)) # the label locations width = 0.35 # the width of the bars From 5abaeb077607bfd2d6f5f32f4a5991c7ec4ba7bf Mon Sep 17 00:00:00 2001 From: Yanli Date: Fri, 7 Jul 2023 15:13:45 -0600 Subject: [PATCH 11/11] add details to comments on the record --- .../darshan/experimental/plots/plot_common_access_table.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py b/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py index 9e4f8ed57..b20171789 100644 --- a/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py +++ b/darshan-util/pydarshan/darshan/experimental/plots/plot_common_access_table.py @@ -83,7 +83,7 @@ def get_access_count_df(mod_df: Any, mod: str) -> Any: Parameters ---------- mod_df: "counters" dataframe for the input - module `mod` from a record. + module `mod` from a dictionary with 2 separate DataFrames: 'counters' and 'fcounters'. mod: the module to obtain the common accesses table for (i.e "POSIX", "MPI-IO", "H5D"). @@ -128,7 +128,7 @@ def plot_common_access_table(record: dict, mod: str, n_rows: int = 4) -> Darshan Parameters ---------- - record: a dict. + record: a dictionary with 2 separate DataFrames: 'counters' and 'fcounters' mod: the module to obtain the common access size table for (i.e "POSIX", "MPI-IO", "H5D").