ipynb/andrew_owens-parallel_vfi_examples.ipynb

{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Serial\n",
                "Here we perform a serial (single-core) value function iteration to solve a simple savings problem with idiosyncratic income shocks. To solve the Bellman equation at each point in the state space, we use numerical optimization (Brent's method) and monotonic cubic spline interpolation over the expected value function. For simplicity we iterate a fixed 100 times."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "20-element Array{Float64,1}:\n",
                            "  0.18208499862389876\n",
                            "  0.20679522050714869\n",
                            "  0.23894401308852461\n",
                            "  0.2807706251409615 \n",
                            "  0.3351883912625588 \n",
                            "  0.40598765336756437\n",
                            "  0.4980997680657806 \n",
                            "  0.6179405887454282 \n",
                            "  0.77385734679864   \n",
                            "  0.9767100584536119 \n",
                            "  1.240627953743172  \n",
                            "  1.583993614896087  \n",
                            "  2.030723372003401  \n",
                            "  2.61193313891799   \n",
                            "  3.3681057192812967 \n",
                            "  4.351910541297183  \n",
                            "  5.631872223267574  \n",
                            "  7.297143495221169  \n",
                            "  9.463714923300914  \n",
                            " 12.282493960703478  "
                        ]
                    },
                    "execution_count": 1,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "using Distributed\n",
                "addprocs(4)\n",
                "using Interpolations, Optim, BenchmarkTools, QuantEcon\n",
                "const agrid = exp.(range(log(1), stop = log(200), length = 100 )) .- 1\n",
                "uc(c) = c > 0 ? c^(-2.5)/-2.5 : -Inf\n",
                "u(a, ap, x) =  uc(a - ap + x)\n",
                "maxap(a, x) = a + x\n",
                "const beta = 0.96\n",
                "using Random\n",
                "Random.seed!(2)\n",
                "mc = QuantEcon.tauchen(20, .8, .5)\n",
                "const P = mc.p\n",
                "const xgrid = exp.(mc.state_values) .+ 0.1"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "expectation (generic function with 1 method)"
                        ]
                    },
                    "execution_count": 2,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# Bellman step given evf and x\n",
                "function bellman(evf, x)\n",
                "    vf, pol = similar(evf), similar(evf)\n",
                "    for i in eachindex(vf)\n",
                "        a = agrid[i]\n",
                "        obj = ap -> -(u(a, ap, x) + beta * evf(ap))\n",
                "        upper = min(maxap(a, x), agrid[end])\n",
                "        sol = optimize(obj, agrid[1], .99*upper)\n",
                "        vf[i], pol[i] = -sol.minimum, sol.minimizer\n",
                "    end\n",
                "    return vf, pol\n",
                "end\n",
                "\n",
                "function expectation(bigvf, P)\n",
                "   evf = similar(bigvf)\n",
                "    for a_nx in 1:size(bigvf, 1)\n",
                "        for x_nx in 1:size(P, 1)\n",
                "        ev = 0.\n",
                "            for xp_nx in 1:size(P, 2)\n",
                "                ev += bigvf[a_nx, xp_nx] * P[x_nx, xp_nx]\n",
                "            end\n",
                "            evf[a_nx, x_nx] = ev\n",
                "        end\n",
                "    end\n",
                "    return evf\n",
                "end\n",
                "        \n",
                "        "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "  0.517671 seconds (618.11 k allocations: 53.327 MiB, 1.91% gc time)\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "([-85.3916 -70.4362 … -3.44491 -2.90268; -71.7371 -61.2765 … -3.4386 -2.89815; … ; -0.386347 -0.384652 … -0.294167 -0.284689; -0.354445 -0.352946 … -0.282921 -0.278142], [4.2331e-16 2.5884e-16 … 7.60786 10.2432; 3.04769e-16 2.22221e-16 … 7.66075 10.2963; … ; 183.643 183.659 … 191.797 194.16; 193.832 193.848 … 197.01 197.01])"
                        ]
                    },
                    "execution_count": 3,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "vfall = zeros(length(agrid), length(xgrid))\n",
                "polall = zeros(length(agrid), length(xgrid))\n",
                "function test_serial(vfall, polall)\n",
                "   fill!(vfall, 0) # reset the value function each time we benchmark\n",
                "   fill!(polall, 0)\n",
                "   for i in 1:100\n",
                "      vfe = expectation(vfall, P)\n",
                "      for x_nx in eachindex(xgrid)\n",
                "         vfold = interpolate(agrid, vfe[:, x_nx], SteffenMonotonicInterpolation())\n",
                "         vf, pol = bellman(vfold, xgrid[x_nx])\n",
                "         vfall[:, x_nx] = vf; polall[:, x_nx] = pol\n",
                "      end\n",
                "   end\n",
                "   return vfall, polall\n",
                "end\n",
                "vfall, polall = test_serial(vfall, polall)\n",
                "@time vfall, polall = test_serial(vfall, polall)    \n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Threads\n",
                "Here we use multithreading. See https://docs.julialang.org/en/v1/manual/parallel-computing/#Setup-1 for how to enable this. There is no interaction between loop iterations, so this is thread-safe. We check the output at the end."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "  0.147312 seconds (560.85 k allocations: 48.026 MiB, 2.60% gc time)\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "([-85.3916 -70.4362 … -3.44491 -2.90268; -71.7371 -61.2765 … -3.4386 -2.89815; … ; -0.386347 -0.384652 … -0.294167 -0.284689; -0.354445 -0.352946 … -0.282921 -0.278142], [4.2331e-16 2.5884e-16 … 7.60786 10.2432; 3.04769e-16 2.22221e-16 … 7.66075 10.2963; … ; 183.643 183.659 … 191.797 194.16; 193.832 193.848 … 197.01 197.01])"
                        ]
                    },
                    "execution_count": 4,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "vfall2 = zeros(length(agrid), length(xgrid))\n",
                "polall = zeros(length(agrid), length(xgrid))\n",
                "function test_threads(vfall, polall)\n",
                "    fill!(vfall, 0) # reset the value function each time we benchmark\n",
                "    fill!(polall, 0)\n",
                "    for i in 1:100\n",
                "        vfe = expectation(vfall, P)\n",
                "        Threads.@threads for x_nx in eachindex(xgrid)\n",
                "            vfold = interpolate(agrid, vfe[:, x_nx], SteffenMonotonicInterpolation())\n",
                "            vf, pol = bellman(vfold, xgrid[x_nx])\n",
                "            vfall[:, x_nx] = vf; polall[:, x_nx] = pol\n",
                "        end\n",
                "    end\n",
                "    return vfall, polall\n",
                "end\n",
                "vfall, polall = test_threads(vfall2, polall)\n",
                "@time vfall, polall = test_threads(vfall2, polall)    "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "true"
                        ]
                    },
                    "execution_count": 5,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "all(vfall .== vfall2) #did multithreading give the same result as serial?"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# pmap\n",
                "Now we use distributed memory parallelism with pmap. This requires that the code is loaded on all nodes. The easiest way to do this is to define a module everywhere."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {},
            "outputs": [],
            "source": [
                "@everywhere module DM\n",
                "using Interpolations, Optim, BenchmarkTools, QuantEcon\n",
                "const agrid = exp.(range(log(1), stop = log(200), length = 100 )) .- 1\n",
                "uc(c) = c > 0 ? c^(-2.5)/-2.5 : -Inf\n",
                "u(a, ap, x) =  uc(a - ap + x)\n",
                "maxap(a, x) = a + x\n",
                "const beta = 0.96\n",
                "using Random\n",
                "Random.seed!(2)\n",
                "mc = QuantEcon.tauchen(20, .8, .5)\n",
                "const P = mc.p\n",
                "const xgrid = exp.(mc.state_values) .+ 0.1\n",
                "function bellman(evf, x)\n",
                "    vf, pol = similar(evf), similar(evf)\n",
                "    for i in eachindex(vf)\n",
                "        a = agrid[i]\n",
                "        obj = ap -> -(u(a, ap, x) + beta * evf(ap))\n",
                "        upper = min(maxap(a, x), agrid[end])\n",
                "        sol = optimize(obj, agrid[1], .99*upper)\n",
                "        vf[i], pol[i] = -sol.minimum, sol.minimizer\n",
                "    end\n",
                "    return vf, pol\n",
                "end\n",
                "\n",
                "function expectation(bigvf, P)\n",
                "   evf = similar(bigvf)\n",
                "    for a_nx in 1:size(bigvf, 1)\n",
                "        for x_nx in 1:size(P, 1)\n",
                "        ev = 0.\n",
                "            for xp_nx in 1:size(P, 2)\n",
                "                ev += bigvf[a_nx, xp_nx] * P[x_nx, xp_nx]\n",
                "            end\n",
                "            evf[a_nx, x_nx] = ev\n",
                "        end\n",
                "    end\n",
                "    return evf\n",
                "end    \n",
                "end"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {},
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "  0.377046 seconds (212.99 k allocations: 31.369 MiB, 0.88% gc time)\n"
                    ]
                },
                {
                    "data": {
                        "text/plain": [
                            "([-85.3916 -70.4362 … -3.44491 -2.90268; -71.7371 -61.2765 … -3.4386 -2.89815; … ; -0.386347 -0.384652 … -0.294167 -0.284689; -0.354445 -0.352946 … -0.282921 -0.278142], [4.2331e-16 2.5884e-16 … 7.60786 10.2432; 3.04769e-16 2.22221e-16 … 7.66075 10.2963; … ; 183.643 183.659 … 191.797 194.16; 193.832 193.848 … 197.01 197.01])"
                        ]
                    },
                    "execution_count": 7,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "vfall3 = zeros(length(DM.agrid), length(DM.xgrid))\n",
                "polall = zeros(length(DM.agrid), length(DM.xgrid))\n",
                "function test_pmap(vfall, polall)\n",
                "    fill!(vfall, 0)\n",
                "    fill!(polall, 0)\n",
                "    for i in 1:100\n",
                "        vfe = DM.expectation(vfall, DM.P)\n",
                "        vfolds = [DM.interpolate(DM.agrid, vfe[:, x_nx], DM.SteffenMonotonicInterpolation()) for x_nx in eachindex(DM.xgrid)]\n",
                "        vfs_pols = pmap(DM.bellman, vfolds, DM.xgrid)\n",
                "        for x_nx in eachindex(DM.xgrid)\n",
                "            vfall[:, x_nx] = vfs_pols[x_nx][1]; polall[:, x_nx] = vfs_pols[x_nx][2]\n",
                "        end\n",
                "    end\n",
                "    return vfall, polall\n",
                "end\n",
                "vfall, polall = test_pmap(vfall3, polall)\n",
                "@time vfall, polall = test_pmap(vfall3, polall)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 8,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "text/plain": [
                            "true"
                        ]
                    },
                    "execution_count": 8,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "all(vfall .== vfall3)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {},
            "outputs": [],
            "source": [
                "using PyPlot"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/plain": [
                            "1-element Array{PyCall.PyObject,1}:\n",
                            " PyObject <matplotlib.lines.Line2D object at 0x7fb2c42e3f60>"
                        ]
                    },
                    "execution_count": 10,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# net savings\n",
                "plot(agrid, polall[:, 1] .- agrid)\n",
                "plot(agrid, polall[:, 10] .- agrid)\n",
                "plot(agrid, polall[:, 15] .- agrid)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {},
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "text/plain": [
                            "1-element Array{PyCall.PyObject,1}:\n",
                            " PyObject <matplotlib.lines.Line2D object at 0x7fb2c40e5dd8>"
                        ]
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ],
            "source": [
                "# value\n",
                "plot(agrid, vfall[:, 5])\n",
                "plot(agrid, vfall[:, 10])\n",
                "plot(agrid, vfall[:, 15])"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "Threads is about 4x faster than serial with 4 threads, while pmap is only about 2x faster. The relative slowness of pmap improves with the size of the task. Each call to the bellman function only takes about 0.5 ms here, so the overhead from the distributed memory nature of pmap is significant. For larger state spaces the bellman function will use more time, and its performance approaches that of threads in my testing.\n",
                "\n",
                "Julia can make use of multiple nodes on a cluster, and pmap will distribute the work across available nodes automatically if you make use of the ClusterManagers package. For example, if you have a Slurm cluster with 2 nodes and 4 tasks per node, the following code should set up and confirm the communication is working."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {},
            "outputs": [],
            "source": [
                "# Run without the comments on a Slurm cluster\n",
                "#=\n",
                "using Distributed, ClusterManagers\n",
                "addprocs(SlurmManager(8))\n",
                "@everywhere function test(x)\n",
                "    host, pid = gethostname(), getpid()\n",
                "    \"Hello from process $(pid) on host $(host)!\"\n",
                "end\n",
                "pmap(test, 1:8)\n",
                "=#"
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Julia 1.0.2",
            "language": "julia",
            "name": "julia-1.0"
        },
        "language_info": {
            "file_extension": ".jl",
            "mimetype": "application/julia",
            "name": "julia",
            "version": "1.0.2"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}