# Memory allocation with Channels

**URL:** https://discourse.julialang.org/t/memory-allocation-with-channels/3639
**Category:** General Usage
**Created:** [May 10, 2017, 10:23pm UTC](https://discourse.julialang.org/t/memory-allocation-with-channels/3639 "2017-05-10T22:23:38Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![gasagna](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/gasagna/32/1275_2.png) [@gasagna](https://discourse.julialang.org/u/gasagna)
#### Post date: [May 10, 2017, 10:23pm UTC](https://discourse.julialang.org/t/memory-allocation-with-channels/3639/1 "2017-05-10T22:23:38Z")

</div>

Hi all,

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

```julia
# 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

```julia
  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!