FR3124873A1 - Program processing planning system and method - Google Patents

Abstract

A program processing control method implemented in a system comprising computing devices connected by a network, represented by a graph comprising nodes, each having several hardware resources, is proposed. The nodes are logically indexed in a multidimensional structure according to the resources of a multidimensional space. In response to a request for processing microservices from a program, the method comprises a calculation (507), for each microservice, of an elementary quality of service indicator associated with the microservice, from differences relating to each quality parameter from among a set of service quality parameters representing hardware resource capacity parameters of the source device, and an operation (511) relating to the processing of part of the microservices of the program in a device of the network according to the indicators of quality of service. The process makes it possible to optimize the energy consumption of the devices. (Figure 5)

Description

Program processing planning system and method

The invention relates generally to the processing of computer programs and in particular to a system and a method for dynamic program planning in a network comprising a set of computing devices.

Managing the processing of programs and data in computer networks is a major challenge. A computer program can consist of a set of microservices to be executed using the resources of network computing devices.

In particular, in a decentralized network environment, load balancing, microservices discovery and energy saving are difficult to analyze in the absence of a central entity containing all the information necessary to apply the heuristic of program treatment planning.

There are structures capable of modeling data sets in computer networks as spaces with as many dimensions as the data sets have characteristics. Such spaces make it possible to insert, analyze and retrieve data at efficient operating costs. One-dimensional examples of existing data modeling structures are binary-based trees, performing O(Log(N)) data management operations. However, these operations become more complicated with the incrementing of the dimensions of the search in the trees. To overcome such a problem, solutions based on metrics defined by distance functions and/or on multi-dimensional spaces have been proposed. These solutions are able to manage multidimensional datasets from the point of view of:

- distances between its elements (for example BKT, BT or LAESA), as described in Edgar Chávez, Gonzalo Navarro, Ricardo Baeza-Yates, and José Luis Marroquín. 2001. Searching in Metric Spaces. ACM Compute. Surv. 33, 3 (Sept. 2001), 273–321. https://doi.org/10.1145/502807.502808; Or

- the abstraction of the universe in which they exist (for example KD-tree, R* tree or Z-ordering), as described in Volker Gaede and Oliver Günther. 1998. Multidimensional Access Methods. ACM Compute. Surv. 30, 2 (June 1998), 170–231.

Such data management approaches not only make it possible to process program processing requests based on a single feature/dimension to obtain a single item, but also to retrieve all data that meets different criteria in a certain region, either from point of view of another element, or from the point of view of the point of view of the entire universe.

However, existing solutions do not allow a dynamic placement of microservices processing in the devices of a distributed environment, taking into account the energy consumption of the system.

There is thus a need for a system and a method for scheduling optimized program processing in a computer network consisting of a set of computing devices.

To improve the situation, a program processing control method implemented in a computer system comprising a plurality of computer devices connected by means of at least one computer network is proposed. Each device has a plurality of hardware resources, each program being configured as a set of microservices, each device being able to process at least one program. The plurality of computing devices is represented in the form of a graph comprising nodes, two nodes being connected by a link, a node representing a computing device, a connecting link of nodes representing the connection between the two computing devices represented by the nodes . The nodes are logically indexed in a multidimensional structure according to the resources of a multidimensional space. The method includes the steps of:

- Receive a request to process at least part of the microservices of a program from a source device of the set of devices, issued in the multidimensional space;

- For each quality of service parameter among a set of quality of service parameters representing hardware resource capacity parameters of the source device, determining the difference between the target value and the value obtained from the quality of service parameter for the processing of the microservice by the requesting device, which provides a difference relative to the quality of service parameter; the quality of service parameters include at least the frequency of the central processor of the source device, the capacity of the RAM memory of the source device, the rate of source device's network interface transfer, and the device's hard disk transfer rate;

- Calculate for each microservice, an elementary quality of service indicator associated with the microservice, from the differences relating to each quality of service parameter; And

- Calculating a program service quality indicator from the elementary service quality indicators determined for each microservice of the program;

- Perform a processing operation relating to the processing of at least part of the microservices of the program in a device of the network according to the quality of service indicators.

In one embodiment, the processing operation is a termination of the microservices portion of the program in the source device.

In one embodiment, the method further comprises a step of selecting at least one target candidate device from among the plurality of devices according to the program quality of service indicator and energy consumption information determined for each device at time T, using the graph. The processing operation then consists of moving or duplicating the part of the microservices in the at least one candidate device selected for execution of the program by the at least one selected device.

In embodiments, in the selection step, the source device is able to search for a neighboring node logically close to the node representing the source device in the graph and to implement negotiation exchanges with the neighboring node.

The method can include a step consisting in managing the devices of the network using the graph in which a node of the graph is capable of being added or removed dynamically from the multidimensional space.

An elementary quality of service indicator associated with a microservice can be calculated by performing the weighted sum of the differences relating to each quality of service parameter using elementary weights associated with each quality of service parameter.

The sum of the elementary weights can be equal to 1.

In one embodiment, a program service quality indicator can be calculated by performing the weighted sum of the elementary service qualities determined for the microservices of the program using global weights associated with each microservice.

The sum of the global weights can be equal to 1.

In one embodiment, the elementary quality of service indicator calculated for a microservice can be the minimum value between the differences relating to each quality of service parameter, each weighted by an impact indicator.

In one embodiment, the program quality of service indicator may be the smallest value among the elementary quality of service indicators calculated for the microservices of the program.

The method may include a step of determining the power consumption information of each device of the set of devices, the determining step comprising:

- determine the energy consumption of the central processor CPU of the device;

- determine the energy consumption of the RAM of the device;

- determine the power consumption of the device's network interface card and the device's hard disk;

Device power consumption information can be calculated from device CPU central processor power consumption, RAM power consumption, network interface cards power consumption and consumption of the device's hard disk.

In one embodiment, the energy consumption E of the central processor CPU of the device can be determined according to the equation:

denotes the capacitance of the central processor, denotes the voltage of the central processor, denotes the frequency of the central processor and the amount of energy consumed at a given time by the (CPU) of the device.

The energy consumption E generated by a given microservice on the network interface card or the hard disk of the device can be determined, according to the equation:

Wu refers to the Watts consumed by the device when the device's network interface card or the device's hard drive is in an active state. Wi refers to when the device's network interface card or the device's hard drive is in an idle state. Li denotes the transfer rate of a microservice. L _MAX denotes the maximum transfer rate of the microservice and L denotes the current load of the device at time T.

In one embodiment, the method itself is executed as a microservice.

There is further provided a program processing control system, implemented in a computer system, comprising a plurality of computing devices connected by means of at least one computer network, each device having a plurality of hardware resources, each program being configured in the form of a set of microservices, each device being capable of processing at least one program, the plurality of computing devices being represented in the form of a graph comprising nodes, two nodes being connected by a link, a node representing a computing device, a link connecting nodes representing the connection between the two computing devices represented by the nodes. The nodes are logically indexed in a multidimensional structure according to the resources of a multidimensional space. The system is configured for:
- Receiving a request to process at least part of the microservices of a program from a source device (D) of the set of devices, transmitted in the multidimensional space;
- For each quality of service parameter among a set of quality of service parameters representing hardware resource capacity parameters of the source device, determining the difference between the target value and the value obtained from the quality of service parameter for the processing of the microservice by the requesting device, which provides a difference relating to the quality of service parameter, the quality of service parameters including at least the frequency of the central processor of the source device, the capacity of the RAM memory of the source device, the rate of source device's network interface transfer, and the device's hard disk transfer rate;
- Calculate for each microservice, an elementary quality of service indicator associated with the microservice, from the differences relating to each quality of service parameter; And
- Calculating a program service quality indicator from the elementary service quality indicators determined for each microservice of the program;
- Perform a processing operation relating to the processing of at least a part of the microservices of the program in a device of the network according to the quality of service indicators.

Embodiments of the invention enable placement of microservices processing on network computing devices in an optimized manner based on system power consumption.

They allow in particular a dynamic reconfiguration by redeployment of microservices and to dynamically modify the reconfigurations of the applications on the various hardware devices of the network.

Advantageously, they make it possible to determine the deployments of microservices which allow the best hardware exploitation and the lowest power consumption of the hardware components of the hardware computing devices of the network.

Brief Description of Figures

Other characteristics, details and advantages of the invention will become apparent on reading the description given with reference to the appended drawings given by way of example and which represent, respectively:

There depicts an exemplary computer system in which the treatment planning system and method according to embodiments of the invention may be implemented;

There schematically represents the hardware components (or hardware resources) of a computing device, according to certain embodiments of the invention;

There is an example of a network overlay architecture that can be used by the computer network;

There is a flowchart representing the microservice monitoring method, according to some embodiments of the invention; And

There is a flowchart depicting the treatment planning method, according to certain embodiments of the invention;

Detailed description of the request

There depicts an exemplary computer system 100 in which the program processing system and method according to certain embodiments may be implemented.

The computer system comprises at least one communication network 2, which can be centralized or non-centralized, and a set of computer devices 10 connected to each other via the network 2.

A communication network can for example be a WIFI or satellite type network (for example, Ethernet, wireless, 4G, Bluetooth, etc.).

The devices 10 (also called “device” or “machine”) can include any type of computer device, in particular mobile devices, such as personal computers, smart mobile telephones (called “Smartphone” in English language), tablets computers, etc.

Computing devices 10 can support different types of communication networks.

The computing devices 10 can comprise heterogeneous devices, that is to say of different types.

A computer device 10 is capable of executing a program (also called an 'application'). Each program being configured in the form of a set of program software components also referred to below as “microservices”. Each computing device 10 is capable of processing (that is to say executing) a program and the microservices included in a program.

The computing devices 10 of the network 2 are represented in the form of a graph comprising nodes, two nodes being linked by a connection, a node representing a computing device, a link connecting two nodes representing the connection between the two computing devices represented by the knots.

Each program is thus deployed on a graph of connected devices, whose nodes can be:

- individual devices with heterogeneous characteristics (e.g. battery dependent devices, mobile devices, and devices with different network interfaces) or

- abstract entities such as clusters or cloudlets.

An abstract entity designates a resource provider such as a cluster or a cloudlet. An abstract entity can be deployed and connected in the same way as individual devices, establishing the amount of resources to be provided and managed.

The computing devices 10 may or may not belong to the same hierarchy, that is to say may or may not belong to a single level of abstraction. In an embodiment where the nodes belong to the same hierarchy, the program processing planning method can be distributed, that is to say it is not executed by a single central entity which decides on the how the load is to be balanced but is distributed among the nodes corresponding to the different computing devices 10. The nodes representing the computing devices 10 can then implement a negotiation process by exchanging messages to manage the processing schedule.

The planning process can be used in different types of system, such as for example:

- In cluster systems managed by different types of technologies. In such an application, the processing planning process can replace a conventional deployment and load balancing process so as to have “master” nodes which are only discovery and restriction application managers (number of copies, required response speed, etc.).

- In systems of computing devices connected by at least one network 2 (e.g. laptops, tablets, smart TVs) in which applications can be executed on different devices of the system, such as for example Internet of Things (IoT) type systems )).

The connections between the computing devices 10 (represented by links between two nodes) make it possible to determine the transfer rate at which the microservices can send or receive data between them.

A computer device 10 designates a processing entity identifiable by a unique device identifier ID.

There is a diagram representing a computing device 10, according to embodiments of the invention.

A computer device 10 comprises a processor 22, also called a Central Processing Unit or CPU (acronym for the corresponding English expression "Central Processing Unit"), a mass memory device 26, an input/output interface (I/O or I/O) 28, and a human-machine interface (HMI) 30. The computing device 10 can also be coupled to one or more external resources 32 via a network 35 (which can be the same as the network 2 or another network), or of a network interface device 31. The network interface 31 can be connected to a communication medium 33, which can itself be in communication with other computing devices. The network interface device comprises a network interface card NIC 310 (acronym for the corresponding English expression "Network Interface Card"). The network card (NIC) allows wired and wireless communications between the device 10 and other computing devices 10 connected via the network 2 as well as communications via the network 35, for example by means of the Internet protocol (IP).

External resources 32 may include, without limitation, servers, databases, mass storage devices, peripheral devices, cloud network services, or any other suitable computing resources that may be used with device 10.

CPU 22 is configured to execute on program instructions stored in memory 34.

The memory 26 comprises a random access memory RAM 260 (Random Access Memory). The memory 26 may further include one or more memory devices such as, for example and without limitation, a read-only memory (ROM acronym for Read-Only Memory), a volatile memory, a non-volatile memory, a static random access memory (SRAM acronym for Static Random Access Memory), dynamic random access memory (DRAM acronym for Dynamic Random Access Memory), flash memory, cache memory or any other device capable of storing information.

The mass memory 24 comprises at least one hard disk HDD 240 (Hard Disk Drive). It may further include data storage devices such as an optical disc, or any other device capable of storing information.

CPU 22 may operate under the control of an operating system 261 which resides in memory 26. Operating system 261 may manage the resources of computing device 10 such that the program code of computing device 10, integrated as one or more application software, such as applications 262 which reside in memory 26, may have instructions executed by processor 22. Alternatively, processor 22 may directly execute applications 262 without system 261. One or more data structures 264 may also reside in memory 26, and may be used by processor 22, operating system 261, and/or applications 262 to store or manipulate data.

I/O interface 28 provides a machine interface that operably couples processor 22 with other devices and systems, such as network 35 or external resources 32.

Computing system 100 may include applications located external to computing devices 10 and distributable to computing devices 10 provided by a cloud system over network 35.

The Human Machine Interface HMI 30 can be coupled with the processor 22 to allow a user to interact directly with the computing device 10. The HMI interface 30 can include a video or alphanumeric display, a touch screen, a loudspeaker and any other visual and/or audio element capable of communicating data to the user. The HMI interface 30 can also include input control devices such as an alphanumeric keyboard, a pointing device, keyboards, push buttons, command buttons, microphones, etc., capable of accepting commands or user inputs and transmit them to the processor 22.

The device 10 can comprise one or more databases 25 to collect and organize the data used by the various components of the system. Database 25 may include data and/or data structures storing the data. Databases 25 can reside in mass memory 24.

Each computing device 10 has specific component capabilities in terms of CPU (22) central processor frequency, RAM (260) size, hard drive (240) speed, network 2 transfer rate (speed at which the data is sent or received by the network 2), and battery (29), depending on the type of device and its configuration.

Each device 10 is capable of executing microservices, providing them with an amount of resources that may depend on their needs and/or on the needs of competing microservices (for example in the case of proportional shared planning).

A device 10 includes a supervisory program that runs on the device to:

- monitor the status of each of its components in terms of load, capacity and energy consumption; And

- to execute a distributed treatment planning method according to the embodiments of the invention.

The distributed processing planning method allows to determine a microservices operation among:

- a movement of microservice(s) to another peer device 10;

- a start of execution of microservice(s);

- a stop in the execution of microservice(s);

- a duplication of a microservice to another peer device 10.

Such operations may depend on conditions of power consumption, negotiation criteria, load balance, number of hops, etc.

A program (or application) is also represented by a directed graph comprising a set of elementary nodes, each elementary node representing a microservice, the elementary nodes being linked by connections between the microservices.

As used here, a microservice means a functional entity (program software component) identifiable with a unique microservice identifier ID, which has an associated function. A microservice is code that represents this related function and can be duplicated by a program processing system. When a microservice is deployed on a device 10, the microservice requires an amount of resources in terms of central CPU (22), network capacity (31), RAM (260) and hard disk (240) from of the device 10 which executes it.

Microservices can be of different types such as for example GUI microservices, compute microservices and data management microservices.

These types of microservices can differ from each other in terms of:

- their default resource consumption,

- the amount of data they send or receive, and

- the associated restriction indicator which indicates whether or not the microservice can be moved and/or duplicated from one device 10 to another.

For example, a UI GUI microservice might have a restriction flag indicating that it cannot be moved because the user experience might be affected by such a move. A compute microservice can be associated with a restriction flag indicating that it can be duplicated or moved to another nearby device. A data management microservice can be associated with a restriction flag indicating that it can be moved, but such a move can have a strong impact on bandwidth consumption.

A user of a device 10 can create their own type of microservice.

Connections between two devices can be direct (without intermediate components other than a router) or indirect. Connections between microservices can be logical/functional. A physical connection supports multiple microservice connections and tracks the maximum and current possible transfer rate between two devices 10 (maximum transmission capacity of the device with the network interface).

Connections between microservices logically store a set of physical connections that they use to communicate. Thus, it is possible to determine by means of a microservice supervisor the path of the devices 10 that a microservice connection uses to operate, as well as the current and expected transfer rates.

The computer system 100 may include an operations center 12 corresponding to a centralized entity which stores all references to connections in the network 2 and to devices 10 deployed.

The computer system 100 implements a planning process to deploy and plan the microservices on the devices 10 of the network, according to the energy consumption of the devices 10, and the Quality of Service of the programs.

When deploying devices 10 in network 2, the capacity parameters of the new device 10 can be specified. For example, capacity parameters can include:

- the frequency of the CPU 22 of the device 10 in Ghz,

- the RAM capacity 260 of the device 10 in MB,

- the network capacity 31 in Mb/s of the device 10,

- the capacity of the hard disk 240 of the device in MB/s,

- the capacity of the battery 29 of the device.

In one embodiment, the computer system 100 may include a device manager 120, for example implemented in the operations center 12, configured to add a device 10 to the network or remove a device 10 from the network 2. deletion can be done statically in response to a user command or dynamically, depending on a deployment scenario. A system operator can activate a deletion command for each device 10 causing the deletion of a device 10, when the deletion command is activated.

The program processing scheduling method allows scheduling the processing (execution) of microservices on one or more network devices. Thus, once deployed, a microservice uses a quantity of resources for a determined or indefinite time.

The size of a microservice in terms of serialization (amount of data to send over the network if the microservice is moved or duplicated) can be predefined. Such a size attribute can be used to analyze the cost of operations relating to the execution of treatment planning in terms of efficiency and energy.

Computer system 100 may include a microservices manager 122 configured to perform a microservice operation which may be a shutdown, startup, migration, or replication of a microservice.

Microservices can be moved (migrated) from one device D in the network to another device in the network D' in response to the execution of the microservice processing scheduling process.

The microservices manager 122 can be implemented in the operations center (as in the example in the ) or from a specific device that knows its connected peers and is able to run decentralized algorithms.

In response to a request to move a microservice from a device D to another device D':

- the microservice first releases the resources of its current device D;

- the program processing scheduling system executes the process of moving the microservice from D to D' using the involved network connection for a period of time based on the size of the microservice;

- the microservice begins to compete for the resources of the new device D'. If a microservice is moved, the microservice may become unreachable for one of its dependencies. Search mechanisms can then be implemented for a duplicate instance or to establish special search and path optimization mechanisms to solve such a microservice access problem.

The microservice manager 122 may duplicate a required microservice in response to performing the microservice processing scheduling process, for example if the scheduling process determines that such a microservice is in high demand and producing excessive power consumption or low QoS (Quality Of Service). The planning process then determines the target device D' on which the microservice is duplicated, which can be: - the same device as the original microservice, or - another device connected or reachable by device D.

The microservices manager 122 may stop or start a microservice in response to executing the microservice processing scheduling process.

Shut down devices and/or microservices can be put on standby or permanently deleted.

The planning method makes it possible to optimize the load of the computing devices 10 of the system 100 according to the energy consumption of the hardware components of the computing devices 10.

The resource planning process makes it possible to dynamically determine the computing devices 10 on which the processing of one or more programs (or applications) consisting of microservices must be executed so as to optimize the energy consumption in the network 2.

In one embodiment of the invention where the planning method is decentralized, each computing device 10 can execute steps of the planning method and negotiate with the other computing devices of the network 2 by exchanging messages for the selection of the device or devices. target computers on which the required program(s) are to be executed.

In embodiments, configuration parameters of the scheduling method may be modified to reduce the power consumption of one or more specified resources (such as CPU 22, RAM 260, battery 29, etc.).

The computing devices 10 are arranged so that each computing device 10 can search for another computing device in the network 2, depending on the load of at least one resource among a set of resources of the computing devices 10. The device manager 3 is particularly capable of dynamically adding or removing new devices. Thus a device can be isolated at a given time and reconnect dynamically at another time.

In one embodiment, the set of computing resources includes one or more of CPU 22, RAM 260, network interface card NIC 310, hard disk 20, battery 29 of a computing device 10.

The program processing planning system and method according to the embodiments of the invention exploit requests from a multidimensional space of hardware resources (also called 'hardware components' below) to optimize energy consumption. in a microservices environment.

The energy consumption of the hardware components of the computing devices 10 is closely related to the way in which these hardware components are used. For example for a processor type component, the power consumption may depend on the intensity, or the use of special processor features such as a "turbo boost", etc.

Thus, at a given instant, for a microservice M executed in a source computing device D (10) generating a load L and an energy consumption E, the program processing planning method determines a destination device D' in the network 2 such as:

- D' has at least material resources C such that C>=L and

- the energy consumption E' generated by the microservice M in D' is less than the energy consumption E (for example, due to the current load or the particular characteristics of the hardware components concerned).

Device D' is then a candidate to run microservice M by moving M from D to D'.

The program processing planning method according to the embodiments of the invention allows an intelligent organization of the computing devices 10 of the network 2 (for example P2P network). Thus, if a computing device D has overload or power problems (e.g., low battery situation, fan power expenditures, etc.), the treatment scheduling system and method according to embodiments of the of the invention allow the computing device D to move one or more microservices M to another computing device D' to decrease the load of D and/or save the energy of D. In addition, the system and the process planning method according to embodiments of the invention may enable an under-loaded computing device D' to provide assistance to one or more other computing devices D to process the microservices of those devices D in a more power-efficient manner.

The hardware resources of the devices 10 in the network 2 are organized in the form of an N-dimensional multidimensional space (for example a 4-dimensional space). The dimensions correspond to capacity parameters representing component capacity parameters of the computing devices 10.

Each node (10) of the network 2 can make requests in the multidimensional space according to the resource or resources to be optimized, each node being able to find a logically close neighbor in the sense of the parameters to be optimized on these resources (energy for example) to engage negotiations and perform operations on microservices (such as a stop, move, or duplicate operation) to optimize the chosen parameters, each node being able to dynamically enter or exit the space without altering the stability of the system.

In one embodiment, the multidimensional space is a space with at least 4 dimensions (N at least equal to 4), the four dimensions corresponding to 4 capacity parameters comprising a capacity parameter of the central processor 22, to a capacity parameter of the RAM 260, a capacity parameter of the network interface 31, and a capacity parameter of the hard disk 240.

In one embodiment, the four capacity parameters include:

C1. the frequency of the processor 22 expressed in GHz,

C2. the capacity of RAM 260 expressed in MB,

C3. the network transfer rate associated with network interface 31, and

C4. hard disk speed 240.

To facilitate the rest of the description, it will be considered that the multidimensional space U is defined, in a set of devices 10 connected to a common network 2, and includes the 4 dimensions C1 to C4.

Queries may be exchanged in U-space to allow a device 10 to determine which device(s) 10 in the network have sufficient resources or optimal characteristics for microservice processing, such as a low-cost microservice. processor and a device 10 whose processor is capable of disabling certain cores to run a given microservice.

To determine whether a microservice is a candidate for relocation or duplication in a subsequent negotiation process with another device 10 (implemented by means of message exchange between devices 10), each device 10 may analyze the requirements, the type and processing restrictions of a microservice.

Microservices can include:

- microservices that stay running until a goal is met, while others keep running pending requests all the time.

- microservices that can be moved or not depending on their objectives. For example, while a microservice that performs high-cost CPU operations can be moved or duplicated to balance the load, a microservice that represents an element of a GUI should not always be moved because it usually works with a single screen.

The planning system and method according to the embodiments of the invention make it possible to determine on which target device 10 of the network to execute a microservice, by implementing a process of prior negotiation of a microservices operation between the computing devices 10 at the end of which it can be decided to start, migrate, stop, or duplicate the microservices on a selected computing device.

In a decentralized embodiment, the treatment planning system and method according to the embodiments of the invention allow each device 10 to analyze its own load and/or its own energy consumption in order to perform operations related to the processing of microservices (operations of negotiation, load balancing, interrogation, etc.) by means of direct exchanges with other devices 10 of the network.

Network 2 may be based on different network overlay architectures to allow computing devices 10 to seek information or peer computing devices in a logarithmic number of hops by abstracting Network 2 as a structure deployment. data, such as:

- an ordered circular list iterated with hashing techniques, whose nodes and information are indexed in the same universe of identifiers an example of an ordered circular list is based for example on the “Chord” technique (as described for example in Ion Stoica , Robert Morris, David Karger, M. Kaashoek, and Hari Balakrishnan.2001.Chord: A scalable peer-to-peer lookup service for internet applications, Vol.149-160.149–160.https://doi.org/ 10.1145/383059.383071);

- a binary tree that can be explored through binary space and logical operations like XOR (as described for example in Petar Maymounkov and David Eres. 2002. Kademlia: A Peer-to-peer Information System Based on the XOR Metric. Kademlia : A Peer-to-peer Information System Based on the XOR Metric 2429. https://doi.org/10.1007/3-540-45748-8_5 Microsoft. 2018. Creating composite UI based on microservices); Or

- a linked list of nodes that can search for items by performing smart skips in the structure (as described for example in S. Mandal, S. Chakraborty, and S. Karmakar. 2012. Deterministic 1–2 skip list in distributed system. In 2012 2nd IEEE International Conference on Parallel, Distributed and Grid Computing. 296–301).

However, the invention is not limited to such network overlay architectures and may rely on other types of network overlay architectures that allow deployment and queries in multidimensional spaces on P2P networks.

In an exemplary embodiment, the U-space can for example be based on the MAAN (Multi-Attribute Addressable Network) overlay architecture which depends on the Chord technique, as described for example in M. Cai, M. Frank, J. Chen, and P. Szekely. 2003. MAAN: a multi-attribute addressable network for grid information services. In Proceedings. First Latin American Web Congress.

Chord is a distributed hash table-like overlay network for peer-to-peer (P2P) networks. Chord deploys an ordered circular list of devices 10 in which devices are arranged clockwise according to their ID. In Chord, each device as well as the elements to be searched (i.e. data, processes, etc.) are identified with the same universe of IDs.

The distributed hash table stores key/value pairs by assigning keys to different computing devices 10 which correspond to nodes. A node stores the values of all the keys for which it is responsible. Chord defines how keys are assigned to nodes and how a node can discover the value for a given key by locating the node responsible for the key.

Nodes and keys are assigned an m-bit identifier using a hash function (e.g. according to the SHA-1 algorithm).

According to the Chord protocol, nodes and keys are arranged in a circle of identifiers that has at most ^2m nodes ranging from 0 to ^2m -1, where m is the number of bits in the hash key. Some of the nodes correspond to computing devices or keys while others are empty.

A node has a successor and a predecessor. The successor of a node is the next node in the circle in a clockwise direction.

Nodes corresponding to keys can also have successors. The successor of a node corresponding to a key k is the first node whose identifier is equal to k or which follows k in the circle (called successor (k)).

Each key is stored in a successor node so that a search for key k is equivalent to searching for successor(k).

The Chord protocol makes it possible to request a key from a client (generally a node) to find a successor (k).

Chord implements a fast search method according to which each computer device 10 (represented by a chord node) maintains a table of addresses (called 'finger table' in English language) containing up to m entries, m being the number of bits in the hash key. The address table contains as many elements as the length of the bit string that represents the highest ID of all elements.

The i-th entry of a node n contains successor ((n+2 ^i-1 ) mod m). The first entry in the node's table is the node's immediate successor. When a node searches for a key k, it passes the query to the nearest successor or predecessor of k according to the 'finger' table

There illustrates an example of a chord-like overlay architecture with multiple nodes (N1, N8, etc.) arranged in a circle, as described in Ion Stoica, Robert Morris, David Karger, M. Kaashoek, and Hari Balakrishnan. 2001. Chord: A scalable peer-to-peer lookup service for internet applications, Vol. 149-160. 149–160. https://doi.org/10.1145/383059.383071.

There shows the address table ('finger table') of node N6. There shows the address table entries at node N6 and a "Lookup(29)" query to look up key 29 starting at node N6 using the Chord search algorithm.

In the example of the , the system supports up to 127 (1111111 in the binary system) 10 devices. Therefore, the address table can contain up to 7 elements. Each index i of the address table is defined by the identifier ID of each node added to 2 ⁱ being between 0 and the length of the bit string which represents the highest ID of all the elements.

In the existing Chord approach, whenever an element E is searched through a node N, N searches for the index of E's successor in its finger table, i.e. l 'highest possible index that does not exceed the identifier of E. For example, if in the topology of the , element 24 is searched by node N6, it will be determined that element 24 must be in node N23, since it is the element stored between index 22 (N6 + 16), c ie the highest possible identifier, which does not exceed 24 (otherwise, N6 + 32 = 38). Thus, the data structure used to look up items is a consistent hash table.

On the other hand, the nodes can join and leave the network 2 dynamically at any time. A network 2 node insertion or exit operation can be implemented to achieve this dynamism.

A new node nN and other nodes in the network must perform several operations for nN to join the Chord network. The incoming node nN is first assigned a unique ID using a SHA-1 function to transform its IP address. Then, an external mechanism guarantees a connection between nN and a preexisting node of the Chord network which is found by executing a query inside the network to find a node representative of an immediate successor of nN: nN1.

The information of nN1, consisting of an immediate circle predecessor node reference and a table of addresses (“finger table”), is then used by nN to assign its own circle predecessor reference to that of nN1 and fill its own “finger table” by copying that of nN1. Finally, the predecessor reference of nN1 is reset to nN at this instant.

Once nN has been initialized, an update is issued moving counter-clockwise along the circle to update the previous nodes' finger tables, recognizing the existence of nN and preserving the consistency of the address tables. This update is performed by assigning the ID of nN to the appropriate finger table references within the address table of the predecessor node P if the following two conditions are met:

- P precedes nN by at least 2 ⁱ -1 where i is between 1 and m, with m designating the length of the address tables, and

- The last entry of node P succeeds nN. This update operation is maintained until a previous node P, whose i-th entry precedes nN, is reached. Finally, the responsibility for the corresponding keys is delegated from node nN1 to nN.

An exit operation from a node affects network members when the exit operation is performed. More precisely, an outgoing node LN first informs its predecessor node pLN that the immediate successor node of LN in the circle, LN1, is now its immediate successor in the circle. Then the circle predecessor reference of LN1 is set to pLN. An update operation similar to that described for the insert operation is performed with the LN successor ID. The purpose of this update operation is to keep the address tables (“finger tables”) located in the counter clock along the circle up to date. Finally, responsibility for LN's keys is delegated to LN1.

The existing MAAN architecture generalizes the Chord approach to support n-dimensional queries as well as range queries. MAAN uses a first hash function (SHA-1 for example) to assign a bit identifier of length m for each node and a second locality-preserving hash function (a function configured to output consecutive values from associated entries) which, unlike the basic Chord approach, is used to assign each attribute an identifier in the m-bit space based on its value (same space shared by the node identifiers of m-bits). The use of such identifiers prevents the first hash function (SHA-1) from destroying the locality of the keys insofar as MAAN seeks to associate them with numeric attribute values instead of object names. Thus, this allows the execution of two different multi-attribute query resolution approaches that are not possible in Chord's system, these two approaches including:

- An iterative approach, which consists of a search for resources coming from a node N and composed of a number M of following sub-queries according to the number n of attribute dimensions available. The iterative approach provides a series of candidate lists which are then intersected in the original node N with the aim of finding the most suitable candidate;

- A single attribute dominated query resolution aimed at finding suitable candidates by performing a search that meets the needs of a single dominant attribute, returning a candidate set X. Subqueries for other attributes are then applied on X to obtain a single set of candidates whose members meet the needs of other resources. Finally, the origin node N proceeds to the selection of the most suitable candidate by correlation. Alternatively, subqueries can be applied locally in member nodes of X.

The peripheral resources (CPU 22, RAM 260, HDD 240, Network Interface 31 and/or battery 29) exist inside the space U according to the availability of their processing capacities. The processing planning method according to the embodiments makes it possible to efficiently find and index the resources which make it possible to carry out migration and duplication operations of the microservices in order to achieve energy savings. The space U being multidimensional (at least 4 dimensions of resources), a multidimensional indexing of resources is supported.

U space including at least the 4 dimensions related to hardware resources (1) processor frequency in GHz, (2) RAM capacity in MB, (3) network transfer rate in Mbps, and (4) disk speed drive in Mbps, the overlay architecture, for example MAAN, can be used to index each device resource availability value to the corresponding U axis.

When a device intends to join the MAAN network, at least 4 different logical nodes are created in the 4 space dimensions (one node for each dimension), in accordance with the space axis U. These 4 logical nodes follow operations similar to those described for Chord node insertion operations. A locality preservation formula which, for any dimension, transforms a numeric value representing the availability of a resource into a corresponding identifier consistent with the available identifier space is further used.

Formula 1 indicates an upper limit for numeric input values and a maximum number of nodes supported:

(1)

In formula (1), V denotes an input value, N denotes the maximum quantity of nodes, and SL denotes the maximum value that a node can have regarding a resource (availability of a hardware component).

Formula (1) is used to transform the availability of a resource into an integer ID.

Thus, the digital input value V is multiplied by the maximum number of nodes supported (at any time) N and the obtained product VxN is divided by the maximum resource limit value SL of all devices, where the values SL and N are relative to each dimension constraint. A lower bound exists as a constant value of 0 for all dimensions considering that position 0 is associated with 0 resource availability, while SL is only relevant for the context of each dimension (difference in units and magnitudes) and N is a constant value.

Formula (1) maintains a unique universe of numeric integer IDs that can be assigned to nodes regardless of dimension. Thus, according to embodiments of the invention, the address tables (“finger tables”) contain records in pairs of m-bit space identifiers and node references. Such elements make it possible to execute n-dimensional queries by applying an iterative approach like the one used in the original MAAN proposal.

Note that nodes with an already existing availability value for any attribute can join the network, resulting in an ID assignment identical to that of a pre-existing node in the network. To avoid a collision causing the placement of any incoming node between a successor circle node and (if it exists) a node identical to itself, hereinafter called "twin node" ("twin node" in English language ), a method can be implemented to manage the nodes involved in this collision phenomenon, according to embodiments of the invention. When a “twin node” TN tries to join the network and finds a predecessor node rN (root node that has assigned the same identifier as TN) along the circle, TN enters a list of “twin nodes” of rN in which each node has a reference to its twin in the previous and next position in the list.

In the rest of the description, it is assumed that the iterative approach of the MAAN technique is used, by way of non-limiting example, by considering any list of candidates. A candidate lock can be used to avoid resource selection collisions. Resource selection collisions occur when the same node is selected as the fittest candidate by multiple different query executions and concurrent microservice migration/duplication operations occur to that node, causing saturation and increased consumption energy of the new candidate due to the newly received competing microservices. The candidate-lock is applied on each member , which means devices can be candidates for only one query at a time.

The output operation of a node is similar to that of the Chord technique, treating twin nodes as an additional feature. For any list of twin nodes inside any pre-existing parent root node rN, if rN leaves the network, the first twin node TN in the list of twins inside rN is assigned as the new rN in copying the elements of rN, such as the reference of the predecessor and its address table (“finger table”). In the event that a “twin node” inside rN's twins list leaves, it is removed from rN's “twins” list and the references of its predecessor and successor in the list are reset.

Dataframes can be implemented to obtain the value of resource availability change in each device, allowing control over how often nodes are dynamically re-indexed in the overlay architecture (e.g. MAAN ). Dataframes are a limited collection of resource availability measurement values related to a single resource. The process of reindexing a single node can thus be carried out via a monitoring service which makes the node leave and then join it again if there is a substantial change in its identifier.

System 100 may implement a calculation method to determine whether or not a node should be re-indexed comprising the steps of:

- find the average value in the dataframe (dataframe) to get an identifier associated with it, and

- if the identifier is different from the one currently indexed, perform a re-indexing operation on this node.

To reduce energy consumption in the network 2 of devices 10, the characteristics of the hardware components of the devices and the way in which they are used by the running processes are taken into account. Execution of microservices in network devices takes into account their load in terms of CPU frequency (22), RAM (260), network transfer rate (310) and hard disk speed (240) and/or battery (29).

Network consumption optimization takes into account, for each CPU component (22), RAM (260), network transfer rate (310) and hard disk speed (240) and/or battery (29) :

- the amount of energy consumed in relation to its load,

- the amount of energy consumed by a running microservice, and

- the amount of energy consumed by a microservice if it were migrated or duplicated on another device.

In response to an insertion of a computing device 10 in the network 2 (the network 2 having for example a MAAN configuration containing the space U deployed), a microservices supervision method can be implemented to supervise its microservices and its hardware resources, for example by the microservice manager 122 or in a decentralized manner by the device 10.

There describes the supervision method implemented by a device 10 for its insertion into the network 2, according to embodiments of the invention (decentralized approach to supervision).

In step 400, at each elapsed instant the load supported by each of the hardware components of device 10 is estimated.

In step 402, the set of microservices that the device runs are managed using a monitoring method implemented by each device. Step 402 of microservices management makes it possible to verify that each hardware component of the device is not overloaded. If it is verified that a component of the device is overloaded, a microservice operation among a start, a stop, a migration or a microservice duplication can be implemented.

In step 402, the device 10 uses its supervision method to analyze its state of charge by component (hardware resource) and its state of energy consumption by component.

In step 404, device and/or microservice information is determined, including:

- performance information relating to the device 10 such as the load of the hardware components of the device, or the capacities of the hardware components of the device;

- information related to the microservices that the device is running, such as processing requirements, execution time and the load generated by running the microservices in each of the hardware components.

Such information may be collected during step 402 of supervisory management.

At step 406, the supervision method can implement an analysis of the data frames (“dataframes”) of each hardware resource (in particular the CPU 22, the RAM 260, the HDD 240, the network interface 31, and optionally the battery 29) of the device 10 to maintain updated consumption information.

Such supervision is implemented so that the devices 10 of the network 2 can achieve an energy-efficient load state by means of the program processing planning method according to the embodiments of the invention and exchanges of messages as part of a collaborative negotiation process between devices 10.

The information collected during the supervision process makes it possible to determine the states of load and consumption per hardware resource of the device 10. The processing of processing planning allows an initial device to search for another candidate device 10 in the network 2 and to negotiate with it. this candidate device for moving or duplicating at least part of the microservices of the program according to the state of charge and consumption of the source device determined from the information collected by the supervision method.

The planning process allows in particular:

- a source device D (10) to search for another candidate device D' to process a microservice meeting the processing requirements associated with the microservice with lower power consumption; Or

- to a source device D which presents overload conditions in its hardware resources (CPU 22 and/or NIC 310 and HDD 240 components for example) to implement an energy saving action, to avoid the use of heat dissipation mechanisms (like a fan) which results in higher power consumption; Or

- to migrate microservices from a source device D to a destination device D' to stop the device D, and thus save energy;

- a source device D to migrate high/low consumption microservices to one or more destination devices.

Execution of the planning process may result in actions relating to the microservices or to the source device D (microservice operation such as a move or a migration or a power saving action in the source device D) that depends the energy situation of the source device depending on whether it is determined, in response to the execution of the treatment planning method, that:

i. the source device D is saturated: in this case, migration operations are performed in response to the execution of the processing planning method.

ii. the source device D is not saturated but it is detected that the power consumption can be mitigated/reduced: in this case, microservices migration operations can be performed to reduce the hardware load.

In case ii. where the source device D is determined to be unsaturated, actions taken to decrease consumption may include reducing the load of a device to a given rate (e.g. 80% or less), which mitigates the consumption of additional energy (for example, the reduction in consumption induced by a reduction in fan speed)

A hardware resource (22, 240, 260, 31, 310, 29) is considered saturated (based on previous behavioral observations of the algorithm) when one of the hardware resources is loaded beyond a threshold of load, which can be set at 85%. Additionally, additional power consumption set at a given rate, for example 20%, can be applied to a saturated device to highlight saturation.

If a device saturation condition is detected, the planning process can select one or more microservices of the program, for example the heaviest microservice(s) of the program (in terms of load), and execute a search for candidate devices D' meeting the load requirements to host and process the selected microservices.

If there are no candidate devices available, a new device search can be implemented iteratively using the requirements of other program microservices until a candidate device(s) is found. The selected microservices can then be migrated to the selected candidate devices.

In embodiments of the invention, the program processing planning method exploits in particular the quality of service QoS of the microservices.

The processing planning method can calculate the quality of service QoS value of the microservices in proportion to the hardware resources (hardware) required or obtained. The QoS of a program is determined in proportion to the QoS of each microservice that composes it.

Thus for a microservice M executed in a device D, an optimal Quality of Service (QoS=100%) is defined by specifying:

- resources microservice M needs to run in terms of CPU frequency 22 GHz, RAM consumption 260 MB/s, network transfer rate 310 MB/s and hard disk transfer rate 240 in MB/s, and

- an impact value that each of the quality parameters needs. The impact value can be between 0 and 1, and the sum of all impact values can be 1.

There are differences between the resources M needed to run a microservice and the resources obtained from device D. Each difference between the resources requested by M and the resources obtained from D, for each quality of service parameter, can be expressed as a percentage (between 0 and 100). The quality of service parameters correspond to the capacity parameters of the universe U.

The rest of the description will be made with reference to a space U comprising 4 dimensions to facilitate understanding of the invention, corresponding to the four capacity parameters: CPU 22 frequency parameter, RAM 260 parameter, network transfer rate parameter 310, and hard disk transfer rate parameter 240. of battery capacity, for a U space with more than 4 dimensions.

The differences between the resources requested and those obtained for each QoS parameter may include at least:

- The difference D _C for the CPU frequency parameter 22,

- D _R difference for RAM setting 260,

- The difference D _N for the network transfer rate parameter 310, and

- D _H difference for HDD transfer rate setting 240.

In the first so-called “independent” approach, a QoS of a QoS _M microservice is defined by the weighted sum of the differences relating to the various quality of service parameters, the weight I _i associated with each quality of service parameter being a lower value to 1, the sum of the weights being equal to 1 according to equation 11:

The QoS of a program (application) QoS _prog is defined by the QoS determined for each of the N QoS microservices _i that make up the program, based on the impact value that the user defines:

In the second so-called “dependent” approach, the quality of service of a microservice M is limited by the resource that has obtained the least quantity of resources compared to the others, taking into account the impact parameter I _C , I _N , I _R and I _H specified by the user for each quality of service parameter. The QoS of a QoS _M microservice is then defined by:

The QoS of a PROG program composed of a set of microservices Mi, the set of microservices being denoted M = [M0...Mn], is limited by the microservice with the smallest QoS value, i.e.:

(5)

The planning process can assess the QoS of applications and microservices at a specific predefined rate.

The power consumption of a device is based on the level of use of each component of the device.

The power consumption of a device is defined by a function which relates the power consumption expressed in Watts to the CPU frequency 22 used, to the current transfer rate of the hard disk 240 and to the current transfer rate 310 of the network (the consumption of RAM 260 is independent of its load).

The following models can for example and without limitation be used to measure the energy of devices and microservices:

In order to find the amount of energy consumed at a time by the CPU 22 of a device D, depending on its load, the following equation (6) can be used:

(6)

Formula (6) provides energy consumption in Joules (watts*seconds) of processor D _D from its clock-cycle-switched capacitance (C _D ), voltage (V _D ), processor frequency F _D (cycles per second), and factor T _D , in seconds . .

The energy consumed by a microservice M, in terms of the CPU of D can be determined by interpreting equation (5) in proportion to the load that M generates in this CPU component of D. Thus, from the “capacitance” C _D of this processor, the voltage V _D , of the factor T _D and of the total frequency F _D at a given instant, if the microservice M loads it at X%, the energy consumed for process M will be calculated in the same proportion as the load mentioned according to equation (7):

(7)

To determine the power consumed by M on the processor of an external device (to know how much power the microservice will consume before migrating it), equation (7) can be used to derive the number of instructions from program of M taking into account the number of instructions per unit of time that the processor can execute.

Thus, if D's processor is capable of executing program instructions at in time T1 and if M consumes % of the capacity of this component at time T1, then M also executes the program instructions proportionally:

(8)

By considering another device D2, it is possible to deduce the percentage of its CPU load if M were executed in this device, depending on the number of instructions in time T1 that D2 can execute:

(9)

The energy that D2's processor would consume to process M can be calculated according to equation (6), taking into account the above proportions:

(10)

Equation (10) makes it possible to obtain from D, an estimate of the energy that the CPU of D2 would consume if it executed M. Thus, in a negotiation process, this consumption can be used before a migration or duplication operation.

Because RAM loading typically results in relatively small increases in overall power consumption, in one embodiment, RAM consumption is estimated to avoid overload situations that can impact program performance and an increase in disk load/consumption.

In one embodiment, the power consumption RAM 260 of a device 10 can be estimated as a constant power value multiplied by the analysis time T in seconds (watt *s) according to equation (11):

(11)

Alternatively, mathematical models based on the amount of read and write operations the RAM performs in a given time can be used.

The energy consumption of the RAM can for example be estimated from the number of accesses and operations that the RAM performs in the context of the execution of a program.

To model the energy consumption of the network interfaces 31 of a device and the hard disk drives 240, their heterogeneity is taken into account.

In the case of network interfaces 31, different types of connections (eg Ethernet, WIFI, 2G, 3G, 4G, 5G, etc.) can be taken into account. For each type of connection, there is a relationship between power consumption and the baud rate at which the connection operates.

Similarly, the power consumption produced by the hard disk 240 is related to its transfer rate. The consumption of a network card 310 and/or a hard disk 240, when they are in their active state (read / write) and their inactive state can be predetermined.

For each of the two network card NIC 310 and hard disk HDD 240 components of a device, the power consumption of the component at a time T can be linked to the transfer rate of the component. The transfer rate of a network card 310 or of a hard disk 240 is the average of the transmission/reception states and of the inactive state (idle) of the component considered (310 or 240) at time T. For a given device D, the power consumption in watts when the NIC component 310 (respectively HDD 240) is in an active state is denoted W _u and when its NIC component 310 (respectively HDD 240) is in an inactive state is denoted W _i .

The NIC 310 network card or the HDD 240 hard disk of a device (D) will be commonly designated by the notation "ND" below, ND thus designating either the NIC 310 network card or the HDD 240 hard disk.

For a current transfer rate L, W _u is multiplied by L with respect to its maximum transfer capacity L _MAX . This result is then added to the consumption corresponding to the inactive state. For this, Wi is multiplied by the additional charge of ND with respect to L _MAX , ie L _MAX -L. To obtain the energy consumption in Joules (watts*s), T is taken into account (T in seconds). Thus, the power consumption of the NIC 310 network card or the HDD 240 hard disk is given by equation (12), with ND designating the NIC 310 network card or the HDD 240 hard disk:

(12)

In order to model the energy consumption of a microservice M according to its load generated in the network card NIC 310 or the hard disk HDD 240 of a device (D) (both commonly denoted by the notation "ND") ), equation (12) can be used considering only the load generated by M, i.e. L _M , and considering the state of rest that M generates proportionally in the same way as L _M for the current load L of the ND, which gives the following equation (13):

(13)

To model the energy consumption that a microservice M would produce depending on its load generated in another device, equation (13) is written, considering the ND component of D1, its maximum transfer capacity and its current load :

(14)

The program processing planning method enables the power consumption to be measured in a range of time. This analysis can be performed for each device or for each entire scenario (all devices).

In response to the execution of the planning process, metrics relating to the performance of the planning process can be estimated such as: (1) the execution time, (2) the number of operations performed, (3) the data transmitted by movements/duplicates on the device or in the network, (4) the energy used for movements/duplicates on devices or on the network, and (5) the load per device and the overall load of the devices.

A display of such metrics may further be generated on a graphical interface for an operator of system 100.

There illustrates the program processing scheduling method according to some embodiments

At step 500, a request to process at least one program at a given instant T from a requesting device (D) of the set of devices 10 of the network 2. The program comprises a set of microservices associates.

For each microservice associated with the program (block 502), target values for a set of quality of service parameters defined for the microservice and the values obtained for the set of quality of service parameters by the requesting device (D) are extracted at step 504.

For each quality of service parameter (block 505), the difference between the target value and the obtained value of the quality of service parameter for the processing of the microservice by the requesting device D is determined, at step 506, which provides a difference relating to the quality of service parameter.

In step 507, for each microservice, an elementary quality of service indicator associated with the microservice (also called microservice quality of service indicator) is calculated from the differences relating to each quality of service parameter.

In step 508, the overall quality of service indicator (also called program service quality indicator is calculated from the elementary service quality indicators determined for each microservice of the program.

In step 510, at least one target device D' among said plurality of devices is selected, by implementing a search, in the network, according to the program quality of service indicator and energy consumption information determined for each device at time T.

In step 511, a microservices operation (operation relating to the processing of part of the microservices of the program) is executed for one or more selected microservices of the program PROG in a device of the network according to the quality of service indicator calculated program.

For example, the microservices operation might be a program shutdown. In such an embodiment, the stopping of the program can be implemented directly after step 508 and in this case step 510 is not carried out.

As a variant, the microservices operation can be a movement or a duplication of the microservices of the program PROG on the device D′ selected at step 510 for execution of the program by the device D′.

The program processing method, according to the embodiments of the invention, thus makes it possible to execute a program on one or more devices 10. For example, if one of the devices 10 consumes a lot of energy, a microservice of the device 10 can be moved to another device, if processing power costs are better. In another example, if a microservice consumes a lot because many other microservices consume its data, the device 10 can also seek to duplicate the microservice. In another example application of the invention, if a microservice has a non-movement restriction so that the microservice cannot be moved, the microservice can be duplicated on another device D' (case of a microservice GUI for example).

Advantageously, the program processing planning method can itself be implemented in the form of a microservice.

Those skilled in the art will understand that the systems or subsystems according to the embodiments of the invention can be implemented in various ways by hardware (“hardware”), software, or a combination of hardware and software, including in the form of program code that may be distributed as a program product, in various forms. In particular, the program code may be distributed using computer readable media, which may include computer readable storage media and communication media. The methods described in this description may in particular be implemented in the form of computer program instructions executable by one or more processors in a computer computing device. These computer program instructions may also be stored in computer-readable media.

Furthermore, the invention is not limited to the embodiments described above by way of non-limiting example. It encompasses all the variant embodiments which may be envisaged by those skilled in the art. In particular, those skilled in the art will understand that the invention is not limited to the examples of overlay architectures (Chord, Maan) cited by way of illustration.

Claims (16)

1. Program processing control method implemented in a computer system comprising a plurality of computer devices connected by means of at least one computer network (2), each device having a plurality of hardware resources, each program being configured under the form of a set of microservices, each device being capable of processing at least one program, the said plurality of computing devices being represented in the form of a graph comprising nodes, two nodes being connected by a link, a node representing a computing device, a connecting link of nodes representing the connection between the two computing devices represented by the nodes, characterized in that the nodes are logically indexed in a multidimensional structure according to the resources of a multidimensional space, characterized in that method comprising the steps consists in :
- Receive (500) a request to process at least part of the microservices of a program from a source device (D) of said set of devices, transmitted in the multidimensional space;

• For each quality of service parameter from a set of quality of service parameters representing hardware resource capacity parameters of the source device, determine the difference between the target value and the obtained value of the quality of service parameter for processing the microservice by the requesting device, which provides a difference relative to the quality of service parameter (506), the quality of service parameters including at least the frequency of the central processor (22) of the source device, the capacity of the RAM memory (260 ) of the source device, the transfer rate of the network interface (31) of the source device, and the transfer rate of the hard disk (240) of the device;
• Calculate (507) for each microservice, an elementary quality of service indicator associated with the microservice, from the differences relating to each quality of service parameter; And
• Calculating a program service quality indicator from the elementary service quality indicators determined for each microservice of the program;
• Perform (511) a processing operation relating to the processing of at least part of the microservices of the program in a device of the network according to the calculated quality of service indicators.

2. Method according to claim 1, characterized in that said processing operation is a stop of said at least part of the microservices of the program in the source device. 3. Method according to claim 1, characterized in that it further comprises the following step:
- Selecting at least one target candidate device from said plurality of devices according to the program quality of service indicator and energy consumption information determined for each device at time T, using said graph,
and in that said processing operation consists of moving or duplicating said at least part of the microservices in said at least one selected candidate device for execution of the program by said at least one selected device. 4. Method according to claim 3, characterized in that in the selection step, the source device is able to search for a neighboring node logically close to the node representing said source device in said graph and to implement negotiation exchanges with said neighbor node. 5. Method according to one of claims 1 to 4, characterized in that it comprises a step consisting in managing the devices of the network by using said graph in which a node of the graph is capable of being added or deleted dynamically from the multidimensional space. 6. Method according to one of the preceding claims, characterized in that an elementary quality of service indicator associated with a microservice is calculated by carrying out the weighted sum of the differences relating to each quality of service parameter using elementary weights associated to each quality of service parameter. 7. Method according to claim 6, characterized in that the sum of the elementary weights is equal to 1. 8. Method according to one of the claims, characterized in that a program service quality indicator is calculated by carrying out the weighted sum of the elementary service qualities determined for the microservices of the program by using global weights associated with each microservice . 9. Method according to claim 8, characterized in that the sum of the global weights is equal to 1. 10. Method according to one of claims 1 to 5, characterized in that the elementary quality of service indicator calculated for a microservice is the minimum value between the differences relating to each quality of service parameter, each weighted by an indicator impact. 11. Method according to claim 10, characterized in that the program quality of service indicator is the smallest value among the elementary quality of service indicators calculated for the microservices of the program. 12. Method according to one of the preceding claims, characterized in that it further comprises a step of determining the energy consumption information of each device of the set of devices, said step of determining comprising:
- determining the energy consumption of the central processor CPU (22) of the device;
- determining the power consumption of the RAM (260) of the device;
- determining the energy consumption of the network interface card (310) of the device and of the hard disk (240) of the device;
the power consumption information of the device being calculated from the power consumption of the central processor CPU (22) of the device, the power consumption of the RAM (260), the power consumption of the network interface cards (310) and hard disk (240) consumption of the device. 13. Method according to claim 12, characterized in that the energy consumption E of the central processor CPU (22) of the device for a time is determined according to the equation:

With denoting the capacitance of the central processor, denoting the voltage of the central processor, designating the frequency of the central processor. 14. Method according to one of claims 12 and 13, characterized in that the energy consumption E generated by a given microservice on the network interface card (310) or the hard disk (240) of the device is determined, according to the equation:

, where Wu is the Watts consumption of the device when the device network interface card or the hard disk (240) of the device is in an active state, Wi is when the network interface card of the device or the hard disk ( 240) of the device is in an idle state, Li denoting the transfer rate of a microservice, L _MAX denoting the maximum transfer rate of the microservice and L denoting the current load of the device at time T. 15. Method according to one of the preceding claims, characterized in that the method is itself executed in the form of a microservice. 16. Program processing control system implemented in a computer system comprising a plurality of computing devices connected by means of at least one computer network (2), each device having a plurality of hardware resources, each program being configured under the form of a set of microservices, each device being capable of processing at least one program, the said plurality of computing devices being represented in the form of a graph comprising nodes, two nodes being connected by a link, a node representing a computing device, a connecting link of nodes representing the connection between the two computing devices represented by the nodes, characterized in that the nodes are logically indexed in a multidimensional structure according to the resources of a multidimensional space, characterized in that the system is configured For :
- Receive a request to process at least part of the microservices of a program from a source device (D) of said set of devices, transmitted in the multidimensional space;

• For each quality of service parameter from a set of quality of service parameters representing hardware resource capacity parameters of the source device, determine the difference between the target value and the obtained value of the quality of service parameter for processing the microservice by the requesting device, which provides a difference relating to the quality of service parameter, the quality of service parameters including at least the frequency of the central processor (22) of the source device, the capacity of the RAM memory (260) of the source, the transfer rate of the network interface (31) of the source device, and the transfer rate of the hard disk (240) of the device;
• Calculate for each microservice, an elementary quality of service indicator associated with the microservice, from the differences relating to each quality of service parameter; And
• Calculate a program service quality indicator from the elementary service quality indicators determined for each microservice of the program;
• Perform a processing operation relating to the processing of at least a portion of the program's microservices in a network device.