Hello,

I am considering these 3 ODEs

```
function minimalModelNonAlloc!(D, u, p, t)
M = p
v = 0.2 .* ones(length(u))
D .= v - M * u.^3 - u.^5
return nothing
end
function minimalModelAlloc(u, p, t)
M = p
v = 0.2 .* ones(length(u))
return v - M * u.^3 - u.^5
end
function minimalModelAllocContainer(u, p, t)
@unpack M = p
v = 0.2 .* ones(length(u))
return v - M * u.^3 - u.^5
end
```

and compare their performance when optimising some loss function via `M`

(see below) for different dimensions of `u`

. In the last model I use a `ComponentArray`

for `p`

as a container.

I find following result:

(There is also a similar result for the allocate memory, but I am only allowed to upload one file )

Okay, unsurprisingly, the containerised version fairs worse than `minimalModelAlloc`

which I expected, since the container adds some overhead. But the magnitude of it surprises me nevertheless. However, the biggest surprise is, that the non allocating version is by far the worst. We are talking 1.9 seconds per run vs ~ 80 ms for `minimalModelAlloc`

at `length(u)`

. These results are completely unintuitve for me. Could anyone please tell me what part of the equation I am missing

The code for benchmarking I use reads

```
dims = [2, 5, 10, 20, 50, 100, 200]
memories = []
times = []
for dim ∈ dims
@info "Processing $dim dimensions"
function lossBenchmark(p)
sol = solve(prob, Tsit5(), p = p)
loss = sum(abs2, sol[end])
return loss, sol
end
u0 = zeros(dim)
# pTest = ones(dim, dim)
pTest = ComponentArray(M = ones(dim, dim))
prob = ODEProblem(minimalModelAllocContainer, u0, (0.0, 10.0), pTest)
benchmark = @benchmark DiffEqFlux.sciml_train($lossBenchmark, $pTest, $ADAM(0.05), maxiters = 30) samples = 100 seconds = 30
push!(memories, benchmark.memory)
push!(times, benchmark.times |> mean)
end
```

All models are tested under exactly the same `u0`

and `M`

so that cannot be the reason. Also, I know there is still so much room for improvement. My goal here was just to make all three approaches comparable. Thanks in advance for any input on that puzzeling finding .