Padding of type UInt8 is not compatible

[freddycct]

b = Dict{Tuple{UInt8, Int}, Int}((1, 2) => 10)
BSON.@save "tmp.bson" b

results in

Padding of type UInt8 is not compatible with type Tuple{UInt8, Int64}.

check_readable@reinterpretarray.jl:184[inlined]
getindex@reinterpretarray.jl:342[inlined]
iterate@abstractarray.jl:1167[inlined]
iterate@abstractarray.jl:1165[inlined]
reinterpret_(::Type{UInt8}, ::Vector{Tuple{UInt8, Int64}})@extensions.jl:93
lower@extensions.jl:98[inlined]
_lower_recursive(::Vector{Tuple{UInt8, Int64}}, ::IdDict{Any, Any}, ::Vector{Any})@write.jl:66
(::BSON.var"#5#9"{IdDict{Any, Any}, Vector{Any}})(::Vector{Tuple{UInt8, Int64}})@write.jl:66
applychildren!(::BSON.var"#5#9"{IdDict{Any, Any}, Vector{Any}}, ::Vector{Any})@BSON.jl:26

[hhaensel]

Same problem here:

julia> bson(IOBuffer(), Dict(:mol => [(1, true)]))
x = Tuple{Int64, Bool}[(1, 1)]
ERROR: Padding of type UInt8 is not compatible with type Tuple{Int64, Bool}.
Stacktrace:
  [1] check_readable
    @ ./reinterpretarray.jl:228 [inlined]
  [2] getindex
    @ ./reinterpretarray.jl:400 [inlined]
  [3] iterate
    @ ./abstractarray.jl:1209 [inlined]
  [4] iterate
    @ ./abstractarray.jl:1207 [inlined]
  [5] reinterpret_
    @ ~/.julia/packages/BSON/mzJoC/src/extensions.jl:93 [inlined]
  [6] lower(x::Vector{Tuple{Int64, Bool}})
    @ BSON ~/.julia/dev/BSON/src/extensions.jl:99
  [7] _lower_recursive(x::Vector{Tuple{Int64, Bool}}, cache::IdDict{Any, Any}, refs::Vector{Any})
    @ BSON ~/.julia/dev/BSON/src/write.jl:66
  [8] (::BSON.var"#5#9"{IdDict{Any, Any}, Vector{Any}})(x::Vector{Tuple{Int64, Bool}})
    @ BSON ~/.julia/packages/BSON/mzJoC/src/write.jl:66
  [9] applychildren!(f::BSON.var"#5#9"{IdDict{Any, Any}, Vector{Any}}, x::Dict{Symbol, Any})
    @ BSON ~/.julia/dev/BSON/src/BSON.jl:19
 [10] _lower_recursive(x::Dict{Symbol, Vector{Tuple{Int64, Bool}}}, cache::IdDict{Any, Any}, refs::Vector{Any})
    @ BSON ~/.julia/dev/BSON/src/write.jl:66
 [11] lower_recursive(y::Dict{Symbol, Vector{Tuple{Int64, Bool}}})
    @ BSON ~/.julia/dev/BSON/src/write.jl:77
 [12] bson(io::IOBuffer, doc::Dict{Symbol, Vector{Tuple{Int64, Bool}}})
    @ BSON ~/.julia/dev/BSON/src/write.jl:85
 [13] top-level scope
    @ REPL[251]:1

[hhaensel]

It's not BSON's fault, most probably:

julia> reinterpret(UInt8, [(1,true)])
16-element reinterpret(UInt8, ::Vector{Tuple{Int64, Bool}}):
Error showing value of type Base.ReinterpretArray{UInt8, 1, Tuple{Int64, Bool}, Vector{Tuple{Int64, Bool}}, false}:
ERROR: Padding of type UInt8 is not compatible with type Tuple{Int64, Bool}.
Stacktrace:
  [1] check_readable
    @ ./reinterpretarray.jl:228 [inlined]
  [2] getindex
    @ ./reinterpretarray.jl:400 [inlined]
  [3] _getindex
    @ ./abstractarray.jl:1341 [inlined]
  [4] getindex(::Base.ReinterpretArray{UInt8, 1, Tuple{Int64, Bool}, Vector{Tuple{Int64, Bool}}, false}, ::Int64, ::Int64)
    @ Base ./abstractarray.jl:1312
  [5] alignment(io::IOContext{Base.TTY}, X::AbstractVecOrMat, rows::Vector{Int64}, cols::Vector{Int64}, cols_if_complete::Int64, cols_otherwise::Int64, sep::Int64, ncols::Int64)
    @ Base ./arrayshow.jl:69

[hhaensel]

A possible workaround is to use unsafe_wrap() instead of reinterpret() if accessing the reinterpreted array fails.
I'll submit a PR for review.

[hhaensel]

While this is not reviewed or merged, you could add your own method - with some type piracy, but without loosing precompilability. That's how I fixed this for a private project.

const WARN_PADDING = Ref(false)
function BSON.reinterpret_(::Type{T}, x::Vector{<:Tuple}) where T
    r = reinterpret(T, x)
    if r isa Base.ReinterpretArray && !(r.readable)
      # type mapping was successful, but the array is not readable due to padding
      # in that case make use unsafe_wrap() to map the data 
      # the data might not be restorable on a different machine with different padding or with a different version of Julia
      WARN_PADDING[] && @warn """
      Storing structure with padding, data might not be restorable.\n
      To suppress this warning, set $(@__MODULE__).WARN_PADDING[] = false.
      """
      GC.@preserve x begin
        a = unsafe_wrap(Vector{T}, Ptr{T}(pointer(x)), sizeof(x) ÷ sizeof(T))
        T[_x for _x in a]
      end
    else
        T[_x for _x in r]
    end
end