An idea for using ccall less in BigFloat operations

nsajko · January 10, 2023, 1:15pm

I got an idea for a way to slightly decrease the ccall-ing of libmpfr within the Base.MPFR module, which implements BigFloat.

Julia defines the BigFloat type as a mutable struct with a number of fields, and it seems like it could be worthwhile to mutate the fields directly in more places withing mpfr.jl, instead of calling C:

github.com

JuliaLang/julia/blob/6deb98f56ef3c2b6ff3d4364c966c26e43895da6/base/mpfr.jl#L90-L96


      
          mutable struct BigFloat <: AbstractFloat
              prec::Clong
              sign::Cint
              exp::Clong
              d::Ptr{Limb}
              # _d::Buffer{Limb} # Julia gc handle for memory @ d
              _d::String # Julia gc handle for memory @ d (optimized)

For example, currently the method -(::BigFloat) in mpfr.jl ccalls mpfr_neg:

github.com

JuliaLang/julia/blob/6deb98f56ef3c2b6ff3d4364c966c26e43895da6/base/mpfr.jl#L616-L620


      
          function -(x::BigFloat)
              z = BigFloat()
              ccall((:mpfr_neg, :libmpfr), Int32, (Ref{BigFloat}, Ref{BigFloat}, MPFRRoundingMode), z, x, ROUNDING_MODE[])
              return z
          end

The ccall overhead seems unnecessary however, as all that’s necessary for implementing -(::BigFloat) is copying the contents and, flipping the sign field of the copy, and returning the copy.

The trouble is with the BigFloat field that holds the mantissa, _d. It’s a String, an immutable type, and I’m not sure how to safely copy an immutable object that’s going to be mutated by non-Julia code later. It seems an implementation of such a copy method already exists here, but I don’t understand it or feel comfortable adapting the code:

github.com

JuliaLang/julia/blob/6deb98f56ef3c2b6ff3d4364c966c26e43895da6/base/mpfr.jl#L1083-L1092


      
          function Base.deepcopy_internal(x::BigFloat, stackdict::IdDict)
              get!(stackdict, x) do
                  # d = copy(x._d)
                  d = x._d
                  d′ = GC.@preserve d unsafe_string(pointer(d), sizeof(d)) # creates a definitely-new String
                  y = _BigFloat(x.prec, x.sign, x.exp, d′)
                  #ccall((:mpfr_custom_move,:libmpfr), Cvoid, (Ref{BigFloat}, Ptr{Limb}), y, d) # unnecessary
                  return y
              end
          end

If anyone get’s around to improving -(::BigFloat) in this manner, it would probably also make sense to add abs(::BigFloat), implemented analogously. Similarly for functions that only modify the exponent.