CN111917666A - Data frame preemptive cache management method based on service level agreement - Google Patents

Abstract

The invention discloses a data frame preemptive cache management method based on a service level agreement, which mainly solves the problems that the prior art does not consider the QoS of users with high service levels, and the high-priority data has a high frame loss rate and a low utilization rate of cache space. . The scheme is: 1) Set the queue threshold and the minimum threshold of each priority based on the service level agreement, and initialize the cache management parameters; 2) When a data frame arrives in the cache, judge whether it is necessary to discard the data frame or other stored data frames, and execute 3), if no data frame arrives, end the service; 3) For the data frame that does not need to be discarded, enter it into the buffer space, and return 2); for the data frame that needs to be discarded, according to the queue threshold set by the service level agreement, discarding meets the After the conditional data frame, return 2). The invention can ensure the QoS of users with high service levels, reduce the frame loss rate of high-priority data frames, and improve the utilization rate of cache space, and can be used for switching equipment in star networks.

Description

Data frame preemptive cache management method based on service level agreement

technical field

The invention belongs to the technical field of communication, and further relates to a data frame queue buffer management method, which can be used for switching equipment in a star network.

Background technique

In local area networks and access networks based on shared media, a star network topology is often used, which is usually composed of a central node and several user nodes. In this kind of network, two-way data transmission can be performed between the central node and each user node, and each user node needs to be forwarded by the central node for data transmission. Therefore, the central node needs to manage and coordinate the data frames sent to different user nodes, and further requires the central node to effectively use the buffer space to ensure that the data frames sent to different nodes can be effectively queued.

In an actual network system, various network resources are limited. In order to make full use of network resources, service providers often provide different service levels, so different user nodes enjoy different services. Therefore, when the network switching equipment performs cache management, it is necessary for the central node to consider the QoS of high service level users as much as possible, the utilization rate of cache space, and the reduction of the frame loss rate of data frames when the data frames arrive in the cache. Ensure the frame loss rate of high-priority data frames as much as possible. Currently, the most used cache management methods mainly include static threshold strategy ST, dynamic threshold strategy DT, Push-Out strategy PO and multi-priority strategy, among which:

The static threshold strategy ST includes a fully shared mode, a fully shared mode, and a partially shared and partially shared mode.

缓存大小，当某队列的固定缓存空间占满之后，再入队的数据帧就需要被丢弃，这种缓存管理方式能很好的保证用户的公平性，但是不能保证高服等级用户的服务质量而且缓存利用率低。The full-occupancy method is to divide the entire cache space into n equal parts according to the number of user queues, and each queue occupies a fixed

Cache size. When the fixed cache space of a queue is full, the data frames that are re-queued need to be discarded. This cache management method can well guarantee the fairness of users, but cannot guarantee the service quality of high-level users. And the cache utilization is low.

This fully shared method allows all user queues to share the entire cache space, and only when the cache space is full will the arriving data frames be discarded. This cache management method makes full use of the cache space and improves the utilization of the cache space, but completely The allocation of buffer space to the amount of data cannot ensure that users with high service levels enjoy due QoS, and cannot guarantee a lower packet loss rate for high-priority data.

This part-shared part-occupancy method divides the cache space into a shared area and an occupied area, and evenly distributes the occupied area to each user queue to ensure the lower limit of the cache space of each queue. When a queue has a large amount of data and When the corresponding partition queue space is filled, data frames can be stored in the shared buffer area, and the arriving data frames will not be discarded until the shared buffer area is full. This method ensures the fairness of users and reduces data accordingly. frame packet loss rate, but this method does not guarantee that users with high service levels can enjoy a lower packet loss rate, nor does it consider the packet loss rate of high-priority data frames, and cannot guarantee the buffer space in the case of bursty services. utilization.

The dynamic threshold policy DT means that the queue length threshold at any time is proportional to the size of the unused cache in cache management. The typical dynamic threshold strategy and the best DT algorithm are representative of dynamic threshold strategy.

The idea of this typical dynamic threshold strategy is to set the independent queue threshold of each queue in queue management in proportion to the size of the currently unused buffer space. Only when the actual length of the queue exceeds the calculated queue threshold, the data frames that arrive in the buffer will be processed. Discard, although this cache management strategy can ensure the cache space utilization in the case of sudden business, the dynamic threshold calculated by this strategy is only related to the entire cache space and does not consider the influence of the length of the queue itself, it is difficult to guarantee The quality of service for users with high service levels and the packet loss rate of high-priority data frames.

The optimal DT algorithm is based on the typical dynamic threshold strategy. The port queue threshold will change with the output service rate. The strategy itself does not require buffer reservation, and allows overloaded queues to occupy when the buffer is not full. More space and improved cache utilization compared to typical dynamic threshold policies. But it has the same drawbacks as the typical dynamic threshold strategy.

The Push-Out policy PO means that whenever the cache is not full, the data frame can be stored in the cache space. The most representative Push-Out strategies include delayed decision strategy DRP and drop-out DoD as required.

The DRP strategy does not decide whether to discard the packet until the buffer space is empty, and the discarded object is determined by the cache occupancy status or no priority; the DoD strategy discards the packet with the longest queue in the buffer when the buffer is full.

These two strategies have higher cache space utilization than the static threshold and dynamic threshold strategies, and also take into account the priority to varying degrees. However, these two strategies cannot provide guarantees for users with high service levels, and are only based on improving space utilization, which lacks certain practicability. Moreover, the idea of directly discarding the packet with the longest queue in the cache in the DoD strategy does not take into account the fairness among users.

The multi-priority strategy is proposed to provide QoS guarantees with different priorities for different types of service flows, and the most representative strategies are multi-priority optimal DT and pipeline interval strategy.

The multi-priority optimal DT is extended to the multi-priority case on the basis of the optimal DT strategy. It inherits the advantages of the optimal DT, that is, high cache utilization and low packet loss rate, and also compensates for the optimal DT. The DT strategy does not have the disadvantage of providing guarantees for priority.

The pipeline interval strategy divides the buffer space into different priority intervals. The transport stream that arrives first enters the last interval and has the highest priority. When the last interval is exhausted, it will enter other intervals. The output port can only take out packets from the last interval. After the interval has been transmitted, the lower priority interval is moved to the adjacent higher priority interval. This strategy guarantees the QoS of high-priority traffic well, but the cache utilization cannot be guaranteed very high.

The above two strategies both consider providing guarantees for priority, but neither consider how to provide QoS guarantees for users with high service levels, and the cache utilization of the pipeline interval strategy is not high.

SUMMARY OF THE INVENTION

The purpose of the present invention is to address the deficiencies of the above-mentioned existing methods and technologies, and propose a data frame preemptive cache management method based on a service level agreement, so as to ensure that users with high service levels can enjoy service quality with a lower packet loss rate, and It ensures that each user's high-priority queue has a high success rate of queuing, and at the same time improves the cache space utilization under different business conditions.

In order to achieve the above goals, the technical solutions of the present invention include the following:

(1) Initialize the cache management parameters:

(1a) Suppose there are k users Ni who need to provide cache management services, where _i ranges from 1 to k;

(1b) The total number of data frames that can be accommodated in the total buffer space is M, and the number of data frames that can be accommodated in real time is m;

(1c) Let the service level agreement SLA be the size of the bandwidth purchased by the user;

的条件，其中

是k个用户购买的带宽总和；(1d) Suppose the total bandwidth size is B, the bandwidth size purchased by user _{Ni is B i ,} and the sum of the bandwidth purchased by k users satisfies

conditions, where

is the sum of bandwidth purchased by k users;

(1e) _Suppose the data frame of user Ni is divided into three priority levels: high, medium and low, and all are stored in the user queue _Qi ;

(1f) Let the queue threshold M _i of the user queue Q _i be:

中优先级最低门限值L_{i_M}为：

低优先级最低门限值L_{i_L}为：

其中

为高中低优先级最低门限值之和占队列门限M_i的比例，且满足n≥1，a，b，c分别为高中低优先级最低门限值的比例，且满足a、b、c≥0；(1g) Let the high-priority minimum threshold value L _{i_H} of the user queue Q _i be:

The lowest threshold value L _{i_M} of the medium priority is:

The low priority minimum threshold value _{Li_L} is:

in

is the ratio of the sum of the minimum thresholds of high, medium and low priorities to the queue threshold Mi, and satisfies _n≥1 , a, b, and c are the proportions of the minimum thresholds of high, medium and low priorities, and satisfies a, b, c ≥0;

(1h) Let the real-time length m _i of the user queue Q _i be: m _i =m _{i_H} +m _{i_M} +m _{i_L} , where m _{i_H} is the number of data frames with high priority, and m _{i_M} is the number of data frames with medium priority , m _{i_L} is the number of low-priority data frames;

(1i) Let the set of users whose real-time length of user queue exceeds the queue threshold be: C={N _i |m _i >M _i , 1≤i≤k};

(1j) Let the user queue whose real-time length of the user queue exceeds the queue threshold the most is: Q _max ={Q _i |m _i -M _i =B}, where B is the maximum difference between the real-time length of the user queue and the queue threshold, B= max{m _i -M _i |N _i ∈ C};

(2) When the data frame of user Ni _arrives in the cache, compare the size of the number of data frames m that the cache can accommodate in real time and the total number of data frames M that the cache can accommodate:

If m<M, the entire cache space is not full, execute (11);

Otherwise, the cache space is full, execute (3);

(3) compare the real-time length m _i of the user queue Q _i of the above-mentioned data frame with the queue threshold M _i :

If m _i <M _i , the real-time length of the user queue Qi does not exceed the threshold of the queue, find out the jth user N _j to which Q _max belongs, j≠ _i , and execute (4);

Otherwise, the real-time length of the user queue Qi has _exceeded the threshold of the queue, and execute (6);

(4) Compare the number of low-priority data frames m _{j_L} of user N _j with the low-priority minimum threshold L _{j_L} of the jth user queue Q _j :

If m _{j_L} > L _{j_L} , discard any low-priority data frame in the user queue Q _j , and execute (11);

Otherwise, execute (5);

(5) Compare the number m _{j_M} of medium-priority data frames of user N _j with the lowest threshold L _{j_M} of medium-priority in the user queue Q _j :

If m _{j_M} > L _{j_M} , discard any medium-priority data frame in the user queue Q _j , and execute (11);

Otherwise, there must be m _{j_H} > L _{j_H} at this time, then discard any high-priority data frame in the user queue Q _j , and execute (11);

(6) judge whether the data frame that the user _Ni arrives at the cache is a low-priority data frame: if so, directly discard the data frame and execute (12); otherwise, execute (7);

(7) judge whether the data frame that the user N _i arrives at the buffer is a medium priority data frame: if so, execute (8), otherwise, execute (9);

(8) _Determine whether there is a low-priority data frame in the user queue Qi to which the data frame of the user _Ni arrives at the buffer:

If it exists, _discard any low-priority data frame in Qi, and execute (11);

Otherwise, discard the data frame that arrives in the cache, and execute (12);

(9) Compare the number of low- _priority data frames of the user Ni that arrives at the buffered data frame with the size of the low-priority minimum threshold of the user queue _Qi :

If m _{i_L} >L _{i_L} , discard any low-priority data frame in Qi _, and execute (11); otherwise, execute (10);

(10) Compare the number of medium-priority data frames of the user N _i to which the buffered data frame belongs and the size of the lowest threshold of medium-priority in the user queue Q _i :

If m _{i_M} > L _{i_M} , discard any medium-priority data frame in Qi _, and execute (11); otherwise, directly discard the data frame and execute (12);

(11) Enter the data frame that reaches the cache into the user queue to which it belongs;

(12) Determine whether there are still data frames arriving in the cache: if so, return to (2), otherwise, stop the management service.

Compared with the prior art, the present invention has the following advantages:

First, because the present invention sets the threshold value of the queue based on the service level agreement, it ensures that users with high service levels can enjoy higher service quality even when all users have burst services at the same time. In the case of non-burst services, it can temporarily provide higher service quality for users with low service levels.

Second, when the present invention sets the queue threshold based on the service level agreement, the minimum thresholds of the three priority queues, high, middle and low, are simultaneously set, thus ensuring that the high-priority service has a higher success in joining the queue than the low-priority service. Rate.

Description of drawings

Fig. 1 is the realization flow chart of the present invention;

Fig. 2 is the network topology diagram that the present invention uses;

FIG. 3 is a schematic diagram of cache allocation based on service level agreement in the present invention.

Detailed ways

The embodiments of the present invention will be described in further detail below with reference to the accompanying drawings.

Referring to FIG. 2 , this embodiment uses a star network topology, and the network consists of one central node and eight user nodes.

Referring to FIG. 3 , this embodiment provides 8 users with 3 different service levels, and the ratio of the bandwidth values provided by the 3 service levels is 1:2:3. Table 1 shows the service levels purchased by the 8 users.

Table 1 User purchase service level table

User node service level User 1 Grade 1 User 2 Level 2 User 3 Grade 1 User 4 Grade 1 User 5 Grade 1 User 6 Level 3 User 7 Level 2 User 8 Grade 1

1, the implementation steps of this embodiment are as follows:

Step 1, initialize the cache management parameters.

The cache management parameter is the condition basis for the cache to manage the entry of data frames, including but not limited to: the number of users served, the number of data frames that can be accommodated in the cache space, and various thresholds of user queues. According to the cache management parameters, the cache can control whether the data frame is queued when the data frame arrives, so as to realize the effective management of the cache space.

1.1) Suppose there are 8 users N _i that need to provide cache management services, where i is from 1 to 8;

1.2) The total number of data frames that can be accommodated in the total buffer space is M=2400, and the number of data frames accommodated in real time is m, where m≤M;

1.3) Set the total bandwidth size provided by the central equipment to be B=120MHz, the bandwidth size purchased by user _{Ni is B i ,} and the bandwidth size purchased by 8 users is as shown in Table 2;

Table 2 Bandwidth purchased by users

Continued from Table 2

1.4) Suppose the data frame of user N _i is divided into three priorities: high, medium and low, and all are stored in the user queue Q _i ;

为高中低优先级最低门限值之和占队列门限M_i的比例，且满足n≥1，本实施例设

a，b，c分别为高中低优先级最低门限值的比例，且满足a、b、c≥0，该比例可以根据优先级的实际情况来设置，本实施例设但不限于a＝6、b＝3、c＝1，8个用户根据服务等级协议SLA计算出的队列门限以及各优先级最低门限通过如下公式计算，最终得出的门限值如表3所示；1.5) Set the queue threshold of user queue Qi as M _{i ,} wherein the minimum threshold of high priority of queue Qi is _{Li_H} , the minimum threshold of _middle priority is _{Li_M} , and the minimum threshold of low priority is L _{i_L} ,

is the ratio of the sum of the minimum thresholds of high, medium and low priorities to the queue threshold M _i , and satisfies n≥1. In this embodiment, set

a, b, and c are the ratios of the lowest thresholds of high, medium and low priorities respectively, and satisfy a, b, and c≥0. The ratio can be set according to the actual situation of the priorities. In this embodiment, a=6 is set but not limited to , b=3, c=1, the queue threshold calculated by 8 users according to the service level agreement SLA and the minimum threshold of each priority are calculated by the following formula, and the final threshold value is shown in Table 3;

Table 3 SLA-based queue thresholds

User node SLA queue threshold High priority minimum threshold Medium Priority Lowest Threshold Low priority minimum threshold N₁ M₁=200 L_{1_H}=30 L_{1_M}=15 L_{1_L}=5 N₂ M₂=400 L_{1_H}=60 L_{1_M}=30 L_{1_L}=10 N₃ M₃=200 L_{1_H}=30 L_{1_M}=15 L_{1_L}=5 N₄ M₄=200 L_{1_H}=30 L_{1_M}=15 L_{1_L}=5 N₅ M₅=200 L_{1_H}=30 L_{1_M}=15 L_{1_L}=5 N₆ M₆=600 L_{1_H}=90 L_{1_M}=45 L_{1_L}=15 N₇ M₇=400 L_{1_H}=60 L_{1_M}=30 L_{1_L}=10 N₈ M₈=200 L_{1_H}=30 L_{1_M}=15 L_{1_L}=5

1.6) Let the real-time length m _i of the user queue Q _i be: m _i =m _{i_H} +m _{i_M} +m _{i_L} , where m _{i_H} is the number of data frames with high priority, and m _{i_M} is the number of data frames with medium priority, m _{i_L} is the number of low-priority data frames;

1.7) Let the set of users whose real-time length of user queue exceeds the queue threshold be: C={N _i |m _i >M _i , 1≤i≤8};

1.8) Let the user queue whose real-time length of user queue exceeds the queue threshold the most is: Q _max ={Q _i |m _i -M _i =B}, where B is the maximum difference between the real-time length of the user queue and the queue threshold, B=max {m _i -M _i |N _i ∈ C}.

Step 2, it is judged whether the data frame that user N ₇ arrives at the buffer can enter the buffer space.

Compare the size of the number of data frames m that the cache can hold in real time with the total number of data frames M that the cache can hold:

If the number of data frames m that the cache can accommodate in real time is less than 2400, the arriving data frames can enter the cache space, and step 8 is performed;

If the number m of data frames that the cache can hold in real time is equal to 2400, go to step 3.

In this embodiment, it is assumed that the user belonging to the data frame that has arrived at this time is N ₇ .

Step 3, it is judged whether to discard the data frame that user N ₇ has arrived at.

Compare the real-time length m ₇ of the user queue Q ₇ with its queue threshold M ₇ :

If the real-time length m ₇ of the user queue Q ₇ is less than 400 at this time, there must be other user queues whose real-time length exceeds the corresponding threshold. The reason is that the cache space is full at this time, that is, m=2400, but at this time m ₇ is less than 400, so There must be other users N _j , j≠i that have seized the cache space originally belonging to N ₇ , that is, m _j >M _j , j≠7, so select other users to discard the data frame, and go to step 4;

If the real-time length m ₇ of the user queue Q ₇ is greater than or equal to 400 at this time, the data frame needs to be discarded for the user N ₇ whose data frame has arrived at this time, and step 7 is executed.

Step 4: Select the user who needs to discard the data frame and the corresponding user queue.

4.1) Traverse all users except user N ₇ , that is, find out the users whose real-time length of the corresponding user queue exceeds the queue threshold from N ₁ , N ₂ , N ₃ , N ₄ , N ₅ , N ₆ , and N ₈ Collection C:

C={N _j |m _j >M _j ,1≤j≤8,j≠7},

In this embodiment, it is assumed that there are N ₁ , N ₃ , and N ₅ users whose real-time queue length exceeds the queue threshold at this time, namely:

C={N _j |m _j >M _j ,1≤j≤8,j≠7}={N ₁ ,N ₃ ,N ₅ }

4.2) Traverse the users N ₁ , N ₃ , and N ₅ in the set C, and find out the user queue Q _max corresponding to the user whose real-time queue length exceeds the queue threshold the most at this time:

Q _max ={Q _i |m _i -M _i =B}, where B=max{m _i -M _i |N _i ∈C}

In this embodiment, it is assumed that the users with the most real-time queue length exceeding the queue threshold at this time are N ₃ , that is:

Q _max ={Q _i |m _i -M _i =B}=Q ₃

Therefore, the user queue Q ₃ corresponding to the user N ₃ needs to discard the data frame.

Step 5, judge whether to discard the low-priority data frames in the user queue _Q3 .

Compare the number of low-priority data frames in user queue Q ₃ corresponding to user N ₃ with its low-priority minimum threshold:

If the number m _{3_L} of low-priority data frames in the user queue Q ₃ exceeds 5, discard any low-priority data frame in Q ₃ , and perform step 8;

If the number m _{3_L} of low-priority data frames in the user queue Q ₃ does not exceed 5, the medium or high-priority data frames in Q ₃ need to be discarded, and step 6 is performed.

Step 6, judging whether to discard the medium-priority data frames in the user queue _Q3 .

Compare the number of medium-priority data frames in the user queue Q ₃ corresponding to user N ₃ with the lowest priority threshold among them:

If the number of medium-priority data frames m _{3_M} in the user queue Q ₃ exceeds 10, discard any medium-priority data frame in Q ₃ , and perform step 8;

If the number of medium-priority data frames m _{3_M} in user queue Q ₃ does not exceed 10, discard any high-priority data frame in Q ₃ , and perform step 8 .

Step 7, select the data frame of user N ₇ to discard.

7.1) Determine whether the data frame arrived by user N ₇ is of low priority:

If the data frame that the user N ₇ arrives at is a low-priority data frame, then discard the arriving data frame, and execute step 9;

If the data frame arriving by user N ₇ is not a low priority data frame, then step 7.2) is performed.

7.2) Determine whether the data frame arrived by user N ₇ is of medium priority:

If the data frame arriving by user N ₇ is of medium priority, then perform step 7.3);

If the data frame arrived by user N ₇ is not of medium priority, it must be of high priority, and execute step 7.4).

_7.3 ) Determine whether there is a low-priority data frame in the user queue Q7:

If there is a low _- priority data frame in the user queue Q7, then discard any low-priority data frame in Q7, and execute step ₈ ;

If there is no low _- priority data frame in the user queue Q7, the arriving data frame is discarded, and step 9 is performed.

7.4) Determine whether the number of low _- priority data frames in the user queue Q7 exceeds the low-priority minimum threshold:

If the number m _{7_L} of low-priority data frames in the user queue Q ₇ exceeds 10, discard any low-priority data frame in Q ₇ , and perform step 8;

If the number m _{7_L} of low-priority data frames in the user queue Q ₇ does not exceed 10, step 7.5) is performed.

7.5) Determine whether the number of medium-priority data frames in the user queue Q ₇ corresponding to the user N ₇ exceeds the minimum threshold of the medium-priority:

If the number of medium-priority data frames m _{7_M} in the user queue Q ₇ does not exceed 30, discard any medium-priority data frame in Q ₇ , and perform step 8;

If the number m _{7_M} of medium-priority frames in the user queue Q ₇ exceeds 30, the arriving data frames are directly discarded, and step 9 is performed.

Step 8: Enter the data frame that arrives in the buffer into the queue of the user to which it belongs.

Step 9, determine whether there are still data frames arriving.

If there are still data frames arriving, go back to step 2;

If no data frame arrives, stop the management service.

The above description is only a specific example of the present invention, and does not constitute any limitation to the present invention. Obviously, for those skilled in the art, after understanding the content and principles of the present invention, they may not deviate from the principles of the present invention, In the case of the structure, modifications and changes in form and details are made, but these modifications and changes based on the idea of the present invention are thrown within the protection scope of the claims of the present invention.

Claims (2)

1. a data frame preemptive cache management method based on service level agreement, is characterized in that, comprises as follows: (1) Initialize the cache management parameters: (1a) Suppose there are k users Ni who need to provide cache management services, where _i ranges from 1 to k; (1b) The total number of data frames that can be accommodated in the total buffer space is M, and the number of data frames that can be accommodated in real time is m; (1c) Let the service level agreement SLA be the size of the bandwidth purchased by the user; (1d) Suppose the total bandwidth size is B, the bandwidth size purchased by user _{Ni is B i ,} and the sum of the bandwidth purchased by k users satisfies

conditions, where

is the sum of bandwidth purchased by k users; (1e) _Suppose the data frame of user Ni is divided into three priority levels: high, medium and low, and all are stored in the user queue _Qi ; (1f) Let the queue threshold M _i of the user queue Q _i be:

(1g) Let the high-priority minimum threshold value L _{i_H} of the user queue Q _i be:

The lowest threshold value L _{i_M} of the medium priority is:

The low priority minimum threshold value _{Li_L} is:

in

is the ratio of the sum of the minimum thresholds of high, medium and low priorities to the queue threshold Mi, and satisfies _n≥1 , a, b, and c are the proportions of the minimum thresholds of high, medium, and low priorities, respectively, and satisfies a, b. c≥0; (1h) Let the real-time length m _i of the user queue Q _i be: m _i =m _{i_H} +m _{i_M} +m _{i_L} , where m _{i_H} is the number of data frames with high priority, and m _{i_M} is the number of data frames with medium priority , m _{i_L} is the number of low-priority data frames; (1i) Let the set of users whose real-time length of user queue exceeds the queue threshold be: C={N _i |m _i >M _i , 1≤i≤k}; (1j) Let the user queue whose real-time length of the user queue exceeds the queue threshold the most is: Q _max ={Q _i |m _i -M _i =B}, where B is the maximum difference between the real-time length of the user queue and the queue threshold, B= max{m _i -M _i |N _i ∈ C}; (2) When the data frame of user Ni _arrives in the cache, compare the size of the number of data frames m that the cache can accommodate in real time and the total number of data frames M that the cache can accommodate: If m<M, the entire cache space is not full, execute (11); Otherwise, the cache space is full, execute (3); (3) compare the real-time length m _i of the user queue Q _i of the above-mentioned data frame with the queue threshold M _i : If m _i <M _i , the real-time length of the user queue Qi does not exceed the threshold of the queue, find out the jth user N _j to which Q _max belongs, j≠ _i , and execute (4); Otherwise, the real-time length of the user queue Qi has _exceeded the threshold of the queue, and execute (6); (4) Compare the number of low-priority data frames m _{j_L} of user N _j with the low-priority minimum threshold L _{j_L} of the jth user queue Q _j : If m _{j_L} > L _{j_L} , discard any low-priority data frame in the user queue Q _j , and execute (11); Otherwise, execute (5); (5) Compare the number m _{j_M} of medium-priority data frames of user N _j with the lowest threshold L _{j_M} of medium-priority in the user queue Q _j : If m _{j_M} > L _{j_M} , discard any medium-priority data frame in the user queue Q _j , and execute (11); Otherwise, there must be m _{j_H} > L _{j_H} at this time, then discard any high-priority data frame in the user queue Q _j , and execute (11); (6) judge whether the data frame that the user _Ni arrives at the cache is a low-priority data frame: if so, directly discard the data frame and execute (12); otherwise, execute (7); (7) judge whether the data frame that the user N _i arrives at the buffer is a medium priority data frame: if so, execute (8), otherwise, execute (9); (8) _Determine whether there is a low-priority data frame in the user queue Qi to which the data frame of the user _Ni arrives at the buffer: If it exists, _discard any low-priority data frame in Qi, and execute (11); Otherwise, discard the data frame arriving in the buffer, and execute (12); (9) Compare the number of low- _priority data frames of the user Ni that arrives at the buffered data frame with the size of the low-priority minimum threshold of the user queue _Qi : If m _{i_L} >L _{i_L} , discard any low-priority data frame in Qi _, and execute (11); otherwise, execute (10); (10) Compare the number of medium-priority data frames of the user N _i to which the buffered data frame belongs and the size of the lowest threshold of medium-priority in the user queue Q _i : If m _{i_M} > L _{i_M} , discard any medium-priority data frame in Qi _, and execute (11); otherwise, directly discard the data frame and execute (12); (11) Enter the data frame that reaches the cache into the user queue to which it belongs; (12) Determine whether there are still data frames arriving in the cache: if so, return to (2), otherwise, stop the management service. 2 . The method according to claim 1 , wherein the data frames are all fixed-length data frames. 3 .

Images