Fiber

java.lang.Object
- kilim.Fiber

```
public final class Fiber
extends java.lang.Object
```
This class serves as a context to manage and store the continuation stack. The actual capture of the closure is done in the Weaver-transformed code.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Fiber.MethodRef

static interface Fiber.Worker

Nested Classes
Modifier and Type	Class and Description
`static class`	`Fiber.MethodRef`
`static interface`	`Fiber.Worker`

Field Summary

Fields
Modifier and Type	Field and Description
`State`	`curState` The current frame's state (local vars and elements of the operand stack that will be needed when the Fiber is resumed.
`static int`	`NOT_PAUSING__HAS_STATE`
`static int`	`NOT_PAUSING__NO_STATE`
`static int`	`PAUSING__HAS_STATE`
`static int`	`PAUSING__NO_STATE`
`int`	`pc` The "program counter", kept equal to stateStack[iStack].pc and is used to jump to the appropriate place in the code while rewinding the code, and also to inform the weaved code inside an exception handler which pausable method (if at all) was being invoked when that exception was thrown.
`Task`	`task`

Constructor Summary

Constructors
Constructor and Description

Fiber(Task t)

Constructors
Constructor and Description
`Fiber(Task t)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Fiber`	`begin()`
`Fiber`	`down()`
`boolean`	`end()` end() is the last up().
`java.lang.Object`	`getCallee()` Called by the weaved code while rewinding the stack.
`State`	`getState()`
`boolean`	`isDone()`
`static void`	`pause()`
`static void`	`pause(Fiber f)`
`void`	`reset()`
`void`	`setCallee(java.lang.Object callee)`
`void`	`setState(State state)` Called by the generated code before pausing and unwinding its stack frame.
`Task`	`task()`
`java.lang.String`	`toString()`
`int`	`up()`
`int`	`upEx()` In the normal (non-exception) scheme of things, the iStack is incremented by down() on the way down and decremented by a corresponding up() when returning or pausing.
`void`	`wrongPC()`
`static void`	`yield()` yield cooperatively to the next task waiting to use the thread
`static void`	`yield(Fiber f)` yield cooperatively to the next task waiting to use the thread

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - curState
```
public State curState
```
    The current frame's state (local vars and elements of the operand stack that will be needed when the Fiber is resumed. It is always kept equal to stateStack[iStack] if iStack is in the (0..stateStack.length-1) range, and null otherwise. This is used by the generated code to avoid having to manipulate stateStack in the generated code, and to isolate all stack manipulations to up() and down().
  - pc
```
public int pc
```
    The "program counter", kept equal to stateStack[iStack].pc and is used to jump to the appropriate place in the code while rewinding the code, and also to inform the weaved code inside an exception handler which pausable method (if at all) was being invoked when that exception was thrown. The value 0 refers to normal operation; control transfers to the beginning of the original (pre-weaved) code. A value of n indicates a direct jump into the nth pausable method (after restoring the appropriate state). Accessed by generated code (hence public).
  - task
```
public Task task
```
  - NOT_PAUSING__NO_STATE
```
public static final int NOT_PAUSING__NO_STATE
```
    See Also:
    
    Constant Field Values
  - NOT_PAUSING__HAS_STATE
```
public static final int NOT_PAUSING__HAS_STATE
```
    See Also:
    
    Constant Field Values
  - PAUSING__NO_STATE
```
public static final int PAUSING__NO_STATE
```
    See Also:
    
    Constant Field Values
  - PAUSING__HAS_STATE
```
public static final int PAUSING__HAS_STATE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Fiber
```
public Fiber(Task t)
```
- Method Detail
  - task
```
public Task task()
```
  - isDone
```
public boolean isDone()
```
  - pause
```
public static void pause()
                  throws Pausable
```
    Throws:
    
    Pausable
  - reset
```
public void reset()
```
  - yield
```
public static void yield()
                  throws Pausable
```
    yield cooperatively to the next task waiting to use the thread
    
    Throws:
    
    Pausable
  - yield
```
public static void yield(Fiber f)
```
    yield cooperatively to the next task waiting to use the thread
  - pause
```
public static void pause(Fiber f)
```
  - up
```
public int up()
```
  - begin
```
public final Fiber begin()
```
  - end
```
public final boolean end()
```
    end() is the last up(). returns true if the fiber is not pausing.
  - down
```
public Fiber down()
```
  - upEx
```
public int upEx()
```
    In the normal (non-exception) scheme of things, the iStack is incremented by down() on the way down and decremented by a corresponding up() when returning or pausing. If, however, an exception is thrown, we lose track of where we are in the hierarchy. We recalibrate iStack by creating a dummy exception and comparing it to the stack depth of an exception taken earlier. This is done in scheduler.getStackDepth(); A sample stack trace of the dummy exception looks as follows
```
   at kilim.Fiber.upEx(Fiber.java:250)
   at kilim.test.ex.ExCatch.normalCatch(ExCatch.java)
   at kilim.test.ex.ExCatch.test(ExCatch.java)
   at kilim.test.ex.ExCatch.execute(ExCatch.java)
   at kilim.Task.runExecute(Task.java)
   at kilim.WorkerThread.run(WorkerThread.java:11)
 
```
    We have to figure out the stack depth (iStack) of the method that caught the exception and called upEx ("normalCatch" here). The call stack below runExecute may be owned by the scheduler, which may permit more than one task to build up on the stack. For this reason, we let the scheduler tell us the depth of upEx below the task's execute().
    Returns:
    
    Fiber.pc (note: in contrast up() returns status)
  - getCallee
```
public java.lang.Object getCallee()
```
    Called by the weaved code while rewinding the stack. If we are about to call a virtual pausable method, we need an object reference on which to call that method. The next state has that information in state.self
  - setCallee
```
public void setCallee(java.lang.Object callee)
```
  - setState
```
public void setState(State state)
```
    Called by the generated code before pausing and unwinding its stack frame.
    
    Parameters:
    
    state -
  - getState
```
public State getState()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - wrongPC
```
public void wrongPC()
```

Class Fiber

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

curState

pc

task

NOT_PAUSING__NO_STATE

NOT_PAUSING__HAS_STATE

PAUSING__NO_STATE

PAUSING__HAS_STATE

Constructor Detail

Fiber

Method Detail

task

isDone

pause

reset

yield

yield

pause

up

begin

end

down

upEx

getCallee

setCallee

setState

getState

toString

wrongPC