Class: ProcessShared::SharedArray

Inherits:
SharedMemory
  • Object
show all
Includes:
Enumerable
Defined in:
lib/process_shared/shared_array.rb

Instance Method Summary collapse

Constructor Details

#initialize(type_or_count = 1, count = 1) ⇒ SharedArray

A fixed-size array in shared memory. Processes forked from this one will be able to read and write shared data to the array. Access should be synchronized using a Mutex, Semaphore, or other means.

Note that Enumerable methods such as #map, #sort, etc. return new Array objects rather than modifying the shared array.

understood by FFI (e.g. :int, :double)

Parameters:

  • type_or_count (Symbol) (defaults to: 1) —

    the data type as a symbol

  • count (Integer) (defaults to: 1) —

    number of array elements



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/process_shared/shared_array.rb', line 20

def initialize(type_or_count = 1, count = 1)
  super(type_or_count, count)

  # See https://github.com/ffi/ffi/issues/118
  ffi_type = FFI.find_type(self.type)

  name = if ffi_type.inspect =~ /FFI::Type::Builtin:(\w+)*/
           # name will be something like int32
           $1.downcase
         end

  unless name
    raise ArgumentError, "could not find FFI::Type for #{self.type}"
  end
  
  getter = "get_#{name}"
  setter = "put_#{name}"

  # singleton class
  sclass = class << self; self; end

  unless sclass.method_defined?(getter)
    raise ArgumentError, "no element getter for #{self.type} (#{getter})"
  end

  unless sclass.method_defined?(setter)
    raise ArgumentError, "no element setter for #{self.type} (#{setter})"
  end

  sclass.send(:alias_method, :get_type, getter)
  sclass.send(:alias_method, :put_type, setter)
end

Instance Method Details

#[](i) ⇒ Object 



63
64
65
 
# File 'lib/process_shared/shared_array.rb', line 63

def [](i)
  get_type(i * self.type_size)
end

#[]=(i, val) ⇒ Object 



67
68
69
 
# File 'lib/process_shared/shared_array.rb', line 67

def []=(i, val)
  put_type(i * self.type_size, val)
end

#each ⇒ Object 



53
54
55
56
57
 
# File 'lib/process_shared/shared_array.rb', line 53

def each
  # NOTE: using @count because Enumerable defines its own count
  # method...
  @count.times { |i| yield self[i] }
end

#each_with_index ⇒ Object 



59
60
61
 
# File 'lib/process_shared/shared_array.rb', line 59

def each_with_index
  @count.times { |i| yield self[i], i }
end