WO2020094815A1

WO2020094815A1 - Method of dynamic representation of allocation of resources, device and computer program corresponding thereto.

Info

Publication number: WO2020094815A1
Application number: PCT/EP2019/080614
Authority: WO
Inventors: Gilbert Cabillic
Original assignee: Scaledynamics
Priority date: 2018-11-07
Filing date: 2019-11-07
Publication date: 2020-05-14

Abstract

The invention pertains to a method for processing event-based data, method implemented by an electronic device connected to a communication network, said event-based data originating from at least one resource, said at least one resource being known to said electronic device and identified within a resource list. Such a method comprises: - a step (10) of displaying, on a screen connected to the electronic device, an initial multidimensional representation of a resource set, said multidimensional representation comprising, for a given process and/or a resource, a displaying of an initial state; - at least one iteration (20) of a step of receiving, from at least one computing resource, a resource current event and/or of an event of a process executing on said resource; - at least one iteration (30) of a step of processing the multidimensional representation of the resource set comprising an updating of the representation of the resource and/or of the process as a function of the current event and of an earlier state of the resource and/or of the process.

Description

Method for dynamic representation of resource allocation, device and corresponding computer program.

1. Domain

The invention relates to the integration of large amounts of computing resources. The present technique relates more particularly to the integration of large sets of resources available for performing treatments. Even more specifically, the technique described offers the possibility of integrating, in a centralized manner, sets of computerized application processing resources in a simple and intuitive manner, while allowing an overview of the resources.

2. Prior Art

Organizations operate computer networks that interconnect many IT resources to implement their operations, for example when IT resources are co-located (for example as part of a local network) or located in several separate geographic locations (for example connected via one or more private or public intermediary networks). Data centers hosting a large number of interconnected IT resources have become commonplace. There are private data centers operated by and on behalf of a single organization and public data centers operated by companies to provide IT resources to its customers. Some public data center operators provide network access, power and secure facilities for equipment belonging to various customers, while other public data center operators offer "full service" facilities also material resources made available to their customers. However, with the increase in size and scope of such data centers, the tasks of provisioning, administering, and managing IT resources have become increasingly complex.

The massive deployment of virtualization technologies has brought benefits in terms of large-scale IT resource management for many customers with diverse needs, allowing multiple customers to efficiently and securely share diverse IT resources. For example, virtualization technologies can allow a single physical computer machine to be shared among multiple users by providing each user with one or more virtual machines hosted by the single physical computer machine. Each virtual machine can be thought of as a software simulation acting as a separate logical computer system that gives users the illusion that they are the only operators and administrators of a given hardware IT resource, while ensuring the isolation and security of applications between different virtual systems. In addition, some virtualization technologies are capable of providing virtual resources spanning at least two physical resources, such as a single virtual machine with multiple virtual processors spanning multiple distinct physical computing resources.

As the functionality supported by providers of virtualized compute, storage and network resources grows and the number of hardware platforms used by large-scale vendors grows, the implementation Control operations on platforms, such as managing network traffic flows, can itself become quite complex. In many cases, the functionality and usability of applications running on such platforms can largely rely on network communications with other parts of the provider's network and / or with external entities such as customers or third parties. In order to achieve the desired performance levels for the applications, the operators of such distributed systems may on the one hand have set up high bandwidth network infrastructures and on the other hand have grossly oversize the computing capacities. and processing infrastructure, with the sole aim of dealing with the ramp-up and breakdowns. However, despite the availability of high-bandwidth network links and devices, and the increase in processing resources, managing the infrastructure, resources, and applications running within those resources often involves list management. Virtualization can further complicate the management of network bandwidth (as well as latency and other network characteristics), because the various virtual machines implemented on a single hardware platform can have very diverse requirements that must be met using the shared network components of the platform and also because all of the applications and virtual machines instantiated on a given hardware platform can change over time. To deal with administration difficulties, the solution often lies in reporting events to an administration interface, which is used by an operator who sees events (such as hardware or software malfunctions) appear under the form of a list. However, this way of doing things is not very effective, on the one hand because obtaining complete information relating to the event does not generally allow the operator to consider this event in relation to its environment: the operator does not has no information about the task, the application or the resource, in a contextual form, that is to say in relation to its environment. However, for example when a task is in default (case of a faulty application thread), it may be interesting to contextualize this fault compared to all the threads of a physical or virtual resource. Current administration solutions do not make it possible to contextualize the visualization of events related to the execution of applications or portions of applications within a set of resources. There is therefore a need to provide a method which allows such contextualization.

3. Summary

The method proposed by the inventors does not pose at least some of these problems of the prior art. Indeed, an integration method for processing event data is proposed, a method implemented by an electronic device connected to a communication network, said event data coming from at least one resource, said at least one resource being known. said electronic device and identified within a list of resources. Such a method includes:

a step of displaying, on a screen connected to the electronic device, an initial multidimensional representation of a set of resources, said multidimensional representation comprising, for a given resource and / or a process, a display of an initial state;

at least one iteration of a reception step, coming from at least one IT resource, of a current resource event and / or of an event of a process executing on said resource;

at least one iteration of a step of processing the multidimensional representation of the resource set comprising an update of the representation of the resource and / or of the process as a function of the current event and of a previous state of the resource and / or process.

Thus, the invention makes it possible to simplify the display of events originating from resources, nodes and processes in progress and offering a multidimensional and visual representation of the activity of all the resources. For example when using a list to view the resources, it does not fit on the screen size when there are many resources. This is not the case with the invention since the representation is adapted to the quantity of resources to be displayed, either in terms of the size of the representation of a resource or in terms of zooming in / out of this of the resources within which an event has occurred.

According to a particular characteristic, the method further comprises at least one step of processing, from a user device, a command to display said multidimensional representation on said screen. According to a particular characteristic, the step of displaying the initial multidimensional representation of said resource set comprises the display of a basic multidimensional structure, comprising a plurality of locations, each resource and / or process of the resource list being assigned to a given location among all the available locations.

According to a particular embodiment, the display step further comprises a step of grouping, on the basic multidimensional structure, processes belonging to the same resource.

According to a particular characteristic, the step of updating the representation of the resource and / or of the process as a function of the current event and of a previous state of the resource and / or of the process comprises a modification of the height of the representation of the resource and / or the process.

Thus, the invention makes it possible to represent the execution, on multiple resources, of an application or of a portion of application, for the infrastructure manager which allows him to visually realize the use of its resources and which allows it to avoid oversizing its infrastructure so that it can respond to the failures noted.

It is understood, in the context of the description of the present technique according to the invention, that a step of transmitting information and / or a message from a first device to a second device, corresponds at least partially , for this second device at a step of receiving the information and / or the transmitted message, whether this reception and this transmission is direct or whether it is carried out by means of other transport, gateway or intermediation, including the devices described herein according to the invention.

According to another aspect, the invention also relates to an electronic device for processing event data capable of being connected to a communication network, said event data coming from at least one resource, said at least one resource being known by said device electronic and identified within a list of resources. The device comprises means for displaying, on a screen connected to the electronic device, an initial multidimensional representation of a set of resources, said multidimensional representation comprising, for a given resource and / or a process, a display of a initial state ; means for receiving, from at least one computer resource, a current resource event and / or an event of a process executing on said resource;

means for processing the multidimensional representation of the resource set comprising an update of the representation of the resource and / or of the process as a function of the current event and of a previous state of the resource and / or of the process.

The invention also relates, according to a complementary aspect, to an execution system. Such a system comprises at least one integration resource, of “master” type taking the form of an electronic execution device as described above and at least one execution resource accessible from the execution resource and suitable for transmit status information to it.

According to a preferred implementation, the different steps of the methods according to the invention are implemented by one or more software or computer programs, comprising software instructions intended to be executed by a data processor of an execution device according to the invention and being designed to control the execution of the different stages of the methods, implemented at the level of the communication terminal, of the electronic execution device and / or of the remote server, within the framework of a distribution of the treatments to perform and determined by scripted source code.

Consequently, the invention also relates to programs, capable of being executed by a computer or by a data processor, these programs comprising instructions for controlling the execution of the steps of the methods as mentioned above.

A program can use any programming language, and be in the form of source code, object code, or intermediate code between source code and object code, such as in a partially compiled form, or in any other desirable form.

The invention also relates to an information medium readable by a data processor, and comprising instructions of a program as mentioned above.

The information medium can be any entity or device capable of storing the program. For example, the support may include a storage means, such as a ROM, for example a CD ROM or a microelectronic circuit ROM, or else a magnetic recording means, for example a mobile support (memory card) or a hard drive or SSD.

On the other hand, the information medium can be a transmissible medium such as an electrical or optical signal, which can be routed via an electrical or optical cable, by radio or by other ways. The program according to the invention can in particular be downloaded from a network of the Internet type.

Alternatively, the information medium can be an integrated circuit in which the program is incorporated, the circuit being adapted to execute or to be used in the execution of the process in question.

According to one embodiment, the invention is implemented by means of software and / or hardware components. In this perspective, the term "module" can correspond in this document as well to a software component, as to a hardware component or to a set of hardware and software components.

A software component corresponds to one or more computer programs, one or more subroutines of a program, or more generally to any element of a program or software capable of implementing a function or a set of functions, as described below for the module concerned. Such a software component is executed by a data processor of a physical entity (terminal, server, gateway, set-top-box, router, etc.) and is capable of accessing the hardware resources of this physical entity (memories, recording media, communication bus, electronic input / output cards, user interfaces, etc.).

In the same way, a hardware component corresponds to any element of a hardware (or hardware) set capable of implementing a function or a set of functions, according to what is described below for the module concerned. It can be a programmable hardware component or with an integrated processor for the execution of software, for example an integrated circuit, a smart card, a memory card, an electronic card for the execution of firmware ( firmware), etc.

Each component of the system described above naturally implements its own software modules.

The various embodiments mentioned above can be combined with one another for implementing the invention.

4. Figures

Other characteristics and advantages of the invention will appear more clearly on reading the following description of a preferred embodiment, given by way of simple illustrative and nonlimiting example, and of the appended drawings, among which:

FIG. 1 describes a system in which the invention is implemented;

FIG. 2 describes the steps for implementing the invention;

FIG. 3 illustrates a first representation of a system according to the invention; FIG. 4 illustrates a second representation of a system according to the invention; FIG. 5 illustrates a third representation of a system according to the invention;

FIG. 6 illustrates an architecture of a device capable of implementing a processing method of the invention.

5. Description

5.1. Statement of the principle

The object of the invention, as explained above, is to provide a simple, efficient and intuitive management technique for physical or virtual IT resources. More particularly, the invention offers a solution for managing large sets of resources in a simple manner by proposing a graphical representation combined with a technique for modulating the representation as a function of the states of the computer resources. Within this graphic representation, IT resources are grouped in a cluster. Each cluster includes a predetermined number of IT resources (either physical, virtual or both): a cluster can represent a calculation grid or a set of calculation grids. The invention offers the possibility on the one hand of managing these clusters individually and easily and on the other hand of managing each of the IT resources of this cluster individually completely independently. Finally, in general, the invention offers the possibility of viewing events (anomaly / task in progress, load) in a simple manner without restricting the field of vision of the user, that is to say without limiting the vision that the user can have of the set of resources.

These advantages are obtained by a method of integrating computer resources, method comprising the implementation of a data structure representative of a set of computer resources. This data structure includes, for each IT resource, at least one state information and at least one membership cluster (node). The data structure is sized to meet the display needs of the representation associated with all of the IT resources that are managed. As explained below, in an explanatory and nonlimiting embodiment, the data structure can include several thousand entries and be in the form of a table or even a database. The data structure is created, fed and updated by an IT resource integration server. For the purposes of the description, an IT resource integration server is called "master". Depending on the embodiments, several “master” servers can transmit data to be displayed to a given display device. The "master" has at least one hardware interface for accessing resources. This (at least one) hardware interface for accessing computer resources can be supplemented or overloaded with logical interfaces for accessing computer resources. The computer resources accessed by master are of the physical computer resources and / or logical (virtual) computer resources type. A physical computing resource can take the form of a server, a personal computer, a smartphone, a tablet or even a core of a multicore processor. More generally, a physical computer resource comprises a calculation unit that is physically addressable and capable of implementing computerized processing of an application (a program) or a part of an application (a part of a program). A logical (virtual) computer resource can take the form of a virtual machine (reproducing as explained above the operation of a physical machine) executing on one or more physical computing resources or more generally of a program executing on a physical computer resource (for example a scripted code or bytecode interpreter).

Within the framework of the invention, it is assumed that an IT resource can, depending on the embodiments, be in charge of the implementation of one or more "threads" (also called "threads"). process, which executes part or all of an application by an IT resource (execution can also be called "job"). In the context of this, it is also assumed that master is able to obtain, from computer resources, the state of the threads that run within the computer resource.

FIG. 1 represents all of the possible computer resources as implemented in the invention. The data structure representative of all of the computer resources includes the information illustrated in FIG. 1, either in tabular form (one row per record), or in the form of a tree. The constitution of the data structure (SDAT) is adapted to the operational implementation conditions, in order to provide rapid access to the content of the data structure. For example, a database can be adapted to the integration of a very large number of IT resources, while an XML file or a flat file of the "json" type can be adapted to a lower number of IT resources. .

Anyway, as explained in Figure 1, we consider that a cluster (a node) relates to at least one IT resource (physical or logical). An IT resource implements one or more threads associated with the execution of part or all of an application. An IT resource can relate to several clusters (nodes) at the same time. In a mode of particular embodiment, a cluster comprises a plurality of resources and each resource implements one and only one thread at a given time (no concurrency of access to the resources).

In possession of this data structure, the method of the invention, as illustrated in FIG. 2, comprises the following steps, implemented iteratively, to allow restitution of the data of the structure, by the "master" or by a terminal to which the "master" communicates display data:

a step of displaying (10), on a screen connected to the electronic device, an initial multidimensional representation of a set of resources, said multidimensional representation comprising, for a given resource and / or a process, a display of a initial state ;

at least one iteration (20) of a reception step, coming from at least one IT resource, of a current resource event and / or of an event of a process executing on said resource;

at least one iteration (30) of a step for processing the multidimensional representation of the resource set comprising an update of the representation of the resource and / or of the process as a function of the current event and of a previous state of the resource and / or process.

According to the invention, updating the representation of the resource and / or of the thread (process) as a function of the current state, comprises at least one step belonging to the following group:

for a given thread, among all the threads running, a modification of the height and / or of the shape of the multidimensional representation of this thread according to the processing load associated with the application or the portion of application executed by this thread;

for a given thread, among all the threads running, a modification of the color of the multidimensional representation of this thread according to the processing load associated with the application or with the portion of application executed by this thread;

for a given thread, among all the threads currently running, a change in the color of the multidimensional representation of this thread according to the state of this thread (active, inactive, pending, faulty state, etc.);

for a given resource, among all the resources in use, a modification of the color of the multidimensional representation of this resource in function of the processing load associated with the application or with the portion of application executed by at least one thread on said resource;

for a given resource, among all the resources in use, a modification of the color of the multidimensional representation of this resource as a function of the state of this resource (active, inactive, pending, faulty state, etc.);

for a given node, among all the nodes in use, a modification of the color of the multidimensional representation of this node as a function of the processing load associated with the application or with the portion of application executed by at least one thread on a resource associated with this node;

for a given node, among all the nodes in use, a modification of the color of the multidimensional representation of this node according to the state of this node (active, inactive, pending, faulty state, etc.);

In addition to the modifications linked to the reception of status or execution data from the nodes / resources / thread, the graphic representation is also modifiable for a user viewing this representation on the screen of the device connected to the master. The modifications of representations linked to the manipulation carried out by or for the user include in particular: the selection of a node (cluster) among all of the available nodes; this action results in the display of a certain amount of information relating to the selected node, such as for example the identifier of the node, its type, the number of resources and / or thread of which the node is composed , the number of resources used and / or thread running, the processing load of the node (memory, CPU, etc.)

the selection of a resource from the set of available resources; this action results in the display of a certain amount of information relating to the selected resource, such as for example the identifier of the resource, its type, the number of threads associated with this resource, the number of running thread, resource processing load (memory, CPU, etc.)

the selection of a thread from the set of available threads; this action results in the display of a certain amount of information relating to the selected thread, such as for example the identifier of the thread, its type, the processing load on the resource (memory, CPU, etc. ) the use of a zoom in or zoom out command of the representation; the consequence of this action is to cause, by the master or by a visualization application, a more or less extensive display (depending on the command used),

the use of a command for rotation, translation, displacement of the representation.

The modifications can be implemented automatically or manually (by the user himself. However, the automatic character of the modification is privileged when an event of type "error" (blocking / abort / failure) occurs. visualization application which manages the representation has a data structure representing the resources which are displayed (called display data structure) on the screen (and their position on the screen) and a data structure representing the all resources (these characteristics are specified below) When an event received relates to a resource which is not displayed on the screen or which is not fully visible or a resource which is not fully centered, then the viewing application performs one or more of the actions mentioned above, on behalf of the user (i.e. in automated mode) in order to allow c it is easier to visualize the impacted resource.

In order to facilitate the administration of resources (physical or virtual), nodes (nodes) or processes (thread), according to the invention, manipulations can automatically be carried out depending on the occurrence of previously determined events (faults, modifications of 'condition, load changes, etc.). For example, in the event of a fault on a resource, a node or a process, the application implemented by the master and / or by the display terminal connected to the master performs an automatic movement to the resource, node or process in question to place the faulty element at the center of the user's vision, according to predetermined viewing parameters (in terms of zoom, size, color, etc.). Cleverly, this displacement can be accompanied, according to the embodiments, by an automatic selection of this element in order to allow the display of its properties. In a particular embodiment, modifications to the appearance of the selected element (shape, color) can also be implemented to allow its faster identification by the user (the operator) and ultimately allow the user - to react more quickly when actions are required from him. Changes in appearance may include any change in size, color, shape, or even the addition of an animation. The objective is to allow the operator to quickly identify the element that deserves attention in order to exercise the necessary actions if possible. The processing operations implemented by the master to modify the display according to the actions of the user allow the latter to check the operation and / or the execution of the nodes / resources / thread in operation during the execution of one or more applications in a simple and intuitive way. In fact, unlike the methods traditionally used in data centers, the display produced by the invention makes it possible to quickly locate an operating anomaly while sizing the architecture optimally in relation to needs. More particularly, after an initialization phase, in which the representation of all the resources / nodes / thread is initially drawn (displayed), the modifications made to the representation are made by communicating, to the communication terminal (comprising by example a browser) by transmitting commands (and / or requests) which communicate event modifications (ie event and data relating to these events), linked to one or more resources / nodes / thread from the master to the communication terminal.

Figures 3 to 5 show, for a given embodiment, the three-dimensional (three-dimensional) visual representation which changes over time (in the end, a four-dimensional representation (x, y, z, t)) is obtained, obtained for different states and different viewing angles. In this embodiment, a hexagonal representation is adopted for each thread. Another form could just as easily be implemented. The representations of the threads are positioned on a plane, which can have a predetermined size. This plan constitutes the basic representation on which the other representations (thread, resources, nodes) are displayed and updated. In this representation, the different nodes and threads all have the same color. For reasons of ease of support and selection, it could be envisaged to give different colors to the threads of a given node, when selecting a thread for this node.

Figure 2 is a representation of two nodes, comprising between them fifty-eight threads (illustrated by the word flow on the screenshot), the whole being in an inactive state. Each thread is represented by the same three-dimensional hexagon, of uniform height and color. As indicated in the left part of the screen, no job is running and the system state is inactive. We also visualize on the screen a set of "empty" hexagons, ie a representation of all the threads that it would be possible to instantiate in the system. In the right part of the screen, a general state of the system is represented, comprising in particular the number of nodes, the number of threads, a general state of use of the resource and an indication of pressure exerted on the system (representing the number number of jobs pending). FIG. 3 is a representation of the same two nodes as in FIG. 2, comprising between them two fifty-eight threads (illustrated by the word flow on the screenshot), the assembly being in an active state. More specifically, fifty threads are in an active state (blue and red colored threads) and eight threads are in an inactive state (as in Figure 2). The blue threads have a higher height than the red and black threads. They indicate that a task (a job) is running on the thread). The height of the representation varies according to the load, a high load resulting in a high height. As shown in the figure, there are forty tasks (portions of applications) running on the screenshot (num running flow = 40), while the node has fifty threads (num flow = 50). The node identifier is listed at the top left (node id). Usage and load information is also present for this node. The threads shown in red are those for which a failure occurs (it can be a hardware or software failure). Not being in execution, the height of the representation of these failing threads is lower than that of the threads in execution. A selection of a failing thread makes it possible to obtain information on the state of the thread (and therefore of the resource) and to determine or determine the origin of the failure encountered.

FIG. 4 represents the same nodes and thread as in FIG. 3, on the one hand that the representation is rotated by the user and on the other hand that the number of threads for which a task is running is no longer equal to sixteen (num running flows = 16), the other threads having finished executing the portions of applications that they were running. They are therefore again black and their height has been adjusted according to their new condition.

Thanks to the implementation of the technique described here, it is easier for a resource manager (for example an operator assigned to resource management) to quickly and efficiently observe the state of resources of a given system , with or without execution of applications or portions of applications, without the need to search through a simple list or without the need to prioritize resources to allow monitoring of these.

In order to illustrate a particular implementation, we present below an example of decoding requests sent by a master to a browser (Firefox ™ type, etc.) in charge of rendering the interface previously illustrated. In this implementation, the master runs on a server and communicates via a dedicated "socket" requests with a browser so that the latter displays the representation of a cluster in real time.

The data exchange format is in this case a JSON format suitable for these exchanges. To materialize the state of a cluster, the master defines a “metrics” data structure. This structure is made up of “nodes” representing an IT resource. A “node” is represented by an identifier “id” and has a “load” representing the load of the resource, a “State” representing the state of the resource and another flow structure representing the different threads associated with this resource. Each “flow” has its identifier “Id” as well as a “State” representing its state (“run” or “wait” in this case).

As an example, here is a "metrics" structure used in this implementation. metrics = {

nodes: {

'nodeldl': {

load: 10,

State: 'ok',

flows: {

'flowldl': {

State: 'run'

},

'flowId2': {

State: 'wait'

},

'flowId3': {

State: 'wait'

},

'flowId4': {

State: 'wait'

}

Thanks to this data structure, the visualization application (also called visualization interface) which runs in the browser is able to produce an initial representation of the state of a cluster.

In order to initialize the display, the “master” transmits via a “setMetrics” request, the initial state of the cluster. Within this request, "req. metrics ”includes the version of“ metrics ”to initialize. To do this, the browser performs the call “new ClusterMetrics” which creates the initial “metrics” data structure and updates the initial visualization of the cluster on the interface.

Then, the master transmits requests when the state of the cluster changes (for events occurring on the cluster). Cleverly, the events transmitted to be represented can be "filtered", by an event processing component, as described below. As indicated previously in this example "Node" represents a resource, "Job" represents a thread. There is thus a function call to add a resource "AddNode", or delete it "removeNode", or update its charge state "setNodeLoad" or update its state (on / error / suspended, ...) update "setNodeState".

In this implementation, the "addNode" request indicates the identifier associated with this resource ("nodeld"), as well as a "flows" structure which includes the identifiers (Ids) of each thread of the resource. In order to update the state of the threads, the master transmits "jobRun" requests to indicate that a job is executing or "jobDone" to indicate that the thread is waiting.

During each of these calls, the visualization interface is updated by the browser and thus represents a real-time view of the state of a given cluster. The advantage of such an implementation is to limit the exchange of data between the master and the browser: in fact, once the initialization has been carried out and the first representation displayed by the browser, the amount of data exchanged between the master and the browser is weak and is limited to the changes processed by the master and transmitted to the browser. This also ensures greater responsiveness of the browser.

In this embodiment, the call to “addNode” or “removeNode” is made simultaneously when adding or removing a resource, just like “jobRun” or “jobDone” for a thread, as many "setNodeLoad" or "setNodeState" calls are updated at indefinite periods depending on the configuration and / or the master's treatments. For example if the master processes the load information of the processors of a computer every minute, the call "setNodeLoad" will be made only every minute at least. When the master processes its load information from the processors of a computer every second, it could make "setNodeLoad" requests every second. The master, however, itself has an event processing component which makes it possible to decide on the frequency of transmission of data to the browser in order on the one hand not to overload the latter and on the other hand to take into account the evolutions real and representative of charges or other events. In the previous case, the event processing component can determine that an update less frequent than the second is sufficient to reflect the load of the processors and make a call to "setNodeLoad" only every 10 seconds in order to limit request traffic on the network. The transmitted load value can then advantageously be an average of the values processed by the master. The master (event processing component) is therefore responsible, according to a predetermined policy, for the frequency of these "setNodeLoad" or "setNodeState" requests (and in general for the frequency of events transmitted, as well as values associated with these events, which can therefore be representative of the situation of one or more events, without necessarily being exact). This procedure ensures that the cluster representation can be displayed (and be executed) on communication terminals which do not necessarily have sufficient computing and / or processing power and / or bandwidth for intensive processing. This also makes it possible to eliminate irrelevant events, such as, for example, insignificant load decreases or increases and / or not to display divergent behaviors (that is to say unrelated to actual activity). switch (action required) {

// Initialize the view

'setMetrics' box:

metrics = new ClusterMetrics (req .metrics);

break;

// Resource management or Nodes

// Add, delete, change of state or charge

'addNode' box:

metrics. addNode (req. nodeld, req. flows);

break;

'setNodeLoad' box:

showNodeLoad (req. load);

break;

'setNodeState' box:

showNodeState (req. State);

break;

'removeNode' box:

metrics. removeNode (req. nodeld);

break;

// Management of a thread (job) for a given resource

// Add or delete a job on a node

box 'j obRun':

metrics. 'jobRun' (req. nodeld, req.flowld);

break;

box 'j obDone':

metrics. j obDone (req. nodeld, req. flowld);

break;

}

As indicated above, from this “metrics” data structure, the browser allows you to produce a visualization of a cluster. For example the latter can be built on top of a 3D interface which makes it possible to support the selection, the zoom and other manipulations of the different elements, as in Figures 3 to 5.

In a complementary embodiment, the display application generates, on reception, a display data structure, which for each node ("node") comprises display coordinates of this node. When a node has no display coordinates, either it is not in the display structure or alternatively it has non-valued coordinates. The display data structure can be updated according to the operations performed manually by the user. This additional embodiment has the advantage of facilitating the visualization of the resources for which an event (for example an error) occurs. Concretely, the display data structure is created by the visualization application and includes at least one pair of display coordinates for each node (resource) displayed on the screen, as well as the identifier of this node. This data structure is maintained (modified) in real time depending on the user's manipulations in particular. For these modifications to be simple, a simple coordinate system (x, y) is preferred. Manual translations, zoom rotation and dezoom are then easier to pass on to the data structure. When an event occurs on a node (a resource), the visualization application searches if this node is present within the display data structure and if it is present, what are its coordinates. When the resource is "sufficiently" visible (the sufficiency criterion can be calculated in several different ways, in particular with respect to the center of the screen (ie distance "threshold" separating the display of the resource from the center of the screen)), then no action is taken. When the resource is not sufficiently visible (see not displayed), then one or more actions (rotation, homothety, translation, zoom / dezoom) are implemented by the visualization application to make the resource visible (compared to the previously defined threshold for example). The coordinates of the impacted resources are updated in the display structure to allow the automatic implementation of these actions. In addition, an action of selecting the resource (causing the opening of a window of its properties) can also be implemented. Thus, the user is guaranteed to be informed of events deemed important (this being of course configurable), even with very large amounts of resources to manage.

5.2. Other features and benefits

In at least some embodiments, a server that implements some or all of one or more of the technologies described here, including techniques for implementing network configuration servers, network configuration service managers, viewing topology and / or instance hosts, may: include a general purpose computer system that includes or is configured to access one or more media accessible by computer. FIG. 6 illustrates such a general-purpose computing device 3000. In the illustrated embodiment, the computing device 3000 comprises one or more processors 3010 coupled to a system memory 3020 via an input / output interface 3030. The computing device 3000 further includes network interface 3040 coupled to the input / output interface 3030.

In various embodiments, the computing device 3000 may be a single processor system comprising a processor 3010 or a multi-processor system comprising multiple processors 3010 (for example two, four, eight or some other suitable number). 3010 processors can be any suitable processors capable of running instructions. For example, in various embodiments, processors 3010 can be general purpose or embedded processors implementing any of a variety of instruction set architectures (ISAs), such as ISA x86, PowerPC, SPARC or MIPS, or any other appropriate ISA. In multiprocessor systems, each of the processors 3010 can generally, but not necessarily, implement the same ISA. In some implementations, graphics processing units (GPUs) can be used in place of or in addition to conventional processors.

System memory 3020 can be configured to store instructions and data accessible to processor (s) 3010. In various embodiments, system memory 3020 can be implemented using any suitable memory technology, such as '' static random access memory (SRAM), synchronous dynamic RAM (SDRAM).), non-volatile / Flash memory or any other type of memory. In the illustrated embodiment, the program instructions and the data implementing one or more desired functions, such as the methods, techniques and data described above, are stored in the system memory 3020 in the form of code 3025 and 3026.

In one embodiment, the I / O interface 3030 can be configured to coordinate I / O traffic between the processor 3010, system memory 3020, and all devices on the device, including the network interface 3040. or other peripheral interfaces such as various types of persistent data and / or the like or volatile storage devices used to store physical replicas of data object partitions. In some embodiments, the I / O interface 3030 can perform any necessary protocol, synchronization, or other data transformation to convert the data signals of a component (for example, system memory 3020) to an appropriate format. to be used by another component (for example, the 3010 processor). In some embodiments, the I / O interface 3030 may include support for devices connected via various types of device buses, such as a variant of the PCI bus standard ("Peripheral Component Interconnect") or USB standard ("Universal Serial Bus"), for example. In some embodiments, the function of the I / O interface 3030 can be split into two or more separate components, such as a north bridge and a south bridge, for example. Likewise, in some embodiments, some or all of the functionality of the I / O interface 3030, such as an interface to system memory 3020, can be incorporated directly into the processor.

3010. The network interface 3040 can be configured to allow the exchange of data between the computing device 3000 and other devices 3060 connected to a network or to networks 3050, such as other computer systems or devices, as illustrated in the Fig. 1 and 2, for example. In various embodiments, the network interface 3040 can support communication via any suitable general wired or wireless data network, such as types of Ethernet network, for example. In addition, the network interface 3040 can support communication via telecommunication / telephony networks such as analog voice networks or digital fiber communication networks, via storage networks such as Fiber Channel SANs or via any other type of network and / or appropriate protocol.

In some embodiments, system memory 3020 may be an embodiment of computer-accessible media configured to store program instructions and data as described above for FIG. 1 in FIG. 5 for implementing embodiments of the corresponding methods and devices. However, in other embodiments, program instructions and / or data may be received, sent or stored on different types of media accessible by computer. In general, a computer-accessible medium can include a non-transient storage medium or a memory medium such as a magnetic or optical medium, for example a disc or a DVD / CD coupled to the computing device 3000 via a computer interface. input / output 3030. A non-transient computer an accessible storage medium can also include any volatile or non-volatile medium such as RAM (for example, SDRAM, SDRAM DDR, RDRAM, SRAM, etc.), ROM, etc., which can be included in certain embodiments of the computing device 3000 as system memory. 3020 or another type of memory. In addition, a computer accessible medium may include a transmission medium or signals such as electrical, electromagnetic or digital signals, routed via a communication medium such as a network and / or a wireless link, such as can be implemented via the network interface 3040 or all multiple computing devices such as that illustrated in FIG. 5 can be used to implement the functionality described in various embodiments; For example, software components running on different devices and servers can collaborate to provide functionality. In some embodiments, portions of the functionality described can be implemented using storage devices, network devices, or specific purpose computer systems, in addition to or instead of being implemented using systems general purpose computers. The term "computing device" as as used herein, refers to at least all of these types of devices and is not limited to these types of devices.

Various embodiments can also include receiving, sending or storing instructions and / or data implemented in accordance with the preceding description on a medium accessible by computer. In general, a computer-accessible medium can include a storage medium or a memory medium such as a magnetic or optical medium, for example a disc or DVD / CD-ROM, a volatile or non-volatile medium such as a random access memory (SDRAM, DDR, RDRAM, SRAM, etc.). , etc.), ROM, etc., as well as transmission media or signals such as electrical, electromagnetic or digital signals, routed via a communication medium such as a network and / or a wireless link.

The various methods illustrated in the figures and described here represent examples of embodiments of methods. The methods can be implemented in software, hardware or a combination thereof. The order of the method can be changed and various elements can be added, reorganized, combined, omitted, modified, etc.

Various modifications and changes may be made, as would be obvious to a skilled person benefiting from this disclosure. It is intended to encompass all of these modifications and changes and, therefore, the above description should be considered illustrative rather than restrictive.

Claims

1. Method for processing event data, method implemented by an electronic device connected to a communication network, said event data coming from at least one resource, said at least one resource being known to said electronic device and identified within a list of resources, said method comprising:

2. Method for processing event data according to claim 1, characterized in that it further comprises at least one step of processing, from a user device, a command to display said multidimensional representation. on said screen.

3. Processing method according to claim 1, characterized in that the display step (10) of the initial multidimensional representation of said resource set comprises the display of a basic multidimensional structure, comprising a plurality of locations , each resource and / or process of the resource list being assigned to a given location among the set of available locations.

4. Processing method according to claim 3, characterized in that the display step (10) further comprises a step of grouping, on the basic multidimensional structure, processes belonging to the same resource.

5. Processing method according to claim 1, characterized in that the step of updating the representation of the resource and / or of the process as a function of the current event and of a previous state of the resource and / or of the process includes a change in the height of the representation of the resource and / or process.

6. Electronic event data processing device able to be connected to a communication network, said event data coming from at least one resource, said at least one resource being known to said electronic device and identified within a list of resources , said device comprising:

means for displaying, on a screen connected to the electronic device, an initial multidimensional representation of a set of resources, said multidimensional representation comprising, for a given resource and / or process, a display of an initial state;

means for receiving, from at least one computer resource, a current resource event and / or an event of a process executing on said resource;

7. Product computer program downloadable from a communication network and / or stored on a medium readable by computer and / or executable by a microprocessor, characterized in that it comprises instructions of program code for the execution of a method according to claim 1, when executed on a computer.