new benchmarks (#53)

Author: guilhermebodin

bench/benchmark_estimate.jl

@@ -2,6 +2,28 @@ using ScoreDrivenModels, Distributions, BenchmarkTools, Random, Test
 
 include("test/utils.jl")
 
+scaling = 0.0
+ω = [0.1, 0.1]
+A = [0.2 0; 0 0.2]
+B = [0.2 0; 0 0.2]
+simulation = simulate_GAS_1_1(Beta, scaling, ω, A, B, 1)
+gas = GAS(1, 1, Beta, scaling)
+gas.ω = ω
+gas.A[1] = A
+gas.B[1] = B
+@benchmark score_driven_recursion($gas, $simulation)
+# BenchmarkTools.Trial:
+#   memory estimate:  235.38 KiB
+#   allocs estimate:  18
+#   --------------
+#   minimum time:     999.374 μs (0.00% GC)
+#   median time:      1.006 ms (0.00% GC)
+#   mean time:        1.050 ms (1.74% GC)
+#   maximum time:     55.351 ms (98.06% GC)
+#   --------------
+#   samples:          4756
+#   evals/sample:     1
+
 scaling = 0.0
 ω = [0.1, 0.1]
 A = [0.2 0; 0 0.2]
@@ -17,13 +39,13 @@ num_seeds = 3
     fit!(gas, $simulation; verbose = $verbose, opt_method = opt_method)
 end
 # BenchmarkTools.Trial:
-#   memory estimate:  466.69 MiB
-#   allocs estimate:  40237
+#   memory estimate:  516.71 MiB
+#   allocs estimate:  50679
 #   --------------
-#   minimum time:     2.553 s (0.57% GC)
-#   median time:      2.655 s (0.59% GC)
-#   mean time:        2.655 s (0.59% GC)
-#   maximum time:     2.756 s (0.60% GC)
+#   minimum time:     2.857 s (2.91% GC)
+#   median time:      2.927 s (1.71% GC)
+#   mean time:        2.927 s (1.71% GC)
+#   maximum time:     2.997 s (0.57% GC)
 #   --------------
 #   samples:          2
 #   evals/sample:     1
@@ -43,13 +65,13 @@ num_seeds = 3
     fit!(gas, $simulation; verbose = $verbose, opt_method = opt_method)
 end
 # BenchmarkTools.Trial:
-#   memory estimate:  353.02 MiB
-#   allocs estimate:  30598
+#   memory estimate:  386.33 MiB
+#   allocs estimate:  38084
 #   --------------
-#   minimum time:     1.008 s (1.41% GC)
-#   median time:      1.265 s (1.36% GC)
-#   mean time:        1.281 s (1.35% GC)
-#   maximum time:     1.587 s (1.28% GC)
+#   minimum time:     1.014 s (1.15% GC)
+#   median time:      1.358 s (1.13% GC)
+#   mean time:        1.341 s (2.56% GC)
+#   maximum time:     1.632 s (1.12% GC)
 #   --------------
 #   samples:          4
 #   evals/sample:     1
@@ -62,15 +84,15 @@ scaling = 0.5
     fit!(gas, $simulation; verbose = $verbose, opt_method = opt_method)
 end
 # BenchmarkTools.Trial:
-#   memory estimate:  8.26 GiB
-#   allocs estimate:  159942290
+#   memory estimate:  1.94 GiB
+#   allocs estimate:  54273958
 #   --------------
-#   minimum time:     7.361 s (18.19% GC)
-#   median time:      7.361 s (18.19% GC)
-#   mean time:        7.361 s (18.19% GC)
-#   maximum time:     7.361 s (18.19% GC)
+#   minimum time:     4.936 s (3.77% GC)
+#   median time:      6.007 s (4.06% GC)
+#   mean time:        6.007 s (4.06% GC)
+#   maximum time:     7.078 s (4.26% GC)
 #   --------------
-#   samples:          1
+#   samples:          2
 #   evals/sample:     1
 
 scaling = 1.0
@@ -80,13 +102,13 @@ scaling = 1.0
     fit!(gas, $simulation; verbose = $verbose, opt_method = opt_method)
 end
 # BenchmarkTools.Trial:
-#   memory estimate:  666.69 MiB
-#   allocs estimate:  8744603
+#   memory estimate:  750.17 MiB
+#   allocs estimate:  9849254
 #   --------------
-#   minimum time:     2.908 s (2.08% GC)
-#   median time:      3.382 s (2.07% GC)
-#   mean time:        3.382 s (2.07% GC)
-#   maximum time:     3.855 s (2.07% GC)
+#   minimum time:     3.217 s (1.91% GC)
+#   median time:      3.320 s (1.91% GC)
+#   mean time:        3.320 s (1.91% GC)
+#   maximum time:     3.424 s (1.92% GC)
 #   --------------
 #   samples:          2
 #   evals/sample:     1

src/gas/gas.jl

@@ -79,20 +79,20 @@ function fill_psitilde!(gas::GAS, psitilde::Vector{T}, unknowns::UnknownsGAS) wh
     # fill ω
     for i in unknowns.ω
         offset += 1
-        gas.ω[i] = psitilde[offset]
+        @inbounds gas.ω[i] = psitilde[offset]
     end
     # fill A
     for (k, v) in unknowns.A
         for i in v
             offset += 1
-            gas.A[k][i] = psitilde[offset]
+            @inbounds gas.A[k][i] = psitilde[offset]
         end
     end
     # fill B
     for (k, v) in unknowns.B
         for i in v
             offset += 1
-            gas.B[k][i] = psitilde[offset]
+            @inbounds gas.B[k][i] = psitilde[offset]
         end
     end
     return 

src/gas/univariate_score_driven_recursion.jl

@@ -20,7 +20,7 @@ function score_driven_recursion(gas::GAS{D, T}, observations::Vector{T};
     biggest_lag = number_of_lags(gas)
 
     # initial_values  
-    for i in 1:biggest_lag
+    @inbounds for i in 1:biggest_lag
         for p in 1:n_params
             param[i, p] = initial_params[i, p]
         end
@@ -30,7 +30,7 @@ function score_driven_recursion(gas::GAS{D, T}, observations::Vector{T};
 
     update_param_tilde!(param_tilde, gas.ω, gas.A, gas.B, scores_tilde, biggest_lag)
 
-    for i in biggest_lag + 1:n
+    @inbounds for i in biggest_lag + 1:n
         univariate_score_driven_update!(param, param_tilde, scores_tilde, observations[i], aux, gas, i)
     end
     update_param!(param, param_tilde, D, n + 1)
@@ -59,7 +59,7 @@ function simulate_recursion(gas::GAS{D, T}, n::Int;
     # initial_values  
     for t in 1:biggest_lag
         for p in 1:n_params
-            param[t, p] = initial_params[t, p]
+            @inbounds param[t, p] = initial_params[t, p]
         end
         link!(param_tilde, D, param, t)
         # Sample
@@ -111,16 +111,16 @@ end
 function update_param_tilde!(param_tilde::Matrix{T}, ω::Vector{T}, A::Dict{Int, Matrix{T}}, 
                              B::Dict{Int, Matrix{T}}, scores_tilde::Matrix{T}, i::Int) where T
     for p in eachindex(ω)
-        param_tilde[i + 1, p] = ω[p]
+        @inbounds param_tilde[i + 1, p] = ω[p]
     end
     for (lag, mat) in A
         for p in axes(mat, 1)
-            param_tilde[i + 1, p] += mat[p, p] * scores_tilde[i - lag + 1, p]
+            @inbounds param_tilde[i + 1, p] += mat[p, p] * scores_tilde[i - lag + 1, p]
         end
     end
     for (lag, mat) in B
         for p in axes(mat, 1)
-            param_tilde[i + 1, p] += mat[p, p] * param_tilde[i - lag + 1, p]
+            @inbounds param_tilde[i + 1, p] += mat[p, p] * param_tilde[i - lag + 1, p]
         end
     end
     return