From 7f8576d46929eaf67f41f92102fa17a62f14d871 Mon Sep 17 00:00:00 2001 From: Siddharth Bhat Date: Fri, 29 Mar 2024 17:17:34 +0000 Subject: [PATCH] feat: run stage3 build for noreuse and reuse, compare timing and file size --- 1-runs/run-2023-03-29---16-31---tcg40/README | 2 + .../ResetReuse.baseline.lean.in | 161 ++ .../ResetReuse.research.lean.in | 157 ++ .../plot-stage2.ipynb | 1947 ++++++++++++++++ .../plot-stage3.ipynb | 1973 +++++++++++++++++ .../run-bash-worker.sh | 63 + .../run-bash-wrapper.sh | 3 + 7 files changed, 4306 insertions(+) create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/README create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.baseline.lean.in create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.research.lean.in create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/plot-stage2.ipynb create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/plot-stage3.ipynb create mode 100644 1-runs/run-2023-03-29---16-31---tcg40/run-bash-worker.sh create mode 100755 1-runs/run-2023-03-29---16-31---tcg40/run-bash-wrapper.sh diff --git a/1-runs/run-2023-03-29---16-31---tcg40/README b/1-runs/run-2023-03-29---16-31---tcg40/README new file mode 100644 index 000000000000..613dcd903de3 --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/README @@ -0,0 +1,2 @@ +- Run stage2 normally, then time the compile of stage3. Also track file sizes to compare between baseline and reused compiler. + diff --git a/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.baseline.lean.in b/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.baseline.lean.in new file mode 100644 index 000000000000..44e3235207eb --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.baseline.lean.in @@ -0,0 +1,161 @@ +/- +Copyright (c) 2019 Microsoft Corporation. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Leonardo de Moura +-/ +prelude +import Lean.Compiler.IR.Basic +import Lean.Compiler.IR.LiveVars +import Lean.Compiler.IR.Format + + +namespace Lean.IR.ResetReuse +/-! Remark: the insertResetReuse transformation is applied before we have + inserted `inc/dec` instructions, and performed lower level optimizations + that introduce the instructions `release` and `set`. -/ + +/-! Remark: the functions `S`, `D` and `R` defined here implement the + corresponding functions in the paper "Counting Immutable Beans" + + Here are the main differences: + - We use the State monad to manage the generation of fresh variable names. + - Support for join points, and `uset` and `sset` instructions for unboxed data. + - `D` uses the auxiliary function `Dmain`. + - `Dmain` returns a pair `(b, found)` to avoid quadratic behavior when checking + the last occurrence of the variable `x`. + - Because we have join points in the actual implementation, a variable may be live even if it + does not occur in a function body. See example at `livevars.lean`. +-/ + +private def mayReuse (c₁ c₂ : CtorInfo) : Bool := + c₁.size == c₂.size && c₁.usize == c₂.usize && c₁.ssize == c₂.ssize && + /- The following condition is a heuristic. + We don't want to reuse cells from different types even when they are compatible + because it produces counterintuitive behavior. -/ + (c₁.name.getPrefix == c₂.name.getPrefix) + +private partial def S (w : VarId) (c : CtorInfo) : FnBody → FnBody + | FnBody.vdecl x t v@(Expr.ctor c' ys) b => + if mayReuse c c' then + let updtCidx := c.cidx != c'.cidx + FnBody.vdecl x t (Expr.reuse w c' updtCidx ys) b + else + FnBody.vdecl x t v (S w c b) + | FnBody.jdecl j ys v b => + let v' := S w c v + if v == v' then FnBody.jdecl j ys v (S w c b) + else FnBody.jdecl j ys v' b + | FnBody.case tid x xType alts => FnBody.case tid x xType <| alts.map fun alt => alt.modifyBody (S w c) + | b => + if b.isTerminal then b + else let + (instr, b) := b.split + instr.setBody (S w c b) + +/-- We use `Context` to track join points in scope. -/ +abbrev M := ReaderT LocalContext (StateT Index Id) + +private def mkFresh : M VarId := do + let idx ← getModify (fun n => n + 1) + pure { idx := idx } + +private def tryS (x : VarId) (c : CtorInfo) (b : FnBody) : M FnBody := do + let w ← mkFresh + let b' := S w c b + if b == b' then pure b + else pure $ FnBody.vdecl w IRType.object (Expr.reset c.size x) b' + +private def Dfinalize (x : VarId) (c : CtorInfo) : FnBody × Bool → M FnBody + | (b, true) => pure b + | (b, false) => tryS x c b + +private def argsContainsVar (ys : Array Arg) (x : VarId) : Bool := + ys.any fun arg => match arg with + | Arg.var y => x == y + | _ => false + +private def isCtorUsing (b : FnBody) (x : VarId) : Bool := + match b with + | (FnBody.vdecl _ _ (Expr.ctor _ ys) _) => argsContainsVar ys x + | _ => false + +/-- Given `Dmain b`, the resulting pair `(new_b, flag)` contains the new body `new_b`, + and `flag == true` if `x` is live in `b`. + + Note that, in the function `D` defined in the paper, for each `let x := e; F`, + `D` checks whether `x` is live in `F` or not. This is great for clarity but it + is expensive: `O(n^2)` where `n` is the size of the function body. -/ +private partial def Dmain (x : VarId) (c : CtorInfo) : FnBody → M (FnBody × Bool) + | e@(FnBody.case tid y yType alts) => do + let ctx ← read + if e.hasLiveVar ctx x then do + /- If `x` is live in `e`, we recursively process each branch. -/ + let alts ← alts.mapM fun alt => alt.mmodifyBody fun b => Dmain x c b >>= Dfinalize x c + pure (FnBody.case tid y yType alts, true) + else pure (e, false) + | FnBody.jdecl j ys v b => do + let (b, found) ← withReader (fun ctx => ctx.addJP j ys v) (Dmain x c b) + let (v, _ /- found' -/) ← Dmain x c v + /- If `found' == true`, then `Dmain b` must also have returned `(b, true)` since + we assume the IR does not have dead join points. So, if `x` is live in `j` (i.e., `v`), + then it must also live in `b` since `j` is reachable from `b` with a `jmp`. + On the other hand, `x` may be live in `b` but dead in `j` (i.e., `v`). -/ + pure (FnBody.jdecl j ys v b, found) + | e => do + let ctx ← read + if e.isTerminal then + pure (e, e.hasLiveVar ctx x) + else do + let (instr, b) := e.split + if isCtorUsing instr x then + /- If the scrutinee `x` (the one that is providing memory) is being + stored in a constructor, then reuse will probably not be able to reuse memory at runtime. + It may work only if the new cell is consumed, but we ignore this case. -/ + pure (e, true) + else + let (b, found) ← Dmain x c b + /- Remark: it is fine to use `hasFreeVar` instead of `hasLiveVar` + since `instr` is not a `FnBody.jmp` (it is not a terminal) nor it is a `FnBody.jdecl`. -/ + if found || !instr.hasFreeVar x then + pure (instr.setBody b, found) + else + let b ← tryS x c b + pure (instr.setBody b, true) + +private def D (x : VarId) (c : CtorInfo) (b : FnBody) : M FnBody := + Dmain x c b >>= Dfinalize x c + +partial def R : FnBody → M FnBody + | FnBody.case tid x xType alts => do + let alts ← alts.mapM fun alt => do + let alt ← alt.mmodifyBody R + match alt with + | Alt.ctor c b => + if c.isScalar then pure alt + else Alt.ctor c <$> D x c b + | _ => pure alt + pure $ FnBody.case tid x xType alts + | FnBody.jdecl j ys v b => do + let v ← R v + let b ← withReader (fun ctx => ctx.addJP j ys v) (R b) + pure $ FnBody.jdecl j ys v b + | e => do + if e.isTerminal then pure e + else do + let (instr, b) := e.split + let b ← R b + pure (instr.setBody b) + +end ResetReuse + +open ResetReuse + +def Decl.insertResetReuse (d : Decl) : Decl := + match d with + | .fdecl (body := b) ..=> + let nextIndex := d.maxIndex + 1 + let bNew := (R b {}).run' nextIndex + d.updateBody! bNew + | other => other + +end Lean.IR diff --git a/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.research.lean.in b/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.research.lean.in new file mode 100644 index 000000000000..03ce55b6e57e --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/ResetReuse.research.lean.in @@ -0,0 +1,157 @@ +/- +Copyright (c) 2019 Microsoft Corporation. All rights reserved. +Released under Apache 2.0 license as described in the file LICENSE. +Authors: Leonardo de Moura +-/ +prelude +import Lean.Compiler.IR.Basic +import Lean.Compiler.IR.LiveVars +import Lean.Compiler.IR.Format + + +namespace Lean.IR.ResetReuse +/-! Remark: the insertResetReuse transformation is applied before we have + inserted `inc/dec` instructions, and performed lower level optimizations + that introduce the instructions `release` and `set`. -/ + +/-! Remark: the functions `S`, `D` and `R` defined here implement the + corresponding functions in the paper "Counting Immutable Beans" + + Here are the main differences: + - We use the State monad to manage the generation of fresh variable names. + - Support for join points, and `uset` and `sset` instructions for unboxed data. + - `D` uses the auxiliary function `Dmain`. + - `Dmain` returns a pair `(b, found)` to avoid quadratic behavior when checking + the last occurrence of the variable `x`. + - Because we have join points in the actual implementation, a variable may be live even if it + does not occur in a function body. See example at `livevars.lean`. +-/ + +private def mayReuse (c₁ c₂ : CtorInfo) : Bool := + c₁.size == c₂.size && c₁.usize == c₂.usize && c₁.ssize == c₂.ssize + +private partial def S (w : VarId) (c : CtorInfo) : FnBody → FnBody + | FnBody.vdecl x t v@(Expr.ctor c' ys) b => + if mayReuse c c' then + let updtCidx := c.cidx != c'.cidx + FnBody.vdecl x t (Expr.reuse w c' updtCidx ys) b + else + FnBody.vdecl x t v (S w c b) + | FnBody.jdecl j ys v b => + let v' := S w c v + if v == v' then FnBody.jdecl j ys v (S w c b) + else FnBody.jdecl j ys v' b + | FnBody.case tid x xType alts => FnBody.case tid x xType <| alts.map fun alt => alt.modifyBody (S w c) + | b => + if b.isTerminal then b + else let + (instr, b) := b.split + instr.setBody (S w c b) + +/-- We use `Context` to track join points in scope. -/ +abbrev M := ReaderT LocalContext (StateT Index Id) + +private def mkFresh : M VarId := do + let idx ← getModify (fun n => n + 1) + pure { idx := idx } + +private def tryS (x : VarId) (c : CtorInfo) (b : FnBody) : M FnBody := do + let w ← mkFresh + let b' := S w c b + if b == b' then pure b + else pure $ FnBody.vdecl w IRType.object (Expr.reset c.size x) b' + +private def Dfinalize (x : VarId) (c : CtorInfo) : FnBody × Bool → M FnBody + | (b, true) => pure b + | (b, false) => tryS x c b + +private def argsContainsVar (ys : Array Arg) (x : VarId) : Bool := + ys.any fun arg => match arg with + | Arg.var y => x == y + | _ => false + +private def isCtorUsing (b : FnBody) (x : VarId) : Bool := + match b with + | (FnBody.vdecl _ _ (Expr.ctor _ ys) _) => argsContainsVar ys x + | _ => false + +/-- Given `Dmain b`, the resulting pair `(new_b, flag)` contains the new body `new_b`, + and `flag == true` if `x` is live in `b`. + + Note that, in the function `D` defined in the paper, for each `let x := e; F`, + `D` checks whether `x` is live in `F` or not. This is great for clarity but it + is expensive: `O(n^2)` where `n` is the size of the function body. -/ +private partial def Dmain (x : VarId) (c : CtorInfo) : FnBody → M (FnBody × Bool) + | e@(FnBody.case tid y yType alts) => do + let ctx ← read + if e.hasLiveVar ctx x then do + /- If `x` is live in `e`, we recursively process each branch. -/ + let alts ← alts.mapM fun alt => alt.mmodifyBody fun b => Dmain x c b >>= Dfinalize x c + pure (FnBody.case tid y yType alts, true) + else pure (e, false) + | FnBody.jdecl j ys v b => do + let (b, found) ← withReader (fun ctx => ctx.addJP j ys v) (Dmain x c b) + let (v, _ /- found' -/) ← Dmain x c v + /- If `found' == true`, then `Dmain b` must also have returned `(b, true)` since + we assume the IR does not have dead join points. So, if `x` is live in `j` (i.e., `v`), + then it must also live in `b` since `j` is reachable from `b` with a `jmp`. + On the other hand, `x` may be live in `b` but dead in `j` (i.e., `v`). -/ + pure (FnBody.jdecl j ys v b, found) + | e => do + let ctx ← read + if e.isTerminal then + pure (e, e.hasLiveVar ctx x) + else do + let (instr, b) := e.split + if isCtorUsing instr x then + /- If the scrutinee `x` (the one that is providing memory) is being + stored in a constructor, then reuse will probably not be able to reuse memory at runtime. + It may work only if the new cell is consumed, but we ignore this case. -/ + pure (e, true) + else + let (b, found) ← Dmain x c b + /- Remark: it is fine to use `hasFreeVar` instead of `hasLiveVar` + since `instr` is not a `FnBody.jmp` (it is not a terminal) nor it is a `FnBody.jdecl`. -/ + if found || !instr.hasFreeVar x then + pure (instr.setBody b, found) + else + let b ← tryS x c b + pure (instr.setBody b, true) + +private def D (x : VarId) (c : CtorInfo) (b : FnBody) : M FnBody := + Dmain x c b >>= Dfinalize x c + +partial def R : FnBody → M FnBody + | FnBody.case tid x xType alts => do + let alts ← alts.mapM fun alt => do + let alt ← alt.mmodifyBody R + match alt with + | Alt.ctor c b => + if c.isScalar then pure alt + else Alt.ctor c <$> D x c b + | _ => pure alt + pure $ FnBody.case tid x xType alts + | FnBody.jdecl j ys v b => do + let v ← R v + let b ← withReader (fun ctx => ctx.addJP j ys v) (R b) + pure $ FnBody.jdecl j ys v b + | e => do + if e.isTerminal then pure e + else do + let (instr, b) := e.split + let b ← R b + pure (instr.setBody b) + +end ResetReuse + +open ResetReuse + +def Decl.insertResetReuse (d : Decl) : Decl := + match d with + | .fdecl (body := b) ..=> + let nextIndex := d.maxIndex + 1 + let bNew := (R b {}).run' nextIndex + d.updateBody! bNew + | other => other + +end Lean.IR diff --git a/1-runs/run-2023-03-29---16-31---tcg40/plot-stage2.ipynb b/1-runs/run-2023-03-29---16-31---tcg40/plot-stage2.ipynb new file mode 100644 index 000000000000..b9bdfb16a7dd --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/plot-stage2.ipynb @@ -0,0 +1,1947 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "305ca8eb-b873-4f3e-aa55-9d0adeab7fe9", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display, HTML\n", + "from datetime import timedelta\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "56f9cc1a-76c5-488f-9fa2-a6eade40369d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "noreuse\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileConditionMetricValue
0Init/Prelude.leanreuse_across_ctor_disabledrss147406848
1Init/Prelude.leanreuse_across_ctor_disablednum_alloc1321689
2Init/Prelude.leanreuse_across_ctor_disablednum_small_alloc26538112
3Init/Prelude.leanreuse_across_ctor_disablednum_dealloc1273439
4Init/Prelude.leanreuse_across_ctor_disablednum_small_dealloc26156876
...............
8495Lake/Main.leanreuse_across_ctor_disablednum_segments4
8496Lake/Main.leanreuse_across_ctor_disablednum_pages3715
8497Lake/Main.leanreuse_across_ctor_disablednum_exports0
8498Lake/Main.leanreuse_across_ctor_disablednum_recycled_pages743
8499Lake/Main.leanreuse_across_ctor_disabledtime_elapsed_ms903
\n", + "

8500 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " File Condition Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_disabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_disabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_disabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_disabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_disabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_disabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_disabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_disabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_disabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_disabled time_elapsed_ms \n", + "\n", + " Value \n", + "0 147406848 \n", + "1 1321689 \n", + "2 26538112 \n", + "3 1273439 \n", + "4 26156876 \n", + "... ... \n", + "8495 4 \n", + "8496 3715 \n", + "8497 0 \n", + "8498 743 \n", + "8499 903 \n", + "\n", + "[8500 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reuse\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileConditionMetricValue
0Init/Prelude.leanreuse_across_ctor_disabledrss147394560
1Init/Prelude.leanreuse_across_ctor_disablednum_alloc1321689
2Init/Prelude.leanreuse_across_ctor_disablednum_small_alloc26538165
3Init/Prelude.leanreuse_across_ctor_disablednum_dealloc1273439
4Init/Prelude.leanreuse_across_ctor_disablednum_small_dealloc26156925
...............
8495Lake/Main.leanreuse_across_ctor_disablednum_segments4
8496Lake/Main.leanreuse_across_ctor_disablednum_pages3715
8497Lake/Main.leanreuse_across_ctor_disablednum_exports0
8498Lake/Main.leanreuse_across_ctor_disablednum_recycled_pages743
8499Lake/Main.leanreuse_across_ctor_disabledtime_elapsed_ms820
\n", + "

8500 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " File Condition Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_disabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_disabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_disabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_disabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_disabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_disabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_disabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_disabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_disabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_disabled time_elapsed_ms \n", + "\n", + " Value \n", + "0 147394560 \n", + "1 1321689 \n", + "2 26538165 \n", + "3 1273439 \n", + "4 26156925 \n", + "... ... \n", + "8495 4 \n", + "8496 3715 \n", + "8497 0 \n", + "8498 743 \n", + "8499 820 \n", + "\n", + "[8500 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reuse = pd.read_csv('1711699885---29-03-2024---08:11:25.noreuse.stage2.csv',\n", + " names=[\"File\", \"Condition\", \"Metric\", \"Value\"])\n", + "noreuse = pd.read_csv('1711699885---29-03-2024---08:11:25.noreuse.stage3.csv', \n", + " names=[\"File\", \"Condition\", \"Metric\", \"Value\"])\n", + "print(\"noreuse\"); display(noreuse);\n", + "print(\"reuse\"); display(reuse);" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2912e2fe-5706-4831-a8b0-77fc8e6a2133", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time (reuse): 0:35:56.367000 | time (noreuse): 0:35:30.234000\n" + ] + } + ], + "source": [ + "# Filtering the rows where Metric is 'time_elapsed_ms' and then summing the 'Value' column for both DataFrames\n", + "sum_time_elapsed_reuse = reuse[reuse[\"Metric\"] == \"time_elapsed_ms\"][\"Value\"].sum()\n", + "sum_time_elapsed_no_reuse = noreuse[noreuse[\"Metric\"] == \"time_elapsed_ms\"][\"Value\"].sum()\n", + "\n", + "sum_time_elapsed_reuse, sum_time_elapsed_no_reuse\n", + "\n", + "# Ensuring the values are in a compatible format for timedelta\n", + "time_reuse = timedelta(milliseconds=int(sum_time_elapsed_reuse))\n", + "time_no_reuse = timedelta(milliseconds=int(sum_time_elapsed_no_reuse))\n", + "\n", + "# Formatting as hours:minutes:seconds.milliseconds again\n", + "time_format_reuse = str(time_reuse)\n", + "time_format_no_reuse = str(time_no_reuse)\n", + "print(f\"time (reuse): {time_format_reuse} | time (noreuse): {time_format_no_reuse}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a8f14d78-1cf1-4d14-a128-76fa55975629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileCondition_reuseMetricValue_reuseCondition_no_reuseValue_no_reuse
0Init/Prelude.leanreuse_across_ctor_disabledrss147394560reuse_across_ctor_disabled147406848
1Init/Prelude.leanreuse_across_ctor_disablednum_alloc1321689reuse_across_ctor_disabled1321689
2Init/Prelude.leanreuse_across_ctor_disablednum_small_alloc26538165reuse_across_ctor_disabled26538112
3Init/Prelude.leanreuse_across_ctor_disablednum_dealloc1273439reuse_across_ctor_disabled1273439
4Init/Prelude.leanreuse_across_ctor_disablednum_small_dealloc26156925reuse_across_ctor_disabled26156876
.....................
8495Lake/Main.leanreuse_across_ctor_disablednum_segments4reuse_across_ctor_disabled4
8496Lake/Main.leanreuse_across_ctor_disablednum_pages3715reuse_across_ctor_disabled3715
8497Lake/Main.leanreuse_across_ctor_disablednum_exports0reuse_across_ctor_disabled0
8498Lake/Main.leanreuse_across_ctor_disablednum_recycled_pages743reuse_across_ctor_disabled743
8499Lake/Main.leanreuse_across_ctor_disabledtime_elapsed_ms820reuse_across_ctor_disabled903
\n", + "

8500 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " File Condition_reuse Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_disabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_disabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_disabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_disabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_disabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_disabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_disabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_disabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_disabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_disabled time_elapsed_ms \n", + "\n", + " Value_reuse Condition_no_reuse Value_no_reuse \n", + "0 147394560 reuse_across_ctor_disabled 147406848 \n", + "1 1321689 reuse_across_ctor_disabled 1321689 \n", + "2 26538165 reuse_across_ctor_disabled 26538112 \n", + "3 1273439 reuse_across_ctor_disabled 1273439 \n", + "4 26156925 reuse_across_ctor_disabled 26156876 \n", + "... ... ... ... \n", + "8495 4 reuse_across_ctor_disabled 4 \n", + "8496 3715 reuse_across_ctor_disabled 3715 \n", + "8497 0 reuse_across_ctor_disabled 0 \n", + "8498 743 reuse_across_ctor_disabled 743 \n", + "8499 820 reuse_across_ctor_disabled 903 \n", + "\n", + "[8500 rows x 6 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_merged = pd.merge(reuse, noreuse, on=[\"File\", \"Metric\"], suffixes=('_reuse', '_no_reuse'))\n", + "display(df_merged)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "6c6fc924-32ba-4821-842b-a48c0489c96e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

time_elapsed_ms

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Lean/Compiler/IR.lean738148474650.269542
1Lean/Compiler/InitAttr.lean11052196109149.681239
2Lean/PrettyPrinter/Delaborator/SubExpr.lean1065189783243.858724
3Lean/Compiler/IR/UnboxResult.lean50589539043.575419
4Lean/Compiler/LCNF/PullLetDecls.lean1306229198542.994326
..................
845Lean/Elab/Tactic/Delta.lean25881325-1263-95.320755
846Lean/Elab/Tactic/Symm.lean1794886-908-102.483070
847Lean/Elab/Eval.lean1821896-925-103.236607
848Lean/Elab/PreDefinition/WF/TerminationArgument...34751695-1780-105.014749
849Lean/Elab/AuxDef.lean28571280-1577-123.203125
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse \\\n", + "0 Lean/Compiler/IR.lean 738 \n", + "1 Lean/Compiler/InitAttr.lean 1105 \n", + "2 Lean/PrettyPrinter/Delaborator/SubExpr.lean 1065 \n", + "3 Lean/Compiler/IR/UnboxResult.lean 505 \n", + "4 Lean/Compiler/LCNF/PullLetDecls.lean 1306 \n", + ".. ... ... \n", + "845 Lean/Elab/Tactic/Delta.lean 2588 \n", + "846 Lean/Elab/Tactic/Symm.lean 1794 \n", + "847 Lean/Elab/Eval.lean 1821 \n", + "848 Lean/Elab/PreDefinition/WF/TerminationArgument... 3475 \n", + "849 Lean/Elab/AuxDef.lean 2857 \n", + "\n", + " Value_no_reuse absolute_diff %Decrease \n", + "0 1484 746 50.269542 \n", + "1 2196 1091 49.681239 \n", + "2 1897 832 43.858724 \n", + "3 895 390 43.575419 \n", + "4 2291 985 42.994326 \n", + ".. ... ... ... \n", + "845 1325 -1263 -95.320755 \n", + "846 886 -908 -102.483070 \n", + "847 896 -925 -103.236607 \n", + "848 1695 -1780 -105.014749 \n", + "849 1280 -1577 -123.203125 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

rss

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Init/Data/FloatArray.lean883507208953036811796481.317595
1Init/Control/Basic.lean948715529592012810485761.093176
2Init/Classical.lean11128832011246796811796481.048875
3Init/Data/Sum.lean84230144850165767864320.925034
4Init/Omega/Logic.lean1045831681055006729175040.869666
..................
845Lean/Elab/Quotation/Util.lean225468416223899648-1568768-0.700657
846Lean/Data/Xml/Basic.lean113606656112627712-978944-0.869186
847Init/Guard.lean106020864105099264-921600-0.876885
848Lean/Data/Json/Printer.lean126935040125771776-1163264-0.924901
849Init/Data/Fin/Log2.lean105627648104493056-1134592-1.085806
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Init/Data/FloatArray.lean 88350720 89530368 \n", + "1 Init/Control/Basic.lean 94871552 95920128 \n", + "2 Init/Classical.lean 111288320 112467968 \n", + "3 Init/Data/Sum.lean 84230144 85016576 \n", + "4 Init/Omega/Logic.lean 104583168 105500672 \n", + ".. ... ... ... \n", + "845 Lean/Elab/Quotation/Util.lean 225468416 223899648 \n", + "846 Lean/Data/Xml/Basic.lean 113606656 112627712 \n", + "847 Init/Guard.lean 106020864 105099264 \n", + "848 Lean/Data/Json/Printer.lean 126935040 125771776 \n", + "849 Init/Data/Fin/Log2.lean 105627648 104493056 \n", + "\n", + " absolute_diff %Decrease \n", + "0 1179648 1.317595 \n", + "1 1048576 1.093176 \n", + "2 1179648 1.048875 \n", + "3 786432 0.925034 \n", + "4 917504 0.869666 \n", + ".. ... ... \n", + "845 -1568768 -0.700657 \n", + "846 -978944 -0.869186 \n", + "847 -921600 -0.876885 \n", + "848 -1163264 -0.924901 \n", + "849 -1134592 -1.085806 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAIjCAYAAAAJLyrXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABOc0lEQVR4nO3deXgUVR7u8bc7IXtC2LKxRgj7JiCIIItEg6CCsiooMigqMICoCKMgqwgqIpuM3hkYN9wGdQaVxYA6LEZAEMUQAwZagSS2CAkJJCRd9w8vfW0TINUk6U7y/TxPnsc6dU7Vrzptd16q6pTFMAxDAAAAAIASs3q6AAAAAACoaAhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgCASmfWrFmyWCzlsq9evXqpV69ezuXPPvtMFotF7733Xrns/95771WjRo3KZV9/lpGRocGDB6tWrVqyWCxasmSJR+oAAE8gSAFAMY4dO6b+/fsrLCxMLVu21H//+98ifdatW6eIiAidPn26yLpevXrJYrHIYrHIarUqLCxMzZo10913363NmzeXxyFUGmvWrHG+lhaLRQEBAYqJiVFCQoKWLl2q7OzsUtnP8ePHNWvWLO3bt69UtleavLW2hx9+WBs3btT06dP12muvqW/fvp4uCQDKja+nCwAAbzRq1CgdO3ZMCxcu1Pbt2zVkyBAdPHjQ+S//586d06OPPqp58+apevXqxW6jXr16WrBggSQpJydHhw4d0rp16/T6669r6NChev3111WtWrXyOqQKb86cOYqNjdX58+eVnp6uzz77TJMnT9bixYv1n//8R23btnX2ffLJJzVt2jRT2z9+/Lhmz56tRo0aqX379iUet2nTJlP7ccelanvllVfkcDjKvIbibNmyRQMGDNCjjz7qkf0DgCcRpADgT86ePastW7bos88+U48ePfTggw9qx44d2rhxox544AFJ0nPPPafq1avrvvvuu+h2qlevrpEjR7q0PfPMM5o4caJWrlypRo0aaeHChWV6LH+Uk5Oj4ODgcttfabv55pvVqVMn5/L06dO1ZcsW3XLLLbrtttuUnJyswMBASZKvr698fcv2Ky43N1dBQUHy8/Mr0/1cjifDeGZmpsLDw0tte+fOnZOfn5+s1pJdMFNQUCCHw+Hx3wGAqolL+wDgT86dOyfDMFSjRg1JksViUXh4uHJzcyX9ftnfM888oxdffLHEf/Bd4OPjo6VLl6ply5Zavnx5kcsCX3/9dXXs2FGBgYGqWbOmhg8frp9++qnIdpKSktSvXz/VqFFDwcHBatu2rV588UXn+nvvvVchISE6fPiw+vXrp9DQUI0YMUKS5HA4tGTJErVq1UoBAQGKjIzUAw88oN9++81lHx9++KH69++vmJgY+fv7q3Hjxpo7d64KCwtd+qWmpmrQoEGKiopSQECA6tWrp+HDh7t9bGbccMMNmjFjho4eParXX3/d2V7cPVKbN29W9+7dFR4erpCQEDVr1kx/+9vfJP1+X9M111wjSRo9erTzMsI1a9ZI+v1SzdatW2vPnj3q0aOHgoKCnGP/fI/UBYWFhfrb3/6mqKgoBQcH67bbbityvI0aNdK9995bZOwft3m52oq7RyonJ0ePPPKI6tevL39/fzVr1kzPPfecDMNw6WexWDRhwgR98MEHat26tfz9/dWqVStt2LCh+Bf8/7lwuaVhGFqxYoWzpgt+/PFHDRkyRDVr1lRQUJCuvfZaffTRRy7buHAv2VtvvaUnn3xSdevWVVBQkLKysord55EjR2SxWPTcc89pyZIlaty4sfz9/fX9999LkpYtW6ZWrVopKChINWrUUKdOnfTmm286x2dnZ2vy5Mlq1KiR/P39FRERoRtvvFFff/31JY8VAC6GM1IA8Cc1atRQ48aN9fTTT+vpp5/Wjh07tG/fPi1btkySNHXqVN18883q0aOHW9v38fHRnXfeqRkzZmjbtm3q37+/JGn+/PmaMWOGhg4dqvvuu0+//PKLli1bph49emjv3r3Of/nfvHmzbrnlFkVHR2vSpEmKiopScnKy1q9fr0mTJjn3U1BQoISEBHXv3l3PPfecgoKCJEkPPPCA1qxZo9GjR2vixIlKS0vT8uXLtXfvXm3fvt15hmPNmjUKCQnRlClTFBISoi1btmjmzJnKysrSs88+K0nKz89XQkKC8vLy9Ne//lVRUVE6duyY1q9fr1OnTjkveyzpsbnj7rvv1t/+9jdt2rRJ999/f7F9Dhw4oFtuuUVt27bVnDlz5O/vr0OHDmn79u2SpBYtWmjOnDmaOXOmxo4dq+uvv16SdN111zm38euvv+rmm2/W8OHDNXLkSEVGRl6yrvnz58tisejxxx9XZmamlixZovj4eO3bt8955qwkSlLbHxmGodtuu01bt27VmDFj1L59e23cuFGPPfaYjh07phdeeMGl/7Zt27Ru3TqNGzdOoaGhWrp0qQYNGiSbzaZatWoVu48ePXrotdde0913360bb7xR99xzj3NdRkaGrrvuOuXm5mrixImqVauW/vWvf+m2227Te++9p9tvv91lW3PnzpWfn58effRR5eXlXfbs0urVq3Xu3DmNHTtW/v7+qlmzpl555RVNnDhRgwcP1qRJk3Tu3Dnt379fSUlJuuuuuyRJDz74oN577z1NmDBBLVu21K+//qpt27YpOTlZHTp0uPQvAQCKYwAAikhMTDRq1KhhSDIkGZMnTzYMwzC2b99uBAYGGkeOHLnk+J49exqtWrW66Pr333/fkGS8+OKLhmEYxpEjRwwfHx9j/vz5Lv2+/fZbw9fX19leUFBgxMbGGg0bNjR+++03l74Oh8P536NGjTIkGdOmTXPp87///c+QZLzxxhsu7Rs2bCjSnpubW6TuBx54wAgKCjLOnTtnGIZh7N2715BkvPvuuxc91pIe28WsXr3akGTs2rXron2qV69uXH311c7lp556yvjjV9wLL7xgSDJ++eWXi25j165dhiRj9erVRdb17NnTkGSsWrWq2HU9e/Z0Lm/dutWQZNStW9fIyspytr/zzjsuv3PDMIyGDRsao0aNuuw2L1XbqFGjjIYNGzqXP/jgA0OSMW/ePJd+gwcPNiwWi3Ho0CFnmyTDz8/Ppe2bb74xJBnLli0rsq8/k2SMHz/epW3y5MmGJON///ufsy07O9uIjY01GjVqZBQWFhqG8f9fp6uuuqrY99qfpaWlGZKMsLAwIzMz02XdgAEDLvn/m2H8/h75c60AcCW4tA8AinHDDTfIZrPpyy+/lM1m0wsvvCCHw6GJEyfqkUceUcOGDfXSSy+pefPmatasmVatWmVq+yEhIZLknHFu3bp1cjgcGjp0qOx2u/MnKipKcXFx2rp1qyRp7969SktL0+TJk4ucxSluuu+HHnrIZfndd99V9erVdeONN7rsp2PHjgoJCXHuR5LLWZPs7GzZ7XZdf/31ys3N1cGDByXJecZp48aNzksf/6ykx3YlQkJCLjl734XX6sMPP3R7YgZ/f3+NHj26xP3vuecehYaGOpcHDx6s6Ohoffzxx27tv6Q+/vhj+fj4aOLEiS7tjzzyiAzD0CeffOLSHh8fr8aNGzuX27Ztq7CwMP34449u779z587q3r27sy0kJERjx47VkSNHnJfiXTBq1ChTZ+gGDRqkOnXquLSFh4fr559/1q5duy46Ljw8XElJSTp+/HiJ9wUAl0KQAoCLCAkJUZcuXVS/fn1Jv19SlJ6ermnTpunTTz/VY489pmeeeUaLFi3SI488YioQnDlzRpKcf2inpqbKMAzFxcWpTp06Lj/JycnKzMyUJB0+fFiS1Lp168vuw9fXV/Xq1XNpS01N1enTpxUREVFkP2fOnHHuR/r9crjbb79d1atXV1hYmOrUqeOcPOPC/U+xsbGaMmWK/s//+T+qXbu2EhIStGLFCpf7o0p6bFfizJkzLqHlz4YNG6Zu3brpvvvuU2RkpIYPH6533nnHVKiqW7euqUkN4uLiXJYtFouaNGmiI0eOlHgb7jh69KhiYmKKvB4tWrRwrv+jBg0aFNlGjRo1itwzZ2b/zZo1K9J+sf3Hxsaa2n5x/R9//HGFhISoc+fOiouL0/jx452XbV6waNEifffdd6pfv746d+6sWbNmuR0WAUDiHikAKJGsrCw98cQTeu655xQcHKy1a9dq8ODBGjhwoKTfzza88cYb6t27d4m2991330mSmjRpIun3CSAsFos++eQT+fj4FOl/4QyWGf7+/kUmw3A4HIqIiNAbb7xR7JgL/9J/6tQp9ezZU2FhYZozZ44aN26sgIAAff3113r88cddAsjzzz+ve++9Vx9++KE2bdqkiRMnasGCBfryyy9Vr169Mjm2P/r55591+vRp52tZnMDAQH3xxRfaunWrPvroI23YsEFvv/22brjhBm3atKnYuorbRmm72EODCwsLS1RTabjYfow/TUxRVsy+rsX1b9GihVJSUrR+/Xpt2LBB//73v7Vy5UrNnDlTs2fPliQNHTpU119/vd5//31t2rRJzz77rBYuXKh169bp5ptvLpVjAVC1EKQAoAQuPMPowsx3x48f19VXX+1cHxMTU+KHpRYWFurNN99UUFCQ8/Knxo0byzAMxcbGqmnTphcde+ESrO+++07x8fGmj6Nx48b69NNP1a1bt0v+AfvZZ5/p119/1bp161wm1UhLSyu2f5s2bdSmTRs9+eST2rFjh7p166ZVq1Zp3rx5JT42d7322muSpISEhEv2s1qt6tOnj/r06aPFixfr6aef1hNPPKGtW7cqPj7+oqHGXampqS7LhmHo0KFDLs+7qlGjhk6dOlVk7NGjR3XVVVc5l83U1rBhQ3366afKzs52OSt14XLMhg0blnhb7mjYsKFSUlKKtJf1/oODgzVs2DANGzZM+fn5uuOOOzR//nxNnz5dAQEBkqTo6GiNGzdO48aNU2Zmpjp06KD58+cTpAC4hUv7AOAyfvjhBy1fvlwvvvii8w/ayMhI5x+GkpScnKyoqKjLbquwsFATJ05UcnKyJk6cqLCwMEnSHXfcIR8fH82ePbvImQDDMPTrr79Kkjp06KDY2FgtWbKkyB/gJTmDMHToUBUWFmru3LlF1hUUFDi3eeEsxR+3mZ+fr5UrV7qMycrKUkFBgUtbmzZtZLValZeXZ+rY3LFlyxbNnTvXJeQW5+TJk0XaLjzY9kKdF56xVVywccerr77qct/We++9pxMnTrj80d64cWN9+eWXys/Pd7atX7++yDTpZmrr16+fCgsLtXz5cpf2F154QRaLpcxDQ79+/fTVV19p586dzracnBy9/PLLatSokVq2bFnq+/zze8jPz08tW7aUYRg6f/68CgsLi0zHHxERoZiYGOfvHwDM4owUAFzGww8/rGHDhqlz587OtsGDB2vAgAHOZwn997//1fr1613GnT592vlso9zcXB06dEjr1q3T4cOHNXz4cJcw07hxY82bN0/Tp0/XkSNHNHDgQIWGhiotLU3vv/++xo4dq0cffVRWq1UvvfSSbr31VrVv316jR49WdHS0Dh48qAMHDmjjxo2XPJaePXvqgQce0IIFC7Rv3z7ddNNNqlatmlJTU/Xuu+/qxRdf1ODBg3XdddepRo0aGjVqlCZOnCiLxaLXXnutSBDasmWLJkyYoCFDhqhp06YqKCjQa6+9Jh8fHw0aNMjUsV3OJ598ooMHD6qgoEAZGRnasmWLNm/erIYNG+o///mP86xDcebMmaMvvvhC/fv3V8OGDZWZmamVK1eqXr16LmcFw8PDtWrVKoWGhio4OFhdunQxfQ/PBTVr1lT37t01evRoZWRkaMmSJWrSpInLFO333Xef3nvvPfXt21dDhw7V4cOH9frrr7tM/mC2tltvvVW9e/fWE088oSNHjqhdu3batGmTPvzwQ02ePLnItkvbtGnTtHbtWt18882aOHGiatasqX/9619KS0vTv//9b9PPXiuJm266SVFRUerWrZsiIyOVnJys5cuXq3///goNDdWpU6dUr149DR48WO3atVNISIg+/fRT7dq1S88//3yp1wOgivDATIEAUGF89NFHRkhIiHH8+PEi6xYsWGDExMQY0dHRxsKFC13WXZgu+8JPSEiIERcXZ4wcOdLYtGnTRff373//2+jevbsRHBxsBAcHG82bNzfGjx9vpKSkuPTbtm2bceONNxqhoaFGcHCw0bZtW5fpqkeNGmUEBwdfdD8vv/yy0bFjRyMwMNAIDQ012rRpY0ydOtXlOLdv325ce+21RmBgoBETE2NMnTrV2LhxoyHJ2Lp1q2EYhvHjjz8af/nLX4zGjRsbAQEBRs2aNY3evXsbn376qdvH9mcXpj+/8OPn52dERUUZN954o/Hiiy+6TDF+wZ+nP09MTDQGDBhgxMTEGH5+fkZMTIxx5513Gj/88IPLuA8//NBo2bKl4evr6zLd+KWms7/Y9Odr1641pk+fbkRERBiBgYFG//79jaNHjxYZ//zzzxt169Y1/P39jW7duhm7d+8uss1L1fbn6c8N4/fpxh9++GEjJibGqFatmhEXF2c8++yzLlPkG0bx05cbxsWnZf+zi40/fPiwMXjwYCM8PNwICAgwOnfubKxfv96lz4XX6VJT5//RhenPn3322SLr/v73vxs9evQwatWqZfj7+xuNGzc2HnvsMeP06dOGYRhGXl6e8dhjjxnt2rVz/j/Trl07Y+XKlSXaNwAUx2IY5XQ3KQAAAABUEtwjBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEzigbySHA6Hjh8/rtDQUFksFk+XAwAAAMBDDMNQdna2YmJiLvkQcYKUpOPHj6t+/fqeLgMAAACAl/jpp59Ur169i64nSEkKDQ2V9PuLFRYW5uFqAAAAAHhKVlaW6tev78wIF0OQkpyX84WFhRGkAAAAAFz2lh8mmwAAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYJKvpwsAAFR+NptNdrvd9LjatWurQYMGZVARAABXhiAFAChTNptNzVu00NncXNNjA4OCdDA5mTAFAPA6BCkAQJmy2+06m5urofNeUkRsXInHZaal6p0nH5LdbidIAQC8DkEKAFAuImLjVLdFO0+XAQBAqWCyCQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGCSR4PUF198oVtvvVUxMTGyWCz64IMPXNYbhqGZM2cqOjpagYGBio+PV2pqqkufkydPasSIEQoLC1N4eLjGjBmjM2fOlONRAAAAAKhqPBqkcnJy1K5dO61YsaLY9YsWLdLSpUu1atUqJSUlKTg4WAkJCTp37pyzz4gRI3TgwAFt3rxZ69ev1xdffKGxY8eW1yEAAAAAqII8+kDem2++WTfffHOx6wzD0JIlS/Tkk09qwIABkqRXX31VkZGR+uCDDzR8+HAlJydrw4YN2rVrlzp16iRJWrZsmfr166fnnntOMTEx5XYsAAAAAKoOjwapS0lLS1N6erri4+OdbdWrV1eXLl20c+dODR8+XDt37lR4eLgzRElSfHy8rFarkpKSdPvttxe77by8POXl5TmXs7KyJEkFBQUqKCgooyMCgKrJ4XDIz89PVhmyOApLPM4qQ35+fnI4HHw2AwDKTUm/c7w2SKWnp0uSIiMjXdojIyOd69LT0xUREeGy3tfXVzVr1nT2Kc6CBQs0e/bsIu27d+9WcHDwlZYOAPiD7OxszZgxQ3UDzsn/l+9LPC4i4JxmzJghu92upKSkMqwQAID/Lycnp0T9vDZIlaXp06drypQpzuWsrCzVr19fnTp1UlhYmAcrA4DKZ9++fZo7d64eXP2RYhq2LPG44ynfatXcudq+fbvat29fdgUCAPAHF65WuxyvDVJRUVGSpIyMDEVHRzvbMzIynF+oUVFRyszMdBlXUFCgkydPOscXx9/fX/7+/kXafX195evrtS8JAFRIVqtV+fn5csgiw+pT4nEOWZSfny+r1cpnMwCg3JT0O8drnyMVGxurqKgoJSYmOtuysrKUlJSkrl27SpK6du2qU6dOac+ePc4+W7ZskcPhUJcuXcq9ZgAAAABVg0f/ie/MmTM6dOiQczktLU379u1TzZo11aBBA02ePFnz5s1TXFycYmNjNWPGDMXExGjgwIGSpBYtWqhv3766//77tWrVKp0/f14TJkzQ8OHDmbEPAAAAQJnxaJDavXu3evfu7Vy+cN/SqFGjtGbNGk2dOlU5OTkaO3asTp06pe7du2vDhg0KCAhwjnnjjTc0YcIE9enTR1arVYMGDdLSpUvL/VgAAAAAVB0eDVK9evWSYRgXXW+xWDRnzhzNmTPnon1q1qypN998syzKAwAAAIBiee09UgAAAADgrQhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGCSVwepwsJCzZgxQ7GxsQoMDFTjxo01d+5cGYbh7GMYhmbOnKno6GgFBgYqPj5eqampHqwaAAAAQGXn1UFq4cKFeumll7R8+XIlJydr4cKFWrRokZYtW+bss2jRIi1dulSrVq1SUlKSgoODlZCQoHPnznmwcgAAAACVma+nC7iUHTt2aMCAAerfv78kqVGjRlq7dq2++uorSb+fjVqyZImefPJJDRgwQJL06quvKjIyUh988IGGDx/usdoBAAAAVF5eHaSuu+46vfzyy/rhhx/UtGlTffPNN9q2bZsWL14sSUpLS1N6erri4+OdY6pXr64uXbpo586dFw1SeXl5ysvLcy5nZWVJkgoKClRQUFCGRwQAVY/D4ZCfn5+sMmRxFJZ4nFWG/Pz85HA4+GwGAJSbkn7neHWQmjZtmrKystS8eXP5+PiosLBQ8+fP14gRIyRJ6enpkqTIyEiXcZGRkc51xVmwYIFmz55dpH337t0KDg4uxSMAAGRnZ2vGjBmqG3BO/r98X+JxEQHnNGPGDNntdiUlJZVhhQAA/H85OTkl6ufVQeqdd97RG2+8oTfffFOtWrXSvn37NHnyZMXExGjUqFFub3f69OmaMmWKczkrK0v169dXp06dFBYWVhqlAwD+n3379mnu3Ll6cPVHimnYssTjjqd8q1Vz52r79u1q37592RUIAMAfXLha7XK8Okg99thjmjZtmvMSvTZt2ujo0aNasGCBRo0apaioKElSRkaGoqOjneMyMjIu+aXr7+8vf3//Iu2+vr7y9fXqlwQAKhyr1ar8/Hw5ZJFh9SnxOIcsys/Pl9Vq5bMZAFBuSvqd49Wz9uXm5spqdS3Rx8dHDodDkhQbG6uoqCglJiY612dlZSkpKUldu3Yt11oBAAAAVB1e/U98t956q+bPn68GDRqoVatW2rt3rxYvXqy//OUvkiSLxaLJkydr3rx5iouLU2xsrGbMmKGYmBgNHDjQs8UDAAAAqLS8OkgtW7ZMM2bM0Lhx45SZmamYmBg98MADmjlzprPP1KlTlZOTo7Fjx+rUqVPq3r27NmzYoICAAA9WDgAAAKAy8+ogFRoaqiVLlmjJkiUX7WOxWDRnzhzNmTOn/AoDAAAAUKV59T1SAAAAAOCNCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgkq+nCwAAoLTZbDbZ7XbT42rXrq0GDRqUQUUAgMqGIAUAqFRsNpuat2ihs7m5pscGBgXpYHIyYQoAcFkEKQBApWK323U2N1dD572kiNi4Eo/LTEvVO08+JLvdTpACAFwWQQoAUClFxMapbot2ni4DAFBJMdkEAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJjkVpD68ccfS7sOAAAAAKgw3ApSTZo0Ue/evfX666/r3LlzpV0TAAAAAHg1t4LU119/rbZt22rKlCmKiorSAw88oK+++qq0awMAAAAAr+RWkGrfvr1efPFFHT9+XP/85z914sQJde/eXa1bt9bixYv1yy+/lHadAAAAAOA1rmiyCV9fX91xxx169913tXDhQh06dEiPPvqo6tevr3vuuUcnTpy44gKPHTumkSNHqlatWgoMDFSbNm20e/du53rDMDRz5kxFR0crMDBQ8fHxSk1NveL9AgAAAMDFXFGQ2r17t8aNG6fo6GgtXrxYjz76qA4fPqzNmzfr+PHjGjBgwBUV99tvv6lbt26qVq2aPvnkE33//fd6/vnnVaNGDWefRYsWaenSpVq1apWSkpIUHByshIQE7t0CAAAAUGZ83Rm0ePFirV69WikpKerXr59effVV9evXT1br77ksNjZWa9asUaNGja6ouIULF6p+/fpavXq1sy02Ntb534ZhaMmSJXryySedoe3VV19VZGSkPvjgAw0fPrzY7ebl5SkvL8+5nJWVJUkqKChQQUHBFdUMAJXZzz//LLvdbmpMSkqK/Pz8ZJUhi6OwxOOsMuTn5yeHw2Hqs9nhcJTr/gAAlUtJvwMshmEYZjceFxenv/zlL7r33nsVHR1dbJ/8/HytXbtWo0aNMrt5p5YtWyohIUE///yzPv/8c9WtW1fjxo3T/fffL+n3adgbN26svXv3qn379s5xPXv2dN7HVZxZs2Zp9uzZRdo3btyo4OBgt+sFgMrs3LlzSkpKksPhcGt83Zbt5R9U8s/YvNwcHft+nzp16qTQ0NASj8vOztbu3bvLbX8AgMolJydHCQkJOn36tMLCwi7az60gVV4CAgIkSVOmTNGQIUO0a9cuTZo0SatWrdKoUaO0Y8cOdevWTcePH3cJdEOHDpXFYtHbb79d7HaLOyNVv359/frrr5d8sQCgKtu3b5+6deumQU+9qDqNmpR4XOrOz5T48rN6cPVHimnWpsTjjqd8q1Wj+2v79u0u/1hW0jrLa38AgMolKytLtWrVumyQcuvSvtWrVyskJERDhgxxaX/33XeVm5t7RWeh/sjhcKhTp056+umnJUlXX321vvvuO2eQcpe/v7/8/f2LtPv6+srX162XBAAqPavVqvz8fNVqFKfoFu1KPC497ZDy8/PlkEWG1afE4xyyKD8/X1ar1dRn84U6y2t/AIDKpaTfAW5NNrFgwQLVrl27SHtERIQz9JSG6OhotWzZ0qWtRYsWstlskqSoqChJUkZGhkufjIwM5zoAAAAAKG1u/ZObzWZzmfThgoYNGzpDTmno1q2bUlJSXNp++OEHNWzYUNLvE09ERUUpMTHReRlGVlaWkpKS9NBDD5VaHQBQ2dhsNtOTRiQnJ5dRNQAAVDxuBamIiAjt37+/yKx833zzjWrVqlUadUmSHn74YV133XV6+umnNXToUH311Vd6+eWX9fLLL0uSLBaLJk+erHnz5ikuLk6xsbGaMWOGYmJiNHDgwFKrAwAqE5vNpuYtWuhsbq6nSwEAoMJyK0jdeeedmjhxokJDQ9WjRw9J0ueff65JkyZddMpxd1xzzTV6//33NX36dM2ZM0exsbFasmSJRowY4ewzdepU5eTkaOzYsTp16pS6d++uDRs2OCeqAAC4stvtOpubq6HzXlJEbFyJx6VsT9TmlQvKsDIAACoOt4LU3LlzdeTIEfXp08d5M5bD4dA999xTqvdISdItt9yiW2655aLrLRaL5syZozlz5pTqfgGgsouIjVNdE5NGZKallmE1AABULG4FKT8/P7399tuaO3euvvnmGwUGBqpNmzbOe5cAAAAAoDK7ovldmzZtqqZNm5ZWLQAAAABQIbgVpAoLC7VmzRolJiYqMzOzyFPut2zZUirFAQAAAIA3citITZo0SWvWrFH//v3VunVrWSyW0q4LAAAAALyWW0Hqrbfe0jvvvKN+/fqVdj0AALgw+/wqnncFACgPbk820aRJk9KuBQAAp2x7hixWq0aOHOnpUgAAKMKtIPXII4/oxRdf1PLly7msDwBQJs5mZ8lwOHjeFQDAK7kVpLZt26atW7fqk08+UatWrVStWjWX9evWrSuV4gAA4HlXAABv5FaQCg8P1+23317atQAAAABAheBWkFq9enVp1wEAAAAAFYbV3YEFBQX69NNP9fe//13Z2dmSpOPHj+vMmTOlVhwAAAAAeCO3zkgdPXpUffv2lc1mU15enm688UaFhoZq4cKFysvL06pVq0q7TgAAAADwGm6dkZo0aZI6deqk3377TYGBgc7222+/XYmJiaVWHAAAAAB4I7fOSP3vf//Tjh075Ofn59LeqFEjHTt2rFQKAwBcns1mk91uNzWGB9YCAHDl3ApSDodDhYWFRdp//vlnhYaGXnFRAIDLs9lsat6ihc7m5nq6FAAAqhy3gtRNN92kJUuW6OWXX5YkWSwWnTlzRk899ZT69etXqgUCAIpnt9t1NjeXB9YCAOABbgWp559/XgkJCWrZsqXOnTunu+66S6mpqapdu7bWrl1b2jUCAC6BB9YCAFD+3ApS9erV0zfffKO33npL+/fv15kzZzRmzBiNGDHCZfIJAAAAAKiM3ApSkuTr66uRI0eWZi0AAAAAUCG4FaReffXVS66/55573CoGAAAAACoCt4LUpEmTXJbPnz+v3Nxc+fn5KSgoiCAFAAAAoFJz64G8v/32m8vPmTNnlJKSou7duzPZBAAAAIBKz60gVZy4uDg988wzRc5WAQAAAEBlU2pBSvp9Aorjx4+X5iYBAAAAwOu4dY/Uf/7zH5dlwzB04sQJLV++XN26dSuVwgAAAADAW7kVpAYOHOiybLFYVKdOHd1www16/vnnS6MuAAAAAPBabgUph8NR2nUAAAAAQIVRqvdIAQAAAEBV4NYZqSlTppS47+LFi93ZBQAAAAB4LbeC1N69e7V3716dP39ezZo1kyT98MMP8vHxUYcOHZz9LBZL6VQJAAAAAF7ErSB16623KjQ0VP/6179Uo0YNSb8/pHf06NG6/vrr9cgjj5RqkQAAlJfk5GTTY2rXrq0GDRqUQTUAAG/lVpB6/vnntWnTJmeIkqQaNWpo3rx5uummmwhSAIAKJ9ueIYvVqpEjR5oeGxgUpIPJyYQpAKhC3ApSWVlZ+uWXX4q0//LLL8rOzr7iogAAKG9ns7NkOBwaOu8lRcTGlXhcZlqq3nnyIdntdoIUAFQhbgWp22+/XaNHj9bzzz+vzp07S5KSkpL02GOP6Y477ijVAgEAKE8RsXGq26Kdp8sAAHg5t4LUqlWr9Oijj+quu+7S+fPnf9+Qr6/GjBmjZ599tlQLBAAAAABv41aQCgoK0sqVK/Xss8/q8OHDkqTGjRsrODi4VIsDAAAAAG90RQ/kPXHihE6cOKG4uDgFBwfLMIzSqgsAAAAAvJZbQerXX39Vnz591LRpU/Xr108nTpyQJI0ZM4YZ+wAAAABUem5d2vfwww+rWrVqstlsatGihbN92LBhmjJlip5//vlSKxAAALiy2Wyy2+1ujeWZVwBQOtwKUps2bdLGjRtVr149l/a4uDgdPXq0VAoDAABF2Ww2NW/RQmdzc90azzOvAKB0uBWkcnJyFBQUVKT95MmT8vf3v+KiAABA8ex2u87m5pp+3pXEM68AoDS5FaSuv/56vfrqq5o7d64kyWKxyOFwaNGiRerdu3epFggAAIrieVcA4FluBalFixapT58+2r17t/Lz8zV16lQdOHBAJ0+e1Pbt20u7RgAAAADwKm7N2te6dWv98MMP6t69uwYMGKCcnBzdcccd2rt3rxo3blzaNQIAAACAVzF9Rur8+fPq27evVq1apSeeeKIsagIAAAAAr2b6jFS1atW0f//+sqgFAAAAACoEty7tGzlypP7xj3+Udi0AAAAAUCG4NdlEQUGB/vnPf+rTTz9Vx44dFRwc7LJ+8eLFpVIcAAAAAHgjU0Hqxx9/VKNGjfTdd9+pQ4cOkqQffvjBpY/FYim96gAAAADAC5kKUnFxcTpx4oS2bt0qSRo2bJiWLl2qyMjIMikOAAAAALyRqXukDMNwWf7kk0+Uk5NTqgUBAAAAgLdza7KJC/4crAAAAACgKjAVpCwWS5F7oLgnCgAAAEBVY+oeKcMwdO+998rf31+SdO7cOT344INFZu1bt25d6VUIAAAAAF7GVJAaNWqUy/LIkSNLtRgAAAAAqAhMBanVq1eXVR0AAAAAUGFc0WQTAAAAAFAVEaQAAAAAwCSCFAAAAACYRJACAAAAAJNMTTYBACgbNptNdrvd1Jjk5OQyqgblhd87AFRcBCkA8DCbzabmLVrobG6up0tBOeL3DgAVG0EKADzMbrfrbG6uhs57SRGxcSUel7I9UZtXLijDylCW+L0DQMVGkAIALxERG6e6LdqVuH9mWmoZVoPywu8dAComJpsAAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYFKFClLPPPOMLBaLJk+e7Gw7d+6cxo8fr1q1aikkJESDBg1SRkaG54oEAAAAUOlVmCC1a9cu/f3vf1fbtm1d2h9++GH997//1bvvvqvPP/9cx48f1x133OGhKgEAAABUBRUiSJ05c0YjRozQK6+8oho1ajjbT58+rX/84x9avHixbrjhBnXs2FGrV6/Wjh079OWXX3qwYgAAAACVma+nCyiJ8ePHq3///oqPj9e8efOc7Xv27NH58+cVHx/vbGvevLkaNGignTt36tprry12e3l5ecrLy3MuZ2VlSZIKCgpUUFBQRkcBAMVzOBzy8/OTVYYsjsISj/OxiHFeMM4qQ35+fkpOTpbD4SjxuJSUlHKt84+1OhwOvu8A4CJK+vloMQzDKONarshbb72l+fPna9euXQoICFCvXr3Uvn17LVmyRG+++aZGjx7tEookqXPnzurdu7cWLlxY7DZnzZql2bNnF2nfuHGjgoODy+Q4AOBisrOztXv3btVt2V7+QSX/DDrz6y/KTPuBcR4el3v6N6Wnfl/i/n9WXnVKUl5ujo59v0+dOnVSaGio2VIBoErIyclRQkKCTp8+rbCwsIv28+ozUj/99JMmTZqkzZs3KyAgoNS2O336dE2ZMsW5nJWVpfr166tTp06XfLEAoCzs27dPc+fO1YOrP1JMw5YlHvfN1+/r34zzmnGDnnpRdRo1KfG41J2fKfHlZ8utTkk6nvKtVs2dq+3bt6t9+/amxgJAVXHharXL8eogtWfPHmVmZqpDhw7OtsLCQn3xxRdavny5Nm7cqPz8fJ06dUrh4eHOPhkZGYqKirrodv39/eXv71+k3dfXV76+Xv2SAKiErFar8vPz5ZBFhtWnxOMKDTHOi8bVahSn6BbtSjwuPe1QudYpSQ5ZlJ+fL6vVyvcdAFxEST8fvfpTtE+fPvr2229d2kaPHq3mzZvr8ccfV/369VWtWjUlJiZq0KBBkn6/5txms6lr166eKBkAAABAFeDVQSo0NFStW7d2aQsODlatWrWc7WPGjNGUKVNUs2ZNhYWF6a9//au6du160YkmAAAAAOBKeXWQKokXXnhBVqtVgwYNUl5enhISErRy5UpPlwUAAACgEqtwQeqzzz5zWQ4ICNCKFSu0YsUKzxQEAAAAoMqpcEEKALyVzWaT3W43PS45ObkMqgEAAGWJIAUApcBms6l5ixY6m5vr6VIAAEA5IEgBQCmw2+06m5urofNeUkRsnKmxKdsTtXnlgjKqDAAAlAWCFACUoojYONU18SwhScpMSy2jagAAQFmxeroAAAAAAKhoCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEzy9XQBAFBWbDab7Ha76XG1a9dWgwYNyqAiAABQWRCkAFRKNptNzVu00NncXNNjA4OCdDA5mTAFAAAuiiAFoFKy2+06m5urofNeUkRsXInHZaal6p0nH5LdbidIAQCAiyJIAajUImLjVLdFO0+XAQAAKhkmmwAAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIlZ+wCgGMnJyWXaHwAAVGwEKQD4g2x7hixWq0aOHOnpUgAAgBcjSAHAH5zNzpLhcJh+kG/K9kRtXrmgDCsDAADehCAFAMUw+yDfzLTUMqwGAAB4GyabAAAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmeXWQWrBgga655hqFhoYqIiJCAwcOVEpKikufc+fOafz48apVq5ZCQkI0aNAgZWRkeKhiAAAAAFWBVwepzz//XOPHj9eXX36pzZs36/z587rpppuUk5Pj7PPwww/rv//9r9599119/vnnOn78uO644w4PVg0AAACgsvP1dAGXsmHDBpflNWvWKCIiQnv27FGPHj10+vRp/eMf/9Cbb76pG264QZK0evVqtWjRQl9++aWuvfZaT5QNAAAAoJLz6iD1Z6dPn5Yk1axZU5K0Z88enT9/XvHx8c4+zZs3V4MGDbRz586LBqm8vDzl5eU5l7OysiRJBQUFKigoKKvyAZQjh8MhPz8/WWXI4igs8Tgfi8p1nCf2ybiqOU6SrDLk5+cnh8PB9x0AXERJPx8thmEYZVxLqXA4HLrtttt06tQpbdu2TZL05ptvavTo0S6hSJI6d+6s3r17a+HChcVua9asWZo9e3aR9o0bNyo4OLj0iwdQ7rKzs7V7927Vbdle/kEl///6zK+/KDPth3Ib54l9Mq5qjpOkvNwcHft+nzp16qTQ0FBTYwGgqsjJyVFCQoJOnz6tsLCwi/arMGekxo8fr++++84Zoq7E9OnTNWXKFOdyVlaW6tevr06dOl3yxQJQcezbt09z587Vg6s/UkzDliUe983X7+vf5TjOE/tkXNUcJ0nHU77VqrlztX37drVv397UWACoKi5crXY5FSJITZgwQevXr9cXX3yhevXqOdujoqKUn5+vU6dOKTw83NmekZGhqKioi27P399f/v7+Rdp9fX3l61shXhIAl2G1WpWfny+HLDKsPiUeV2ioXMd5Yp+Mq5rjJMkhi/Lz82W1Wvm+A4CLKOnno1fP2mcYhiZMmKD3339fW7ZsUWxsrMv6jh07qlq1akpMTHS2paSkyGazqWvXruVdLgAAAIAqwqv/OWr8+PF688039eGHHyo0NFTp6emSpOrVqyswMFDVq1fXmDFjNGXKFNWsWVNhYWH661//qq5duzJjHwAAAIAy49VB6qWXXpIk9erVy6V99erVuvfeeyVJL7zwgqxWqwYNGqS8vDwlJCRo5cqV5VwpAAAAgKrEq4NUSSYUDAgI0IoVK7RixYpyqAgAAAAAvPweKQAAAADwRl59RgoAAJS+5ORk02Nq166tBg0alEE1AFAxEaQAAKgisu0ZslitGjlypOmxgUFBOpicTJgCgP+HIAUAQBVxNjtLhsOhofNeUkRsXInHZaal6p0nH5LdbidIAcD/Q5ACAKCKiYiNU90W7TxdBgBUaEw2AQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJvl6ugAAAFAxJCcnmx5Tu3ZtNWjQoAyqAQDPIkgBAIBLyrZnyGK1auTIkabHBgYF6WByMmEKQKVDkAIAAJd0NjtLhsOhofNeUkRsXInHZaal6p0nH5LdbidIAah0CFIAAKBEImLjVLdFO0+XAQBegSAFAAC8js1mk91uNz2Oe7IAlBeCFAAA8Co2m03NW7TQ2dxc02O5JwtAeSFIAQAAr2K323U2N5d7sgB4NYIUAADwStyTBcCbEaQAeD137pVw53k3AAAAJUWQAuDVruReCQAAgLJCkALg1dy9VyJle6I2r1xQhpUBAICqjCAFoEIwe69EZlpqGVYDAACqOqunCwAAAACAioYgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTfD1dAICqw2azyW63mxqTnJxcRtUAAAC4jyAFoFzYbDY1b9FCZ3NzPV0KAADAFSNIASgXdrtdZ3NzNXTeS4qIjSvxuJTtidq8ckEZVgYAAGAeQQpAuYqIjVPdFu1K3D8zLbUMqwEAAHAPk00AAAAAgEmckQKqMHcmf5Ck2rVrq0GDBmVQEQAAQMVAkAKqqCuZ/CEwKEgHk5MJUwAAoMoiSAFVlLuTP2SmpeqdJx+S3W4nSAEAgCqLIAVUcWYnfwAAAABBCgAAlDGzD9bmQdwAKgKCFAAAKBPZ9gxZrFaNHDnS06UAQKkjSAEAgDJxNjtLhsPBg7gBVEoEKQAAUKZ4EDeAyoggBcAt3PMAoDLhuXoAzCJIATCFex4AVDY8Vw+AOwhSAEzhngcAlQ3P1QPgDoIUALdwzwOAyobn6gEwgyAFVALuXNvPPUsAUDrc+Tzl3iqg4iNIARXclVzbDwBw35XcM8q9VUDFR5ACKjh3r+3nniUAuDLu3jPKvVVA5UCQAioJ7lkCAM/g3iqgarJ6ugAAAAAAqGgIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJWfsAAEClYvYBuTygHIA7CFIAAKBSuJIH5AKAWQQpAABQKbj7gFweUA7AHQQpAABQqfCAcgDlgSCFcmez2WS3202Pq127tho0aFAGFQEAUDHwHQp4D4IUypXNZlPzFi10NjfX9NjAoCAdTE7miwAAUCXxHQp4F4IUypXdbtfZ3FzT169npqXqnScfkt1u50sAAFAl8R0KeBeCFDzC7PXrAADgd3yHAt6BIOWFKsr1z+7UWVWe1VFRfocAAM8p7+dduTM+Ly9P/v7+bu3P3bHujqsIfwdJFef43FWV/gYiSHmZinL985XUWdlVlN8hAMAzyvt5V1eyP4vVKsPhcGu/7o51d1xF+TuoIhyfu6ra30CVJkitWLFCzz77rNLT09WuXTstW7ZMnTt39nRZplWU65/drbMqPKujovwOAQCeUd7Pu7rS/ZkddyVj3R1X0f4O8vbjc1dV+xuoUgSpt99+W1OmTNGqVavUpUsXLVmyRAkJCUpJSVFERISny3NLRbn+mWd1XFxF+R0CADyjvL9D3d2fO99n7o69kn16QmU/PndV9uO7wOrpAkrD4sWLdf/992v06NFq2bKlVq1apaCgIP3zn//0dGkAAAAAKqEKf0YqPz9fe/bs0fTp051tVqtV8fHx2rlzZ7Fj8vLylJeX51w+ffq0JOnkyZMqKCgo24IvIysrS9WqVVP6wf06n3umxON+tf2oatWqac+ePcrKyjK1T6vVKofJa3VTU1PdqvOk7XCFOL4rGevua+PuMZb374JxpTuuItXKuIo9riLVyriKPc4T++TvoItz9+8gT/wNlJWVpZMnT5ottdRdeI0Nw7hkP4txuR5e7vjx46pbt6527Nihrl27OtunTp2qzz//XElJSUXGzJo1S7Nnzy7PMgEAAABUID/99JPq1at30fUV/oyUO6ZPn64pU6Y4lx0Oh06ePKlatWrJYrF4sLLykZWVpfr16+unn35SWFiYp8tBBcZ7CaWB9xFKC+8llAbeRzAMQ9nZ2YqJiblkvwofpGrXri0fHx9lZGS4tGdkZCgqKqrYMf7+/kXm7w8PDy+rEr1WWFgYHxAoFbyXUBp4H6G08F5CaeB9VLVVr179sn0q/GQTfn5+6tixoxITE51tDodDiYmJLpf6AQAAAEBpqfBnpCRpypQpGjVqlDp16qTOnTtryZIlysnJ0ejRoz1dGgAAAIBKqFIEqWHDhumXX37RzJkzlZ6ervbt22vDhg2KjIz0dGleyd/fX0899VSRyxsBs3gvoTTwPkJp4b2E0sD7CCVV4WftAwAAAIDyVuHvkQIAAACA8kaQAgAAAACTCFIAAAAAYBJBCgAAAABMIkhVEfPnz9d1112noKCgEj982DAMzZw5U9HR0QoMDFR8fLxSU1PLtlB4tZMnT2rEiBEKCwtTeHi4xowZozNnzlxyTK9evWSxWFx+HnzwwXKqGN5ixYoVatSokQICAtSlSxd99dVXl+z/7rvvqnnz5goICFCbNm308ccfl1Ol8HZm3ktr1qwp8vkTEBBQjtXCG33xxRe69dZbFRMTI4vFog8++OCyYz777DN16NBB/v7+atKkidasWVPmdcL7EaSqiPz8fA0ZMkQPPfRQiccsWrRIS5cu1apVq5SUlKTg4GAlJCTo3LlzZVgpvNmIESN04MABbd68WevXr9cXX3yhsWPHXnbc/fffrxMnTjh/Fi1aVA7Vwlu8/fbbmjJlip566il9/fXXateunRISEpSZmVls/x07dujOO+/UmDFjtHfvXg0cOFADBw7Ud999V86Vw9uYfS9JUlhYmMvnz9GjR8uxYnijnJwctWvXTitWrChR/7S0NPXv31+9e/fWvn37NHnyZN13333auHFjGVcKr2egSlm9erVRvXr1y/ZzOBxGVFSU8eyzzzrbTp06Zfj7+xtr164twwrhrb7//ntDkrFr1y5n2yeffGJYLBbj2LFjFx3Xs2dPY9KkSeVQIbxV586djfHjxzuXCwsLjZiYGGPBggXF9h86dKjRv39/l7YuXboYDzzwQJnWCe9n9r1U0u88VF2SjPfff/+SfaZOnWq0atXKpW3YsGFGQkJCGVaGioAzUihWWlqa0tPTFR8f72yrXr26unTpop07d3qwMnjKzp07FR4erk6dOjnb4uPjZbValZSUdMmxb7zxhmrXrq3WrVtr+vTpys3NLety4SXy8/O1Z88el88Sq9Wq+Pj4i36W7Ny506W/JCUkJPDZU8W5816SpDNnzqhhw4aqX7++BgwYoAMHDpRHuahE+EzCxfh6ugB4p/T0dElSZGSkS3tkZKRzHaqW9PR0RUREuLT5+vqqZs2al3xP3HXXXWrYsKFiYmK0f/9+Pf7440pJSdG6devKumR4AbvdrsLCwmI/Sw4ePFjsmPT0dD57UIQ776VmzZrpn//8p9q2bavTp0/rueee03XXXacDBw6oXr165VE2KoGLfSZlZWXp7NmzCgwM9FBl8DTOSFVg06ZNK3IT7Z9/LvblAlxQ1u+jsWPHKiEhQW3atNGIESP06quv6v3339fhw4dL8SgAoKiuXbvqnnvuUfv27dWzZ0+tW7dOderU0d///ndPlwagEuCMVAX2yCOP6N57771kn6uuusqtbUdFRUmSMjIyFB0d7WzPyMhQ+/bt3domvFNJ30dRUVFFbuguKCjQyZMnne+XkujSpYsk6dChQ2rcuLHpelGx1K5dWz4+PsrIyHBpz8jIuOj7JioqylR/VA3uvJf+rFq1arr66qt16NChsigRldTFPpPCwsI4G1XFEaQqsDp16qhOnTplsu3Y2FhFRUUpMTHRGZyysrKUlJRkauY/eL+Svo+6du2qU6dOac+ePerYsaMkacuWLXI4HM5wVBL79u2TJJeAjsrLz89PHTt2VGJiogYOHChJcjgcSkxM1IQJE4od07VrVyUmJmry5MnOts2bN6tr167lUDG8lTvvpT8rLCzUt99+q379+pVhpahsunbtWuQRDHwmQRKz9lUVR48eNfbu3WvMnj3bCAkJMfbu3Wvs3bvXyM7OdvZp1qyZsW7dOufyM888Y4SHhxsffvihsX//fmPAgAFGbGyscfbsWU8cArxA3759jauvvtpISkoytm3bZsTFxRl33nmnc/3PP/9sNGvWzEhKSjIMwzAOHTpkzJkzx9i9e7eRlpZmfPjhh8ZVV11l9OjRw1OHAA946623DH9/f2PNmjXG999/b4wdO9YIDw830tPTDcMwjLvvvtuYNm2as//27dsNX19f47nnnjOSk5ONp556yqhWrZrx7bffeuoQ4CXMvpdmz55tbNy40Th8+LCxZ88eY/jw4UZAQIBx4MABTx0CvEB2drbz7yBJxuLFi429e/caR48eNQzDMKZNm2bcfffdzv4//vijERQUZDz22GNGcnKysWLFCsPHx8fYsGGDpw4BXoIgVUWMGjXKkFTkZ+vWrc4+kozVq1c7lx0OhzFjxgwjMjLS8Pf3N/r06WOkpKSUf/HwGr/++qtx5513GiEhIUZYWJgxevRolzCelpbm8r6y2WxGjx49jJo1axr+/v5GkyZNjMcee8w4ffq0h44AnrJs2TKjQYMGhp+fn9G5c2fjyy+/dK7r2bOnMWrUKJf+77zzjtG0aVPDz8/PaNWqlfHRRx+Vc8XwVmbeS5MnT3b2jYyMNPr162d8/fXXHqga3mTr1q3F/k104b0zatQoo2fPnkXGtG/f3vDz8zOuuuoql7+XUHVZDMMwPHIqDAAAAAAqKGbtAwAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAACPeOONN1S/fn3VqFFDU6ZMcVl35MgRNW3aVFlZWc62WbNmyWKxyGKxyNfXV7Vr11aPHj20ZMkS5eXllXf5AIAqjiAFACh3drtd9913n5577jlt2rRJr7/+utavX+9cP27cOD3zzDMKCwtzGdeqVSudOHFCNptNW7du1ZAhQ7RgwQJdd911ys7OLrN68/Pzy2zbAICKiSAFACh3P/74o6pXr65hw4bpmmuuUe/evZWcnCxJWrt2rapVq6Y77rijyDhfX19FRUUpJiZGbdq00V//+ld9/vnn+u6777Rw4UJnv7y8PD366KOqW7eugoOD1aVLF3322Wcu29q+fbt69eqloKAg1ahRQwkJCfrtt98kSb169dKECRM0efJk1a5dWwkJCZKk7777TjfffLNCQkIUGRmpu+++W3a73bnNDRs2qHv37goPD1etWrV0yy236PDhw871+fn5mjBhgqKjoxUQEKCGDRtqwYIFzvWnTp3Sfffdpzp16igsLEw33HCDvvnmmyt/wQEApY4gBQAod3FxccrNzdXevXt18uRJ7dq1S23bttVvv/2mGTNmaPny5SXeVvPmzXXzzTdr3bp1zrYJEyZo586deuutt7R//34NGTJEffv2VWpqqiRp37596tOnj1q2bKmdO3dq27ZtuvXWW1VYWOjcxr/+9S/5+flp+/btWrVqlU6dOqUbbrhBV199tXbv3q0NGzYoIyNDQ4cOdY7JycnRlClTtHv3biUmJspqter222+Xw+GQJC1dulT/+c9/9M477yglJUVvvPGGGjVq5Bw/ZMgQZWZm6pNPPtGePXvUoUMH9enTRydPnnT3pQYAlBGLYRiGp4sAAFQ977//vmbOnKmzZ89q5MiRmjVrlsaMGaM2bdqoQ4cOmjRpks6fP69Zs2Zp8ODBmjVrlj744APt27evyLamTZumpUuXKjc3VzabTVdddZVsNptiYmKcfeLj49W5c2c9/fTTuuuuu2Sz2bRt27Zia+vVq5eysrL09ddfO9vmzZun//3vf9q4caOz7eeff1b9+vWVkpKipk2bFtmO3W5XnTp19O2336p169aaOHGiDhw4oE8//VQWi8Wl77Zt29S/f39lZmbK39/f2d6kSRNNnTpVY8eOLfFrCwAoe76eLgAAUDXdfvvtuv32253Ln3/+ufbv369ly5apSZMmWrt2raKiotS5c2f16NHjktsyDMMZTL799lsVFhYWCTZ5eXmqVauWpN/PSA0ZMuSS2+zYsaPL8jfffKOtW7cqJCSkSN/Dhw+radOmSk1N1cyZM5WUlCS73e48E2Wz2dS6dWvde++9uvHGG9WsWTP17dtXt9xyi2666Sbn9s+cOeOs8YKzZ8+6XB4IAPAOBCkAgMfl5eVp3Lhxeu2113To0CEVFBSoZ8+ekqSmTZsqKSnpkuOTk5MVGxsrSTpz5ox8fHy0Z88e+fj4uPS7EIICAwMvW1NwcLDL8pkzZ3Trrbe63It1QXR0tCTp1ltvVcOGDfXKK68oJiZGDodDrVu3dk5W0aFDB6WlpemTTz7Rp59+qqFDhyo+Pl7vvfeezpw5o+jo6CL3cklSeHj4ZesFAJQvghQAwOPmzZunvn37qkOHDtq7d68KCgqc686fP+9y79KfHTx4UBs2bND06dMlSVdffbUKCwuVmZmp66+/vtgxbdu2VWJiombPnl3iGjt06KB///vfatSokXx9i359/vrrr0pJSdErr7zi3G9xlw6GhYVp2LBhGjZsmAYPHqy+ffvq5MmT6tChg9LT0+Xr6+ty3xQAwDsx2QQAwKO+//57vf3225ozZ46k3yePsFqt+sc//qGPPvpIBw8e1DXXXCNJKigoUHp6uo4fP65vv/1Wy5YtU8+ePdW+fXs99thjkn4/gzVixAjdc889WrdundLS0vTVV19pwYIF+uijjyRJ06dP165duzRu3Djt379fBw8e1EsvveQyA9+fjR8/XidPntSdd96pXbt26fDhw9q4caNGjx6twsJC1ahRQ7Vq1dLLL7+sQ4cOacuWLUWej7V48WKtXbtWBw8e1A8//KB3331XUVFRCg8PV3x8vLp27aqBAwdq06ZNOnLkiHbs2KEnnnhCu3fvLouXHgBwBTgjBQDwGMMwNHbsWC1evNh5KV1gYKDWrFmj8ePHKy8vT8uXL1fdunUlSQcOHFB0dLR8fHxUvXp1tWzZUtOnT9dDDz3kMkHD6tWrNW/ePD3yyCM6duyYateurWuvvVa33HKLpN/D1qZNm/S3v/1NnTt3VmBgoLp06aI777zzorXGxMRo+/btevzxx3XTTTcpLy9PDRs2VN++fWW1WmWxWPTWW29p4sSJat26tZo1a6alS5eqV69ezm2EhoZq0aJFSk1NlY+Pj6655hp9/PHHslp//3fNjz/+WE888YRGjx6tX375RVFRUerRo4ciIyNL+6UHAFwhZu0DAAAAAJO4tA8AAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADDp/wKU3psRrmFq3gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_small_alloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Leanc.lean279844827987523040.010862
1Lean/Data/PersistentArray.lean12783248127838916430.005030
2Init/Data/List/Lemmas.lean32689272326900117390.002261
3Init/Data/BitVec/Lemmas.lean67573064675740519870.001461
4Init/Control/Lawful/Instances.lean17477933174780501170.000669
..................
845Init/Data/Nat/Mod.lean30431293043087-42-0.001380
846Init/Data/Fin/Lemmas.lean3239106432390526-538-0.001661
847Init/Data/Nat/Lemmas.lean2812421628123720-496-0.001764
848Init/Data/Nat/Bitwise/Lemmas.lean1981858619817980-606-0.003058
849Lean/Widget/TaggedText.lean73260067325521-485-0.006621
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Leanc.lean 2798448 2798752 \n", + "1 Lean/Data/PersistentArray.lean 12783248 12783891 \n", + "2 Init/Data/List/Lemmas.lean 32689272 32690011 \n", + "3 Init/Data/BitVec/Lemmas.lean 67573064 67574051 \n", + "4 Init/Control/Lawful/Instances.lean 17477933 17478050 \n", + ".. ... ... ... \n", + "845 Init/Data/Nat/Mod.lean 3043129 3043087 \n", + "846 Init/Data/Fin/Lemmas.lean 32391064 32390526 \n", + "847 Init/Data/Nat/Lemmas.lean 28124216 28123720 \n", + "848 Init/Data/Nat/Bitwise/Lemmas.lean 19818586 19817980 \n", + "849 Lean/Widget/TaggedText.lean 7326006 7325521 \n", + "\n", + " absolute_diff %Decrease \n", + "0 304 0.010862 \n", + "1 643 0.005030 \n", + "2 739 0.002261 \n", + "3 987 0.001461 \n", + "4 117 0.000669 \n", + ".. ... ... \n", + "845 -42 -0.001380 \n", + "846 -538 -0.001661 \n", + "847 -496 -0.001764 \n", + "848 -606 -0.003058 \n", + "849 -485 -0.006621 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_dealloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Init/Prelude.lean1273439127343900.0
1Lean/Meta/Tactic/Simp/BuiltinSimprocs.lean332523325200.0
2Lean/Elab/Tactic/Congr.lean580555805500.0
3Lean/Elab/Tactic/Repeat.lean11677711677700.0
4Lean/Elab/Binders.lean2070703207070300.0
..................
845Lean/DocString.lean894258942500.0
846Init.lean307213072100.0
847Lean/Data/Lsp/Diagnostics.lean38404838404800.0
848Lean/Parser/Basic.lean1241793124179300.0
849Lake/Main.lean837078370700.0
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Init/Prelude.lean 1273439 1273439 \n", + "1 Lean/Meta/Tactic/Simp/BuiltinSimprocs.lean 33252 33252 \n", + "2 Lean/Elab/Tactic/Congr.lean 58055 58055 \n", + "3 Lean/Elab/Tactic/Repeat.lean 116777 116777 \n", + "4 Lean/Elab/Binders.lean 2070703 2070703 \n", + ".. ... ... ... \n", + "845 Lean/DocString.lean 89425 89425 \n", + "846 Init.lean 30721 30721 \n", + "847 Lean/Data/Lsp/Diagnostics.lean 384048 384048 \n", + "848 Lean/Parser/Basic.lean 1241793 1241793 \n", + "849 Lake/Main.lean 83707 83707 \n", + "\n", + " absolute_diff %Decrease \n", + "0 0 0.0 \n", + "1 0 0.0 \n", + "2 0 0.0 \n", + "3 0 0.0 \n", + "4 0 0.0 \n", + ".. ... ... \n", + "845 0 0.0 \n", + "846 0 0.0 \n", + "847 0 0.0 \n", + "848 0 0.0 \n", + "849 0 0.0 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_small_dealloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Leanc.lean241934124196493080.012729
1Lean/Data/PersistentArray.lean12390323123909706470.005222
2Init/Data/List/Lemmas.lean32276637322773777400.002293
3Init/Data/BitVec/Lemmas.lean67092979670939709910.001477
4Init/Control/Lawful/Instances.lean17127580171277011210.000706
..................
845Init/Data/Nat/Mod.lean27155342715496-38-0.001399
846Init/Data/Fin/Lemmas.lean3197309831972564-534-0.001670
847Init/Data/Nat/Lemmas.lean2771270327712211-492-0.001775
848Init/Data/Nat/Bitwise/Lemmas.lean1944127919440677-602-0.003097
849Lean/Widget/TaggedText.lean69418346941353-481-0.006929
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Leanc.lean 2419341 2419649 \n", + "1 Lean/Data/PersistentArray.lean 12390323 12390970 \n", + "2 Init/Data/List/Lemmas.lean 32276637 32277377 \n", + "3 Init/Data/BitVec/Lemmas.lean 67092979 67093970 \n", + "4 Init/Control/Lawful/Instances.lean 17127580 17127701 \n", + ".. ... ... ... \n", + "845 Init/Data/Nat/Mod.lean 2715534 2715496 \n", + "846 Init/Data/Fin/Lemmas.lean 31973098 31972564 \n", + "847 Init/Data/Nat/Lemmas.lean 27712703 27712211 \n", + "848 Init/Data/Nat/Bitwise/Lemmas.lean 19441279 19440677 \n", + "849 Lean/Widget/TaggedText.lean 6941834 6941353 \n", + "\n", + " absolute_diff %Decrease \n", + "0 308 0.012729 \n", + "1 647 0.005222 \n", + "2 740 0.002293 \n", + "3 991 0.001477 \n", + "4 121 0.000706 \n", + ".. ... ... \n", + "845 -38 -0.001399 \n", + "846 -534 -0.001670 \n", + "847 -492 -0.001775 \n", + "848 -602 -0.003097 \n", + "849 -481 -0.006929 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# metrics for which we should compute decreases\n", + "df_corr = pd.DataFrame(df_merged[\"File\"].unique(), columns=[\"File\"]) \n", + "\n", + "for metric in [\"time_elapsed_ms\", \"rss\", \"num_small_alloc\", \"num_dealloc\", \"num_small_dealloc\"]:\n", + " display(HTML(f\"

{metric}

\"))\n", + " df_metric = df_merged[df_merged[\"Metric\"] == metric].copy()\n", + " df_metric[\"absolute_diff\"] = df_merged[\"Value_no_reuse\"] - df_merged[\"Value_reuse\"]\n", + " df_metric[\"%Decrease\"] = (\n", + " 100.0 * (df_merged[\"Value_no_reuse\"] - df_merged[\"Value_reuse\"]) / df_merged[\"Value_no_reuse\"]\n", + " )\n", + " df_metric = df_metric.drop([\"Condition_reuse\", \"Condition_no_reuse\", \"Metric\"], axis=1)\n", + "\n", + " df_kv = df_metric[[\"File\", \"%Decrease\"]].copy()\n", + " df_kv.rename(columns={\"%Decrease\": metric}, inplace=True)\n", + " df_corr = pd.merge(df_corr, df_kv, on=\"File\", how=\"outer\")\n", + " \n", + " # Sorting by maximum decrease\n", + " df_metric_sorted = df_metric.sort_values(by=\"%Decrease\", ascending=False)\n", + " df_metric_sorted.reset_index(drop=True, inplace=True) # changes index to start from zero.\n", + " display(df_metric_sorted)\n", + " plt.figure(figsize=(10, 6))\n", + " plt.hist(df_metric_sorted['%Decrease'], bins=50, color='skyblue', edgecolor='black')\n", + " plt.title(f'%Decrease Distribution for {metric}')\n", + " plt.xlabel('%Decrease')\n", + " plt.ylabel('Frequency')\n", + " plt.grid(axis='y', alpha=0.75)\n", + " plt.show()\n", + "\n", + "corr = df_corr.drop('File', axis=1).corr() # Assuming df_corr is defined and populated\n", + "plt.figure(figsize=(12,8))\n", + "sns.heatmap(corr, cmap=\"Greens\",annot=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7ec6270-c6f5-46b0-b7e6-b28f343851f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Correlation: Time elapsed v/s # allocations (reuse)

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean423384034116
Lean/Elab/Quotation.lean317303926757
Lean/Elab/Do.lean315006328540
Lean/Elab/App.lean279784005911
Lean/Meta/Match/MatchEqs.lean268022950442
.........
Init/Data/String.lean14655644
Init/Data/FloatArray.lean14555502
Lean/Meta/TransparencyMode.lean14363389
Init/Data/Char.lean12053141
Init/Data/Cast.lean10248545
\n", + "

850 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 42338 4034116\n", + "Lean/Elab/Quotation.lean 31730 3926757\n", + "Lean/Elab/Do.lean 31500 6328540\n", + "Lean/Elab/App.lean 27978 4005911\n", + "Lean/Meta/Match/MatchEqs.lean 26802 2950442\n", + "... ... ...\n", + "Init/Data/String.lean 146 55644\n", + "Init/Data/FloatArray.lean 145 55502\n", + "Lean/Meta/TransparencyMode.lean 143 63389\n", + "Init/Data/Char.lean 120 53141\n", + "Init/Data/Cast.lean 102 48545\n", + "\n", + "[850 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

Correlation: Time elapsed v/s # allocations (noreuse)

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean402534034116
Lean/Elab/Do.lean329476328540
Lean/Elab/Quotation.lean279803926757
Lean/Meta/Match/MatchEqs.lean261022950442
Lean/Elab/App.lean259784005911
.........
Lean/Runtime.lean13945677
Lean/Meta/TransparencyMode.lean13563389
Init/Data/Int/Bitwise.lean12861700
Init/Data/Char.lean10653141
Init/Data/Cast.lean9148545
\n", + "

850 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 40253 4034116\n", + "Lean/Elab/Do.lean 32947 6328540\n", + "Lean/Elab/Quotation.lean 27980 3926757\n", + "Lean/Meta/Match/MatchEqs.lean 26102 2950442\n", + "Lean/Elab/App.lean 25978 4005911\n", + "... ... ...\n", + "Lean/Runtime.lean 139 45677\n", + "Lean/Meta/TransparencyMode.lean 135 63389\n", + "Init/Data/Int/Bitwise.lean 128 61700\n", + "Init/Data/Char.lean 106 53141\n", + "Init/Data/Cast.lean 91 48545\n", + "\n", + "[850 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean423384034116
Lean/Elab/Tactic/Omega/Frontend.lean402534034116
Lean/Elab/Do.lean329476328540
Lean/Elab/Quotation.lean317303926757
Lean/Elab/Do.lean315006328540
.........
Init/Data/Int/Bitwise.lean12861700
Init/Data/Char.lean12053141
Init/Data/Char.lean10653141
Init/Data/Cast.lean10248545
Init/Data/Cast.lean9148545
\n", + "

1700 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 42338 4034116\n", + "Lean/Elab/Tactic/Omega/Frontend.lean 40253 4034116\n", + "Lean/Elab/Do.lean 32947 6328540\n", + "Lean/Elab/Quotation.lean 31730 3926757\n", + "Lean/Elab/Do.lean 31500 6328540\n", + "... ... ...\n", + "Init/Data/Int/Bitwise.lean 128 61700\n", + "Init/Data/Char.lean 120 53141\n", + "Init/Data/Char.lean 106 53141\n", + "Init/Data/Cast.lean 102 48545\n", + "Init/Data/Cast.lean 91 48545\n", + "\n", + "[1700 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_full = None\n", + "\n", + "# for each file, grab num alloc and time elapsed.\n", + "variant2df = { \"reuse\" : reuse, \"noreuse\": noreuse }\n", + "for (variant, df) in variant2df.items():\n", + " metric2df = {}\n", + " for metric in [\"time_elapsed_ms\", \"num_alloc\"]:\n", + " out = df[df[\"Metric\"] == metric].copy()\n", + " out = out[[\"File\", \"Value\"]]\n", + " out.rename(columns={\"Value\" : metric}, inplace=True)\n", + " out = out[[\"File\", metric]].set_index(\"File\")\n", + " metric2df[metric] = out\n", + " \n", + " df_metrics_merged = metric2df[\"time_elapsed_ms\"].join(metric2df[\"num_alloc\"])\n", + " df_metrics_merged = df_metrics_merged.sort_values(by='time_elapsed_ms', ascending=False)\n", + "\n", + " display(HTML(f\"

Correlation: Time elapsed v/s # allocations ({variant})

\"))\n", + " display(df_metrics_merged)\n", + " corr = df_metrics_merged.corr() # Assuming df_corr is defined and populated\n", + " plt.figure(figsize=(4,2))\n", + " sns.heatmap(corr, cmap=\"Greens\",annot=True)\n", + " plt.title(f\"Correlation: Time Elapsed v/s # Allocations ({variant})\")\n", + " plt.show()\n", + "\n", + " \n", + " if df_full is None:\n", + " df_full = df_metrics_merged\n", + " else:\n", + " df_full = pd.concat([df_full, df_metrics_merged])\n", + "\n", + "df_full = df_full.sort_values(by='time_elapsed_ms', ascending=False)\n", + "display(df_full)\n", + "corr = df_full.corr() \n", + "plt.figure(figsize=(4,2))\n", + "sns.heatmap(corr, cmap=\"Greens\",annot=True)\n", + "plt.title('Correlation: Time Elapsed v/s # Allocations (Aggregate reuse + no reuse)')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efe6633f-1cd3-4187-99c7-2bdffc6a3f6f", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1-runs/run-2023-03-29---16-31---tcg40/plot-stage3.ipynb b/1-runs/run-2023-03-29---16-31---tcg40/plot-stage3.ipynb new file mode 100644 index 000000000000..1575ede6e980 --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/plot-stage3.ipynb @@ -0,0 +1,1973 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "id": "305ca8eb-b873-4f3e-aa55-9d0adeab7fe9", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from IPython.display import display, HTML\n", + "from datetime import timedelta\n", + "import seaborn as sns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56f9cc1a-76c5-488f-9fa2-a6eade40369d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "noreuse\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileConditionMetricValue
0Init/Prelude.leanreuse_across_ctor_enabledrss151330816
1Init/Prelude.leanreuse_across_ctor_enablednum_alloc1321786
2Init/Prelude.leanreuse_across_ctor_enablednum_small_alloc26198906
3Init/Prelude.leanreuse_across_ctor_enablednum_dealloc1273534
4Init/Prelude.leanreuse_across_ctor_enablednum_small_dealloc25817637
...............
8495Lake/Main.leanreuse_across_ctor_enablednum_segments4
8496Lake/Main.leanreuse_across_ctor_enablednum_pages3715
8497Lake/Main.leanreuse_across_ctor_enablednum_exports0
8498Lake/Main.leanreuse_across_ctor_enablednum_recycled_pages742
8499Lake/Main.leanreuse_across_ctor_enabledtime_elapsed_ms856
\n", + "

8500 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " File Condition Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_enabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_enabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_enabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_enabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_enabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_enabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_enabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_enabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_enabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_enabled time_elapsed_ms \n", + "\n", + " Value \n", + "0 151330816 \n", + "1 1321786 \n", + "2 26198906 \n", + "3 1273534 \n", + "4 25817637 \n", + "... ... \n", + "8495 4 \n", + "8496 3715 \n", + "8497 0 \n", + "8498 742 \n", + "8499 856 \n", + "\n", + "[8500 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reuse\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileConditionMetricValue
0Init/Prelude.leanreuse_across_ctor_disabledrss147406848
1Init/Prelude.leanreuse_across_ctor_disablednum_alloc1321689
2Init/Prelude.leanreuse_across_ctor_disablednum_small_alloc26538112
3Init/Prelude.leanreuse_across_ctor_disablednum_dealloc1273439
4Init/Prelude.leanreuse_across_ctor_disablednum_small_dealloc26156876
...............
8495Lake/Main.leanreuse_across_ctor_disablednum_segments4
8496Lake/Main.leanreuse_across_ctor_disablednum_pages3715
8497Lake/Main.leanreuse_across_ctor_disablednum_exports0
8498Lake/Main.leanreuse_across_ctor_disablednum_recycled_pages743
8499Lake/Main.leanreuse_across_ctor_disabledtime_elapsed_ms903
\n", + "

8500 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " File Condition Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_disabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_disabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_disabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_disabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_disabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_disabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_disabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_disabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_disabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_disabled time_elapsed_ms \n", + "\n", + " Value \n", + "0 147406848 \n", + "1 1321689 \n", + "2 26538112 \n", + "3 1273439 \n", + "4 26156876 \n", + "... ... \n", + "8495 4 \n", + "8496 3715 \n", + "8497 0 \n", + "8498 743 \n", + "8499 903 \n", + "\n", + "[8500 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "noreuse = pd.read_csv('1711699885---29-03-2024---08:11:25.noreuse.stage3.csv',\n", + " names=[\"File\", \"Condition\", \"Metric\", \"Value\"])\n", + "reuse = pd.read_csv('1711702292---29-03-2024---08:51:32.reuse.stage3.csv', \n", + " names=[\"File\", \"Condition\", \"Metric\", \"Value\"])\n", + "print(\"noreuse\"); display(noreuse);\n", + "print(\"reuse\"); display(reuse);" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "2912e2fe-5706-4831-a8b0-77fc8e6a2133", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "time (reuse): 0:35:30.234000 | time (noreuse): 0:40:34.567000\n" + ] + } + ], + "source": [ + "# Filtering the rows where Metric is 'time_elapsed_ms' and then summing the 'Value' column for both DataFrames\n", + "sum_time_elapsed_reuse = reuse[reuse[\"Metric\"] == \"time_elapsed_ms\"][\"Value\"].sum()\n", + "sum_time_elapsed_no_reuse = noreuse[noreuse[\"Metric\"] == \"time_elapsed_ms\"][\"Value\"].sum()\n", + "\n", + "sum_time_elapsed_reuse, sum_time_elapsed_no_reuse\n", + "\n", + "# Ensuring the values are in a compatible format for timedelta\n", + "time_reuse = timedelta(milliseconds=int(sum_time_elapsed_reuse))\n", + "time_no_reuse = timedelta(milliseconds=int(sum_time_elapsed_no_reuse))\n", + "\n", + "# Formatting as hours:minutes:seconds.milliseconds again\n", + "time_format_reuse = str(time_reuse)\n", + "time_format_no_reuse = str(time_no_reuse)\n", + "print(f\"time (reuse): {time_format_reuse} | time (noreuse): {time_format_no_reuse}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a8f14d78-1cf1-4d14-a128-76fa55975629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileCondition_reuseMetricValue_reuseCondition_no_reuseValue_no_reuse
0Init/Prelude.leanreuse_across_ctor_disabledrss147406848reuse_across_ctor_enabled151330816
1Init/Prelude.leanreuse_across_ctor_disablednum_alloc1321689reuse_across_ctor_enabled1321786
2Init/Prelude.leanreuse_across_ctor_disablednum_small_alloc26538112reuse_across_ctor_enabled26198906
3Init/Prelude.leanreuse_across_ctor_disablednum_dealloc1273439reuse_across_ctor_enabled1273534
4Init/Prelude.leanreuse_across_ctor_disablednum_small_dealloc26156876reuse_across_ctor_enabled25817637
.....................
8495Lake/Main.leanreuse_across_ctor_disablednum_segments4reuse_across_ctor_enabled4
8496Lake/Main.leanreuse_across_ctor_disablednum_pages3715reuse_across_ctor_enabled3715
8497Lake/Main.leanreuse_across_ctor_disablednum_exports0reuse_across_ctor_enabled0
8498Lake/Main.leanreuse_across_ctor_disablednum_recycled_pages743reuse_across_ctor_enabled742
8499Lake/Main.leanreuse_across_ctor_disabledtime_elapsed_ms903reuse_across_ctor_enabled856
\n", + "

8500 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " File Condition_reuse Metric \\\n", + "0 Init/Prelude.lean reuse_across_ctor_disabled rss \n", + "1 Init/Prelude.lean reuse_across_ctor_disabled num_alloc \n", + "2 Init/Prelude.lean reuse_across_ctor_disabled num_small_alloc \n", + "3 Init/Prelude.lean reuse_across_ctor_disabled num_dealloc \n", + "4 Init/Prelude.lean reuse_across_ctor_disabled num_small_dealloc \n", + "... ... ... ... \n", + "8495 Lake/Main.lean reuse_across_ctor_disabled num_segments \n", + "8496 Lake/Main.lean reuse_across_ctor_disabled num_pages \n", + "8497 Lake/Main.lean reuse_across_ctor_disabled num_exports \n", + "8498 Lake/Main.lean reuse_across_ctor_disabled num_recycled_pages \n", + "8499 Lake/Main.lean reuse_across_ctor_disabled time_elapsed_ms \n", + "\n", + " Value_reuse Condition_no_reuse Value_no_reuse \n", + "0 147406848 reuse_across_ctor_enabled 151330816 \n", + "1 1321689 reuse_across_ctor_enabled 1321786 \n", + "2 26538112 reuse_across_ctor_enabled 26198906 \n", + "3 1273439 reuse_across_ctor_enabled 1273534 \n", + "4 26156876 reuse_across_ctor_enabled 25817637 \n", + "... ... ... ... \n", + "8495 4 reuse_across_ctor_enabled 4 \n", + "8496 3715 reuse_across_ctor_enabled 3715 \n", + "8497 0 reuse_across_ctor_enabled 0 \n", + "8498 743 reuse_across_ctor_enabled 742 \n", + "8499 903 reuse_across_ctor_enabled 856 \n", + "\n", + "[8500 rows x 6 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_merged = pd.merge(reuse, noreuse, on=[\"File\", \"Metric\"], suffixes=('_reuse', '_no_reuse'))\n", + "display(df_merged)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6c6fc924-32ba-4821-842b-a48c0489c96e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

time_elapsed_ms

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Lean/Server/Utils.lean11262859173360.615600
1Lean/Elab/PreDefinition/Basic.lean28196095327653.748975
2Lean/Elab/CheckTactic.lean17823435165348.122271
3Lake/Config/Glob.lean49692643046.436285
4Lean/Elab/Tactic/RCases.lean957817718814045.941980
..................
845Lean/Elab/Util.lean32282056-1172-57.003891
846Lean/Meta/Tactic/Constructor.lean1511945-566-59.894180
847Lean/Compiler/IR/UnboxResult.lean895533-362-67.917448
848Lean/Compiler/LCNF/MonoTypes.lean25721421-1151-80.999296
849Lean/Compiler/IR.lean1484791-693-87.610619
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Lean/Server/Utils.lean 1126 2859 \n", + "1 Lean/Elab/PreDefinition/Basic.lean 2819 6095 \n", + "2 Lean/Elab/CheckTactic.lean 1782 3435 \n", + "3 Lake/Config/Glob.lean 496 926 \n", + "4 Lean/Elab/Tactic/RCases.lean 9578 17718 \n", + ".. ... ... ... \n", + "845 Lean/Elab/Util.lean 3228 2056 \n", + "846 Lean/Meta/Tactic/Constructor.lean 1511 945 \n", + "847 Lean/Compiler/IR/UnboxResult.lean 895 533 \n", + "848 Lean/Compiler/LCNF/MonoTypes.lean 2572 1421 \n", + "849 Lean/Compiler/IR.lean 1484 791 \n", + "\n", + " absolute_diff %Decrease \n", + "0 1733 60.615600 \n", + "1 3276 53.748975 \n", + "2 1653 48.122271 \n", + "3 430 46.436285 \n", + "4 8140 45.941980 \n", + ".. ... ... \n", + "845 -1172 -57.003891 \n", + "846 -566 -59.894180 \n", + "847 -362 -67.917448 \n", + "848 -1151 -80.999296 \n", + "849 -693 -87.610619 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

rss

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Init/Data/Nat/Bitwise/Basic.lean922583049707520048168964.962025
1Init/Data/Int/Basic.lean9832038410329702449766404.817796
2Init/WF.lean10163814410671718450790404.759346
3Init/Data/Prod.lean854302728948940840591364.535884
4Init/Data/Fin/Basic.lean9641984010087628844564484.417736
..................
845Lean/Elab/PreDefinition/WF.lean33244774433427865618309120.547720
846Lean/Compiler.lean27131494427259289612779520.468813
847Lean/Elab/Tactic.lean37383782437551718416793600.447213
848Lean/PrettyPrinter/Delaborator.lean2277498882287083529584640.419077
849Lean/Elab/PreDefinition.lean33903411234032025612861440.377922
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Init/Data/Nat/Bitwise/Basic.lean 92258304 97075200 \n", + "1 Init/Data/Int/Basic.lean 98320384 103297024 \n", + "2 Init/WF.lean 101638144 106717184 \n", + "3 Init/Data/Prod.lean 85430272 89489408 \n", + "4 Init/Data/Fin/Basic.lean 96419840 100876288 \n", + ".. ... ... ... \n", + "845 Lean/Elab/PreDefinition/WF.lean 332447744 334278656 \n", + "846 Lean/Compiler.lean 271314944 272592896 \n", + "847 Lean/Elab/Tactic.lean 373837824 375517184 \n", + "848 Lean/PrettyPrinter/Delaborator.lean 227749888 228708352 \n", + "849 Lean/Elab/PreDefinition.lean 339034112 340320256 \n", + "\n", + " absolute_diff %Decrease \n", + "0 4816896 4.962025 \n", + "1 4976640 4.817796 \n", + "2 5079040 4.759346 \n", + "3 4059136 4.535884 \n", + "4 4456448 4.417736 \n", + ".. ... ... \n", + "845 1830912 0.547720 \n", + "846 1277952 0.468813 \n", + "847 1679360 0.447213 \n", + "848 958464 0.419077 \n", + "849 1286144 0.377922 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_small_alloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Lean/Data/Format.lean264828428409521926686.781811
1Lean/Meta/Coe.lean11295176120181277229516.015505
2Lean/Meta/Tactic/Rewrite.lean667329569001932268983.288285
3Lean/Data/Lsp/Internal.lean796552382325472670243.243516
4Lean/Server/Rpc/Deriving.lean18330790188238154930252.619156
..................
845Init/SimpLemmas.lean55566995473473-83226-1.520534
846Init/PropLemmas.lean86113608482281-129079-1.521749
847Init/Data/Option/Basic.lean45703214499867-70454-1.565691
848Init/Control/StateCps.lean28645932818149-46444-1.648032
849Init/Control/ExceptCps.lean27785382732272-46266-1.693316
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Lean/Data/Format.lean 2648284 2840952 \n", + "1 Lean/Meta/Coe.lean 11295176 12018127 \n", + "2 Lean/Meta/Tactic/Rewrite.lean 6673295 6900193 \n", + "3 Lean/Data/Lsp/Internal.lean 7965523 8232547 \n", + "4 Lean/Server/Rpc/Deriving.lean 18330790 18823815 \n", + ".. ... ... ... \n", + "845 Init/SimpLemmas.lean 5556699 5473473 \n", + "846 Init/PropLemmas.lean 8611360 8482281 \n", + "847 Init/Data/Option/Basic.lean 4570321 4499867 \n", + "848 Init/Control/StateCps.lean 2864593 2818149 \n", + "849 Init/Control/ExceptCps.lean 2778538 2732272 \n", + "\n", + " absolute_diff %Decrease \n", + "0 192668 6.781811 \n", + "1 722951 6.015505 \n", + "2 226898 3.288285 \n", + "3 267024 3.243516 \n", + "4 493025 2.619156 \n", + ".. ... ... \n", + "845 -83226 -1.520534 \n", + "846 -129079 -1.521749 \n", + "847 -70454 -1.565691 \n", + "848 -46444 -1.648032 \n", + "849 -46266 -1.693316 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_dealloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Lean/Data/Format.lean1099381376902775220.155422
1Lean/Server/Rpc/Deriving.lean7556448486159297110.955616
2Lean/Meta/Tactic/Rewrite.lean258123284497263749.270397
3Lean/Meta/Coe.lean491859537971461128.571466
4Lean/Data/Lsp/Internal.lean366489397898314097.893732
..................
845Lean/Server/CompletionItemData.lean6213162017-114-0.183821
846Lean/Meta/LevelDefEq.lean341207340504-703-0.206459
847Lean/Util/FileSetupInfo.lean4829648192-104-0.215803
848Lean/Data/LOption.lean4200541913-92-0.219502
849Lean/Meta/CtorRecognizer.lean139844138881-963-0.693399
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Lean/Data/Format.lean 109938 137690 \n", + "1 Lean/Server/Rpc/Deriving.lean 755644 848615 \n", + "2 Lean/Meta/Tactic/Rewrite.lean 258123 284497 \n", + "3 Lean/Meta/Coe.lean 491859 537971 \n", + "4 Lean/Data/Lsp/Internal.lean 366489 397898 \n", + ".. ... ... ... \n", + "845 Lean/Server/CompletionItemData.lean 62131 62017 \n", + "846 Lean/Meta/LevelDefEq.lean 341207 340504 \n", + "847 Lean/Util/FileSetupInfo.lean 48296 48192 \n", + "848 Lean/Data/LOption.lean 42005 41913 \n", + "849 Lean/Meta/CtorRecognizer.lean 139844 138881 \n", + "\n", + " absolute_diff %Decrease \n", + "0 27752 20.155422 \n", + "1 92971 10.955616 \n", + "2 26374 9.270397 \n", + "3 46112 8.571466 \n", + "4 31409 7.893732 \n", + ".. ... ... \n", + "845 -114 -0.183821 \n", + "846 -703 -0.206459 \n", + "847 -104 -0.215803 \n", + "848 -92 -0.219502 \n", + "849 -963 -0.693399 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

num_small_dealloc

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FileValue_reuseValue_no_reuseabsolute_diff%Decrease
0Lean/Data/Format.lean230786024918601840007.384042
1Lean/Meta/Coe.lean10805958115138237078656.147958
2Lean/Meta/Tactic/Rewrite.lean618247864012482187703.417615
3Lean/Data/Lsp/Internal.lean755287878116532587753.312679
4Lean/Server/Rpc/Deriving.lean17689432181614474720152.598994
..................
845Init/Data/Option/Instances.lean21363672102505-33862-1.610555
846Init/Data/Option/Basic.lean43194314248977-70454-1.658140
847Init/Coe.lean13957661372438-23328-1.699749
848Init/Control/StateCps.lean25803952533958-46437-1.832588
849Init/Control/ExceptCps.lean24954202449161-46259-1.888769
\n", + "

850 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " File Value_reuse Value_no_reuse \\\n", + "0 Lean/Data/Format.lean 2307860 2491860 \n", + "1 Lean/Meta/Coe.lean 10805958 11513823 \n", + "2 Lean/Meta/Tactic/Rewrite.lean 6182478 6401248 \n", + "3 Lean/Data/Lsp/Internal.lean 7552878 7811653 \n", + "4 Lean/Server/Rpc/Deriving.lean 17689432 18161447 \n", + ".. ... ... ... \n", + "845 Init/Data/Option/Instances.lean 2136367 2102505 \n", + "846 Init/Data/Option/Basic.lean 4319431 4248977 \n", + "847 Init/Coe.lean 1395766 1372438 \n", + "848 Init/Control/StateCps.lean 2580395 2533958 \n", + "849 Init/Control/ExceptCps.lean 2495420 2449161 \n", + "\n", + " absolute_diff %Decrease \n", + "0 184000 7.384042 \n", + "1 707865 6.147958 \n", + "2 218770 3.417615 \n", + "3 258775 3.312679 \n", + "4 472015 2.598994 \n", + ".. ... ... \n", + "845 -33862 -1.610555 \n", + "846 -70454 -1.658140 \n", + "847 -23328 -1.699749 \n", + "848 -46437 -1.832588 \n", + "849 -46259 -1.888769 \n", + "\n", + "[850 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# metrics for which we should compute decreases\n", + "df_corr = pd.DataFrame(df_merged[\"File\"].unique(), columns=[\"File\"]) \n", + "\n", + "for metric in [\"time_elapsed_ms\", \"rss\", \"num_small_alloc\", \"num_dealloc\", \"num_small_dealloc\"]:\n", + " display(HTML(f\"

{metric}

\"))\n", + " df_metric = df_merged[df_merged[\"Metric\"] == metric].copy()\n", + " df_metric[\"absolute_diff\"] = df_merged[\"Value_no_reuse\"] - df_merged[\"Value_reuse\"]\n", + " df_metric[\"%Decrease\"] = (\n", + " 100.0 * (df_merged[\"Value_no_reuse\"] - df_merged[\"Value_reuse\"]) / df_merged[\"Value_no_reuse\"]\n", + " )\n", + " df_metric = df_metric.drop([\"Condition_reuse\", \"Condition_no_reuse\", \"Metric\"], axis=1)\n", + "\n", + " df_kv = df_metric[[\"File\", \"%Decrease\"]].copy()\n", + " df_kv.rename(columns={\"%Decrease\": metric}, inplace=True)\n", + " df_corr = pd.merge(df_corr, df_kv, on=\"File\", how=\"outer\")\n", + " \n", + " # Sorting by maximum decrease\n", + " df_metric_sorted = df_metric.sort_values(by=\"%Decrease\", ascending=False)\n", + " df_metric_sorted.reset_index(drop=True, inplace=True) # changes index to start from zero.\n", + " display(df_metric_sorted)\n", + " plt.figure(figsize=(10, 6))\n", + " plt.hist(df_metric_sorted['%Decrease'], bins=50, color='skyblue', edgecolor='black')\n", + " plt.title(f'%Decrease Distribution for {metric}')\n", + " plt.xlabel('%Decrease')\n", + " plt.ylabel('Frequency')\n", + " plt.grid(axis='y', alpha=0.75)\n", + " plt.show()\n", + "\n", + "corr = df_corr.drop('File', axis=1).corr() # Assuming df_corr is defined and populated\n", + "plt.figure(figsize=(12,8))\n", + "sns.heatmap(corr, cmap=\"Greens\",annot=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e7ec6270-c6f5-46b0-b7e6-b28f343851f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Correlation: Time elapsed v/s # allocations (reuse)

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean402534034116
Lean/Elab/Do.lean329476328540
Lean/Elab/Quotation.lean279803926757
Lean/Meta/Match/MatchEqs.lean261022950442
Lean/Elab/App.lean259784005911
.........
Lean/Runtime.lean13945677
Lean/Meta/TransparencyMode.lean13563389
Init/Data/Int/Bitwise.lean12861700
Init/Data/Char.lean10653141
Init/Data/Cast.lean9148545
\n", + "

850 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 40253 4034116\n", + "Lean/Elab/Do.lean 32947 6328540\n", + "Lean/Elab/Quotation.lean 27980 3926757\n", + "Lean/Meta/Match/MatchEqs.lean 26102 2950442\n", + "Lean/Elab/App.lean 25978 4005911\n", + "... ... ...\n", + "Lean/Runtime.lean 139 45677\n", + "Lean/Meta/TransparencyMode.lean 135 63389\n", + "Init/Data/Int/Bitwise.lean 128 61700\n", + "Init/Data/Char.lean 106 53141\n", + "Init/Data/Cast.lean 91 48545\n", + "\n", + "[850 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

Correlation: Time elapsed v/s # allocations (noreuse)

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean525354060739
Lean/Elab/Quotation.lean345504037147
Lean/Elab/Match.lean345243847469
Lean/Meta/Match/MatchEqs.lean340633015219
Lean/Elab/Do.lean321776328533
.........
Init/Data/ByteArray.lean14355552
Lean/Runtime.lean14145677
Init/Data/FloatArray.lean14055502
Init/Data/Cast.lean13048545
Init/Data/Char.lean11753141
\n", + "

850 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 52535 4060739\n", + "Lean/Elab/Quotation.lean 34550 4037147\n", + "Lean/Elab/Match.lean 34524 3847469\n", + "Lean/Meta/Match/MatchEqs.lean 34063 3015219\n", + "Lean/Elab/Do.lean 32177 6328533\n", + "... ... ...\n", + "Init/Data/ByteArray.lean 143 55552\n", + "Lean/Runtime.lean 141 45677\n", + "Init/Data/FloatArray.lean 140 55502\n", + "Init/Data/Cast.lean 130 48545\n", + "Init/Data/Char.lean 117 53141\n", + "\n", + "[850 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
time_elapsed_msnum_alloc
File
Lean/Elab/Tactic/Omega/Frontend.lean525354060739
Lean/Elab/Tactic/Omega/Frontend.lean402534034116
Lean/Elab/Quotation.lean345504037147
Lean/Elab/Match.lean345243847469
Lean/Meta/Match/MatchEqs.lean340633015219
.........
Init/Data/Cast.lean13048545
Init/Data/Int/Bitwise.lean12861700
Init/Data/Char.lean11753141
Init/Data/Char.lean10653141
Init/Data/Cast.lean9148545
\n", + "

1700 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " time_elapsed_ms num_alloc\n", + "File \n", + "Lean/Elab/Tactic/Omega/Frontend.lean 52535 4060739\n", + "Lean/Elab/Tactic/Omega/Frontend.lean 40253 4034116\n", + "Lean/Elab/Quotation.lean 34550 4037147\n", + "Lean/Elab/Match.lean 34524 3847469\n", + "Lean/Meta/Match/MatchEqs.lean 34063 3015219\n", + "... ... ...\n", + "Init/Data/Cast.lean 130 48545\n", + "Init/Data/Int/Bitwise.lean 128 61700\n", + "Init/Data/Char.lean 117 53141\n", + "Init/Data/Char.lean 106 53141\n", + "Init/Data/Cast.lean 91 48545\n", + "\n", + "[1700 rows x 2 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_full = None\n", + "\n", + "# for each file, grab num alloc and time elapsed.\n", + "variant2df = { \"reuse\" : reuse, \"noreuse\": noreuse }\n", + "for (variant, df) in variant2df.items():\n", + " metric2df = {}\n", + " for metric in [\"time_elapsed_ms\", \"num_alloc\"]:\n", + " out = df[df[\"Metric\"] == metric].copy()\n", + " out = out[[\"File\", \"Value\"]]\n", + " out.rename(columns={\"Value\" : metric}, inplace=True)\n", + " out = out[[\"File\", metric]].set_index(\"File\")\n", + " metric2df[metric] = out\n", + " \n", + " df_metrics_merged = metric2df[\"time_elapsed_ms\"].join(metric2df[\"num_alloc\"])\n", + " df_metrics_merged = df_metrics_merged.sort_values(by='time_elapsed_ms', ascending=False)\n", + "\n", + " display(HTML(f\"

Correlation: Time elapsed v/s # allocations ({variant})

\"))\n", + " display(df_metrics_merged)\n", + " corr = df_metrics_merged.corr() # Assuming df_corr is defined and populated\n", + " plt.figure(figsize=(4,2))\n", + " sns.heatmap(corr, cmap=\"Greens\",annot=True)\n", + " plt.title(f\"Correlation: Time Elapsed v/s # Allocations ({variant})\")\n", + " plt.show()\n", + "\n", + " \n", + " if df_full is None:\n", + " df_full = df_metrics_merged\n", + " else:\n", + " df_full = pd.concat([df_full, df_metrics_merged])\n", + "\n", + "df_full = df_full.sort_values(by='time_elapsed_ms', ascending=False)\n", + "display(df_full)\n", + "corr = df_full.corr() \n", + "plt.figure(figsize=(4,2))\n", + "sns.heatmap(corr, cmap=\"Greens\",annot=True)\n", + "plt.title('Correlation: Time Elapsed v/s # Allocations (Aggregate reuse + no reuse)')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efe6633f-1cd3-4187-99c7-2bdffc6a3f6f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c2141e2c-d2b6-4557-8793-a8bfa9bb5944", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ee06416-6477-4bd2-a10c-3671b1e27105", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/1-runs/run-2023-03-29---16-31---tcg40/run-bash-worker.sh b/1-runs/run-2023-03-29---16-31---tcg40/run-bash-worker.sh new file mode 100644 index 000000000000..4e54fb9db27e --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/run-bash-worker.sh @@ -0,0 +1,63 @@ +#!/usr/bin/env bash +set -o xtrace +set -e + +EXPERIMENTDIR=$(pwd) +echo "pwd: $EXPERIMENTDIR" +DATE=$(date) +echo "date: $DATE" +MACHINE=$(uname -a) +echo "machine: $MACHINE" +echo "git status: $(git status --short)" +echo "git commit: $(git rev-parse HEAD)" +ROOT=$(git rev-parse --show-toplevel) +echo "root folder: $ROOT" +echo "out folder: $OUTFOLDER" + +if [ "$(uname -s)" = "Darwin" ]; then + TIME="gtime" +else + TIME="command time" +fi +echo "time: $TIME" +$TIME -v echo "time" + + +rm -rf $ROOT/build || true +rm -rf $ROOT/build/noreuse || true +mkdir -p $ROOT/build/noreuse +cd $ROOT/build/noreuse + +# == NO REUSE == + +echo "@@@ NOREUSE BUILD @@@" + +CSVNAME=$(date +'%s---%d-%m-%Y---%H:%M:%S') +echo "CSV name is: $CSVNAME" +echo "output file is: OUTFOLDER/$CSVNAME" + +KINDS=("noreuse" "reuse") +REUSE_ENABLED=(0 1) +REUSE_FILES=("$EXPERIMENTDIR/ResetReuse.baseline.lean.in" "$EXPERIMENTDIR/ResetReuse.research.lean.in") + +for i in {0..1}; do + BUILD_DIR="$ROOT/build/${KINDS[i]}" + mkdir -p $BUILD_DIR + cd $BUILD_DIR + cp "${REUSE_FILES[i]}" "$ROOT/src/Lean/Compiler/IR/ResetReuse.lean" + + # output log name from stage3 build. + CSVNAME="${KINDS[i]}.stage3.csv" + + PROFILE_FILE=$EXPERIMENTDIR/$CSVNAME + cmake ../../ \ + -DCCACHE=OFF \ + -DRUNTIME_STATS=ON \ + -DLEAN_RESEARCH_IS_REUSE_ACROSS_CONSTRUCTORS_ENABLED=${REUSE_ENABLED[i]} \ + -DLEAN_RESEARCH_COMPILER_PROFILE_CSV_PATH=$PROFILE_FILE + + make -j10 stage2 + touch $EXPERIMENTDIR/$CSVNAME && echo "" > $EXPERIMENTDIR/$CSVNAME + $TIME -v make -j10 stage3 2>&1 | tee "$EXPERIMENTDIR/time-${KINDS[i]}-stage3.txt" + curl -d "Done[${KINDS[i]}]. run:$EXPERIMENTDIR. machine:$(uname -a)." ntfy.sh/xISSztEV8EoOchM2 +done; diff --git a/1-runs/run-2023-03-29---16-31---tcg40/run-bash-wrapper.sh b/1-runs/run-2023-03-29---16-31---tcg40/run-bash-wrapper.sh new file mode 100755 index 000000000000..8632a57617ae --- /dev/null +++ b/1-runs/run-2023-03-29---16-31---tcg40/run-bash-wrapper.sh @@ -0,0 +1,3 @@ +#!/usr/bin/env bash +bash run-bash-worker.sh 2>&1 | tee log.txt +