start working on better device select

Author: SimonDanisch

src/backends/backends.jl

@@ -8,6 +8,7 @@ function default_backend()
         JLBackend
     end
 end
+
 let compute_contexts = Context[]
     function current_context()
         if isempty(compute_contexts)
@@ -45,34 +46,78 @@ end
 function free(x::AbstractArray)
 
 end
+#=
+Functions to select contexts
+=#
+
+is_gpu(ctx) = false
+is_cpu(ctx) = false
+is_opencl(ctx) = false
+is_cudanative(ctx) = false
+is_julia(ctx) = false
+is_opengl(ctx) = false
+has_atleast(ctx, attribute, value) = error("has_atleast not implemented yet")
 
 # BLAS support
 hasblas(x) = false
 include("blas.jl")
 include("supported_backends.jl")
 include("shared.jl")
 
-function init(sym::Symbol, args...; kw_args...)
-    if sym == :julia
-        JLBackend.init(args...; kw_args...)
-    elseif sym == :cudanative
-        CUBackend.init(args...; kw_args...)
-    elseif sym == :opencl
-        CLBackend.init(args...; kw_args...)
-    elseif sym == :opengl
-        GLBackend.init(args...; kw_args...)
+function to_backend_module(backend::Symbol)
+    if backend in supported_backends()
+        if sym == :julia
+            JLBackend
+        elseif sym == :cudanative
+            CUBackend
+        elseif sym == :opencl
+            CLBackend
+        elseif sym == :opengl
+            GLBackend
+        end
     else
         error("$sym not a supported backend. Try one of: $(supported_backends())")
     end
 end
+function init(sym::Symbol, args...; kw_args...)
+    backend_module(sym).init(args...; kw_args...)
+end
+function init(filterfuncs::Function...; kw_args...)
+    init_from_device(first(devices(filterfuncs...)))
+end
+backend_modules() = to_backend_module.(supported_backends())
+
+
 
 
+function devices(filter_funcs...)
+    result = []
+    for Module in backend_modules()
+        for device in Module.devices()
+            if all(f-> f(device), filter_funcs)
+                push!(result, device)
+            end
+        end
+    end
+    result
+end
+
 """
 Iterates through all backends and calls `f` after initializing the current one!
 """
 function perbackend(f)
     for backend in supported_backends()
         ctx = GPUArrays.init(backend)
-        f(backend)
+        f(ctx)
+    end
+end
+
+"""
+Iterates through all available devices and calls `f` after initializing the current one!
+"""
+function forall_devices(f, filterfuncs...)
+    for device in devices(filterfunc)
+        make_current(device)
+        f(device)
     end
 end

src/backends/opencl/opencl.jl

@@ -12,10 +12,13 @@ import GPUArrays: Context, GPUArray, context, linear_index, free
 import GPUArrays: blasbuffer, blas_module, is_blas_supported, is_fft_supported
 import GPUArrays: synchronize, hasblas, LocalMemory, AccMatrix, AccVector, gpu_call
 import GPUArrays: default_buffer_type, broadcast_index, unsafe_reinterpret
+import GPUArrays: is_opencl, is_gpu, is_cpu
 
 using Transpiler
 import Transpiler: cli, CLFunction, cli.get_global_id
 
+
+
 immutable CLContext <: Context
     device::cl.Device
     context::cl.Context
@@ -52,6 +55,15 @@ function Base.show(io::IO, ctx::CLContext)
     print(io, "CLContext: $name")
 end
 
+
+function devices()
+    cl.devices()
+end
+is_opencl(ctx::CLContext) = true
+is_gpu(ctx::CLContext) = cl.info(ctx.device, :device_type) == :gpu
+is_cpu(ctx::CLContext) = cl.info(ctx.device, :device_type) == :cpu
+
+
 global init, all_contexts, current_context
 let contexts = CLContext[]
     all_contexts() = copy(contexts)::Vector{CLContext}