![[object Object],[object Object],[object Object]](https://image.slidesharecdn.com/railswaycon10dynamiclanguagevms-100531170541-phpapp01/85/railswaycon-2010-dynamic-language-vms-1-320.jpg)
![[object Object],[object Object],[object Object]](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
More Related Content
What's hot
What's hot (20)
Viewers also liked
Similar to RailswayCon 2010 - Dynamic Language VMs
Similar to RailswayCon 2010 - Dynamic Language VMs (20)
More from Lourens Naudé
Recently uploaded
Recently uploaded (20)
RailswayCon 2010 - Dynamic Language VMs
- 3. Well versed full stack
- 6. Bursty traffic – Lady Gaga, EA, Gatorade etc.
- 12. Time
- 14. Serialization / coercion (CPU)
- 15. VM – allocation, symbol tables etc. (CPU + mem)
- 20. Memory – local
- 21. Disk - local
- 23. Serialization + conversion (CPU)
- 24. Object instantiation (CPU + memory)
- 25. Optional memcached (local or remote memory)
- 33. Dispatch
- 36. Contexts and control flow
- 37. Concurrency
- 41. Object model
- 44. Faster runtime
- 48. Annotations attach semantics to nodes
- 50. Method calls, arguments and return values
- 51. Jumps – if, else, iterators
- 52. Unconditional jumps – exceptions, retry etc.
- 54. Reduces a tree to a linear and ordered instruction set
- 56. Codegen, nodes -> instruction sequences
- 57. Postprocessing – replace with optimal instruction sequences (peephole optimization)
- 58. Pre and postprocessing phases may be multiple passes
- 62. Table defaults: 11 bins, 5 entries per bin
- 63. Bins++, sequential lookup inside bins
- 65. !(String || Symbol), points to a table entry
- 66. Developer identifies by name, VM by int
- 67. Immutable for performance – watch out for memory
- 70. Generated from definitions at interpreter compile time (existing ruby requirement for 1.9)
- 72. class / module: definition
- 73. method / iterator: invoke method, call block
- 74. Optimization: redefines common +, <<, * contracts
- 76. Move / copy values, top of stack -> elsewhere
- 78. Put strings “a”, “b” and “c” on the stack
- 79. Fetch top 3 stack elements
- 80. Create an array from them
- 82. Optimizing simple instructions is very important
- 84. Switch Dispatch : slower, but portable
- 87. Forth, Python 3
- 89. Up to 50% slower than Threaded dispatch
- 90. Portable
- 93. constant removal
- 95. method removal
- 96. method cache changes (covered later)
- 100. Constants can be redefined
- 101. Open classes – variable method table
- 103. No explicit return types
- 105. Constant propagation
- 108. Method in-lining
- 109. Cloning
- 111. * not all implemented in YARV
- 113. 2 * 1 # 2
- 114. 2 ** 2 # 2 *2
- 115. class Fixnum
- 116. def +(*args) # dynamic Ruby spec
- 117. end
- 118. end
- 129. Command and Query pattern
- 132. RBASIC(obj)->flags
- 134. marked
- 135. tainted
- 136. embedded status
- 140. Class / module distinction through flags
- 142. nil #=> 4
- 143. true #=> 2
- 144. false #=> 0
- 145. Symbols
- 146. Fixnums <= 30 bits
- 147. Floats and Bignum are complex objects – hence poor Floating Point benchmarks
- 148. RFLOAT(float_obj)->float_value #=> a double
- 150. Objects, even, multiples of 4
- 151. Symbols, even, multiples of 8
- 152. Integers, odd
- 153. Immediates <= 4
- 156. allocates slightly more data than required
- 157. Avoids malloc, realloc and memmove overhead
- 158. Short strings “str”
- 159. Short arrays %w(a r y)
- 162. Open classes
- 163. Method calls can never be reduced to CALL(a_method)
- 165. Dispatch sequence
- 166. Deref class pointer
- 167. Check methods table
- 168. Call method or delegate to superclass
- 171. Send query / command messages to objects
- 173. 95% hit rate when warm
- 174. Method redefinition, module inclusion etc. clears the method cache / “routing table”
- 175. Introduces significant overhead for subsequent method calls
- 177. # busts method cache for the whole VM
- 179. end
- 180. end
- 186. Ivar table is shared by all instances of the same class
- 187. Saves on memory footprint of a table per instance
- 200. Hands out objects while heap space is available
- 201. Halts execution to reclaim memory
- 203. Smoother, but with some minor overhead
- 204. Suitable for hard realtime environments
- 206. Assumes remainder is for collection
- 208. 1 active, 1 inactive
- 209. Copies reachable chunks to the new active area
- 210. Concerned with live objects
- 212. Dangling pointers
- 214. Knowledge of pointer layout and chunks required
- 216. Composed of multiple slots
- 217. Freed when empty ...
- 218. IF all slots is tagged as being free
- 219. A Rails app allocates 4 to 6 heaps on startup
- 224. Defaults to 10 000 slots for the first heap
- 225. Threshold of 4096 free slots per heap
- 227. That's why memory consumption's so high ...
- 229. >> 8 * 1.8 * 1.8
- 230. => 25.92
- 231. >> 8 * 1.8 * 1.8 * 1.8
- 232. => 46.656
- 233. >> 8 * 1.8 * 1.8 * 1.8 * 1.8
- 234. => 83.9808
- 236. => 151.16544
- 237. >> 8 * 1.8 * 1.8 * 1.8 * 1.8 * 1.8 * 1.8
- 238. => 272.097792
- 239. >> 8 * 1.8 * 1.8 * 1.8 * 1.8 * 1.8 * 1.8 * 1.8
- 240. => 489.7760256
- 242. struct {
- 243. VALUE flags; /* 0 when free */
- 244. struct RVALUE *next;
- 245. }free;
- 247. struct RFloat float;
- 248. ...
- 250. RVALUE union can accommodate any ruby object
- 251. Frames, variable structures etc. well defined also
- 252. 40 bytes (64 bit arch) represents a slot
- 253. Free list points to the next free slot
- 258. Sweep phase: iterates through the object space and …
- 259. free all objects not marked
- 262. Work proportional to heap size
- 263. Prone to memory fragmentation (no compaction)
- 265. Every 8MB allocated triggers GC
- 266. Not enough heap reserve
- 268. ary2 = %w(d e f)
- 269. # both ary1 and ary2 is reachable
- 270. ary1 = nil
- 271. # ary1 and it's contents is unreachable
- 276. Expensive to account for long lived objects
- 278. These “sub heaps” are referred to as generations
- 279. Perform a full GC only when the youngest generation
- 280. fails to meet memory requirements
- 283. Ruby Thread == pthread
- 285. Much more expensive to spawn and switch than green threads
- 286. Global VM Lock (GVL)
- 288. Blocking operations should release the GVL
- 289. Automatically released when scheduled
- 290. C extensions : author does not concern with syncronization
- 292. DNS resolution or connects
- 294. Process.waitpid
- 295. File locks
- 298. Cannot access VALUEs (objects) in blocking functions
- 299. No integration with Ruby's exception / error handler
- 301. Very fast user space context switches
- 304. Blocking I/0 - Neverblock
- 306. Sandboxed per VM application state
- 307. Distribute VMs across available cores
- 308. Message passing for inter VM communication
- 309. Most Ruby deployments aren't thread safe
- 310. MVM is well suited for this