Hi all,

I am playing with channels and I have this example code.

```
# Example producer, will generate `N` element using function
# `ϕ` and push them in a channel of size `csize`
function Produce(ϕ, x₀::T, N::Int, csize::Int=20) where T
# create closure to feed the channel with
function f(ch::Channel)
# preallocate a set of elements to be reused by `ϕ`
xs = T[similar(x₀) for _ = 1:csize]
# put elements in channel, will block as soon as `i == csize`
for i = 1:N
put!(ch, ϕ(xs[i % csize + 1]))
end
close(ch)
end
return Channel(f; ctype=T, csize=csize)
end
# Example consumer function. Just sum the sums of the
# stream elements.
function Consume(stream::Channel{T}) where T
s = sum(take!(stream))
while isopen(stream) || isready(stream)
s += sum(take!(stream))
end
s
end
# example function that modifies x in place
ϕ(x) = (x .= 2.*x .+ 1; return x)
# warm up
stream = Produce(ϕ, randn(1000), 1000, 10)
Consume(stream)
# Time function for increasing number of generated
# elements and fixed channel size = 10
# Number of allocations grows
for N = [10, 100, 1000, 10000]
stream = Produce(ϕ, randn(1000), N, 10)
@time Consume(stream)
end
println()
# Time function for increasing channel size
# Number of allocations decreases
for csize = [10, 100, 1000, 10000]
stream = Produce(ϕ, randn(1000), 10000, csize)
@time Consume(stream)
end
```

This produces the output

```
0.000004 seconds (1 allocation: 16 bytes)
0.000077 seconds (27 allocations: 896 bytes)
0.000670 seconds (207 allocations: 3.688 KiB)
0.006473 seconds (2.01 k allocations: 31.813 KiB)
0.007672 seconds (2.01 k allocations: 31.813 KiB)
0.006934 seconds (208 allocations: 9.484 KiB)
0.009498 seconds (27 allocations: 16.609 KiB)
0.005006 seconds (1 allocation: 16 bytes)
```

What I don’t get is the largish number of allocations done in the second set of calls when the channel

size is small compared to the number of elements produced `N`

. Any suggestions?

Thanks!