Merge pull request JuliaControl#8 from JuliaControl/alloccheck

add static analysis for allocations

Author: baggepinnen

.github/workflows/CI.yml

@@ -18,7 +18,7 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1.7'
+          - '1'
         os:
           - ubuntu-latest
         arch:

Project.toml

@@ -7,9 +7,10 @@ version = "0.1.3"
 julia = "1.7"
 
 [extras]
-ControlSystems = "a6e380b2-a6ca-5380-bf3e-84a91bcd477e"
+AllocCheck = "9b6a8646-10ed-4001-bbdc-1d2f46dfbb1a"
+ControlSystemsBase = "aaaaaaaa-a6ca-5380-bf3e-84a91bcd477e"
 FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "ControlSystems", "FixedPointNumbers"]
+test = ["AllocCheck", "Test", "ControlSystemsBase", "FixedPointNumbers"]

README.md

@@ -137,8 +137,8 @@ K  = 1    # Proportional gain
 Ti = 1    # Integral time
 Td = 1    # Derivative time
 Ts = 0.01 # sample time
-P   = ss(tf(1, [1, 1])) # Process to be controlled, in continuous time
-A,B,C = ssdata(P)       # Extract the system matrices
+P  = ss(tf(1, [1, 1]))    # Process to be controlled, in continuous time
+A,B,C = ssdata(P)         # Extract the system matrices
 p = (; A, B, C, r=0, d=1) # reference = 0, disturbance = 1
 
 pid = DiscretePID(; K, Ts, Ti, Td)
@@ -168,14 +168,15 @@ Xm = reduce(hcat, X)' # Reduce to from vector of vectors to matrix
 Ym = Xm*P.C'          # Compute the output (same as state in this simple case)
 Um = reduce(hcat, U)'
 
-plot(t, [Ym Um], layout=(2,1), ylabel = ["y" "u"])
+plot(t, [Ym Um], layout=(2,1), ylabel = ["y" "u"], legend=false)
 ```
 Once again, the output looks identical and is omitted here.
 
 ## Details
 - The derivative term only acts on the (filtered) measurement and not the command signal. It is thus safe to pass step changes in the reference to the controller. The parameter $b$ can further be set to zero to avoid step changes in the control signal in response to step changes in the reference.
 - Bumpless transfer when updating `K` is realized by updating the state `I`. See the docs for `set_K!` for more details.
 - The total control signal $u(t)$ (PID + feed-forward) is limited by the integral anti-windup.
+- When used with input arguments of standard types, such as `Float64` or `Float32`, the controller is guaranteed not to allocate any memory or contain any dynamic dispatches. This analysis is carried out in the tests, and is performed using [AllocCheck.jl](https://github.com/JuliaLang/AllocCheck.jl).
 
 ## Simulation of fixed-point arithmetic
 If the controller is ultimately to be implemented on a platform without floating-point hardware, you can simulate how it will behave with fixed-point arithmetics using the `FixedPointNumbers` package. The following example modifies the first example above and shows how to simulate the controller using 16-bit fixed-point arithmetics with 10 bits for the fractional part:

src/DiscretePIDs.jl

@@ -2,23 +2,38 @@ module DiscretePIDs
 
 export DiscretePID, calculate_control!, set_K!, set_Td!, set_Ti!
 
+"""
+    DiscretePID{T}
+"""
 mutable struct DiscretePID{T} <: Function
-    K::T # Proportional gain
-    Ti::T # Integral time
-    Td::T # Derivative time
-    Tt::T # Reset time
-    N::T # Maximum derivative gain
-    b::T # Fraction of set point in prop. term
-    umin::T # Low output limit
-    umax::T # High output limit
-    Ts::T # Sampling period
+    "Proportional gain"
+    K::T 
+    "Integral time"
+    Ti::T 
+    "Derivative time"
+    Td::T 
+    "Reset time"
+    Tt::T 
+    "Maximum derivative gain"
+    N::T 
+    "Fraction of set point in prop. term"
+    b::T 
+    "Low output limit"
+    umin::T 
+    "High output limit"
+    umax::T 
+    "Sampling period"
+    Ts::T 
     bi::T
     ar::T
     bd::T
     ad::T
-    I::T # Integral state
-    D::T # Derivative state
-    yold::T # Last measurement signal
+    "Integral state"
+    I::T 
+    "Derivative state"
+    D::T 
+    "Last measurement signal"
+    yold::T 
 end
 
 """
@@ -38,6 +53,7 @@ Call the controller like this
 ```julia
 u = pid(r, y, uff) # uff is optional
 u = calculate_control!(pid, r, y, uff) # Equivalent to the above
+```
 
 # Arguments:
 - `K`: Proportional gain

test/runtests.jl

@@ -1,15 +1,39 @@
 using DiscretePIDs
 using Test
-using ControlSystems
+using ControlSystemsBase
+using AllocCheck
 
 @testset "DiscretePIDs.jl" begin
+
+# Allocation tests
+@testset "allocation" begin
+    @info "Testing allocation"
+    for T0 = (Float64, Float32)
+        for T1 = (Float64, Float32, Int)
+            for T2 = (Float64, Float32, Int)
+                for T3 = (Float64, Float32, Int, Nothing)
+                    @test isempty(AllocCheck.check_allocs(calculate_control!, (DiscretePID{T0}, T1, T2)))
+                    @test isempty(AllocCheck.check_allocs(calculate_control!, (DiscretePID{T0}, T1, T2, T3)))
+                end
+            end
+        end
+    end
+end
 
 
 K = 1
 Ts = 0.01
 
 pid = DiscretePID(; K, Ts)
 display(pid)
+for T1 = (Float64, Float32, Int)
+    for T2 = (Float64, Float32, Int)
+        for T3 = (Float64, Float32, Int, Nothing)
+            @test isempty(AllocCheck.check_allocs(pid, (T1, T2)))
+            @test isempty(AllocCheck.check_allocs(pid, (T1, T2, T3)))
+        end
+    end
+end
 
 ctrl = function(x,t)
     y = (P.C*x)[]
@@ -20,7 +44,7 @@ end
 P = c2d(ss(tf(1, [1, 1])), Ts)
 
 ## P control
-C = c2d(ControlSystems.pid(K, 0), Ts)
+C = c2d(ControlSystemsBase.pid(K, 0), Ts)
 res = step(feedback(P*C), 3)
 res2 = lsim(P, ctrl, 3)
 
@@ -31,15 +55,15 @@ res2 = lsim(P, ctrl, 3)
 ## PI control
 Ti = 1
 pid = DiscretePID(; K, Ts, Ti)
-C = c2d(ControlSystems.pid(K, Ti), Ts)
+C = c2d(ControlSystemsBase.pid(K, Ti), Ts)
 res = step(feedback(P*C), 3)
 res2 = lsim(P, ctrl, 3)
 
 # plot([res, res2])
 @test res.y ≈ res2.y rtol=0.01
 
 ## PID control
-# Here we simulate a load disturbance instead since the discrete PID does not differentiate r, while the ControlSystems.pid does.
+# Here we simulate a load disturbance instead since the discrete PID does not differentiate r, while the ControlSystemsBase.pid does.
 Tf = 10
 Ti = 1
 Td = 1
@@ -89,7 +113,7 @@ ctrl = function(x,t)
     u = pid(r, y)
 end
 
-C = c2d(ControlSystems.pid(K, Ti), Ts)
+C = c2d(ControlSystemsBase.pid(K, Ti), Ts)
 res = step(feedback(P*C), Tf)
 res2 = lsim(P, ctrl, Tf)
 
@@ -98,7 +122,7 @@ res2 = lsim(P, ctrl, Tf)
 
 
 ## PID control with bumpless transfer
-# Here we simulate a load disturbance instead since the discrete PID does not differentiate r, while the ControlSystems.pid does.
+# Here we simulate a load disturbance instead since the discrete PID does not differentiate r, while the ControlSystemsBase.pid does.
 Tf = 10
 Ti = 1
 Td = 1
@@ -138,7 +162,7 @@ ctrl = function(x,t)
     r = 1
     u = pid(r, y)
 end
-C = c2d(ControlSystems.pid(K, 0), Ts)
+C = c2d(ControlSystemsBase.pid(K, 0), Ts)
 res = step(feedback(P*C), 3)
 res2 = lsim(P, ctrl, 3)