Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • doc/proposals/concurrency/text/together.tex

    r20ffcf3 r3364962  
    77
    88\section{Threads as monitors}
    9 As it was subtely alluded in section \ref{threads}, \code{threads} in \CFA are in fact monitors, which means that all monitor features are available when using threads. For example, here is a very simple two thread pipeline that could be used for a simulator of a game engine :
     9As it was subtely alluded in section \ref{threads}, \code{threads} in \CFA are in fact monitors. This means that all the monitors features are available when using threads. For example, here is a very simple two thread pipeline that could be used for a simulator of a game engine :
    1010\begin{cfacode}
    1111// Visualization declaration
    … …  
    3636}
    3737\end{cfacode}
    38 One of the obvious complaints of the previous code snippet (other than its toy-like simplicity) is that it does not handle exit conditions and just goes on forever. Luckily, the monitor semantics can also be used to clearly enforce a shutdown order in a concise manner :
     38One of the obvious complaints of the previous code snippet (other than its toy-like simplicity) is that it does not handle exit conditions and just goes on for ever. Luckily, the monitor semantics can also be used to clearly enforce a shutdown order in a concise manner :
    3939\begin{cfacode}
    4040// Visualization declaration
    … …  
    7272        }
    7373}
    74 
    75 // Call destructor for simulator once simulator finishes
    76 // Call destructor for renderer to signify shutdown
    7774\end{cfacode}
    7875
    7976\section{Fibers \& Threads}
    80 As mentionned in section \ref{preemption}, \CFA uses preemptive threads by default but can use fibers on demand. Currently, using fibers is done by adding the following line of code to the program~:
    81 \begin{cfacode}
    82 unsigned int default_preemption() {
    83         return 0;
    84 }
    85 \end{cfacode}
    86 This function is called by the kernel to fetch the default preemption rate, where 0 signifies an infinite time-slice i.e. no preemption. However, once clusters are fully implemented, it will be possible to create fibers and uthreads in on the same system :
    87 \begin{figure}
    88 \begin{cfacode}
    89 //Cluster forward declaration
    90 struct cluster;
    91 
    92 //Processor forward declaration
    93 struct processor;
    94 
    95 //Construct clusters with a preemption rate
    96 void ?{}(cluster& this, unsigned int rate);
    97 //Construct processor and add it to cluster
    98 void ?{}(processor& this, cluster& cluster);
    99 //Construct thread and schedule it on cluster
    100 void ?{}(thread& this, cluster& cluster);
    101 
    102 //Declare two clusters
    103 cluster thread_cluster = { 10`ms };                     //Preempt every 10 ms
    104 cluster fibers_cluster = { 0 };                         //Never preempt
    105 
    106 //Construct 4 processors
    107 processor processors[4] = {
    108         //2 for the thread cluster
    109         thread_cluster;
    110         thread_cluster;
    111         //2 for the fibers cluster
    112         fibers_cluster;
    113         fibers_cluster;
    114 };
    115 
    116 //Declares thread
    117 thread UThread {};
    118 void ?{}(UThread& this) {
    119         //Construct underlying thread to automatically
    120         //be scheduled on the thread cluster
    121         (this){ thread_cluster }
    122 }
    123 
    124 void main(UThread & this);
    125 
    126 //Declares fibers
    127 thread Fiber {};
    128 void ?{}(Fiber& this) {
    129         //Construct underlying thread to automatically
    130         //be scheduled on the fiber cluster
    131         (this.__thread){ fibers_cluster }
    132 }
    133 
    134 void main(Fiber & this);
    135 \end{cfacode}
    136 \end{figure}
Note: See TracChangeset for help on using the changeset viewer.