Merge branch '2024W' of https://github.com/JuliaTeachingCTU/Scientific-Programming-in-Julia into 2024W

TheMrGhostman · TheMrGhostman · commit 8cbe1994f227 · 2024-10-25T09:20:18.000+02:00
diff --git a/docs/src/lecture_05/lab.md b/docs/src/lecture_05/lab.md
@@ -56,46 +56,6 @@ We are getting a little ahead of ourselves in this lab, as understanding of thes
     - run the function with the argument once before running `@time` or use `@btime` if you have `BenchmarkTools` readily available in your environment
     - To see some measurable difference with this simple function, a longer vector of coefficients may be needed.
 
-!!! details
-    ```@repl lab05_polynomial
-    function polynomial_stable(a, x)
-        accumulator = zero(x)
-        for i in length(a):-1:1
-            accumulator += x^(i-1) * a[i]
-        end
-        accumulator
-    end
-    ```
-
-    ```@repl lab05_polynomial
-    @code_warntype polynomial_stable(a, x)  # type stable
-    @code_warntype polynomial_stable(a, xf) # type stable
-    ```
-
-    ```@repl lab05_polynomial
-    polynomial(a, xf) #hide
-    polynomial_stable(a, xf) #hide
-    @time polynomial(a, xf)
-    @time polynomial_stable(a, xf)
-    ```
-
-    Only really visible when evaluating multiple times.
-    ```julia
-    julia> using BenchmarkTools
-
-    julia> @btime polynomial($a, $xf)
-      31.806 ns (0 allocations: 0 bytes)
-    128.0
-
-    julia> @btime polynomial_stable($a, $xf)
-      28.522 ns (0 allocations: 0 bytes)
-    128.0
-    ```
-    Difference only a few nanoseconds.
-
-
-    *Note*: Recalling homework from lab 1. Adding `zero` also extends this function to the case of `x` being a matrix, see `?` menu.
-
 
 Code stability issues are something unique to Julia, as its JIT compilation allows it to produce code that contains boxed variables, whose type can be inferred during runtime. This is one of the reasons why interpreted languages are slow to run but fast to type. Julia's way of solving it is based around compiling functions for specific arguments, however in order for this to work without the interpreter, the compiler has to be able to infer the types.
 
@@ -201,22 +161,6 @@ In order to get more of a visual feel for profiling, there are packages that all
     Let's compare this with the type unstable situation.
 
 
-!!! details
-    First let's define the function that allows us to run the `polynomial` multiple times.
-    ```@repl lab05_polynomial
-    function run_polynomial(a, x, n) 
-        for _ in 1:n
-            polynomial(a, x)
-        end
-    end
-    ```
-
-    ```julia
-    @profview run_polynomial(a, xf, Int(1e5)) # clears the profile for us
-    ```
-    ![poly_unstable](poly_unstable.png)
-
-
 Other options for viewing profiler outputs
 - [ProfileView](https://github.com/timholy/ProfileView.jl) - close cousin of `ProfileSVG`, spawns GTK window with interactive FlameGraph
 - [VSCode](https://www.julia-vscode.org/docs/stable/release-notes/v0_17/#Profile-viewing-support-1) - always imported `@profview` macro, flamegraphs (js extension required), filtering, one click access to source code 
@@ -235,47 +179,6 @@ We have noticed that no matter if the function is type stable or unstable the ma
     [^1]: Explanation of the Horner schema can be found on [https://en.wikipedia.org/wiki/Horner%27s\_method](https://en.wikipedia.org/wiki/Horner%27s_method).
 
 
-!!! details
-    ```julia
-    function polynomial(a, x)
-        accumulator = a[end] * one(x)
-        for i in length(a)-1:-1:1
-            accumulator = accumulator * x + a[i]
-        end
-        accumulator  
-    end
-    ```
-
-    Speed up:
-    - 49ns -> 8ns ~ 6x on integer valued input 
-    - 59ns -> 8ns ~ 7x on real valued input
-
-    ```
-    julia> @btime polynomial($a, $x)
-      8.008 ns (0 allocations: 0 bytes)
-    97818
-
-    julia> @btime polynomial_stable($a, $x)
-      49.173 ns (0 allocations: 0 bytes)
-    97818
-
-    julia> @btime polynomial($a, $xf)
-      8.008 ns (0 allocations: 0 bytes)
-    97818.0
-
-    julia> @btime polynomial_stable($a, $xf)
-      58.773 ns (0 allocations: 0 bytes)
-    97818.0
-    ```
-    These numbers will be different on different HW.
-
-    **BONUS**: The profile trace does not even contain the calling of mathematical operators and is mainly dominated by the iteration utilities. In this case we had to increase the number of runs to `1e6` to get some meaningful trace.
-
-    ```julia
-    @profview run_polynomial(a, xf, Int(1e6))
-    ```
-    ![poly_horner](poly_horner.png)
-
 ---
 
 ### Where to find source code?
@@ -409,42 +312,6 @@ nothing # hide
     ![lab04-ecosystem](ecosystems/lab04-worldstep.png)
 
 
-!!! details
-    Red bars indicate type instabilities. The bars stacked on top of them are high,
-    narrow and not filling the whole width, indicating that the problem is pretty
-    serious. In our case the worst offender is the `filter` method inside
-    `find_food` and `find_mate` functions.
-    In both cases the bars on top of it are narrow and not the full with, meaning
-    that not that much time has been really spend working, but instead inferring the
-    types in the function itself during runtime.
-
-    As a reminder, this is the `find_food` function:
-    ```julia
-    # original
-    function find_food(a::Animal, w::World)
-        as = filter(x -> eats(a,x), w.agents |> values |> collect)
-        isempty(as) ? nothing : sample(as)
-    end
-    ```
-    Just from looking at that piece of code its not obvious what is the problem,
-    however the red color indicates that the code may be type unstable. Let's see if
-    that is the case by evaluation the function with some isolated inputs.
-
-    ```julia
-    using InteractiveUtils # hide
-    w = Wolf(4000)
-    find_food(w, world)
-    @code_warntype find_food(w, world)
-    ```
-
-    Indeed we see that the return type is not inferred precisely but ends up being
-    just the `Union{Nothing, Agent}`, this is better than straight out `Any`, which
-    is the union of all types but still, julia has to do dynamic dispatch here, which is slow.
-
-    The underlying issue here is that we are working array of type `Vector{Agent}`,
-    where `Agent` is abstract, which does not allow the compiler to specialize the
-    code for the loop body.
-
 ## Different `Ecosystem.jl` versions
 
 In order to fix the type instability in the `Vector{Agent}` we somehow have to
@@ -478,50 +345,6 @@ end
 
     Which differences can you observe? Why is one version faster than the other?
 
-!!! details
-    It turns out that with this simple change we can already gain a little bit of speed:
-
-    |                                           | `find_food` | `reproduce!` |
-    |-------------------------------------------|-------------|--------------|
-    |`Animal{A}`   & `Dict{Int,Agent}`          | 43.917 μs   | 439.666 μs   |
-    |`Animal{A}`   & `Dict{Int,Union{...}}`     | 12.208 μs   | 340.041 μs   |
-
-    We are gaining performance here because for small `Union`s of types the julia
-    compiler can precompile the multiple available code branches.  If we have just a
-    `Dict` of `Agent`s this is not possible.
-
-    This however, does not yet fix our type instabilities completely. We are still working with `Union`s of types
-    which we can see again using `@code_warntype`:
-    ```@setup uniondict
-    include("ecosystems/animal_S_world_DictUnion/Ecosystem.jl")
-
-    function make_counter()
-        n = 0
-        counter() = n += 1
-    end
-
-    function create_world()
-        n_grass  = 1_000
-        n_sheep  = 40
-        n_wolves = 4
-
-        nextid = make_counter()
-
-        World(vcat(
-            [Grass(nextid()) for _ in 1:n_grass],
-            [Sheep(nextid()) for _ in 1:n_sheep],
-            [Wolf(nextid()) for _ in 1:n_wolves],
-        ))
-    end
-    world = create_world();
-    ```
-    ```@example uniondict
-    using InteractiveUtils # hide
-    w = Wolf(4000)
-    find_food(w, world)
-    @code_warntype find_food(w, world)
-    ```
-
 --- 
 
 Julia still has to perform runtime dispatch on the small `Union` of `Agent`s that is in our dictionary.
diff --git a/docs/src/lecture_05/lecture.md b/docs/src/lecture_05/lecture.md
@@ -228,7 +228,7 @@ BenchmarkTools.Trial: 11 samples with 1 evaluation.
 
 We can see that we have approximately 3-fold improvement.
 
-Let's profile again, not forgetting to use `Profile.clear()` to clear already stored probes.
+Let's profile again.
 ```
 prof = @profview g2(p,n)
 ProfileCanvas.html_file("profiles/profile2.html", prof)
