Faster in-place ntoh

[Moelf]

You guys will have to tell me how horrible this PR is.

Before:

julia> using Revise, UnROOT
[ Info: Precompiling UnROOT [3cd96dde-e98d-4713-81e9-a4a1b0235ce9]
cons
julia> const t = LazyTree(ROOTFile("Run2012BC_DoubleMuParked_Muons.root"), "Events", ["Muon_pt"]);

julia> @time  for evt in t
                evt.Muon_pt
              end
  5.021026 seconds (1.93 M allocations: 4.254 GiB, 4.75% gc time, 4.34% compilation time)

julia> @time  for evt in t
                evt.Muon_pt
              end
  4.285786 seconds (58.16 k allocations: 4.159 GiB, 1.68% gc time)

julia> @time  for evt in t
                evt.Muon_pt
              end
  4.255702 seconds (58.16 k allocations: 4.159 GiB, 1.48% gc time)

After:

julia> const t = LazyTree(ROOTFile("Run2012BC_DoubleMuParked_Muons.root"), "Events", ["Muon_pt"]);

julia> @time let x = 0
           for evt in t
               evt.Muon_pt
           end
           x
       end
  4.731603 seconds (1.46 M allocations: 3.674 GiB, 4.55% gc time, 4.94% compilation time)
0

julia> @time  for evt in t
                evt.Muon_pt
              end
  4.096869 seconds (59.20 k allocations: 3.603 GiB, 1.22% gc time)

[aminnj]

Not sure why you closed? Some questions

1. Does the speedup hold with @btime? Probably easier to see it on the uncompressed file when it's not diluted by 70% zlib.
2. Won't this mess up the basketarray API? Users will have to keep that reference themselves when it's not used internally via LazyBranch. Or maybe we make that an internal api?

[Moelf]

Won't this mess up the basketarray API?
yep... which is why I closed it.

I think we should disable array() API. Maybe only allow if for raw = true

[aminnj]

Just tested this PR vs master on another machine. I get @btimes ranging from 1.698 to 1.652 when alternately switching between the two. It seems like there's no time difference. My benchmark is

julia> using UnROOT

julia> const t = LazyTree(ROOTFile("uncompressed_Run2012BC_DoubleMuParked_Muons.root"), "Events");

julia> function foo(t)
           s = 0.0f0
           for evt in t
               s += sum(evt.Muon_pt)
           end
           s
       end
foo (generic function with 1 method)

julia> @benchmark foo(t)

[aminnj]

With a benchmark where I don't loop over the elements I get

julia> function foo2(t)
           for evt in t
               evt.Muon_pt
           end
       end
foo2 (generic function with 1 method)

julia> @benchmark foo2(t) seconds=15 # master
BenchmarkTools.Trial: 17 samples with 1 evaluation.
 Range (min … max):  851.025 ms … 991.843 ms  ┊ GC (min … max): 6.61% … 6.04%
 Time  (median):     876.236 ms               ┊ GC (median):    6.92%
 Time  (mean ± σ):   889.033 ms ±  40.918 ms  ┊ GC (mean ± σ):  6.75% ± 0.29%
 Memory estimate: 1.82 GiB, allocs estimate: 14304.

julia> @benchmark foo2(t) seconds=15 # PR
BenchmarkTools.Trial: 17 samples with 1 evaluation.
 Range (min … max):  769.904 ms … 873.306 ms  ┊ GC (min … max): 5.60% … 5.41%
 Time  (median):     795.748 ms               ┊ GC (median):    5.84%
 Time  (mean ± σ):   800.257 ms ±  23.881 ms  ┊ GC (mean ± σ):  5.78% ± 0.20%
 Memory estimate: 1.26 GiB, allocs estimate: 14602.

but it's kind of a dumb benchmark?

[Moelf]

at least

Memory estimate: 1.26 GiB

so I think in some cases this would be faster

[aminnj]

ϖ :(

[aminnj]

We don't need this else?