\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}{}
\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}{}
PROCESSOR_OBJECT_TYPE
processor1
a_network
MONOCORE_TYPE
NO_MIGRATION_TYPE
\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}{}
PROCESSOR_OBJECT_TYPE
processor1
a_network
IDENTICAL_MULTICORES_TYPE
TIME_UNIT_MIGRATION_TYPE
\end{lstlisting}
\caption{An example of $Multi_{-}cores_{-}processor$ description}
\label{Processor_example}
\end{figure}