anchor.diff:  
   %% @private
   %% @doc Move the top process of the secondary queue to the primary.
  +-spec promote( #state{} ) -> {ok, #state{}}.
   promote( #state{rdyQ1=Q1, rdyQ2=Q2} = State ) ->
       case queue:out( Q2 ) of
           {empty, _} -> {ok, State};
  
positive.code: %% @doc Implements the CML based picker which looks at the dual level queue
  %%   to select a process from the primary or secondary queues.
  %% @end
  pick_next( #state{ curThread=T, curReduct=R } = State ) ->
      ok. %TODO
  
  
  %% @hidden
  %% @doc Perform a reduction.
  reduce( #state{ curThread=T, curReduct=R } = State ) ->
      case erlam_rts:safe_step(T) of
          {ok,NP} -> {ok, running, State#state{ curThread=NP,
                                                           curReduct=R-1 }}; 
          {stop,NP} -> check_on_stop( NP, State );
          {yield, NP} -> %% This was a swap, and intentional yield
             ok; 
          {hang, NP, Sleep} -> 
          %% We are sleeping, so hang (stop the world style), and set reductions
          %% to zero (ignoring what they were before). Will push the process to
  
negative.code: %% @doc Return the Scheduler topology for this scheduler implementation. This
  %%   uses only Processor0, and will round robit on the primary work queue.
  %% @end
  layout( _CPUTop, Options ) ->
      ProcID = 0,                % Bind Scheduler to Processor with ID = 0.
      Module = ?MODULE,          % Use the callbacks in this module for scheduling
      Opts = parse_sched_opts( Options ), % Pull out options passed to scheduler
      { ProcID,                  % Set this scheduler as primary (for main function)
         [ {ProcID, Module, Opts} ]}.
  
  %% @doc Initializing the scheduler on the processor is easy as returning default
  %%   state. The state will hold the local work queue and thats it.
  %% @end
  init( Options ) -> get_options( Options, #state{} ).
  
  %% @doc Cleanup is simple too, we ignore unfinised processes in the queue.
  cleanup( _State ) -> ok.
  