CCArray.of_iter missing in containers v3.15

[illusory0x0]

[c-cube]

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.

[illusory0x0]

I think we can use CCVector for that.

[illusory0x0]

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

[illusory0x0]

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%            --

[illusory0x0]

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%            --

[illusory0x0]

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%            --

[c-cube]

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.