Use 'using' when we don't actually extend a method.

maleadt · maleadt · commit 9ae7b883d8d7 · 2019-09-27T14:09:35.000+02:00
diff --git a/src/blas/CUBLAS.jl b/src/blas/CUBLAS.jl
@@ -2,7 +2,7 @@ module CUBLAS
 
 using CUDAapi
 
-import CUDAdrv: CUDAdrv, CuContext, CuStream_t, CuPtr, PtrOrCuPtr, CU_NULL, devices
+using CUDAdrv: CUDAdrv, CuContext, CuStream_t, CuPtr, PtrOrCuPtr, CU_NULL, devices
 
 import CUDAnative
 
diff --git a/src/deprecated.jl b/src/deprecated.jl
@@ -1,6 +1,6 @@
 # Deprecated functionality
 
-import Base: @deprecate_binding
+using Base: @deprecate_binding
 
 @deprecate_binding BLAS CUBLAS
 @deprecate_binding FFT CUFFT
diff --git a/src/dnn/CUDNN.jl b/src/dnn/CUDNN.jl
@@ -3,7 +3,8 @@ module CUDNN
 using CUDAapi
 using CUDAapi: libraryPropertyType
 
-import CUDAdrv: CUDAdrv, CuContext, CuPtr, PtrOrCuPtr, CU_NULL, CuStream_t
+using CUDAdrv
+using CUDAdrv: CuContext, CuPtr, PtrOrCuPtr, CU_NULL, CuStream_t
 
 import CUDAnative
 
diff --git a/src/dnn/conv.jl b/src/dnn/conv.jl
@@ -1,4 +1,4 @@
-import NNlib: DenseConvDims
+using NNlib: DenseConvDims
 
 
 # descriptor
diff --git a/src/dnn/pooling.jl b/src/dnn/pooling.jl
@@ -1,4 +1,4 @@
-import NNlib: PoolDims
+using NNlib: PoolDims
 
 
 # descriptor
diff --git a/src/dnn/rnn.jl b/src/dnn/rnn.jl
@@ -8,7 +8,7 @@
 # GRU: [weight, bias] × [input, hidden] × [reset, update, newmem]
 # LSTM: [weight, bias] × [input, hidden] × [input, forget, newmem, output]
 
-import LinearAlgebra: copy_transpose!
+using LinearAlgebra: copy_transpose!
 
 function params(w::CuVector, input, hidden, n = 1)
   slice(offset, shape) = reshape(view(w, offset.+(1:prod(shape))), shape)
diff --git a/src/memory/binned.jl b/src/memory/binned.jl
@@ -17,7 +17,7 @@ module BinnedPool
 #                       or just use unified memory for all allocations.
 # - per-device pools
 
-import ..@pool_timeit, ..actual_alloc, ..actual_free
+using ..CuArrays: @pool_timeit, actual_alloc, actual_free
 
 using CUDAdrv
 
diff --git a/src/memory/dummy.jl b/src/memory/dummy.jl
@@ -2,7 +2,7 @@ module DummyPool
 
 # dummy allocator that passes through any requests, calling into the GC if that fails.
 
-import ..@pool_timeit, ..actual_alloc, ..actual_free
+using ..CuArrays: @pool_timeit, actual_alloc, actual_free
 
 using CUDAdrv
 
diff --git a/src/memory/simple.jl b/src/memory/simple.jl
@@ -2,7 +2,7 @@ module SimplePool
 
 # simple scan into a list of free buffers
 
-import ..@pool_timeit, ..actual_alloc, ..actual_free
+using ..CuArrays: @pool_timeit, actual_alloc, actual_free
 
 using CUDAdrv
 
diff --git a/src/memory/split.jl b/src/memory/split.jl
@@ -2,15 +2,16 @@ module SplittingPool
 
 # scan into a sorted list of free buffers, splitting buffers along the way
 
-import ..CuArrays, ..@pool_timeit
+using ..CuArrays
+using ..CuArrays: @pool_timeit
 
 using DataStructures
 
 using CUDAdrv
 
 # use a macro-version of Base.lock to avoid closures
 if VERSION >= v"1.3.0-DEV.555"
-    import Base.@lock
+    using Base: @lock
 else
     macro lock(l, expr)
         quote
diff --git a/src/nnlib.jl b/src/nnlib.jl
@@ -1,8 +1,5 @@
 using NNlib
-import NNlib: conv!, ∇conv_filter!, ∇conv_data!,
-  maxpool!, meanpool!, ∇maxpool!, ∇meanpool!,
-  softmax, softmax!, ∇softmax!, logsoftmax, logsoftmax!, ∇logsoftmax
-using CUDAnative
+
 
 # Activation functions
 @cufunc σ(x) = ifelse(x < -80, zero(x), one(x) / (one(x) + exp(-x)))
diff --git a/src/permuteddimsarray.jl b/src/permuteddimsarray.jl
@@ -1,4 +1,4 @@
-import Base. PermutedDimsArrays
+using Base: PermutedDimsArrays
 
 # PermutedDimsArrays' custom copyto! doesn't know how to deal with GPU arrays
 function PermutedDimsArrays._copy!(dest::PermutedDimsArray{T,N,<:Any,<:Any,<:GPUArray}, src) where {T,N}
diff --git a/src/solver/CUSOLVER.jl b/src/solver/CUSOLVER.jl
@@ -3,16 +3,16 @@ module CUSOLVER
 using ..CuArrays
 using ..CuArrays: libcusolver, active_context, _getindex, unsafe_free!
 
+using ..CUBLAS: cublasFillMode_t, cublasOperation_t, cublasSideMode_t, cublasDiagType_t
+using ..CUSPARSE: cusparseMatDescr_t
+
 using CUDAapi
 
 using CUDAdrv
 using CUDAdrv: CuStream_t
 
 import CUDAnative
 
-import ..CUBLAS: cublasFillMode_t, cublasOperation_t, cublasSideMode_t, cublasDiagType_t
-import ..CUSPARSE: cusparseMatDescr_t
-
 using CEnum
 
 include("libcusolver_common.jl")
diff --git a/src/solver/dense.jl b/src/solver/dense.jl
@@ -1,6 +1,6 @@
 # wrappers of the low-level dense CUSOLVER functionality
 
-import ..CUBLAS: cublasfill, cublasop, cublasside
+using ..CUBLAS: cublasfill, cublasop, cublasside
 
 using LinearAlgebra
 using LinearAlgebra: BlasInt, checksquare
diff --git a/src/solver/sparse.jl b/src/solver/sparse.jl
@@ -4,7 +4,10 @@ using SparseArrays
 
 using LinearAlgebra
 
-import ..CUSPARSE: CuSparseMatrixCSR, CuSparseMatrixCSC, cusparseindex, CUSPARSE_MATRIX_TYPE_GENERAL, CUSPARSE_FILL_MODE_LOWER, CUSPARSE_FILL_MODE_UPPER, CUSPARSE_DIAG_TYPE_NON_UNIT, CUSPARSE_DIAG_TYPE_UNIT, cusparseMatDescr
+using ..CUSPARSE: CuSparseMatrixCSR, CuSparseMatrixCSC, cusparseindex,
+                  CUSPARSE_MATRIX_TYPE_GENERAL, CUSPARSE_FILL_MODE_LOWER,
+                  CUSPARSE_FILL_MODE_UPPER, CUSPARSE_DIAG_TYPE_NON_UNIT,
+                  CUSPARSE_DIAG_TYPE_UNIT, cusparseMatDescr
 
 #csrlsvlu
 for (fname, elty, relty) in ((:cusolverSpScsrlsvluHost, :Float32, :Float32),
diff --git a/src/sparse/CUSPARSE.jl b/src/sparse/CUSPARSE.jl
@@ -6,7 +6,7 @@ using ..CuArrays: libcusparse, active_context, unsafe_free!
 using CUDAapi
 
 using CUDAdrv
-import CUDAdrv: CuStream_t
+using CUDAdrv: CuStream_t
 
 import CUDAnative
 
diff --git a/src/sparse/linalg.jl b/src/sparse/linalg.jl
@@ -1,30 +1,30 @@
 # integration with LinearAlgebra stdlib
 
 using LinearAlgebra
-import LinearAlgebra: BlasFloat, mul!
+using LinearAlgebra: BlasFloat
 
 Base.:(\)(A::Union{UpperTriangular{T, S},LowerTriangular{T, S}}, B::CuMatrix{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}}       = sm('N',A,B,'O')
 Base.:(\)(transA::Transpose{T, UpperTriangular{T, S}}, B::CuMatrix{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}} = sm('T',parent(transA),B,'O')
 Base.:(\)(transA::Transpose{T, LowerTriangular{T, S}}, B::CuMatrix{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}} = sm('T',parent(transA),B,'O')
 Base.:(\)(adjA::Adjoint{T, UpperTriangular{T, S}},B::CuMatrix{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}} = sm('C',parent(adjA),B,'O')
 Base.:(\)(adjA::Adjoint{T, LowerTriangular{T, S}},B::CuMatrix{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}} = sm('C',parent(adjA),B,'O')
 
-mul!(C::CuVector{T},A::CuSparseMatrix,B::CuVector) where {T} = mv!('N',one(T),A,B,zero(T),C,'O')
-mul!(C::CuVector{T},transA::Transpose{<:Any,<:CuSparseMatrix},B::CuVector) where {T} = mv!('T',one(T),parent(transA),B,zero(T),C,'O')
-mul!(C::CuVector{T},adjA::Adjoint{<:Any,<:CuSparseMatrix},B::CuVector) where {T} = mv!('C',one(T),parent(transA),B,zero(T),C,'O')
-mul!(C::CuVector{T},A::HermOrSym{T,<:CuSparseMatrix{T}},B::CuVector{T}) where T = mv!('N',one(T),A,B,zero(T),C,'O')
-mul!(C::CuVector{T},transA::Transpose{<:Any, <:HermOrSym{T,<:CuSparseMatrix{T}}},B::CuVector{T}) where {T} = mv!('T',one(T),parent(transA),B,zero(T),C,'O')
-mul!(C::CuVector{T},adjA::Adjoint{<:Any, <:HermOrSym{T,<:CuSparseMatrix{T}}},B::CuVector{T}) where {T} = mv!('C',one(T),parent(adjA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},A::CuSparseMatrix,B::CuVector) where {T} = mv!('N',one(T),A,B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},transA::Transpose{<:Any,<:CuSparseMatrix},B::CuVector) where {T} = mv!('T',one(T),parent(transA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},adjA::Adjoint{<:Any,<:CuSparseMatrix},B::CuVector) where {T} = mv!('C',one(T),parent(transA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},A::HermOrSym{T,<:CuSparseMatrix{T}},B::CuVector{T}) where T = mv!('N',one(T),A,B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},transA::Transpose{<:Any, <:HermOrSym{T,<:CuSparseMatrix{T}}},B::CuVector{T}) where {T} = mv!('T',one(T),parent(transA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuVector{T},adjA::Adjoint{<:Any, <:HermOrSym{T,<:CuSparseMatrix{T}}},B::CuVector{T}) where {T} = mv!('C',one(T),parent(adjA),B,zero(T),C,'O')
 
-mul!(C::CuMatrix{T},A::CuSparseMatrix{T},B::CuMatrix{T}) where {T} = mm2!('N','N',one(T),A,B,zero(T),C,'O')
-mul!(C::CuMatrix{T},A::CuSparseMatrix{T},transB::Transpose{<:Any, CuMatrix{T}})  where {T} = mm2!('N','T',one(T),A,parent(transB),zero(T),C,'O')
-mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:CuSparseMatrix{T}},B::CuMatrix{T})  where {T} = mm2!('T','N',one(T),parent(transA),B,zero(T),C,'O')
-mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:CuSparseMatrix{T}},transB::Transpose{<:Any, CuMatrix{T}}) where {T} = mm2!('T','T',one(T),parent(transA),parent(transB),zero(T),C,'O')
-mul!(C::CuMatrix{T},adjA::Adjoint{<:Any, <:CuSparseMatrix{T}},B::CuMatrix{T})  where {T} = mm2!('C','N',one(T),parent(adjA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},A::CuSparseMatrix{T},B::CuMatrix{T}) where {T} = mm2!('N','N',one(T),A,B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},A::CuSparseMatrix{T},transB::Transpose{<:Any, CuMatrix{T}})  where {T} = mm2!('N','T',one(T),A,parent(transB),zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:CuSparseMatrix{T}},B::CuMatrix{T})  where {T} = mm2!('T','N',one(T),parent(transA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:CuSparseMatrix{T}},transB::Transpose{<:Any, CuMatrix{T}}) where {T} = mm2!('T','T',one(T),parent(transA),parent(transB),zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},adjA::Adjoint{<:Any, <:CuSparseMatrix{T}},B::CuMatrix{T})  where {T} = mm2!('C','N',one(T),parent(adjA),B,zero(T),C,'O')
 
-mul!(C::CuMatrix{T},A::HermOrSym{<:Number, <:CuSparseMatrix},B::CuMatrix) where {T} = mm!('N',one(T),A,B,zero(T),C,'O')
-mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:HermOrSym{<:Number, <:CuSparseMatrix}},B::CuMatrix) where {T} = mm!('T',one(T),parent(transA),B,zero(T),C,'O')
-mul!(C::CuMatrix{T},adjA::Adjoint{<:Any, <:HermOrSym{<:Number, <:CuSparseMatrix}},B::CuMatrix) where {T} = mm!('C',one(T),parent(adjA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},A::HermOrSym{<:Number, <:CuSparseMatrix},B::CuMatrix) where {T} = mm!('N',one(T),A,B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},transA::Transpose{<:Any, <:HermOrSym{<:Number, <:CuSparseMatrix}},B::CuMatrix) where {T} = mm!('T',one(T),parent(transA),B,zero(T),C,'O')
+LinearAlgebra.mul!(C::CuMatrix{T},adjA::Adjoint{<:Any, <:HermOrSym{<:Number, <:CuSparseMatrix}},B::CuMatrix) where {T} = mm!('C',one(T),parent(adjA),B,zero(T),C,'O')
 
 Base.:(\)(A::Union{UpperTriangular{T, S},LowerTriangular{T, S}}, B::CuVector{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}}       = sv2('N',A,B,'O')
 Base.:(\)(transA::Transpose{T, UpperTriangular{T, S}},B::CuVector{T}) where {T<:BlasFloat, S<:AbstractCuSparseMatrix{T}} = sv2('T',parent(transA),B,'O')

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import NNlib: DenseConvDims`
	`1`	`+using NNlib: DenseConvDims`
`2`	`2`
`3`	`3`
`4`	`4`	`# descriptor`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import NNlib: PoolDims`
	`1`	`+using NNlib: PoolDims`
`2`	`2`
`3`	`3`
`4`	`4`	`# descriptor`