Module: Khiva::Library

Defined in:
lib/khiva/library.rb

Constant Summary collapse

BACKENDS = 
{
  default: 0,
  cpu: 1,
  cuda: 2,
  opencl: 4
}

Class Method Summary collapse

Class Method Details

.backend ⇒ Object 



17
18
19
20
21
 
# File 'lib/khiva/library.rb', line 17

def backend
  backend = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
  FFI.call(:get_backend, backend)
  BACKENDS.map(&:reverse).to_h[backend.to_s(backend.size).unpack1("i")]
end

.backend_info ⇒ Object 



11
12
13
14
15
 
# File 'lib/khiva/library.rb', line 11

def backend_info
  info = Fiddle::Pointer.malloc(1000)
  FFI.call(:backend_info, info.ref)
  info.to_s
end

.backends ⇒ Object 



23
24
25
26
27
28
 
# File 'lib/khiva/library.rb', line 23

def backends
  backends = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
  FFI.call(:get_backends, backends)
  mask = backends.to_s(backends.size).unpack1("i")
  BACKENDS.select { |_, v| mask & v != 0 }.map(&:first)
end

.device_count ⇒ Object 



46
47
48
49
50
 
# File 'lib/khiva/library.rb', line 46

def device_count
  device_count = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
  FFI.call(:get_device_count, device_count)
  device_count.to_s(device_count.size).unpack1("i")
end

.device_id ⇒ Object 



40
41
42
43
44
 
# File 'lib/khiva/library.rb', line 40

def device_id
  device_id = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
  FFI.call(:get_device_id, device_id)
  device_id.to_s(device_id.size).unpack1("i")
end

.set_backend(backend) ⇒ Object

Raises:



30
31
32
33
34
 
# File 'lib/khiva/library.rb', line 30

def set_backend(backend)
  b = BACKENDS[backend]
  raise Error, "Invalid backend: #{backend}" unless b
  FFI.call(:set_backend, Utils.int_ptr(b))
end

.set_device(device) ⇒ Object 



36
37
38
 
# File 'lib/khiva/library.rb', line 36

def set_device(device)
  FFI.call(:set_device, Utils.int_ptr(device))
end

.set_device_memory_in_gb(memory) ⇒ Object 



52
53
54
 
# File 'lib/khiva/library.rb', line 52

def set_device_memory_in_gb(memory)
  FFI.call(:set_device_memory_in_gb, Utils.double_ptr(memory))
end

.version ⇒ Object 



56
57
58
59
60
 
# File 'lib/khiva/library.rb', line 56

def version
  v = Fiddle::Pointer.malloc(20)
  FFI.call(:version, v.ref)
  v.to_s
end