A Kubernetes-based DPU system-on-chip management method and device

Abstract

The application provides a Kubernetes-based DPU system-on-chip management method and device, creates a system-on-chip type custom resource definition, and registers the custom resource definition in a Kubernetes cluster; a custom controller is created and started on a system-on-chip of a data processing unit (DPU); the custom controller listens to and collects state information of the DPU, and sends the state information to an application programming interface (API) server; the API server receives the state information, creates a system-on-chip resource instance, and stores the system-on-chip resource instance in a preset database; the API server receives a request initiated by a user to modify the system-on-chip resource instance, modifies the system-on-chip resource instance, and sends information before and after the modification to the custom controller; and the custom controller performs corresponding operations according to the information before and after the modification. The method provided by the application can control physical resources of a system-on-chip by operating resource instances of Kubernetes.

Description

Technical Field

[0001] This invention relates to the field of cloud computing technology, and in particular to a Kubernetes-based DPU on-chip system management method and apparatus. Background Technology

[0002] With the growth of data center and cloud computing demands, as well as the need for higher network and storage performance, data processing units (DPUs) are playing an increasingly prominent role in today's large-scale server clusters. Compared to traditional central processing units (CPUs), DPUs offer advantages such as low latency, high throughput, and high security. They can also free up a significant amount of computing power that is consumed by the CPU during large-scale data transfers, allowing the CPU to focus on pure business operations. As a result, DPUs are becoming an increasingly important component in data centers and large-scale server clusters, with a very broad prospect for application.

[0003] Kubernetes (K8s), as an open-source container orchestration and management platform, is powerful and comprehensive, with a broad and active ecosystem. It is the preferred tool for cloud-native application development and deployment, and the mainstream solution for managing large-scale cloud server clusters. Kubernetes has many built-in resources that are associated with actual physical resources. Users can trigger resource change events by modifying the state of these resources. By defining methods to listen for these events, users can perform corresponding operations on the physical resources to change their state. In short, Kubernetes manages actual physical resources through Kubernetes resources associated with them. In addition to these built-in resources, Kubernetes also provides a Custom Resource Definition (CRD) mechanism for non-built-in resources. CRDs allow extending Kubernetes functionality through declarative Application Programming Interface (API) resources, thereby creating new resource types that meet specific needs. This is an extension mechanism provided by Kubernetes that allows developers to add new resources without modifying the Kubernetes core code.

[0004] As a physical resource with broad application prospects in large-scale cloud server clusters, the Dynamic Processing Unit (DPU) currently lacks a mechanism for direct monitoring and management in mainstream cluster orchestration systems. Users wishing to modify DPU configurations must log into the DPU's System-on-Chip (SoC) and use commands. Furthermore, since the DPU SoC is not added to the Kubernetes cluster as a node, Kubernetes cannot promptly detect DPU failures, impacting normal cluster operation and maintenance. Additionally, as a shareable physical resource, direct monitoring of the DPU by the cluster orchestration system would allow for load balancing based on occupied physical resources. Therefore, effective DPU management can improve cluster resource utilization, enhance system security and stability, optimize performance, and reduce the risk of failure. Summary of the Invention

[0005] In view of this, embodiments of the present invention provide a Kubernetes-based DPU on-chip system management method and apparatus to eliminate or improve one or more defects in the prior art, and solve the problem that the existing mainstream cluster orchestration system lacks a mechanism for directly monitoring and managing physical resources, and that when the DPU fails, it cannot be detected in time, thus affecting the normal operation and maintenance of the cluster.

[0006] On one hand, the present invention provides a Kubernetes-based DPU on-chip system management method, the method comprising the following steps:

[0007] Create a custom resource definition to describe the on-chip system specifications and behavior of the data processing unit, and register the custom resource definition in the Kubernetes cluster;

[0008] A custom controller is created and started on the system-on-a-chip of the data processing unit; the custom controller listens to and collects the status information of the system-on-a-chip of the data processing unit, and sends the status information of the system-on-a-chip to the application programming interface server of the Kubernetes cluster;

[0009] After receiving the status information of the system-on-chip, the application programming interface server creates a system-on-chip resource instance and stores it in a preset database;

[0010] The application programming interface server receives a user's request to modify the on-chip system resource instance, modifies the on-chip system resource instance, and sends the information before and after modification to the custom controller; the custom controller performs corresponding operations based on the information before and after modification.

[0011] In some instances of this invention, a custom resource definition is created to describe the specifications and behavior of the on-chip system of the data processing unit. This custom resource definition includes metadata, specifications, status, and fault conditions, including:

[0012] In the metadata section, set the name of the custom resource definition and set the type of the custom resource definition to System on Chip;

[0013] In the specification section, the custom resource definition is associated with the physical system-on-a-chip by setting the offloading function and the uplink network.

[0014] In some instances of this invention, after creating a custom resource definition to describe the specifications and behavior of the data processing unit on-chip system and registering the custom resource definition in the Kubernetes cluster, the method further includes:

[0015] The custom resource definition is stored in the etcd database of the control plane component of the Kubernetes cluster as part of the state of the Kubernetes cluster.

[0016] In some embodiments of the present invention, sending the status information of the on-chip system to the Kubernetes application programming interface server includes:

[0017] The status information of the on-chip system is assembled according to a preset custom resource definition format to generate on-chip system assembly information;

[0018] A new resource instance is created to store the system-on-chip assembly information; the newly created resource instance is sent to the application programming interface server through the application programming interface of the Kubernetes cluster.

[0019] In some embodiments of the present invention, the application programming interface server modifies the on-chip system resource instance and sends the information before and after the modification to the custom controller, including:

[0020] The application programming interface server modifies the on-chip system resource instance, triggering an update event for the on-chip system resource instance. The update event carries information about the on-chip system resource instance before and after the modification. The update event is then sent to the custom controller via the application programming interface.

[0021] In some embodiments of the present invention, the custom controller performs corresponding operations based on the information before and after the modification, including:

[0022] The custom controller determines itself as the on-chip system resource instance of the Kubernetes cluster corresponding to the data processing unit on-chip system based on the metadata information in the information before and after modification.

[0023] The custom controller modifies the fields in the on-chip system resource instance specification and performs corresponding operations.

[0024] In some embodiments of the present invention, the method obtains the on-chip system node resources and operating status of the data processing unit based on the on-chip system resource instance, including:

[0025] The custom controller senses the status information of the data processing unit on-chip system at preset time intervals and organizes the status information into a format that conforms to the on-chip system resource status field format in the custom resource definition.

[0026] The custom controller sends an update request to the application programming interface server for the status field of the on-chip system resource instance, and updates the status information of the on-chip system resource instance in the preset database with the sensed status information.

[0027] On the other hand, the present invention also provides a Kubernetes-based DPU on-chip system management device, the device comprising:

[0028] A custom resource definition creation module is used to create on-chip system resource instances of data processing units in a Kubernetes cluster to describe the specifications and behavior of the on-chip system and to build the association between the on-chip system resource instances and the physical on-chip system.

[0029] The management module is used so that when a user initiates a request to modify the on-chip system resource instance, the application programming interface server of the Kubernetes cluster modifies the on-chip system resource instance and sends the information before and after the modification to the custom controller running on the on-chip system, and the custom controller performs corresponding operations based on the information before and after the modification.

[0030] On the other hand, the present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of any of the methods mentioned above.

[0031] On the other hand, the present invention also provides a computer program product, including a computer program / instructions that, when executed by a processor, implement the steps of any of the methods mentioned above.

[0032] The beneficial effects of the present invention are at least as follows:

[0033] This invention provides a Kubernetes-based DPU (Data Processing Unit) on-chip system management method and apparatus. The method involves creating a custom resource definition for an on-chip system type and registering this custom resource definition in the Kubernetes cluster. A custom controller is created and started on the on-chip system of the data processing unit. The custom controller listens to and collects the status information of the data processing unit and sends the status information to an application programming interface (API) server. Upon receiving the status information, the API server creates an on-chip system resource instance and stores it in a preset database. The API server receives user requests to modify the on-chip system resource instance, modifies the on-chip system resource instance, and sends the before-and-after information to the custom controller. The custom controller performs corresponding operations based on the before-and-after information. This invention, by registering on-chip system resource instances in Kubernetes to associate them with the physical resources of the on-chip system, and by responding to on-chip system resource instance update events in the cluster based on the custom controller running on the on-chip system, allows users to control the physical resources of the corresponding on-chip system by manipulating the spec field of the Kubernetes on-chip system resource instance. Furthermore, a custom controller running on the system-on-chip periodically collects the status information of this data processing unit and updates the status field of the corresponding system-on-chip resource instance. Users can retrieve information about the corresponding physical system-on-chip by querying the system-on-chip resource instance. This enables the management and monitoring of physical resources within the orchestration system, providing a solution for the further use of the data processing unit in large-scale server clusters.

[0034] Additional advantages, objects, and features of the invention will be set forth in part in the description which follows, and will also become apparent in part to those skilled in the art upon studying the description, or may be learned by practice of the invention. The objects and other advantages of the invention can be realized and obtained by means of the structures specifically pointed out in the description and drawings.

[0035] Those skilled in the art will understand that the objectives and advantages achievable with the present invention are not limited to those specifically described above, and that the above and other objectives achievable with the present invention will become clearer from the following detailed description. Attached Figure Description

[0036] The accompanying drawings, which are included to provide a further understanding of the invention and form part of this application, are not intended to limit the scope of the invention. In the drawings:

[0037] Figure 1 This is a schematic diagram illustrating the steps of a Kubernetes-based DPU on-chip system management method in one embodiment of the present invention.

[0038] Figure 2 This is a schematic diagram of an instance format of a system-on-a-chip resource in one embodiment of the present invention.

[0039] Figure 3 This is a schematic diagram of the process for creating a system-on-a-chip resource instance in one embodiment of the present invention.

[0040] Figure 4 This is a schematic diagram of the process of controlling the corresponding physical resources of the system on-chip by operating on-chip resource instances in one embodiment of the present invention.

[0041] Figure 5 This is a schematic diagram of the process of obtaining the corresponding entity on-chip system node resources and operating status through an on-chip system resource instance in one embodiment of the present invention. Detailed Implementation

[0042] To make the objectives, technical solutions, and advantages of this invention clearer, the invention will be further described in detail below with reference to the embodiments and accompanying drawings. Here, the illustrative embodiments and descriptions of this invention are used to explain the invention, but are not intended to limit the invention.

[0043] It should also be noted that, in order to avoid obscuring the invention with unnecessary details, only the structures and / or processing steps closely related to the solution according to the invention are shown in the accompanying drawings, while other details that are not closely related to the invention are omitted.

[0044] It should be emphasized that the term "including / comprises" as used herein refers to the presence of a feature, element, step, or component, but does not exclude the presence or addition of one or more other features, elements, steps, or components.

[0045] It should also be noted that, unless otherwise specified, the term "connection" in this article can refer not only to a direct connection, but also to an indirect connection involving an intermediary.

[0046] In the following description, embodiments of the invention will be illustrated with reference to the accompanying drawings. In the drawings, the same reference numerals represent the same or similar parts, or the same or similar steps.

[0047] It should be emphasized here that the step markers mentioned below are not a limitation on the order of the steps, but should be understood as meaning that the steps can be executed in the order mentioned in the embodiments, or in a different order than in the embodiments, or several steps can be executed simultaneously.

[0048] To address the lack of direct monitoring and management mechanisms for physical resources in existing mainstream cluster orchestration systems, which leads to the inability to detect data processing unit (DPU) failures in a timely manner and thus affect the normal operation and maintenance of the cluster, this invention proposes a Kubernetes-based on-chip DPU system management method. Figure 1 As shown, the method includes the following steps S101 to S104:

[0049] Step S101: Create a custom resource definition to describe the on-chip system specifications and behavior of the data processing unit, and register the custom resource definition in the Kubernetes cluster.

[0050] Step S102: Create and start a custom controller on the system-on-a-chip of the data processing unit; listen to and collect the status information of the system-on-a-chip of the data processing unit through the custom controller, and send the status information of the system-on-a-chip to the application programming interface server of the Kubernetes cluster.

[0051] Step S103: After receiving the status information of the system on the chip, the application programming interface server creates a system on the chip resource instance and stores it in the preset database.

[0052] Step S104: The application programming interface server receives a user's request to modify the on-chip system resource instance, modifies the on-chip system resource instance, and sends the information before and after modification to the custom controller; the custom controller performs corresponding operations based on the information before and after modification.

[0053] In step S101, a custom resource definition (CRD) is created, defining the type, application programming interface version, resource fields, status fields, etc., and the resource is registered with the Kubernetes cluster so that it can be understood and managed by the Kubernetes cluster.

[0054] In some embodiments, such as Figure 2 As shown, an on-chip system resource instance includes four parts: metadata, specifications, status, and fault conditions. Specifically:

[0055] Meta data is used to name the custom resource definition to distinguish different resource instances. For example, it is named soc1. At the same time, the type of the custom resource definition can also be set. In this invention, it is set to the system on-chip (SoC) type.

[0056] The specification (spec) allows users to set and modify the specification section, such as by setting off the unloading function, uplink direction network, etc., and associating custom resource definitions with the corresponding physical on-chip system.

[0057] Status: This section cannot be set or modified by the user. It displays the status information of the data processing unit as perceived by the custom controller running on the data processing unit on-chip system.

[0058] The fault condition is used to collect information on faults that the on-chip system of the data processing unit is currently encountering that cannot be automatically recovered from.

[0059] In some embodiments, after a custom resource definition is created and registered, it is stored in the etcd database of the Kubernetes cluster's control plane component (master) as part of the Kubernetes cluster's state.

[0060] In step S102, a custom controller is created on the on-chip system of the data processing unit. This custom controller is used to sense and collect the status information of the on-chip system of this data processing unit. The status information mainly includes connectivity, memory and CPU resource utilization, etc. After collection, the status information is sent to the Kubernetes cluster's Application Programming Interface (API) server. The API server is one of the core components of the Kubernetes architecture, providing a RESTful API interface for interacting with and managing the cluster status. This API is the main entry point for the Kubernetes system; all operations, such as creating, reading, updating, and deleting resources, are performed through this API.

[0061] In some embodiments, the collected system-on-chip (SoC) status information is assembled according to a preset custom resource definition (CRD) table to generate SoC assembly information. A resource creation request is made, i.e., a new resource instance is created to store the SoC assembly information, and the newly created resource instance, i.e., the SoC assembly information, is sent to the API server via an application programming interface (API).

[0062] In step S103, after receiving the status information of the system on the chip, the application programming interface server creates a system on the chip resource instance and stores it in a preset database. For example, the preset database is the etcd database.

[0063] like Figure 3As shown, based on the settings in steps S101 to S103, users can access the logical resource through the Kubernetes cluster to obtain the corresponding physical data processing unit on-chip system.

[0064] In step S104, as Figure 4 As shown, based on the settings in steps S101 to S103, the corresponding physical data processing unit on-chip system node can be controlled by operating the on-chip system resource instance. Specifically:

[0065] A user, operating an on-chip system resource instance (using soc1 as an example), sends a request to the Kubernetes cluster's application programming interface (API) server to modify soc1. The API server modifies the resources of soc1 stored in a preset database (e.g., the etcd database in the example), simultaneously triggering an update event for the soc1 resource instance. This update event carries information about the soc1 resource instance before and after the modification. This update event is then sent to a custom controller, which runs on the physical on-chip system and continuously listens for the soc1 resource instance through the API server. The custom controller performs the corresponding operation based on the received information about the modification.

[0066] In some embodiments, the custom controller determines that the soc1 resource instance is the on-chip system resource instance of the Kubernetes cluster corresponding to the on-chip system of this data processing unit based on the metadata information in the before-and-after modification information of the soc1 resource instance carried in the update event. After confirmation, the custom controller performs the corresponding operation according to the modified fields in the on-chip system resource instance specification (spec) section.

[0067] In some embodiments, such as Figure 5 As shown, based on the above steps S101 to S104, the method provided by the present invention can also be used to obtain the corresponding physical data processing unit on-chip system node resources and operating status through on-chip system resource instances, including:

[0068] The custom controller senses the status information of the on-chip system of the data processing unit at preset time intervals and organizes the status information into a format that conforms to the on-chip system resource status field format defined in the custom resource definition. For example, the status information includes the on-chip system's memory and CPU usage, physical device function interfaces, data forwarding plane, uplink connectivity, and other information.

[0069] The custom controller sends an update (patch) request to the application programming interface server for the status field of the on-chip system resource instance, and updates the status information of the on-chip system resource instance soc1 in the preset database (etcd database) with the sensed status information.

[0070] Corresponding to the Kubernetes-based DPU on-chip system management method, the present invention also provides a Kubernetes-based DPU on-chip system management device, which includes:

[0071] The custom resource definition creation module is used to create on-chip system resource instances of data processing units in a Kubernetes cluster to describe the specifications and behavior of the on-chip system and to build the association between on-chip system resource instances and physical on-chip systems.

[0072] The management module is used when a user initiates a request to modify the on-chip system resource instance. The Kubernetes cluster's application programming interface server modifies the on-chip system resource instance and sends the information before and after the modification to the custom controller running on the on-chip system. The custom controller then performs the corresponding operation based on the information before and after the modification.

[0073] The present invention also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the steps of a Kubernetes-based DPU on-chip system management method.

[0074] Corresponding to the above method, the present invention also provides an apparatus comprising a computer device, the computer device including a processor and a memory, the memory storing computer instructions, the processor executing the computer instructions stored in the memory, and when the computer instructions are executed by the processor, the apparatus performs the steps of the method as described above.

[0075] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the steps of the aforementioned edge computing server deployment method. The computer-readable storage medium can be a tangible storage medium, such as random access memory (RAM), main memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, floppy disks, hard disks, removable storage disks, CD-ROMs, or any other form of storage medium known in the art.

[0076] In summary, this invention provides a Kubernetes-based DPU on-chip system management method and apparatus. The method involves creating a custom resource definition for an on-chip system type and registering this custom resource definition in the Kubernetes cluster; creating and starting a custom controller on the on-chip system of the data processing unit; listening to and collecting the status information of the data processing unit through the custom controller and sending the status information to an application programming interface (API) server; receiving the status information, the API server creates an on-chip system resource instance and stores it in a preset database; the API server receives a user request to modify the on-chip system resource instance, modifies the on-chip system resource instance, and sends the before-and-after information to the custom controller; the custom controller performs corresponding operations based on the before-and-after information. The method provided by this invention, by registering on-chip system resource instances in Kubernetes to associate the physical resources of the on-chip system of an entity, and by responding to on-chip system resource instance update events in the cluster based on the custom controller running on the on-chip system, allows users to control the physical resources of the corresponding on-chip system by manipulating the spec field of the Kubernetes on-chip system resource instance. Furthermore, a custom controller running on the system-on-chip periodically collects the status information of this data processing unit and updates the status field of the corresponding system-on-chip resource instance. Users can retrieve information about the corresponding physical system-on-chip by querying the system-on-chip resource instance. This enables the management and monitoring of physical resources within the orchestration system, providing a solution for the further use of the data processing unit in large-scale server clusters.

[0077] Those skilled in the art will understand that the exemplary components, systems, and methods described in conjunction with the embodiments disclosed herein can be implemented in hardware, software, or a combination of both. Whether implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this invention. When implemented in hardware, it can be, for example, electronic circuits, application-specific integrated circuits (ASICs), appropriate firmware, plug-ins, function cards, etc. When implemented in software, the elements of this invention are programs or code segments used to perform the desired tasks. The programs or code segments can be stored in a machine-readable medium or transmitted over a transmission medium or communication link via data signals carried in a carrier wave.

[0078] It should be clarified that the present invention is not limited to the specific configurations and processes described above and shown in the figures. For the sake of brevity, detailed descriptions of known methods are omitted here. In the above embodiments, several specific steps are described and shown as examples. However, the method process of the present invention is not limited to the specific steps described and shown. Those skilled in the art can make various changes, modifications, and additions, or change the order of steps, after understanding the spirit of the present invention.

[0079] In this invention, features described and / or illustrated for one embodiment may be used in the same or similar manner in one or more other embodiments, and / or combined with or in place of features of other embodiments.

[0080] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. For those skilled in the art, various modifications and variations of the embodiments of the present invention are possible. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

Claims

1. A Kubernetes-based DPU system-on-chip management method, characterized in that, The method comprises the following steps: creating a custom resource definition for describing the specification and behavior of the data processing unit system on a chip, and registering the custom resource definition in a Kubernetes cluster; storing the custom resource definition in an etcd database of a control plane component of the Kubernetes cluster as part of the state of the Kubernetes cluster; the custom resource definition comprises metadata, specification, state and fault condition, wherein the name of the custom resource definition is set in the metadata, and the category of the custom resource definition is set as a system on a chip; in the specification, the custom resource definition is associated to a physical system on a chip by setting offloading function and uplink network; creating and starting a custom controller on the system on a chip of the data processing unit; the custom controller is used for periodically listening to and collecting state information of the system on a chip of the data processing unit, and the state information is arranged in a form conforming to the format of the system on a chip resource state field in the custom resource definition; and the arranged state information of the system on a chip is sent to an application programming interface server of the Kubernetes cluster; after the application programming interface server receives the state information of the system on a chip, a system on a chip resource instance is created based on the custom resource definition and stored in a preset database; the application programming interface server receives a request initiated by a user for modifying the system on a chip resource instance, modifies the system on a chip resource instance, and sends the information before and after the modification to the custom controller; the custom controller performs corresponding operations according to the information before and after the modification.

2. The Kubernetes-based DPU system-on-chip management method of claim 1, wherein, sending the state information of the system on a chip to the application programming interface server of the Kubernetes cluster comprises: assembling the state information of the system on a chip according to a preset custom resource definition format to generate system on a chip assembly information; creating a new resource instance for storing the system on a chip assembly information; and sending the newly created resource instance to the application programming interface server through the application programming interface of the Kubernetes cluster.

3. The Kubernetes-based DPU system-on-chip management method of claim 1, wherein, the application programming interface server modifies the system on a chip resource instance, and sends the information before and after the modification to the custom controller, which comprises: the application programming interface server modifies the system on a chip resource instance, triggers an update event of the system on a chip resource instance, and carries the information before and after the modification of the system on a chip resource instance in the update event; and the update event is sent to the custom controller through the application programming interface.

4. The Kubernetes-based DPU system-on-chip management method of claim 1, wherein, the custom controller performs corresponding operations according to the information before and after the modification, which comprises: the custom controller determines, according to the metadata information in the information before and after the modification, that the information before and after the modification is related to the system on a chip resource instance of the Kubernetes cluster corresponding to the system on a chip of the data processing unit. The custom controller performs corresponding operations according to the field modification content of the SoC resource instance specification part.

5. The Kubernetes-based DPU system-on-chip management method of claim 1, wherein, The state information of the arranged SoC is sent to an application programming interface server of the Kubernetes cluster, including: The custom controller sends an update request for the SoC resource instance state field to the application programming interface server, and updates the perceived state information to the state information of the SoC resource instance in the preset database.

6. A Kubernetes-based DPU system-on-chip management apparatus, comprising: The device comprises: A custom resource definition creation module is configured to create a custom resource definition for describing the specification and behavior of a data processing unit SoC, and register the custom resource definition in a Kubernetes cluster; wherein the custom resource definition is stored in an etcd database of a control plane component of the Kubernetes cluster as part of the state of the Kubernetes cluster; the custom resource definition comprises metadata, specification, state and fault condition, the name of the custom resource definition is set in the metadata, and the type of the custom resource definition is set as SoC; in the specification, the custom resource definition is associated to a physical SoC by setting offloading function and uplink network; A management module is configured to create and start a custom controller on the data processing unit SoC; the custom controller is configured to listen to and collect state information of the data processing unit SoC at regular intervals, and arrange the state information into a format conforming to the SoC resource state field format in the custom resource definition; the state information of the arranged SoC is sent to an application programming interface server of the Kubernetes cluster, so that the application programming interface server creates a SoC resource instance based on the custom resource definition and stores it in a preset database; and when the application programming interface server receives a request initiated by a user to modify the SoC resource instance, the SoC resource instance is modified, and the information before and after the modification is sent to the custom controller running on the SoC, and the custom controller performs corresponding operations according to the information before and after the modification.

7. A computer-readable storage medium having stored thereon a computer program, characterized in that The program is executed by the processor to implement the steps of the method of any one of claims 1 to 5.

8. A computer program product comprising computer programs / instructions, characterized in that, The computer program / instruction is executed by the processor to implement the steps of the method of any one of claims 1 to 5.

Images