Class: MiniRacer::Context

Inherits:
Object
  • Object
show all
Defined in:
lib/mini_racer/shared.rb,
lib/mini_racer.rb,
lib/mini_racer/truffleruby.rb,
ext/mini_racer_extension/mini_racer_extension.c

Overview

eval is defined in the C class

Defined Under Namespace

Classes: ExternalFunction

Instance Method Summary collapse

Constructor Details

#initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil, marshal_stack_depth: nil) ⇒ Context

Returns a new instance of Context.



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/mini_racer/shared.rb', line 102

def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil, marshal_stack_depth: nil)
  options ||= {}

  check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, marshal_stack_depth: marshal_stack_depth, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)

  @functions = {}
  @timeout = nil
  @max_memory = nil
  @current_exception = nil
  @timeout = timeout
  @max_memory = max_memory
  @marshal_stack_depth = marshal_stack_depth

  # false signals it should be fetched if requested
  @isolate = isolate || false

  @ensure_gc_after_idle = ensure_gc_after_idle

  if @ensure_gc_after_idle
    @last_eval = nil
    @ensure_gc_thread = nil
    @ensure_gc_mutex = Mutex.new
  end

  @disposed = false

  @callback_mutex = Mutex.new
  @callback_running = false
  @thread_raise_called = false
  @eval_thread = nil

  # defined in the C class
  init_unsafe(isolate, snapshot)
end

Instance Method Details

#attach(name, callback) ⇒ Object

Raises:



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
 
# File 'lib/mini_racer/shared.rb', line 185

def attach(name, callback)
  raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed

  wrapped = lambda do |*args|
    begin

      r = nil

      begin
        @callback_mutex.synchronize{
          @callback_running = true
        }
        r = callback.call(*args)
      ensure
        @callback_mutex.synchronize{
          @callback_running = false
        }
      end

      # wait up to 2 seconds for this to be interrupted
      # will very rarely be called cause #raise is called
      # in another mutex
      @callback_mutex.synchronize {
        if @thread_raise_called
          sleep 2
        end
      }

      r

    ensure
      @callback_mutex.synchronize {
        @thread_raise_called = false
      }
    end
  end

  isolate_mutex.synchronize do
    external = ExternalFunction.new(name, wrapped, self)
    @functions["#{name}"] = external
  end
end

#call(function_name, *arguments) ⇒ Object 



160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/mini_racer/shared.rb', line 160

def call(function_name, *arguments)
  raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed

  @eval_thread = Thread.current
  isolate_mutex.synchronize do
    timeout do
      call_unsafe(function_name, *arguments)
    end
  end
ensure
  @eval_thread = nil
  ensure_gc_thread if @ensure_gc_after_idle
end

#dispose ⇒ Object 



174
175
176
177
178
179
180
181
182
 
# File 'lib/mini_racer/shared.rb', line 174

def dispose
  return if @disposed
  isolate_mutex.synchronize do
    return if @disposed
    dispose_unsafe
    @disposed = true
    @isolate = nil # allow it to be garbage collected, if set
  end
end

#eval(str, options = nil) ⇒ Object 



143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/mini_racer/shared.rb', line 143

def eval(str, options=nil)
  raise(ContextDisposedError, 'attempted to call eval on a disposed context!') if @disposed

  filename = options && options[:filename].to_s

  @eval_thread = Thread.current
  isolate_mutex.synchronize do
    @current_exception = nil
    timeout do
      eval_unsafe(str, filename)
    end
  end
ensure
  @eval_thread = nil
  ensure_gc_thread if @ensure_gc_after_idle
end

#heap_stats ⇒ Object

Raises:



47
48
49
50
51
52
53
54
55
56
 
# File 'lib/mini_racer/truffleruby.rb', line 47

def heap_stats
  raise ContextDisposedError if @disposed
  {
    total_physical_size: 0,
    total_heap_size_executable: 0,
    total_heap_size: 0,
    used_heap_size: 0,
    heap_size_limit: 0,
  }
end

#isolate ⇒ Object 



137
138
139
140
141
 
# File 'lib/mini_racer/shared.rb', line 137

def isolate
  return @isolate if @isolate != false
  # defined in the C class
  @isolate = create_isolate_value
end

#load(filename) ⇒ Object 



92
93
94
 
# File 'lib/mini_racer.rb', line 92

def load(filename)
  eval(File.read(filename))
end

#low_memory_notification ⇒ Object 



66
67
68
 
# File 'lib/mini_racer/truffleruby.rb', line 66

def low_memory_notification
  GC.start
end

#stop ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/mini_racer/truffleruby.rb', line 58

def stop
  if @entered
    @context.stop
    @stopped = true
    stop_attached
  end
end

#write_heap_snapshot(file_or_io) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/mini_racer.rb', line 96

def write_heap_snapshot(file_or_io)
  f = nil
  implicit = false

  if String === file_or_io
    f = File.open(file_or_io, "w")
    implicit = true
  else
    f = file_or_io
  end

  raise ArgumentError, "file_or_io" unless File === f

  f.write(heap_snapshot())
ensure
  f.close if implicit
end