3. Well versed full stack

5. Large whitelabel clients

6. Bursty traffic – Lady Gaga, EA, Gatorade etc.

12. Time

14. Serialization / coercion (CPU)

15. VM – allocation, symbol tables etc. (CPU + mem)

16. Business requirements (CPU)

20. Memory – local

21. Disk - local

23. Serialization + conversion (CPU)

24. Object instantiation (CPU + memory)

25. Optional memcached (local or remote memory)

32. Opcodes / instructions

33. Dispatch

35. Garbage Collection

36. Contexts and control flow

37. Concurrency

41. Object model

42. Garbage Collection

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

94. method definition

95. method removal

96. method cache changes (covered later)

100. Constants can be redefined

101. Open classes – variable method table

102. Object#method_missing

103. No explicit return types

105. Constant propagation

106. Dead code elimination

107. Subexpression elimination

108. Method in-lining

109. Cloning

110. Peephole Optimization

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

178. @user.extend SomeBehavior

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;

246. struct RObject object;

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

260. unmark marked objects

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

302. Cooperative scheduling required

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