diff --git a/README.md b/README.md index ebbfbf7..4676697 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,324 @@ -# oasis-hurricane +# oasishurricane + +[![image](https://github.com/mtazzari/oasishurricane/actions/workflows/tests.yml/badge.svg)](https://github.com/mtazzari/oasishurricane/actions/workflows/tests.yml) +[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)] + A Python command-line utility for Linux that computes the economic loss for hurricanes in Florida and in the Gulf states + +## Installation +As easy as + +```bash +pip git+https://github.com/mtazzari/OasisHurricane.git +``` + +or, if you prefer to have the code locally, first clone the github repo and then install it with: + +```bash +git clone https://github.com/mtazzari/OasisHurricane.git +cd OasisHurricane +pip install . +``` + +## Basic usage +Once installed, the requested Python command line utility has the following interface: +```bash +$ gethurricaneloss -h +usage: use "gethurricaneloss --help" for more information + +A Python command-line utility for Linux that computes the economic loss for hurricanes in Florida and in the Gulf states. + +positional arguments: + florida_landfall_rate + [float] annual rate of landfalling hurricanes in Florida. + florida_mean [float] mean of the economic loss of landfalling hurricane in Florida. + florida_stddev [float] std deviation of the economic loss of landfalling hurricane in Florida. + gulf_landfall_rate [float] annual rate of landfalling hurricanes in Gulf states. + gulf_mean [float] mean of the economic loss of landfalling hurricane in Gulf states. + gulf_stddev [float] std deviation of the economic loss of landfalling hurricane in Gulf states. + +optional arguments: + -h, --help show this help message and exit + -n NUM_MONTE_CARLO_SAMPLES, --num_monte_carlo_samples NUM_MONTE_CARLO_SAMPLES + [int] number of monte carlo samples, i.e. years. (default=10) + -s SIMULATOR_ID, --simulator SIMULATOR_ID + [int] simulator id (default=0). Implemented simulators: (id:name) + 0: python + 1: jit + 2: jit-parallel + 3: jit-noloops + 4: python-noloops + 5: jit-parallel-fastmath +``` +The positional parameters are required for execution. + +The utility has **6 different implementations** of the proposed Monte Carlo hurricane losses model, which can be selected +with the `-s` or `--simulator` option by providing the `id` of the simulator. The implementations achieve different levels +of acceleration w.r.t. the baseline pure-`python` implementation. + +The implementations are: + +| ID | Simulator | Description | +| --- | ------------------------- | ----------- | +| 0 | `python` | a pure Python implementation of the algorithm outlined in the test sheet. Used as a reference for accuracy and performance benchmarks. | +| 1 | `jit` | the same algorithm as in `python`, with `numba` just-in-time compilation | +| 2 | `jit-parallel` | the same algorithm as in `python`, with `numba` just-in-time compilation **and** `numba` automatic | +| 3 | `jit-noloops` | a `numpy`-only algorithm with **no explicit loops**, with `numba` just-in-time compilation | +| 4 | `python-noloops` | a pure Python`numpy`-only algorithm with **no explicit loops** | +| 5 | `jit-parallel-fastmath` | the same algorithm as in `jit-parallel`, with additional `fastmath` enabled, GIL released, and the declaration of data types | + +## Examples +Let us run a series of examples in which the losses are highly peaked around the +mean loss values. Since the events are all independent, the expected mean loss value is +```bash +florida_landfall_rate * florida_mean + gulf_landfall_rate * gulf_mean +``` +it's easy to verify whether the result is about correct. + +### Example 1: get started with `gethurricaneloss` +`gethurricaneloss` is easy to use. + +Let us run it with 100k Monte Carlo steps (i.e., years): +```bash +$ gethurricaneloss 10 5 0.00001 30 1 0.00001 -n 100000 +[2021-11-04 16:33:01] gethurricaneloss v0.0.1 by Marco Tazzari +[2021-11-04 16:33:01] Validated parameters: +[2021-11-04 16:33:01] florida_landfall_rate = 10.00000 +[2021-11-04 16:33:01] florida_mean = 1.60944 +[2021-11-04 16:33:01] florida_stddev = 0.00001 +[2021-11-04 16:33:01] gulf_landfall_rate = 30.00000 +[2021-11-04 16:33:01] gulf_mean = 0.00000 +[2021-11-04 16:33:01] gulf_stddev = 0.00001 +[2021-11-04 16:33:01] Using simulator: python +[2021-11-04 16:33:01] Setting the random number generator with seed:None +[2021-11-04 16:33:01] Starting main loop over desired 100000 Monte Carlo samples +[2021-11-04 16:33:12] End of main loop. Elapsed time: 0:00:11.463529 (h:m:s) +[2021-11-04 16:33:12] MEAN LOSS: 79.96644884090169 +79.96644884090169 +``` +By default, `gethurricaneloss` uses the `python` simulator. + +Note that the last line of the console output is the mean loss: this is because the test sheet required +the CLI utility to return the expected mean economic loss. + + +> **Note:** the `validated parameters` printed in the console/log show the values of the parameters after validation (type- and value-checking), and transformation, if necessary. + +> **Note:** `florida_mean` and `gulf_mean` printed in the console/log are the natural log of the values +passed in input by the user: the transformation ensures that the expected value of the lognormal distribution +is the value of `florida_mean` passed by the user (as opposed to `exp^florida_mean`). The same applies to `gulf_mean`. + +### Example 2: run `gethurricaneloss` with a different simulator +Let us now run `gethurricaneloss` using the `python-noloops` simulator (id: 4) by passing the `-s4` option. +```bash +$ gethurricaneloss 10 5 0.00001 30 1 0.00001 -n 100000 -s4 +[2021-11-04 16:44:03] gethurricaneloss v0.0.1 by Marco Tazzari +[2021-11-04 16:44:03] Validated parameters: +[2021-11-04 16:44:03] florida_landfall_rate = 10.00000 +[2021-11-04 16:44:03] florida_mean = 1.60944 +[2021-11-04 16:44:03] florida_stddev = 0.00001 +[2021-11-04 16:44:03] gulf_landfall_rate = 30.00000 +[2021-11-04 16:44:03] gulf_mean = 0.00000 +[2021-11-04 16:44:03] gulf_stddev = 0.00001 +[2021-11-04 16:44:03] Using simulator: python-noloops +[2021-11-04 16:44:03] Setting the random number generator with seed:None +[2021-11-04 16:44:03] Starting main loop over desired 100000 Monte Carlo samples +[2021-11-04 16:44:03] End of main loop. Elapsed time: 0:00:00.174803 (h:m:s) +[2021-11-04 16:44:03] MEAN LOSS: 80.01731942131745 +80.01731942131745 +``` +This is waaaay faster! 0.17s vs 11.46s compared to the explicit-loop Python version (`python` simulator), a 67x speed-up! + +## Logging +Logging is handled with the `logging` Python module: + +- the **console** shows a concise and easy-to-read log; +- a **development logfile** stores the debug-level logs (typically named `gethurricaneloss_dev.log.x`); +- a **production logfile** stores a production-level (info and above) logs (typically named `gethurricaneloss.log.x`). + +The numerical `.x` suffix (e.g., `.1`, `.2`, ...) in the log filenames allows for a rotating log file handling, for logs +of large volume. + +## Testing +Testing uses `pytest` and is performed automatically with GitHub Actions on every push on any branch. + +Note that GitHub Actions is free for an unlimited amount of compute-minutes for open source projects. + +I implemented three tests, with a matrix of parametrizations: + +| test name | test description | +| ---------------------------------- | ----------------------------------------------------------- | +| `test_simulators_accuracy` | Test if the different simulators return mean losses that agree within a relative tolerance `rtol` and an absolute tolerance `atol`. | +| `test_simulator_selection` | Test exceptions if the chosen simulator_id doesn't exist. | +| `test_input_parameter_values` | Test exceptions if input data has forbidden values. | + +All the three tests use `pytest.mark.parametrize`, which allows repeating the same test with different +input parameters, handy to test the validity of a test under different scenarios. + +To keep the tests reproducible, I fix the random seed to the `SEED` defined in `tests.py`. + +Additional tests that it would be easy to implement: + +- a test against analytical expected values for the mean loss, considering that the expectation values for + the Poissonian is the `mean` (i.e., `florida_landfall_rate`) and the expected values for the LogNormal is + again the `mean` (i.e., `florida_mean`). + +- a test to check the CLI usage from a shell (e.g., using `subprocess`). + +- additional convergence checks for different regimes of the input parameters. + +## Accuracy checks +Accuracy is checked in the tests. + +In particular, `test_simulators_accuracy` checks that all the implementations of the hurricane loss model return mean loss +values within a given accuracy, for 3 different sets of input parameters. + +To have relatively quick checks, the threshold accuracy is now set to 1%, but it can be +made smaller (i.e. tighter constraint), at the cost of longer CI tests. + +## Performance +In order to test the performance of the implemented simulators I adopt a Factory design patter for the +`Simulator` class, e.g.: + +```py +from oasishurricane.simulator import Simulator + +sim = Simulator(simulator_id=1) +``` +Regardless of the chosen simulator, the MC simulation is run with: +```py +sim.simulate(**validated_parameters) +``` +where `validated_parameters` are the CLI input parameters after validation. + +This architecture allows for a modular and quick replacement of the core MC model. + +To properly evaluate the performance of the simulators I defined an ad-hoc decorator `oasishurricane.utils.timer` +which: + +- runs the simulator core function for the desired number of `cycles`, +- momentarily deactivates the garbage collector, +- computes the best execution time among the `cycles` execution times. + +For reference: in developing `oasishurricane.utils.timer`, I follow the nomenclature of `timeit.Timer`. + +The timing functionality can be activated by setting the `TIMEIT` environment variable, e.g. +```bash +export TIMEIT=1 +``` +Additional parameters to customize the timing functionality are: + +- `TIMEIT_CYCLES`: the number of times the simulator core function is executed. The larger, the better, but + for large `num_monte_carlo_samples` it might be handy to reduce it. If not set, `cycles=3`. +- `TIMEIT_LOGFILE`: the filename of the log where to store the timings. If not set, it prints to the console log. + +### Examples +With this setup: +```bash +export TIMEIT=1 +export TIMEIT_CYCLES=33 +export TIMEIT_LOGFILE=timings_example.txt +``` +we obtain the following output in the console: +```bash +$ gethurricaneloss 10 2 0.001 30 1 0.000001 -n 1000 -s3 +[2021-11-05 01:25:52] gethurricaneloss v0.0.1 by Marco Tazzari +[2021-11-05 01:25:52] Validated parameters: +[2021-11-05 01:25:52] florida_landfall_rate = 10.00000 +[2021-11-05 01:25:52] florida_mean = 0.69315 +[2021-11-05 01:25:52] florida_stddev = 0.00100 +[2021-11-05 01:25:52] gulf_landfall_rate = 30.00000 +[2021-11-05 01:25:52] gulf_mean = 0.00000 +[2021-11-05 01:25:52] gulf_stddev = 0.00000 +[2021-11-05 01:25:52] Found TIMEIT and TIMEIT_LOGFILE: timings will be logged in timings_example.txt +[2021-11-05 01:25:52] Using simulator: jit-noloops +[2021-11-05 01:25:52] Setting the random number generator with seed:None +[2021-11-05 01:25:52] Starting main loop over desired 1000 Monte Carlo samples +[2021-11-05 01:25:52] Timings are computed by running 33 times the function. +[2021-11-05 01:25:53] End of main loop. Elapsed time: 0:00:00.478656 (h:m:s) +[2021-11-05 01:25:53] MEAN LOSS: 49.98602443852616 +49.98602443852616 +``` +This is the content of `timings_example.txt`: +```text + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 33 0.001399 49.986024 +``` +where the columns are: + +- `florida_landfall_rate` +- `ln(florida_mean)` +- `florida_stddev` +- `gulf_landfall_rate` +- `ln(gulf_mean)` +- `gulf_stddev` +- `num_monte_carlo_samples` +- `cycles` +- `best execution time` +- Mean economic loss + +By running multiple times `gethurricaneloss` with the environment variables as above, the timings are appended, e.g.: +```text + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000013 49.966121 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000133 50.037439 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.001401 49.991665 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.014170 50.000415 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.144798 49.999268 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 1.464731 50.000486 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 14.800176 50.001481 +``` + +Timing functionality is deactivated by unsetting `TIMEIT`: +```bash +unset TIMEIT +``` + +### Results +To quantify the performance of the different implementations I wrote a simple bash script (benchmark/benchmark.sh) +to compute the execution times of all the simulators, each of them for a range of `num_monte_carlo_samples` +between 10 and 10 millions. + +All the execution times are in the `benchmark/timings/` folder, e.g. `timings_s0.txt` for `simulator_id=0` (`python`). + +For reference, all the timings were performed on an Apple Macbook Pro (13-inch 2019) with a 2.4 GHz Intel Core i5 and 16 GB 2133 MHz LPDDR3 of RAM. + +In this plot I present the scaling as a function of `num_monte_carlo_samples`: +

+ +

+ +**Comments:** + +- the scaling is pretty much linear (cf. reference dashed line) for all the implementations. +- the pure `python` implementation is, as expected, the least efficient. +- the `numba.jit` compilation achieves a 75x speed-up when applied to the `python` implementation (`jit`), roughly the same speed-up achieved by implementations with no explicit loops (`jit-noloops`). +- using only numpy functions with no explicit loops achieves a very good acceleration as well (75x w.r.t. `python`), + without the need of `numba.jit`. +- `numba.jit` with `parallel` option is further 5.7x faster than the `jit` version. Overall, the `jit-parallel` + version is 390x faster than pure `python`. + +The following plot shows the speedups over the `python` implementation: +

+ +

+ +In the following figure I show the convergence of the mean economic losses for increasing `num_monte_carlo_samples`. +

+ +

+ +Comments: + +- as expected, with increasing `num_monte_carlo_samples`, all the implementations tend towards the + same expected value (dashed line at mean loss=50 $B). +- the pure `python` implementation is slightly slower in converging than the others. + +## Author + +- [Marco Tazzari](https://github.com/mtazzari) + +## License +**oasishurricane** is free software licensed under the BSD-3 License. For more details see +the [LICENSE](https://github.com/mtazzari/oasishurricane/blob/main/LICENSE). + +© Copyright 2021 Marco Tazzari. + diff --git a/benchmark/benchmark.sh b/benchmark/benchmark.sh new file mode 100644 index 0000000..d5fb7e2 --- /dev/null +++ b/benchmark/benchmark.sh @@ -0,0 +1,59 @@ +# bash script to run all the benchmarks + +TIMINGS_LOGS_DIR="timings" + + +# simulator 0 +export TIMEIT=1 +export TIMEIT_CYCLES=100 +export TIMEIT_LOGFILE="${TIMINGS_LOGS_DIR}/timings_s0.txt" + +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 10 -s0 +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 100 -s0 +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 1000 -s0 +export TIMEIT_CYCLES=10 +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 100000 -s0 +export TIMEIT_CYCLES=4 +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 1000000 -s0 +export TIMEIT_CYCLES=2 +gethurricaneloss 10 2 0.001 30 1 0.000001 -n 10000000 -s0 # <-- THIS TAKES **A LOT** (~30 mins on Macbook Pro 2019) + + +# simulators 1, 2, 3, 4 +export TIMEIT_CYCLES=1000 + +num_monte_carlo_samples="10 100 1000 10000 100000" #manca 100000 +simulator_ids="1 2 3 4 5" + +for simulator_id in $simulator_ids; do + for num_monte_carlo_sample in $num_monte_carlo_samples; do + export TIMEIT_LOGFILE="${TIMINGS_LOGS_DIR}/timings_s${simulator_id}.txt"; + gethurricaneloss 10 2 0.001 30 1 0.000001 -n ${num_monte_carlo_sample} -s${simulator_id}; + done +done + +# run the largest MC simulations with reduced TIMEIT_CYCLES +export TIMEIT_CYCLES=50 + +num_monte_carlo_samples="1000000" +simulator_ids="1 2 3 4 5" + +for simulator_id in $simulator_ids; do + for num_monte_carlo_sample in $num_monte_carlo_samples; do + export TIMEIT_LOGFILE="${TIMINGS_LOGS_DIR}/timings_s${simulator_id}.txt"; + gethurricaneloss 10 2 0.001 30 1 0.000001 -n ${num_monte_carlo_sample} -s${simulator_id}; + done +done + +# run the largest MC simulations with reduced TIMEIT_CYCLES +export TIMEIT_CYCLES=5 + +num_monte_carlo_samples="10000000" +simulator_ids="1 2 3 4 5" + +for simulator_id in $simulator_ids; do + for num_monte_carlo_sample in $num_monte_carlo_samples; do + export TIMEIT_LOGFILE="${TIMINGS_LOGS_DIR}/timings_s${simulator_id}.txt"; + gethurricaneloss 10 2 0.001 30 1 0.000001 -n ${num_monte_carlo_sample} -s${simulator_id}; + done +done \ No newline at end of file diff --git a/benchmark/execution_time_vs_num_monte_carlo_samples.png b/benchmark/execution_time_vs_num_monte_carlo_samples.png new file mode 100644 index 0000000..50317f5 Binary files /dev/null and b/benchmark/execution_time_vs_num_monte_carlo_samples.png differ diff --git a/benchmark/mean_loss_vs_num_monte_carlo_samples.png b/benchmark/mean_loss_vs_num_monte_carlo_samples.png new file mode 100644 index 0000000..65ce1d2 Binary files /dev/null and b/benchmark/mean_loss_vs_num_monte_carlo_samples.png differ diff --git a/benchmark/plot_timing_results.ipynb b/benchmark/plot_timing_results.ipynb new file mode 100644 index 0000000..71c74d0 --- /dev/null +++ b/benchmark/plot_timing_results.ipynb @@ -0,0 +1,281 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2242b35b", + "metadata": {}, + "source": [ + "# Plotting notebook\n" + ] + }, + { + "cell_type": "markdown", + "id": "b316ec5b", + "metadata": {}, + "source": [ + "Notebook to plot timing results and study the performance of the code.\n", + "\n", + "by Marco Tazzari." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "12180de4", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from glob import glob\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "63783e85", + "metadata": {}, + "outputs": [], + "source": [ + "try:\n", + " import matplotlib as mpl\n", + " import matplotlib.pyplot as plt\n", + "except ModuleNotFoundError:\n", + " print(\"matplotlib not found: I will now install it!\")\n", + " !pip install matplotlib\n", + "finally:\n", + " import matplotlib as mpl\n", + " import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "0da8395e", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "# % mpl\n", + "mpl.rcParams['figure.figsize'] = (6, 6)\n", + "mpl.rcParams['font.size'] = 10\n", + "mpl.rcParams['font.weight'] = 'normal'\n", + "mpl.rcParams['axes.linewidth'] = 1.2\n", + "mpl.rcParams['xtick.major.pad'] = 8\n" + ] + }, + { + "cell_type": "markdown", + "id": "e3e6e93c", + "metadata": {}, + "source": [ + "## Read timing logs" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "465111c5", + "metadata": {}, + "outputs": [], + "source": [ + "fnames = glob(\"timings/*.txt\")\n", + "\n", + "fnames = sorted(glob(\"timings/*.txt\"))\n", + "data = {}\n", + "for fname in fnames:\n", + " simulator_id = os.path.splitext(fname)[0][-1]\n", + " data[simulator_id] = np.loadtxt(fname)\n", + "\n", + "# extrapolate timing for `python` (id=0) for N=1e7\n", + "# (just for the sake of speed in returning the test; the timing takes 30 mins)\n", + "d = data[\"0\"].copy()\n", + "new_entry = d[-1].copy()\n", + "new_entry[6] = 1e7\n", + "new_entry[8] = 0.1*0.001*1e7 # roughly linear extrapolation\n", + "data[\"0\"] = np.concatenate((d, new_entry[None, :]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e3d522d6", + "metadata": {}, + "outputs": [], + "source": [ + "# descriptions of simulators\n", + "desc = {\n", + " '0': 'python',\n", + " '1': 'jit',\n", + " '2': 'jit-parallel',\n", + " '3': 'jit-noloops',\n", + " '4': 'python-noloops',\n", + " '5': 'jit-parallel-fastmath',\n", + "}" + ] + }, + { + "cell_type": "markdown", + "id": "062335e5", + "metadata": {}, + "source": [ + "## Plot the timing and convergence results" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "36f87c90", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(3, 3), dpi=200, facecolor='w')\n", + "\n", + "s_to_ms = 1e3 # factor to convert from seconds (measured) to ms (plotted)\n", + "\n", + "ax.plot(np.logspace(1, 7), 0.01*np.logspace(1, 7), 'k--',\n", + " lw=0.5,\n", + " label='linear (reference)')\n", + "\n", + "for simulator_id, data_ in data.items():\n", + " ax.plot(data_[:, 6], data_[:, 8]*s_to_ms, '.-', \n", + " lw=0.5,\n", + " label=desc[simulator_id])\n", + "\n", + "ax.grid(lw=0.2, which=\"both\", axis='both')\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xticks(data[\"0\"][:, 6])\n", + "\n", + "ax.set_xlabel(\"num_monte_carlo_samples\", fontsize=9)\n", + "ax.set_ylabel(\"t [ms]\", fontsize=9)\n", + "\n", + "ax.legend(fontsize=7, labelspacing=0.15, handletextpad=0.1, frameon=True)\n", + "\n", + "fig.savefig('execution_time_vs_num_monte_carlo_samples.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d1ee4e5c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(3, 3), dpi=200, facecolor='w')\n", + "\n", + "# baseline: `python` id=0\n", + "baseline = data[\"0\"][:, 8]\n", + "\n", + "for simulator_id, data_ in data.items():\n", + " ax.plot(data_[:, 6], baseline/data_[:, 8], '.-', \n", + " lw=0.5,\n", + " label=desc[simulator_id])\n", + "\n", + "ax.grid(lw=0.2, which=\"both\", axis='both')\n", + "\n", + "ax.set_xscale('log')\n", + "\n", + "ax.set_xticks(data[\"0\"][:, 6])\n", + "\n", + "ax.set_xlabel(\"num_monte_carlo_samples\", fontsize=9)\n", + "ax.set_ylabel(\"speedup\", fontsize=9)\n", + "\n", + "ax.legend(fontsize=7, labelspacing=0.15, handletextpad=0.1, frameon=True)\n", + "\n", + "fig.savefig('speedup_vs_num_monte_carlo_samples.png', bbox_inches='tight')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "5e5cfb28", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 1, figsize=(3, 3), dpi=200, facecolor='w')\n", + "\n", + "ax.plot(np.logspace(1, 7), 50.*np.ones(50), 'k--',\n", + " lw=0.5,\n", + " label='expected value (50)')\n", + "\n", + "for simulator_id, data_ in data.items():\n", + " ax.plot(data_[:, 6], data_[:, 9], '.-', \n", + " lw=0.5,\n", + " label=desc[simulator_id])\n", + "\n", + "ax.grid(lw=0.2, which=\"both\", axis='both')\n", + "\n", + "ax.set_xscale('log')\n", + "\n", + "ax.set_xticks(data[\"0\"][:, 6])\n", + "\n", + "ax.set_xlabel(\"num_monte_carlo_samples\", fontsize=9)\n", + "ax.set_ylabel(\"Mean loss [$B]\", fontsize=9)\n", + "\n", + "ax.legend(fontsize=7, labelspacing=0.15, handletextpad=0.5, frameon=True, loc='lower right')\n", + "\n", + "fig.savefig('mean_loss_vs_num_monte_carlo_samples.png', bbox_inches='tight')" + ] + } + ], + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/benchmark/speedup_vs_num_monte_carlo_samples.png b/benchmark/speedup_vs_num_monte_carlo_samples.png new file mode 100644 index 0000000..878e24f Binary files /dev/null and b/benchmark/speedup_vs_num_monte_carlo_samples.png differ diff --git a/benchmark/timings/timings_s0.txt b/benchmark/timings/timings_s0.txt new file mode 100644 index 0000000..715eab2 --- /dev/null +++ b/benchmark/timings/timings_s0.txt @@ -0,0 +1,6 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 100 0.000914 50.087758 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 100 0.010028 49.988582 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 100 0.101372 49.983956 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 100 1.040224 49.992674 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 10 10.038142 49.980640 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 4 105.049747 50.000562 diff --git a/benchmark/timings/timings_s1.txt b/benchmark/timings/timings_s1.txt new file mode 100644 index 0000000..9dfa550 --- /dev/null +++ b/benchmark/timings/timings_s1.txt @@ -0,0 +1,7 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000013 49.966121 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000133 50.037439 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.001401 49.991665 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.014170 50.000415 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.144798 49.999268 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 1.464731 50.000486 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 14.800176 50.001481 diff --git a/benchmark/timings/timings_s2.txt b/benchmark/timings/timings_s2.txt new file mode 100644 index 0000000..726af2a --- /dev/null +++ b/benchmark/timings/timings_s2.txt @@ -0,0 +1,7 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000042 49.797800 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000065 50.027264 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.000302 50.002490 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.002653 50.000720 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.029597 49.999877 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 0.273513 49.998960 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 2.935461 50.002490 diff --git a/benchmark/timings/timings_s3.txt b/benchmark/timings/timings_s3.txt new file mode 100644 index 0000000..20309c7 --- /dev/null +++ b/benchmark/timings/timings_s3.txt @@ -0,0 +1,7 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000014 50.119241 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000139 49.950395 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.001394 49.983407 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.014457 50.006514 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.150629 49.999678 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 1.609194 50.000586 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 16.547855 50.000416 diff --git a/benchmark/timings/timings_s4.txt b/benchmark/timings/timings_s4.txt new file mode 100644 index 0000000..7c02903 --- /dev/null +++ b/benchmark/timings/timings_s4.txt @@ -0,0 +1,7 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000040 49.928014 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000166 49.999524 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.001432 49.987668 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.014547 49.999203 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.150475 49.998460 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 1.632011 49.999781 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 16.701602 49.999752 diff --git a/benchmark/timings/timings_s5.txt b/benchmark/timings/timings_s5.txt new file mode 100644 index 0000000..eae8b6c --- /dev/null +++ b/benchmark/timings/timings_s5.txt @@ -0,0 +1,7 @@ + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10.000000 1000 0.000041 49.950534 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100.000000 1000 0.000063 49.969032 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000.000000 1000 0.000284 50.000781 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000.000000 1000 0.002494 49.997507 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 100000.000000 1000 0.026746 50.000624 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 1000000.000000 50 0.296471 50.002018 + 10.000000 0.693147 0.001000 30.000000 0.000000 0.000001 10000000.000000 5 3.050854 49.999555 diff --git a/oasishurricane/cli.py b/oasishurricane/cli.py index f9460e9..df2dc6c 100644 --- a/oasishurricane/cli.py +++ b/oasishurricane/cli.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # coding=utf-8 - +import os import sys import argparse import numpy as np @@ -13,21 +13,22 @@ logging.config.dictConfig(LOGGING) logger = logging.getLogger("cli") -from .model import Simulator, SIMULATORS - +from .simulator import Simulator, SIMULATORS +from . import __version__ def parse_args(): """ + Parse arguments from CLI. + + :return: [dict] Parsed arguments. - :return: """ parser = argparse.ArgumentParser( + description="A Python command-line utility for Linux that computes the economic loss for hurricanes in Florida and in the Gulf states.", usage='use "%(prog)s --help" for more information', formatter_class=argparse.RawTextHelpFormatter # for multi-line help text ) - # parser = parser.add_argument_group('parser arguments') - parser.add_argument("florida_landfall_rate", action="store", help="[float] annual rate of landfalling hurricanes in Florida.", @@ -60,12 +61,11 @@ def parse_args(): default=10) parser.add_argument("-s", "--simulator", action="store", - help="[int] simulator id. Implemented simulators: (id:name) \n" + \ + help="[int] simulator id (default=0). Implemented simulators: (id:name) \n" + \ "\n".join([f"{k}: {v['desc']}" for k, v in SIMULATORS.items()]), type=int, dest="simulator_id", default=0) - args = vars(parser.parse_args()) # convert to dict for ease of use return args @@ -130,13 +130,26 @@ def validate_args(args): for arg_k in numerical_args: logger.info(f"{arg_k:>30s} = {validated_args[arg_k]:>10.5f}") + if os.getenv("TIMEIT"): + if os.getenv("TIMEIT_LOGFILE"): + logger.info( + f"Found TIMEIT and TIMEIT_LOGFILE: timings will be logged in {os.getenv('TIMEIT_LOGFILE')}") + else: + logger.info("Found TIMEIT: logging timings to the console.") return validated_args def main(args=None): """ Main function, called through the shell entrypoint. - # TODO: IMPROVE DOCS + If no args are passed, the function assumes it is called as a CLI and parses the args from the shell. + If args are passed (e.g., when testing), then the args are not parsed. + In any case, the args are validated. + If used as a CLI, the function terminates the program, otherwise it returns the mean loss. + + :param args: [dict] CLI arguments (default=None). + + :return mean_loss: [float,optional] The mean economic loss. """ as_CLI = False @@ -146,6 +159,9 @@ def main(args=None): as_CLI = True args = parse_args() + # splash message + logger.info(f"gethurricaneloss v{__version__} by Marco Tazzari") + # validate (and transform, if necessary) arguments validated_args = validate_args(args) @@ -156,6 +172,7 @@ def main(args=None): mean_loss = sim.simulate(**validated_args) if as_CLI: + print(mean_loss) sys.exit(0) else: return mean_loss diff --git a/oasishurricane/logs.py b/oasishurricane/logs.py index dd69001..3cdd131 100644 --- a/oasishurricane/logs.py +++ b/oasishurricane/logs.py @@ -3,6 +3,7 @@ import os +# setup the directories for namespacing BASE_DIR = os.path.curdir LOGS_DIR = BASE_DIR @@ -12,11 +13,15 @@ DEVELOPMENT_LOGFILE = os.path.join(LOGS_DIR, DEV_LOGFILE) PRODUCTION_LOGFILE = os.path.join(LOGS_DIR, PROD_LOGFILE) - +# define logging config LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { + 'concise': { + 'format': '[%(asctime)s] %(message)s', + 'datefmt': '%Y-%m-%d %H:%M:%S' + }, 'simple': { 'format': '[%(asctime)s] %(levelname)6s %(message)s', 'datefmt': '%Y-%m-%d %H:%M:%S' @@ -30,7 +35,7 @@ 'console': { 'level': 'INFO', 'class': 'logging.StreamHandler', - 'formatter': 'simple' + 'formatter': 'concise' }, 'development_logfile': { 'level': 'DEBUG', diff --git a/oasishurricane/model.py b/oasishurricane/simulator.py similarity index 82% rename from oasishurricane/model.py rename to oasishurricane/simulator.py index 071ccfd..fded569 100644 --- a/oasishurricane/model.py +++ b/oasishurricane/simulator.py @@ -1,10 +1,11 @@ #!/usr/bin/env python # coding=utf-8 -import numpy as np +import os import logging import time import datetime +import numpy as np from numba import jit, njit, prange logging.getLogger('numba').setLevel(logging.WARNING) @@ -24,10 +25,9 @@ def get_rng(seed=None): return np.random.default_rng(seed) -@timer +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) def mean_loss_py(florida_landfall_rate, florida_mean, florida_stddev, - gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples, - timeit_discard=False): + gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples): """ Compute mean economic loss in Pure Python. @@ -38,7 +38,6 @@ def mean_loss_py(florida_landfall_rate, florida_mean, florida_stddev, :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. - :param timeit_discard: [bool] (optional) If True, @timer does not record the timing. Only used by @timer. :return: [float] Mean annual losses. @@ -64,11 +63,10 @@ def mean_loss_py(florida_landfall_rate, florida_mean, florida_stddev, return tot_loss / num_monte_carlo_samples -@timer +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) @jit(nopython=True) def mean_loss_jit(florida_landfall_rate, florida_mean, florida_stddev, - gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples, - timeit_discard=False): + gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples): """ Compute mean economic loss with explicit loops and jit-compilation with numba. @@ -79,7 +77,6 @@ def mean_loss_jit(florida_landfall_rate, florida_mean, florida_stddev, :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. - :param timeit_discard: [bool] (optional) If True, @timer does not record the timing. Only used by @timer. :return: [float] Mean annual losses. @@ -106,11 +103,10 @@ def mean_loss_jit(florida_landfall_rate, florida_mean, florida_stddev, return tot_loss / num_monte_carlo_samples -@timer +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) @njit(parallel=True) def mean_loss_jit_parallel(florida_landfall_rate, florida_mean, florida_stddev, - gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples, - timeit_discard=False): + gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples): """ Compute mean economic loss with explicit loops, jit-compilation, and auto-parallelization with numba. @@ -121,7 +117,6 @@ def mean_loss_jit_parallel(florida_landfall_rate, florida_mean, florida_stddev, :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. - :param timeit_discard: [bool] (optional) If True, @timer does not record/print the timing. Only used by @timer. :return: [float] Mean annual losses. @@ -146,11 +141,10 @@ def mean_loss_jit_parallel(florida_landfall_rate, florida_mean, florida_stddev, return tot_loss / num_monte_carlo_samples -@timer +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) @jit(nopython=True) def mean_loss_noloops_jit(florida_landfall_rate, florida_mean, florida_stddev, - gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples, - timeit_discard=False): + gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples): """ Compute mean economic loss with numpy vectorization, no explicit loops, and jit-compilation with numba. @@ -161,7 +155,6 @@ def mean_loss_noloops_jit(florida_landfall_rate, florida_mean, florida_stddev, :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. - :param timeit_discard: [bool] (optional) If True, @timer does not record the timing. Only used by @timer. :return: [float] Mean annual losses. @@ -180,10 +173,9 @@ def mean_loss_noloops_jit(florida_landfall_rate, florida_mean, florida_stddev, return tot_loss / num_monte_carlo_samples -@timer +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) def mean_loss_noloops_py(florida_landfall_rate, florida_mean, florida_stddev, - gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples, - timeit_discard=False): + gulf_landfall_rate, gulf_mean, gulf_stddev, num_monte_carlo_samples): """ Compute mean economic loss in Pure Python, using numpy vectorization and no explicit loops. @@ -194,7 +186,6 @@ def mean_loss_noloops_py(florida_landfall_rate, florida_mean, florida_stddev, :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. - :param timeit_discard: [bool] (optional) If True, @timer does not record the timing. Only used by @timer. :return: [float] Mean annual losses. @@ -214,6 +205,46 @@ def mean_loss_noloops_py(florida_landfall_rate, florida_mean, florida_stddev, return tot_loss / num_monte_carlo_samples +@timer(cycles=int(os.getenv("TIMEIT_CYCLES", 100))) +@njit("float64(float64, float64, float64, float64, float64, float64, int64)", + parallel=True, fastmath=True, nogil=True) +def mean_loss_jit_parallel_fastmath(florida_landfall_rate, florida_mean, florida_stddev, + gulf_landfall_rate, gulf_mean, gulf_stddev, + num_monte_carlo_samples): + """ + Compute mean economic loss with explicit loops, jit-compilation, and auto-parallelization with numba. + + :param florida_landfall_rate: [float] annual rate of landfalling hurricanes in Florida. + :param florida_mean: [float] mean of the economic loss of landfalling hurricane in Florida. + :param florida_stddev: [float] std deviation of the economic loss of landfalling hurricane in Florida. + :param gulf_landfall_rate: [float] annual rate of landfalling hurricanes in Gulf states. + :param gulf_mean: [float] mean of the economic loss of landfalling hurricane in Gulf states. + :param gulf_stddev: [float] std deviation of the economic loss of landfalling hurricane in Gulf states. + :param num_monte_carlo_samples: [int] Number of monte carlo samples, i.e. years. + + :return: [float] Mean annual losses. + + """ + fl_events = np.random.poisson(lam=florida_landfall_rate, size=num_monte_carlo_samples) + gulf_events = np.random.poisson(lam=gulf_landfall_rate, size=num_monte_carlo_samples) + + tot_loss = 0 + for i in prange(num_monte_carlo_samples): + fl_loss = 0 + for j in range(fl_events[i]): + fl_loss += np.random.lognormal(florida_mean, florida_stddev) + + gulf_loss = 0 + for k in range(gulf_events[i]): + gulf_loss += np.random.lognormal(gulf_mean, gulf_stddev) + + year_loss = fl_loss + gulf_loss + + tot_loss += year_loss + + return tot_loss / num_monte_carlo_samples + + SIMULATORS = { 0: { 'func': mean_loss_py, @@ -235,6 +266,10 @@ def mean_loss_noloops_py(florida_landfall_rate, florida_mean, florida_stddev, 'func': mean_loss_noloops_py, 'desc': "python-noloops" }, + 5: { + 'func': mean_loss_jit_parallel_fastmath, + 'desc': "jit-parallel-fastmath" + }, } @@ -287,14 +322,10 @@ def simulate(self, florida_landfall_rate, florida_mean, florida_stddev, logger.info( f"Starting main loop over desired {num_monte_carlo_samples} Monte Carlo samples ") - # dummy call to jit-compile it - _ = self._simulate_core(1, 1e-10, 1e-10, 1, 1e-10, 1e-10, 1, timeit_discard=True) - t0 = time.time() mean_loss = self._simulate_core(florida_landfall_rate, florida_mean, florida_stddev, gulf_landfall_rate, gulf_mean, gulf_stddev, - num_monte_carlo_samples, - ) + num_monte_carlo_samples) t1 = time.time() logger.info( diff --git a/oasishurricane/tests.py b/oasishurricane/tests.py index a2e9adf..75c9ae0 100644 --- a/oasishurricane/tests.py +++ b/oasishurricane/tests.py @@ -11,7 +11,7 @@ from pytest import raises from .cli import main -from .model import SIMULATORS +from .simulator import SIMULATORS # fix random number generator seed SEED = 123456789 @@ -28,6 +28,7 @@ "num_monte_carlo_samples": 20000, "simulator_id": 0, "rng_seed": SEED, + "timeit": False, }, { # test larger rates "florida_landfall_rate": 30., @@ -39,6 +40,7 @@ "num_monte_carlo_samples": 20000, "simulator_id": 0, "rng_seed": SEED, + "timeit": False, }, { # test larger losses (requires deeper MC sampling) "florida_landfall_rate": 8., @@ -50,16 +52,17 @@ "num_monte_carlo_samples": 1000000, "simulator_id": 0, "rng_seed": SEED, + "timeit": False, } ] @pytest.mark.parametrize("test_args", [(args_) for args_ in args], ids=["{}".format(i) for i in range(len(args))]) -def test_simulators_consistency(test_args, rtol=0.01, atol=0.001): +def test_simulators_accuracy(test_args, rtol=0.01, atol=0.001): """ Test if simulators return mean losses that agree within a relative tolerance `rtol` - and an absolute tolerance `atol` + and an absolute tolerance `atol`. :param test_args: [dict] test arguments, same format as in the CLI (i.e., before validation) :param rtol: relative tolerance of the checks :param atol: absolute tolerance of the checks @@ -82,7 +85,7 @@ def test_simulators_consistency(test_args, rtol=0.01, atol=0.001): [(args_) for args_ in args], ids=["{}".format(i) for i in range(len(args))]) def test_simulator_selection(test_args): - """Test exceptions if simulator doesn't exist. """ + """Test exceptions if the chosen simulator_id doesn't exist. """ max_simulator_id = int(np.max(list(SIMULATORS.keys()))) # if simulator_id > max available should return NotImplementedError diff --git a/oasishurricane/utils.py b/oasishurricane/utils.py index 0cf8254..fb7148f 100644 --- a/oasishurricane/utils.py +++ b/oasishurricane/utils.py @@ -4,37 +4,83 @@ import functools import time import os +import logging +import gc +import numpy as np + +logger = logging.getLogger("timing") # TODO: pass named arguments to the core functions to improve formatting of the logfile -def timer(func): +def timer(cycles=3): """ Decorator that times the decorated function. If TIMEIT_LOGFILE is defined in the shell, it prints the timing to file, else to stdout. :param func: decorated function :return: the evaluated function + """ - @functools.wraps(func) - def wrapper_timer(*args, **kwargs): - tic = time.perf_counter() - value = func(*args, **kwargs) - toc = time.perf_counter() - elapsed_time = toc - tic - - if kwargs.get("timeit_discard", False): - return value - # timeit_msg = f"Elapsed time: {elapsed_time:0.4f} seconds" - timeit_msg = "\t".join([f"{arg:>10.6f}" for arg in args]) - timeit_msg += "\t" + f"{elapsed_time:5.4f}" - timeit_msg += " \n" - if 'TIMEIT_LOGFILE' in os.environ: - with open(os.environ['TIMEIT_LOGFILE'], "a") as f: - f.write(timeit_msg) - else: - print(timeit_msg) + def inner_function(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + + timeit = bool(os.getenv("TIMEIT")) + + if not timeit: + value = func(*args, **kwargs) + return value + + logger.info(f"Timings are computed by running {cycles} times the function.") + + # momentarily disable garbage collector (if enabled) + gcold = gc.isenabled() + gc.disable() + + try: + # use a precise timer for performance benchmark + _timer = time.perf_counter + + values = [] + times = [] + for _i in range(cycles): + t0 = _timer() + values.append(func(*args, **kwargs)) + t1 = _timer() + times.append(t1 - t0) + + value = np.mean(values) + + # evaluate the best execution time + # according to the docstring of `timeit.Timer.repeat`, min(times) is the best number + # to use as a representation of the best performance. Higher time values are likely + # affected by variability, and interference with other processes. + + # Note on numba jit-compiled functions: + # jit compilation takes time, which should be discarded when timing the performance. + # Since the best execution time is the `min` of all the execution times, the jit + # compilation time is naturally excluded from the benchmark. + best_time = np.min(times) + + finally: + # re-enable garbage collector if it was enabled + if gcold: + gc.enable() + + timeit_msg = " ".join([f"{arg:10.6f}" for arg in args]) + timeit_msg += " " + f"{cycles:10}" + timeit_msg += " " + f"{best_time:10.6f}" + timeit_msg += " " + f"{value:10.6f}" + + if 'TIMEIT_LOGFILE' in os.environ: + with open(os.environ['TIMEIT_LOGFILE'], "a") as f: + f.write(timeit_msg + " \n") + else: + logger.info("timeit: " + timeit_msg) + + return value - return value + return wrapper - return wrapper_timer + return inner_function