La API simple para aplicaciones Grid ( 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 una funcionalidad informática distribuida común .
La especificación SAGA para computación distribuida originalmente consistía en un solo documento, GFD.90, que se publicó en 2009.
La API SAGA no pretende reemplazar a Globus o sistemas de middleware de computación grid similares , y no está dirigido a desarrolladores de middleware, sino a desarrolladores de aplicaciones sin experiencia en computación grid. 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 servicios y los protocolos para interactuar con ellos está fuera del alcance de SAGA. Más bien, la API busca ocultar los detalles de cualquier infraestructura de servicio que pueda o no usarse 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 SAGA Core API define una serie de paquetes: gestión de trabajos, gestión de archivos, gestión de réplicas, llamadas a procedimientos remotos y transmisiones. 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 sólo soporta una amplia gama de modelos distribuidos de programación y coordinación, sino que también es fácilmente extensible para soportar middleware nuevo y emergente. [2] [3]
La API SAGA está estandarizada en el Grupo de Trabajo SAGA, el Foro Open Grid . [4] Basado 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 API que se representan comúnmente Patrones de programación Grid 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 definirán los paquetes API adicionales y cómo se relacionan con la API Core y con su "apariencia y sensación". En base a eso, se han definido una serie de extensiones de API que se encuentran en varios estados del proceso de estandarización .
Todas las especificaciones SAGA están definidas en (una versión de) IDL y, por lo tanto, están orientadas a objetos, pero son neutrales en cuanto al lenguaje. Existen diferentes enlaces de lenguaje (Java, C++, Python), pero, en este momento, 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 API abstractas).
La parte 'Look and Feel' de la especificación SAGA Core API 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 central de SAGA define los siguientes paquetes: [11]
La arquitectura general de SAGA sigue el patrón de 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. [12]
La siguiente tabla enumera los sistemas de middleware distribuido que actualmente son compatibles con SAGA. La columna denominada Adapter Suite nombra la colección (paquete de lanzamiento) del (conjunto de) adaptadores de middleware que proporciona soporte para el sistema de middleware.
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. Además del lenguaje de implementación, se diferencian entre sí por su integridad en cuanto a cobertura estándar, así como por su soporte para middleware distribuido.
SAGA C++ [13] fue la primera implementación completa de la especificación SAGA Core, escrita en C++. Actualmente, la implementación de 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 distribuido. RADICAL-SAGA implementa las funciones más utilizadas de GFD.90 basándose en un análisis exhaustivo de casos de uso y se centra 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 las API principales de administración de trabajos y archivos, así como la extensión API de administración de recursos. RADICAL-SAGA proporciona complementos para diferentes sistemas y servicios de middleware distribuido, 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, incluidos XSEDE, [15] LONI y FutureGrid, [16] otras nubes y clústeres locales.
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 :: descripción_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: descripción_salida , "/home/user/hello.out" ); jd . set_attribute ( sja :: descripción_error , "/home/user/hello.err" ); // Declarar esto como un trabajo estilo MPI jd . set_attribute ( sja :: descripción_spmd_variation , "mpi" ); // Nombre de la cola que queremos usar jd . set_attribute ( sja :: descripción_queue , "checkpt" ); jd . set_attribute ( sja :: descripción_spmd_variation , "mpi" ); // Número de procesadores para solicitar jd . set_attribute ( sja :: descripción_número_de_procesos , "32" ); saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . crear_trabajo ( jd ); j . ejecutar () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . qué () << std :: endl ; } } jSAGA [17] es otra implementación Java de la especificación SAGA Core. jSAGA se encuentra actualmente en desarrollo activo.
DESHL [18] (Servicios DEISA para capa de gestión heterogénea), proporciona funcionalidad para el envío y gestión de trabajos computacionales dentro de DEISA . DESHL se implementa como un conjunto de herramientas de línea de comandos además de una API inspirada en SAGA implementada en Java. En el back-end, interactúa con HiLA, una biblioteca cliente genérica 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 distribuidos local o remoto . SAGA proporciona una API de alto nivel llamada paquete de trabajo para esto. Los siguientes dos ejemplos sencillos muestran cómo se puede utilizar la API del paquete de trabajos SAGA para enviar un trabajo de interfaz de paso de mensajes (MPI) a un administrador de recursos Globus GRAM remoto.
#incluir <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 :: descripción_executable , "/home/user/hello-mpi" ); jd . set_attribute ( sja :: descripción_salida , "/home/user/hello.out" ); jd . set_attribute ( sja :: descripción_error , "/home/user/hello.err" ); // Declarar esto como un trabajo estilo MPI jd . set_attribute ( sja :: descripción_spmd_variation , "mpi" ); // Nombre de la cola que queremos usar jd . set_attribute ( sja :: descripción_queue , "checkpt" ); jd . set_attribute ( sja :: descripción_spmd_variation , "mpi" ); // Número de procesadores para solicitar jd . set_attribute ( sja :: descripción_número_de_procesos , "32" ); saga :: trabajo :: servicio js ( "gram://my.globus.host/jobmanager-pbs" ); saga :: trabajo :: trabajo j = js . crear_trabajo ( jd ); j . ejecutar () } catch ( saga :: excepción const & e ) { std :: cerr << "Excepción SAGA detectada: " << e . qué () << std :: endl ; } } #!/usr/bin/env python3 importar sys importar tiempo importar bliss.saga como sagadef principal ( número de trabajo : int , sesión , servicio de trabajo ) -> Ninguno : bfast_base_dir = saga . URL ( "sftp://india.futuregrid.org/N/u/oweidner/software/bfast/" ) intente : workdir = " %s /tmp/run/ %s " % ( bfast_base_dir . ruta , str ( int ( time . time ()))) basedir = saga . sistema de archivos . Directorio ( bfast_base_dir , sesión = sesión ) basedir . make_dir ( dirección de trabajo ) 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_de_trabajo = directorio de 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" ] mitrabajo = js . create_job ( jd ) mi trabajo . correr () print ( "Nº de trabajo %s comenzó con ID ' %s ' y directorio de trabajo: ' %s '" % ( jobno , myjob . jobid , workdir )) mi trabajo . esperar () print ( "Trabajo # %s con ID ' %s ' terminado (RC: %s ). Salida disponible en: ' %s '" % ( jobno , myjob . jobid , myjob . exitcode , workdir )) basar . cerca () excepto saga . Excepción , por ejemplo : print ( f "Se produjo un error durante la ejecución del trabajo: { ex } " ) sys . salir ( -1 )si __name__ == "__main__" : ejecución_host = saga . URL ( "pbs+ssh://india.futuregrid.org" ) ctx = saga . Contexto () ctx . tipo = saga . Contexto . SSH ctx . ID de usuario = "oweidner" # como 'ssh nombre de usuario@host...' ctx . clave de usuario = "/Users/oweidner/.ssh/rsa_work" # como ssh -i ...' sesión = saga . Sesión () sesión . contextos . agregar ( ctx ) js = saga . trabajo . Servicio ( ejecución_host , sesión ) para i en el rango ( 0 , 4 ): principal ( i , sesión , 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]