ocaml-containers
ocaml-containers copied to clipboard
Published
20 hours ago •
c-cube
c-cube
CCArray.of_iter missing in containers v3.15
Right, it's never been there. It is in the iter package. Implementing reasonably efficiently requires a dynamic array and I didn't have that at the time.
I run the benchmark, Constructing arrays with CCVectors is a bad idea.
*** Run benchmarks for path "iter.to_array.1000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 27720.03/s (n=87481)
3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 27671.08/s (n=87481)
3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 27667.08/s (n=87481)
gen.to_array: 3.15 WALL ( 3.15 usr + 0.00 sys = 3.15 CPU) @ 27502.18/s (n=86511)
3.14 WALL ( 3.13 usr + 0.01 sys = 3.14 CPU) @ 27541.84/s (n=86511)
3.15 WALL ( 3.15 usr + 0.00 sys = 3.15 CPU) @ 27494.58/s (n=86511)
oseq.to_array: 3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 40901.12/s (n=129308)
3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 40959.03/s (n=129308)
3.17 WALL ( 3.17 usr + 0.00 sys = 3.17 CPU) @ 40849.63/s (n=129308)
ccarray.to_array: 3.16 WALL ( 3.12 usr + 0.04 sys = 3.16 CPU) @ 24513.87/s (n=77389)
3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 24479.66/s (n=77389)
3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 24526.76/s (n=77389)
Rate ccarray.to_array gen.to_array iter.to_array oseq.to_array
ccarray.to_array 24507+-19/s -- -11% -11% -40%
gen.to_array 27513+-20/s 12% -- -1% -33%
iter.to_array 27686+-23/s 13% 1% -- -32%
oseq.to_array 40903+-42/s 67% 49% 48% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.10000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.15 WALL ( 3.15 usr + 0.00 sys = 3.15 CPU) @ 2663.04/s (n=8394)
3.15 WALL ( 3.15 usr + 0.00 sys = 3.15 CPU) @ 2664.44/s (n=8394)
3.16 WALL ( 3.10 usr + 0.06 sys = 3.16 CPU) @ 2659.38/s (n=8394)
gen.to_array: 3.14 WALL ( 3.12 usr + 0.02 sys = 3.14 CPU) @ 2388.26/s (n=7504)
3.14 WALL ( 3.12 usr + 0.02 sys = 3.14 CPU) @ 2387.19/s (n=7504)
3.15 WALL ( 3.12 usr + 0.03 sys = 3.15 CPU) @ 2382.99/s (n=7504)
oseq.to_array: 3.17 WALL ( 3.16 usr + 0.01 sys = 3.17 CPU) @ 4148.05/s (n=13166)
3.17 WALL ( 3.14 usr + 0.03 sys = 3.17 CPU) @ 4151.46/s (n=13166)
3.18 WALL ( 3.18 usr + 0.00 sys = 3.18 CPU) @ 4141.93/s (n=13166)
ccarray.to_array: 3.15 WALL ( 3.12 usr + 0.03 sys = 3.15 CPU) @ 2265.67/s (n=7143)
3.17 WALL ( 3.09 usr + 0.08 sys = 3.17 CPU) @ 2254.36/s (n=7143)
3.16 WALL ( 3.14 usr + 0.02 sys = 3.16 CPU) @ 2260.56/s (n=7143)
Rate ccarray.to_array gen.to_array iter.to_array oseq.to_array
ccarray.to_array 2260+-4/s -- -5% -15% -45%
gen.to_array 2386+-2/s 6% -- -10% -42%
iter.to_array 2662+-2/s 18% 12% -- -36%
oseq.to_array 4147+-4/s 83% 74% 56% --
let bench_to_array n =
let iter () = Iter.to_array Iter.(1 -- n)
and gen () = Gen.to_array Gen.(1 -- n)
and oseq () = OSeq.to_array OSeq.(1 -- n)
and ccarray () = CCArray.of_iter Iter.(1 -- n) in
B.throughputN 3 ~repeat
[
"iter.to_array", iter, ();
"gen.to_array", gen, ();
"oseq.to_array", oseq, ();
"ccarray.to_array", ccarray, ();
]
let of_iter (i : 'a iter) : 'a array =
let open CCVector in
let vec = create () in
i (push vec);
to_array vec
I doubled the growth factor.
let[@inline] next_grow_ n = min Sys.max_array_length (n lsl 1)
*** Run benchmarks for path "iter.to_array.1000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.32 WALL ( 3.32 usr + 0.00 sys = 3.32 CPU) @ 49712.32/s (n=164923)
3.31 WALL ( 3.30 usr + 0.01 sys = 3.31 CPU) @ 49886.15/s (n=164923)
3.28 WALL ( 3.28 usr + 0.00 sys = 3.28 CPU) @ 50264.36/s (n=164923)
gen.to_array: 3.10 WALL ( 3.08 usr + 0.02 sys = 3.10 CPU) @ 49552.32/s (n=153456)
3.10 WALL ( 3.09 usr + 0.01 sys = 3.10 CPU) @ 49447.80/s (n=153456)
3.09 WALL ( 3.08 usr + 0.01 sys = 3.09 CPU) @ 49632.60/s (n=153456)
oseq.to_array: 3.21 WALL ( 3.19 usr + 0.02 sys = 3.21 CPU) @ 75944.34/s (n=244064)
3.22 WALL ( 3.20 usr + 0.02 sys = 3.22 CPU) @ 75705.83/s (n=244064)
3.19 WALL ( 3.16 usr + 0.03 sys = 3.19 CPU) @ 76447.67/s (n=244064)
ccarray.to_array: 3.22 WALL ( 3.20 usr + 0.02 sys = 3.22 CPU) @ 57355.75/s (n=184791)
3.17 WALL ( 3.14 usr + 0.03 sys = 3.17 CPU) @ 58252.00/s (n=184791)
3.17 WALL ( 3.16 usr + 0.01 sys = 3.17 CPU) @ 58259.08/s (n=184791)
Rate gen.to_array iter.to_array ccarray.to_array oseq.to_array
gen.to_array 49544+- 72/s -- [-1%] -15% -35%
iter.to_array 49954+-219/s [1%] -- -14% -34%
ccarray.to_array 57956+-403/s 17% 16% -- -24%
oseq.to_array 76033+-294/s 53% 52% 31% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.10000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.43 WALL ( 3.40 usr + 0.03 sys = 3.43 CPU) @ 4627.10/s (n=15890)
3.42 WALL ( 3.37 usr + 0.05 sys = 3.42 CPU) @ 4649.20/s (n=15890)
3.40 WALL ( 3.33 usr + 0.07 sys = 3.40 CPU) @ 4672.96/s (n=15890)
gen.to_array: 3.22 WALL ( 3.19 usr + 0.03 sys = 3.22 CPU) @ 4358.97/s (n=14021)
3.22 WALL ( 3.19 usr + 0.03 sys = 3.22 CPU) @ 4356.15/s (n=14021)
3.23 WALL ( 3.23 usr + 0.00 sys = 3.23 CPU) @ 4336.51/s (n=14021)
oseq.to_array: 3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 7696.78/s (n=24358)
3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 7696.24/s (n=24358)
3.16 WALL ( 3.15 usr + 0.01 sys = 3.16 CPU) @ 7696.69/s (n=24358)
ccarray.to_array: 3.28 WALL ( 3.25 usr + 0.03 sys = 3.28 CPU) @ 4655.44/s (n=15259)
3.31 WALL ( 3.23 usr + 0.08 sys = 3.31 CPU) @ 4611.93/s (n=15259)
3.30 WALL ( 3.22 usr + 0.08 sys = 3.30 CPU) @ 4620.20/s (n=15259)
Rate gen.to_array ccarray.to_array iter.to_array oseq.to_array
gen.to_array 4351+- 9/s -- -6% -6% -43%
ccarray.to_array 4629+-18/s 6% -- [-0%] -40%
iter.to_array 4650+-18/s 7% [0%] -- -40%
oseq.to_array 7697+- 0/s 77% 66% 66% --
We need to separate benchmarks for large and small amounts of data
let bench_to_array n =
let iter () = Iter.to_array Iter.(1 -- n)
and gen () = Gen.to_array Gen.(1 -- n)
and oseq () = OSeq.to_array OSeq.(1 -- n)
and ccarray () = CCArray.of_iter Iter.(1 -- n) in
let list () = Iter.(1 -- n) |> CCList.of_iter |> CCArray.of_list in
B.throughputN 3 ~repeat
[
"iter.to_array", iter, ();
"gen.to_array", gen, ();
"oseq.to_array", oseq, ();
"ccarray.to_array", ccarray, ();
"list.to_array", list, ();
]
*** Run benchmarks for path "iter.to_array.1000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array", "list.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.07 WALL ( 3.07 usr + 0.00 sys = 3.07 CPU) @ 27669.54/s (n=84817)
3.07 WALL ( 3.07 usr + 0.00 sys = 3.07 CPU) @ 27660.74/s (n=84817)
3.07 WALL ( 3.07 usr + 0.00 sys = 3.07 CPU) @ 27664.80/s (n=84817)
gen.to_array: 3.17 WALL ( 3.12 usr + 0.05 sys = 3.17 CPU) @ 27117.99/s (n=85886)
3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 27137.69/s (n=85886)
3.17 WALL ( 3.15 usr + 0.02 sys = 3.17 CPU) @ 27089.38/s (n=85886)
oseq.to_array: 3.15 WALL ( 3.14 usr + 0.01 sys = 3.15 CPU) @ 40981.14/s (n=129165)
3.15 WALL ( 3.14 usr + 0.01 sys = 3.15 CPU) @ 40963.24/s (n=129165)
3.18 WALL ( 3.14 usr + 0.04 sys = 3.18 CPU) @ 40668.98/s (n=129165)
ccarray.to_array: 3.10 WALL ( 3.09 usr + 0.01 sys = 3.10 CPU) @ 31550.58/s (n=97838)
3.10 WALL ( 3.08 usr + 0.02 sys = 3.10 CPU) @ 31577.80/s (n=97838)
3.10 WALL ( 3.07 usr + 0.03 sys = 3.10 CPU) @ 31518.15/s (n=97838)
list.to_array: 3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 41909.74/s (n=132415)
3.06 WALL ( 3.06 usr + 0.00 sys = 3.06 CPU) @ 58611.70/s (n=179393)
3.09 WALL ( 3.09 usr + 0.00 sys = 3.09 CPU) @ 77373.87/s (n=239422)
Rate gen.to_array iter.to_array ccarray.to_array oseq.to_array list.to_array
gen.to_array 27115+- 19/s -- -2% -14% -34% -54%
iter.to_array 27665+- 3/s 2% -- -12% -32% -53%
ccarray.to_array 31549+- 23/s 16% 14% -- -23% [-47%]
oseq.to_array 40871+- 136/s 51% 48% 30% -- [-31%]
list.to_array 59298+-13762/s 119% 114% [88%] [45%] --
**********************************************************************
*** Run benchmarks for path "iter.to_array.10000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array", "list.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.12 WALL ( 3.07 usr + 0.05 sys = 3.12 CPU) @ 4933.67/s (n=15381)
3.13 WALL ( 3.09 usr + 0.04 sys = 3.13 CPU) @ 4919.92/s (n=15381)
3.13 WALL ( 3.09 usr + 0.04 sys = 3.13 CPU) @ 4911.09/s (n=15381)
gen.to_array: 3.28 WALL ( 3.27 usr + 0.01 sys = 3.28 CPU) @ 4208.28/s (n=13824)
3.27 WALL ( 3.25 usr + 0.02 sys = 3.27 CPU) @ 4225.04/s (n=13824)
3.28 WALL ( 3.26 usr + 0.02 sys = 3.28 CPU) @ 4214.18/s (n=13824)
oseq.to_array: 3.08 WALL ( 3.05 usr + 0.03 sys = 3.08 CPU) @ 7690.70/s (n=23717)
3.10 WALL ( 3.08 usr + 0.02 sys = 3.10 CPU) @ 7642.20/s (n=23717)
3.08 WALL ( 3.07 usr + 0.01 sys = 3.08 CPU) @ 7690.02/s (n=23717)
ccarray.to_array: 3.02 WALL ( 2.97 usr + 0.05 sys = 3.02 CPU) @ 4684.59/s (n=14159)
3.04 WALL ( 3.02 usr + 0.02 sys = 3.04 CPU) @ 4661.37/s (n=14159)
3.05 WALL ( 2.99 usr + 0.06 sys = 3.05 CPU) @ 4646.96/s (n=14159)
list.to_array: 3.09 WALL ( 3.06 usr + 0.03 sys = 3.09 CPU) @ 5297.84/s (n=16395)
3.14 WALL ( 3.12 usr + 0.02 sys = 3.14 CPU) @ 5218.24/s (n=16395)
3.11 WALL ( 3.05 usr + 0.06 sys = 3.11 CPU) @ 5275.21/s (n=16395)
Rate gen.to_array ccarray.to_array iter.to_array list.to_array oseq.to_array
gen.to_array 4216+- 7/s -- -10% -14% -20% -45%
ccarray.to_array 4664+-15/s 11% -- -5% -11% -39%
iter.to_array 4922+- 9/s 17% 6% -- -7% -36%
list.to_array 5264+-32/s 25% 13% 7% -- -31%
oseq.to_array 7674+-22/s 82% 65% 56% 46% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.100000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array", "list.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.03 WALL ( 2.93 usr + 0.10 sys = 3.03 CPU) @ 513.70/s (n=1558)
3.02 WALL ( 2.95 usr + 0.07 sys = 3.02 CPU) @ 515.24/s (n=1558)
3.04 WALL ( 2.96 usr + 0.08 sys = 3.04 CPU) @ 512.90/s (n=1558)
gen.to_array: 3.25 WALL ( 3.21 usr + 0.04 sys = 3.25 CPU) @ 264.35/s (n=858)
3.29 WALL ( 3.25 usr + 0.04 sys = 3.29 CPU) @ 261.18/s (n=858)
3.26 WALL ( 3.25 usr + 0.01 sys = 3.25 CPU) @ 263.59/s (n=858)
oseq.to_array: 3.10 WALL ( 3.06 usr + 0.04 sys = 3.10 CPU) @ 756.78/s (n=2349)
3.13 WALL ( 3.09 usr + 0.04 sys = 3.13 CPU) @ 792.04/s (n=2477)
3.16 WALL ( 3.14 usr + 0.02 sys = 3.16 CPU) @ 784.10/s (n=2477)
ccarray.to_array: 3.14 WALL ( 3.05 usr + 0.09 sys = 3.14 CPU) @ 541.57/s (n=1700)
3.13 WALL ( 3.02 usr + 0.11 sys = 3.13 CPU) @ 542.90/s (n=1700)
3.15 WALL ( 3.10 usr + 0.05 sys = 3.15 CPU) @ 539.00/s (n=1700)
list.to_array: 3.17 WALL ( 3.17 usr + 0.00 sys = 3.17 CPU) @ 204.36/s (n=648)
3.16 WALL ( 3.16 usr + 0.00 sys = 3.16 CPU) @ 204.84/s (n=648)
3.18 WALL ( 3.16 usr + 0.02 sys = 3.18 CPU) @ 203.91/s (n=648)
Rate list.to_array gen.to_array iter.to_array ccarray.to_array oseq.to_array
list.to_array 204+- 0/s -- -22% -60% -62% -74%
gen.to_array 263+- 1/s 29% -- -49% -51% -66%
iter.to_array 514+- 1/s 151% 95% -- -5% -34%
ccarray.to_array 541+- 2/s 165% 106% 5% -- -30%
oseq.to_array 778+-14/s 281% 196% 51% 44% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.1000000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "ccarray.to_array", "list.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.11 WALL ( 3.11 usr + 0.00 sys = 3.11 CPU) @ 52.72/s (n=164)
3.12 WALL ( 3.12 usr + 0.00 sys = 3.12 CPU) @ 52.56/s (n=164)
3.15 WALL ( 3.14 usr + 0.01 sys = 3.15 CPU) @ 52.09/s (n=164)
gen.to_array: 3.13 WALL ( 3.12 usr + 0.01 sys = 3.13 CPU) @ 22.68/s (n=71)
3.16 WALL ( 3.14 usr + 0.02 sys = 3.16 CPU) @ 22.48/s (n=71)
3.14 WALL ( 3.13 usr + 0.01 sys = 3.14 CPU) @ 22.62/s (n=71)
oseq.to_array: 3.04 WALL ( 3.02 usr + 0.01 sys = 3.03 CPU) @ 79.44/s (n=241)
3.05 WALL ( 3.02 usr + 0.03 sys = 3.05 CPU) @ 79.11/s (n=241)
3.03 WALL ( 3.01 usr + 0.02 sys = 3.03 CPU) @ 79.52/s (n=241)
ccarray.to_array: 3.09 WALL ( 3.00 usr + 0.09 sys = 3.09 CPU) @ 58.21/s (n=180)
3.13 WALL ( 3.03 usr + 0.10 sys = 3.13 CPU) @ 57.49/s (n=180)
3.12 WALL ( 2.98 usr + 0.14 sys = 3.12 CPU) @ 57.65/s (n=180)
list.to_array: 3.63 WALL ( 3.62 usr + 0.01 sys = 3.63 CPU) @ 17.06/s (n=62)
3.66 WALL ( 3.65 usr + 0.01 sys = 3.66 CPU) @ 16.95/s (n=62)
3.64 WALL ( 3.59 usr + 0.05 sys = 3.64 CPU) @ 17.04/s (n=62)
Rate list.to_array gen.to_array iter.to_array ccarray.to_array oseq.to_array
list.to_array 17.0+-0.0/s -- -25% -68% -71% -79%
gen.to_array 22.6+-0.1/s 33% -- -57% -61% -72%
iter.to_array 52.5+-0.3/s 208% 132% -- -9% -34%
ccarray.to_array 57.8+-0.3/s 240% 156% 10% -- -27%
oseq.to_array 79.4+-0.2/s 366% 251% 51% 37% --
I tried a trivial implementation, benchmarked on my machine, which is very fast when the length is less than 10_000
let to_array it =
let i = ref 0 in
let xs = ref [] in
it (fun x ->
xs := x :: !xs;
incr i;
());
match !xs with
| [] -> [||]
| x::_ ->
let arr = Array.make !i x in
!xs |> List.iteri (fun i x -> arr.(i) <- x );
arr
let bench_to_array n =
let iter () = Iter.to_array Iter.(1 -- n)
and gen () = Gen.to_array Gen.(1 -- n)
and oseq () = OSeq.to_array OSeq.(1 -- n)
and list () = Iter.(1 -- n) |> CCList.of_iter |> CCArray.of_list
and list' () = Iter.(1 -- n) |> to_array
in
B.throughputN 3 ~repeat
[
"iter.to_array", iter, ();
"gen.to_array", gen, ();
"oseq.to_array", oseq, ();
"list.to_array", list, ();
"list'.to_array", list', ();
]
*** Run benchmarks for path "iter.to_array.1000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "list.to_array", "list'.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.37 WALL ( 3.37 usr + 0.00 sys = 3.37 CPU) @ 45301.51/s (n=152742)
3.25 WALL ( 3.25 usr + 0.00 sys = 3.25 CPU) @ 47026.06/s (n=152742)
3.23 WALL ( 3.23 usr + 0.00 sys = 3.23 CPU) @ 47360.95/s (n=152742)
gen.to_array: 3.13 WALL ( 3.11 usr + 0.02 sys = 3.13 CPU) @ 49327.05/s (n=154174)
3.02 WALL ( 3.00 usr + 0.02 sys = 3.02 CPU) @ 51116.43/s (n=154174)
3.02 WALL ( 2.99 usr + 0.03 sys = 3.02 CPU) @ 51134.15/s (n=154174)
oseq.to_array: 3.24 WALL ( 3.20 usr + 0.04 sys = 3.24 CPU) @ 76391.19/s (n=247818)
3.27 WALL ( 3.25 usr + 0.02 sys = 3.27 CPU) @ 75785.34/s (n=247818)
3.22 WALL ( 3.22 usr + 0.00 sys = 3.22 CPU) @ 76862.07/s (n=247818)
list.to_array: 3.10 WALL ( 3.10 usr + 0.00 sys = 3.10 CPU) @ 78954.36/s (n=244957)
3.09 WALL ( 3.07 usr + 0.02 sys = 3.09 CPU) @ 79228.57/s (n=244957)
3.12 WALL ( 3.11 usr + 0.01 sys = 3.12 CPU) @ 78509.92/s (n=244957)
list'.to_array: 3.18 WALL ( 3.13 usr + 0.05 sys = 3.18 CPU) @ 81626.44/s (n=259564)
3.18 WALL ( 3.16 usr + 0.02 sys = 3.18 CPU) @ 81731.51/s (n=259564)
3.21 WALL ( 3.16 usr + 0.05 sys = 3.21 CPU) @ 80880.96/s (n=259564)
Rate iter.to_array gen.to_array oseq.to_array list.to_array list'.to_array
iter.to_array 46563+-857/s -- -8% -39% -41% -43%
gen.to_array 50526+-805/s 9% -- -34% -36% -38%
oseq.to_array 76346+-419/s 64% 51% -- -3% -6%
list.to_array 78898+-281/s 69% 56% 3% -- -3%
list'.to_array 81413+-360/s 75% 61% 7% 3% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.10000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "list.to_array", "list'.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.27 WALL ( 3.21 usr + 0.06 sys = 3.27 CPU) @ 4878.26/s (n=15942)
3.23 WALL ( 3.21 usr + 0.02 sys = 3.23 CPU) @ 4929.13/s (n=15942)
3.26 WALL ( 3.19 usr + 0.07 sys = 3.26 CPU) @ 4891.62/s (n=15942)
gen.to_array: 3.18 WALL ( 3.15 usr + 0.03 sys = 3.18 CPU) @ 4446.37/s (n=14146)
3.19 WALL ( 3.16 usr + 0.03 sys = 3.19 CPU) @ 4438.34/s (n=14146)
3.22 WALL ( 3.21 usr + 0.01 sys = 3.22 CPU) @ 4398.63/s (n=14146)
oseq.to_array: 3.22 WALL ( 3.22 usr + 0.00 sys = 3.22 CPU) @ 7675.77/s (n=24733)
3.21 WALL ( 3.21 usr + 0.00 sys = 3.21 CPU) @ 7716.39/s (n=24733)
3.21 WALL ( 3.21 usr + 0.00 sys = 3.21 CPU) @ 7700.71/s (n=24733)
list.to_array: 3.15 WALL ( 3.13 usr + 0.02 sys = 3.15 CPU) @ 5384.53/s (n=16940)
3.15 WALL ( 3.08 usr + 0.07 sys = 3.15 CPU) @ 5380.52/s (n=16940)
3.14 WALL ( 3.13 usr + 0.01 sys = 3.14 CPU) @ 5403.45/s (n=16940)
list'.to_array: 3.07 WALL ( 3.06 usr + 0.01 sys = 3.07 CPU) @ 6995.13/s (n=21444)
3.07 WALL ( 3.03 usr + 0.04 sys = 3.07 CPU) @ 6980.44/s (n=21444)
3.07 WALL ( 3.07 usr + 0.00 sys = 3.07 CPU) @ 6984.02/s (n=21444)
Rate gen.to_array iter.to_array list.to_array list'.to_array oseq.to_array
gen.to_array 4428+-20/s -- -10% -18% -37% -42%
iter.to_array 4900+-20/s 11% -- -9% -30% -36%
list.to_array 5389+- 9/s 22% 10% -- -23% -30%
list'.to_array 6987+- 6/s 58% 43% 30% -- -9%
oseq.to_array 7698+-16/s 74% 57% 43% 10% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.100000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "list.to_array", "list'.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.21 WALL ( 3.15 usr + 0.06 sys = 3.21 CPU) @ 509.94/s (n=1638)
3.22 WALL ( 3.15 usr + 0.07 sys = 3.22 CPU) @ 508.28/s (n=1638)
3.22 WALL ( 3.11 usr + 0.11 sys = 3.22 CPU) @ 508.98/s (n=1638)
gen.to_array: 3.24 WALL ( 3.23 usr + 0.01 sys = 3.24 CPU) @ 268.73/s (n=870)
3.24 WALL ( 3.21 usr + 0.03 sys = 3.24 CPU) @ 268.77/s (n=870)
3.20 WALL ( 3.19 usr + 0.01 sys = 3.20 CPU) @ 272.26/s (n=870)
oseq.to_array: 3.09 WALL ( 3.04 usr + 0.05 sys = 3.09 CPU) @ 792.21/s (n=2451)
3.11 WALL ( 3.07 usr + 0.04 sys = 3.11 CPU) @ 787.84/s (n=2451)
3.08 WALL ( 3.05 usr + 0.03 sys = 3.08 CPU) @ 795.68/s (n=2451)
list.to_array: 3.14 WALL ( 3.13 usr + 0.01 sys = 3.14 CPU) @ 208.20/s (n=653)
3.14 WALL ( 3.13 usr + 0.01 sys = 3.14 CPU) @ 208.08/s (n=653)
3.15 WALL ( 3.14 usr + 0.01 sys = 3.15 CPU) @ 207.09/s (n=653)
list'.to_array: 3.24 WALL ( 3.24 usr + 0.00 sys = 3.24 CPU) @ 308.97/s (n=1002)
3.22 WALL ( 3.21 usr + 0.01 sys = 3.22 CPU) @ 310.97/s (n=1002)
3.22 WALL ( 3.22 usr + 0.00 sys = 3.22 CPU) @ 311.36/s (n=1002)
Rate list.to_array gen.to_array list'.to_array iter.to_array oseq.to_array
list.to_array 208+-0/s -- -23% -33% -59% -74%
gen.to_array 270+-2/s 30% -- -13% -47% -66%
list'.to_array 310+-1/s 49% 15% -- -39% -61%
iter.to_array 509+-1/s 145% 89% 64% -- -36%
oseq.to_array 792+-3/s 281% 193% 155% 56% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.1000000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "list.to_array", "list'.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.15 WALL ( 3.13 usr + 0.02 sys = 3.15 CPU) @ 52.67/s (n=166)
3.17 WALL ( 3.17 usr + 0.00 sys = 3.17 CPU) @ 52.42/s (n=166)
3.14 WALL ( 3.14 usr + 0.00 sys = 3.14 CPU) @ 52.89/s (n=166)
gen.to_array: 3.43 WALL ( 3.41 usr + 0.02 sys = 3.43 CPU) @ 23.65/s (n=81)
3.46 WALL ( 3.43 usr + 0.03 sys = 3.46 CPU) @ 23.41/s (n=81)
3.46 WALL ( 3.43 usr + 0.03 sys = 3.46 CPU) @ 23.40/s (n=81)
oseq.to_array: 3.11 WALL ( 3.11 usr + 0.00 sys = 3.11 CPU) @ 79.81/s (n=248)
3.13 WALL ( 3.08 usr + 0.04 sys = 3.12 CPU) @ 79.39/s (n=248)
3.17 WALL ( 3.15 usr + 0.02 sys = 3.17 CPU) @ 78.14/s (n=248)
list.to_array: 3.07 WALL ( 2.99 usr + 0.08 sys = 3.07 CPU) @ 17.26/s (n=53)
3.10 WALL ( 3.03 usr + 0.07 sys = 3.10 CPU) @ 17.12/s (n=53)
3.08 WALL ( 3.05 usr + 0.03 sys = 3.08 CPU) @ 17.22/s (n=53)
list'.to_array: 3.15 WALL ( 3.13 usr + 0.02 sys = 3.15 CPU) @ 29.86/s (n=94)
3.18 WALL ( 3.14 usr + 0.03 sys = 3.17 CPU) @ 29.61/s (n=94)
3.18 WALL ( 3.16 usr + 0.02 sys = 3.18 CPU) @ 29.57/s (n=94)
Rate list.to_array gen.to_array list'.to_array iter.to_array oseq.to_array
list.to_array 17.2+-0.1/s -- -27% -42% -67% -78%
gen.to_array 23.5+-0.1/s 37% -- -21% -55% -70%
list'.to_array 29.7+-0.1/s 73% 26% -- -44% -62%
iter.to_array 52.7+-0.2/s 206% 124% 77% -- -33%
oseq.to_array 79.1+-0.7/s 360% 237% 167% 50% --
**********************************************************************
*** Run benchmarks for path "iter.to_array.10000000"
Throughputs for "iter.to_array", "gen.to_array", "oseq.to_array", "list.to_array", "list'.to_array" each running 3 times for at least 3 CPU seconds:
iter.to_array: 3.18 WALL ( 2.95 usr + 0.23 sys = 3.18 CPU) @ 5.03/s (n=16)
3.16 WALL ( 3.01 usr + 0.15 sys = 3.16 CPU) @ 5.07/s (n=16)
3.01 WALL ( 2.78 usr + 0.23 sys = 3.01 CPU) @ 4.98/s (n=15)
gen.to_array: 3.18 WALL ( 2.93 usr + 0.24 sys = 3.17 CPU) @ 2.21/s (n=7)
3.05 WALL ( 2.85 usr + 0.20 sys = 3.05 CPU) @ 2.29/s (n=7)
3.41 WALL ( 3.28 usr + 0.12 sys = 3.40 CPU) @ 2.35/s (n=8)
oseq.to_array: 3.05 WALL ( 2.97 usr + 0.08 sys = 3.05 CPU) @ 7.86/s (n=24)
3.09 WALL ( 3.00 usr + 0.09 sys = 3.09 CPU) @ 7.77/s (n=24)
3.07 WALL ( 2.95 usr + 0.11 sys = 3.06 CPU) @ 7.85/s (n=24)
list.to_array: 3.55 WALL ( 3.43 usr + 0.12 sys = 3.55 CPU) @ 1.69/s (n=6)
3.62 WALL ( 3.41 usr + 0.20 sys = 3.61 CPU) @ 1.66/s (n=6)
3.51 WALL ( 3.32 usr + 0.19 sys = 3.51 CPU) @ 1.71/s (n=6)
list'.to_array: 3.27 WALL ( 2.90 usr + 0.37 sys = 3.27 CPU) @ 2.75/s (n=9)
3.11 WALL ( 2.91 usr + 0.19 sys = 3.10 CPU) @ 2.90/s (n=9)
3.21 WALL ( 3.03 usr + 0.17 sys = 3.20 CPU) @ 2.82/s (n=9)
Rate list.to_array gen.to_array list'.to_array iter.to_array oseq.to_array
list.to_array 1.69+-0.02/s -- -26% -40% -66% -78%
gen.to_array 2.28+-0.06/s 35% -- -19% -55% -71%
list'.to_array 2.82+-0.06/s 67% 24% -- -44% -64%
iter.to_array 5.02+-0.04/s 197% 120% 78% -- -36%
oseq.to_array 7.83+-0.03/s 363% 243% 177% 56% --
An alternative is to port the unrolled list from iter, and add it to containers as a separate module, and then use that in Array.of_iter.