cdc1874bcd1f495097f1251764f3e1b79502bfc1
1 # This file is part of NIT ( http://www.nitlanguage.org ).
3 # Copyright 2014 Julien Pagès <julien.pages@lirmm.fr>
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
17 # Implementation of the Nit virtual machine
20 intrude import naive_interpreter
22 import perfect_hashing
24 redef class ModelBuilder
25 redef fun run_naive_interpreter
(mainmodule
: MModule, arguments
: Array[String])
28 self.toolcontext
.info
("*** NITVM STARTING ***", 1)
30 var interpreter
= new VirtualMachine(self, mainmodule
, arguments
)
31 init_naive_interpreter
(interpreter
, mainmodule
)
34 self.toolcontext
.info
("*** NITVM STOPPING : {time1-time0} ***", 2)
38 # A virtual machine based on the naive_interpreter
39 class VirtualMachine super NaiveInterpreter
41 # Perfect hashing and perfect numbering
42 var ph
: Perfecthashing = new Perfecthashing
44 # Handles memory and garbage collection
45 var memory_manager
: MemoryManager = new MemoryManager
47 # Subtyping test for the virtual machine
48 redef fun is_subtype
(sub
, sup
: MType): Bool
50 var anchor
= self.frame
.arguments
.first
.mtype
.as(MClassType)
51 var sup_accept_null
= false
52 if sup
isa MNullableType then
53 sup_accept_null
= true
55 else if sup
isa MNullType then
56 sup_accept_null
= true
59 # Can `sub` provides null or not?
60 # Thus we can match with `sup_accept_null`
61 # Also discard the nullable marker if it exists
62 if sub
isa MNullableType then
63 if not sup_accept_null
then return false
65 else if sub
isa MNullType then
66 return sup_accept_null
68 # Now the case of direct null and nullable is over
70 # An unfixed formal type can only accept itself
71 if sup
isa MParameterType or sup
isa MVirtualType then
75 if sub
isa MParameterType or sub
isa MVirtualType then
76 sub
= sub
.anchor_to
(mainmodule
, anchor
)
77 # Manage the second layer of null/nullable
78 if sub
isa MNullableType then
79 if not sup_accept_null
then return false
81 else if sub
isa MNullType then
82 return sup_accept_null
86 assert sub
isa MClassType
88 # `sup` accepts only null
89 if sup
isa MNullType then return false
91 assert sup
isa MClassType
93 # Create the sup vtable if not create
94 if not sup
.mclass
.loaded
then create_class
(sup
.mclass
)
96 # Sub can be discovered inside a Generic type during the subtyping test
97 if not sub
.mclass
.loaded
then create_class
(sub
.mclass
)
99 if anchor
== null then anchor
= sub
100 if sup
isa MGenericType then
101 var sub2
= sub
.supertype_to
(mainmodule
, anchor
, sup
.mclass
)
102 assert sub2
.mclass
== sup
.mclass
104 for i
in [0..sup
.mclass
.arity
[ do
105 var sub_arg
= sub2
.arguments
[i
]
106 var sup_arg
= sup
.arguments
[i
]
107 var res
= is_subtype
(sub_arg
, sup_arg
)
109 if res
== false then return false
114 var super_id
= sup
.mclass
.vtable
.id
115 var mask
= sub
.mclass
.vtable
.mask
117 return inter_is_subtype
(super_id
, mask
, sub
.mclass
.vtable
.internal_vtable
)
120 # Subtyping test with perfect hashing
121 private fun inter_is_subtype
(id
: Int, mask
:Int, vtable
: Pointer): Bool `{
122 // hv is the position in hashtable
125 // Follow the pointer to somewhere in the vtable
126 long unsigned int *offset = (long unsigned int*)(((long int *)vtable)[-hv]);
128 // If the pointed value is corresponding to the identifier, the test is true, otherwise false
129 return *offset == id;
132 # Redef init_instance to simulate the loading of a class
133 redef fun init_instance
(recv
: Instance)
135 if not recv
.mtype
.as(MClassType).mclass
.loaded
then create_class
(recv
.mtype
.as(MClassType).mclass
)
137 recv
.vtable
= recv
.mtype
.as(MClassType).mclass
.vtable
139 assert(recv
isa MutableInstance)
141 recv
.internal_attributes
= init_internal_attributes
(null_instance
, recv
.mtype
.as(MClassType).mclass
.all_mattributes
(mainmodule
, none_visibility
).length
)
145 # Initialize the internal representation of an object (its attribute values)
146 private fun init_internal_attributes
(null_instance
: Instance, size
: Int): Pointer
147 import Array[Instance].length
, Array[Instance].[] `{
149 Instance* attributes = malloc(sizeof(Instance) * size);
152 for(i=0; i<size; i++)
153 attributes[i] = null_instance;
155 Instance_incr_ref(null_instance);
159 # Creates the runtime structures for this class
160 fun create_class
(mclass
: MClass) do mclass
.make_vt
(self)
162 # Return the value of the attribute `mproperty for the object `recv
163 redef fun read_attribute
(mproperty
: MAttribute, recv
: Instance): Instance
165 assert recv
isa MutableInstance
167 # Read the attribute value with perfect hashing
168 var id
= mproperty
.intro_mclassdef
.mclass
.vtable
.id
170 var i
= read_attribute_ph
(recv
.internal_attributes
, recv
.vtable
.internal_vtable
,
171 recv
.vtable
.mask
, id
, mproperty
.offset
)
176 # Return the attribute value in `instance with a sequence of perfect_hashing
177 # `instance is the attributes array of the receiver
178 # `vtable is the pointer to the virtual table of the class (of the receiver)
179 # `mask is the perfect hashing mask of the class
180 # `id is the identifier of the class
181 # `offset is the relative offset of this attribute
182 private fun read_attribute_ph
(instance
: Pointer, vtable
: Pointer, mask
: Int, id
: Int, offset
: Int): Instance `{
183 // Perfect hashing position
185 long unsigned int *pointer = (long unsigned int*)(((long int *)vtable)[-hv]);
187 // pointer+1 is the position where the delta of the class is
188 int absolute_offset = *(pointer + 1);
190 Instance res = ((Instance *)instance)[absolute_offset + offset];
195 # Replace in `recv the value of the attribute `mproperty by `value
196 redef fun write_attribute
(mproperty
: MAttribute, recv
: Instance, value
: Instance)
198 assert recv
isa MutableInstance
200 var id
= mproperty
.intro_mclassdef
.mclass
.vtable
.id
202 # Replace the old value of mproperty in recv
203 write_attribute_ph
(recv
.internal_attributes
, recv
.vtable
.internal_vtable
,
204 recv
.vtable
.mask
, id
, mproperty
.offset
, value
)
207 # Replace the value of an attribute in an instance
208 # `instance is the attributes array of the receiver
209 # `vtable is the pointer to the virtual table of the class (of the receiver)
210 # `mask is the perfect hashing mask of the class
211 # `id is the identifier of the class
212 # `offset is the relative offset of this attribute
213 # `value is the new value for this attribute
214 private fun write_attribute_ph
(instance
: Pointer, vtable
: Pointer, mask
: Int, id
: Int, offset
: Int, value
: Instance) `{
215 // Perfect hashing position
217 long unsigned int *pointer = (long unsigned int*)(((long int *)vtable)[-hv]);
219 // pointer+1 is the position where the delta of the class is
220 int absolute_offset = *(pointer + 1);
222 ((Instance *)instance)[absolute_offset + offset] = value;
223 Instance_incr_ref(value);
228 # A reference to the virtual table of this class
229 var vtable
: nullable VTable
231 # True when the class is effectively loaded by the vm, false otherwise
232 var loaded
: Bool = false
234 # Cached attributes for faster instanciations of this class
235 var cached_attributes
: Array[MAttribute] = new Array[MAttribute]
237 # Allocates a VTable for this class and gives it an id
238 private fun make_vt
(v
: VirtualMachine)
240 if loaded
then return
242 # Superclasses contains all superclasses except self
243 var superclasses
= new Array[MClass]
244 superclasses
.add_all
(ancestors
)
245 superclasses
.remove
(self)
246 v
.mainmodule
.linearize_mclasses
(superclasses
)
248 # Make_vt for super-classes
249 var ids
= new Array[Int]
250 var nb_methods
= new Array[Int]
251 var nb_attributes
= new Array[Int]
253 for parent
in superclasses
do
254 if parent
.vtable
== null then parent
.make_vt
(v
)
256 # Get the number of introduced methods and attributes for this class
260 for p
in parent
.intro_mproperties
(none_visibility
) do
261 if p
isa MMethod then methods
+= 1
262 if p
isa MAttribute then
267 ids
.push
(parent
.vtable
.id
)
268 nb_methods
.push
(methods
)
269 nb_attributes
.push
(attributes
)
272 # When all super-classes have their identifiers and vtables, allocate current one
273 allocate_vtable
(v
, ids
, nb_methods
, nb_attributes
)
275 # The virtual table now needs to be filled with pointer to methods
278 # Allocate a single vtable
279 # `ids : Array of superclasses identifiers
280 # `nb_methods : Array which contain the number of introducted methods for each class in ids
281 # `nb_attributes : Array which contain the number of introducted attributes for each class in ids
282 private fun allocate_vtable
(v
: VirtualMachine, ids
: Array[Int], nb_methods
: Array[Int], nb_attributes
: Array[Int])
285 var idc
= new Array[Int]
287 vtable
.mask
= v
.ph
.pnand
(ids
, 1, idc
) - 1
289 vtable
.classname
= name
291 # Add current id to Array of super-ids
292 var ids_total
= new Array[Int]
293 ids_total
.add_all
(ids
)
294 ids_total
.push
(vtable
.id
)
296 var nb_methods_total
= new Array[Int]
297 var nb_attributes_total
= new Array[Int]
300 var self_attributes
= 0
302 # For self attributes, fixing offsets
303 var relative_offset
= 0
304 for p
in intro_mproperties
(none_visibility
) do
305 if p
isa MMethod then self_methods
+= 1
306 if p
isa MAttribute then
308 p
.offset
= relative_offset
310 cached_attributes
.push
(p
)
314 nb_methods_total
.add_all
(nb_methods
)
315 nb_methods_total
.push
(self_methods
)
317 nb_attributes_total
.add_all
(nb_attributes
)
318 nb_attributes_total
.push
(self_attributes
)
320 # Since we have the number of attributes for each class, calculate the delta
321 var d
= calculate_delta
(nb_attributes_total
)
322 vtable
.internal_vtable
= v
.memory_manager
.init_vtable
(ids_total
, nb_methods_total
, d
, vtable
.mask
)
325 # Computes delta for each class
326 # A delta represents the offset for this group of attributes in the object
327 # `nb_attributes : number of attributes for each class (classes are linearized from Object to current)
328 # return deltas for each class
329 private fun calculate_delta
(nb_attributes
: Array[Int]): Array[Int]
331 var deltas
= new Array[Int]
334 for nb
in nb_attributes
do
343 redef class MAttribute
344 # Represents the relative offset of this attribute in the runtime instance
348 # Redef MutableInstance to improve implementation of attributes in objects
349 redef class MutableInstance
351 # C-array to store pointers to attributes of this Object
352 var internal_attributes
: Pointer
355 # A VTable contains the virtual method table for the dispatch
356 # and informations to perform subtyping tests
358 # The mask to perform perfect hashing
359 var mask
: Int is noinit
361 # Unique identifier given by perfect hashing
362 var id
: Int is noinit
364 # Pointer to the c-allocated area, represents the virtual table
365 var internal_vtable
: Pointer is noinit
367 # The short classname of this class
368 var classname
: String is noinit
372 var vtable
: nullable VTable
375 # Handle memory, used for allocate virtual table and associated structures
378 # Allocate and fill a virtual table
379 fun init_vtable
(ids
: Array[Int], nb_methods
: Array[Int], nb_attributes
: Array[Int], mask
: Int): Pointer
381 # Allocate in C current virtual table
382 var res
= intern_init_vtable
(ids
, nb_methods
, nb_attributes
, mask
)
387 # Construct virtual tables with a bi-dimensional layout
388 private fun intern_init_vtable
(ids
: Array[Int], nb_methods
: Array[Int], deltas
: Array[Int], mask
: Int): Pointer
389 import Array[Int].length
, Array[Int].[] `{
391 // Allocate and fill current virtual table
393 int total_size = 0; // total size of this virtual table
394 int nb_classes = Array_of_Int_length(nb_methods);
395 for(i = 0; i<nb_classes; i++) {
396 /* - One for each method of this class
397 * - One for the delta (offset of this group of attributes in objects)
400 total_size += Array_of_Int__index(nb_methods, i);
404 // Add the size of the perfect hashtable (mask +1)
405 // Add one because we start to fill the vtable at position 1 (0 is the init position)
406 total_size += mask+2;
407 long unsigned int* vtable = malloc(sizeof(long unsigned int)*total_size);
409 // Initialisation to the first position of the virtual table (ie : Object)
410 long unsigned int *init = vtable + mask + 2;
411 for(i=0; i<total_size; i++)
412 vtable[i] = (long unsigned int)init;
414 // Set the virtual table to its position 0
415 // ie: after the hashtable
416 vtable = vtable + mask + 1;
418 int current_size = 1;
419 for(i = 0; i < nb_classes; i++) {
421 vtable[hv] contains a pointer to the group of introduced methods
422 For each superclasse we have in virtual table :
423 (id | delta | introduced methods)
425 int hv = mask & Array_of_Int__index(ids, i);
427 vtable[current_size] = Array_of_Int__index(ids, i);
428 vtable[current_size + 1] = Array_of_Int__index(deltas, i);
429 vtable[-hv] = (long unsigned int)&(vtable[current_size]);
432 current_size += Array_of_Int__index(nb_methods, i);