data parameter to {@link #enter} upon a {@link
+ * #save} call.
+ *
+ * For example, this field can be used to pass some data from + * a scope entry point (a {@link #enter} call site) to the + * continuation resume point. + */ + protected volatile Object data1; + + /** + * A simple data field for convenience. For example, this field + * can be used to pass some data from the continuation save + * point to the continuation resume point. + */ + protected volatile Object data2; // the user-defined data + + public Object data1() { synchronized(this) { return data1; } } + public Object data2() { synchronized(this) { return data2; } } + public void set_data1(Object o) { synchronized(this) { data1 = o; } } + public void set_data2(Object o) { synchronized(this) { data2 = o; } } + public boolean isSaved() { return stack != null; } + + /** + * The continuation may save the compiled stack frames. The + * reference count of the compiled code (nmethod) is incremented + * upon a continuation save and decremented by this finalizer. + */ + protected void finalize() throws Throwable { + if (pcs == null || pcs.length == 0) { + return; + } + for (long pc : pcs) { + dec_code_cache_ref_count(pc); + } + } + + /** + * Copies the stack frames in the current scope, and stores them + * in this object. This method must be called in an enclosing + * scope. Calling this method causes the stack frames in the + * scope to suspend (including the current frame) and the enter + * call at the entry of the current scope to return. + * + * @return the parameter passed to the resume call when the saved stack + * frames are resumed in the future. + */ + public Object save() { + return save_cont(this); + } + + /** + * Reactivates the stack frames saved in this object on the + * current thread. Overwrites the stack frames in the current + * scope with the saved stack frames. This method must be + * called in an enclosing scope. Calling this method causes the + * suspended save call to resume from the point where it was + * suspended. + * + * @param rv the value to be returned from the resumed save call site. + */ + public void resume(Object rv) { + if (stack == null) { + throw new IllegalArgumentException( + "Continuation hasn't been saved or tried to resume for a second time."); + } + Object s = stack; + stack = null; // resumable only once + resume_cont(s, rv); + } + + /** + * Marks the beginning of a new 'scope' in preparation for stack + * save/resume. Executes the given Runnable. + * + * @param data any user defined data to be passed from this call + * site to the point where {@link #resume} is called + * for convenience. The {@link #data1} field will be + * set to this object. + * @return the Continuation object after the scope was saved + * into a Continuation object or null if it wasn't and + * simply returned + */ + public static Object enter(Runnable r, Object data) { + Object rv = enter0(r, data); + return rv; + } + + /* + * This method currently exists just for convenience for the + * continuation implementation in the JVM. This method along with + * enter() above will never be jitted. This may go away in the + * future. + */ + private static Object enter0(Runnable r, Object data) { + Object rv = enter1(r, data); + return rv; + } + + /* + * This method currently exists just for convenience for the + * continuation implementation in the JVM. This may go away in the + * future. + */ + private static Object enter1(Runnable r, Object data) { + r.run(); + return null; // If saved, this will return the CSE. + } + + private static native Object save_cont(Continuation cont); + private static native void resume_cont(Object stack, Object rv); + private static native void dec_code_cache_ref_count(long pc); +}