An online resource allocation method and system based on multiplicative weight update

Abstract

The application discloses an online resource allocation method and system based on multiplicative weight update, and belongs to the technical field of computer resource scheduling. In order to solve the problems of low resource utilization, difficult quality of service guarantee and limited feedback information in a multi-user sharing scene, the application mainly adopts a multiplicative weight update strategy based on a binary queue state, and dynamically adjusts a resource allocation proportion in combination with a truncated simplex projection mechanism. The application can realize collaborative optimization of resource utilization efficiency maximization and quality of service guarantee under the condition of only relying on queue empty / non-empty states, and has good efficiency, robustness and fairness.

Description

Technical Field

[0001] This invention belongs to the field of computer resource scheduling technology, specifically relating to an online resource allocation method and system based on multiplicative weight updates. Background Technology

[0002] In current cloud computing platforms, where multiple tenants share physical resources (such as CPU, memory, storage, and network bandwidth), mainstream resource allocation methods focus on balancing efficiency and Quality of Service (QoS) through different strategies. Static allocation strategies meet user needs by predefined fixed quotas, such as reserving 30%, 30%, and 40% of CPU resources for three users respectively, ensuring basic performance guarantees for their task processing. Greedy strategies dynamically allocate resources based on real-time queue status, prioritizing resources to currently non-empty queues to maximize instantaneous utilization. For example, in a Kubernetes cluster, the scheduler allocates idle resources to high-load tasks based on queue activity. Proportional allocation strategies combine preset weights with real-time status adjustments to resource allocation. For instance, when users A, B, and C have QoS weights of 0.3, 0.3, and 0.4 respectively, the system dynamically allocates resources in a 3:3:4 ratio, adapting to both user priorities and dynamic needs. This is particularly effective in highly volatile scenarios such as video streaming, where the linkage between weight ratios and queue activity enables elastic resource adaptation. These methods all revolve around improving resource utilization efficiency and ensuring service quality, and meet diverse scenario needs through different dimensions of design.

[0003] The core problems of existing technologies can be summarized in the following four aspects: First, the irreconcilable contradiction between resource utilization and QoS makes it impossible for static and greedy strategies to simultaneously achieve efficiency and fairness. For example, when a financial trading platform uses static allocation, the resource utilization rate is only 65%, but after switching to a greedy strategy, the transaction latency of low-priority users increases significantly, and the QoS default rate increases significantly. Second, insufficient dynamic feedback information severely limits the algorithm's adjustment capability. Traditional algorithms rely on fine-grained data such as queue length or task arrival volume, but actual systems can only provide binary feedback (queue empty / not empty). In edge computing scenarios, due to limitations in sensor accuracy and communication bandwidth, the controller cannot obtain the queue backlog in real time, resulting in limited dynamic adjustment capabilities. Third, poor adaptability to non-steady-state demands makes it difficult for existing algorithms to cope with sudden traffic surges or periodic peaks. For example, the instantaneous request volume of e-commerce platforms during promotional periods can reach tens of times the daily traffic. Traditional proportional allocation strategies cannot respond quickly to such fluctuations, leading to a sharp drop in resource utilization and causing large-scale queue backlogs. Finally, the lack of theoretical performance guarantees makes it difficult for existing methods to quantify their gap with the ideal optimal solution. Summary of the Invention

[0004] This invention aims to provide an online resource allocation method and system based on multiplicative weight updates. Under the limited feedback condition of only obtaining whether the queue is empty, it can realize the dynamic scheduling and reasonable allocation of resources among multiple users, improve the overall resource utilization of the system, and while meeting the minimum service quality requirements of each user, it has the ability to adapt to non-steady-state load changes and the stability of long-term operation.

[0005] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0006] An online resource allocation method based on multiplicative weight updates includes the following steps:

[0007] 1) At each time step, obtain the task load L for each user. t (n), and update the task queue length Q for each user based on the resource allocation and task load of the previous time step. t (n);

[0008] 2) Based on the updated task queue length Q t (n), the set of active user queues A at the current time step. t Inactive user queue set B t Active users are those whose queue length is greater than zero;

[0009] 3) For each active user in the active user queue, based on their current resource allocation H t (n) is compared with the service quality requirements η(n) to determine the service quality satisfaction, and users whose service quality is not satisfied are grouped into the set. The set of already satisfied members

[0010] 4) Based on the queue classification results in step 3), generate a gain value g for each user. t (n), this gain value is used to measure the user's current activity level and the degree of service quality satisfaction;

[0011] 5) Based on the resource allocation vector H from the previous time step t (n) and the current gain value g t (n), the resource allocation weights for each user are updated exponentially weighted to obtain a temporary resource allocation vector.

[0012] 6) Allocate temporary vectors for resources Projected onto a truncated simplex feasible region Obtain the formal resource allocation vector H t+1 (n);

[0013] 7) Repeat the above process to allocate resources for the next time step.

[0014] Further, before proceeding with step 1), parameters are initialized, including: setting the service quality requirement ρ(n) for each user, the truncation parameter δ, the learning rate η, the gain factor λ, and the initial resource allocation vector H1, where, O(·) represents the asymptotic upper bound, T represents the total time; H1 consists of the resource allocation for different users.

[0015] Furthermore, the initial resource allocation vector H1 originates from the truncated simplex feasible region. Obtained by random sampling, satisfying and Where n represents the number of users and N represents the number of users.

[0016] Furthermore, in step 1), the task queuing length Q t The update method for (n) is:

[0017] Q t (n)=max{L t (n)+Q t-1 (n)-H t (n),0}

[0018] Among them, L t (n) represents the task load of user n at time step t, H t (n) represents the current resource allocation to user n.

[0019] Furthermore, the method for judging service quality satisfaction in step 3) is as follows: For active user n, if the current resource allocation H t (n) is less than Then it is determined that the user has not met the service quality requirements, among which This represents the total service quality requirements for all currently active users.

[0020] Furthermore, in step 4), the gain value g t The calculation rules for (n) include:

[0021]

[0022] Where λ represents the gain factor and n represents the number of users.

[0023] Furthermore, in step 5), the intermediate resource vector for resource allocation... The calculation method is as follows:

[0024]

[0025] Where η represents the learning rate, g t(n) represents the current user's gain value.

[0026] Furthermore, in step 6), the resource allocation temporary vector is obtained through Kullback-Leibler divergence. Projected onto a truncated simplex feasible region Obtain the formal resource allocation vector H t+1 (n) is represented as follows:

[0027]

[0028] The constraints are n represents the number of users, N represents the number of users, and δ represents the truncation parameter.

[0029] Furthermore, in step 6), the simplex feasible region is truncated. It is expressed as follows:

[0030]

[0031] Where x(n) represents the share of resources allocated to user n, This means that the share of resources allocated to user n is greater than or equal to the minimum resource guarantee threshold. N represents the number of users, and δ represents the truncation parameter.

[0032] An online resource allocation system based on multiplicative weight updates includes a memory for storing a computer program and a processor for executing the computer program to implement the steps of the method described above.

[0033] The beneficial effects achieved by this invention are as follows:

[0034] 1. This invention transforms the only available binary feedback (empty / non-empty queue) into effective optimization signals by dynamically adjusting resource allocation weights, thereby maximizing the cumulative task completion amount while strictly meeting the Quality of Service (QoS) constraints for all users.

[0035] 2. This invention uses an exponential weight growth mechanism to prioritize the scheduling of queues that have not been allocated resources consecutively, effectively avoiding QoS violations caused by insufficient resources.

[0036] 3. By introducing a truncated simplex constraint, this invention ensures that the resource allocation for each user is not lower than a set lower limit, thus maintaining scheduling stability and improving the robustness of the algorithm even under severe fluctuations in system load.

[0037] 4. This invention achieves efficient dynamic resource scheduling through a multiplicative weight update mechanism, which can quickly respond to changes in the status of each queue in the system, prioritize the resource needs of high-load users, and at the same time take into account the minimum resource allocation for low-priority users, thereby improving the overall scheduling fairness.

[0038] 5. This invention avoids resource waste caused by static quota strategies and resource preemption problems under greedy strategies by adjusting the resource allocation ratio in real time. It effectively improves resource utilization in multi-user mixed load scenarios and makes the system operating efficiency close to the optimal level.

[0039] 6. This invention constrains the weight update results through a projection mechanism, ensuring that each queue can still obtain minimum resource guarantees even under low load conditions, preventing low-priority users from experiencing "starvation" and improving long-term service quality assurance capabilities. Attached Figure Description

[0040] Figure 1 This is a flowchart of an online resource allocation method based on multiplicative weight updates.

[0041] Figure 2 This is a graph showing the total workload of the experimental results.

[0042] Figure 3 This is a graph showing the total workload of each cohort in the experimental results.

[0043] Figure 4 This is a graph showing the queue lengths of the experimental results. Detailed Implementation

[0044] To make the various technical features, advantages, or effects of the present invention more apparent and understandable, detailed descriptions are provided below through embodiments.

[0045] This invention provides an online resource allocation method (QoS-MWU) based on multiplicative weight update, such as... Figure 1 As shown, this method is applicable to resource allocation systems that meet multi-user quality of service (QoS) constraints. The core idea is to map the user queue state into a gain signal in binary feedback form, and realize the dynamic adjustment of resource allocation through a multiplicative weight update mechanism to maximize the overall task completion volume, while strictly ensuring the QoS requirements of each user throughout the process.

[0046] The method includes the following steps:

[0047] I. Initialization Phase

[0048] Step 1: Parameter and Space Definition

[0049] Define the user set as [N] = {1, 2, ..., N}, where each user n corresponds to a resource queue.

[0050] The minimum resource requirement vector for Quality of Service (QoS) for each user is defined as follows:

[0051] ρ=(ρ(1),ρ(2),...,ρ(N)), satisfying

[0052] To prevent a user from being allocated extremely low resources for an extended period, a truncation parameter is defined. It is a parameter that converges inversely proportional to the total number of time steps T, indicating that δ gradually decreases as T increases, and its order of magnitude does not exceed 1 / T; where O(·) represents the asymptotic upper bound, used to describe the upper bound of the growth rate of the function when a certain variable approaches infinity, and T is the total number of time steps.

[0053] Based on this truncation parameter, a truncated simplex feasible region is constructed and defined:

[0054]

[0055] in, Let x represent the set of truncated simplexes with lower bound constraints. It is a feasible region for resource allocation in N-dimensional space. It is an extended set based on the original simplex set (i.e., a set of vectors with non-negative dimensions and a sum of 1), with a minimum lower bound set set for each component; x is an arbitrary variable used to define the set; x(n) represents the share of resources allocated to user n. This indicates that a minimum resource guarantee threshold has been set for each user n: it cannot be less than The truncated simplex feasible region ensures that the resource allocation for each user is not less than [a certain value]. This avoids resource allocation approaching zero and effectively suppresses the phenomenon of resource "hunger".

[0056] Step 2: Initial resource allocation and parameter settings

[0057] The truncated simplex feasible region is defined above. Initial resource allocation vector randomly sampled in the middle:

[0058] H1 = (H1(1),H1(2),...,H1(N))

[0059] in, As for the amount of resources allocated,

[0060] Set the gain amplification factor And the learning rate η∈(0,1). Initialize the time step t=1, and set the initial length of all queues to zero, that is:

[0061]

[0062] II. Dynamic Resource Allocation Loop (at each time step t)

[0063] Step 3: Execute current resource allocation

[0064] According to the resource allocation vector H at the current time step t t =(H t (1),H t (2),...,H t (N)) allocates resources to each user's resource queue:

[0065] Each user n receives H resources at this time step. t (n) is used to handle its pending task load.

[0066] Step 4: Update queue length

[0067] Each user queue receives a new task load L at the current time step. t (n), combined with the currently allocated resources H t (n), calculate the updated queue length:

[0068] Q t (n)=max{L t (n)+Q t-1 (n)-H t (n),0}

[0069] Among them, L t (n) represents the unobservable task load; the above expression indicates that the next step is determined solely based on whether the updated queue is empty.

[0070] Step 5: Binary Queue State Observation

[0071] By queue length Q t The non-zero or zero states of (n) divide all users into two sets:

[0072] Set of active user queues (i.e., where there is a backlog of tasks):

[0073] A t ={n∈[N]|Q t (n)>0}

[0074] Inactive user queue collection (queue has been cleared):

[0075] B t =[N]\A t

[0076] Step 6: Service Quality Assessment and Active User Queue Classification

[0077] Calculate the total QoS requirements of the current active user queue:

[0078]

[0079] For each active user queue n∈A t Perform the following QoS allocation judgment:

[0080] like Then, if n does not meet the QoS requirements, it will be added to the set:

[0081]

[0082] Otherwise, it is included in the set that meets QoS requirements:

[0083]

[0084] The above threshold δ is the minimum reasonable resource allocation ratio for fault tolerance, and it serves as a relaxation factor to improve the robustness of the method.

[0085] Step 7: Gain Function Generation

[0086] Based on the queue classification results, calculate the gain value g for each user n. t (n), used to guide the next weight update:

[0087]

[0088] Where λ is the gain factor. The three cases in the above formula, from top to bottom, are:

[0089] Queues that do not meet QoS requirements This will result in a magnified gain, increasing its weight in subsequent allocations;

[0090] Queues that meet QoS requirements Maintain the current allocation ratio;

[0091] Inactive user queue B t We will not participate in the competition for additional resources for the time being.

[0092] Step 8: Multiplicative Weight Update

[0093] Based on the above gain, the current resource allocation vector is updated with an exponential weighting to obtain the updated temporary resource allocation vector:

[0094]

[0095] Where η∈(0,1) is a hyperparameter representing the learning rate.

[0096] Step 9: Project KL to the feasible region

[0097] To make the updated resource allocation temporary vector Satisfy the truncated simplex constraint and project it back to the feasible region through the KL divergence Obtain the formal resource allocation vector H for the next time step t+1 , that is:

[0098]

[0099] The constraint conditions are as follows:

[0100] The total resource sum is 1:

[0101] Lower limit of single queue allocation:

[0102] That is, ensure that the total resource amount is 1, and the resources obtained by each user are not less than While retaining the optimization direction, constrain the rationality of allocation.

[0103] III. Termination judgment

[0104] Step 10: Iterative control

[0105] If the current time step t < T, where T is the preset maximum time step, update t = t + 1, and return to step 3 to continue the next round of resource allocation; otherwise, terminate the algorithm process.

[0106] Experimental test:

[0107] To verify the feasibility and effectiveness of the method of the present invention, simulation experiments were conducted to compare the online resource allocation method based on multiplicative weight update proposed in the present invention (abbreviated as QoS-MWU strategy) with three baseline algorithms, including static quality of service strategy, online proportional strategy, and greedy strategy.

[0108] The experiments were based on the following three evaluation metrics: resource utilization, quality of service guarantee ability, and dynamic change of queue length.

[0109] The first metric is the cumulative completed workload, that is, the total task amount completed by each algorithm on all queues;

[0110] The second metric is the quality of service satisfaction, which is compared by the cumulative completed workload of each algorithm on each queue with the completed amount of the static quality of service strategy;

[0111] The third metric is system stability, which evaluates the queue management performance of each algorithm through the dynamic queue length over time.

[0112] The simulation environment uses a synthetically generated adversarial load sequence to simulate challenging resource allocation scenarios. The experimental system includes three user queues, each with a service quality demand vector of ρ = (0.3, 0.3, 0.4). The simulation time step is set to T = 10,000.

[0113] Experimental results:

[0114] Figure 2 The cumulative workload of each algorithm during the simulation is presented. The results show that the QoS-MWU strategy has a higher cumulative workload than the other three baseline strategies over the entire timeframe. Under adversarial load, the online proportional strategy performs worse than the static QoS strategy, indicating that the static QoS strategy has an advantage in strictly meeting QoS constraints, while the online proportional strategy has a bias in task allocation, affecting the overall workload.

[0115] Figure 3 The performance of each algorithm in terms of service quality satisfaction is demonstrated, specifically through a comparison of the cumulative workload completed by each user with that of the static service quality strategy. Experiments show that the QoS-MWU strategy has an advantage in meeting the service quality needs of all users, with its cumulative workload consistently exceeding that of the static service quality strategy, reflecting strong service assurance capabilities. In contrast, the online proportion strategy exhibits over-allocation of resources on some queues, resulting in insufficient resources for other queues and affecting the overall service quality balance; while the greedy strategy increases the overall task completion volume, the service quality needs of some queues are not guaranteed, leading to service imbalance.

[0116] Figure 4 The experiment demonstrates the changes in user queue length over time under various algorithms. Experimental results show that the QoS-MWU strategy effectively controls queue length fluctuations under dynamic load, maintaining overall system stability. While the greedy strategy can also maintain queue stability to some extent, it suffers from long-term resource shortages in some queues due to its lack of targeted control over service quality requirements.

[0117] Although the present invention has been disclosed above with reference to embodiments, it is not intended to limit the present invention. Appropriate modifications or equivalent substitutions made by those skilled in the art to the technical solutions of the present invention should be covered within the protection scope of the present invention, which is defined by the claims.

Claims

1. An online resource allocation method based on multiplicative weight updates, characterized in that, Includes the following steps: 1) According to the current time step Resource allocation vector Resources are allocated to the resource queues of each user, where each user... The amount of resources acquired at the current time step is , used to handle its pending task load; 2) Obtain each user Task load And based on the task queue length of the previous time step Resource quantity at the current time step With task load Update the task queue length for each user. ; 3) Based on the updated task queue length Divide the active user queue set at the current time step. Inactive user queues Active users are those whose queue length is greater than zero; 4) For each active user in the active user queue, based on their current resource allocation... With service quality requirements Perform a service quality satisfaction assessment and group users who do not meet the service quality requirements into a set. The satisfied ones are included in the set. ; 5) Based on the queue classification results in step 4), generate a gain value for each user. This gain value is used to measure the user's current activity level and the degree of service quality satisfaction; 6) Based on the resource allocation vector of the current time step Compared with the current gain value The resource allocation weights for each user are updated exponentially to obtain a temporary resource allocation vector. ; 7) Allocate temporary vectors for resources Projected onto a truncated simplex feasible region This yields the formal resource allocation vector. ; 8) Transfer the formal resource allocation vector As the current resource allocation vector for the next time step, and repeat steps 1) through 7 in the next time step.

2. The method as described in claim 1, characterized in that, Step 1) Initialize parameters before proceeding, including setting the service quality requirements for each user. , truncation parameters Learning rate Gain factor and initial resource allocation vector ,in, , The upper bound is represented by T, and the total time is represented by T. It consists of the resource allocation for different users.

3. The method as described in claim 2, characterized in that, Initial resource allocation vector From the truncated simplex feasible region Obtained by random sampling, satisfying and ,in Indicates user, Indicates the number of users.

4. The method as described in claim 1, characterized in that, Task queue length in step 1) The update method is as follows: in, This represents the task load of user n at time step t. This represents the current resource allocation to user n.

5. The method as described in claim 2, characterized in that, Step 3) determines service quality satisfaction as follows: For active user n, if the current resource allocation... Less than If so, the user is deemed not to have met the service quality requirements. This represents the total service quality requirements for all currently active users.

6. The method as described in claim 1, characterized in that, Gain value in step 4) The calculation rules include: in, denoted as gain factor, and n represents the number of users.

7. The method as described in claim 1, characterized in that, Temporary resource allocation vector in step 5) The calculation method is as follows: in, Indicates the learning rate. This represents the current user's gain value.

8. The method as described in claim 1, characterized in that, In step 6), the resource allocation temporary vector is obtained through Kullback-Leibler divergence. Projected onto a truncated simplex feasible region This yields the formal resource allocation vector. , means as follows: The constraints are , n represents the number of users, and N represents the total number of users. Indicates the truncation parameter. This represents the share of resources allocated to user n.

9. The method as described in claim 1 or 8, characterized in that, Step 6) Truncate the simplex feasible region It is expressed as follows: in, This represents the share of resources allocated to user n. This means that the share of resources allocated to user n is greater than or equal to the minimum resource guarantee threshold. N represents the number of users. This indicates the parameter to be truncated.

10. An online resource allocation system based on multiplicative weight updates, characterized in that, It includes a memory and a processor, the memory being used to store a computer program and the processor being used to execute the computer program to implement the steps of the method according to any one of claims 1-9.

Images