primitives.py 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468
  1. import time as python_time
  2. class PrimitiveFinished(Exception):
  3. """Exception to indicate the result value of a primitive, as a return cannot be used."""
  4. def __init__(self, value):
  5. Exception.__init__(self)
  6. self.result = value
  7. class InterpretedFunctionFinished(Exception):
  8. """Exception to indicate the result value of an interpreted function, as a return
  9. cannot be used."""
  10. def __init__(self, value):
  11. Exception.__init__(self)
  12. self.result = value
  13. class SleepKernel(Exception):
  14. """Exception to indicate the kernel to sleep for some time."""
  15. def __init__(self, timeout, interruptable):
  16. Exception.__init__(self)
  17. self.timeout = timeout
  18. self.interruptable = interruptable
  19. # Functions annotated with __exception_return use the JIT's calling convention instead of
  20. # the kernel's: returns are handled by throwing a PrimitiveFinished exception; the caller's
  21. # returnvalue is not modified.
  22. #
  23. # ### Rationale for __exception_return
  24. #
  25. # __exception_return is a useful mechanism because it allows us to have a __call_function
  26. # implementation that has O(1) state read overhead. A previous implementation of
  27. # __call_function checked if the caller's frame had been popped whenever
  28. # ModelverseKernel.execute_yield threw a StopIteration exception. However, that incurs O(n) overhead
  29. # _per call,_ where n is the number of StopIteration exceptions that are thrown during the call.
  30. # O(n) is pretty bad, but this actually becomes O(n * m) when m calls to __call_function are
  31. # nested. And that's just not acceptable.
  32. # __exception_return requires kernel support, but I think the complexity gains are well worth it;
  33. # I reckon JIT-to-interpreter switches aren't going to get a whole lot cheaper than this.
  34. EXCEPTION_RETURN_KEY = "__exception_return"
  35. """A dictionary key for functions which request that the kernel throw a InterpretedFunctionFinished
  36. exception with the return value instead of injecting the return value in the caller's frame."""
  37. def integer_subtraction(a, b, **remainder):
  38. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  39. result, = yield [("CNV", [a_value - b_value])]
  40. raise PrimitiveFinished(result)
  41. def integer_addition(a, b, **remainder):
  42. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  43. result, = yield [("CNV", [a_value + b_value])]
  44. raise PrimitiveFinished(result)
  45. def integer_multiplication(a, b, **remainder):
  46. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  47. result, = yield [("CNV", [a_value * b_value])]
  48. raise PrimitiveFinished(result)
  49. def integer_division(a, b, **remainder):
  50. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  51. result, = yield [("CNV", [int(a_value) / b_value])]
  52. raise PrimitiveFinished(result)
  53. """
  54. def integer_gt(a, b, **remainder):
  55. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  56. result, = yield [("CNV", [a_value > b_value])]
  57. raise PrimitiveFinished(result)
  58. """
  59. def integer_lt(a, b, **remainder):
  60. # TODO make non-primitive, though compiled
  61. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  62. result, = yield [("CNV", [a_value < b_value])]
  63. raise PrimitiveFinished(result)
  64. """
  65. def integer_neg(a, **remainder):
  66. # TODO make non-primitive, though compiled
  67. a_value, = yield [("RV", [a])]
  68. result, = yield [("CNV", [-a_value])]
  69. raise PrimitiveFinished(result)
  70. """
  71. def bool_and(a, b, **remainder):
  72. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  73. result, = yield [("CNV", [a_value and b_value])]
  74. raise PrimitiveFinished(result)
  75. def bool_or(a, b, **remainder):
  76. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  77. result, = yield [("CNV", [a_value or b_value])]
  78. raise PrimitiveFinished(result)
  79. def bool_not(a, **remainder):
  80. a_value, = yield [("RV", [a])]
  81. result, = yield [("CNV", [not a_value])]
  82. raise PrimitiveFinished(result)
  83. def float_subtraction(a, b, **remainder):
  84. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  85. result, = yield [("CNV", [a_value - b_value])]
  86. raise PrimitiveFinished(result)
  87. def float_addition(a, b, **remainder):
  88. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  89. result, = yield [("CNV", [a_value + b_value])]
  90. raise PrimitiveFinished(result)
  91. def float_multiplication(a, b, **remainder):
  92. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  93. result, = yield [("CNV", [a_value * b_value])]
  94. raise PrimitiveFinished(result)
  95. def float_division(a, b, **remainder):
  96. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  97. result, = yield [("CNV", [float(a_value) / float(b_value)])]
  98. raise PrimitiveFinished(result)
  99. def float_lt(a, b, **remainder):
  100. # TODO make non-primitive, though compiled
  101. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  102. result, = yield [("CNV", [a_value < b_value])]
  103. raise PrimitiveFinished(result)
  104. def string_join(a, b, **remainder):
  105. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  106. result, = yield [("CNV", [str(a_value) + str(b_value)])]
  107. raise PrimitiveFinished(result)
  108. def string_split(a, b, **remainder):
  109. # TODO make non-primitive, though compiled
  110. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  111. result = a_value.split(b_value)
  112. elems = yield [("CN", [])] + [("CNV", [v]) for v in result]
  113. new_val = elems[0]
  114. yield [("CD", [new_val, i, v]) for i, v in enumerate(elems[1:])]
  115. raise PrimitiveFinished(new_val)
  116. def string_get(a, b, **remainder):
  117. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  118. result, = yield [("CNV", [a_value[b_value]])]
  119. raise PrimitiveFinished(result)
  120. def string_len(a, **remainder):
  121. a_value, = yield [("RV", [a])]
  122. result, = yield [("CNV", [len(a_value)])]
  123. raise PrimitiveFinished(result)
  124. def value_eq(a, b, **remainder):
  125. a_value, b_value = yield [("RV", [a]), ("RV", [b])]
  126. result, = yield [("CNV", [a_value == b_value])]
  127. raise PrimitiveFinished(result)
  128. def element_eq(a, b, **remainder):
  129. result, = yield [("CNV", [a == b])]
  130. raise PrimitiveFinished(result)
  131. def cast_a2s(a, **remainder):
  132. a_value, = yield [("RV", [a])]
  133. result, = yield [("CNV", [str(a_value["value"])])]
  134. raise PrimitiveFinished(result)
  135. def cast_i2f(a, **remainder):
  136. a_value, = yield [("RV", [a])]
  137. result, = yield [("CNV", [float(a_value)])]
  138. raise PrimitiveFinished(result)
  139. def cast_i2s(a, **remainder):
  140. a_value, = yield [("RV", [a])]
  141. result, = yield [("CNV", [str(a_value)])]
  142. raise PrimitiveFinished(result)
  143. def cast_i2b(a, **remainder):
  144. a_value, = yield [("RV", [a])]
  145. result, = yield [("CNV", [bool(a_value)])]
  146. raise PrimitiveFinished(result)
  147. def cast_f2i(a, **remainder):
  148. a_value, = yield [("RV", [a])]
  149. result, = yield [("CNV", [int(a_value)])]
  150. raise PrimitiveFinished(result)
  151. def cast_f2s(a, **remainder):
  152. a_value, = yield [("RV", [a])]
  153. result, = yield [("CNV", [str(a_value)])]
  154. raise PrimitiveFinished(result)
  155. def cast_f2b(a, **remainder):
  156. a_value, = yield [("RV", [a])]
  157. result, = yield [("CNV", [bool(a_value)])]
  158. raise PrimitiveFinished(result)
  159. def cast_s2i(a, **remainder):
  160. a_value, = yield [("RV", [a])]
  161. result, = yield [("CNV", [int(a_value)])]
  162. raise PrimitiveFinished(result)
  163. def cast_s2f(a, **remainder):
  164. a_value, = yield [("RV", [a])]
  165. result, = yield [("CNV", [float(a_value)])]
  166. raise PrimitiveFinished(result)
  167. def cast_s2b(a, **remainder):
  168. a_value, = yield [("RV", [a])]
  169. result, = yield [("CNV", [bool(a_value)])]
  170. raise PrimitiveFinished(result)
  171. def cast_b2i(a, **remainder):
  172. a_value, = yield [("RV", [a])]
  173. result, = yield [("CNV", [int(a_value)])]
  174. raise PrimitiveFinished(result)
  175. def cast_b2f(a, **remainder):
  176. a_value, = yield [("RV", [a])]
  177. result, = yield [("CNV", [float(a_value)])]
  178. raise PrimitiveFinished(result)
  179. def cast_b2s(a, **remainder):
  180. a_value, = yield [("RV", [a])]
  181. result, = yield [("CNV", [str(a_value)])]
  182. raise PrimitiveFinished(result)
  183. def cast_e2s(a, **remainder):
  184. a_value, = yield [("RV", [a])]
  185. result, = yield [("CNV", ["{ID: %s, value: %s}" % (a, a_value)])]
  186. raise PrimitiveFinished(result)
  187. def cast_v2s(a, **remainder):
  188. a_value, = yield [("RV", [a])]
  189. if isinstance(a_value, (str, unicode)):
  190. # String should be encoded to distinguish between 3 and "3"
  191. a_value = '"%s"' % a_value
  192. elif isinstance(a_value, dict):
  193. # Action or type
  194. a_value = a_value["value"]
  195. result, = yield [("CNV", ["%s" % (a_value)])]
  196. raise PrimitiveFinished(result)
  197. def cast_id2s(a, **remainder):
  198. result, = yield [("CNV", ["%s" % (a)])]
  199. raise PrimitiveFinished(result)
  200. def list_insert(a, b, c, **remainder):
  201. # TODO make non-primitive, though compiled
  202. a_outgoing, c_value = yield [("RO", [a]), ("RV", [c])]
  203. links = yield [("RD", [a, i]) for i in range(c_value, len(a_outgoing))] + \
  204. [("RDE", [a, i]) for i in range(c_value, len(a_outgoing))]
  205. values = links[:len(links)/2]
  206. edges = links[len(links)/2:]
  207. yield [("CD", [a, c_value, b])] + \
  208. [("CD", [a, c_value + 1 + index, value]) for index, value in enumerate(values)] + \
  209. [("DE", [i]) for i in edges]
  210. raise PrimitiveFinished(a)
  211. def list_delete(a, b, **remainder):
  212. # TODO make non-primitive, though compiled
  213. a_outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  214. links = yield [("RD", [a, i]) for i in range(b_value, len(a_outgoing))] + \
  215. [("RDE", [a, i]) for i in range(b_value, len(a_outgoing))]
  216. values = links[:len(links)/2]
  217. edges = links[len(links)/2:]
  218. yield [("CD", [a, b_value + index, value]) for index, value in enumerate(values[1:])] + \
  219. [("DE", [i]) for i in edges]
  220. raise PrimitiveFinished(a)
  221. def dict_add_fast(a, b, c, **remainder):
  222. # TODO deprecate, as dict_add is now also efficient
  223. v, = yield [("RV", [b])]
  224. yield [("CD", [a, v, c])]
  225. raise PrimitiveFinished(a)
  226. def dict_delete(a, b, **remainder):
  227. b_value, = yield [("RV", [b])]
  228. edge, = yield [("RDE", [a, b_value])]
  229. if edge is None:
  230. print("Failed dict_delete for value %s!" % b_value)
  231. keys, = yield [("RDK", [a])]
  232. keys = yield [("RV", [i]) for i in keys]
  233. print("Keys: " + str(keys))
  234. yield [("DE", [edge])]
  235. raise PrimitiveFinished(a)
  236. def dict_delete_node(a, b, **remainder):
  237. edge, = yield [("RDNE", [a, b])]
  238. if edge is None:
  239. print("Failed dict_delete_node!")
  240. yield [("DE", [edge])]
  241. raise PrimitiveFinished(a)
  242. def dict_read(a, b, **remainder):
  243. b_value, = yield [("RV", [b])]
  244. result, = yield [("RD", [a, b_value])]
  245. raise PrimitiveFinished(result)
  246. def dict_read_edge(a, b, **remainder):
  247. b_value, = yield [("RV", [b])]
  248. result, = yield [("RDE", [a, b_value])]
  249. raise PrimitiveFinished(result)
  250. def dict_read_node(a, b, **remainder):
  251. result, = yield [("RDN", [a, b])]
  252. raise PrimitiveFinished(result)
  253. def dict_in(a, b, **remainder):
  254. b_value, = yield [("RV", [b])]
  255. value, = yield [("RD", [a, b_value])]
  256. is_in = value is not None
  257. result, = yield [("CNV", [is_in])]
  258. raise PrimitiveFinished(result)
  259. def dict_in_node(a, b, **remainder):
  260. value, = yield [("RDN", [a, b])]
  261. result, = yield [("CNV", [value is not None])]
  262. raise PrimitiveFinished(result)
  263. def dict_keys(a, **remainder):
  264. keys, result = yield [("RDK", [a]), ("CN", [])]
  265. yield [("CE", [result, v]) for v in keys]
  266. raise PrimitiveFinished(result)
  267. def is_physical_int(a, **remainder):
  268. t, = yield [("RV", [a])]
  269. result, = yield [("CNV", [isinstance(t, int) or isinstance(t, long)])]
  270. raise PrimitiveFinished(result)
  271. def is_physical_string(a, **remainder):
  272. t, = yield [("RV", [a])]
  273. result, = yield [("CNV", [isinstance(t, str) or isinstance(t, unicode)])]
  274. raise PrimitiveFinished(result)
  275. def is_physical_float(a, **remainder):
  276. t, = yield [("RV", [a])]
  277. result, = yield [("CNV", [isinstance(t, float)])]
  278. raise PrimitiveFinished(result)
  279. def is_physical_boolean(a, **remainder):
  280. t, = yield [("RV", [a])]
  281. result, = yield [("CNV", [isinstance(t, bool)])]
  282. raise PrimitiveFinished(result)
  283. def is_physical_action(a, **remainder):
  284. t, = yield [("RV", [a])]
  285. result, = yield [("CNV", [isinstance(t, dict) and t["value"] in ["if", "while", "assign", "call", "break", "continue", "return", "resolve", "access", "constant", "global", "declare"]])]
  286. raise PrimitiveFinished(result)
  287. def create_node(**remainder):
  288. result, = yield [("CN", [])]
  289. raise PrimitiveFinished(result)
  290. def create_edge(a, b, **remainder):
  291. result, = yield [("CE", [a, b])]
  292. raise PrimitiveFinished(result)
  293. def create_value(a, **remainder):
  294. a_value, = yield [("RV", [a])]
  295. result, = yield [("CNV", [a_value])]
  296. raise PrimitiveFinished(result)
  297. def read_nr_out(a, **remainder):
  298. outgoing, = yield [("RO", [a])]
  299. result, = yield [("CNV", [len(outgoing)])]
  300. raise PrimitiveFinished(result)
  301. def read_out(a, b, root, **remainder):
  302. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  303. raise PrimitiveFinished(sorted(outgoing)[b_value] if len(outgoing) > b_value else root)
  304. def read_nr_in(a, **remainder):
  305. incoming, = yield [("RI", [a])]
  306. result, = yield [("CNV", [len(incoming)])]
  307. raise PrimitiveFinished(result)
  308. def read_in(a, b, root, **remainder):
  309. incoming, b_value = yield [("RI", [a]), ("RV", [b])]
  310. raise PrimitiveFinished(sorted(incoming)[b_value] if len(incoming) > b_value else root)
  311. def read_edge_src(a, **remainder):
  312. result, = yield [("RE", [a])]
  313. raise PrimitiveFinished(result[0])
  314. def read_edge_dst(a, **remainder):
  315. result, = yield [("RE", [a])]
  316. raise PrimitiveFinished(result[1])
  317. def delete_element(a, **remainder):
  318. edge, = yield [("RE", [a])]
  319. if edge[0] is None:
  320. # Not an edge:
  321. yield [("DN", [a])]
  322. result, = yield [("CNV", [False])]
  323. raise PrimitiveFinished(result)
  324. else:
  325. yield [("DE", [a])]
  326. result, = yield [("CNV", [True])]
  327. raise PrimitiveFinished(result)
  328. def read_root(root, **remainder):
  329. raise PrimitiveFinished(root)
  330. def set_remove(a, b, **remainder):
  331. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  332. elements = yield [("RE", [i]) for i in outgoing]
  333. values = yield [("RV", [i[1]]) for i in elements]
  334. yield [("DE", [identifier]) for identifier, edge in zip(outgoing, values) if edge == b_value]
  335. raise PrimitiveFinished(a)
  336. def set_remove_node(a, b, **remainder):
  337. outgoing, = yield [("RO", [a])]
  338. elements = yield [("RE", [i]) for i in outgoing]
  339. elements = [elements] if not isinstance(elements[0], list) else elements
  340. yield [("DE", [identifier]) for identifier, edge in zip(outgoing, elements) if edge[1] == b]
  341. raise PrimitiveFinished(a)
  342. def set_in(a, b, **remainder):
  343. # TODO make non-primitive, though compiled
  344. outgoing, b_value = yield [("RO", [a]), ("RV", [b])]
  345. if outgoing:
  346. elements = yield [("RE", [i]) for i in outgoing]
  347. values = yield [("RV", [i[1]]) for i in elements]
  348. if b_value in values:
  349. result, = yield [("CNV", [True])]
  350. else:
  351. result, = yield [("CNV", [False])]
  352. else:
  353. result, = yield [("CNV", [False])]
  354. raise PrimitiveFinished(result)
  355. def set_in_node(a, b, **remainder):
  356. # TODO make non-primitive, though compiled
  357. outgoing, = yield [("RO", [a])]
  358. if outgoing:
  359. elements = yield [("RE", [i]) for i in outgoing]
  360. if b in [v[1] for v in elements]:
  361. result, = yield [("CNV", [True])]
  362. else:
  363. result, = yield [("CNV", [False])]
  364. else:
  365. result, = yield [("CNV", [False])]
  366. raise PrimitiveFinished(result)
  367. def is_edge(a, **remainder):
  368. edge, = yield [("RE", [a])]
  369. result, = yield [("CNV", [edge[0] is not None])]
  370. raise PrimitiveFinished(result)
  371. def log(a, **remainder):
  372. a_value, = yield [("RV", [a])]
  373. print("== LOG == " + str(a_value))
  374. raise PrimitiveFinished(a)
  375. def read_taskroot(task_root, **remainder):
  376. raise PrimitiveFinished(task_root)
  377. def time(**remainder):
  378. a, = yield [("CNV", [python_time.time()])]
  379. raise PrimitiveFinished(a)
  380. def hash(a, **remainder):
  381. a_value, = yield [("RV", [a])]
  382. import hashlib
  383. b_value = hashlib.sha512(a_value).hexdigest()
  384. b, = yield [("CNV", [b_value])]
  385. raise PrimitiveFinished(b)
  386. def __sleep(a, b, **remainder):
  387. timeout, interruptable = yield [("RV", [a]), ("RV", [b])]
  388. yield [("SLEEP", [timeout, interruptable])]
  389. raise PrimitiveFinished(a)