move Info to C interface (#268)

Author: simonbyrne

src/MPI.jl

@@ -11,6 +11,11 @@ end
     isfile(depfile) || error("MPI not properly installed. Please run Pkg.build(\"MPI\")")
 end
 
+macro mpichk(expr)
+    esc(expr)
+end
+
+
 include(depfile)
 
 include("mpi-base.jl")

src/mpi-base.jl

@@ -206,6 +206,9 @@ function Init()
     end
     ccall(MPI_INIT, Nothing, (Ref{Cint},), 0)
     atexit(refcount_dec)
+
+    # initialise constants
+    INFO_NULL.cinfo = CInfo(MPI_INFO_NULL)
 end
 
 """
@@ -1728,11 +1731,11 @@ function Comm_get_parent()
 end
 
 function Comm_spawn(command::String, argv::Vector{String}, nprocs::Integer,
-                    comm::Comm, errors = Vector{Cint}(undef, nprocs))
+                    comm::Comm, errors = Vector{Cint}(undef, nprocs); kwargs...)
     c_intercomm = Ref{CComm}()
     ccall((:MPI_Comm_spawn, libmpi), Nothing,
          (Cstring, Ptr{Ptr{Cchar}}, Cint, CInfo, Cint, CComm, Ref{CComm}, Ptr{Cint}),
-         command, argv, nprocs, CInfo(INFO_NULL), 0, CComm(comm), c_intercomm, errors)
+         command, argv, nprocs, Info(kwargs...), 0, CComm(comm), c_intercomm, errors)
     return Comm(c_intercomm[])
 end
 
@@ -1829,13 +1832,6 @@ if HAVE_MPI_COMM_C2F
     function Comm(ccomm::CComm)
       Comm(ccall((:MPI_Comm_c2f, libmpi), Cint, (CComm,), ccomm))
     end
-    # Assume info is treated the same way
-    function CInfo(info::Info)
-      ccall((:MPI_Info_f2c, libmpi), CInfo, (Cint,), info.val)
-    end
-    function Info(cinfo::CInfo)
-      Info(ccall((:MPI_Info_c2f, libmpi), Cint, (CInfo,), cinfo))
-    end
 elseif sizeof(CComm) == sizeof(Cint)
     # in MPICH, both C and Fortran use identical Cint comm handles
     # and MPI_Comm_c2f is not provided.
@@ -1845,12 +1841,6 @@ elseif sizeof(CComm) == sizeof(Cint)
     function Comm(ccomm::CComm)
       Comm(reinterpret(Cint, ccomm))
     end
-    function CInfo(info::Info)
-      reinterpret(CInfo, info.val)
-    end
-    function Info(cinfo::CInfo)
-      Info(reinterpret(Cint, cinfo))
-    end
 else
     @warn("No MPI_Comm_c2f found - conversion to/from MPI.CComm will not work")
 end

src/mpi-info.jl

@@ -26,41 +26,67 @@ If `init=false` is used in the costructor (the default), a "null" `Info` object
 returned: no keys can be added to such an object.
 """
 mutable struct Info <: AbstractDict{Symbol,String}
-    val::Cint
+    cinfo::CInfo
+
+    function Info(cinfo::CInfo)
+        new(cinfo)
+    end
     function Info(;init=false)
-        info = new(MPI_INFO_NULL)
+        info = Info(INFO_NULL.cinfo)
         if init
-            ccall(MPI_INFO_CREATE, Nothing, (Ptr{Cint}, Ref{Cint}), info, 0)
+            @mpichk ccall((:MPI_Info_create, libmpi), Cint, (Ptr{CInfo},), info)
             refcount_inc()
             finalizer(free, info)
         end
         return info
     end
 end
 
-# allows us to pass Info objects directly into Ptr{Cint} ccall signatures
-function Base.unsafe_convert(::Type{Ptr{Cint}}, info::Info)
-    convert(Ptr{Cint}, pointer_from_objref(info))
+# allows us to pass Info objects directly into CInfo ccall signatures
+function Base.cconvert(::Type{CInfo}, info::Info)
+    info.cinfo
+end
+# allows us to pass Info objects directly into Ptr{CInfo} ccall signatures
+function Base.unsafe_convert(::Type{Ptr{CInfo}}, info::Info)
+    convert(Ptr{CInfo}, pointer_from_objref(info))
 end
 
+if HAVE_MPI_COMM_C2F
+    # Assume info is treated the same way
+    function CInfo(finfo::Cint)
+        ccall((:MPI_Info_f2c, libmpi), CInfo, (Cint,), finfo)
+    end
+
+    # only used for use with Fortran API
+    # can be removed once we have switched to C API
+    function Base.cconvert(::Type{Ptr{Cint}}, info::Info)
+        Ref(ccall((:MPI_Info_c2f, libmpi), Cint, (CInfo,), info.cinfo))
+    end
+else
+    function CInfo(finfo::Cint)
+        reinterpret(CInfo, finfo)
+    end
+    function Base.cconvert(::Type{Ptr{Cint}}, info::Info)
+        Ref(reinterpret(Cint, info.cinfo))
+    end
+end
+
+const INFO_NULL = Info(Ref{CInfo}()[]) # get an arbitrary bit-pattern: this will be set correctly at Init time
+
 function free(info::Info)
-    if info.val != MPI_INFO_NULL
-        ccall(MPI_INFO_FREE, Nothing, (Ptr{Cint}, Ref{Cint}), info, 0)
+    if info.cinfo != INFO_NULL.cinfo
+        @mpichk ccall((:MPI_Info_free, libmpi), Cint, (Ptr{CInfo},), info)
         refcount_dec()
     end
     return nothing
 end
 
-const INFO_NULL = Info(init=false)
-
-# the info functions assume that Fortran hidden arguments are placed at the end of the argument list
 function Base.setindex!(info::Info, value::AbstractString, key::Symbol)
     skey = String(key)
     @assert isascii(skey) && isascii(value) &&
         length(skey) <= MPI_MAX_INFO_KEY && length(value) <= MPI_MAX_INFO_VAL
-    ccall(MPI_INFO_SET, Nothing,
-          (Ptr{Cint}, Ptr{UInt8}, Ptr{UInt8}, Ref{Cint}, Csize_t, Csize_t),
-          info, skey, value, 0, sizeof(skey), sizeof(value))
+    @mpichk ccall((:MPI_Info_set, libmpi), Cint,
+          (CInfo, Cstring, Cstring), info, skey, value)
 end
 
 Base.setindex!(info::Info, value::Any, key::Symbol) = info[key] = infoval(value)
@@ -90,49 +116,49 @@ end
 function Base.getindex(info::Info, key::Symbol)
     skey = String(key)
     @assert isascii(skey) && length(skey) <= MPI_MAX_INFO_KEY
-    keyexists = Ref{Cint}()
-    len       = Ref{Cint}()
-    ccall(MPI_INFO_GET_VALUELEN, Nothing,
-          (Ptr{Cint}, Ptr{UInt8}, Ptr{Cint}, Ptr{Cint}, Ref{Cint}, Csize_t),
-          info, skey, len, keyexists, 0, sizeof(skey))
+    valuelen = Ref{Cint}()
+    flag = Ref{Cint}()
+    @mpichk ccall((:MPI_Info_get_valuelen, libmpi), Cint,
+          (CInfo, Cstring, Ptr{Cint}, Ptr{Cint}),
+          info, skey, valuelen, flag)
 
-    if keyexists[] == 0
+    if flag[] == 0
         throw(KeyError(key))
     end
 
-    buffer = Vector{UInt8}(undef, len[])
-    ccall(MPI_INFO_GET, Nothing,
-          (Ptr{Cint}, Ptr{UInt8}, Ptr{Cint}, Ptr{UInt8}, Ptr{Cint}, Ref{Cint}, Csize_t, Csize_t),
-          info, skey, len, buffer, keyexists, 0, sizeof(skey), sizeof(buffer))
+    n = valuelen[]
+    buffer = Vector{UInt8}(undef, n)
+    @mpichk ccall((:MPI_Info_get, libmpi), Cint,
+          (CInfo, Cstring, Cint, Ptr{UInt8}, Ptr{Cint}),
+          info, skey, n, buffer, flag)
     return String(buffer)
 end
 
 function Base.delete!(info::Info,key::Symbol)
     skey = String(key)
     @assert isascii(skey) && length(skey) <= MPI_MAX_INFO_KEY
-    ccall(MPI_INFO_DELETE, Nothing,
-          (Ptr{Cint}, Ptr{UInt8}, Ref{Cint}, Csize_t),
-          info, skey, 0, sizeof(skey))
+    @mpichk ccall((:MPI_Info_delete, libmpi), Cint,
+          (CInfo, Cstring), info, skey)
 end
 
 function Base.length(info::Info)
-    if info.val == MPI_INFO_NULL
+    if info.cinfo == INFO_NULL.cinfo
         return 0
     end
     nkeys = Ref{Cint}()
-    ccall(MPI_INFO_GET_NKEYS, Nothing,
-          (Ptr{Cint}, Ptr{Cint}, Ref{Cint}),
-          info, nkeys, 0)
+    @mpichk ccall((:MPI_Info_get_nkeys, libmpi), Cint,
+                   (CInfo, Ptr{Cint}), info, nkeys)
     return Int(nkeys[])
 end
 
 function nthkey(info::Info, n::Integer)
     buffer = Vector{UInt8}(undef, MPI_MAX_INFO_KEY)
-    ccall(MPI_INFO_GET_NTHKEY, Nothing,
-          (Ptr{Cint}, Ref{Cint}, Ptr{UInt8}, Ref{Cint}, Csize_t),
-          info, n, buffer, 0, length(buffer))
-    i = findlast(!isequal(UInt8(' ')), buffer)
-    resize!(buffer, i)
+    @mpichk ccall((:MPI_Info_get_nthkey, libmpi), Cint,
+                  (CInfo, Cint, Ptr{UInt8}), info, n, buffer)
+    i = findfirst(isequal(UInt8(0)), buffer)
+    if i !== nothing
+        resize!(buffer, i-1)
+    end
     Symbol(buffer)
 end
 

test/test_info.jl

@@ -5,12 +5,12 @@ MPI.Init()
 
 info = MPI.Info()
 @test typeof(info) == MPI.Info
-@test info.val == MPI.MPI_INFO_NULL
+@test info.cinfo == MPI.CInfo(MPI.MPI_INFO_NULL)
 
 testinfo(;kwargs...) = MPI.Info(kwargs...)
 
 info = testinfo(foo="fast", bar=true, baz=[10, -2])
-@test info.val != MPI.MPI_INFO_NULL
+@test info.cinfo !=  MPI.CInfo(MPI.MPI_INFO_NULL)
 
 @test length(info) == 3
 @test info[:foo] == "fast"
@@ -22,6 +22,7 @@ delete!(info, :bar)
 @test_throws KeyError info[:bar]
 
 MPI.free(info)
-@test info.val == MPI.MPI_INFO_NULL
+@test info.cinfo ==  MPI.CInfo(MPI.MPI_INFO_NULL)
 
 MPI.Finalize()
+@test MPI.Finalized()