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)


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

#eachObject


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_indexObject


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

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