miércoles, 8 de septiembre de 2010
domingo, 13 de junio de 2010
jppf español
Java Parallel Procesing Framework
JPPF Manual
CONCEPTO
JPPF permite a las aplicaciones con grandes necesidades de potencia de procesamiento y que van hacer ser ejecutadas en cualquier número de computadoras, a fin de reducir dramáticamente su tiempo de procesamiento. Esto se hace mediante el fraccionamiento de una aplicación en partes más pequeñas que pueden ser ejecutadas simultáneamente en diferentes máquinas.
CARACTERISTICAS
Simples API’s que requieren pequeñas curvas de aprendizaje
Despliegue automático de código de la aplicación en el grid
Capacidad de reutilizar los objetos existentes o heredados sin modificación
"happy path" sin necesidad de configuración adicional
Descubrimiento automático del servidor
Aplicación reutilizables conveniente plantilla de forma rápida y sencilla empezar a desarrollar aplicaciones JPPF
Reconexión automática del cliente con la estrategia de conmutación por error
Trabajo con tolerancia a fallos requeuing
* El número máximo de nodos que se pueden ejecutar en un trabajo
* Trabajo priorización
* Trabajo de inicio programada la fecha
* Nivel de empleo eventos
* Las estadísticas de rendimiento del servidor
* Gráficos de rendimiento del servidor
*Gráficas definidas por el usuario
* El control de servidor remoto y supervisión
* Nodos de control remoto y monitorización
* El seguimiento de uso de CPU
* Gestión de equilibrio de carga
* Gestión y control disponibles a través de las API y la interfaz gráfica de usuario (consola de administración)
Clases de inicio: los usuarios pueden añadir sus propios módulos de inicialización en el servidor y el nodo de inicio
Seguridad: los datos que transitan por la red ahora pueden ser codificados por el camino de las transformaciones definidas por el usuario
Módulos de equilibrio de carga permite a los usuarios escribir su propia carga de equilibrio de estrategias
Capacidad para especificar esquemas alternativos de serialización
Adaptación de equilibrio de carga se ajusta en tiempo real la carga de trabajo los cambios
Servidores de la memoria-aware y nodos (conmutación automática de la memoria al archivo de almacenamiento cuando la memoria se vuelve escasa)
El lado del cliente piscinas de conexión del servidor
Servidores se pueden agregar y quitar de forma dinámica de la red
Servidores pueden trabajar solos o unidos en topología P2P con otros servidores conectores de terceros
J2EE conector compatible con JCA 1.5, desplegado como un adaptador de recursos estándar
GigaSpaces XAP conector
Apache Tomcat conector
Modos de implementación
Todos los componentes se despliegan como aplicaciones Java
Servidores y nodos son desplegables como Linux / Unix demonios
Servidores y nodos son desplegables como los servicios de Windows
Implementación de aplicaciones cliente como web, J2EE o aplicación GigaSpaces XAP
Ejecución de los modos
Empleo de comunicaciones síncronas y asíncronas
El cliente puede ejecutar en modo local (prestaciones a los sistemas con muchas CPU)
El cliente puede ejecutar en modo distribuido (ejecución delegada a los nodos remotos)
El cliente puede ejecutar en modo mixto local / distribuido con adaptación de equilibrio de carga.
ARQUITECTURA
Arquitectura de Alto Nivel
Descripción de Componentes
Marco tiene una arquitectura 3 niveles, consta de 3 capas distintas:
* Nivel de cliente: proporciona un API y herramientas de comunicación que utilizan el marco para presentar las tareas, a ejecutar en paralelo.
* Capa de servicios: responsable de la comunicación entre los clientes y los nodos, junto con la gestión de la cola de ejecución, el balanceo de carga y características de recuperación, y la carga dinámica de ambos marco y clases de la aplicación en los nodos correspondientes.
* Ejecución de capa: estos son los nodos. Ellos ejecutan las tareas individuales, devuelva los resultados de ejecución, y dinámicamente solicitud, desde el controlador de JPPF, el código que necesitan para ejecutar las tareas de cliente.
Flujo de ejecución
Clase de carga en JPPF
Topología extendida de la red
JPPF puede ser extendido para incluir muchos servidores, comunicarse juntos en una topología de punto a punto.
En esta topología, cada servidor es visto por sus pares como un nodo, y ve a sus pares como clientes.
Hay un gran número de ventajas a este diseño:
* Permite una mayor escalabilidad de la red JPPF, al permitir que el "pluging-in" de servidores adicionales dynamcally. De esta manera, un servidor puede delegar una parte de su carga a otros servidores.
* No importa cuántos servidores están presentes, los nodos y los clientes se comunican con ellos de la misma manera exacta
* Servidor de las conexiones entre los propios beneficios de la conmutación por error mismo y la recuperación de características disponibles para los nodos y los clientes
Ventajas
Entre los beneficios JPPF es su facilidad de instalación, uso y despliegue. No es necesario para pasar unos días para escribir un "Hola Mundo". Un par de minutos, hasta un par de horas como máximo, será suficiente. Implementación de componentes JPPF más de un grupo es tan simple como copiar archivos a través de FTP o cualquier otro sistema de archivos de red. JPPF permite a los desarrolladores centrarse en su núcleo de desarrollo de software, en lugar de perder el tiempo en la complejidad de procesamiento paralelo y distribuido.
Con el framework 100% Java, JPPF se ejecutará en cualquier sistema que soporte Java: MacOS, Windows, Linux, zOS, en cualquier hardware de una computadora portátil simple hasta una computadora central. Esto no quiere decir que JPPF se limita a los trabajos en ejecución de Java Puede ejecutar cualquier aplicación que está disponible en su plataforma como un trabajo JPPF. Por ejemplo, usted podría querer ejecutar la suite de gráficos favorito en el modo por lotes, para que la multiplicidad de imágenes grandes y complejas a la vez.
Otro beneficio de JPPF es una simplificación, casi inmediata, el proceso de despliegue de la aplicación de la parrilla. Pesar de que su aplicación se ejecutará en los nodos a la vez, sólo es necesario incorporar este sistema en un solo lugar. Al extender la clase Java de carga mecanismo, JPPF elimina la mayor parte de la carga de la implementación del ciclo de vida de la aplicación, acortando dramáticamente el tiempo de salida al mercado y el tiempo de producción para.
Introducción
Dirigido a:
Este manual está dirigido a desarrolladores, ingenieros de software y arquitectos que deseen conocer, aprender o profundizar sus conocimientos de JPPF y cómo funciona. La intención es también proporcionar los conocimientos suficientes no sólo para escribir sus propias aplicaciones usando JPPF, sino también hacerla extensiva mediante la creación de complementos y los conectores con otros frameworks.
Requisitos previos
JPPF funciona en cualquier sistema que soporte Java. No se requiere sistema operativo, puede ser instalado en todos los sabores de Unix, Linux, Windows, Mac OS y otros sistemas, como zOS u otros sistemas mainframe.
JPPF requiere lo siguiente instalado en su máquina:
Java Standard Edition versión 1.5 o posterior, con la variable de entorno JAVA_HOME apuntando a la carpeta raíz de instalación de Java
Apache Ant, la versión 1.7.0 o posterior, con la variable de entorno ANT_HOME apuntando a la carpeta raíz de instalación de Ant
Las inscripciones en el PATH del sistema por defecto para JAVA-HOME/bin y Bin ANT_HOME /
Donde descargar
Todo el software JPPF se puede descargar desde la página de descargas JPPF .
Hemos tratado de dar a cada módulo un nombre que tenga sentido. El formato es JPPF-xyz-. Zip, cuando:
x es el número de versión principal
y es el número menor de versión
z es el número de lanzamiento del parche - no aparecerá si no hay parche ha sido puesto en libertad (es decir, si es igual a 0)
es el nombre dado al módulo
Instalación
Cada descarga JPPF está en formato zip. Para instalarlo, simplemente descomprimir en un directorio de su elección.
Cuando descomprimido, el contenido será bajo un directorio llamado JPPF-xyz-
Ejecución de los módulos independientes
La distribución JPPF incluye una serie de módulos independientes o componentes, que se pueden implementar y ejecutar de forma independiente en cualquier máquina, ya sea separadas, y / o en máquinas desde una ubicación distinta.
Estos módulos son los siguientes:
plantilla de aplicación: esta es la plantilla de aplicación para utilizar como punto de partida para una nueva aplicación JPPF, archivo JPPF-2.0-application-template.zip
driver: éste es el componente de servidor, el archivo JPPF-2.0-driver.zip
nodo: este es el componente del nodo, archivo JPPF-2.0-node.zip
consola de administración: esta es la gestión y la interfaz de usuario de seguimiento, archivo JPPF-2.0.admin-ui.zip
multiplexor: este es el Multiplicador de TCP que las rutas de todo el tráfico a través de un solo puerto, archivo JPPF-2.0.multiplexer.zip.
Estos módulos están diseñados para ejecutarse desde un script de Ant. La secuencia de comandos siempre se llama "build.xml" y siempre tiene un destino predeterminado llamado "run". Para ejecutar cualquiera de estos módulos, simplemente escriba "ant" o "ant run" en un símbolo del sistema o consola de shell.
Software necesario
En este tutorial, vamos a estar escribiendo una muestra JPPF aplicación, y se lo ejecuta en una red pequeña. En este sentido, tendremos que descargar e instalar los siguientes componentes JPPF:
JPPF plantilla aplicación: este es el archivo JPPF-xyz-application-template.zip
JPPF driver: este es el archivo JPPF-xyz-driver.zip
JPPF nodo: este es el archivo JPPF-xyz-node.zip
JPPF consola de administración: esta es el archivo JPPF-xyz-admin-ui.zip
Nota: "xyz" designa a la última versión de JPPF (mayor.menor.update). En general, "xy0" se abrevia en "xy".
Estos archivos están disponibles desde el instalador JPPF y / o desde la página de descarga JPPF .
Además de esto, Java 1.5 o posterior y Apache Ant 1.7.0 o posterior ya debería estar instalado en su máquina.
Vamos a suponer la creación de una nueva carpeta llamada "JPPF-Tutorial, en el que todos estos componentes son descomprimidos. Por lo tanto, debemos tener la siguiente estructura de carpetas:
JPPF-Tutorial
JPPF-xyz-admin-ui
JPPF-xyz-application-plantilla
JPPF-xyz-driver
JPPF-xyz-nodo
Información general
Tutorial organización
Vamos a base de este tutorial sobre una solicitud de pre-existentes de plantilla, que es uno de los componentes de la distribución JPPF. La ventaja es que la mayoría de los cables de bajo nivel ya está escritos para nosotros, y de este modo, puede centrarse en los pasos para armar una aplicación JPPF. La plantilla es un muy simple, pero totalmente funcional, aplicación JPPF, y contiene completamente comentado el código fuente, archivos de configuración y scripts para generar y ejecutar la misma.
Se organiza con la siguiente estructura de directorios:
directorio raíz: contiene las secuencias de comandos para generar y ejecutar la aplicación
src: aquí es donde las fuentes de la aplicación se encuentran
clases: el lugar donde el compilador Java lugar las fuentes construidas
config: contiene el JPPF y la explotación forestal archivos de configuración
lib: contiene las bibliotecas necesarias para generar y ejecutar la aplicación
Expectativas
Vamos a aprender cómo:
Escribir una tarea JPPF
crear un trabajo y lo ejecutamos
proceso de la ejecución resultados
administrar los trabajos JPPF
ejecutar una aplicación JPPF
Las características de JPPF que vamos a utilizar:
· JPPF Trabajo y tarea API’s
· los cambios del código local cuenta automáticamente, en
· JPPF API de cliente
· la gestión y la consola de supervisión
· configurar JPPF
Al final de este tutorial, vamos a tener una aplicación JPPF de pleno derecho que podemos construir, ejecutar, supervisar y administrar de una red de JPPF. También se han adquirido los conocimientos del funcionamiento de una aplicación típica de JPPF y estaremos listos para escribir la vida real, las aplicaciones habilitadas para la red.
Escribir una tarea JPPF
Una tarea JPPF es la unidad más pequeña de código que puede ejecutarse en una red JPPF. Desde una perspectiva JPPF, que se define así como un código de la unidad atómica. Una tarea siempre se define como una subclase de la clase JPPFTask . JPPFTask es una clase abstracta que implementa la interfaz Runnable. La parte de una tarea que se ejecutará en la parrilla es lo que está escrito en su método run ().
Desde el punto de vista del diseño, la escritura una tarea JPPF comprenderá dos pasos principales:
crear una subclase de JPPFTask.
aplicar el método run ().
Desde la carpeta de plantillas de aplicación de la raíz, navegue a la carpeta src / org / jppf / application / plantilla. Verás 2 ficheros Java en esta carpeta: "TemplateApplicationRunner.java" y "TemplateJPPFTask.java". Abra el archivo "TemplateJPPFTask.java" en tu editor de texto favorito.
En el editor podrás ver una tarea JPPF de pleno derecho declarada como sigue:
public class TemplateJPPFTask extends JPPFTask
Por debajo de este, se encuentra un método run () declararse como sigue:
public void run()
{
// write your task code here. /
System.out.println("Hello, this is the node executing a template JPPF task");
// ... / / ...
// eventually set the execution results /
setResult("the execution was performed successfully");
}
Podemos adivinar que esta primera tarea se imprimirá un "Hola ..." mensaje a la consola, a continuación, la resultado de la ejecución mediante una llamada al setResult () con un mensaje de cadena. El setResult() método en realidad toma cualquier objeto, y se ofrecen como un servicio para almacenar los resultados de la ejecución de la tarea, para su posterior recuperación.
En este método, para demostrar que hemos personalizado la plantilla, vamos a reemplazar la línea "/ / ..." con una declaración en la impresión de un segundo mensaje, por ejemplo "De hecho, esto es más que el modelo estándar". El método run () se convierte en:
public void run()
{
// write your task code here. /
System.out.println("Hello, this is the node executing a template JPPF task");
System.out.println("In fact, this is more than the standard template");
// eventually set the execution results
setResult("the execution was performed successfully");
}
No se olvide de guardar el archivo para que este cambio se tenga en cuenta.
El siguiente paso es crear un trabajo JPPF de una o varias tareas, y ejecutar este trabajo en el grid.
Crear y ejecutar un trabajo
Un trabajo es un conjunto de tareas con un conjunto común de características comunes y un SLA. Estas características incluyen:
datos comunes compartidos entre las tareas
una prioridad
un número máximo de nodos de un trabajo puede ser ejecutado
una política de ejecución de los nodos que describen qué puede funcionar
un indicador de suspensión, que permite la presentación de un trabajo en estado de suspensión, en espera de un comando externo para reanudar o comenzar su ejecución
un indicador de bloqueo / no-bloqueo, especificando si la ejecución del trabajo es sincrónica o asincrónica desde el punto de vista de la aplicación
Crear y llenar un puesto de trabajo
En el API JPPF, un puesto de Job se representa como una instancia de la clase JPPFJob .
Para ver cómo se crea un puesto de Job, vamos a abrir el archivo de origen "TemplateApplicationRunner.java" en la carpeta JPPF-xyz-application-template/src/org/jppf/application/template. En este archivo, vaya a la createJob método ().
Este método se escribe como sigue:
public JPPFJob createJob() throws Exception
{
// create a JPPF job
JPPFJob job = new JPPFJob();
// Controlar y gestionar la misma.
job.setId("Template Job Id");
// Añadir una tarea para el trabajo.
job.addTask(new TemplateJPPFTask());
// Añadir tareas más aquí ...
// No hay ninguna garantía sobre la orden de ejecución de las tareas,
// Fin de que las tareas.
return job;
}
Podemos ver que la creación de un puesto de trabajo se realiza mediante una llamada al constructor predeterminado de la clase JPPFJob. La llamada al método job.setId (String) se utiliza para dar el trabajo de un nombre significativo que después puede utilizar para manejarlo. Si este método no se llama a un id se genera automáticamente, como una cadena de 32 caracteres hexadecimales.
Agregar una tarea para el trabajo se hace mediante una llamada al método addTask (tarea de objetos, objetos ... args). Los argumentos opcionales se utilizan cuando queremos ejecutar otras formas de tareas, que no son subclases de JPPFTask. Veremos su uso en los sectores más avanzados del manual de usuario JPPF. Como podemos ver, todo el trabajo ya se hace en el archivo de plantilla, así que no hay necesidad de modificar el createJob () método por ahora.
La ejecución de un trabajo y procesamiento de los resultados
Ahora que hemos aprendido a crear un puesto de trabajo y rellenarla con las tareas, todavía es necesario para ejecutar este trabajo en el grid, y procesar los resultados de esta ejecución. Aún en el archivo de origen "TemplateApplicationRunner.java", vamos a navegar a la principal (String. .. args) método, en primer lugar a echar un vistazo más de cerca el bloque try, el cual contiene una declaración de inicialización muy importante:
jppfClient = new JPPFClient();
Esta sola declaración inicializa el marco JPPF en su aplicación. Cuando se ejecuta JPPF hará varias cosas:
leer el fichero de configuración
establecer una conexión con uno o varios servidores para la ejecución del trabajo
establecer un seguimiento y gestión de la conexión con cada servidor conectado
registro oyentes para controlar el estado de cada conexión
Como puede ver, el cliente tiene un impacto JPPF no despreciable sobre la memoria y recursos de red. Es por eso que recomendamos a declararlo como un producto único, y utilizar siempre la misma instancia en toda la aplicación. Esto también asegurará una mayor escalabilidad, ya que también está diseñado para su uso simultáneo por parte de varios hilos. Para este efecto, hemos declarado como una variable estática en TemplateApplicationRunner.java:
private static JPPFClient jppfClient = null;
También es una buena práctica para liberar los recursos utilizados por el cliente JPPF cuando no están en desuso. En realidad recomiendo hacer esto llamando a su método close () en un finally{} bloque :
finally
{
if (jppfClient != null) jppfClient.close();
}
Volver al método principal, después de inicializar el cliente JPPF, son los próximos pasos para inicializar nuestro corredor de trabajo, crear un trabajo y ejecutarlo:
// create a runner instance.
TemplateApplicationRunner runner = new TemplateApplicationRunner();
// Create a job
JPPFJob job = runner.createJob();
// execute a blocking job
runner.executeBlockingJob(job);
La llamada a runner.createJob () es exactamente lo que vimos en la sección anterior 2.4.1. Lo que queda por hacer es ejecutar el trabajo y el proceso de los resultados, que es la intención de la llamada a executeBlockingJob (JPPFJob Trabajo):
/**
* Execute a job in blocking mode. The application will be blocked until the job
* execution is complete.
* @param job the JPPF job to execute.
* @throws Exception if an error occurs while executing the job.
*/
public void executeBlockingJob(JPPFJob job) throws Exception
{
// set the job in blocking mode.
job.setBlocking(true);
// Submit the job and wait until the results are returned.
// The results are returned as a list of JPPFTask instances,
// in the same order as the one in which the tasks where initially added the job.
List results = jppfClient.submit(job);
// process the results
for (JPPFTask task: results)
{
// if the task execution resulted in an exception
if (task.getException() != null)
{
// process the exception here ...
}
else
{
// process the result here ...
}
}
}
La primera declaración de este método asegura que el trabajo se presentará en modo de bloqueo, lo que significa que la aplicación se bloqueará hasta que el trabajo se ejecuta:
job.setBlocking(true);
Esto es, de hecho, opcional desde la presentación en modo de bloqueo es el comportamiento predeterminado en JPPF.
La segunda declaración es la que va a enviar el trabajo al servidor y esperar hasta que haya sido ejecutado y los resultados devueltos son los siguientes:
List results = jppfClient.submit(job);
Podemos ver que los resultados se devuelven como una lista de objetos JPPFTask. Se garantiza que cada tarea en esta lista tiene la misma posición que la tarea correspondiente que se ha añadido al trabajo. En otras palabras, los resultados son siempre en el mismo orden que las tareas en el trabajo que él.
El último paso consiste en interpretar y procesar los resultados. Desde el punto de vista JPPF, hay dos posibles resultados de la ejecución de una tarea: una que plantea una Throwable, y uno que no lo hizo. Cuando uno no detectada Throwable (es decir, en general, una instancia de una subclase de java.lang.Error jo java.lang.Exception) se eleva, JPPF lo cogerá y lo puso como el resultado de la tarea. Para ello, el método JPPFTask.setException (Excepción) se llama. Usted notará que el parámetro es una instancia de excepción o de una de sus subclases. Por lo tanto, cualquier error no detectado se verá envuelto en una JPPFException. JPPF considera que el procesamiento de excepciones es parte del ciclo de vida de una tarea y proporciona los medios para capturar esa información en consecuencia.
Esto explica por qué, en nuestro código de la plantilla, hemos separado el resultado de procesamiento de cada tarea en 2 bloques:
if (task.getException() != null)
{
// process the exception here ...
}
else
{
// process the result here ...}
Los resultados reales de la computación de una tarea puede ser cualquier atributo de la tarea, o cualquier objeto accesible de ellos. El API JPPFTask ofrece dos métodos de conveniencia para ayudar a hacer esto: setResult (Objeto) y getResult (), sin embargo no es obligatorio su uso, y se puede aplicar el resultado de su propia manipulación régimen, o podría ser simplemente una parte de la tarea diseño.
Como ejemplo para este tutorial, vamos a modificar esta parte del código para mostrar el mensaje de excepción si la excepción se planteó, y para mostrar el resultado de otro modo:
if (task.getException() != null)
{
System.out.println("An exception was raised: "
+ task.getException().getMessage());
}
else
{
System.out.println("Execution result: "
+ task.getResult());
}
Ahora puede guardar el archivo y ciérrelo.
Ejecución de la aplicación RECETA
Ahora estamos listos para probar nuestra aplicación JPPF. A tal efecto, tendrá que empezar primero una rejilla JPPF, de la siguiente manera:
Paso 1: iniciar un servidor
Vaya la carpeta JPPF-xyz-driver y abrir una línea de comandos o consola de shell. Escriba "ant". Usted debe ver las siguientes líneas en la consola:
run:
[echo] starting the JPPF driver
[java] Class Server initialized - listening on port 11111
[java] Client Server initialized - listening on port 11112
[java] Tasks Server initialized - listening on port 11113
[java] JPPF Driver management initialized
[java] JPPF Driver initialization complete
El servidor ya está listo para procesar las solicitudes de trabajo.
Paso 2: comienzo de un nodo
Ir a la carpeta JPPF-xyz-nodo y abrir una línea de comandos o consola de shell. Escriba "ant". A continuación, verá las siguientes líneas en la consola:
run:
[java] JPPFClassLoader.init(): attempting connection to the class server
[java] JPPFClassLoader.init(): Reconnected to the class server
[java] PeerNode.init(): Attempting connection to the JPPF driver
[java] PeerNode.init(): Reconnected to the JPPF driver
[java] Node successfully initialized
En conjunto, este nodo y el servidor constituyen la más pequeña rejilla JPPF que usted pueda tener.
Paso 3: ejecutar la aplicación
Ir a la JPPF-xyz-application-carpeta de plantillas y abrir una línea de comandos o consola de shell. Escriba "ant". Esta vez, la secuencia de comandos Ant primero compilará nuestra aplicación, a continuación, ejecutarlo. Usted debe ver estas líneas en la consola:
run:
[java] [client: driver-1 (:11198)] ClassServerDelegate.init(): Attempting
connection to the class server
[java] [client: driver-1 (:11198)] ClassServerDelegate.init():
Reconnected to the class server
[java] [client: driver-1 (:11198)] : Attempting connection to the JPPF
task server
[java] [client: driver-1 (:11198)] : Reconnected to the JPPF task server
[java] Execution result: the execution was performed successfully
donde corresponde a la dirección IP de su ordenador.
Usted se dará cuenta de que la última línea impresa es el mismo mensaje que hemos utilizado en nuestra tarea en el método run (), para establecer el resultado de la ejecución en la declaración:
setResult("the execution was performed successfully");
Ahora bien, si se cambia de nuevo al nodo de la consola, debería ver que 2 mensajes nuevos se han publicado:
[java] Hello, this is the node executing a template JPPF task
[java] In fact, this is more than the standard template
Estas líneas 2 son los que en realidad codificada a principios de ejecutar la tarea del método ():
System.out.println("Hello, this is the node executing a template JPPF task");
System.out.println("In fact, this is more than the standard template");
A partir de estos mensajes, podemos concluir que nuestra aplicación se ejecute correctamente. ¡Felicitaciones!
En este punto, hay sin embargo un aspecto que todavía no hemos abordado: desde el nodo es un proceso independiente de nuestra aplicación, ¿cómo sabe para ejecutar nuestra tarea? Recuerde que ni siquiera hemos tratado de implementar las clases aplicación a cualquier ubicación específica. Simplemente hemos recopilado de manera que les podemos ejecutar nuestra aplicación a nivel local. Este tema es objeto de la siguiente sección de este tutorial.
Dinámica de implementación
Una de las mayores características de JPPF es su capacidad para cargar dinámicamente el código de una aplicación que se utilicen tan sólo a nivel local. JPPF amplía la clase estándar de Java mecanismo de carga de manera que, simplemente utilizando las API de JPPF, las clases de una aplicación se cargan a cualquier nodo remoto que las necesita. La ventaja es que no hay despliegue de la aplicación es necesaria para que se ejecute en una cuadrícula JPPF, no importa cómo muchos nodos o servidores están presentes en la red. Además, este mecanismo es totalmente transparente para el desarrollador de aplicaciones.
Una ventaja importante es que los cambios de código son tomados en cuenta de forma automática, sin necesidad de reiniciar los nodos o el servidor. Esto significa que, al cambiar cualquier parte del código que se ejecuta en un nodo, lo único que tienes que hacer es volver a compilar el código y ejecutar la aplicación, y los cambios tendrán efecto de inmediato, en todos los nodos que ejecutan la aplicación.
Ahora vamos a demostrar esto haciendo un pequeño, pero un cambio visible, el código y ejecutarlo en el servidor y el nodo ya hemos empezado, si usted los ha dejado ya, simplemente realizar nuevamente todos los pasos descritos en la sección anterior (2,5), antes de continuar.
Está abierto de nuevo el archivo de origen Let "TemplateJPPFTask.java" en JPPF-xyz-application-template/src/org/jppf/application/template /, y vaya a la método run().Vamos a sustituir las dos primeras líneas con lo siguiente:
System.out.println("*** We are now running a modified version of the code ***");
El método run () ahora debe verse así:
public void run()
{
// write your task code here.
System.out.println("*** We are now running a modified version of the code ***");
// eventually set the execution results
setResult("the execution was performed successfully");
}
Guarde los cambios en el archivo y abrir o volver a una línea de comandos o shell de la consola en el JPPF-xyz-application-carpeta de plantillas. A partir de ahí, el ant "tipo" para ejecutar la aplicación de nuevo. Ahora debería ver los mismos mensajes que en el largo inicial se muestra en la consola. Esto es lo que esperábamos. Por otra parte, si se cambia de nuevo al nodo de la consola, ahora debería ver un nuevo mensaje:
[java] *** We are now running a modified version of the code ***
Éxito! Hemos implementado exitosamente nuestra nuevo código sin ningún tipo de redistribución explícito.
Administración de los trabajos
Ahora que somos capaces de crear, presentar y ejecutar un trabajo, podemos empezar a pensar acerca de la supervisión y, finalmente, el control de su ciclo de vida del grid. Para ello, usaremos la administración y supervisión JPPF consola. El JPPF consola es una herramienta independiente que proporciona interfaces gráficas fáciles de usar para:
obtener estadísticas sobre el rendimiento del servidor
definir, personalizar y visualizar gráficos de rendimiento del servidor
supervisar y controlar el estado y la salud de los servidores y nodos
vigilar y controlar la ejecución de los trabajos en la parrilla
gestionar la carga de trabajo y el comportamiento de equilibrio de carga
Preparar el trabajo para la gestión
En nuestra plantilla de aplicación, el trabajo que llevamos a cabo en el grid tiene una sola tarea. Como hemos visto, esta tarea es muy corto en vivo, ya que se ejecuta en no más de unos pocos milisegundos. Esto definitivamente no nos permite que controlemos o gestionar con nuestro tiempo desnuda reacción humana. A los efectos de este tutorial, ahora vamos a adaptar la plantilla a algo más realista desde esta perspectiva.
Paso 1: Hacer las tareas duran más
Lo que haremos aquí es añadir un retardo a cada tarea, antes de que termine. No hará nada durante este tiempo, sólo esperar a un tiempo determinado. Vamos a editar de nuevo el archivo de origen "TemplateJPPFTask.java" en JPPF-xyz-application-template/src/org/jppf/application/template / y modificar el método run () de la siguiente manera:
public void run()
{
// write your task code here.
System.out.println("*** We are now running a modified version of the code ***");
// simply wait for 3 seconds
try
{
Thread.sleep(3000L);
}
catch(InterruptedException e)
{
setException(e);
return;
}
// eventually set the execution results
setResult("the execution was performed successfully");
}
Tenga en cuenta que aquí, hacemos una llamada explícita a setException(), en el caso de una InterruptedException se eleva. Puesto que esta excepción se producen en el nodo, capturando nos permitirá saber lo que pasó desde el lado de la aplicación.
Paso 2: añadir más tareas a los puestos de trabajo, lo presentará como suspendida
Esta vez, nuestro trabajo va a contener más de una tarea. Para que podamos tener el tiempo para manipular desde la consola de administración, también se inicia en modo suspendido. En este sentido, vamos a modificar el método de createJob () del corredor de aplicaciones"
public JPPFJob createJob() throws Exception
{
// create a JPPF job
JPPFJob job = new JPPFJob();
// give this job a readable unique id that we can use to monitor and manage it.
job.setId("Template Job Id");
// add 10 tasks to the job.
for (int i=0; i<10; i++) job.addTask(new TemplateJPPFTask());
// start the job in suspended mode
job.getJobSLA().setSuspended(true);
return job;}
Paso 3: Inicie los componentes JPPF
Si ha dejado el servidor y el nodo, simplemente empezar de nuevo como se describe en los dos primeros pasos de la sección 2.5 de este tutorial.
También vamos a iniciar la consola de administración:
Ir a la JPPF-xyz-admin-carpeta ui y abrir una línea de comandos o consola de shell. Type "ant". Escriba "ant".
Cuando la consola se inicia, verá un panel llamado "Topología" que muestra los servidores y los nodos conectados a ellos. Se debe tener este aspecto:
Podemos ver aquí que un servidor se inicia en la máquina "lolo-quad" y que tiene un nodo se le atribuye. El color para el servidor es un indicador de salud, lo que significa verde que se está ejecutando normalmente y roja que significa que está abajo.
Cambiemos al "Trabajo de datos" panel, que debería tener este aspecto:
También vemos la información del controlador de la salud con códigos de color en este panel. Actualmente no hay otro elemento en pantalla, porque no hemos presentado un trabajo todavía.
Paso 4: iniciar un nuevo trabajo
Ahora vamos a comenzar un trabajo mediante la ejecución de nuestra aplicación: ir a la JPPF-xyz-application-carpeta de plantillas y abrir una línea de comandos o consola de shell. Escriba "ant". Switch. Vaya a la consola de la administración. Ahora, deberíamos ver un cambio en la pantalla:
Ahora vemos que un trabajo está presente en la cola del servidor, en estado de suspensión (destacado en amarillo). He aquí una explicación de las columnas de la tabla:
"Driver / Trabajo / Nodo": muestra un nombre de usuario para un servidor, por un trabajo presentado a ese servidor, o para un nodo al que algunas de las tareas en el trabajo han sido enviados para su ejecución
"Estado": el estado actual de un trabajo, ya sea "suspendido" o de ejecución "
"Contar tarea inicial": el número de tareas en el trabajo en el momento en que se envía a la aplicación
"Contar tarea actual": el número de tareas pendientes en el trabajo, que no han sido ejecutados
"Prioridad": esta es la prioridad, del trabajo, el valor por defecto es 0.
"Max nodos": el número máximo de nodos de un trabajo puede ser ejecutado en. De forma predeterminada, no hay límite, que se representa como el símbolo de infinito
Paso 5: la reanudación de la ejecución de trabajo
Dado que el trabajo se presentó en estado de suspensión, se reanudará su ejecución manualmente desde la consola Seleccione la línea en el trabajo "ID de la plantilla de trabajo" en la pantalla. Usted debe ver que algunos botones se activará. Haga clic en el botón de reanudar (marcados con el icono [[Image:]]) para reanudar la ejecución del trabajo, como se muestra a continuación:
Tan pronto como reanudar el trabajo, el servidor inicia la distribución de tareas a los nodos, y podemos ver que el recuento de la tarea actual comienza a disminuir en consecuencia, y el estado de los trabajos se ha cambiado a "Ejecutar":
Se le anima a experimentar con la herramienta y el código. Por ejemplo, puede añadir más tareas a los puestos de trabajo, los hacen durar más tiempo, suspender, reanudar o terminar el trabajo mientras se está ejecutando, etc ..
Conclusión
En este tutorial, hemos visto cómo escribir una aplicación JPPF habilitado de punta a punta. También hemos aprendido de las API básicas que nos permiten escribir una solicitud de las unidades de ejecución atómica e independiente llamada tareas y agruparlas en puestos de trabajo que pueden ser ejecutados en la parrilla. También hemos aprendido cómo los trabajos se pueden administrar y controlar de forma dinámica durante la ejecución. Por último, también se enteró de que, a pesar de que una aplicación puede ser distribuida a través de cualquier número de nodos, no hay necesidad de desplegar explícitamente el código de la aplicación, ya que JPPF implícitamente se encarga de ello.
JPPF Manual
CONCEPTO
JPPF permite a las aplicaciones con grandes necesidades de potencia de procesamiento y que van hacer ser ejecutadas en cualquier número de computadoras, a fin de reducir dramáticamente su tiempo de procesamiento. Esto se hace mediante el fraccionamiento de una aplicación en partes más pequeñas que pueden ser ejecutadas simultáneamente en diferentes máquinas.
CARACTERISTICAS
- Facilidad de uso
Simples API’s que requieren pequeñas curvas de aprendizaje
Despliegue automático de código de la aplicación en el grid
Capacidad de reutilizar los objetos existentes o heredados sin modificación
"happy path" sin necesidad de configuración adicional
Descubrimiento automático del servidor
Aplicación reutilizables conveniente plantilla de forma rápida y sencilla empezar a desarrollar aplicaciones JPPF
- Auto-reparación y recuperación
Reconexión automática del cliente con la estrategia de conmutación por error
Trabajo con tolerancia a fallos requeuing
- Trabajo a nivel de SLA
* El número máximo de nodos que se pueden ejecutar en un trabajo
* Trabajo priorización
* Trabajo de inicio programada la fecha
- Gestión y seguimiento
* Nivel de empleo eventos
* Las estadísticas de rendimiento del servidor
* Gráficos de rendimiento del servidor
*Gráficas definidas por el usuario
* El control de servidor remoto y supervisión
* Nodos de control remoto y monitorización
* El seguimiento de uso de CPU
* Gestión de equilibrio de carga
* Gestión y control disponibles a través de las API y la interfaz gráfica de usuario (consola de administración)
- Plataforma de extensibilidad
Clases de inicio: los usuarios pueden añadir sus propios módulos de inicialización en el servidor y el nodo de inicio
Seguridad: los datos que transitan por la red ahora pueden ser codificados por el camino de las transformaciones definidas por el usuario
Módulos de equilibrio de carga permite a los usuarios escribir su propia carga de equilibrio de estrategias
Capacidad para especificar esquemas alternativos de serialización
- Rendimiento y eficiencia de los recursos
Adaptación de equilibrio de carga se ajusta en tiempo real la carga de trabajo los cambios
Servidores de la memoria-aware y nodos (conmutación automática de la memoria al archivo de almacenamiento cuando la memoria se vuelve escasa)
El lado del cliente piscinas de conexión del servidor
- Dinámica de la ampliación topología
Servidores se pueden agregar y quitar de forma dinámica de la red
Servidores pueden trabajar solos o unidos en topología P2P con otros servidores conectores de terceros
J2EE conector compatible con JCA 1.5, desplegado como un adaptador de recursos estándar
GigaSpaces XAP conector
Apache Tomcat conector
- Complementos para Firefox
Modos de implementación
Todos los componentes se despliegan como aplicaciones Java
Servidores y nodos son desplegables como Linux / Unix demonios
Servidores y nodos son desplegables como los servicios de Windows
Implementación de aplicaciones cliente como web, J2EE o aplicación GigaSpaces XAP
Ejecución de los modos
Empleo de comunicaciones síncronas y asíncronas
El cliente puede ejecutar en modo local (prestaciones a los sistemas con muchas CPU)
El cliente puede ejecutar en modo distribuido (ejecución delegada a los nodos remotos)
El cliente puede ejecutar en modo mixto local / distribuido con adaptación de equilibrio de carga.
ARQUITECTURA
Arquitectura de Alto Nivel
Descripción de Componentes
Marco tiene una arquitectura 3 niveles, consta de 3 capas distintas:
* Nivel de cliente: proporciona un API y herramientas de comunicación que utilizan el marco para presentar las tareas, a ejecutar en paralelo.
* Capa de servicios: responsable de la comunicación entre los clientes y los nodos, junto con la gestión de la cola de ejecución, el balanceo de carga y características de recuperación, y la carga dinámica de ambos marco y clases de la aplicación en los nodos correspondientes.
* Ejecución de capa: estos son los nodos. Ellos ejecutan las tareas individuales, devuelva los resultados de ejecución, y dinámicamente solicitud, desde el controlador de JPPF, el código que necesitan para ejecutar las tareas de cliente.
Flujo de ejecución
Clase de carga en JPPF
Topología extendida de la red
JPPF puede ser extendido para incluir muchos servidores, comunicarse juntos en una topología de punto a punto.
En esta topología, cada servidor es visto por sus pares como un nodo, y ve a sus pares como clientes.
Hay un gran número de ventajas a este diseño:
* Permite una mayor escalabilidad de la red JPPF, al permitir que el "pluging-in" de servidores adicionales dynamcally. De esta manera, un servidor puede delegar una parte de su carga a otros servidores.
* No importa cuántos servidores están presentes, los nodos y los clientes se comunican con ellos de la misma manera exacta
* Servidor de las conexiones entre los propios beneficios de la conmutación por error mismo y la recuperación de características disponibles para los nodos y los clientes
Ventajas
Entre los beneficios JPPF es su facilidad de instalación, uso y despliegue. No es necesario para pasar unos días para escribir un "Hola Mundo". Un par de minutos, hasta un par de horas como máximo, será suficiente. Implementación de componentes JPPF más de un grupo es tan simple como copiar archivos a través de FTP o cualquier otro sistema de archivos de red. JPPF permite a los desarrolladores centrarse en su núcleo de desarrollo de software, en lugar de perder el tiempo en la complejidad de procesamiento paralelo y distribuido.
Con el framework 100% Java, JPPF se ejecutará en cualquier sistema que soporte Java: MacOS, Windows, Linux, zOS, en cualquier hardware de una computadora portátil simple hasta una computadora central. Esto no quiere decir que JPPF se limita a los trabajos en ejecución de Java Puede ejecutar cualquier aplicación que está disponible en su plataforma como un trabajo JPPF. Por ejemplo, usted podría querer ejecutar la suite de gráficos favorito en el modo por lotes, para que la multiplicidad de imágenes grandes y complejas a la vez.
Otro beneficio de JPPF es una simplificación, casi inmediata, el proceso de despliegue de la aplicación de la parrilla. Pesar de que su aplicación se ejecutará en los nodos a la vez, sólo es necesario incorporar este sistema en un solo lugar. Al extender la clase Java de carga mecanismo, JPPF elimina la mayor parte de la carga de la implementación del ciclo de vida de la aplicación, acortando dramáticamente el tiempo de salida al mercado y el tiempo de producción para.
Introducción
Dirigido a:
Este manual está dirigido a desarrolladores, ingenieros de software y arquitectos que deseen conocer, aprender o profundizar sus conocimientos de JPPF y cómo funciona. La intención es también proporcionar los conocimientos suficientes no sólo para escribir sus propias aplicaciones usando JPPF, sino también hacerla extensiva mediante la creación de complementos y los conectores con otros frameworks.
Requisitos previos
JPPF funciona en cualquier sistema que soporte Java. No se requiere sistema operativo, puede ser instalado en todos los sabores de Unix, Linux, Windows, Mac OS y otros sistemas, como zOS u otros sistemas mainframe.
JPPF requiere lo siguiente instalado en su máquina:
Java Standard Edition versión 1.5 o posterior, con la variable de entorno JAVA_HOME apuntando a la carpeta raíz de instalación de Java
Apache Ant, la versión 1.7.0 o posterior, con la variable de entorno ANT_HOME apuntando a la carpeta raíz de instalación de Ant
Las inscripciones en el PATH del sistema por defecto para JAVA-HOME/bin y Bin ANT_HOME /
Donde descargar
Todo el software JPPF se puede descargar desde la página de descargas JPPF .
Hemos tratado de dar a cada módulo un nombre que tenga sentido. El formato es JPPF-xyz-
x es el número de versión principal
y es el número menor de versión
z es el número de lanzamiento del parche - no aparecerá si no hay parche ha sido puesto en libertad (es decir, si es igual a 0)
Instalación
Cada descarga JPPF está en formato zip. Para instalarlo, simplemente descomprimir en un directorio de su elección.
Cuando descomprimido, el contenido será bajo un directorio llamado JPPF-xyz-
Ejecución de los módulos independientes
La distribución JPPF incluye una serie de módulos independientes o componentes, que se pueden implementar y ejecutar de forma independiente en cualquier máquina, ya sea separadas, y / o en máquinas desde una ubicación distinta.
Estos módulos son los siguientes:
plantilla de aplicación: esta es la plantilla de aplicación para utilizar como punto de partida para una nueva aplicación JPPF, archivo JPPF-2.0-application-template.zip
driver: éste es el componente de servidor, el archivo JPPF-2.0-driver.zip
nodo: este es el componente del nodo, archivo JPPF-2.0-node.zip
consola de administración: esta es la gestión y la interfaz de usuario de seguimiento, archivo JPPF-2.0.admin-ui.zip
multiplexor: este es el Multiplicador de TCP que las rutas de todo el tráfico a través de un solo puerto, archivo JPPF-2.0.multiplexer.zip.
Estos módulos están diseñados para ejecutarse desde un script de Ant. La secuencia de comandos siempre se llama "build.xml" y siempre tiene un destino predeterminado llamado "run". Para ejecutar cualquiera de estos módulos, simplemente escriba "ant" o "ant run" en un símbolo del sistema o consola de shell.
Software necesario
En este tutorial, vamos a estar escribiendo una muestra JPPF aplicación, y se lo ejecuta en una red pequeña. En este sentido, tendremos que descargar e instalar los siguientes componentes JPPF:
JPPF plantilla aplicación: este es el archivo JPPF-xyz-application-template.zip
JPPF driver: este es el archivo JPPF-xyz-driver.zip
JPPF nodo: este es el archivo JPPF-xyz-node.zip
JPPF consola de administración: esta es el archivo JPPF-xyz-admin-ui.zip
Nota: "xyz" designa a la última versión de JPPF (mayor.menor.update). En general, "xy0" se abrevia en "xy".
Estos archivos están disponibles desde el instalador JPPF y / o desde la página de descarga JPPF .
Además de esto, Java 1.5 o posterior y Apache Ant 1.7.0 o posterior ya debería estar instalado en su máquina.
Vamos a suponer la creación de una nueva carpeta llamada "JPPF-Tutorial, en el que todos estos componentes son descomprimidos. Por lo tanto, debemos tener la siguiente estructura de carpetas:
JPPF-Tutorial
JPPF-xyz-admin-ui
JPPF-xyz-application-plantilla
JPPF-xyz-driver
JPPF-xyz-nodo
Información general
Tutorial organización
Vamos a base de este tutorial sobre una solicitud de pre-existentes de plantilla, que es uno de los componentes de la distribución JPPF. La ventaja es que la mayoría de los cables de bajo nivel ya está escritos para nosotros, y de este modo, puede centrarse en los pasos para armar una aplicación JPPF. La plantilla es un muy simple, pero totalmente funcional, aplicación JPPF, y contiene completamente comentado el código fuente, archivos de configuración y scripts para generar y ejecutar la misma.
Se organiza con la siguiente estructura de directorios:
directorio raíz: contiene las secuencias de comandos para generar y ejecutar la aplicación
src: aquí es donde las fuentes de la aplicación se encuentran
clases: el lugar donde el compilador Java lugar las fuentes construidas
config: contiene el JPPF y la explotación forestal archivos de configuración
lib: contiene las bibliotecas necesarias para generar y ejecutar la aplicación
Expectativas
Vamos a aprender cómo:
Escribir una tarea JPPF
crear un trabajo y lo ejecutamos
proceso de la ejecución resultados
administrar los trabajos JPPF
ejecutar una aplicación JPPF
Las características de JPPF que vamos a utilizar:
· JPPF Trabajo y tarea API’s
· los cambios del código local cuenta automáticamente, en
· JPPF API de cliente
· la gestión y la consola de supervisión
· configurar JPPF
Al final de este tutorial, vamos a tener una aplicación JPPF de pleno derecho que podemos construir, ejecutar, supervisar y administrar de una red de JPPF. También se han adquirido los conocimientos del funcionamiento de una aplicación típica de JPPF y estaremos listos para escribir la vida real, las aplicaciones habilitadas para la red.
Escribir una tarea JPPF
Una tarea JPPF es la unidad más pequeña de código que puede ejecutarse en una red JPPF. Desde una perspectiva JPPF, que se define así como un código de la unidad atómica. Una tarea siempre se define como una subclase de la clase JPPFTask . JPPFTask es una clase abstracta que implementa la interfaz Runnable. La parte de una tarea que se ejecutará en la parrilla es lo que está escrito en su método run ().
Desde el punto de vista del diseño, la escritura una tarea JPPF comprenderá dos pasos principales:
crear una subclase de JPPFTask.
aplicar el método run ().
Desde la carpeta de plantillas de aplicación de la raíz, navegue a la carpeta src / org / jppf / application / plantilla. Verás 2 ficheros Java en esta carpeta: "TemplateApplicationRunner.java" y "TemplateJPPFTask.java". Abra el archivo "TemplateJPPFTask.java" en tu editor de texto favorito.
En el editor podrás ver una tarea JPPF de pleno derecho declarada como sigue:
public class TemplateJPPFTask extends JPPFTask
Por debajo de este, se encuentra un método run () declararse como sigue:
public void run()
{
// write your task code here. /
System.out.println("Hello, this is the node executing a template JPPF task");
// ... / / ...
// eventually set the execution results /
setResult("the execution was performed successfully");
}
Podemos adivinar que esta primera tarea se imprimirá un "Hola ..." mensaje a la consola, a continuación, la resultado de la ejecución mediante una llamada al setResult () con un mensaje de cadena. El setResult() método en realidad toma cualquier objeto, y se ofrecen como un servicio para almacenar los resultados de la ejecución de la tarea, para su posterior recuperación.
En este método, para demostrar que hemos personalizado la plantilla, vamos a reemplazar la línea "/ / ..." con una declaración en la impresión de un segundo mensaje, por ejemplo "De hecho, esto es más que el modelo estándar". El método run () se convierte en:
public void run()
{
// write your task code here. /
System.out.println("Hello, this is the node executing a template JPPF task");
System.out.println("In fact, this is more than the standard template");
// eventually set the execution results
setResult("the execution was performed successfully");
}
No se olvide de guardar el archivo para que este cambio se tenga en cuenta.
El siguiente paso es crear un trabajo JPPF de una o varias tareas, y ejecutar este trabajo en el grid.
Crear y ejecutar un trabajo
Un trabajo es un conjunto de tareas con un conjunto común de características comunes y un SLA. Estas características incluyen:
datos comunes compartidos entre las tareas
una prioridad
un número máximo de nodos de un trabajo puede ser ejecutado
una política de ejecución de los nodos que describen qué puede funcionar
un indicador de suspensión, que permite la presentación de un trabajo en estado de suspensión, en espera de un comando externo para reanudar o comenzar su ejecución
un indicador de bloqueo / no-bloqueo, especificando si la ejecución del trabajo es sincrónica o asincrónica desde el punto de vista de la aplicación
Crear y llenar un puesto de trabajo
En el API JPPF, un puesto de Job se representa como una instancia de la clase JPPFJob .
Para ver cómo se crea un puesto de Job, vamos a abrir el archivo de origen "TemplateApplicationRunner.java" en la carpeta JPPF-xyz-application-template/src/org/jppf/application/template. En este archivo, vaya a la createJob método ().
Este método se escribe como sigue:
public JPPFJob createJob() throws Exception
{
// create a JPPF job
JPPFJob job = new JPPFJob();
// Controlar y gestionar la misma.
job.setId("Template Job Id");
// Añadir una tarea para el trabajo.
job.addTask(new TemplateJPPFTask());
// Añadir tareas más aquí ...
// No hay ninguna garantía sobre la orden de ejecución de las tareas,
// Fin de que las tareas.
return job;
}
Podemos ver que la creación de un puesto de trabajo se realiza mediante una llamada al constructor predeterminado de la clase JPPFJob. La llamada al método job.setId (String) se utiliza para dar el trabajo de un nombre significativo que después puede utilizar para manejarlo. Si este método no se llama a un id se genera automáticamente, como una cadena de 32 caracteres hexadecimales.
Agregar una tarea para el trabajo se hace mediante una llamada al método addTask (tarea de objetos, objetos ... args). Los argumentos opcionales se utilizan cuando queremos ejecutar otras formas de tareas, que no son subclases de JPPFTask. Veremos su uso en los sectores más avanzados del manual de usuario JPPF. Como podemos ver, todo el trabajo ya se hace en el archivo de plantilla, así que no hay necesidad de modificar el createJob () método por ahora.
La ejecución de un trabajo y procesamiento de los resultados
Ahora que hemos aprendido a crear un puesto de trabajo y rellenarla con las tareas, todavía es necesario para ejecutar este trabajo en el grid, y procesar los resultados de esta ejecución. Aún en el archivo de origen "TemplateApplicationRunner.java", vamos a navegar a la principal (String. .. args) método, en primer lugar a echar un vistazo más de cerca el bloque try, el cual contiene una declaración de inicialización muy importante:
jppfClient = new JPPFClient();
Esta sola declaración inicializa el marco JPPF en su aplicación. Cuando se ejecuta JPPF hará varias cosas:
leer el fichero de configuración
establecer una conexión con uno o varios servidores para la ejecución del trabajo
establecer un seguimiento y gestión de la conexión con cada servidor conectado
registro oyentes para controlar el estado de cada conexión
Como puede ver, el cliente tiene un impacto JPPF no despreciable sobre la memoria y recursos de red. Es por eso que recomendamos a declararlo como un producto único, y utilizar siempre la misma instancia en toda la aplicación. Esto también asegurará una mayor escalabilidad, ya que también está diseñado para su uso simultáneo por parte de varios hilos. Para este efecto, hemos declarado como una variable estática en TemplateApplicationRunner.java:
private static JPPFClient jppfClient = null;
También es una buena práctica para liberar los recursos utilizados por el cliente JPPF cuando no están en desuso. En realidad recomiendo hacer esto llamando a su método close () en un finally{} bloque :
finally
{
if (jppfClient != null) jppfClient.close();
}
Volver al método principal, después de inicializar el cliente JPPF, son los próximos pasos para inicializar nuestro corredor de trabajo, crear un trabajo y ejecutarlo:
// create a runner instance.
TemplateApplicationRunner runner = new TemplateApplicationRunner();
// Create a job
JPPFJob job = runner.createJob();
// execute a blocking job
runner.executeBlockingJob(job);
La llamada a runner.createJob () es exactamente lo que vimos en la sección anterior 2.4.1. Lo que queda por hacer es ejecutar el trabajo y el proceso de los resultados, que es la intención de la llamada a executeBlockingJob (JPPFJob Trabajo):
/**
* Execute a job in blocking mode. The application will be blocked until the job
* execution is complete.
* @param job the JPPF job to execute.
* @throws Exception if an error occurs while executing the job.
*/
public void executeBlockingJob(JPPFJob job) throws Exception
{
// set the job in blocking mode.
job.setBlocking(true);
// Submit the job and wait until the results are returned.
// The results are returned as a list of JPPFTask instances,
// in the same order as the one in which the tasks where initially added the job.
List
// process the results
for (JPPFTask task: results)
{
// if the task execution resulted in an exception
if (task.getException() != null)
{
// process the exception here ...
}
else
{
// process the result here ...
}
}
}
La primera declaración de este método asegura que el trabajo se presentará en modo de bloqueo, lo que significa que la aplicación se bloqueará hasta que el trabajo se ejecuta:
job.setBlocking(true);
Esto es, de hecho, opcional desde la presentación en modo de bloqueo es el comportamiento predeterminado en JPPF.
La segunda declaración es la que va a enviar el trabajo al servidor y esperar hasta que haya sido ejecutado y los resultados devueltos son los siguientes:
List
Podemos ver que los resultados se devuelven como una lista de objetos JPPFTask. Se garantiza que cada tarea en esta lista tiene la misma posición que la tarea correspondiente que se ha añadido al trabajo. En otras palabras, los resultados son siempre en el mismo orden que las tareas en el trabajo que él.
El último paso consiste en interpretar y procesar los resultados. Desde el punto de vista JPPF, hay dos posibles resultados de la ejecución de una tarea: una que plantea una Throwable, y uno que no lo hizo. Cuando uno no detectada Throwable (es decir, en general, una instancia de una subclase de java.lang.Error jo java.lang.Exception) se eleva, JPPF lo cogerá y lo puso como el resultado de la tarea. Para ello, el método JPPFTask.setException (Excepción) se llama. Usted notará que el parámetro es una instancia de excepción o de una de sus subclases. Por lo tanto, cualquier error no detectado se verá envuelto en una JPPFException. JPPF considera que el procesamiento de excepciones es parte del ciclo de vida de una tarea y proporciona los medios para capturar esa información en consecuencia.
Esto explica por qué, en nuestro código de la plantilla, hemos separado el resultado de procesamiento de cada tarea en 2 bloques:
if (task.getException() != null)
{
// process the exception here ...
}
else
{
// process the result here ...}
Los resultados reales de la computación de una tarea puede ser cualquier atributo de la tarea, o cualquier objeto accesible de ellos. El API JPPFTask ofrece dos métodos de conveniencia para ayudar a hacer esto: setResult (Objeto) y getResult (), sin embargo no es obligatorio su uso, y se puede aplicar el resultado de su propia manipulación régimen, o podría ser simplemente una parte de la tarea diseño.
Como ejemplo para este tutorial, vamos a modificar esta parte del código para mostrar el mensaje de excepción si la excepción se planteó, y para mostrar el resultado de otro modo:
if (task.getException() != null)
{
System.out.println("An exception was raised: "
+ task.getException().getMessage());
}
else
{
System.out.println("Execution result: "
+ task.getResult());
}
Ahora puede guardar el archivo y ciérrelo.
Ejecución de la aplicación RECETA
Ahora estamos listos para probar nuestra aplicación JPPF. A tal efecto, tendrá que empezar primero una rejilla JPPF, de la siguiente manera:
Paso 1: iniciar un servidor
Vaya la carpeta JPPF-xyz-driver y abrir una línea de comandos o consola de shell. Escriba "ant". Usted debe ver las siguientes líneas en la consola:
run:
[echo] starting the JPPF driver
[java] Class Server initialized - listening on port 11111
[java] Client Server initialized - listening on port 11112
[java] Tasks Server initialized - listening on port 11113
[java] JPPF Driver management initialized
[java] JPPF Driver initialization complete
El servidor ya está listo para procesar las solicitudes de trabajo.
Paso 2: comienzo de un nodo
Ir a la carpeta JPPF-xyz-nodo y abrir una línea de comandos o consola de shell. Escriba "ant". A continuación, verá las siguientes líneas en la consola:
run:
[java] JPPFClassLoader.init(): attempting connection to the class server
[java] JPPFClassLoader.init(): Reconnected to the class server
[java] PeerNode.init(): Attempting connection to the JPPF driver
[java] PeerNode.init(): Reconnected to the JPPF driver
[java] Node successfully initialized
En conjunto, este nodo y el servidor constituyen la más pequeña rejilla JPPF que usted pueda tener.
Paso 3: ejecutar la aplicación
Ir a la JPPF-xyz-application-carpeta de plantillas y abrir una línea de comandos o consola de shell. Escriba "ant". Esta vez, la secuencia de comandos Ant primero compilará nuestra aplicación, a continuación, ejecutarlo. Usted debe ver estas líneas en la consola:
run:
[java] [client: driver-1 (
connection to the class server
[java] [client: driver-1 (
Reconnected to the class server
[java] [client: driver-1 (
task server
[java] [client: driver-1 (
[java] Execution result: the execution was performed successfully
donde
Usted se dará cuenta de que la última línea impresa es el mismo mensaje que hemos utilizado en nuestra tarea en el método run (), para establecer el resultado de la ejecución en la declaración:
setResult("the execution was performed successfully");
Ahora bien, si se cambia de nuevo al nodo de la consola, debería ver que 2 mensajes nuevos se han publicado:
[java] Hello, this is the node executing a template JPPF task
[java] In fact, this is more than the standard template
Estas líneas 2 son los que en realidad codificada a principios de ejecutar la tarea del método ():
System.out.println("Hello, this is the node executing a template JPPF task");
System.out.println("In fact, this is more than the standard template");
A partir de estos mensajes, podemos concluir que nuestra aplicación se ejecute correctamente. ¡Felicitaciones!
En este punto, hay sin embargo un aspecto que todavía no hemos abordado: desde el nodo es un proceso independiente de nuestra aplicación, ¿cómo sabe para ejecutar nuestra tarea? Recuerde que ni siquiera hemos tratado de implementar las clases aplicación a cualquier ubicación específica. Simplemente hemos recopilado de manera que les podemos ejecutar nuestra aplicación a nivel local. Este tema es objeto de la siguiente sección de este tutorial.
Dinámica de implementación
Una de las mayores características de JPPF es su capacidad para cargar dinámicamente el código de una aplicación que se utilicen tan sólo a nivel local. JPPF amplía la clase estándar de Java mecanismo de carga de manera que, simplemente utilizando las API de JPPF, las clases de una aplicación se cargan a cualquier nodo remoto que las necesita. La ventaja es que no hay despliegue de la aplicación es necesaria para que se ejecute en una cuadrícula JPPF, no importa cómo muchos nodos o servidores están presentes en la red. Además, este mecanismo es totalmente transparente para el desarrollador de aplicaciones.
Una ventaja importante es que los cambios de código son tomados en cuenta de forma automática, sin necesidad de reiniciar los nodos o el servidor. Esto significa que, al cambiar cualquier parte del código que se ejecuta en un nodo, lo único que tienes que hacer es volver a compilar el código y ejecutar la aplicación, y los cambios tendrán efecto de inmediato, en todos los nodos que ejecutan la aplicación.
Ahora vamos a demostrar esto haciendo un pequeño, pero un cambio visible, el código y ejecutarlo en el servidor y el nodo ya hemos empezado, si usted los ha dejado ya, simplemente realizar nuevamente todos los pasos descritos en la sección anterior (2,5), antes de continuar.
Está abierto de nuevo el archivo de origen Let "TemplateJPPFTask.java" en JPPF-xyz-application-template/src/org/jppf/application/template /, y vaya a la método run().Vamos a sustituir las dos primeras líneas con lo siguiente:
System.out.println("*** We are now running a modified version of the code ***");
El método run () ahora debe verse así:
public void run()
{
// write your task code here.
System.out.println("*** We are now running a modified version of the code ***");
// eventually set the execution results
setResult("the execution was performed successfully");
}
Guarde los cambios en el archivo y abrir o volver a una línea de comandos o shell de la consola en el JPPF-xyz-application-carpeta de plantillas. A partir de ahí, el ant "tipo" para ejecutar la aplicación de nuevo. Ahora debería ver los mismos mensajes que en el largo inicial se muestra en la consola. Esto es lo que esperábamos. Por otra parte, si se cambia de nuevo al nodo de la consola, ahora debería ver un nuevo mensaje:
[java] *** We are now running a modified version of the code ***
Éxito! Hemos implementado exitosamente nuestra nuevo código sin ningún tipo de redistribución explícito.
Administración de los trabajos
Ahora que somos capaces de crear, presentar y ejecutar un trabajo, podemos empezar a pensar acerca de la supervisión y, finalmente, el control de su ciclo de vida del grid. Para ello, usaremos la administración y supervisión JPPF consola. El JPPF consola es una herramienta independiente que proporciona interfaces gráficas fáciles de usar para:
obtener estadísticas sobre el rendimiento del servidor
definir, personalizar y visualizar gráficos de rendimiento del servidor
supervisar y controlar el estado y la salud de los servidores y nodos
vigilar y controlar la ejecución de los trabajos en la parrilla
gestionar la carga de trabajo y el comportamiento de equilibrio de carga
Preparar el trabajo para la gestión
En nuestra plantilla de aplicación, el trabajo que llevamos a cabo en el grid tiene una sola tarea. Como hemos visto, esta tarea es muy corto en vivo, ya que se ejecuta en no más de unos pocos milisegundos. Esto definitivamente no nos permite que controlemos o gestionar con nuestro tiempo desnuda reacción humana. A los efectos de este tutorial, ahora vamos a adaptar la plantilla a algo más realista desde esta perspectiva.
Paso 1: Hacer las tareas duran más
Lo que haremos aquí es añadir un retardo a cada tarea, antes de que termine. No hará nada durante este tiempo, sólo esperar a un tiempo determinado. Vamos a editar de nuevo el archivo de origen "TemplateJPPFTask.java" en JPPF-xyz-application-template/src/org/jppf/application/template / y modificar el método run () de la siguiente manera:
public void run()
{
// write your task code here.
System.out.println("*** We are now running a modified version of the code ***");
// simply wait for 3 seconds
try
{
Thread.sleep(3000L);
}
catch(InterruptedException e)
{
setException(e);
return;
}
// eventually set the execution results
setResult("the execution was performed successfully");
}
Tenga en cuenta que aquí, hacemos una llamada explícita a setException(), en el caso de una InterruptedException se eleva. Puesto que esta excepción se producen en el nodo, capturando nos permitirá saber lo que pasó desde el lado de la aplicación.
Paso 2: añadir más tareas a los puestos de trabajo, lo presentará como suspendida
Esta vez, nuestro trabajo va a contener más de una tarea. Para que podamos tener el tiempo para manipular desde la consola de administración, también se inicia en modo suspendido. En este sentido, vamos a modificar el método de createJob () del corredor de aplicaciones"
public JPPFJob createJob() throws Exception
{
// create a JPPF job
JPPFJob job = new JPPFJob();
// give this job a readable unique id that we can use to monitor and manage it.
job.setId("Template Job Id");
// add 10 tasks to the job.
for (int i=0; i<10; i++) job.addTask(new TemplateJPPFTask());
// start the job in suspended mode
job.getJobSLA().setSuspended(true);
return job;}
Paso 3: Inicie los componentes JPPF
Si ha dejado el servidor y el nodo, simplemente empezar de nuevo como se describe en los dos primeros pasos de la sección 2.5 de este tutorial.
También vamos a iniciar la consola de administración:
Ir a la JPPF-xyz-admin-carpeta ui y abrir una línea de comandos o consola de shell. Type "ant". Escriba "ant".
Cuando la consola se inicia, verá un panel llamado "Topología" que muestra los servidores y los nodos conectados a ellos. Se debe tener este aspecto:
Podemos ver aquí que un servidor se inicia en la máquina "lolo-quad" y que tiene un nodo se le atribuye. El color para el servidor es un indicador de salud, lo que significa verde que se está ejecutando normalmente y roja que significa que está abajo.
Cambiemos al "Trabajo de datos" panel, que debería tener este aspecto:
También vemos la información del controlador de la salud con códigos de color en este panel. Actualmente no hay otro elemento en pantalla, porque no hemos presentado un trabajo todavía.
Paso 4: iniciar un nuevo trabajo
Ahora vamos a comenzar un trabajo mediante la ejecución de nuestra aplicación: ir a la JPPF-xyz-application-carpeta de plantillas y abrir una línea de comandos o consola de shell. Escriba "ant". Switch. Vaya a la consola de la administración. Ahora, deberíamos ver un cambio en la pantalla:
Ahora vemos que un trabajo está presente en la cola del servidor, en estado de suspensión (destacado en amarillo). He aquí una explicación de las columnas de la tabla:
"Driver / Trabajo / Nodo": muestra un nombre de usuario para un servidor, por un trabajo presentado a ese servidor, o para un nodo al que algunas de las tareas en el trabajo han sido enviados para su ejecución
"Estado": el estado actual de un trabajo, ya sea "suspendido" o de ejecución "
"Contar tarea inicial": el número de tareas en el trabajo en el momento en que se envía a la aplicación
"Contar tarea actual": el número de tareas pendientes en el trabajo, que no han sido ejecutados
"Prioridad": esta es la prioridad, del trabajo, el valor por defecto es 0.
"Max nodos": el número máximo de nodos de un trabajo puede ser ejecutado en. De forma predeterminada, no hay límite, que se representa como el símbolo de infinito
Paso 5: la reanudación de la ejecución de trabajo
Dado que el trabajo se presentó en estado de suspensión, se reanudará su ejecución manualmente desde la consola Seleccione la línea en el trabajo "ID de la plantilla de trabajo" en la pantalla. Usted debe ver que algunos botones se activará. Haga clic en el botón de reanudar (marcados con el icono [[Image:]]) para reanudar la ejecución del trabajo, como se muestra a continuación:
Tan pronto como reanudar el trabajo, el servidor inicia la distribución de tareas a los nodos, y podemos ver que el recuento de la tarea actual comienza a disminuir en consecuencia, y el estado de los trabajos se ha cambiado a "Ejecutar":
Se le anima a experimentar con la herramienta y el código. Por ejemplo, puede añadir más tareas a los puestos de trabajo, los hacen durar más tiempo, suspender, reanudar o terminar el trabajo mientras se está ejecutando, etc ..
Conclusión
En este tutorial, hemos visto cómo escribir una aplicación JPPF habilitado de punta a punta. También hemos aprendido de las API básicas que nos permiten escribir una solicitud de las unidades de ejecución atómica e independiente llamada tareas y agruparlas en puestos de trabajo que pueden ser ejecutados en la parrilla. También hemos aprendido cómo los trabajos se pueden administrar y controlar de forma dinámica durante la ejecución. Por último, también se enteró de que, a pesar de que una aplicación puede ser distribuida a través de cualquier número de nodos, no hay necesidad de desplegar explícitamente el código de la aplicación, ya que JPPF implícitamente se encarga de ello.
Suscribirse a:
Entradas (Atom)