La API simple para aplicaciones Grid ( SAGA ) es una familia de estándares relacionados especificados por Open Grid Forum para definir una interfaz de programación de aplicaciones (API) para la funcionalidad informática distribuida común .
Desarrollador (es) | Centro de Computación y Tecnología en LSU , RADICAL Group en Rutgers University , IN2P3 (Francia) y Vrije Universiteit (Amsterdam, Países Bajos) |
---|---|
Escrito en | C ++ , Python , Java |
Plataforma | Multiplataforma |
Tipo | Computación en cuadrícula , biblioteca de computación distribuida |
Licencia | Aumente la licencia del software , GPL |
Sitio web | proyecto-saga |
Descripción general
La especificación SAGA para computación distribuida consistía originalmente en un solo documento, GFD.90, que se publicó en 2009.
La API de SAGA no se esfuerza por reemplazar Globus o sistemas de middleware de computación en cuadrícula similares , y no está dirigida a desarrolladores de middleware, sino a desarrolladores de aplicaciones sin experiencia en computación en cuadrícula. 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. Más bien, la API busca ocultar el detalle de cualquier infraestructura de servicio que pueda o no ser utilizada para implementar la funcionalidad que el desarrollador de la aplicación necesita. Sin embargo, la API se alinea con todos los estándares de middleware dentro de Open Grid Forum (OGF). [1]
La API SAGA definió un mecanismo para especificar paquetes API adicionales que amplían su alcance. La propia API SAGA Core define una serie de paquetes: administración de trabajos, administración de archivos, administración de réplicas, llamadas a procedimientos remotos y flujos. SAGA cubre la funcionalidad distribuida más importante y de uso frecuente y es compatible y está disponible en todos los principales sistemas de redes: Extreme Science and Engineering Discovery Environment (XSEDE), EGI y FutureGrid. SAGA no solo admite una amplia gama de modelos distribuidos de programación y coordinación, sino que también es fácilmente ampliable para admitir middleware nuevo y emergente. [2] [3]
Estandarización
La API de SAGA está estandarizada en el Grupo de Trabajo de SAGA, el Open Grid Forum . [4] Basado en un conjunto de casos de uso [5] , [6] la especificación SAGA Core API [7] define un conjunto de principios API generales (el 'SAGA Look and Feel', y un conjunto de paquetes API que se procesan comúnmente Usó patrones de programación Grid (administración de trabajos, administración y acceso de archivos, administración de réplicas, etc.) La especificación SAGA Core también define cómo se definirán los paquetes API adicionales y cómo se relacionan con la API Core y su 'Look and Feel' Sobre esta base, se han definido varias extensiones de API y se encuentran en varios estados del proceso de estandarización. [8] [9] [10] [11]
Todas las especificaciones de SAGA se definen en (un sabor de) IDL y, por lo tanto, están orientadas a objetos, pero son neutrales en el lenguaje. Existen diferentes enlaces de lenguaje (Java, C ++, Python), pero, en este punto, no están estandarizados. Sin embargo, 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 'Look and Feel' de la especificación SAGA Core API cubre las siguientes áreas:
- seguridad y gestión de sesiones
- gestión de permisos
- operaciones asincrónicas
- vigilancia
- notificaciones asincrónicas
- gestión de atributos
- Gestión de búfer de E / S
Arquitectura
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 central de SAGA define los siguientes paquetes: [12]
- saga :: advert - interfaz para el acceso al servicio de anuncios
- saga :: filesystem - interfaz para acceso a archivos y directorios
- saga :: job - interfaz para la definición, gestión y control de trabajos
- saga :: namespace - interfaz abstracta (utilizada por publicidad, sistema de archivos y interfaces de réplica)
- saga :: replica - interfaz para la gestión de réplicas
- saga :: rpc - interfaz para llamadas a procedimientos remotos cliente y servidores
- saga :: sd- interfaz para el descubrimiento de servicios en entornos distribuidos
- saga :: stream - interfaz para clientes y servidores de flujo de datos
La arquitectura general de SAGA sigue el patrón del 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 tiempo de ejecución SAGA utiliza enlace tardío para decidir en tiempo de ejecución qué complemento ( adaptador de middleware ) cargar y enlazar. [13]
Middleware compatible
La siguiente tabla enumera los sistemas de middleware distribuidos que actualmente son compatibles con SAGA. La columna etiquetada Adapter Suite nombra la colección (paquete de lanzamiento) del (conjunto de) adaptadores de middleware que brindan soporte para el sistema de middleware.
Sistema de middleware | Conjunto de adaptadores SAGA | Espacio de nombres de la API de SAGA |
---|---|---|
Amazon EC2 | saga-adaptadores-aws | saga :: trabajo |
Cóndor | saga-adaptadores-cóndor | saga :: trabajo |
Eucalipto | saga-adaptadores-aws | saga :: trabajo |
Globus GRAM (2 y 5) | saga-adaptadores-globus | saga :: trabajo |
Globus GridFTP | saga-adaptadores-globus | saga :: sistema de archivos |
Globus RLS | saga-adaptadores-globus | saga :: réplica |
HDFS | saga-adaptadores-hdfs | saga :: archivo |
Sistema de archivos local | parte de saga-core | saga :: archivo |
Bifurcación local | parte de saga-core | saga :: trabajo |
Nimbo | saga-adaptadores-aws | saga :: trabajo |
PBS (Pro) | saga-adaptadores-pbs | saga :: trabajo |
Plataforma LSF | saga-adaptadores-lsf | saga :: trabajo |
Servicio de anuncios SQL | parte de saga-core | saga :: anuncio |
Servicio de réplica de SQL | parte de saga-core | saga :: réplica |
SSHFS | saga-adaptadores-ssh | saga :: archivo |
SSH | saga-adaptadores-ssh | saga :: trabajo |
ESFUERZO DE TORSIÓN | saga-adaptadores-torque | saga :: trabajo |
Implementaciones
Dado que las definiciones de la interfaz 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. Aparte del lenguaje de implementación, se diferencian entre sí en su integridad en términos de cobertura estándar, así como en su soporte para middleware distribuido.
SAGA C ++
SAGA C ++ fue la primera implementación completa de la especificación SAGA Core, escrita en C ++. Actualmente, la implementación de C ++ no está en desarrollo activo.
RADICAL-SAGA (Python)
RADICAL-SAGA es un paquete de Python liviano que implementa partes de la especificación de interfaz OGF GFD.90 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 extenso análisis de casos de uso, y se enfoca en la usabilidad y la implementación simple en escenarios de aplicaciones y entornos informáticos distribuidos heterogéneos del mundo real. RADICAL-SAGA actualmente implementa el trabajo y las API centrales de administración de archivos, así como la extensión de la 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 y marcos distribuidos que se ejecutan en una ciberinfraestructura distribuida, incluidas XSEDE , LONI y FutureGrid , otras nubes y clústeres locales.
JavaSAGA
JavaSAGA es una implementación Java de SAGA. Este 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 usar jd . set_attribute ( sja :: description_queue , "checkpt" ); jd . set_attribute ( sja :: description_spmd_variation , "mpi" ); // Número de procesadores para 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 . qué () << std :: endl ; } }
jSAGA
jSAGA es otra implementación Java de la especificación SAGA Core. jSAGA se encuentra actualmente en desarrollo activo.
DESHL
El DESHL (DEISA Servicios para la capa de gestión heterogénea), proporciona la funcionalidad para la presentación y 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 de cliente de acceso a la red genérica, que es parte del sistema UNICORE .
Ejemplos de
Envío de trabajos
Una tarea típica en una aplicación distribuida es enviar un trabajo a un administrador de recursos distribuidos local o remoto . SAGA proporciona una API de alto nivel llamada paquete de trabajo para esto. Los siguientes dos ejemplos simples muestran cómo se puede usar la API del paquete de trabajo SAGA para enviar un trabajo de Interfaz de paso de mensajes (MPI) a un administrador de recursos GRAM de Globus remoto.
C ++
#include 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 usar jd . set_attribute ( sja :: description_queue , "checkpt" ); jd . set_attribute ( sja :: description_spmd_variation , "mpi" ); // Número de procesadores para 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 . qué () << std :: endl ; } }
Pitón
#! / usr / bin / env python3 import sys import time import bliss.saga as sagadef main ( jobno : int , session , jobservice ) -> Ninguno : bfast_base_dir = saga . URL ( "sftp: //india.futuregrid.org/N/u/oweidner/software/bfast/" ) try : workdir = " % s / tmp / run / % s " % ( bfast_base_dir . path , str ( int ( time . time ()))) basedir = saga . sistema de archivos . Directorio ( bfast_base_dir , session = sesión ) basedir . make_dir ( workdir ) jd = saga . trabajo . Descripción () jd . wall_time_limit = 5 # tiempo de pared en minutos jd . total_cpu_count = 1 jd . entorno = { 'BFAST_DIR' : bfast_base_dir . ruta } jd . directorio_trabajo = directorio_trabajo jd . ejecutable = '$ BFAST_DIR / bin / bfast' jd . argumentos = [ 'coincidencia' , '-A 1' , '-r $ BFAST_DIR / data / small / reads_5K / reads.10.fastq' , '-f $ BFAST_DIR / data / small / reference / hg_2122.fa' ] myjob = js . create_job ( jd ) mi trabajo . correr () print ( "Trabajo # % s comenzó con el ID ' % s ' y el directorio de trabajo: ' % s '" % ( jobno , myjob . jobid , workdir )) mi trabajo . esperar () imprimir ( "Trabajo # % s con el ID ' % s ' terminado (RC: % s .) de salida disponible en: ' % s '" % ( jobno , myjob . jobid , myjob . exitcode , workdir )) basedir . cerrar () excepto saga . Excepción , por ejemplo : print ( f "Ocurrió un error durante la ejecución del trabajo: { ex } " ) sys . salir ( - 1 )if __name__ == "__main__" : execution_host = saga . Url ( "pbs + ssh: //india.futuregrid.org" ) ctx = saga . Contexto () ctx . tipo = saga . Contexto . SSH ctx . userid = 'oweidner' # como 'ssh username @ host ...' ctx . userkey = '/Users/oweidner/.ssh/rsa_work' # como ssh -i ... ' sesión = saga . Sesión () sesión . contextos . añadir ( ctx ) js = saga . trabajo . Servicio ( execution_host , sesión ) para i en el rango ( 0 , 4 ): main ( i , session , js )
Subsidios
El trabajo relacionado con el Proyecto SAGA está financiado por las siguientes subvenciones: NSF-CHE 1125332 (CDI) , NSF-EPS 1003897 (LaSIGMA) , NSF-OCI 1007115 (ExTENCI) . Las subvenciones anteriores incluyen: NSF-OCI 0710874 (HPCOPS), número de subvención de NIH P20RR016456 y número de subvención de EPSRC del Reino Unido GR / D0766171 / 1 a través de OMII-UK
enlaces externos
- SAGA-Bliss: una implementación Python de SAGA
- jSAGA: una implementación Java de SAGA
- SAGA C ++: una implementación C ++ de SAGA
- SAGA-GLib: una implementación Vala de SAGA para GLib
- PROYECTO SAGA
- POSIX
Notas
- ^ T. Goodale, S. Jha, H. Kaiser, T. Kielmann, P. Kleijer, A. Merzky, J. Shalf y C.Smith, A Simple API for Grid Applications (SAGA), OGF Document Series 90, http : //www.ogf.org/documents/GFD.90.pdf
- ^ SAGA: una API simple para aplicaciones Grid, programación de aplicaciones de alto nivel en Grid Tom Goodale, Shantenu Jha, Harmut Kaiser, Thilo Kielmann, Pascal K leijer, Gregor von Laszewski, Craig Lee, Andre Merzky, Hrabri Rajic, John Shalf Computational Métodos en ciencia y tecnología, vol. 12 # 1, 2006
- ^ Interoperabilidad de cuadrícula a nivel de aplicación con SAGA Shantenu Jha, Hartmut Kaiser, Andre Merzky, Ole Weidner E-SCIENCE '07: Actas de la Tercera Conferencia Internacional IEEE sobre e-Science y Grid Computing (e-Science 2007), 2007
- ^ http://redmine.ogf.org/projects/saga-wg
- ^ Shantenu Jha, Andre Merzky: "Una colección de casos de uso para una API simple para aplicaciones de cuadrícula", Documento informativo de OGF, GFD.70 (pdf)
- ^ Shantenu Jha, Andre Merzky: "Un análisis de requisitos para una API simple para aplicaciones de cuadrícula", Documento informativo de OGF, GFD.71 (pdf)
- ^ Tom Goodale, Shantenu Jha, Hartmut Kaiser, Thilo Kielmann, Pascal Kleijer, Andre Merzky, John Shalf, Chris Smith: "Una API simple para aplicaciones de red (SAGA)", Documento de recomendación de OGF, GFD.90
- ^ Steve Fisher, Anthony Wilson, Arumugam Paventhan: "Extensión de API de SAGA: API de descubrimiento de servicios", Documento de recomendación de OGF, GFD.144 (pdf)
- ^ Andre Merzky: "Extensión de API SAGA: API de anuncios", Documento de recomendación de OGF, GFD.177 (pdf)
- ^ Andre Merzky: "Extensión de API SAGA: API de mensajes", Documento de recomendación de OGF, GFD.178 (pdf)
- ^ Steve Fisher, Anthony Wilson: "Extensión de la API de SAGA: API del navegador del sistema de información", documento de recomendación de OGF, GFD.195 (pdf)
- ^ La API de referencia SAGA C ++ (documentación) [1] .
- ^ SAGA: Cómo funciona (en Vimeo) [2] .