refactor CUDA kernel defs

Author: pluskid

src/cuda/backend.jl

@@ -1,158 +1,115 @@
 export GPUBackend
 
-type MochaKernels
-  mod :: CUDA.CuModule
-
-  # implemented kernels
-  logistic_loss_forward_float  :: CUDA.CuFunction
-  logistic_loss_forward_double :: CUDA.CuFunction
-  softmax_loss_backward_float  :: CUDA.CuFunction
-  softmax_loss_backward_double :: CUDA.CuFunction
-  relu_forward_float           :: CUDA.CuFunction
-  relu_forward_double          :: CUDA.CuFunction
-  relu_backward_float          :: CUDA.CuFunction
-  relu_backward_double         :: CUDA.CuFunction
-  sigmoid_forward_float        :: CUDA.CuFunction
-  sigmoid_forward_double       :: CUDA.CuFunction
-  sigmoid_backward_float       :: CUDA.CuFunction
-  sigmoid_backward_double      :: CUDA.CuFunction
-  accuracy_forward_float       :: CUDA.CuFunction
-  accuracy_forward_double      :: CUDA.CuFunction
-  argmax_forward_float         :: CUDA.CuFunction
-  argmax_forward_double        :: CUDA.CuFunction
-
-  add_scal_float               :: CUDA.CuFunction
-  add_scal_double              :: CUDA.CuFunction
-  mul_scal_float               :: CUDA.CuFunction
-  mul_scal_double              :: CUDA.CuFunction
-  elem_add_float               :: CUDA.CuFunction
-  elem_add_double              :: CUDA.CuFunction
-  elem_mul_float               :: CUDA.CuFunction
-  elem_mul_double              :: CUDA.CuFunction
-  elem_sub_float               :: CUDA.CuFunction
-  elem_sub_double              :: CUDA.CuFunction
-  elem_div_float               :: CUDA.CuFunction
-  elem_div_double              :: CUDA.CuFunction
-  elem_div2_float              :: CUDA.CuFunction
-  elem_div2_double             :: CUDA.CuFunction
-  elem_pow_fi                  :: CUDA.CuFunction
-  elem_pow_di                  :: CUDA.CuFunction
-  elem_pow_ff                  :: CUDA.CuFunction
-  elem_pow_dd                  :: CUDA.CuFunction
-
-  max_channel_pooling_forward_float   :: CUDA.CuFunction
-  max_channel_pooling_forward_double  :: CUDA.CuFunction
-  max_channel_pooling_backward_float  :: CUDA.CuFunction
-  max_channel_pooling_backward_double :: CUDA.CuFunction
-
-  dense_to_padded_float        :: CUDA.CuFunction
-  dense_to_padded_double       :: CUDA.CuFunction
-  padded_to_dense_float        :: CUDA.CuFunction
-  padded_to_dense_double       :: CUDA.CuFunction
-
-  copy_to_shifted_float        :: CUDA.CuFunction
-  copy_to_shifted_double       :: CUDA.CuFunction
-  copy_from_shifted_float      :: CUDA.CuFunction
-  copy_from_shifted_double     :: CUDA.CuFunction
-
-  dropout_init                 :: CUDA.CuFunction
-  dropout_alloc_size           :: CUDA.CuFunction
-  dropout_forward_float        :: CUDA.CuFunction
-  dropout_forward_double       :: CUDA.CuFunction
-  dropout_backward_float       :: CUDA.CuFunction
-  dropout_backward_double      :: CUDA.CuFunction
-
-  l1_forward_float             :: CUDA.CuFunction
-  l1_forward_double            :: CUDA.CuFunction
-  l1_backward_float            :: CUDA.CuFunction
-  l1_backward_double           :: CUDA.CuFunction
-
-  MochaKernels() = begin
-    mod_dir = joinpath(dirname(@__FILE__), "kernels")
-    mod_path = joinpath(mod_dir, "kernels.ptx")
-
-    # check that our module is up-to-date
-    if !isfile(mod_path)
-      error("Mocha CUDA kernels not found, see the documents of BACKEND on how to compile the kernels")
-    else
-      mod_mtime = stat(mod_path).mtime
-      impl_files = glob(mod_dir, r".*.impl$")
-      for i = 1:length(impl_files)
-        if stat(joinpath(mod_dir, impl_files[i])).mtime > mod_mtime
-          error("Mocha CUDA kernels not up-to-date. Please re-compile (see documents of BACKEND)")
+macro defkernels(kernels...)
+  field_defs = map(kernels) do ker
+    :($ker :: CUDA.CuFunction)
+  end
+  type_body = Expr(:block, field_defs...)
+
+  field_inits = map(kernels) do ker
+    :(kernels.$ker = CUDA.CuFunction(mod, $(string(ker))))
+  end
+  field_init_block = Expr(:block, field_inits...)
+
+  quote
+    type $(esc(:MochaKernels))
+      mod :: CUDA.CuModule
+
+      $type_body
+
+      $(esc(:MochaKernels))() = begin
+        mod_dir = joinpath(dirname(@__FILE__), "kernels")
+        mod_path = joinpath(mod_dir, "kernels.ptx")
+
+        # check that our module is up-to-date
+        if !isfile(mod_path)
+          error("Mocha CUDA kernels not found, see the documents of BACKEND on how to compile the kernels")
+        else
+          mod_mtime = stat(mod_path).mtime
+          impl_files = glob(mod_dir, r".*.impl$")
+          for i = 1:length(impl_files)
+            if stat(joinpath(mod_dir, impl_files[i])).mtime > mod_mtime
+              error("Mocha CUDA kernels not up-to-date. Please re-compile (see documents of BACKEND)")
+            end
+          end
         end
+
+        mod = CUDA.CuModule(mod_path)
+        kernels = new(mod)
+
+        $field_init_block
+
+        return kernels
       end
     end
-
-    mod = CUDA.CuModule(mod_path)
-    kernels = new(mod)
-
-    kernels.logistic_loss_forward_float = CUDA.CuFunction(mod, "logistic_loss_forward_float")
-    kernels.logistic_loss_forward_double = CUDA.CuFunction(mod, "logistic_loss_forward_double")
-    kernels.softmax_loss_backward_float = CUDA.CuFunction(mod, "softmax_loss_backward_float")
-    kernels.softmax_loss_backward_double = CUDA.CuFunction(mod, "softmax_loss_backward_double")
-    kernels.relu_forward_float = CUDA.CuFunction(mod, "relu_forward_float")
-    kernels.relu_forward_double = CUDA.CuFunction(mod, "relu_forward_double")
-    kernels.relu_backward_float = CUDA.CuFunction(mod, "relu_backward_float")
-    kernels.relu_backward_double = CUDA.CuFunction(mod, "relu_backward_double")
-    kernels.sigmoid_forward_float = CUDA.CuFunction(mod, "sigmoid_forward_float")
-    kernels.sigmoid_forward_double = CUDA.CuFunction(mod, "sigmoid_forward_double")
-    kernels.sigmoid_backward_float = CUDA.CuFunction(mod, "sigmoid_backward_float")
-    kernels.sigmoid_backward_double = CUDA.CuFunction(mod, "sigmoid_backward_double")
-    kernels.accuracy_forward_float = CUDA.CuFunction(mod, "accuracy_forward_float")
-    kernels.accuracy_forward_double = CUDA.CuFunction(mod, "accuracy_forward_double")
-    kernels.argmax_forward_float = CUDA.CuFunction(mod, "argmax_forward_float")
-    kernels.argmax_forward_double = CUDA.CuFunction(mod, "argmax_forward_double")
-
-    kernels.add_scal_float   = CUDA.CuFunction(mod, "add_scal_float")
-    kernels.add_scal_double  = CUDA.CuFunction(mod, "add_scal_double")
-    kernels.mul_scal_float   = CUDA.CuFunction(mod, "mul_scal_float")
-    kernels.mul_scal_double  = CUDA.CuFunction(mod, "mul_scal_double")
-    kernels.elem_add_float   = CUDA.CuFunction(mod, "elem_add_float")
-    kernels.elem_add_double  = CUDA.CuFunction(mod, "elem_add_double")
-    kernels.elem_mul_float   = CUDA.CuFunction(mod, "elem_mul_float")
-    kernels.elem_mul_double  = CUDA.CuFunction(mod, "elem_mul_double")
-    kernels.elem_sub_float   = CUDA.CuFunction(mod, "elem_sub_float")
-    kernels.elem_sub_double  = CUDA.CuFunction(mod, "elem_sub_double")
-    kernels.elem_div_float   = CUDA.CuFunction(mod, "elem_div_float")
-    kernels.elem_div_double  = CUDA.CuFunction(mod, "elem_div_double")
-    kernels.elem_div2_float  = CUDA.CuFunction(mod, "elem_div2_float")
-    kernels.elem_div2_double = CUDA.CuFunction(mod, "elem_div2_double")
-    kernels.elem_pow_fi      = CUDA.CuFunction(mod, "elem_pow_fi")
-    kernels.elem_pow_di      = CUDA.CuFunction(mod, "elem_pow_di")
-    kernels.elem_pow_ff      = CUDA.CuFunction(mod, "elem_pow_ff")
-    kernels.elem_pow_dd      = CUDA.CuFunction(mod, "elem_pow_dd")
-
-    kernels.max_channel_pooling_forward_float   = CUDA.CuFunction(mod, "max_channel_pooling_forward_float")
-    kernels.max_channel_pooling_forward_double  = CUDA.CuFunction(mod, "max_channel_pooling_forward_double")
-    kernels.max_channel_pooling_backward_float  = CUDA.CuFunction(mod, "max_channel_pooling_backward_float")
-    kernels.max_channel_pooling_backward_double = CUDA.CuFunction(mod, "max_channel_pooling_backward_double")
-
-    kernels.dense_to_padded_float  = CUDA.CuFunction(mod, "dense_to_padded_float")
-    kernels.dense_to_padded_double = CUDA.CuFunction(mod, "dense_to_padded_double")
-    kernels.padded_to_dense_float  = CUDA.CuFunction(mod, "padded_to_dense_float")
-    kernels.padded_to_dense_double = CUDA.CuFunction(mod, "padded_to_dense_double")
-
-    kernels.copy_to_shifted_float    = CUDA.CuFunction(mod, "copy_to_shifted_float")
-    kernels.copy_to_shifted_double   = CUDA.CuFunction(mod, "copy_to_shifted_double")
-    kernels.copy_from_shifted_float  = CUDA.CuFunction(mod, "copy_from_shifted_float")
-    kernels.copy_from_shifted_double = CUDA.CuFunction(mod, "copy_from_shifted_double")
-
-    kernels.dropout_init            = CUDA.CuFunction(mod, "dropout_init")
-    kernels.dropout_alloc_size      = CUDA.CuFunction(mod, "dropout_alloc_size")
-    kernels.dropout_forward_float   = CUDA.CuFunction(mod, "dropout_forward_float")
-    kernels.dropout_forward_double  = CUDA.CuFunction(mod, "dropout_forward_double")
-    kernels.dropout_backward_float  = CUDA.CuFunction(mod, "dropout_backward_float")
-    kernels.dropout_backward_double = CUDA.CuFunction(mod, "dropout_backward_double")
-
-    kernels.l1_forward_float = CUDA.CuFunction(mod, "l1_forward_float")
-    kernels.l1_forward_double = CUDA.CuFunction(mod, "l1_forward_double")
-    kernels.l1_backward_float = CUDA.CuFunction(mod, "l1_backward_float")
-    kernels.l1_backward_double = CUDA.CuFunction(mod, "l1_backward_double")
-
-    return kernels
   end
 end
+
+@defkernels(
+  logistic_loss_forward_float,
+  logistic_loss_forward_double,
+  softmax_loss_backward_float,
+  softmax_loss_backward_double,
+  relu_forward_float,
+  relu_forward_double,
+  relu_backward_float,
+  relu_backward_double,
+  sigmoid_forward_float,
+  sigmoid_forward_double,
+  sigmoid_backward_float,
+  sigmoid_backward_double,
+  accuracy_forward_float,
+  accuracy_forward_double,
+  argmax_forward_float,
+  argmax_forward_double,
+
+  add_scal_float,
+  add_scal_double,
+  mul_scal_float,
+  mul_scal_double,
+  elem_add_float,
+  elem_add_double,
+  elem_mul_float,
+  elem_mul_double,
+  elem_sub_float,
+  elem_sub_double,
+  elem_div_float,
+  elem_div_double,
+  elem_div2_float,
+  elem_div2_double,
+  elem_pow_fi,
+  elem_pow_di,
+  elem_pow_ff,
+  elem_pow_dd,
+
+  max_channel_pooling_forward_float,
+  max_channel_pooling_forward_double,
+  max_channel_pooling_backward_float,
+  max_channel_pooling_backward_double,
+
+  dense_to_padded_float,
+  dense_to_padded_double,
+  padded_to_dense_float,
+  padded_to_dense_double,
+
+  copy_to_shifted_float,
+  copy_to_shifted_double,
+  copy_from_shifted_float,
+  copy_from_shifted_double,
+
+  dropout_init,
+  dropout_alloc_size,
+  dropout_forward_float,
+  dropout_forward_double,
+  dropout_backward_float,
+  dropout_backward_double,
+
+  l1_forward_float,
+  l1_forward_double,
+  l1_backward_float,
+  l1_backward_double,
+)
+
 function shutdown(mocha :: MochaKernels)
   CUDA.unload(mocha.mod)
 end

test/layers/channel-pooling.jl

@@ -22,8 +22,7 @@ function test_channel_pooling_layer(backend::Backend, pooling::PoolingFunction,
   payloads = Array(Any, n_input)
   for i = 1:n_input
     expected_output, payloads[i] = channel_pooling_forward(state, i, input[i])
-    got_output = similar(expected_output)
-    copy!(got_output, state.blobs[i])
+    got_output = to_array(state.blobs[i])
     @test all(-eps .< expected_output-got_output .< eps)
   end
 
@@ -36,8 +35,7 @@ function test_channel_pooling_layer(backend::Backend, pooling::PoolingFunction,
 
   for i = 1:n_input
     expected_output = channel_pooling_backward(state, i, input[i], top_diff[i], payloads[i])
-    got_output = similar(expected_output)
-    copy!(got_output, diffs[i])
+    got_output = to_array(diffs[i])
     @test all(-eps .< expected_output - got_output .< eps)
   end
 

test/layers/concat.jl

@@ -19,8 +19,7 @@ function test_concat_layer(backend::Backend, dim, T, eps)
   forward(backend, state, input_blobs)
 
   expected_output = cat(dim, inputs...)
-  got_output = similar(expected_output)
-  copy!(got_output, state.blobs[1])
+  got_output = to_array(state.blobs[1])
   @test all(abs(expected_output-got_output) .< eps)
 
   println("    > Backward")