(ns pixie.stacklets

(require pixie.uv :as uv))

(def stacklet-loop-h (atom nil))

(defn -spawn-thread [fn]

(let [[h val] (@stacklet-loop-h [:spawn fn])]

(reset! stacklet-loop-h h)

(println h val)

val))

(defn enqueue [q itm]

; TODO: Rewrite this crappy impl

(vec (conj (seq q) itm)))

(defn dequeue [q]

[(ith q -1)

(pop q)])

(defn yield-control []

(let [[h] (@stacklet-loop-h [:yield nil])]

(reset! stacklet-loop-h h)

nil))

(defmacro spawn [& body]

`(let [f (fn [h# _]

(reset! stacklet-loop-h h#)

(try

(println "spawn" h#)

;(reset! stacklet-loop-h h#)

(let [result# (do ~@body)]

(println "returning " result#)

(@stacklet-loop-h [:spawn-end result#]))

(catch e (println e))))

[h# val#] (@stacklet-loop-h [:spawn f])]

(reset! stacklet-loop-h h#)

val#))

(defn -with-stacklets [fn]

(let [[h [op arg]] ((new-stacklet fn) nil)]

(println h op arg)

(loop [op op

arg arg

this_h h

tasks []]

(println "in loop" op arg this_h tasks)

(cond

(= op :spawn) (let [wh (new-stacklet arg)

[h [op arg]] (this_h nil)]

(recur op arg h (enqueue tasks wh)))

(= op :yield) (let [tasks (enqueue tasks this_h)

[task tasks] (dequeue tasks)

[h [op arg]] (task nil)]

(recur op arg h tasks))

(= op :spawn-end) (if (empty? tasks)

arg

(let [[task tasks] (dequeue tasks)

[h [op arg]] (task nil)]

(recur op arg h tasks)))

:else (assert false (str "Unkown command " op " " arg))))))

(defmacro with-stacklets [& body]

`(-with-stacklets

(fn [h# _]

(try

(println h# _)

(reset! stacklet-loop-h h#)

(let [result# (do ~@body)]

(@stacklet-loop-h [:spawn-end result#]))

(catch e

(println e))))))

(with-stacklets (spawn (dotimes [x 10]

(yield-control)

(println x)))

(spawn (dotimes [x 10]

(yield-control)

(println x)))(yield-control))

(let* [destructured-bindings (transduce (map (fn [args]

(assert (= 2 (count args)) (str "Bindings must be in pairs, not " args

" " (meta (first args))))

(apply destructure args)))

import pixie.vm.stacklet

import rpython.rlib.rstacklet as rstacklet

from pixie.vm.object import Object, Type, affirm

from pixie.vm.code import as_var

import pixie.vm.rt as rt

class GlobalState(object):

def __init__(self):

self._is_inited = False

self._val = None

global_state = GlobalState()

def init():

if not global_state._is_inited:

global_state._th = rstacklet.StackletThread(rt.__config__)

global_state._is_inited = True

class StackletHandle(Object):

_type = Type(u"StackletHandle")

def __init__(self, h):

self._stacklet_handle = h

self._used = False

def type(self):

return self._type

def invoke(self, args):

affirm(not self._used, u"Can only call a given stacklet handle once.")

affirm(len(args) == 1, u"Only one arg should be handed to a stacklet handle")

self._used = True

global_state._val = args[0]

new_h = StackletHandle(global_state._th.switch(self._stacklet_handle))

val = global_state._val

global_state._val = None

return rt.vector(new_h, val)

def new_handler(h, _):

fn = global_state._val

global_state._val = None

h = global_state._th.switch(h)

val = global_state._val

fn.invoke([StackletHandle(h), val])

affirm(False, u"TODO: What do we do now?")

return h

def new_stacklet(fn):

global_state._val = fn

h = global_state._th.new(new_handler)

return StackletHandle(h)

import pixie.vm.stacklet

pixie.vm.stacklet.init()