FR3012896A1 - METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES - Google Patents
METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES Download PDFInfo
- Publication number
- FR3012896A1 FR3012896A1 FR1360780A FR1360780A FR3012896A1 FR 3012896 A1 FR3012896 A1 FR 3012896A1 FR 1360780 A FR1360780 A FR 1360780A FR 1360780 A FR1360780 A FR 1360780A FR 3012896 A1 FR3012896 A1 FR 3012896A1
- Authority
- FR
- France
- Prior art keywords
- application
- execution
- program
- computer
- machine
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims abstract description 47
- 230000004044 response Effects 0.000 title claims abstract description 45
- 238000010200 validation analysis Methods 0.000 title claims abstract description 25
- 238000004590 computer program Methods 0.000 title claims description 10
- 238000012545 processing Methods 0.000 claims description 29
- 230000006870 function Effects 0.000 claims description 27
- 239000000203 mixture Substances 0.000 claims description 22
- 238000004891 communication Methods 0.000 claims description 20
- 238000009434 installation Methods 0.000 claims description 14
- 238000011156 evaluation Methods 0.000 claims description 4
- 230000015654 memory Effects 0.000 description 16
- 230000008569 process Effects 0.000 description 9
- 238000004364 calculation method Methods 0.000 description 6
- 230000009471 action Effects 0.000 description 4
- 238000013459 approach Methods 0.000 description 3
- 238000012423 maintenance Methods 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 238000011161 development Methods 0.000 description 2
- 238000009472 formulation Methods 0.000 description 2
- 239000002131 composite material Substances 0.000 description 1
- 230000003247 decreasing effect Effects 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 238000005259 measurement Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003449 preventive effect Effects 0.000 description 1
- 238000004088 simulation Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000008685 targeting Effects 0.000 description 1
- 238000012360 testing method Methods 0.000 description 1
- 230000017105 transposition Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/61—Installation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/5038—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the execution order of a plurality of tasks, e.g. taking priority or time dependency constraints into consideration
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/50—Indexing scheme relating to G06F9/50
- G06F2209/506—Constraint
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Debugging And Monitoring (AREA)
Abstract
Ce procédé (418) comporte : - l'obtention (420) de caractéristiques d'exécution propre à chaque machine informatique (106, 108), - l'évaluation (424) de la durée d'exécution de chaque programme (PMinuteur) à partir des caractéristiques d'exécution des machines informatiques (106, 108), - la comparaison (426) de la durée d'exécution de chaque programme (PMinuteur) avec une durée maximale prédéterminée d'exécution associée à ce programme (PMinuteur), - dans le cas où la durée d'exécution d'au moins un programme (PMinuteur) est supérieure à sa durée maximale d'exécution, la génération (430) d'un résultat de validation indiquant que le temps de réponse de l'application n'est pas validé.This method (418) comprises: obtaining (420) execution characteristics specific to each computer machine (106, 108), - evaluating (424) the execution time of each program (PMinutor) to from the execution characteristics of the computer machines (106, 108), - the comparison (426) of the execution time of each program (PMinutor) with a predetermined maximum execution duration associated with this program (PMinutor), - in the case where the execution time of at least one program (PMinister) is greater than its maximum execution time, the generation (430) of a validation result indicating that the response time of the application n is not validated.
Description
La présente invention concerne un procédé de validation du temps de réponse d'une application, un procédé de déploiement d'une application comportant un tel procédé de validation, un programme d'ordinateur et des dispositifs correspondants.The present invention relates to a method for validating the response time of an application, a method of deploying an application comprising such a validation method, a computer program and corresponding devices.
L'invention s'applique plus particulièrement à des applications temps-réel modulaires (à base de composants) et flexibles (à base de services). La conception d'une application temps-réel se fait traditionnellement en ciblant une infrastructure spécifique, ce qui peut rendre son développement cher et sa maintenance difficile. En outre, les applications temps réels sont de plus en plus complexes, et leur cycle d'évolution est de plus en plus court : évolution des besoins, maintenance préventive/curative, etc. Un point essentiel d'une application temps réel est la prédictibilité de son temps de réponse, en particulier le fait de connaître la borne supérieure du temps de réponse. Par ailleurs, pour des applications qui ne sont pas en temps réel, l'approche à services et composants a été adoptée par l'industrie informatique, car il s'agit d'un moyen efficace pour répondre aux besoins d'intégration et de modularité des systèmes informatiques. En effet, la modularité et la flexibilité d'une application à services/composants facilitent la maintenance et peuvent rendre le développement plus rapide et moins cher. Ces deux concepts - modularité et flexibilité - ont été regroupés dans l'approche des « modèles à composants orientés services », dans laquelle les différentes unités logicielles (les composants) interagissent par biais de services, ceux-ci étant bien définis par une description de service, et publiables (par les fournisseurs, retrouvables par les consommateurs) dans un annuaire de services. Il a donc été recherché d'utiliser l'approche à services pour les applications temps-réel. Dans ce cas, pour valider une composition de services, il a été proposé de traduire la composition de service en un langage permettant le calcul de la durée de réponse de la composition de services. Par exemple, dans l'article de Benghazi et al. intitulé « Real-time web services orchestration and choreography » publié en 2010 dans « Proceedings of the 6th International Workshop on Enterprise & Organizational Modeling and Simulation », EOMAS '10, pages 142-153, il est proposé d'établir une correspondance entre un programme écrit dans le langage BPEL et une formulation dans le langage Timed CPS. Cette solution nécessite de connaître la durée d'exécution de chaque service au moment de la conception de la composition de service. Or cette durée d'exécution n'est pas toujours disponible à ce moment, ou bien n'est pas forcément fiable car souvent fournie par le fabriquant du service, et non par celui qui utilise le service dans une composition. Il peut ainsi être souhaité de prévoir un procédé de validation du temps de réponse d'une application destinée à être déployée sur des machines informatiques, qui permette de s'affranchir d'au moins une partie des problèmes et contraintes précités. Il est donc proposé un procédé de validation du temps de réponse d'une application destinée à être déployée sur des machines informatiques en réseau, l'application comportant : des composants implémentant une ou plusieurs opérations de service, chaque opération étant implémentée par une fonction du composant, et au moins un programme implémentant une composition d'opérations, au moyen d'appels aux fonctions implémentant les opérations de la composition, les composants et le ou les programmes étant destinés à être exécutés chacun par une machine informatique, le procédé comportant : l'obtention de caractéristiques d'exécution propre à chaque machine informatique, l'évaluation de la durée d'exécution de chaque programme à partir des caractéristiques d'exécution des machines informatiques, la comparaison de la durée d'exécution de chaque programme avec une durée maximale prédéterminée d'exécution associée à ce programme, dans le cas où la durée d'exécution d'au moins un programme est supérieure à sa durée maximale d'exécution, la génération d'un résultat de validation indiquant que le temps de réponse de l'application n'est pas validé. Ainsi, grâce à l'invention, il n'est pas nécessaire de connaître la durée des services au moment de leur composition. En outre, la durée d'exécution de la composition de services est fiable car réalisée en tenant compte des caractéristiques des machines informatiques sur laquelle la composition de services sera exécutée. De manière optionnelle, le procédé comporte en outre : l'évaluation de la durée d'exécution de chaque fonction implémentant une opération d'un composant à partir des caractéristiques d'exécution de la machine informatique sur laquelle ce composant est destiné à être exécuté, la durée d'exécution de chaque programme étant obtenue à partir des durées d'exécution des fonctions implémentant les opérations appelées par ce programme. De manière optionnelle également, chaque composant comporte du code machine fait d'instructions élémentaires, et le procédé comporte en outre : - l'obtention des durées de traitement par chaque machine informatique des instructions élémentaires de chaque composant destiné à être exécuté par cette machine informatique, les caractéristiques d'exécution de la machine informatique comportant les durées de traitement.The invention is more particularly applicable to modular (component-based) and flexible (service-based) real-time applications. The design of a real-time application is traditionally done by targeting a specific infrastructure, which can make its development expensive and maintenance difficult. In addition, real-time applications are increasingly complex, and their evolution cycle is increasingly shorter: changing needs, preventive / curative maintenance, etc. An essential point of a real-time application is the predictability of its response time, in particular knowing the upper limit of the response time. In addition, for applications that are not real-time, the services and components approach has been adopted by the IT industry because it is an effective way to meet the integration and scalability needs. computer systems. Indeed, the modularity and flexibility of a service / component application makes maintenance easier and can make development faster and cheaper. These two concepts - modularity and flexibility - have been grouped together in the "service-oriented component models" approach, in which the different software units (the components) interact through services, these being well defined by a description of service, and publishable (by providers, recoverable by consumers) in a service directory. It has therefore been sought to use the service approach for real-time applications. In this case, to validate a composition of services, it has been proposed to translate the service composition into a language for calculating the response time of the service composition. For example, in the article by Benghazi et al. entitled "Real-time web services orchestration and choreography" published in 2010 in "Proceedings of the 6th International Workshop on Enterprise and Organizational Modeling and Simulation", EOMAS '10, pages 142-153, it is proposed to establish a correspondence between a program written in the language BPEL and a formulation in the language Timed CPS. This solution requires knowing the execution time of each service at the time of the design of the service composition. But this runtime is not always available at this time, or is not necessarily reliable because often provided by the manufacturer of the service, and not by the one who uses the service in a composition. It may thus be desirable to provide a method for validating the response time of an application intended to be deployed on computer machines, which makes it possible to overcome at least some of the aforementioned problems and constraints. It is therefore proposed a method for validating the response time of an application intended to be deployed on networked computer machines, the application comprising: components implementing one or more service operations, each operation being implemented by a function of component, and at least one program implementing a composition of operations, by means of calls to the functions implementing the operations of the composition, the components and the program or programs being intended to be executed each by a computer machine, the method comprising: the obtaining of specific execution characteristics for each computer machine, the evaluation of the execution time of each program from the execution characteristics of the computer machines, the comparison of the execution time of each program with a predetermined maximum execution time associated with this program, in case the hard Execution of at least one program is greater than its maximum execution time, the generation of a validation result indicating that the response time of the application is not validated. Thus, thanks to the invention, it is not necessary to know the duration of services at the time of their composition. In addition, the execution time of the composition of services is reliable because carried out taking into account the characteristics of the computer machines on which the composition of services will be executed. Optionally, the method further comprises: evaluating the execution time of each function implementing an operation of a component from the execution characteristics of the computer machine on which this component is intended to be executed, the execution time of each program being obtained from the execution times of the functions implementing the operations called by this program. Also optionally, each component comprises machine code made up of elementary instructions, and the method furthermore comprises: - obtaining the processing times by each computer machine of the elementary instructions of each component intended to be executed by this computer machine , the execution characteristics of the computer machine including the processing times.
De manière optionnelle également, pour au moins une machine informatique, les durées de traitement des instructions élémentaires sont évaluées par un logiciel de mesure exécuté par cette machine informatique. De manière optionnelle également, les machines informatiques sont reliées entre elles par au moins un lien de communication, et le procédé comporte en outre : - l'obtention de la latence de chaque lien de communication, les caractéristiques d'exécution d'une machine informatique comportant la latence de chaque lien de communication reliant cette machine. De manière optionnelle également, l'application comporte plusieurs programmes, chacun associé à une certaine priorité, et le procédé comporte en outre : la sélection des programmes de priorités les plus élevées, tels que, lorsque ces programmes sont exécutés à la chaîne, la durée totale d'exécution reste inférieure à chacune de leurs durées maximale d'exécution, dans le cas où au moins un programme n'est pas sélectionné, la génération du résultat de validation indiquant que le temps de réponse de l'application n'est pas validé. Il est également proposé un procédé de déploiement d'une application, comportant : la mise en oeuvre d'un procédé selon l'invention de validation du temps de réponse de l'application, en l'absence de résultat de validation indiquant que le temps de réponse de l'application n'est pas validé, le déploiement de l'application par l'installation des composants et du ou des programmes sur leurs machines informatiques respectives, en présence d'un résultat de validation indiquant que le temps de réponse de l'application n'est pas validé, l'interruption du déploiement de l'application et/ou l'affichage d'un message d'erreur et/ou l'écriture dans un fichier de compte-rendu d'une entrée indiquant que le temps de réponse de l'application n'est pas validé. Il est également proposé un programme d'ordinateur téléchargeable depuis un réseau de communication et/ou enregistré sur un support lisible par ordinateur et/ou exécutable par un processeur, caractérisé en ce qu'il comprend des instructions pour l'exécution des étapes d'un procédé selon l'l'invention de validation du temps de réponse d'une application, ou bien d'un procédé selon l'invention de déploiement d'une application, lorsque ledit programme d'ordinateur est exécuté sur un ordinateur. Il est également proposé un dispositif de validation du temps de réponse d'une application destinée à être déployée sur des machines informatiques en réseau, l'application comportant : des composants implémentant une ou plusieurs opérations de service, chaque opération étant implémentée par une fonction du composant, et au moins un programme implémentant une composition d'opérations, au moyen d'appels aux fonctions implémentant les opérations de la composition, les composants et le ou les programmes étant destinés à être exécutés chacun par une machine informatique, le dispositif comportant : une unité d'obtention de caractéristiques d'exécution propre à chaque machine informatique, une unité d'évaluation de la durée d'exécution de chaque programme à partir des caractéristiques d'exécution des machines informatiques, une unité de comparaison de la durée d'exécution de chaque programme avec une durée maximale prédéterminée d'exécution associée à ce programme, une unité de génération, dans le cas où la durée d'exécution d'au moins un programme est supérieure à sa durée maximale d'exécution, d'un résultat de validation indiquant que le temps de réponse de l'application n'est pas validé Il est également proposé un dispositif de déploiement d'une application, comportant : un dispositif selon l'invention de validation du temps de réponse de l'application, une unité de déploiement de l'application par l'installation des composants et du ou des programmes sur leurs machines informatiques respectives, en l'absence de résultat de validation indiquant que le temps de réponse de l'application n'est pas validé, une unité d'interruption du déploiement de l'application et/ou d'affichage d'un message d'erreur et/ou d'écriture dans un fichier de compte-rendu d'une entrée indiquant que l'application est invalide, en présence d'un résultat de validation indiquant que le temps de réponse de l'application n'est pas validé. L'invention sera mieux comprise à l'aide de la description qui va suivre, donnée uniquement à titre d'exemple et faite en se référant aux dessins annexés dans lesquels : la figure 1 représente schématiquement la structure générale d'une installation informatique selon un mode de réalisation de l'invention, la figure 2 représente schématiquement un découpage fonctionnel en services d'une application destinée à être déployée, la figure 3 représente schématiquement une implémentation des services de la figure 2 en composants de l'application, la figure 4 illustre les étapes successives d'un procédé de déploiement de l'application, selon un mode de réalisation de l'invention, et la figure 5 représente schématiquement la structure générale de l'installation informatique de la figure après déploiement de l'application.Also optionally, for at least one computer machine, the processing times of the elementary instructions are evaluated by a measurement software executed by this computer machine. Also optionally, the computer machines are interconnected by at least one communication link, and the method further comprises: - obtaining the latency of each communication link, the execution characteristics of a computer machine with the latency of each communication link connecting this machine. Optionally also, the application has several programs, each associated with a certain priority, and the method further comprises: selecting the highest priority programs, such as, when these programs are run in the chain, the duration execution time remains below each of their maximum execution times, in the case where at least one program is not selected, the generation of the validation result indicating that the response time of the application is not valid. There is also provided a method for deploying an application, comprising: implementing a method according to the invention for validating the response time of the application, in the absence of a validation result indicating that the time application response is not validated, the deployment of the application by the installation of components and the program or programs on their respective computer machines, in the presence of a validation result indicating that the response time of the application is not validated, the interruption of the application deployment and / or the display of an error message and / or the writing in a report file of an entry indicating that the response time of the application is not validated. It is also proposed a computer program downloadable from a communication network and / or recorded on a computer readable medium and / or executable by a processor, characterized in that it comprises instructions for the execution of the steps of a method according to the invention for validating the response time of an application, or a method according to the invention of deployment of an application, when said computer program is executed on a computer. It is also proposed a device for validating the response time of an application intended to be deployed on networked computer machines, the application comprising: components implementing one or more service operations, each operation being implemented by a function of component, and at least one program implementing a composition of operations, by means of calls to the functions implementing the operations of the composition, the components and the program or programs being intended to be executed each by a computer machine, the device comprising: a unit for obtaining performance characteristics specific to each computer machine, a unit for evaluating the execution time of each program from the execution characteristics of the computer machines, a unit for comparing the duration of execution of each program with a predetermined maximum duration of execution e to this program, a generation unit, in the case where the execution time of at least one program is greater than its maximum execution time, a validation result indicating that the response time of the application is not validated It is also proposed a device for deploying an application, comprising: a device according to the invention for validating the response time of the application, a unit for deploying the application by the installation components and program (s) on their respective computer machines, in the absence of a validation result indicating that the response time of the application is not validated, a unit for interrupting the deployment of the application and / or displaying an error message and / or writing in a report file of an entry indicating that the application is invalid, in the presence of a validation result indicating that the response time the application is not p as validated. The invention will be better understood with the aid of the following description, given solely by way of example and with reference to the appended drawings, in which: FIG. 1 schematically represents the general structure of a computer installation according to a Embodiment of the invention, FIG. 2 diagrammatically represents a functional division into services of an application intended to be deployed, FIG. 3 diagrammatically represents an implementation of the services of FIG. 2 as components of the application, FIG. illustrates the successive steps of a deployment method of the application, according to one embodiment of the invention, and Figure 5 schematically shows the general structure of the computer installation of the figure after deployment of the application.
En référence à la figure 1, une installation informatique 100 selon l'invention va à présent être décrite. L'installation informatique 100 comporte tout d'abord une machine 102 de déploiement d'une application. L'application est de préférence une application temps réel. Comme cela sera expliqué plus en détail plus loin, l'application est destinée à être déployée sur des machines informatiques de l'installation informatique 100. L'application comporte des composants et au moins un programme utilisant les composants pour réaliser une fonctionnalité souhaitée de l'application. Les composants et le ou les programmes sont destinés à être exécutés chacun par une des machines informatiques. La machine de déploiement 102 est munie d'une unité de traitement 102A, d'une mémoire vive 102B, d'une mémoire de masse 102C et d'une interface réseau 102D. L'installation informatique 100 comporte en outre des machines informatiques 106, 108 destinées à exécuter chacune au moins un composant et/ou au moins un programme de l'application. Chaque machine d'exécution 106, 108 est munie d'une unité de traitement 106A, respectivement 108A, d'une mémoire vive 106B, respectivement 108B, d'une mémoire de masse 106C, respectivement 108C, d'une première interface réseau 106D, respectivement 108D, et d'une seconde interface réseau 106E, respectivement 108E.With reference to FIG. 1, a computer installation 100 according to the invention will now be described. The computer installation 100 firstly comprises a machine 102 for deploying an application. The application is preferably a real-time application. As will be explained in more detail below, the application is intended to be deployed on computer machines of the computer installation 100. The application comprises components and at least one program using the components to achieve a desired functionality of the computer. 'application. The components and the program or programs are each intended to be executed by one of the computer machines. The deployment machine 102 is provided with a processing unit 102A, a random access memory 102B, a mass memory 102C and a network interface 102D. The computer installation 100 further comprises computer machines 106, 108 for executing each at least one component and / or at least one program of the application. Each execution machine 106, 108 is provided with a processing unit 106A, respectively 108A, a random access memory 106B, respectively 108B, a mass memory 106C, 108C respectively, of a first network interface 106D, respectively 108D, and a second network interface 106E, respectively 108E.
Dans l'exemple décrit, les secondes interfaces réseau 106E, 108E sont des interfaces InfiniBand (marque déposée). Les machines informatiques 102, 106, 108 sont des ordinateurs au sens large. Il s'agit par exemple de serveurs, de tablettes ou bien encore de téléphones intelligents (de l'anglais « smartphones »).In the example described, the second network interfaces 106E, 108E are InfiniBand (registered trademark) interfaces. Computer machines 102, 106, 108 are computers in the broad sense. These include, for example, servers, tablets or even smartphones ("smartphones").
Les unités de traitement 102A, 106A, 108A sont destinées à exécuter des instructions de programme d'ordinateur et comportent par exemple chacune un ou plusieurs processeurs ou bien un ou plusieurs microprocesseurs à un ou plusieurs coeurs. Les mémoires vives 102B, 106B, 108B sont destinées à contenir de manière provisoire les données traitées lors de l'exécution de programmes d'ordinateur. Les mémoires vives 102B, 106B, 108B comportent par exemple de la mémoire à accès direct (de l'anglais « Random Access Memory » ou RAM). Les mémoires de masse 102C, 106C, 108C sont destinées à contenir des données sur une longue durée, et en particulier lors de la mise hors tension des machines informatiques 102, 106, 108. Les mémoires de masse 102C, 106C, 108C comportent par exemple un disque dur, un lecteur/enregistreur de disque muni d'un disque, tel qu'un disque CD ou un disque DVD, ou bien encore un disque électronique (de l'anglais « Solid State Drive » ou SSD). L'installation informatique 100 comporte en outre des liens de communication 110, 112, 114. Le premier lien de communication 110 est une liaison reliant l'interface réseau 102D de la machine de déploiement 102 à l'interface réseau 106D de la première machine d'exécution 106. Le deuxième lien de communication 112 est une liaison reliant l'interface réseau 102D de la machine de déploiement 102 à l'interface réseau 108D de la seconde machine d'exécution 108. Le troisième lien de communication 114 est une liaison InfiniBand reliant l'interface InfiniBand 106E de la première machine d'exécution 106 à l'interface InfiniBand 108E de la seconde machine d'exécution 108. L'installation informatique 100 comporte en outre un intergiciel (de l'anglais « middleware ») de déploiement de l'application. L'intergiciel comporte une première partie, appelée intergiciel principal 116, installée sur la machine de déploiement 102. L'intergiciel principal 116 est enregistré dans la mémoire de masse 102C et comporte des instructions destinées à être chargées dans la mémoire vive 102B pour être exécutées par l'unité de traitement 102A afin de réaliser les étapes correspondantes du procédé de déploiement qui sera décrit par la suite. L'intergiciel comporte en outre deux autres parties, appelées intergiciels auxiliaires 120, 122, respectivement installées sur les machines d'exécution 106, 108. Les intergiciels auxiliaires 120, 122 sont respectivement enregistrés dans les mémoires de masse 106C, 108C et comportent des instructions destinées à être respectivement chargées dans les mémoires vives 106B, 108B pour être respectivement exécutées par les unités de traitement 106A, 108A afin de réaliser les étapes correspondantes du procédé de déploiement qui sera décrit par la suite. De préférence, l'intergiciel présente une interface homme/machine permettant à un utilisateur de lui fournir des informations nécessaires au déploiement de l'application. Cette interface homme/machine comporte par exemple une interface système en mode texte (de l'anglais « shell ») ou bien une interface graphique. L'installation informatique 100 comporte en outre un logiciel de mesure 124 installé sur la seconde machine d'exécution 108. Le logiciel de mesure 124 est enregistré dans la mémoire de masse 108C et comporte des instructions destinées à être chargées dans la mémoire vive 108B pour être exécutées par l'unité de traitement 108A afin de réaliser les étapes correspondantes du procédé de déploiement qui sera décrit par la suite. L'installation informatique 100 comporte en outre des première et seconde machines virtuelles 126, 128 respectivement installées sur les première et seconde machines d'exécution 106, 108. Les machines virtuelles 126, 128 sont des programmes d'ordinateur respectivement enregistrés dans les mémoires de masse 106C, 108C et comportant des instructions destinées à être respectivement chargées dans les mémoires vives 106B, 108B pour être respectivement exécutées par les unités de traitement 106A, 108A afin de simuler chacune une machine informatique. Dans l'exemple décrit, les machines virtuelles 126, 128 sont des machines virtuelles Java (marque déposée) temps réel.The processing units 102A, 106A, 108A are intended to execute computer program instructions and each comprise for example one or more processors or one or more microprocessors with one or more cores. The RAMs 102B, 106B, 108B are intended to temporarily contain the data processed during the execution of computer programs. The random access memories 102B, 106B, 108B comprise, for example, random access memory (Random Access Memory or RAM). The mass memories 102C, 106C, 108C are intended to contain data over a long period of time, and in particular when the computer machines 102, 106, 108 are turned off. The mass memories 102C, 106C, 108C comprise, for example, a hard disk, a disk drive / recorder with a disk, such as a CD or DVD disc, or even an electronic disk ("Solid State Drive" or SSD). The computer installation 100 furthermore comprises communication links 110, 112, 114. The first communication link 110 is a link connecting the network interface 102D of the deployment machine 102 to the network interface 106D of the first machine. The second communication link 112 is a link connecting the network interface 102D of the deployment machine 102 to the network interface 108D of the second execution machine 108. The third communication link 114 is an InfiniBand link. connecting the InfiniBand interface 106E of the first runtime machine 106 to the InfiniBand interface 108E of the second runtime machine 108. The computer installation 100 further comprises middleware (deployment middleware). of the application. The middleware comprises a first part, called the main middleware 116, installed on the deployment machine 102. The main middleware 116 is stored in the mass memory 102C and includes instructions intended to be loaded into the random access memory 102B to be executed. by the processing unit 102A in order to carry out the corresponding steps of the deployment method which will be described later. The middleware further comprises two other parts, called auxiliary middleware 120, 122 respectively installed on the execution machines 106, 108. The auxiliary middleware 120, 122 are respectively registered in the mass memories 106C, 108C and include instructions intended to be respectively loaded into the RAMs 106B, 108B to be respectively executed by the processing units 106A, 108A in order to carry out the corresponding steps of the deployment method which will be described later. Preferably, the middleware has a man / machine interface allowing a user to provide information necessary for the deployment of the application. This man / machine interface comprises for example a system interface in text mode (of the English "shell") or a graphical interface. The computer installation 100 further comprises a measurement software 124 installed on the second execution machine 108. The measurement software 124 is recorded in the mass memory 108C and includes instructions intended to be loaded into the random access memory 108B. be performed by the processing unit 108A to perform the corresponding steps of the deployment method which will be described later. The computer installation 100 further comprises first and second virtual machines 126, 128 respectively installed on the first and second execution machines 106, 108. The virtual machines 126, 128 are computer programs respectively recorded in the memory memories. mass 106C, 108C and having instructions for respectively being loaded into the RAMs 106B, 108B to be respectively performed by the processing units 106A, 108A to each simulate a computer machine. In the example described, the virtual machines 126, 128 are real-time Java (trademark) virtual machines.
En référence à la figure 2, un découpage fonctionnel de l'application en services va à présent être décrit. De manière générale, l'application utilise plusieurs services offrant chacun au moins une opération. Chaque opération peut nécessiter (c'est-à-dire appeler) une ou plusieurs opérations d'un autre service. Dans l'exemple décrit, l'application est découpée fonctionnellement en trois services SCalcul, Sminuteur et SDonnées. Le service SCalcul est destiné à réaliser un calcul et offre pour cela une opération Calculer. Le service SMinuteur est destiné à déclencher le calcul et offre pour cela une opération DéclencherCalcul. Le service SDonnées est destiné à récupérer le résultat du calcul et offre pour cela une opération RécupérerRésultat. En référence à la figure 3, une implémentation des services en composants va à présent être décrite. De manière générale, un composant est un programme d'ordinateur implémentant les opérations d'un ou plusieurs services. Les composants sont donc du code machine fait d'instructions élémentaires provenant de la compilation de code source écrit dans un langage informatique, tel que le langage Java, C, C++, ou bien Ada. Chaque composant comporte des fonctions (appelées « méthodes » dans la programmation orientée objet). Des premières fonctions implémentent les opérations des services, tandis que les autres fonctions sont utilisées par les premières fonctions pour réaliser les opérations. Par ailleurs, les composants peuvent être regroupés en composants plus gros, appelés parfois « composites ». Dans l'exemple décrit, les services de l'application sont implémentés en deux composants CMinuteur, CCalcul. Le premier composant CMinuteur implémente les services SMinuteur et SDonnées, tandis que le second composant CCalcul implémente le service SCalcul. Dans l'exemple décrit, les composants CMinuteur et CCalcul sont du code machine pour machine virtuelle Java, également appelée JVM (de l'anglais « Java Virtual Machine »), et proviennent donc de la compilation de code source écrit en Java. En référence à la figure 4, un procédé 400 de déploiement de l'application va à présent être décrit. Au cours d'une étape 402, l'intergiciel principal 116 obtient une description D1 de l'environnement matériel de l'application.With reference to FIG. 2, a functional division of the application into services will now be described. In general, the application uses several services each offering at least one operation. Each operation may require (i.e. call) one or more operations of another service. In the example described, the application is functionally divided into three services SCalcul, Sminutor and SDonnées. The SCalculating service is intended to perform a calculation and offers a Calculation operation for this purpose. The SMinutor service is intended to trigger the calculation and offers a TriggerCalculating operation. The SDData service is intended to retrieve the calculation result and offers a RetrieveResult operation for this purpose. Referring to Figure 3, an implementation of the component services will now be described. In general, a component is a computer program implementing the operations of one or more services. The components are thus machine code made of elementary instructions from the compilation of source code written in a computer language, such as Java, C, C ++, or Ada. Each component has functions (called "methods" in object-oriented programming). First functions implement the operations of the services, while the other functions are used by the first functions to perform the operations. In addition, components can be grouped into larger components, sometimes called "composites". In the example described, the services of the application are implemented in two CMinutor components, CCalculating. The first CM component implements the SMinutor and SDData services, while the second CCalcul component implements the SCalcul service. In the example described, the CMinutor and CCalcul components are machine code for Java virtual machine, also called JVM (of the "Java Virtual Machine"), and therefore come from the compilation of source code written in Java. With reference to FIG. 4, a method 400 for deploying the application will now be described. During a step 402, the main middleware 116 obtains a description D1 of the hardware environment of the application.
La description D1 indique tous d'abord les machines d'exécution 106, 108, c'est-à-dire les machines informatiques destinées à exécuter l'application. La description D1 indique en outre les ressources de chaque machine d'exécution 106, 108. Ces ressources sont divisées entre ressources quantifiables et ressources partagées. Les ressources quantifiables sont celles qui peuvent être représentées par une quantité pouvant être consommée en tout ou en partie lors de l'exécution d'un composant. Les ressources quantifiables comportent par exemple la mémoire vive disponible, la mémoire de masse disponible sont utilisées intégralement par un ou plusieurs composants. Il s'agit par exemple d'une interface réseau, d'une unité de traitement d'un type particulier, ou bien encore d'un logiciel installé. La description D1 indique en outre les liens de communication pouvant être utilisés pour l'exécution de l'application. Dans l'exemple décrit, la description D1 comporte les informations suivantes : Machine d'exécution 106 : 192 GB de mémoire vive 106B (ressource quantifiable) machine virtuelle Java temps réel 126 (ressource partagée) interface InfiniBand 106E (ressource partagée) Machine d'exécution 108 : 32 GB de mémoire vive 108B (ressource partagée) machine virtuelle Java temps réel 128 (ressource partagée) interface InfiniBand 108E (ressource partagée) Lien de communication 114 entre les interfaces InfiniBand 106E, 108E : - de type InfiniBand (ressource partagée) - débit de 56 Gb/s (ressource quantifiable) Au cours d'une étape 404, l'intergiciel principal 116 obtient une description D2 de modes d'exécution de l'application. La description D2 indique un ou plusieurs modes d'exécution, chacun deux indiquant les machines informatiques et les ressources de ces machines informatiques pouvant être utilisées par l'application. Dans l'exemple décrit, la description D2 comporte un seul mode d'exécution, appelé mode normal, dans lequel les deux machines 106, 108 et toutes leurs ressources peuvent être utilisées.The description D1 first indicates the execution machines 106, 108, that is to say the computer machines intended to execute the application. The description D1 further indicates the resources of each execution machine 106, 108. These resources are divided between quantifiable resources and shared resources. Quantifiable resources are those that can be represented by a quantity that can be consumed in whole or in part during the execution of a component. Quantifiable resources include, for example, the available random access memory and the available mass memory are used integrally by one or more components. This is for example a network interface, a processing unit of a particular type, or even software installed. The description D1 further indicates the communication links that can be used for the execution of the application. In the example described, the description D1 comprises the following information: Execution machine 106: 192 GB of RAM 106B (quantifiable resource) real-time Java virtual machine 126 (shared resource) InfiniBand interface 106E (shared resource) execution 108: 32 GB RAM 108B (shared resource) real-time Java virtual machine 128 (shared resource) InfiniBand interface 108E (shared resource) 114 communication link between InfiniBand interfaces 106E, 108E: - InfiniBand type (shared resource) 56 Gb / s Rate (Quantifiable Resource) During a step 404, the main middleware 116 obtains a description D2 of the execution modes of the application. The description D2 indicates one or more execution modes, each two indicating the computer machines and the resources of these computer machines that can be used by the application. In the example described, the description D2 comprises a single mode of execution, called normal mode, in which the two machines 106, 108 and all their resources can be used.
Au cours d'une étape 406, l'intergiciel principal 116 obtient une description D3 des services de l'application. La description D3 indique les services SCalcul, SMinuteur, SDonnées utilisés par l'application, ainsi que les opérations de chacun d'eux.During a step 406, the main middleware 116 obtains a description D3 of the services of the application. The description D3 indicates the services SCalculate, SMinister, SData used by the application, as well as the operations of each of them.
Dans l'exemple décrit, la description D3 comporte les informations suivantes : Service SCalcul : - Opération Calculer Service SMinuteur : - Opération DéclencherCalcul Service SDonnées : - Opération RécupérerRésultat La description D3 peut en outre comporter d'autres informations pour chaque opération, telles que les entrées et sorties de l'opération (type de données, taille, etc.) et des conditions sur ces entrées et sorties (par exemple, entrée non vide, etc.).In the example described, the description D3 comprises the following information: SCalculating Service: - Calculate Operation SMInteger Service: - Trigger OperationCalculation SDSData: - RetrieveResultDocument The description D3 may also include other information for each operation, such as inputs and outputs of the operation (data type, size, etc.) and conditions on these inputs and outputs (eg non-empty input, etc.).
Au cours d'une étape 408, l'intergiciel principal 116 obtient une description D4 des composants de l'application. Chaque composant peut faire appel à des opérations implémentées par d'autres composants. La description D4 indique les composants CMinuteur, CCalcul de l'application. En outre, la description D4 indique la machine d'exécution 106, 108 sur laquelle chaque composant CMinuteur, CCalcul est destiné à être déployé, ainsi que les services fournis et les services requis par le composant. Par ailleurs, la description D4 indique les ressources requises par chaque composant CMinuteur, CCalcul. Dans le cas d'une ressource quantifiable, la description D4 indique la quantité de ressource requise.During a step 408, the main middleware 116 obtains a description D4 of the components of the application. Each component can use operations implemented by other components. The description D4 indicates the components CMinutor, CCalculating the application. In addition, the description D4 indicates the execution machine 106, 108 on which each CM component, CCalculus is intended to be deployed, as well as the services provided and the services required by the component. Furthermore, the description D4 indicates the resources required by each CMinutor component, CCalculus. In the case of a quantifiable resource, the description D4 indicates the quantity of resource required.
Dans l'exemple décrit, la description D4 comporte les informations suivantes : Composant CMinuteur : machine d'exécution 108 services fournis : SMinuteur, SDonnées services requis : SCalcul ressources requises : - 1 MB de mémoire vive - une interface InfiniBand - une JVM temps réel Composant CCalcul : - machine d'exécution 106 - services fournis : SCalcul - services requis : (aucun) - ressources requises : - 10 MB de mémoire vive - une interface InfiniBand - une JVM temps réel Au cours d'une étape 410, l'intergiciel principal 116 obtient une description D5 d'une politique de déploiement de l'application. La description D5 indique tout d'abord l'ordre dans lequel les composants CMinuteur, Cdonnées doivent être déployés. Elle indique en outre les actions à entreprendre lorsque le temps de réponse de l'application n'est pas validé, comme cela sera expliqué par la suite. Au cours d'une étape 412, l'intergiciel principal 116 obtient une description D6 du ou des programmes de l'application. Chaque programme de l'application correspond à une composition d'opérations implémentées par les composants. De préférence, un seul programme peut être exécuté à la fois. La description D6 indique chaque programme de d'application, ainsi que la machine d'exécution 106, 108 sur laquelle il est destiné à être déployé. La description D6 indique en outre une durée maximale prédéterminée d'exécution de chaque programme. La description D6 indique par ailleurs la composition des opérations implémentée par chaque programme. Cette composition est par exemple indiquée sous la forme de pseudo-code et comporte des appels à des opérations de services implémentés par les composants CMinuteur, CCalcul de l'application.In the example described, the description D4 includes the following information: CMinutor component: execution machine 108 services provided: SMinutor, SDServices required: SCal resources required: - 1 MB of RAM - an InfiniBand interface - a real-time JVM Component Calculation: - runtime machine 106 - services provided: SCalcul - required services: (none) - resources required: - 10 MB of RAM - an InfiniBand interface - a real-time JVM During a step 410, the senior middleware 116 obtains a description D5 of an application deployment policy. The description D5 first indicates the order in which the CMinutor, Cdata components must be deployed. It also indicates the actions to take when the response time of the application is not validated, as will be explained later. During a step 412, the main middleware 116 obtains a description D6 of the program or programs of the application. Each program of the application corresponds to a composition of operations implemented by the components. Preferably, only one program can be run at a time. The description D6 indicates each application program, as well as the execution machine 106, 108 on which it is intended to be deployed. Description D6 further indicates a predetermined maximum duration of execution of each program. The description D6 also indicates the composition of the operations implemented by each program. This composition is for example indicated in the form of a pseudo-code and includes calls to service operations implemented by the CMinutor components, CCalculating the application.
La description D6 indique en outre le langage informatique dans lequel le pseudo-code est destiné à être traduit. Dans l'exemple décrit, la description D6 comporte les informations suivantes : Programme (PMinuteur) : - machine d'exécution 108 - durée maximale d'exécution : 250 ms - Composition des opérations : Invoquer SMinuteur -> « DeclencherCalcul » ; Résultat := SDonnees -> « RecupererRésultat » ; Afficher Résultat à l'écran ; - Langage informatique : Java Les descriptions D1 à D6 précédentes sont généralement générées par un utilisateur qui les fourni à l'intergiciel principal 116 par exemple sous la forme de fichiers. Les fichiers sont alors de préférence écrits dans un langage à balises, tel que le langage XML ou une variante du langage XML.Description D6 further indicates the computer language in which the pseudo-code is to be translated. In the example described, the description D6 includes the following information: Program (PMinutor): - execution machine 108 - maximum execution time: 250 ms - Composition of operations: Invoke SMinuteur -> "DéclencherCalcul"; Result: = SDonnees -> "RecoverResult"; Show Result on the screen; Computer language: Java The preceding descriptions D1 to D6 are generally generated by a user who supplies them to the main middleware 116, for example in the form of files. The files are then preferably written in a tagged language, such as the XML language or a variant of the XML language.
Au cours d'une étape 414, l'intergiciel principal 116 traduit le pseudo-code du ou des programmes en code source rédigé dans le langage informatique indiqué dans la description D6 de la ou des programmes de l'application, puis compile le code source en code machine. Dans l'exemple décrit, le programme PMinuteur est ainsi d'abord traduit en code source Java, puis compiler en code machine Java. Au cours d'une étape 416, l'intergiciel principal 116 obtient le mode d'exécution à utiliser, appelé mode en cours. Le mode d'exécution à utiliser est par exemple indiqué, avant le déploiement de l'application, à l'intergiciel principal 116 par un utilisateur.During a step 414, the main middleware 116 translates the pseudo-code of the program (s) into source code written in the computer language indicated in the description D6 of the program or programs of the application, and then compiles the source code. in machine code. In the example described, the program PMinutor is thus first translated into Java source code, then compile in Java machine code. During a step 416, the main middleware 116 obtains the execution mode to be used, called the current mode. The execution mode to be used is for example indicated, before the deployment of the application, to the main middleware 116 by a user.
Au cours d'une étape 418, l'intergiciel principal 116 met en oeuvre un procédé de validation du temps de réponse de l'application comportant les étapes 420 à 430 suivantes. Au cours d'une étape 420, l'intergiciel principal 116 obtient, pour chaque machine d'exécution 106, 108, des caractéristiques d'exécution de programme par cette machine. L'intergiciel principal 116 enregistre ces caractéristiques, par exemple dans la mémoire de masse 102C pour pouvoir les réutiliser. Les caractéristiques d'exécution d'une machine comportent tout d'abord les durées de traitement des instructions élémentaires par la machine d'exécution. Les instructions élémentaires, également appelées instructions machines, sont les instructions de base qu'une unité de traitement peut traiter. L'intergiciel principal 116 peut par exemple obtenir une durée de traitement pour chaque instruction élémentaire. En variante, il peut obtenir une même durée de traitement pour toutes les instructions élémentaires, par exemple la durée de traitement la plus longue. Les caractéristiques d'exécution d'une machine comportent en outre les latences du ou des liens de communication 114 reliant cette machine à d'autres machines d'exécution 106, 108. La latence correspond au délai entre l'envoi d'un message à une extrémité du lien de communication et sa réception à l'autre extrémité. Les caractéristiques d'exécution d'une machine comportent en outre la durée de commutation entre deux tâches en cours d'exécution sur la machine.During a step 418, the main middleware 116 implements a method for validating the response time of the application comprising the following steps 420 to 430. During a step 420, the main middleware 116 obtains, for each execution machine 106, 108, program execution characteristics by this machine. The main middleware 116 stores these characteristics, for example in the mass memory 102C to be able to reuse them. The execution characteristics of a machine comprise firstly the processing times of the basic instructions by the execution machine. Basic instructions, also known as machine instructions, are the basic instructions that a processing unit can process. The main middleware 116 may for example obtain a processing time for each elementary instruction. As a variant, it can obtain the same processing time for all the elementary instructions, for example the longest processing time. The execution characteristics of a machine furthermore include the latencies of the communication link (s) 114 connecting this machine to other execution machines 106, 108. The latency corresponds to the delay between the sending of a message to one end of the communication link and its reception at the other end. The running characteristics of a machine further include the duration of switching between two tasks running on the machine.
Dans l'exemple décrit, les caractéristiques d'exécution de la seconde machine d'exécution 108 sont mesurées par le logiciel de mesure 124 qui les transmet ensuite à l'intergiciel principal 116. Le logiciel de mesure 124 évalue ainsi les durées de traitement des instructions élémentaires du composant CMinuteur par la machine d'exécution 108, la durée de commutation entre deux tâches en cours d'exécution de la machine d'exécution 108, et la latence du lien de communication 114 au travers de l'interface 108D. Ces durées et la latence sont par exemple mesurées par la répétition de tests. La valeur finale retenue est de préférence la plus mauvaise valeur. Par exemple, pour mesurer la durée de traitement d'une instruction élémentaire, le logiciel de mesure 124 fournit plusieurs fois cette instruction élémentaire à l'unité de traitement correspondante et mesure à chaque fois le temps de traitement. La durée de traitement retenue est alors la plus élevée des mesures. Dans l'exemple décrit où les composants sont destinés à être exécutés par des machines virtuelles Java, l'unité de traitement à laquelle le logiciel de mesure 124 fournit les instructions élémentaires est l'unité de traitement virtuelle de la machine virtuelle Java. En outre, dans l'exemple décrit, pour évaluer des caractéristiques d'exécution pour la première machine d'exécution 106, l'intergiciel principal 116 utilise celles reçues pour la seconde machine d'exécution 108 et les transpose à la première machine d'exécution 106. Par exemple, comme le lien de communication 114 relie les deux machines d'exécution 106, 108, la même valeur de latence peut être utilisée. En outre, si les unités de traitement 106A, 108A sont similaires, les durées de traitement des instructions élémentaires et la durée de commutation entre tâches de la seconde machine d'exécution 108 peuvent être utilisées pour la première machine d'exécution 106. Si les unités de traitement 106A, 108A ne sont pas similaires, l'intergiciel principal 116 peut par exemple utiliser des règles prédéterminées de transposition. Au cours d'une étape 422, l'intergiciel principal 116 obtient la durée d'exécution de chaque fonction de chaque composant CMinuteur, CCalcul. Dans l'exemple décrit, l'intergiciel principal 116 évalue la durée d'exécution au pire cas de chaque fonction à partir des caractéristiques d'exécution de la machine d'exécution 106,108 sur laquelle le composant est destiné à être exécuté. L'intergiciel principal 116 utilise en particulier les durées de traitement des instructions élémentaires et, éventuellement, la ou les latences obtenues. Pour évaluer la durée d'exécution d'une fonction, l'intergiciel principal 116 peut par exemple analyser le code machine constituant le composant pour générer, pour chaque fonction du composant, un graphe de flot de contrôle (de l'anglais « Control Flow Graph » ou CFG). Dans un tel graphe, chaque sommet correspond à un bloc d'instructions qui se suivent sans saut ni cible de saut. Ainsi, la durée d'exécution de chaque sommet correspond à la somme des durées de traitement des instructions élémentaires du sommet. En outre, la durée d'exécution d'un chemin du graphe (qui correspond à une exécution particulière de la fonction) est égale à la somme des durées d'exécution des sommets par lesquels le chemin passe. L'intergiciel principal 116 évalue ainsi la durée d'exécution de la fonction en déterminant le chemin du graphe ayant la durée d'exécution la plus longue. Si la fonction comporte un appel à une opération d'un autre composant, l'intergiciel principal 116 peut par exemple enregistrer une expression représentant le calcul de la durée d'exécution. Dans cette expression, la durée d'exécution de l'appel est laissée comme variable non connue. Lorsque les durées d'exécution des fonctions de cet autre composant sont connues, l'intergiciel principal 116 évalue alors l'expression en y intégrant la durée d'exécution de l'opération appelée. En outre, lorsque les deux composants sont destinés à être installés sur deux machines d'exécution différentes, l'intergiciel principal 116 intègre la latence du lien de communication reliant les deux machines d'exécution. Par exemple, la durée de l'opération DéclencherCalcul sera évaluée de la manière suivante : Durée d'exécution du code machine de l'opération DéclencherCalcul par la machine d'exécution 108 + latence de l'interface 108E (pour l'appel à l'opération Calculer) + durée d'exécution du code machine de l'opération Calculer par la machine d'exécution 106 + latence de l'interface 106E (pour la réponse de l'opération Calculer) Au cours d'une étape 424, l'intergiciel principal 116 obtient la durée d'exécution de chaque programme de l'application. Dans l'exemple décrit, l'intergiciel principal 116 évalue la durée d'exécution de au pire cas de chaque programme PMinuteur à partir de l'analyse du code machine du programme, des durées d'exécution des fonctions implémentant les opérations appelées et de la ou des latences obtenues lorsque l'appel passe par un lien de communication. Par exemple dans l'exemple décrit, le programme PMinuteur appelle tout d'abord l'opération DéclencherCalcul, puis appelle l'opération RécupérerRésultat, puis affecte le résultat récupéré dans une variable « Résultat », puis affiche cette variable à l'écran. Ainsi, la durée d'exécution du programme PMinuteur sera évaluée de la manière suivante : Durée de l'opération DéclencherCalcul + durée de l'opération RécupérerRésultat + durée du code machine implémentant l'affectation du résultat à la variable « Résultat » et affichant cette variable à l'écran. L'évaluation de la durée du code machine d'un programme est par exemple réalisée de la même manière que pour les fonctions des composants, c'est-à-dire en utilisant un graphe de flot et les durée de traitement des instructions élémentaires. Au cours d'une étape 426, l'intergiciel principal 116 compare la durée d'exécution de chaque programme PMinuteur avec la durée maximale d'exécution qui lui est associée dans la description D6. Si la durée d'exécution d'au moins un programme est supérieure à sa durée maximale d'exécution, le temps de réponse de l'application est considéré comme non validé. Si l'application comporte plusieurs programmes, l'intergiciel principal 116 réalise, au cours d'une étape 428, une analyse d'ordonnançabilité pour valider le temps de réponse de l'enchaînement de tous les programmes.In the example described, the execution characteristics of the second execution machine 108 are measured by the measurement software 124 which then transmits them to the main middleware 116. The measurement software 124 thus evaluates the processing times of the basic instructions of the CMinutor component by the execution machine 108, the switching time between two running tasks of the execution machine 108, and the latency of the communication link 114 through the interface 108D. These durations and the latency are for example measured by the repetition of tests. The final value chosen is preferably the worst value. For example, to measure the processing time of an elementary instruction, the measurement software 124 provides this instruction several times to the corresponding processing unit and measures each time the processing time. The duration of treatment chosen is then the highest of the measurements. In the example described where the components are intended to be executed by Java virtual machines, the processing unit to which the measurement software 124 provides the basic instructions is the virtual processing unit of the Java virtual machine. Further, in the example described, to evaluate execution characteristics for the first executing machine 106, the main middleware 116 uses those received for the second execution machine 108 and transposes them to the first machine. Execution 106. For example, since the communication link 114 connects the two execution machines 106, 108, the same latency value can be used. Further, if the processing units 106A, 108A are similar, the processing times of the elementary instructions and the switching time between tasks of the second execution machine 108 can be used for the first execution machine 106. processing units 106A, 108A are not similar, the main middleware 116 may for example use predetermined rules of transposition. During a step 422, the main middleware 116 obtains the execution time of each function of each CM component, CCalculus. In the example described, the main middleware 116 evaluates the worst case execution time of each function from the execution characteristics of the execution machine 106, 108 on which the component is to be executed. The main middleware 116 uses in particular the processing times of the elementary instructions and possibly the latency (s) obtained. To evaluate the duration of execution of a function, the main middleware 116 may for example analyze the machine code constituting the component to generate, for each function of the component, a control flow graph ("Control Flow"). Graph "or CFG). In such a graph, each vertex corresponds to a block of instructions that follow each other without jump or jump target. Thus, the execution time of each vertex corresponds to the sum of the processing times of the elementary instructions of the vertex. In addition, the execution time of a path of the graph (which corresponds to a particular execution of the function) is equal to the sum of the execution times of the vertices through which the path passes. The main middleware 116 thus evaluates the duration of execution of the function by determining the path of the graph having the longest execution time. If the function includes a call to an operation of another component, the main middleware 116 may for example record an expression representing the calculation of the execution time. In this expression, the execution time of the call is left as an unknown variable. When the execution times of the functions of this other component are known, the main middleware 116 then evaluates the expression by incorporating the duration of execution of the called operation. In addition, when the two components are intended to be installed on two different execution machines, the main middleware 116 integrates the latency of the communication link connecting the two execution machines. For example, the duration of the TriggerCalculation operation will be evaluated in the following way: Run time of the machine code of the TriggerCalculate operation by the execution machine 108 + latency of the 108E interface (for the call to the operation Calculate) + execution time of the machine code of the operation Calculate by the execution machine 106 + latency of the interface 106E (for the response of the Calculate operation) During a step 424, the The main middleware 116 gets the execution time of each program of the application. In the example described, the main middleware 116 evaluates the execution time of the worst case of each program PMinister from the analysis of the machine code of the program, the execution times of the functions implementing the called operations and the latency (s) obtained when the call goes through a communication link. For example, in the example described, the PMinister program first calls the TriggerCalculate operation, then calls the RetrieveResult operation, then assigns the retrieved result to a "Result" variable, and then displays that variable on the screen. Thus, the execution time of the PMinutor program will be evaluated as follows: Duration of the TriggerCalculate operation + duration of the RetrieveResult + duration of the machine code implementing the assignment of the result to the "Result" variable and displaying this variable on the screen. The evaluation of the duration of the machine code of a program is for example performed in the same way as for the functions of the components, that is to say using a flow graph and the processing time of the elementary instructions. During a step 426, the main middleware 116 compares the execution time of each program PMinutor with the maximum execution time associated with it in the description D6. If the execution time of at least one program is greater than its maximum execution time, the response time of the application is considered as not validated. If the application comprises several programs, the main middleware 116 performs, during a step 428, a schedulability analysis to validate the response time of the sequence of all the programs.
Pour ce faire, l'intergiciel principal 116 sélectionne les programmes de priorités les plus élevées, tels que, lorsque ces programmes sont exécutées à la chaîne, la durée totale d'exécution reste inférieure à chacune de leurs durées d'exécution maximale prédéterminée. De préférence, la durée totale d'exécution prend en compte les durées de commutation entre tâches obtenues par l'intergiciel principal 116, en insérant ces durées entre celles d'exécution des programmes. Si au moins un programme n'est pas sélectionné, le temps de réponse de l'application est considéré comme non validé. Par exemple, en considérant une application comportant trois programmes A, B, C de priorités décroissantes, associés chacun à une durée maximal d'exécution de 100 ms et en supposant que leurs durées d'exécution ont été évaluées à respectivement 30 ms, 60ms et 20ms et que les durées de commutation sont de 2ms, l'intergiciel principal 116 sélectionnerait les deux premiers programmes A, B. En effet, l'exécution de ces deux programmes à la chaîne est évaluée à 30ms + 2ms + 60ms soit 92ms, ce qui est inférieur à la durée maximale d'exécution de chacun d'eux. En revanche, en ajoutant le troisième programme, la durée totale d'exécution serait de 30ms + 2ms + 60ms + 2ms + 20ms soit 114ms. Ainsi, la durée maximale d'exécution pour les programmes ne pourrait plus être respectée. Dans l'exemple décrit où l'application ne comporte qu'un seul programme PMinuteur, le procédé passe directement à l'étape 430.To do this, the main middleware 116 selects the highest priority programs, such that, when these programs are executed in a chain, the total execution time remains less than each of their predetermined maximum execution times. Preferably, the total execution time takes into account the switching times between tasks obtained by the main middleware 116, by inserting these durations between those of execution of the programs. If at least one program is not selected, the response time of the application is considered as not validated. For example, consider an application with three programs A, B, C of decreasing priorities, each associated with a maximum execution time of 100 ms and assuming that their execution times were evaluated at 30 ms, 60 ms and 60 ms respectively. 20ms and that the switching times are 2ms, the main middleware 116 would select the first two programs A, B. Indeed, the execution of these two programs in the chain is evaluated at 30ms + 2ms + 60ms or 92ms, this which is less than the maximum execution time of each of them. On the other hand, adding the third program, the total running time would be 30ms + 2ms + 60ms + 2ms + 20ms or 114ms. Thus, the maximum execution time for programs could no longer be respected. In the example described where the application has only one program PMinutor, the method goes directly to step 430.
Au cours d'une étape 430, l'intergiciel principal 116 génère un résultat de validation. Si le temps de réponse de l'application n'est pas validé suite à l'étape 426 ou 428, le résultat de validation l'indique. Le résultat de validation peut en outre indiquer l'étape 426 et/ou 428 ayant conduit à ne pas valider le temps de réponse de l'application, ainsi que chaque programme dont la durée d'exécution a été trouvée supérieure à la durée maximale d'exécution au cours de l'étape 426, et chaque programme qui n'a pas été sélectionné au cours de l'étape 428. Dans le cas contraire, le résultat de validation indique que le temps de réponse de l'application est validé.During a step 430, the main middleware 116 generates a validation result. If the response time of the application is not validated following step 426 or 428, the validation result indicates this. The validation result may furthermore indicate the step 426 and / or 428 that led to not validating the response time of the application, as well as each program whose execution time was found to be greater than the maximum duration of the application. execution in step 426, and each program that was not selected in step 428. Otherwise, the validation result indicates that the response time of the application is validated.
Si le résultat de validation indique que le temps de réponse n'est pas validé, au cours d'une étape 432, l'intergiciel principal 116 réalise l'action prévue dans ce cas dans la description D5 des politiques de déploiement. Par exemple, l'intergiciel principal 116 interrompt le déploiement de l'application et/ou affiche un message d'erreur et/ou écrit dans un fichier de compte- rendu d'une entrée reprenant le résultat de validation. Si le déploiement n'est pas interrompu, le procédé continue à l'étape 434. Si le résultat de validation indique que le temps de réponse est validé, le procédé continue à l'étape 434. Au cours d'une étape 434, l'intergiciel principal 116 consulte la description D5 pour déterminer le prochain le composant à installer, appelé composant en cours. Dans l'exemple décrit, le composant CMinuteur doit être installé en premier, et le composant CCalcul en second. Au cours d'une étape 436, l'intergiciel principal 116 vérifie que la machine d'exécution sur laquelle le composant en cours doit être déployé selon la description D4, appelée machine en cours, est autorisée dans le mode en cours. Au cours d'une étape 438, l'intergiciel principal 116 obtient la quantité disponible de chaque ressource quantifiable de la machine en cours. Par exemple, si le composant en cours est le premier à être déployé sur la machine en cours 106, 108, l'intergiciel auxiliaire 120, 122 installé sur la machine en cours 106, 108 mesure la quantité disponible de chaque ressource quantifiable et transmet cette mesure à l'intergiciel principal 116. Si le composant en cours n'est pas le premier à être déployé sur la machine en cours 106, 108, l'intergiciel principal 116 prend la quantité de ressource quantifiable disponible qu'il a calculée, durant l'étape 442 décrite plus loin, suite aux déploiements des précédents composants. Dans l'exemple décrit, ce dernier cas ne se produit pas, car il n'y a qu'un seul composant par machine d'exécution. Ainsi, lors du déploiement du composant CMinuteur, l'intergiciel principal 116 obtient la quantité disponible de mémoire vive de la machine d'exécution 108 mesurée par le second intergiciel auxiliaire 122. Lors du déploiement du composant CCalcul, il obtient la quantité disponible de mémoire vive de machine d'exécution 106 mesurée par le premier intergiciel auxiliaire 120. Au cours d'une étape 440, l'intergiciel principal 116 vérifie que la machine en cours possède les ressources qui sont la fois autorisées par le mode en cours et requises par le composant en cours selon la description D4 des composants de l'application. Dans l'exemple décrit, lors du déploiement du composant CMinuteur, l'intergiciel principal 116 vérifie que la machine d'exécution 108 possède 1 MB de mémoire vive, une interface InfiniBand et une JVM temps réel. Lors du déploiement du composant CCalcul, l'intergiciel principal 116 vérifie que la machine d'exécution 106 possède 10 MB de mémoire vive, une interface InfiniBand et une JVM temps réel. Si une ressource requise est manquante, l'intergiciel principal 116 interrompt par exemple le déploiement. Si la machine en cours ne possède pas les ressources requises, l'intergiciel principal 116 réalise l'action prévue dans ce cas dans la description D5. Cette action comporte par exemple : l'interruption du déploiement de l'application et/ou l'affichage d'un message d'erreur et/ou l'écriture dans un fichier de compte-rendu d'une entrée d'erreur. Au cours d'une étape 442, l'intergiciel principal 116 mets à jour les quantités disponibles des ressources quantifiables en enlevant la quantité nécessaire au composant en cours, telle qu'indiquée dans la description d'implémentation. Dans l'exemple décrit, lors du déploiement du composant CMinuteur, l'intergiciel principal 116 enlève 1 MB à la quantité de mémoire vive qu'il a obtenu du second intergiciel auxiliaire 122. Lors du déploiement du composant CCalcul, l'intergiciel principal 116 enlève 10 MB à la quantité de mémoire vive qu'il a obtenu du premier intergiciel auxiliaire 122. Au cours d'une étape 444, l'intergiciel principal 116 transmet le composant en cours à la machine d'exécution 106, 108 sur laquelle il doit être installé, cette dernière enregistrant le composant en cours dans sa mémoire de masse 106C, 108C. De préférence, l'ensemble des descriptions ainsi que les binaires du ou des composants destinés à être exécutés sur une même machine d'exécution sont assemblés pour former une unité de déploiement. Plusieurs formats sont supportés : zip, tar, tar.gz, jar, répertoire non compressé, etc. Ces unités de déploiement peuvent être placées dans un dépôt informatique pour être réutilisées plus tard. Au cours d'une étape 446, l'intergiciel principal 116 vérifie si tous les services requis par le composant en cours sont disponibles. Si ce n'est pas le cas, au cours d'une étape 448, l'intergiciel principal 116 note le composant en cours comme invalide et retourne à l'étape 434 pour installer le composant suivant. Si c'est le cas, au cours d'une étape 450, l'intergiciel principal 116 note le composant en cours comme valide et publie ses services. La publication des services comporte l'enregistrement des services, avec leurs opérations, dans un annuaire. L'annuaire est par exemple enregistré dans la mémoire de masse 102C, ou bien dans l'importe quel entrepôt informatique accessible par la machine de déploiement 102. L'annuaire indique ainsi les opérations disponibles pour être utilisées. En outre, l'intergiciel principal 116 retourne à l'étape de vérification 446 pour chacun des composants qui ont précédemment été notés comme invalides. En effet, la validation du composant en cours a peut être résolu les dépendances de ces précédents composants. Au cours d'une étape 452, lorsque tous les composants sont valides, l'intergiciel principal 116 transmet chaque programme de l'application à la machine d'exécution 106, 108 sur laquelle il doit être installé, cette dernière enregistrant le programme dans sa mémoire de masse 106C, 108C. On notera que chaque programme de l'application est sous forme de code machine suite à la compilation de l'étape 414. Dans l'exemple écrit, l'intergiciel principal 116 transmet le programme PMinuteur à la machine d'exécution 108. Au cours d'une étape 454, chaque composant et chaque programme de l'application est chargé en mémoire vive par l'intergiciel auxiliaire 120, 122 de la machine d'exécution 106, 108 sur laquelle il est enregistré. Les intergiciels auxiliaires 120, 122 gardent une référence vers chaque programme de l'application, pour par exemple en interrompre l'exécution, l'arrêter ou inspecter son état. Dans l'exemple décrit, pour réaliser l'étape 454, les intergiciels auxiliaires 120, 122 chargent tout d'abord respectivement les machines virtuelles Java 126, 128 dans les mémoires vives 106B, 108B. Les machines virtuelles Java 126, 128 sont alors respectivement exécutées dans des processus notés 126* et 128*. Les intergiciels auxiliaires 120, 122 chargent ensuite les composants CMinuteur, CCalcul et le programme PMinuteur dans des processus virtuels Java, notés CMinuteur*, CCalcul* et PMinuteur*. Ces processus virtuels Java sont contenus dans les processus 126*, 128* des machine virtuelles Java. Plus précisément, le premier intergiciel auxiliaire 120 charge le composant CCalcul dans le processus 126* de la première machine virtuelle Java 126, tandis que le second intergiciel auxiliaire 122 charge le composant CMinuteur et le programme PMinuteur dans le processus 128* de la seconde machine virtuelle Java 128. À la fin de l'étape 454, l'application est déployée. Le résultat obtenu est représenté sur la figure 5. Les flèches en pointillés indiquent les appels du programme en cours d'exécution PMinuteur* aux composants en cours d'exécution CMinuteur*, CCAIcuI* afin d'utiliser leurs opérations. Les références 120* et 122* indiquent les intergiciels auxiliaires 120, 122 en cours d'exécution. La référence 124* indique le logiciel de mesure 124 en cours d'exécution. Il apparaît clairement qu'un procédé de déploiement d'application tel que celui décrit précédemment permet de garantir le temps de réponse de l'application en fonction des machines d'exécution, sans nécessiter de connaître les durées d'exécution de service au préalable. On notera par ailleurs que l'invention n'est pas limitée au mode de réalisation décrit précédemment. Il apparaîtra en effet à l'homme de l'art que diverses modifications peuvent être apportées au mode de réalisation décrit ci-dessus, à la lumière de l'enseignement qui vient de lui être divulgué. Par exemple, les étapes précédentes pourrait être réalisées dans un autre ordre, du moment que ce nouvel ordre est techniquement possible. Dans les revendications qui suivent, les termes utilisés ne doivent pas être interprétés comme limitant les revendications au mode de réalisation exposé dans la présente description, mais doivent être interprétés pour y inclure tous les équivalents que les revendications visent à couvrir du fait de leur formulation et dont la prévision est à la portée de l'homme de l'art en appliquant ses connaissances générales à la mise en oeuvre de l'enseignement qui vient de lui être divulgué.5If the validation result indicates that the response time is not validated, during a step 432, the main middleware 116 performs the action provided in this case in the description D5 of the deployment policies. For example, the main middleware 116 interrupts the deployment of the application and / or displays an error message and / or writes to a report file of an entry containing the validation result. If the deployment is not interrupted, the process proceeds to step 434. If the validation result indicates that the response time is enabled, the process proceeds to step 434. In step 434, The main middleware 116 consults the description D5 to determine the next component to install, called the current component. In the example described, the CM component must be installed first, and the CCalcul component second. In a step 436, the main middleware 116 verifies that the execution machine on which the current component is to be deployed according to the description D4, called the current machine, is allowed in the current mode. During a step 438, the main middleware 116 obtains the available quantity of each quantifiable resource from the current machine. For example, if the current component is the first to be deployed on the current machine 106, 108, the auxiliary middleware 120, 122 installed on the current machine 106, 108 measures the available quantity of each quantifiable resource and transmits that to the main middleware 116. If the current component is not the first to be deployed on the current machine 106, 108, the main middleware 116 takes the amount of available quantifiable resource that it has calculated, step 442 described later, following the deployments of the previous components. In the example described, this last case does not occur because there is only one component per execution machine. Thus, when deploying the CM component, the main middleware 116 obtains the available amount of RAM from the execution machine 108 measured by the second auxiliary middleware 122. When deploying the component CCalculate, it obtains the available amount of memory operating machine key 106 measured by the first auxiliary middleware 120. During a step 440, the main middleware 116 verifies that the current machine has the resources that are both authorized by the current mode and required by the current mode. the current component according to the description D4 of the components of the application. In the example described, during the deployment of the CM component, the main middleware 116 verifies that the execution machine 108 has 1 MB of RAM, an InfiniBand interface and a real-time JVM. When deploying the CCalcul component, the main middleware 116 verifies that the execution machine 106 has 10 MB of RAM, an InfiniBand interface and a real-time JVM. If a required resource is missing, the main middleware 116 interrupts for example the deployment. If the current machine does not have the required resources, the main middleware 116 performs the action provided in this case in the description D5. This action includes for example: the interruption of the deployment of the application and / or the display of an error message and / or the writing in a report file of an error entry. During a step 442, the main middleware 116 updates the available quantities of the quantifiable resources by removing the quantity required for the current component, as indicated in the implementation description. In the example described, during the deployment of the CM component, the main middleware 116 removes 1 MB from the amount of RAM that it obtained from the second auxiliary middleware 122. When deploying the component CCalculus, the main middleware 116 removes 10 MB from the amount of RAM it has obtained from the first auxiliary middleware 122. During a step 444, the main middleware 116 transmits the current component to the execution machine 106, 108 on which it must be installed, the latter registering the current component in its mass memory 106C, 108C. Preferably, all the descriptions as well as the bits of the component or components intended to be executed on the same execution machine are assembled to form a deployment unit. Several formats are supported: zip, tar, tar.gz, jar, uncompressed directory, etc. These deployment units can be placed in a repository for later use. During a step 446, the main middleware 116 checks whether all the services required by the current component are available. If it is not, in a step 448, the main middleware 116 notifies the current component as invalid and returns to step 434 to install the next component. If so, during a step 450, the main middleware 116 notes the current component as valid and publishes its services. The publication of services includes the registration of services, with their operations, in a directory. The directory is for example stored in the mass memory 102C, or in any computer warehouse accessible by the deployment machine 102. The directory thus indicates the operations available to be used. In addition, the main middleware 116 returns to the verification step 446 for each of the components that have previously been rated as invalid. Indeed, the validation of the current component has can be solved the dependencies of these previous components. During a step 452, when all the components are valid, the main middleware 116 transmits each program of the application to the execution machine 106, 108 on which it must be installed, the latter recording the program in its mass memory 106C, 108C. Note that each program of the application is in the form of machine code following the compilation of step 414. In the written example, the main middleware 116 transmits the program PMinutor to the execution machine 108. in a step 454, each component and each program of the application is loaded into RAM by the auxiliary middleware 120, 122 of the execution machine 106, 108 on which it is recorded. The auxiliary middleware 120, 122 keep a reference to each program of the application, for example to interrupt the execution, stop or inspect its state. In the example described, to perform step 454, the auxiliary middleware 120, 122 first respectively load the Java virtual machines 126, 128 in the RAMs 106B, 108B. The Java virtual machines 126, 128 are then respectively executed in processes denoted 126 * and 128 *. Auxiliary middleware 120, 122 then loads the CMinister, CCalculate, and PMinister components into Java virtual processes, denoted by CMinister *, CCalcul *, and PMinister *. These Java virtual processes are contained in the processes 126 *, 128 * of the Java virtual machines. Specifically, the first auxiliary middleware 120 loads the CCalcul component in the process 126 * of the first JVM 126, while the second auxiliary middleware 122 loads the CM component and the PM program in the 128 * process of the second virtual machine. Java 128. At the end of step 454, the application is deployed. The result obtained is shown in FIG. 5. The dashed arrows indicate the calls of the running program PMinister * to the components running CMinister *, CCAIcuI * in order to use their operations. The references 120 * and 122 * indicate the auxiliary middleware 120, 122 running. Reference 124 * indicates the measurement software 124 being executed. It is clear that an application deployment method such as that described above makes it possible to guarantee the response time of the application as a function of the execution machines, without having to know the service execution times beforehand. Note also that the invention is not limited to the embodiment described above. It will be apparent to those skilled in the art that various modifications can be made to the embodiment described above, in the light of the teaching that has just been disclosed. For example, the previous steps could be performed in another order, as long as this new order is technically possible. In the following claims, the terms used are not to be construed as limiting the claims to the embodiment set forth in this description, but must be interpreted to include all the equivalents that the claims are intended to cover by reason of their formulation and whose prediction is within the reach of those skilled in the art by applying his general knowledge to the implementation of the teaching which has just been disclosed to him.
Claims (10)
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| FR1360780A FR3012896B1 (en) | 2013-11-04 | 2013-11-04 | METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| FR1360780A FR3012896B1 (en) | 2013-11-04 | 2013-11-04 | METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| FR3012896A1 true FR3012896A1 (en) | 2015-05-08 |
| FR3012896B1 FR3012896B1 (en) | 2017-01-27 |
Family
ID=50424366
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| FR1360780A Active FR3012896B1 (en) | 2013-11-04 | 2013-11-04 | METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES |
Country Status (1)
| Country | Link |
|---|---|
| FR (1) | FR3012896B1 (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| FR3070213A1 (en) * | 2017-08-21 | 2019-02-22 | Amadeus S.A.S. | MULTI-LAYER CONCEPT CALCULATOR OF RESPONSE TIME |
| US10289525B2 (en) | 2017-08-21 | 2019-05-14 | Amadeus S.A.S. | Multi-layer design response time calculator |
Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1892656A1 (en) * | 2006-07-31 | 2008-02-27 | Sap Ag | Cost-based deployment of components in smart item environments |
-
2013
- 2013-11-04 FR FR1360780A patent/FR3012896B1/en active Active
Patent Citations (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1892656A1 (en) * | 2006-07-31 | 2008-02-27 | Sap Ag | Cost-based deployment of components in smart item environments |
Non-Patent Citations (2)
| Title |
|---|
| "Handbook of Real-Time and Embedded Systems", vol. 20073969, 23 July 2007, CHAPMAN AND HALL/CRC, ISBN: 978-1-42-001174-6, ISSN: 2154-4573, article ANDREAS ERMEDAHL ET AL: "Execution Time Analysis for Embedded Real-Time Systems", pages: 35 - 1, XP055118988, DOI: 10.1201/9781420011746.ch35 * |
| BURNS A: "PREEMPTIVE PRIORITY-BASED SCHEDULING: AN APPROPRIATE ENGINEERING APPROACH", ADVANCES IN REAL-TIME SYSTEMS, XX, XX, 1 January 1995 (1995-01-01), pages 225 - 248, XP009052201 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| FR3070213A1 (en) * | 2017-08-21 | 2019-02-22 | Amadeus S.A.S. | MULTI-LAYER CONCEPT CALCULATOR OF RESPONSE TIME |
| US10289525B2 (en) | 2017-08-21 | 2019-05-14 | Amadeus S.A.S. | Multi-layer design response time calculator |
Also Published As
| Publication number | Publication date |
|---|---|
| FR3012896B1 (en) | 2017-01-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11422778B2 (en) | Development environment for real-time dataflow programming language | |
| US9003416B2 (en) | Predicting resource requirements for a computer application | |
| US9389986B2 (en) | Identifying impacted tests from statically collected data | |
| Flores et al. | Evidence-aware mobile computational offloading | |
| US10284660B1 (en) | Data flow tokens to trace execution of services in a service provider network | |
| US9733910B2 (en) | Replacing annotated program code in a networked computing environment | |
| US9524225B2 (en) | Dynamically providing application analytic information | |
| Taraghi et al. | CAdViSE: cloud-based adaptive video streaming evaluation framework for the automated testing of media players | |
| FR2964225A1 (en) | METHOD AND DEVICE FOR DEPLOYING AND ASSISTING THE DEPLOYMENT OF COMPONENTS FORMING A REAL TIME SYSTEM ONBOARD | |
| US20210111974A1 (en) | Methods and apparatus to monitor telemetry data associated with computing devices | |
| Rösler et al. | Towards a mobile application performance benchmark | |
| US20220269504A1 (en) | Client-side enrichment and transformation via dynamic logic for analytics | |
| US20150193226A1 (en) | Instrumentation agent for manipulating component responses | |
| US10956133B2 (en) | Static optimization of production code for dynamic profiling | |
| FR3012896A1 (en) | METHOD FOR VALIDATION OF AN APPLICATION RESPONSE TIME, METHOD FOR DEPLOYING AN APPLICATION COMPRISING SUCH A VALIDATION METHOD, COMPUTER PROGRAM AND CORRESPONDING DEVICES | |
| FR3056786B1 (en) | METHOD FOR MANAGING CALCULATING TASKS ON A FUNCTIONALLY ASYMMETRIC MULTI-CORE PROCESSOR | |
| EP3881515B1 (en) | System for the formal supervision of communications | |
| Fernando | Implementing Observability for Enterprise Software Systems | |
| US10353801B2 (en) | Abnormal timing breakpoints | |
| Hilgendorf | Efficient industrial big data pipeline for lossless transfer of vehicular data | |
| EP2770438B1 (en) | Monitoring of performance tests executed in a computer system | |
| Zhang | Efficient Resource Management of Cloud Native Systems | |
| FR3118815A1 (en) | Estimating the progress of a software task execution | |
| Sultan et al. | Dynamic cloud resources allocation | |
| Lovstad et al. | Run-time software configuration for mobile devices using an evolutionary quantifiable deployment model |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PLFP | Fee payment |
Year of fee payment: 3 |
|
| PLFP | Fee payment |
Year of fee payment: 4 |
|
| PLFP | Fee payment |
Year of fee payment: 5 |
|
| PLFP | Fee payment |
Year of fee payment: 7 |
|
| PLFP | Fee payment |
Year of fee payment: 8 |
|
| PLFP | Fee payment |
Year of fee payment: 9 |
|
| PLFP | Fee payment |
Year of fee payment: 10 |
|
| PLFP | Fee payment |
Year of fee payment: 11 |