Merge pull request #12 from slimgroup/allocs

Small perf improvements

Author: mloubout

Diff for: Project.toml

@@ -1,7 +1,7 @@
 name = "SegyIO"
 uuid = "157a0f19-4d44-4de5-a0d0-07e2f0ac4dfa"
 authors = ["Henryk Modzelewski <[email protected]>"]
-version = "0.8.1"
+version = "0.8.2"
 
 [deps]
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"

Diff for: README.md

@@ -1,4 +1,5 @@
 # SegyIO.jl
+
 SegyIO is a Julia package for reading and writing SEGY Rev 1 files. In addition to providing tools for reading/writing entire files, SegyIO provides a parallel scanner that reduces any number of files into a single object with direct out-of-core access to the underlying data. 
 
 [![Build Status](https://github.com/slimgroup/SegyIO.jl/workflows/CI-tests/badge.svg)](https://github.com/slimgroup/SegyIO.jl/actions?query=workflow%3ACI-tests)

Diff for: src/SegyIO.jl

@@ -2,7 +2,7 @@ module SegyIO
 
     myRoot=dirname(dirname(pathof(SegyIO)))
     CHUNKSIZE = 2048
-    TRACE_CHUNKSIZE = 2048
+    TRACE_CHUNKSIZE = 512
     MB2B = 1024^2
 
     # what's being used

Diff for: src/read/read_block.jl

@@ -29,6 +29,6 @@ function read_block!(b::BlockScan, keys::Array{String, 1}, ns::Int, dsf::Int, tm
         tracee = min(trace + TRACE_CHUNKSIZE - 1, ntraces)
         chunk = length(trace:tracee)*trace_size
         sloc = IOBuffer(read(s, chunk))
-        read_traces!(sloc, fh.bfh, datatype, tmp_headers, view(tmp_data, :, trace:tracee), trace, keys, th_b2s)
+        read_traces!(sloc, view(tmp_headers, trace:tracee), view(tmp_data, :, trace:tracee), keys, th_b2s)
     end
 end

Diff for: src/read/read_block_headers.jl

@@ -21,7 +21,7 @@ function read_block_headers!(b::BlockScan, keys::Array{String, 1}, ns::Int, dsf:
     th_b2s = th_byte2sample()
     # Read each traceheader
     for trace in 1:ntraces
-        setindex!(headers, read_traceheader(s, keys, th_b2s), trace)
+        read_traceheader!(s, keys, th_b2s, headers[trace])
         skip(s, ns*4)
     end
 
@@ -48,7 +48,7 @@ function read_block_headers!(b::BlockScan, ns::Int, dsf::Int, headers)
     th_b2s = th_byte2sample()
     # Read each traceheader
     for trace in 1:ntraces
-        setindex!(headers, read_traceheader(s, th_b2s), trace)
+        read_traceheader!(s, th_b2s, headers[trace])
         skip(s, ns*4)
     end
 

Diff for: src/read/read_con.jl

@@ -24,7 +24,7 @@ function read_con(con::SeisCon, blocks::Array{Int,1};
 
     # Pre-allocate
     data = Array{datatype,2}(undef, con.ns, prealloc_traces) 
-    headers = Array{BinaryTraceHeader,1}(undef, prealloc_traces) 
+    headers = [BinaryTraceHeader() for _=1:prealloc_traces]
     fh = FileHeader(); set_fileheader!(fh.bfh, :ns, con.ns)
     set_fileheader!(fh.bfh, :DataSampleFormat, con.dsf)
 
@@ -73,7 +73,7 @@ function read_con(con::SeisCon, keys::Array{String,1}, blocks::Array{Int,1};
 
     # Pre-allocate
     data = Array{datatype,2}(undef, con.ns, prealloc_traces) 
-    headers = Array{BinaryTraceHeader,1}(undef, prealloc_traces) 
+    headers = [BinaryTraceHeader() for _=1:prealloc_traces]
     fh = FileHeader(); set_fileheader!(fh.bfh, :ns, con.ns)
     set_fileheader!(fh.bfh, :DataSampleFormat, con.dsf)
 

Diff for: src/read/read_file.jl

@@ -18,7 +18,6 @@ Read entire SEGY file from stream 's', only reading the header values in 'keys'.
 """
 function read_file(s::IO, keys::Array{String, 1}, warn_user::Bool; 
                    start_byte::Int = 3600, end_byte::Int = position(seekend(s)))
-    
     # Read File Header
     fh = read_fileheader(s)
 
@@ -43,16 +42,18 @@ function read_file(s::IO, keys::Array{String, 1}, warn_user::Bool;
     ntraces = Int((end_byte - start_byte)/trace_size)
 
     # Preallocate memory
-    headers = Array{BinaryTraceHeader, 1}(undef, ntraces)
+    headers = [BinaryTraceHeader() for _ = 1:ntraces]
     data = Array{datatype, 2}(undef, fh.bfh.ns, ntraces)
     th_b2s = th_byte2sample()
 
     # Read each trace
+    ref = position(s)
     for trace in 1:TRACE_CHUNKSIZE:ntraces
+        seek(s, (trace - 1) * trace_size + ref)
         tracee = min(trace + TRACE_CHUNKSIZE - 1, ntraces)
         chunk = length(trace:tracee)*trace_size
         sloc = IOBuffer(read(s, chunk))
-        read_traces!(sloc, fh.bfh, datatype, headers, view(data, :, trace:tracee), trace, keys, th_b2s)
+        read_traces!(sloc, view(headers, trace:tracee), view(data, :, trace:tracee), keys, th_b2s)
     end
 
     return SeisBlock(fh, headers, data)

Diff for: src/read/read_trace.jl

@@ -12,12 +12,11 @@ Use:    read_trace!(s::IO,
 Reads 'trace' from the current position of stream 's' into 'headers' and
 'data'. 
 """
-function read_traces!(s::IO, fh::BinaryFileHeader, datatype::Type,
-                    headers::AbstractVector{BinaryTraceHeader},
-                    data::AbstractMatrix{<:Union{IBMFloat32, Float32}},
-                    trace::Int, th_byte2sample::Dict{String,Int32})
+function read_traces!(s::IO, headers::AbstractVector{BinaryTraceHeader},
+                      data::AbstractMatrix{<:Union{IBMFloat32, Float32}},
+                      th_byte2sample::Dict{String,Int32})
 
-    return read_traces!(s, fh, datatype, headers, data, trace, collect(keys(th_byte2sample)), th_byte2sample)
+    return read_traces!(s, headers, data, collect(keys(th_byte2sample)), th_byte2sample)
 end
 
 """
@@ -33,38 +32,23 @@ Use:    read_trace!(s::IO,
 Reads 'trace' from the current position of stream 's' into 'headers' and
 'data'. Only the header values in 'keys' and read.
 """
-function read_traces!(s::IO, fh::BinaryFileHeader,
-                    datatype::Type,
-                    headers::AbstractVector{BinaryTraceHeader},
-                    data::AbstractMatrix{<:Union{IBMFloat32, Float32}},
-                    trace::Int,
-                    keys::Array{String,1},
-                    th_byte2sample::Dict{String,Int32})
+function read_traces!(s::IO, headers::AbstractVector{BinaryTraceHeader},
+                      data::AbstractMatrix{DT}, keys::Array{String,1},
+                      th_byte2sample::Dict{String,Int32}) where {DT<:Union{IBMFloat32, Float32}}
 
     ntrace = size(data, 2)
     ntrace == 0 && return
+    swp = swp_func(DT)
+    tmph = zeros(UInt8, 240)
     for trace_loc=0:ntrace-1
         # Read trace header
-        setindex!(headers, read_traceheader(s, keys, th_byte2sample), trace+trace_loc)
-
+        read_traceheader!(s, keys, th_byte2sample, headers[trace_loc+1]; th=tmph)
         # Read trace
-        setindex!(data, read_tracedata(s, fh, datatype), :, trace_loc+1)
+        read!(s, view(data, :, trace_loc+1))
     end
+    map!(swp, data, data)
     nothing
 end
 
-"""
-Read a single trace from current position in stream as Float32
-"""
-function read_tracedata(s::IO, fh::BinaryFileHeader, dsf::Type{DT}) where {DT<:IBMFloat32}
-    dummy=Vector{DT}(undef, fh.ns)
-    read!(s, dummy)
-    return dummy
-end
-
-function read_tracedata(s::IO, fh::BinaryFileHeader, dsf::Type{DT}) where {DT<:Float32}
-    dummy=Vector{DT}(undef, fh.ns)
-    read!(s, dummy)
-    return bswap.(dummy)
-end
-
+swp_func(::Type{Float32}) = bswap
+swp_func(::Any) = x -> x

Diff for: src/read/read_traceheader.jl

@@ -8,8 +8,8 @@ Use: fileheader = read_fileheader(s::IO; bigendian::Bool = true)
 
 Returns a binary trace header formed from the current position in the stream 's'.
 """
-function read_traceheader(s::IO, th_byte2sample::Dict{String,Int32}; bigendian::Bool = true)
-    return read_traceheader(s, collect(keys(th_byte2sample)), th_byte2sample; bigendian=bigendian)
+function read_traceheader(s::IO, th_byte2sample::Dict{String,Int32}; bigendian::Bool=true, th=zeros(UInt8, 240))
+    return read_traceheader(s, collect(keys(th_byte2sample)), th_byte2sample; bigendian=bigendian, th=th)
 end
 
 """
@@ -19,23 +19,32 @@ Returns a binary trace header formed from the current position in the stream 's'
 header values denoted in 'keys'.
 """
 function read_traceheader(s::IO, keys::Array{String,1}, th_byte2sample::Dict{String, Int32};
-                                bigendian::Bool = true)
+                          bigendian::Bool = true, th=zeros(UInt8, 240))
 
     # Initialize binary file header
     traceheader = BinaryTraceHeader()
 
+    read_traceheader!(s, keys, th_byte2sample, traceheader; bigendian=bigendian, th=th)
+    return traceheader
+end
+
+function read_traceheader!(s::IO, keys::Array{String,1}, th_byte2sample::Dict{String, Int32}, hdr::BinaryTraceHeader;
+                          bigendian::Bool = true, th=zeros(UInt8, 240))
+
     # read full trace header then split
-    th = read(s, 240)
+    read!(s, th)
 
     # Read all header values and put in fileheader
     for k in keys
         sym = Symbol(k)
-        nb = sizeof(getfield(traceheader, sym))-1
+        nb = sizeof(getfield(hdr, sym)) - 1
         bst = th_byte2sample[k]+1
-        val = reinterpret(typeof(getfield(traceheader, sym)), th[bst:bst+nb])[1]
+        val = reinterpret(typeof(getfield(hdr, sym)), th[bst:bst+nb])[1]
         bigendian && (val = bswap(val))
-        setfield!(traceheader, sym, val)
+        setfield!(hdr, sym, val)
     end
-
-    return traceheader
+    nothing
 end
+
+read_traceheader!(s::IO, thb::Dict{String, Int32}, hdr::BinaryTraceHeader; be::Bool = true, th=zeros(UInt8, 240)) =
+    read_traceheader!(s, collect(keys(thb)), thb, hdr; be=be, th=th)

Diff for: src/scan/scan_block.jl

@@ -6,13 +6,13 @@ function scan_block(buf::IO, mem_block::Int, mem_trace::Int, keys::Array{String,
     # Calc info about this block
     startbyte = position(buf) + chunk_start
     ntraces_block = Int(mem_block/mem_trace)
-    headers = Array{BinaryTraceHeader,1}(undef, ntraces_block)
+    headers = [BinaryTraceHeader() for _ = 1:ntraces_block]
     count = 0    
 
     # Read all headers and record end byte
     while !eof(buf) && count<ntraces_block
         count += 1
-        headers[count] = read_traceheader(buf, keys, th_byte2sample)
+        read_traceheader!(buf, keys, th_byte2sample,  headers[count] )
         skip(buf, mem_trace-240)
     end 
     endbyte = position(buf) + chunk_start

Diff for: src/scan/scan_file.jl

@@ -43,7 +43,6 @@ function scan_file(file::AbstractString, keys::Array{String, 1}, blocksize::Int;
     seek(s, 3600)
 
     # For each chunk
-    @show mem_block, chunksize*MB2B, max_blocks_per_chunk, nblocks_file
     for c in 1:max_blocks_per_chunk:nblocks_file
 
         count = scan_chunk!(s, max_blocks_per_chunk, mem_block, mem_trace,

Diff for: src/scan/scan_shots.jl

@@ -9,14 +9,15 @@ function scan_shots!(s::IO, mem_chunk::Int, mem_trace::Int,
     eof(s) ? (fl_eof=true) : nothing
     buf_size = position(seekend(buf)); seekstart(buf)
     ntraces = Int(floor(buf_size/mem_trace))
-    headers = Array{BinaryTraceHeader,1}(undef, ntraces)
+    headers = [BinaryTraceHeader() for _ = 1:ntraces]
 
-    # Get headers from chunk 
+    # Get headers from chunk
+    th = zeros(UInt8, 240)
     for i in 1:ntraces
-        headers[i] = read_traceheader(buf, keys, SegyIO.th_b2s)
+        read_traceheader!(buf, keys, SegyIO.th_b2s, headers[i]; th=th)
         skip(buf, mem_trace-240)
-    end 
-    
+    end
+
     # Get all requested header vectors
     vals = Dict{String, Array{Int32,1}}()
     for k in keys
@@ -29,7 +30,7 @@ function scan_shots!(s::IO, mem_chunk::Int, mem_trace::Int,
     sy = vals["SourceY"] 
     #combo = [[view(sx,i) view(sy,i)] for i in 1:ntraces]
     combo = [[sx[i] sy[i]] for i in 1:ntraces]
-    part = delim_vector(combo,1)
+    part = delim_vector(combo, 1)
     fl_eof ? push!(part, length(combo) + 1) : push!(part, ntraces + 1)
 
     # Summarise each shot