Desarrollador(es) | Centro de Computación y Tecnología de la LSU , Grupo RADICAL de la Universidad Rutgers , IN2P3 (Francia) y Vrije Universiteit (Ámsterdam, Países Bajos) |
---|---|
Escrito en | C++ , Python , Java |
Plataforma | Multiplataforma |
Tipo | Computación en red , biblioteca de computación distribuida |
Licencia | Licencia de software Boost , GPL |
Sitio web | saga-proyecto.org |
La API simple para aplicaciones de cuadrícula ( SAGA ) es una familia de estándares relacionados especificados por el Open Grid Forum para definir una interfaz de programación de aplicaciones (API) para la funcionalidad informática distribuida común .
La especificación SAGA para computación distribuida originalmente constaba de un único documento, GFD.90, que se publicó en 2009.
La API de SAGA no pretende reemplazar a Globus ni a sistemas de middleware de computación en red similares , y no está dirigida a desarrolladores de middleware, sino a desarrolladores de aplicaciones sin experiencia en computación en red. Estos desarrolladores normalmente desean dedicar su tiempo a sus propios objetivos y minimizar el tiempo dedicado a codificar la funcionalidad de la infraestructura. La API aísla a los desarrolladores de aplicaciones del middleware.
La especificación de los servicios y los protocolos para interactuar con ellos están fuera del alcance de SAGA. En cambio, la API busca ocultar los detalles de cualquier infraestructura de servicio que pueda o no utilizarse para implementar la funcionalidad que necesita el desarrollador de la aplicación. Sin embargo, la API se alinea con todos los estándares de middleware dentro del Open Grid Forum (OGF). [1]
La API de SAGA define un mecanismo para especificar paquetes API adicionales que amplían su alcance. La propia API SAGA Core define una serie de paquetes: gestión de trabajos, gestión de archivos, gestión de réplicas, llamadas a procedimientos remotos y flujos. SAGA cubre la funcionalidad distribuida más importante y utilizada con frecuencia y es compatible y está disponible en todos los principales sistemas de red: Extreme Science and Engineering Discovery Environment (XSEDE), EGI y FutureGrid. SAGA no solo admite una amplia gama de modelos de coordinación y programación distribuida, sino que también es fácilmente extensible para admitir middleware nuevo y emergente. [2] [3]
La API de SAGA está estandarizada en el Grupo de Trabajo SAGA del Open Grid Forum . [4] Basada en un conjunto de casos de uso [5] , [6] la especificación SAGA Core API [1] define un conjunto de principios generales de API (el 'SAGA Look and Feel', y un conjunto de paquetes de API que representan patrones de programación Grid comúnmente utilizados (gestión de trabajos, gestión y acceso a archivos, gestión de réplicas, etc.). La especificación SAGA Core también define cómo se deben definir paquetes de API adicionales y cómo se relacionan con la API Core y con su 'Look and Feel'. Basándose en eso, se han definido varias extensiones de API y se encuentran en varios estados del proceso de estandarización. [7] [8] [9] [10]
Todas las especificaciones de SAGA están definidas en (una variante de) IDL y, por lo tanto, están orientadas a objetos, pero son independientes del lenguaje. Existen diferentes enlaces de lenguaje (Java, C++, Python), pero, en este momento, no están estandarizados. No obstante, las diferentes implementaciones de estos enlaces de lenguaje tienen una definición de API relativamente coherente (en particular, las diferentes implementaciones de Java comparten las mismas clases de API abstractas).
La parte "Apariencia y sensación" de la especificación de la API principal de SAGA cubre las siguientes áreas:
SAGA está diseñado como una interfaz orientada a objetos . Encapsula la funcionalidad relacionada en un conjunto de objetos, que se agrupan en espacios de nombres funcionales , que se denominan paquetes en SAGA. La implementación principal de SAGA define los siguientes paquetes: [11]
La arquitectura general de SAGA sigue el patrón adaptador , un patrón de diseño de software que se utiliza para traducir una interfaz a otra. En SAGA, traduce las llamadas de los paquetes API a las interfaces del middleware subyacente. El sistema de ejecución de SAGA utiliza el enlace tardío para decidir en tiempo de ejecución qué complemento ( adaptador de middleware ) cargar y enlazar. [12]
En la siguiente tabla se enumeran los sistemas de middleware distribuidos que SAGA admite actualmente. La columna denominada Adaptor Suite indica el conjunto (paquete de lanzamiento) de adaptadores de middleware (conjunto de adaptadores) que proporciona compatibilidad con el sistema de middleware.
Sistema de middleware | Conjunto de adaptadores SAGA | Espacio de nombres de la API de SAGA |
---|---|---|
Amazon EC2 | adaptadores saga aws | saga::trabajo |
Cóndor | saga-adaptadores-condor | saga::trabajo |
Eucalipto | adaptadores saga aws | saga::trabajo |
Globus GRAM (2 y 5) | saga-adaptadores-globus | saga::trabajo |
Red FTP de Globus | saga-adaptadores-globus | saga::sistema de archivos |
Síndrome de piernas inquietas (RLS) de Globus | saga-adaptadores-globus | saga::réplica |
Sistema de archivos HDFS | adaptadores saga-hdfs | saga::archivo |
Sistema de archivos local | parte de saga-core | saga::archivo |
Bifurcación local | parte de saga-core | saga::trabajo |
Nimbo | adaptadores saga aws | saga::trabajo |
PBS (Profesional) | adaptadores saga-pbs | saga::trabajo |
Plataforma LSF | adaptadores saga lsf | saga::trabajo |
Servicio de anuncios SQL | parte de saga-core | saga::anuncio |
Servicio de réplica SQL | parte de saga-core | saga::réplica |
SSHFS | adaptadores saga-ssh | saga::archivo |
SSH | adaptadores saga-ssh | saga::trabajo |
ESFUERZO DE TORSIÓN | saga-adaptadores-torque | saga::trabajo |
Dado que las definiciones de interfaz de SAGA no están vinculadas a ningún lenguaje de programación específico, existen varias implementaciones de los estándares SAGA en diferentes lenguajes de programación. Además del lenguaje de implementación, se diferencian entre sí en su exhaustividad en cuanto a la cobertura del estándar, así como en su compatibilidad con middleware distribuido.
SAGA C++ [13] fue la primera implementación completa de la especificación SAGA Core, escrita en C++. Actualmente, la implementación en C++ no se encuentra en desarrollo activo.
RADICAL-SAGA [14] es un paquete Python liviano que implementa partes de la especificación de interfaz OGF GFD.90 [1] y proporciona complementos para diferentes sistemas y servicios de middleware distribuidos. RADICAL-SAGA implementa las características más comúnmente utilizadas de GFD.90 basadas en un análisis de casos de uso extenso, y se enfoca en la usabilidad y la implementación simple en entornos informáticos distribuidos heterogéneos del mundo real y escenarios de aplicación. RADICAL-SAGA actualmente implementa las API centrales de administración de archivos y trabajos, así como la extensión de API de administración de recursos. RADICAL-SAGA proporciona complementos para diferentes sistemas y servicios de middleware distribuidos, incluido el soporte para PBS , Sun Grid Engine , SSH , SFTP y otros. RADICAL-SAGA se puede utilizar para desarrollar aplicaciones distribuidas y marcos que se ejecutan en ciberinfraestructura distribuida, incluidos XSEDE, [15] LONI y FutureGrid, [16] otras nubes y clústeres locales.
JavaSAGA es una implementación de SAGA en Java. El estado de JavaSAGA sigue siendo incierto.
importar java.util.io.* int main ( int argc , char ** argv ) { espacio de nombres sa = saga :: atributos ; espacio de nombres sja = saga :: trabajo :: atributos ; prueba { saga :: trabajo :: descripción jd ; jd . set_attribute ( sja :: description_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: description_output , "/home/user/hello.out" ); jd . set_attribute ( sja :: description_error , "/home/user/hello.err" ); // Declare esto como un trabajo de estilo MPI jd . set_attribute ( sja :: description_spmd_variation , "mpi" ); // Nombre de la cola que queremos utilizar jd.set_attribute ( sja :: description_queue , "checkpt" ); jd.set_attribute ( sja :: description_spmd_variation , " mpi" ) ; // Número de procesadores a solicitar jd.set_attribute ( sja :: description_number_of_processes , "32" ) ; saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . create_job ( jd ); j . run () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . what () << std :: endl ; } }
jSAGA [17] es otra implementación Java de la especificación SAGA Core. jSAGA se encuentra actualmente en desarrollo activo.
DESHL [18] (DEISA Services for Heterogeneous management Layer) proporciona funcionalidad para el envío y la gestión de trabajos computacionales dentro de DEISA . DESHL se implementa como un conjunto de herramientas de línea de comandos sobre una API inspirada en SAGA implementada en Java. En el back-end, interactúa con HiLA, una biblioteca genérica de cliente de acceso a la red, que forma parte del sistema UNICORE .
Una tarea típica en una aplicación distribuida es enviar un trabajo a un administrador de recursos distribuido local o remoto . SAGA proporciona una API de alto nivel denominada paquete de trabajo para esto. Los siguientes dos ejemplos simples muestran cómo se puede utilizar la API del paquete de trabajo de SAGA para enviar un trabajo de interfaz de paso de mensajes (MPI) a un administrador de recursos GRAM remoto de Globus.
#include <saga/saga.hpp> int main ( int argc , char ** argv ) { espacio de nombres sa = saga :: atributos ; espacio de nombres sja = saga :: trabajo :: atributos ; prueba { saga :: trabajo :: descripción jd ; jd . set_attribute ( sja :: description_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: description_output , "/home/user/hello.out" ); jd . set_attribute ( sja :: description_error , "/home/user/hello.err" ); // Declare esto como un trabajo de estilo MPI jd . set_attribute ( sja :: description_spmd_variation , "mpi" ); // Nombre de la cola que queremos utilizar jd.set_attribute ( sja :: description_queue , "checkpt" ); jd.set_attribute ( sja :: description_spmd_variation , " mpi" ) ; // Número de procesadores a solicitar jd.set_attribute ( sja :: description_number_of_processes , "32" ) ; saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . create_job ( jd ); j . run () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . what () << std :: endl ; } }
#!/usr/bin/env python3 import sys import time import bliss.saga como sagadef main ( jobno : int , session , jobservice ) -> None : bfast_base_dir = saga.Url ( "sftp: //india.futuregrid.org/N/u/oweidner/software/bfast/ " ) Intente : workdir = " %s /tmp/run/ %s " % ( bfast_base_dir . path , str ( int ( time . time ()))) basedir = saga . filesystem . Directory ( bfast_base_dir , session = session ) basedir . make_dir ( workdir ) jd = saga . job . description () jd . wall_time_limit = 5 # tiempo de ejecución en minutos jd . total_cpu_count = 1 jd . environment = { "BFAST_DIR" : bfast_base_dir . path } jd . working_directory = workdir jd . executable = "$BFAST_DIR/bin/bfast" jd . arguments = [ "match" , "-A 1" , "-r $BFAST_DIR/data/small/reads_5K/reads.10.fastq" , "-f $BFAST_DIR/data/small/reference/hg_2122.fa" ] mitrabajo = js.create_job ( jd ) mitrabajo.run ( ) print ( "El trabajo n.° %s se inició con el ID ' %s ' y el directorio de trabajo: ' %s '" % ( jobno , myjob . jobid , workdir )) mi trabajo .espera ( ) print ( "Trabajo n.° %s con ID ' %s ' finalizado (RC: %s ). Salida disponible en: ' %s '" % ( jobno , myjob . jobid , myjob . exitcode , workdir )) basado en .close ( ) excepto saga . Excepción , ej .: print ( f "Se produjo un error durante la ejecución del trabajo : { ex } " ) sys.exit ( -1 )si __name__ == "__main__" : host_de_ejecución = saga.Url ( "pbs+ssh://india.futuregrid.org" ) ctx = saga.Context ( ) ctx.type = saga.Context.SSH ctx.userid = " oweidner " # como 'ssh nombre_usuario@host ... ' ctx.userkey = " /Usuarios/oweidner/.ssh/rsa_work " # como ssh -i ... ' sesión = saga .sesión ( ) sesión .contextos .anexar ( ctx ) js = saga .job .Service ( host_ejecución , sesión ) para i en el rango ( 0 , 4 ): main ( i , session , js )
El trabajo relacionado con el Proyecto SAGA está financiado por las siguientes subvenciones: NSF-CHE 1125332 (CDI), [19] NSF-EPS 1003897 (LaSIGMA), [20] NSF-OCI 1007115 (ExTENCI). [21] Las subvenciones anteriores incluyen: NSF-OCI 0710874 (HPCOPS), subvención NIH número P20RR016456 y subvención EPSRC del Reino Unido número GR/D0766171/1 a través de OMII-UK [22]