\subsubsection{Processor}
\label{processor}

The entity \processor is specified by the following definitions: \\

(1) It is a deployment unit for a software component.\\

(2) It is composed by a set of \cores and \caches. \\

(3) We distinguish in Cheddar two separate cases: 
\textbf{Mono}$_{-}$\textbf{Core}$_{-}$\textbf{Processor} and 
\textbf{Multi}$_{-}$\textbf{Core}$_{-}$\textbf{Processor}.\\

\begin{center}
Standard attributes
\end{center}

$Name$ : It is the unique name of $Processor$.\\

$Network$: It is a string, which corresponds to the name of entity \network connected to
the \processor.\\

$Processor_{-}Type$: It is an enumeration, which defines the type of considered \processor. \\
	
$Migration_{-}Type$: It is an enumeration, which defines the type of \tasks
migration between the \cores of the \processor.

In Cheddar, we assume that a \task may be migrated only between jobs.
		
\begin{center}
Legality rules
\end{center}

(L1) The \processor name must not be empty.\\

(L2) The \processor name must be valid identifier.\\

(L3) \cores should not be empty in the $Multi_-cores_-processor$ case.\\

(L4) If the \processor type is $Monocore_{-}Type$, it must exist at least one \core. \\

(L5) If the \processor type is $Multicore_{-}Type$, it must exist several \cores. \\

\begin{center}
Annexes
\end{center}

(A1) The types of \processors \cite{Lawler78} \cite{Maculan99} \cite{Baruah03} 
\cite{Hyari09} \cite{Jansen12}.\\

\indent \indent (A11) $Monocore_{-}Type$: It is a \processor with only one \core.\\
In this case, the \processor only executes one instruction flow, i.e. one \task, at a time.\\
                                                                              
The 	$Multicore_{-}Type$ references to a \processor with 
two or more processing units, i.e.  \core components.\\

\indent \indent (A12) $Identical_{-}Multicores_{-}Type$: In this case, 
all processors are identical.

That means processors have the same computing capability and run
task at the same rate.\\

\indent \indent (A13) $Uniform_{-}Multicores_{-}Type$: Each \processor $P$ 
is characterized by a 
single parameter
\textit{speed} (or computing capacity), named $Speed(P)$, with the interpretation that a job 
that executes on processor $P$ for $t$
time units completes $Speed(P) × t$ units of execution.\\

\indent \indent (A14) $Unrelated_{-}Multicores_{-}Types$: In this case, \processors 
differ 
in area, performance, power dissipated, speed, $\dots$ 

An execution rate is defined for every uplet ($r_{i,j}$ , $i$, $j$): 
the work $i$ requires $r_{i,j}$ units of time on the processor $j$.\\

(A2) The types of Migrations \cite{Kartre09} \cite{Fisher07} \cite{Sakar11}.\\

\indent \indent (A21) $No_{-}Migration_{-}Type$: When no migration is allowed between the 
\textbf{Cores} of a \processor.

A \task that begins its execution on a \core cannot migrate
and must always run on this one.\\

\indent \indent (A22) $Job_{-}Level_{-}Migration_{-}Type$:  
a \task  can run its successive jobs in different  \cores.

When a job is started in one \core, the task cannot migrate before 
the job is completed, i.e. a job starting in a given \core must be
completed on the same \core. 

Job-level parallelism is forbidden 
(i.e., a job may not execute concurrently with itself on two or more different \cores.\\

\indent \indent (A23) $Time_{-}Unit_{-}Migration_{-}Type$: 
A \task can migrate at any time on any $Cores$ of the processor.

Job-level parallelism is also forbidden in this case.\\

(A3) \textbf{Mono}$_{-}$\textbf{Core}$_{-}$\textbf{Processor} is defined by the 
following parameter:\\

\indent \indent (A31) $Core$: It is the corresponding core to the 
\textbf{Mono}$_{-}$\textbf{Core}$_{-}$\textbf{Processor}. 

It is 	characterized by:\\

\indent \indent \indent \indent (A311) $Scheduling$: See the \core description.\\

\indent \indent \indent \indent (A312) $Speed$: See the \core description.\\

\indent \indent \indent \indent (A313) $L1_{-}Cache_{-}System_{-}Name$: 
See the \core description.\\

(A4) \textbf{Multi}$_{-}$\textbf{Core}$_{-}$\textbf{Processor} is a single 
computing component with two or 
more independent  \cores, which are the units
 that read and execute program instructions \cite{Rouse07}. 
 
It allows to schedule tasks globally with a set of cores.

It is defined by the following parameters:\\

\indent \indent (A41) $Cores$: The list of $Cores$ of the $Processor$.\\

\indent \indent (A42) $L2_{-}Cache_{-}System_{-}Name$: It is a list of $0$ or several $Caches$.

When it exists, it is $Unified$: it corresponds to $Data_-Instruction_-Cache$.

In this case, all corresponding $L1_-Cache_-System$ are separated.\\

\begin{center}
Implementation
\end{center}

The figure \ref{dtd_proc} gives the DTD of entity \processor.


\begin{figure}{}
\begin{lstlisting}{}
<!ELEMENT processors (generic_processor 
  | mono_core_processor | multi_cores_processor)+>
<!ELEMENT generic_processor (object_type 
  | name | network_name | processor_type | 
  migration_type)*>
<!ATTLIST generic_processor id ID #REQUIRED>
<!ELEMENT mono_core_processor (object_type 
  | name | network_name | processor_type | 
  migration_type | core)*>
<!ATTLIST mono_core_processor id ID #REQUIRED>
<!ELEMENT multi_cores_processor (object_type 
  | name | network_name | processor_type | 
  migration_type 
  | cores | l2_cache_system_name)*>
<!ATTLIST multi_cores_processor id ID #REQUIRED>
\end{lstlisting}
	\caption{The DTD of entity \processor}
	\label{dtd_proc}
\end{figure}


\begin{center}
Example
\end{center}

The example of figure \ref{Processor_example_mono} 
describes a $Mono_{-}core_{-}processor$, 
with one core referenced by $id$ $75$. 

Notice the type of $Processor$ ($MONOCORE_-TYPE$) and the type of $Migration$ 
($NO_-MIGRATION_-TYPE$).


\begin{figure}{}
\begin{lstlisting}{}
<processors>
	<mono_core_processor id=" 77" >
	<object_type>PROCESSOR_OBJECT_TYPE</object_type>
		<name>processor1</name>
		<network>a_network</network>
		<processor_type>MONOCORE_TYPE
		</processor_type>
		<migration_type>NO_MIGRATION_TYPE
		</migration_type>
		<core ref=" 75" />
	</mono_core_processor>
</processors>
\end{lstlisting}
\caption{An example of $Mono_{-}core_{-}processor$ description}
\label{Processor_example_mono}
\end{figure}

The example of figure \ref{Processor_example} describes a $Multi_{-}cores_{-}processor$, 
with two cores referenced by their $id$ ($67$, $68$). 

It has two identical cores (that means that the cores have 
the same computing capability and run
$Task$ at the same rate), and migrations between 
cores is of the type $time_{-}unit_{-}migration$; that means that a job requires one time unit 
for task migration between two cores.


\begin{figure}{}
\begin{lstlisting}{}
<processors>
	<multi_cores_processor id=" 69">
	<object_type>PROCESSOR_OBJECT_TYPE</object_type>
		<name>processor1</name>
		<network>a_network</network>
		<processor_type>IDENTICAL_MULTICORES_TYPE
		</processor_type>
		<migration_type>TIME_UNIT_MIGRATION_TYPE
		</migration_type>
		<cores>
			<core_unit ref=" 67"/>
			<core_unit ref=" 68"/>
		</cores>
	</multi_cores_processor>
</processors>
  \end{lstlisting}
\caption{An example of $Multi_{-}cores_{-}processor$ description}
\label{Processor_example}
\end{figure}