\newpage
%===========================================================================
%       x.12 > OPENMOSIX INTERNALS
%===========================================================================
\pagestyle{empty}
\begin{latexonly}
\ifpdf
 \begin{figure}[htbp]
%      \includegraphics[bb = -250 220 0 0, scale=1]{./TuXes/tux-.jpg}
 \end{figure}
 \vspace{5in}
\else
 \begin{figure}
%      \includegraphics[-275,650][0,0]{./TuXes/tux-}
 \end{figure}
\fi
\hfill\line(1,0){400}
\end{latexonly}
\topmargin 1in
\section{MODELIZACI\'ON MATEM\'ATICA DE PROCEDIMIENTOS}
\begin{latexonly}
\line(1,0){400}
\newpage
\end{latexonly}
\topmargin 0in
\pagestyle{fancy}
%========================cita===============================================
\begin{latexonly}
\hspace{1in}\textcolor{blue_omosix}{{\em Pure mathematics is, in its way, the poetry of logical ideas.}}

\hspace{4in}\textcolor{blue_omosix}{{\em Albert Einstein}}
\vspace{0.5in}
\end{latexonly}
%===========================================================================
\subsection*{Formalizaci\'on de recursos. Objectivo de rendimento}
La formalizaci\'on de los recursos que posee cada nodo permitir\'a construir una visi\'on general
del funcionamiento de ponderaci\'on de tales recursos dentro del cluster.
La nomenclatura a partir de ahora utilizada identificar\'a

\begin{itemize}
  \item $I = \{ i_1, i_2, ..., i_n \},\ \ n\ \in\ \mathbb{N}\ \ \equiv$ el conjunto de $n$ nodos que
  conforman el cluster.
\end{itemize}

Luego los $m$ recursos que posee un nodo $i_k$ cualquiera se identificaran por el conjunto $R(i_k)$
de esta forma:

\begin{itemize}
  \item $R(i_k) = \{ r_c(i_k),\ r_m(i_k),\ ...\ \},\ \ 1\leq k\leq n\ \ \equiv$
  conjunto de recursos del nodo $i_k$ .
  \item $|R(i_k)|=m$ .
\end{itemize}

Esto permite ver a cada nodo como un c\'umulo de recursos, dispuestos para ser
utilizados por el cluster. por lo tanto, extrapolando conceptos, un cluster no
deja de ser tambi\'en una conjunci\'on de recursos, as\'\i\:

\begin{itemize}
  \item $R(I) = \{R(i_1)\ \wedge\ R(i_2)\ \wedge\ ...\ \wedge\ R(i_n) \} =
 \{\ \{r_c(i_1),\ r_m(i_1),\ ...\ \}\ \wedge\ \{r_c(i_2),\ r_m(i_2),\ ...\ \}\ \wedge\
 ...\ \wedge\ \{r_c(i_n),\ r_m(i_n),\ ...\ \}\ \}$

\end{itemize}

Un nodo puede tener muchos recursos a la vez: procesador, memoria, targetas PCI, dispositivos
de E/S, {\em etc.}. Sin embargo no es ahora tan importante saber cuantos
recursos gestiona openMosix sino c\'omo lo hace. Esto es, ?`c\'omo
se llega a la ponderaci\'on de cada nodo?

Antes de responder es importante apuntar lo que debiera haberse comprendido en
la secci\'on anterior: openMosix basa sus decisiones de migraci\'on en una
algor\'\i tmica basada en modelos econ\'omicos, donde los recursos
estan ponderados en una misma escala para simplificar los c\'alculos. Estos c\'alculos
deben ser computables en el menor intervalo de tiempo posible para dotar al
sistema de la m\'axima adaptabilidad a las condiciones cambiantes que los
usuarios -los procesos en \'ultima instancia- puedan propiciar.

 No se entrar\'a -por el momento- en averiguar c\'omo se equiparan par\'ametros tan
dispares como velocidad de procesamiento o cantidad de memoria. Lo relevante ahora es ver qu\'e permite hacer esta
asignaci\'on. Se supondr\'a, para cualquier nodo $i$:

\begin{itemize}
   \item $\displaystyle r_c(i_k),\ c\ \epsilon\ R(i_k) \equiv$ velocidad de
   procesador de $i_k$ ,

   \item $\displaystyle r_m(i_k),\ m\ \epsilon\ R(i_k) \equiv$ tama\~{n}o de memoria de $i_k$ .
\end{itemize}

Igualmente interesa poder estimar los recursos que necesitar\'an las distintas
tareas $j$, de cara a predecir el nodo donde se ejecutar\'\i an con m\'as
celeridad. As\'\i\ se definen para las tareas cuatro par\'ametros.

\begin{itemize}
   \item $a(j,i_k) \equiv$ tiempo de llegada de la tarea $j$ en el nodo $i_k$ ,
   \item $c(j,i_k) \equiv$ tiempo de procesador estimado necesario para la ejecuci\'on,
   \item $m(j,i_k) \equiv$ cantidad de memoria necesaria,
   \item $T(j,i_k) \equiv$ tiempo real invertido en la finalizaci\'on de la ejecuci\'on.
\end{itemize}

Se asume, para una algor\'\i tmica {\em no ideal} -y por tanto suponi\'endose implementable- que
$m(j,i_k)$ y $c(j,i_k)$ son conocidos y $T(j,i_k)$ es desconocido en $a(j,i_k)$.

\vspace{.2in}
La finalidad de la definici\'on de los par\'ametros que hasta ahora se han
visto es poder decidir diversos aspectos que conciernen a la migraci\'on de
procesos -en \'ultima instancia, el objetivo de openMosix-: decisiones sobre
qu\'e proceso migrar y d\'onde hacerlo se apoyan precisamente en
los par\'ametros vistos. Esto es, para definir qu\'e proceso deber\'a migrarse
deben medirse los recursos -y la cantidad de ellos- que ocupar\'a en el nodo
que lo hospede. Igualmente para saber qu\'e nodo es el mejor para aceptar dicho proceso
deber\'a medirse la carga computacional de un cierto n\'umero de ellos para saber
cual dispone de mayor cantidad de ella y, en consecuencia, cual ser\'a capaz de
retornar el resultado de proceso en el menor tiempo posible.

El poder computacional de un nodo queda definido no solamente por la
ponderaci\'on de sus recursos, sino por la utilizaci\'on de ellos tanto en el
actual instante como en el futuro que venga marcado por la planificaci\'on de
tal recurso.

Deber\'\i a definirse la carga de un nodo. Esto es para un nodo $i_k$ en el
instante $t$:
\begin{itemize}
  \item $J(t,i_k)\ \in\ \mathbb{N} \equiv$ procesos en ejecuci\'on,
  \item $carga_c(t,i_k) \propto J(t,i_k)\ \equiv$ carga de procesador ($\in\ \mathbb{Z}^+$) ,
  \item $carga_m(t,i_k) = \displaystyle\sum_{j\ \epsilon\
  J(t,i_k)} m(j)\ \equiv$ carga de memoria ($\in\ \mathbb{Z}^+$).
   \item  $LOAD=\displaystyle\sum \left[ carga_c(t,i_k) +
  carga_m(t,i_k)\right],\ \forall\ i_k\ \in\ I \equiv$ es la  carga total en el sistema en el
  instante $t$ .
\end{itemize}

An\'alogamente, la carga de un nodo se mide en funci\'on de los recursos de
que ya no dispone. En este caso se han dado las expresiones para procesador y memoria.

No obstante para medir la carga de un nodo openMosix no utiliza solamente esta
aproximaci\'on. Hay condiciones que pueden desajustar notablemente los valores
para la carga calculada y la carga real, mayormente cuando el nodo hace {\em
  swapping}.

La implemenaci\'on de openMosix soluciona este apartado sirvi\'endose de un par\'ametro
$s$, que se convertir\'a en un factor que multiplicar\'a a la expresi\'on de
carga del nodo y que por tanto sobredimensionar\'a el valor calculado tras el
repaso de la ponderaci\'on de recursos. Esto tiene una completa l\'ogica ya
que con acceso a {\em swap} el procesador tiene que utilizar muchos m\'as ciclos que trabajando
con memoria, para recuperar una p\'agina.

Para formalizar esta idea puede escribirse:
\begin{itemize}
   \item si $carga_m(t,i_k) \leq r_m(i_k) \Longrightarrow carga_c(t,i_k) = J(t,i_k)$ ,
   \item si $carga_m(t,i_k) > r_m(i_k) \Longrightarrow carga_c(t,i_k) =
   J(t,i_k)*s$ .
\end{itemize}

\vspace{.2in}
{\bf\sc Objetivo de rendimiento de openMosix}

\vspace{.1in}
El objetivo de los c\'alculos de openMosix es optimizar el aprovechamiento de la
totalidad de los recursos del sistema. As\'\i\ por ejemplo, para cada nuevo proceso
iniciado no se estudia solamente el aumento de carga en el nodo local, sino que se tiene en cuenta el
contexto de carga de todo el sistema.
Cuando existen suficientes procesadores en el cluster para encargarse de su
carga, cada proceso se servir\'a al procesador menos cargado
y se devolver\'a la respuesta tan r\'apido como pueda hacerlo.

Si por el contrario no existen suficientes procesadores para encargarse de los
procesos pendientes de ejecuci\'on, se evaluar\'a el tiempo de ejecuci\'on
para un nodo y para el resto de los nodos. De esta manera se llega a un
completo estudio sobre el impacto del aumento de carga que  \'este propicia al
sistema, para luego decidir cual es el mejor nodo de ejecuci\'on. Antes de ver
esto se define:

\begin{itemize}
  \item $N=\displaystyle\sum_{i_k\ \in\ I} r_c(i_k)\ \equiv$ es el
  n\'umero de unidades de procesamiento del cluster.

  \item $L=carga_c(t,i_k)\ \equiv$ es la carga de los elementos procesadores de cualquier nodo.
\end{itemize}

Se deduce que la carga total de todos los procesadores del cluster ser\'a
$NL$ . Si la carga para cualquier nodo es $L$, la carga de los restantes es
$N(L-1)$ . La carga :

\begin{itemize}
    \item sin tener en cuenta el nuevo proceso se necesitar\'an $\frac{N(L-1)}{N}$
    unidades de tiempo para completarse,
    \item con el nuevo proceso ser\'\i an necesarias $\frac{NL}{N}=L$ unidades de
    tiempo.
\end{itemize}

La p\'erdida de tiempo comparativa para la ejecuci\'on de los $NL-1$
 procesos en funci\'on de estas dos situaciones se puede expresar como:

\vspace{.1in}
$\displaystyle L-\frac{1}{N}$ .

\vspace{.1in}
La algor\'\i tmica de openMosix intentar\'a minimizar esta p\'erdida.
%---------------------------------------------------------------------------
\subsection*{Optimizando la planificaci\'on}
Hasta el momento se ha estado viendo la modelizaci\'on de openMosix
para cada nodo, ahora ser\'\i a conveniente fijar como objetivo el c\'alculo para el
algoritmo que reconoce esta modelizaci\'on y opera en consecuencia a ella. El
punto de partida ser\'a el algoritmo \'optimo. Esto permitir\'a que, tras la comparaci\'on con el que
openMosix implementa, sea factible comparar resultados para ver cu\'anto se
acerca el caso real, al ideal.

Pero la algor\'\i tmica utilizada depende enormementede la topolog\'\i a de
los nodos el cluster, es decir, no supone el mismo esfuerzo computacional hacer los c\'alculos sobre
efectos de carga para un conjunto de m\'aquinas {\em
  iguales}\footnote{Refiri\'endose a una misma arquitectura y una
  ponderaci\'on de los recursos equivalente.} -donde la carga
repercutir\'a num\'ericamente igual y por lo tanto solo ser\'a necesario hacer
la predicci\'on una vez- que para un conjunto de m\'aquinas donde la carga
supone una sobrecarga distina.

Esta situaci\'on debe tenerse en cuenta, y se modeliza de la siguiente forma:

\begin{itemize}
  \item {\bf Nodos id\'enticos:} todos y cada uno de los nodos del cluster
  poseer\'a todos y cada uno de los recursos de cualquier otro nodo. Esto
  implica que un proceso supondr\'a el mismo augmento de carga para cualquier
  nodo. V\'ease:

 $\displaystyle IDENTICOS= \{\ \left[ R(i_a),R(i_b) \right] \ | \ R(i_a)=R(i_b) \ \ \forall\ i_a,i_b\
  \in\ I\ \ \wedge\ r_c(i_a)=r_c(i_b),r_m(i_a)=r_m(i_b)\ \} \Rightarrow\ c(j,i_a)=c(j,i_b)$ .

  \item {\bf Nodos relacionados:} todos los nodos del cluster poseen los
  mismos recursos, aunque pueden diferir en su ponderaci\'on. Imag\'\i nese
  por ejemplo un cluster de nodos id\'enticos aunque con los procesadores a diferentes velocidades.


 $\displaystyle RELACIONADOS= \{\ \left[ R(i_a),R(i_b) \right] \ | \
 R(i_a)=R(i_b)\ \ \forall\ i_a,i_b\ \in\ I\ \ \wedge\ r_c(i_a) \neq
 r_c(i_b)\vee r_m(i_a)\neq r_m(i_b)\ \} \Rightarrow\ c(j,i_a)\neq c(j,i_b)$ .

  \item {\bf Nodos no relacionados:} los nodos tienen diferentes recursos.

 $NO\_RELACIONADOS= \{\ \left[ R(i_a),R(i_b) \right] \ | \ \exists\
 R(i_a)\neq R(i_b)\ \ \forall\ i_a,i_b\ \in\ I\ \}$ .
\end{itemize}

Dadas estas diferentes situaciones podr\'a darse un algoritmo para resolver la
planificaci\'on en cada una de ellas, y como se ha apuntado se medir\'a su
ratio de competencia con el algoritmo \'optimo. Por lo tanto van a
compararse.

Un algoritmo que se ejecuta a la vez que los procesos -a tiempo real- es
competitivo de grado $c$ si para una secuencia de entrada $I$, 
$algoritmo(I) \leq c\ *\ optimo(I) + \alpha$ , siendo $\alpha$ una constante
definida y $optimo$ el algoritmo ideal que no se calcula.

\vspace{.1in}
Esta expresi\'on toma diferentes valores para $c$ dependiendo del algoritmo
utilizado para resolver la planificaci\'on, y dicha planificaci\'on depende de
la topolog\'\i a del cluster que anteriormente ya se ha clasificado. Esta clasificaci\'on imprime diferencias a diferentes niveles. El m\'as
immediato, como se ha citado, es en la decidibilidad del algoritmo de
migraci\'on. El grado de competici\'on $c$ seg\'un la topolog\'\i a se define:

\begin{itemize}
  \item Para un cluster con nodos id\'enticos se toma el {\em algoritmo egoista},
  que asigna procesos a la m\'aquina que tenga la menor carga en el momento de
  tomar la decisi\'on de asignaci\'on de tal proceso. El ratio de
  competici\'on frente al algoritmo \'optimo para este algoritmo es $\rightarrow\ c=2-{\frac{1}{n}}$ .

  \item Para un cluster con nodos relacionados se ha implementado el {\em
  algoritmo Assign-R} el cual asigna cada trabajo que llega al nodo m\'as
  lento. El coste de esta asignaci\'on es inferior al doble de la asignaci\'on
  hecha por el algoritmo \'optimo, lo que da $\rightarrow\ c=2$ .

  \item Para un cluster con nodos no relacionados no se conoce todav\'\i a un
  algoritmo con un ratio de competici\'on mejor que $n$. Esto se debe a que en
  este caso hay que tener en cuenta muchas variables que en los dem\'as casos
  pod\'\i an obviarse.

Existe no obstante el {\em algoritmo Assign-U} pensado especialmente para
  m\'aquinas que no tienen relaci\'on entre s\'\i\, para trabajos que se
  mantienen en un mismo nodo, basado en una funci\'on exponencial para el
  coste de un nodo en particular para una carga dada. Este algoritmo asigna
  cada trabajo a uno de los nodos para minimizar el coste total de todos los
  nodos del cluster. Este algoritmo es:

  $\displaystyle U_i(j)=\alpha^{carga_i(j)+p_i(j)}-\alpha^{carga_i(j)}$ ,
 donde
   \begin{itemize}
     \item $1 \leq  \alpha \leq 2$ . En el caso concreto de openMosix $\alpha$
     = 2.
     \item $carga_i(j)$ es la carga que tiene un nodo $i$ antes de
     que le sea asignado un trabajo $j$ .
     \item $p_i(j)$ es la carga que un trabajo $j$ a\~{n}adir\'a a un nodo $i$ .
   \end{itemize}
\end{itemize}

Como se puede ver, la formula favorece a los nodos que tienen cargas menores.
Por ejemplo supongamos que tenemos 2 nodos, uno de ellos con una carga 5 y otro nodo
 con una carga 10.
 En esta configuraci\'on hemos decidido que el par\'ametro $\alpha$ tenga un
 valor de 2 (para simplificar nuestros c\'alculos).
 Se inicia un nuevo trabajo que a\~{n}ade una carga de 1.
 Para nuestros dos nodos tenemos:

\vspace{.1in}
$U_1(j)=2^{5+1}-2^5=64-32=32$ ,

$U_2(j)=2^{10+1}-2^{10}=2048-1024=1024$ .

\vspace{.1in}
Claramente el primer valor que corresponde al nodo con menor carga (5) minimiza
 la carga del sistema por lo tanto se elegir\'a el primer nodo como nodo
 destinatario del nuevo proceso.
Las cargas de los nodos se ponderan en potencias de base 2 -gracias a
$\alpha$- y esto permite agrupar los nodos con cargas iguales. La resoluci\'on
del nodo con menor carga final puede calcularse a aprtir de un \'arbol binario.
Este algoritmo es competitivo de grado $O(\log_2 n)$, para m\'aquinas no relacionadas
 y trabajos permanentes.

 Se puede extender este algoritmo y el ratio de competitividad a los trabajos
 que migran usando como m\'aximo $O(\log_2 n)$ migraciones por trabajo.
 Para este nuevo tipo de situaci\'on necesitamos un par\'ametro m\'as $h_i(j)$
 que es la carga de un nodo $i$ justo antes de que $j$ haya sido por \'ultima
 vez asignado a $i$. Cuando un trabajo ha finalizado, este algoritmo comprueba la estabilidad
 del sistema para cada trabajo $j$ en cada nodo $M$. Esta es una condici\'on
 de estabilidad que siendo $i$ el nodo donde el trabajo $j$ est\'a
 actualmente, se definde como: 

\vspace{.1in}
$\displaystyle \alpha ^{h_i(j)+p_i(j)}-a^{h_i(j)}\leq 2* (\alpha^{carga_M(j)+P_M(j)}-\alpha^{carga_M(j)})$

\vspace{.1in}
Si esta condici\'on no es satisfecha por alg\'un trabajo, el algoritmo reasigna
 el trabajo que no satisface la condici\'on a un nodo $M$ que minimiza
 $U_M(j)$ .

Esta f\'ormula es quiz\'as m\'as omplicada de ver que las dem\'as. Se detallan
seguidamente sus factores:


\vspace{.2in}
Entre las reflexiones que pueden sacarse de este estudio se encuentra la
explicaci\'on a la clara tendencia a construir clusters con nodos
id\'enticos o con las m\'\i nimas diferencias entre nodos. El rendimiento
ser\'a mucho m\'as generoso.
%---------------------------------------------------------------------------
\subsection*{Modelo simplificado de ponderaci\'on}
Una vez formalizados los recursos, los nodos y su relaci\'on dentro del
mecanismo que pone en marcha el cluster para ser capaz de realizar sus
decisiones, solo falta ver la ponderaci\'on, es decir, el valor num\'erico que
todo ello representa. La modelizaci\'on que gestiona openMosix para trabajar con los elementos del
cluster es un grafo poderado $G(A,V,P)$, donde:
\begin{itemize}
   \item $A$: conjunto de arcos $a$ que se corresponden al medio de transporte de datos,
   \item $V$: conjunto de v\'ertices -nodos-,
   \item $P$: funci\'on de incidencia del grafo, definida en $A \rightarrow V$, -se ve m\'as adelante-.
\end{itemize}

Se define tambi\'en una secuencia de llegada de peticiones, en tiempos
arbitrarios, que como puede preverse son los procesos que llegan a un nodo
-localmente por el usuario o desde un remoto- para ser ejecutados. V\'ease
cada elemento con m\'as detalle.

\vspace{.2in}
A cada arco -f\'\i sicamente un enlace de red- se le asocia cierta ponderaci\'on que ir\'a en
aumento cada vez que se genere una comunicaci\'on sirvi\'endose de \'el. Esta
situaci\'on se produce cada vez que un proceso crea un nexo entre su {\em
  remote} y su {\em deputy}, puesto que ambas partes deben permanecer
continuamente comunicadas. Al referirse a un canal real de comunicaci\'on, es
necesario asociarles una capacidad -ancho de banda-, sea $B(a)$.

La petici\'on producida por la tarea $j$ que sea asignada a un camino -conjunto de arcos por los que
circular\'a la petici\'on- desde una fuente $i_s$ a un destino $i_d$ disminuye la capacidad
$B(a)$ en cada uno de los arcos que pertenecen a este camino en una cantidad $carga_a(j)$.
El objetivo es {\bf minimizar la congesti\'on} $C(a)$ m\'axima de cada uno de los enlaces,
que es el ratio entre el ancho de banda requerido de un enlace y su capacidad:

\vspace{.1in}
\begin{center}
 $\displaystyle C(a)=\frac{carga_a(j)}{B(a)}\ \equiv$ congesti\'on de la
 arista $a$ provocada por la tarea $j$
\end{center}

\vspace{.2in}
La soluci\'on viene dada por la minimizaci\'on del m\'aximo uso de procesador y memoria. Tras
ello puede ser reducida a un algoritmo -en tiempo de ejecuci\'on- del problema de encaminamiento de
 los circuitos virtuales. Esta reducci\'on funciona como sigue:

\begin{enumerate}
  \item Se toman dos nodos, $i_s$ e $i_d$, y {\em n} caminos sin tramos
 superpuestos que tengan como origen $i_s$ y como destino el nodo $i_d$.
 Se considerar\'an \'unicamente los caminos que consten solamente de 2 arcos.

  \item  El coste desde el nodo $i_s$ hasta el $i_d$ ser\'a representado por uno de estos caminos. Los arcos se
 dividir\'an ponderando al primero de ellos con la capacidad de memoria de
 $i_s$, es decir  $r_m(i_s)$. Al segundo de ellos se le ponderar\'a con $r_c(i_s)$.

%  \item  Cada tarea $j$ es una petici\'on de $i_s$ a $i_d$. Luego $P$
% -funci\'on de incidencia del grafo $G$- ser\'a
% una funci\'on que mapear\'a los arcos de memoria a los requerimientos de memoria
% de $j$  y los arcos de procesador a 1.

\end{enumerate}

Esta pol\'\i tica acota la congesti\'on
m\'axima del enlace al valor m\'aximo entre la m\'axima carga de
 procesador y el m\'aximo uso de la memoria. De esta manera se extiende para solucionar el problema
 del encaminamiento.

%El algoritmo calcula el coste marginal para cada uno de los posibles caminos de 

%\vspace{.1in}
%$\displaystyle U_P(j)=\sum_{r\ \epsilon\
%  R(i)} a^{carga_a(j)+C(a)}-a^{carga_a(j)}, \ \ \ \forall\ (i_s,i_d) \
%| \ i_s,i_d\ \epsilon\ I$

\vspace{.1in}
Este algoritmo es competitivo de grado $O(\log_2 n)$.
 Por reducci\'on, produce un algoritmo para manejar recursos heterog\'eneos
 que es competitivo tambi\'en de grado $O(\log_2 n)$ en su m\'aximo uso de cada recurso.
 Queda claro que cuando se escoge un camino se est\'a realmente eligiendo un
 nodo y que las diferencias entre los dos problemas se solucionan por la
 funci\'on que mapea la carga de los enlaces de uno de los problemas con la
 carga de los recursos del otro problema.
 Esto hace que la forma de extender sea muy simple porque lo \'unico que es necesario
 para tener en cuenta un recurso m\'as en el sistema es a\~{n}adir un arco,
 adem\'as de una funci\'on que mapee el problema de
 ese recurso en particular en el problema de encaminamiento de circuitos
 virtuales.

\vspace{.2in}
 La {\bf ponderaci\'on para un nodo} $i_k$, poseedor de $m$ recursos 
 consiste en una expresi\'on que relaciona el n\'umero total de
 nodos $n$ del cluster con la utilizaci\'on de cada recurso.
La elecci\'on de los par\'ametros parece correcta -ha sido elegida por los
 desarrolladores- puesto que la parte de potencia que un nodo significa en el
 seno de un clsuter depende del n\'umero de nodos existentes. De igual forma
 un nodo potente no servir\'a de mucho si tiene todos sus recursos utilizados.

La expresi\'on que se indica tendr\'\i a la forma:

\vspace{.1in}
$\displaystyle\sum_{i=1}^k f(n,u_{r_i})\ | \ r_i \ \epsilon\ R(i)$ , \hspace{.3in} donde
$u_{r_i}$ marca la utilizaci\'on del recurso $r_i$ .

\vspace{.1in}
Particularmente esta funci\'on de relaci\'on entre los par\'ametros indicados
tiene la forma:

\vspace{.1in}
 $f(n,u_{r_i})=\displaystyle\sum_{i=1}^k n^{\frac{u_{r_i}}{max[u_{r_i}]}}$,
 \hspace{.3in} donde se relaciona para cada recurso su uso actual con su uso
 m\'aximo\footnote{Valor \'este dado por la capacidad del recurso o por
 alg\'un valor de acotaci\'on puesto para evitar la completa apropiaci\'on del mismo.}.

\vspace{.1in}
NOTA: Tras estudios experimentales se ha probado que el algoritmo consegue una m\'axima p\'erdida
 de rendimiento dentro de $O(\log_2 n)$ de la m\'axima p\'erdida de rendimiento del
 algoritmo \'optimo.

\vspace{.1in}
Esta relaci\'on entre los usos de memoria funciona tal cual para el recurso de memoria.
 El coste por una cierta cantidad de uso de memoria en un nodo es 
 proporcional a la utilizaci\'on de memoria -relaci\'on memoria usada/memoria
 total-.

 Para el recurso procesador se deber\'\i a saber cu\'al es la m\'axima carga
 posible, esto no es tan sencillo como con la memoria y va a ser necesario tener que
 hacer alg\'un manejo matem\'atico.
 Se asume que $L$ es el entero m\'as peque\~{n}o en potencia de dos, mayor
 que la mayor carga que se haya visto hasta el momento, y que este n\'umero es la carga m\'axima posible.
 Aunque esta aproximaci\'on no sea realmente cierta sirve perfectamente para
 resolver el problema.

Tras estas aclaraciones las particularizaciones de ponderaci\'on para el tipo
de recurso procesador y memoria quedar\'\i a respectivamente:

\vspace{.1in}
memoria $\rightarrow n^{\frac{u_{r_m(i)}}{r_m(i)}}$ 
\hspace{.5in}\vspace{.1in}
y procesador $\rightarrow n^{\frac{u_{r_c(i)}}{L}}$ .
