WO2023019712A1

WO2023019712A1 - Zlib compression algorithm-based cloud computing resource manager communication delay optimization method

Info

Publication number: WO2023019712A1
Application number: PCT/CN2021/124403
Authority: WO
Inventors: 黄世鑫; 陈超; 喻之斌; 王峥; 杨永魁
Original assignee: 中国科学院深圳先进技术研究院
Priority date: 2021-08-16
Filing date: 2021-10-18
Publication date: 2023-02-23
Also published as: CN115914380A

Abstract

Disclosed is a Zlib compression algorithm-based cloud computing resource manager communication delay optimization method. A cloud computing manager is used for managing a distributed computing framework comprising a master node and a plurality of corresponding slave nodes. The method comprises: the slave nodes serialize, by using a protocol data interchange format tool library Protobuf, a message to be sent, compress the serialized message at a network layer by using a Zlib algorithm and then pass the compressed message to the master node; and the master node decompresses the received message according to a length identifier of the compressed message. The present invention realizes effective communication delay optimization during high-traffic concurrent message passing under a limited network bandwidth.

Description

Communication Delay Optimization Method for Cloud Computing Resource Manager Based on Zlib Compression Algorithm

technical field

The present invention relates to the technical field of communication, and more specifically, relates to a communication delay optimization method of a cloud computing resource manager based on a Zlib compression algorithm.

Background technique

In recent years, cloud computing technology has developed rapidly. From the earliest physical machines to the virtualization era, to the latest containerization and cloud-native technologies, more and more companies use large-scale cloud computing systems to deploy commercial applications, which brings huge business value. Taking Apache Mesos as an example, it is a cloud computing resource manager whose main goal is to help developers manage fine-grained cluster resource scheduling and allocation of different frameworks. Apache Mesos is a distributed cluster resource management framework that abstracts computing resources such as CPU, memory, network bandwidth, and even hardware storage into a centralized resource pool, and then provides APIs for different computing frameworks (such as spark, hadoop, and MPI). And Apache Mesos supports fine-grained resource sharing across applications. Therefore, Mesos can significantly improve cluster resource utilization, increase CPU utilization, and reduce memory and I/O overhead. In addition, Mesos has excellent scalability and can achieve resource isolation.

When Apache Mesos performs network communication between the master node and the slave node, its communication delay is affected by many factors, such as scheduling algorithm strategy, underlying API for communication, and hardware resource bandwidth. In the scenario where a large number (such as 10,000) slave nodes send messages to the master node at the same time, high communication delays will occur. This seriously affects the performance of the master node in Mesos, and more seriously, due to the limitation of network bandwidth and disk resources, this large-scale traffic transmission may cause the master node to fail. The underlying communication of Mesos uses the Libprocess communication protocol that supports Protobuf. Although Libprocess is an efficient message passing programming model, in this high-traffic message transmission scenario, the communication delay is still high and cannot meet the needs of developers.

Studies have shown that Mesos mainly focuses on computing resources and storage resources (CPU and memory), while ignoring network management, but in fact effective network resource management is the key to optimizing performance. Existing methods focus on providing more appropriate resources or better resource allocation for jobs by designing resource allocation algorithms or scheduling algorithms, and these algorithms are usually too complex, and only increase the utilization of CPU and memory, and rarely consider Communication optimization at the network level, however, is insufficient to optimize the CPU and memory utilization of the Mesos cluster only by designing new resource scheduling and allocation algorithms, which may lead to Mesos performance bottlenecks.

Contents of the invention

The object of the present invention is to overcome above-mentioned defective of prior art, provide a kind of cloud computing resource manager communication delay optimization method based on Zlib compression algorithm, this cloud computing manager is used for managing the distributed network that comprises master node and multiple corresponding slave nodes Computing framework, the method includes the following steps: for the message to be sent, the slave node serializes the message using the protocol data exchange format tool library Protobuf and transmits it to the master node after compressing it using the Zlib algorithm at the network layer; the master node compresses the received message , decompress according to the length identifier of the compressed message.

Compared with the prior art, the present invention has the advantage that for scenarios with different message sizes and different heartbeat time intervals, the Zlib algorithm is used to compress messages, and the communication delay optimization on the network level of the cloud computing resource manager is realized. Especially for the special scenario of concurrent transmission of high-traffic messages, effective delay optimization has been carried out at the network communication level.

Other features of the present invention and advantages thereof will become apparent from the following detailed description of exemplary embodiments of the present invention with reference to the accompanying drawings.

Description of drawings

The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain the principles of the invention.

Fig. 1 is the flow chart of the cloud computing resource manager communication delay optimization method based on Zlib compression algorithm according to an embodiment of the present invention;

Fig. 2 is after using Zlib compression algorithm according to an embodiment of the present invention, the schematic diagram of the time that slave node and master node compress a message;

Fig. 3 is an effect diagram of communication delay optimization according to an embodiment of the present invention;

Fig. 4 is an effect diagram of an optimized ratio according to an embodiment of the present invention.

Detailed ways

Various exemplary embodiments of the present invention will now be described in detail with reference to the accompanying drawings. It should be noted that the relative arrangements of components and steps, numerical expressions and numerical values set forth in these embodiments do not limit the scope of the present invention unless specifically stated otherwise.

The following description of at least one exemplary embodiment is merely illustrative in nature and in no way taken as limiting the invention, its application or uses.

Techniques, methods and devices known to those of ordinary skill in the relevant art may not be discussed in detail, but where appropriate, such techniques, methods and devices should be considered part of the description.

In all examples shown and discussed herein, any specific values should be construed as exemplary only, and not as limitations. Therefore, other instances of the exemplary embodiment may have different values.

It should be noted that like numerals and letters denote like items in the following figures, therefore, once an item is defined in one figure, it does not require further discussion in subsequent figures.

The Zlib-based communication delay optimization method provided by the present invention can be used for cloud computing resource managers, including Mesos-based frameworks, YARN frameworks, K8s frameworks or other types of cloud computing frameworks. These frameworks usually adopt a distributed architecture, including master nodes (master) and multiple corresponding slave nodes (slave). For clarity, the following uses Mesos as an example to illustrate and verify by building a simulation environment.

Referring to Fig. 1, the provided method for optimizing the communication delay of the cloud computing resource manager based on the Zlib compression algorithm includes the following steps.

Step S110, constructing a high-traffic message concurrent delivery scenario between the slave node and the master node.

For example, in the experimental environment, use two physical servers to simulate the scenario where 10,000 slave nodes send messages to Mesos nodes at the same time, one of the servers with better performance acts as the master node, and the other acts as the slave node. Limit, start 100 slave processes on the slave node, and set each slave process to send 100 messages. Since each slave process may not start successfully at the same time, the timing of sending messages is likely to be different. So set the timer code to ensure that all slave processes send 100 messages at the same time as much as possible. In this way, a scenario of concurrent delivery of high-traffic messages on Mesos can be simulated, that is, a communication scenario in which 10,000 slave nodes send messages to the Master at the same time.

Step S120, acquiring the communication delay in the scenario of concurrent delivery of high-traffic messages and analyzing the influencing factors.

In order to understand the factors that affect the communication delay, the total communication delay when 10,000 slave nodes on Mesos send messages to the master at the same time is collected. For example, the total communication time is preset to 20s. The communication delay is defined as follows: within each heartbeat time interval, from the time the master node receives the first message sent by the slave node to the time the master node finishes processing the last message sent by the slave node, the time difference in between is The communication delay of the round heartbeat time interval, by accumulating the delay of each round of heartbeat time interval, the final total communication delay can be obtained. In one embodiment, the Log(INFO) statement is used to print out the time stamp, the heartbeat count, the slave process ID and the message ID, and these four attributes can uniquely determine a message. Then, export important information from the log and process it through python. The difference between the minimum time stamp and the maximum time stamp in each round of heartbeat time interval is the communication delay of each round of heartbeat time interval. The total communication delay in this scenario can be calculated by accumulating the communication delay of each heartbeat interval. After analysis, in the scenario of high-traffic message concurrent delivery, two important factors affecting Mesos communication delay are heartbeat interval and message size.

Step S130, improving the message delivery mechanism of the network layer, so that the message to be sent is compressed at the slave node, and the message is decompressed at the master node.

In one embodiment, the compression function provided by the Zlib.h library is used for message compression. For example, by changing the data type defined by Protobuf and the API provided by Zlib, the message compression of the slave node before message delivery and the message decompression of the master node are performed, and then the communication delay after using the Zlib compression algorithm and the default communication delay are compared , to calculate its optimization rate.

Specifically, first change the string (character string) type of Protobuf to bytes (bytes) type, and Protobuf adopts the serialization method of binary bytes. Because the Zlib compression algorithm compresses binary data. At the same time, a field of type uint64 is added to the message to store the length of the message compressed by the slave process using the Zlib algorithm. Since the master process needs to know the length of the compressed message when decompressing, compared to the length of the compressed message predicted by the master node, it is decompressed based on the length of the compressed message clearly indicated to improve the decompression efficiency and success rate of decompression. Finally, the compression function compress() and decompression function uncompress() defined in the zlib.h library are used to compress 10,000 messages in the slave process and decompress 10,000 messages in the master process before transmitting the messages.

In order to improve the effect of message compression and decompression, in a preferred embodiment, it is judged whether to trigger the message compression mechanism according to one or more of the number of messages to be sent by the slave node, the message length and the heartbeat time interval. For example, when the number of messages to be sent by the slave node is greater than a predetermined threshold, or/and the message size is greater than a predetermined threshold, the message compression mechanism is started.

In order to further verify the effect of the present invention, experiments were carried out. Specifically, create a simulation environment, such as a scene where 10,000 slave nodes send messages to the master node at the same time, and for different message sizes, show the message size after using the Zlib compression algorithm, and calculate the corresponding compression ratio. Furthermore, to understand the performance of the Zlib compression algorithm, the time it takes for the slave process to compress a message and the time for the master process to decompress a message is shown. After using the Zlib compression algorithm, collect the optimized total communication delay and compare it with the default total communication delay to calculate the time saved by its optimization and the corresponding optimization ratio. The experimental results are shown in Table 1 below.

Table 1: Experimental results

It can be seen from Table 1 that the compression ratio increases with the increase of the message size, that is, the larger the message, the better the compression effect. Therefore, after using the Zlib compression algorithm, the compression effect is significantly improved.

Figure 2 shows the time it takes for the slave node to compress a message and the time it takes for the master node to decompress a message after using the Zlib compression algorithm, where the horizontal axis represents the message size (KB). It can be seen from Figure 2 that as the message size increases, the corresponding compression time and decompression time both increase. But when the message size is 100KB, the maximum compression time is only 4.4ms, and the maximum decompression time is only 1.5ms, such a short time overhead is almost negligible.

The vertical axis of Fig. 3 represents the time saved by optimization (that is, the communication delay before optimization minus the communication delay after optimization), and the horizontal axis represents the heartbeat time interval (s). It can be clearly seen from Figure 3 that the communication time is saved as the heartbeat time interval decreases. In the present invention, when the message size is 100KB and the heartbeat time interval is 2s, the time saving for communication delay reaches the maximum optimal value of 54.6 seconds.

The vertical axis of Figure 4 represents the optimization ratio (the communication delay before optimization minus the communication delay after optimization, and finally divided by the communication delay before optimization, the larger the value, the better the optimization effect, and the theoretical maximum value is 1), and the horizontal axis The axis represents the heartbeat time interval (s). When the message size is 20KB, 40KB, 60KB, 80KB, and 100KB, the corresponding average delay optimization rates are 23.54%, 37.28%, 43.85%, 47.18%, and 52.19%. When the message size is 100KB, the maximum optimization ratio reaches 56.34%.

In summary, the existing optimization algorithm does not involve the technical problem of tuning the underlying communication protocol of Mesos. The present invention uses the Zlib compression algorithm to compress the transmitted data without using complex scheduling algorithms or resource allocation algorithms. The message is compressed and decompressed after receiving the message, which realizes effective communication delay optimization during high-traffic concurrent message delivery under limited network bandwidth. Experimental results show that the present invention realizes the communication delay optimization of Mesos, and the optimization performance is significantly better than that of the prior art. By using the Zlib compression algorithm, the highest optimization rate reaches 56.34%.

The present invention can be a system, method and/or computer program product. A computer program product may include a computer readable storage medium having computer readable program instructions thereon for causing a processor to implement various aspects of the present invention.

A computer readable storage medium may be a tangible device that can retain and store instructions for use by an instruction execution device. A computer readable storage medium may be, for example, but is not limited to, an electrical storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of computer-readable storage media include: portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM), or flash memory), static random access memory (SRAM), compact disc read only memory (CD-ROM), digital versatile disc (DVD), memory stick, floppy disk, mechanically encoded device, such as a printer with instructions stored thereon A hole card or a raised structure in a groove, and any suitable combination of the above. As used herein, computer-readable storage media are not to be construed as transient signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides or other transmission media (e.g., pulses of light through fiber optic cables), or transmitted electrical signals.

Computer-readable program instructions described herein may be downloaded from a computer-readable storage medium to a respective computing/processing device, or downloaded to an external computer or external storage device over a network, such as the Internet, a local area network, a wide area network, and/or a wireless network. The network may include copper transmission cables, fiber optic transmission, wireless transmission, routers, firewalls, switches, gateway computers, and/or edge servers. A network adapter card or a network interface in each computing/processing device receives computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in each computing/processing device .

Computer program instructions for carrying out operations of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, state setting data, or Source or object code written in any combination, including object-oriented programming languages—such as Smalltalk, C++, Python, etc., and conventional procedural programming languages—such as the “C” language or similar programming languages. Computer readable program instructions may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer, or entirely on the remote computer or server implement. In cases involving a remote computer, the remote computer can be connected to the user computer through any kind of network, including a local area network (LAN) or a wide area network (WAN), or it can be connected to an external computer (such as via the Internet using an Internet service provider). connect). In some embodiments, an electronic circuit, such as a programmable logic circuit, field programmable gate array (FPGA), or programmable logic array (PLA), can be customized by utilizing state information of computer-readable program instructions, which can Various aspects of the invention are implemented by executing computer readable program instructions.

Aspects of the present invention are described herein with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the invention. It should be understood that each block of the flowcharts and/or block diagrams, and combinations of blocks in the flowcharts and/or block diagrams, can be implemented by computer-readable program instructions.

These computer-readable program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine such that when executed by the processor of the computer or other programmable data processing apparatus , producing an apparatus for realizing the functions/actions specified in one or more blocks in the flowchart and/or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium, and these instructions cause computers, programmable data processing devices and/or other devices to work in a specific way, so that the computer-readable medium storing instructions includes An article of manufacture comprising instructions for implementing various aspects of the functions/acts specified in one or more blocks in flowcharts and/or block diagrams.

It is also possible to load computer-readable program instructions into a computer, other programmable data processing device, or other equipment, so that a series of operational steps are performed on the computer, other programmable data processing device, or other equipment to produce a computer-implemented process , so that instructions executed on computers, other programmable data processing devices, or other devices implement the functions/actions specified in one or more blocks in the flowcharts and/or block diagrams.

The flowchart and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, a portion of a program segment, or an instruction that includes one or more Executable instructions. In some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks in succession may, in fact, be executed substantially concurrently, or they may sometimes be executed in the reverse order, depending upon the functionality involved. It should also be noted that each block of the block diagrams and/or flowchart illustrations, and combinations of blocks in the block diagrams and/or flowchart illustrations, can be implemented by a dedicated hardware-based system that performs the specified function or action , or may be implemented by a combination of dedicated hardware and computer instructions. It is well known to those skilled in the art that implementation by means of hardware, implementation by means of software, and implementation by a combination of software and hardware are all equivalent.

Having described various embodiments of the present invention, the foregoing description is exemplary, not exhaustive, and is not limited to the disclosed embodiments. Many modifications and alterations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the described embodiments. The terminology used herein is chosen to best explain the principle of each embodiment, practical application or technical improvement in the market, or to enable other ordinary skilled in the art to understand each embodiment disclosed herein. The scope of the invention is defined by the appended claims.

Claims

A cloud computing resource manager communication delay optimization method based on Zlib compression algorithm, the cloud computing manager is used to manage a distributed computing framework comprising a master node and a plurality of corresponding slave nodes, the method comprises the following steps:

For the message to be sent, the slave node uses the protocol data exchange format tool library Protobuf to serialize and compress it using the Zlib algorithm at the network layer and then pass it to the master node;

The master node decompresses the received message according to the length identifier of the compressed message.
The method according to claim 1, wherein, before compressing the message, the string type of the protocol data exchange format tool library Protobuf is modified to a byte type, and a field of type uint64 is added in the message for storing the compression of the slave node The length of the message.
The method according to claim 1, further comprising counting the total communication delay of message delivery between the slave node and the master node according to the following steps:

In each round of heartbeat time interval, from the time when the master node receives the first message sent by the slave node to the end when the master node processes the last message sent by the slave node, the time difference is used as the communication delay of each round of heartbeat time interval;

Accumulate the delay of each heartbeat time interval as the final total communication delay.
The method according to claim 3, wherein, in the process of counting the total communication delay, a message is uniquely determined by obtaining a time stamp, a heartbeat count, a slave node process ID and a message ID.
The method according to claim 4, wherein, the timestamp of each message is printed by the Log (INFO) statement, the heartbeat count, the slave node process ID and the message ID.
The method according to claim 1, wherein the slave node invokes the compression function defined in the zlib.h library to compress the message, and the master node decompresses the message by calling the decompression function.
The method according to claim 1, wherein the cloud computing resource manager is used in a framework based on Mesos, a YARN framework or a K8s framework.
The method according to claim 1, wherein it is judged whether to compress the message and deliver it according to the number of messages to be sent by the slave node, the message size or the heartbeat time interval.
A computer-readable storage medium, on which a computer program is stored, wherein, when the program is executed by a processor, the steps of the method according to any one of claims 1 to 8 are realized.
A computer device comprising a memory and a processor, wherein a computer program capable of running on the processor is stored on the memory, wherein any one of claims 1 to 8 is implemented when the processor executes the program The steps of the method described in the item.