Remove common code

Author: Avik Pal

src/nnpack/NNPACK.jl

@@ -8,7 +8,9 @@ if !isfile(depsjl_path)
 end
 include(depsjl_path)
 
-const nnlib_interface_path = joinpath(dirname(@__FILE__), "nnlib.jl")
+const nnlib_interface_path = joinpath(dirname(@__FILE__), "interface.jl")
+global shared_threadpool = Ref(C_NULL)
+
 @init begin
     check_deps()
     status = nnp_initialize()
@@ -22,5 +24,5 @@ const nnlib_interface_path = joinpath(dirname(@__FILE__), "nnlib.jl")
     catch
         global NNPACK_CPU_THREADS = 4
     end
-    global shared_threadpool = Ref(pthreadpool_create(NNPACK_CPU_THREADS), 1)
+    global shared_threadpool = Ref(pthreadpool_create(NNPACK_CPU_THREADS))
 end

src/nnpack/nnlib.jl renamed to src/nnpack/interface.jl

@@ -1,47 +1,51 @@
+function check_support(x, k, pad, stride, dilation = 0)
+    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
+    pad_, stride_ = expand(Val{length(k)}, pad), expand(Val{length(k)}, stride)
+    ((size(x, 1) - k[1] + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - k[2] + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    return pad_, stride_
+end
+
 #NOTE: Commenting out the activation functions until sure what to do
 
-# relu(x::AA1) = nnp_relu_output(x, inplace ? x : similar(x), threadpool = shared_threadpool)
+# relu(x::AA1) = nnp_relu_output(x, inplace ? x : similar(x), threadpool = shared_threadpool[])
 
 # leakyrelu(x::AA1, a = oftype(x/1, 0.01)) =
-#     nnp_relu_output(x, inplace ? x : similar(x), negative_slope = a, threadpool = shared_threadpool)
+#     nnp_relu_output(x, inplace ? x : similar(x), negative_slope = a, threadpool = shared_threadpool[])
 
 softmax!(x::A) where A<:AbstractVecOrMat{Float64} = softmax!(Float32.(x))
 
 softmax!(x::A) where A<:AbstractVecOrMat{Float32} =
-    nnp_softmax_output(x, x, threadpool = shared_threadpool)
+    nnp_softmax_output(x, x, threadpool = shared_threadpool[])
 
 softmax!(y::A, x::A) where A<:AbstractVecOrMat{Float64} = softmax!(Float32.(y), Float32.(x))
 
 softmax!(y::A, x::A) where A<:AbstractVecOrMat{Float32} =
-    nnp_softmax_output(x, y, threadpool = shared_threadpool)
+    nnp_softmax_output(x, y, threadpool = shared_threadpool[])
 
 softmax(x::A) where A<:AbstractVecOrMat{Float64} = softmax(Float32.(x))
 
 softmax(x::A) where A<:AbstractVecOrMat{Float32} =
-    nnp_softmax_output(x, similar(x), threadpool = shared_threadpool)
+    nnp_softmax_output(x, similar(x), threadpool = shared_threadpool[])
 
 maxpool(x::A, k; pad = map(_->0,k), stride = k) where A<:AbstractArray{Float64, 4} =
     maxpool(Float32.(x), k, pad = pad, stride = stride)
 
 function maxpool(x::A, k; pad = map(_->0,k), stride = k) where A<:AbstractArray{Float32, 4}
-    pad_, stride_ = expand(Val{length(k)}, pad), expand(Val{length(k)}, stride)
-    ((size(x, 1) - k[1] + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - k[2] + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     maxpool!(similar(x, pdims(size(x), k, pad_, stride_)), x, k, pad = pad_, stride = stride_)
 end
 
 maxpool!(y::A, x::A, k; pad = map(_->0,k), stride = k) where A<:AbstractArray{Float64, 4} =
     maxpool!(Float32.(y), Float32.(x), k, pad = pad, stride = stride)
 
 maxpool!(y::A, x::A, k; pad = map(_->0,k), stride = k) where A<:AbstractArray{Float32, 4} =
-    nnp_max_pooling_output(x, y, k, padding = expand(Val{length(k)}, pad), stride = expand(Val{length(k)}, stride), threadpool = shared_threadpool)
+    nnp_max_pooling_output(x, y, k, padding = expand(Val{length(k)}, pad), stride = expand(Val{length(k)}, stride), threadpool = shared_threadpool[])
 
 conv(x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where A<:AbstractArray{Float64, 4} =
     conv(Float32.(x), Float32.(w), pad = pad, stride = stride, dilation = dilation, algo = algo)
 
 function conv(x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where A<:AbstractArray{Float32, 4}
-    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
-    pad_, stride_ = padtuple(x, pad), padtuple(x, stride)
-    ((size(x, 1) - size(w, 1) + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - size(w, 2) + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     y = similar(x, cdims(size(x), dilation_dims(w, dilation), pad_, stride_))
     b = zeros(Float32, size(y, 3))
     conv!(y, x, w, b, pad = pad_, stride = stride_, dilation = dilation, algo = UInt32(algo))
@@ -51,19 +55,15 @@ conv(x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) w
     conv(Float32.(x), Float32.(w), Float32.(b), pad = pad, stride = stride, dilation = dilation, algo = algo)
 
 function conv(x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where {A1<:AbstractArray{Float32, 4}, A2<:AbstractArray{Float32, 1}}
-    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
-    pad_, stride_ = padtuple(x, pad), padtuple(x, stride)
-    ((size(x, 1) - size(w, 1) + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - size(w, 2) + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     conv!(similar(x, cdims(size(x), dilation_dims(w, dilation), pad_, stride_)), x, w, b, pad = pad_, stride = stride_, dilation = dilation, algo = UInt32(algo))
 end
 
 crosscor(x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where {A1<:AbstractArray{Float64, 4}, A2<:AbstractArray{Float64, 1}} =
     crosscor(Float32.(x), Float32.(w), Float32.(b), pad = pad, stride = stride, dilation = dilation, algo = algo)
 
 function crosscor(x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where {A1<:AbstractArray{Float32, 4}, A2<:AbstractArray{Float32, 1}}
-    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
-    pad_, stride_ = padtuple(x, pad), padtuple(x, stride)
-    ((size(x, 1) - size(w, 1) + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - size(w, 2) + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     conv!(similar(x, cdims(size(x), dilation_dims(w, dilation), pad_, stride_)), x, w, b, pad = pad_, stride = stride_, dilation = dilation, algo = UInt32(algo), flipkernel = 1)
 end
 
@@ -72,7 +72,7 @@ conv!(y::A1, x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt
 
 function conv!(y::A1, x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0), flipkernel = 0) where {A1<:AbstractArray{Float32, 4}, A2<:AbstractArray{Float32, 1}}
     flipkernel == 0 && (w = reverse(reverse(w, dims=1), dims=2))
-    nnp_convolution_output(y, x, w, b, algo = algo, padding = pad, stride = stride, threadpool = shared_threadpool)
+    nnp_convolution_output(y, x, w, b, algo = algo, padding = pad, stride = stride, threadpool = shared_threadpool[])
 end
 
 crosscor!(y::A1, x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where {A1<:AbstractArray{Float64, 4}, A2<:AbstractArray{Float64, 1}} =
@@ -85,9 +85,7 @@ crosscor!(y::A1, x::A1, w::A1, b::A2; pad = 0, stride = 1, dilation = 1, algo =
     ∇conv_data(Float32.(dy), Float32.(x), Float32.(w), pad = pad, stride = stride, dilation = dilation, algo = algo)
 
 function ∇conv_data(dy::A, x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where A<:AbstractArray{Float32, 4}
-    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
-    pad_, stride_ = padtuple(x, pad), padtuple(x, stride)
-    ((size(x, 1) - size(w, 1) + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - size(w, 2) + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     ∇conv_data!(zeros(Float32, size(x)), dy, x, w; pad = pad_, stride = stride_, dilation = dilation, algo = UInt32(algo))
 end
 
@@ -96,16 +94,14 @@ end
 
 function ∇conv_data!(dx::A, dy::A, x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0), flipkernel = 0) where A<:AbstractArray{Float32, 4}
     flipkernel == 0 && (w = reverse(reverse(w, dims=1), dims=2))
-    nnp_convolution_input_gradient(dx, x, dy, w, padding = pad, stride = stride, algo = algo, threadpool = shared_threadpool)
+    nnp_convolution_input_gradient(dx, x, dy, w, padding = pad, stride = stride, algo = algo, threadpool = shared_threadpool[])
 end
 
 ∇conv_filter(dy::A, x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where A<:AbstractArray{Float64, 4} =
     ∇conv_filter(Float32.(dy), Float32.(x), Float32.(w), pad = pad, stride = stride, dilation = dilation, algo = algo)
 
 function ∇conv_filter(dy::A, x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0)) where A<:AbstractArray{Float32, 4}
-    dilation == 1 || dilation == (1, 1) || error("NNPACK does not support dilation > 1")
-    pad_, stride_ = padtuple(x, pad), padtuple(x, stride)
-    ((size(x, 1) - size(w, 1) + 2 * pad_[1]) % stride_[1] == 0 && (size(x, 2) - size(w, 2) + 2 * pad_[2]) % stride_[2] == 0) || error("Choose the stride, pad and kernel size properly")
+    pad_, stride_ = check_support(x, k, pad, stride)
     ∇conv_filter!(zeros(Float32, size(w)), dy, x, w; pad = pad_, stride = stride_, dilation = dilation, algo = UInt32(algo))
 end
 
@@ -114,6 +110,6 @@ end
 
 function ∇conv_filter!(dw::A, dy::A, x::A, w::A; pad = 0, stride = 1, dilation = 1, algo = UInt32(0), flipkernel = 0) where A<:AbstractArray{Float32, 4}
     flipkernel == 0 && (w = reverse(reverse(w, dims=1), dims=2))
-    dw .= nnp_convolution_kernel_gradient(dw, x, dy, w, padding = pad, stride = stride, algo = algo, threadpool = shared_threadpool)
+    dw .= nnp_convolution_kernel_gradient(dw, x, dy, w, padding = pad, stride = stride, algo = algo, threadpool = shared_threadpool[])
     flipkernel == 0 ? reverse(reverse(dw, dims=1), dims=2) : dw
 end