Max–Min Share-Based Mechanism for Multi-Resource Fair Allocation with Bounded Number of Tasks in Cloud Computing System

Abstract

Finding a fair and efficient multi-resource allocation is a fundamental goal in cloud computing systems. In this paper, we consider the problem of multi-resource allocation with a bounded number of tasks. We propose a lexicographic max–min maximin share (LMM-MMS) fair allocation mechanism and design a non-trivial polynomial-time algorithm to find an LMM-MMS solution. In addition, we prove that LMM-MMS satisfies Pareto efficiency, sharing incentive, envy-freeness, and group strategy-proofness properties. The experimental results showed that LMM-MMS could produce a fair allocation with a higher resource utilization and completion ratio of user jobs than previous known fair mechanisms; LMM-MMS also performed well in resource sharing.

1. Introduction

Multi-resource fair (or efficient) allocation is a fundamental problem in any shared computing system, including cloud computing systems. In a cloud computing system, there are a large number of users with heterogeneous jobs, each containing a bounded number of tasks with the same resource demands [1]. After submitting their jobs, the system should allocate resources to each user as fairly and efficiently as possible.

As mentioned by Ghodsi et al. [2], traditional slot-based scheduler frameworks such as Hadoop achieve poor performance, unfairly punishing certain workloads. In response to this challenge, Ghodsi et al. [2] proposed a compelling alternative, known as dominant resource fairness, which maximizes the minimum dominant share of users, where the dominant share is the maximum share of any resource allocated to that user. Dominant resource fairness (DRF) has been shown to satisfy some desirable fair and efficient properties such as Pareto efficiency, sharing incentive, envy-freeness, and strategy-proofness, and has been implemented in Hadoop for multi-resource fair allocation. Meskar et al. [3] innovatively proposed the Kalai–Smorodinsky negotiation solution to the problem of multi-resource allocation. Due to the excellent performance of the DRF, some variants have been proposed. Sadok et al. [4] proposed Stateful DRF to solve the problem of traditional DRF ignoring historical use by introducing a time decay function and historical use weights. Tang et al. [5] proposed a long-term multi-resource fairness method that, although considering long-term fairness, performs poorly with the complexity of large-scale systems. Parkes et al. [6] extended DRF to a more general case where the user may have zero demands. Recently, Zhang et al. [7] generalized the asset fairness mechanism for improving resource utilization. Li et al. [8] extended DRF to a dynamic scenario, where users can enter and leave the system multiple times. Fallah et al. [9] studied the fair allocation problem in dynamic mechanism design. They proposed a mechanism that can maintain long-term fairness in a dynamic environment by exploring the incentives for dominant resource fair distribution under dynamic demands. Fikioris et al. [10] proposed an improved DRF mechanism that prevents users from benefiting from false reporting of their demands. While DRF and its subsequent versions addressed multi-resource fairness with demand heterogeneity, they all have difficulty achieving high resource utilization. For example, Dolev et al. [11] showed that, although their proposed bottleneck-based fairness (BBF) is better than DRF in many aspects such as algorithm efficiency, both could achieve high resource utilization. Meskar et al. [12] proposed Task Share Fairness with External Resource (TSF-ER) to balance fairness and high resource utilization in heterogeneous server environments.

Recently, another well-known method, Maxmin share (MMS) fair allocation [13], has attracted much attention. MMS can guarantee each user a result no worse than the case of receiving its least desirable allocation. Li et al. [5] extended MMS to a more general case where each job is associated with a release time, deadline, and processing time. Guo et al. [14] proposed a mechanism through bandwidth demand compression technology to improve the overall efficiency of the system while ensuring fairness, and solved the MMS fair allocation problem of multi-resources considering bandwidth demand compression in cloud-edge collaborative systems. Kurokawa et al. [15] presented an algorithm that can determine a 2/3-approximation MMS allocation. Guo et al. [16] proposed an MMS-based dynamic allocation mechanism with elastic demands.

In a real-world cloud computing system, the users have a bounded number of tasks [1]. Li et al. [15] proposed a task share fairness in cloud-edge collaborative computing systems (TSF-CE) mechanism to solve the problem of fair allocation of multi-resources in cloud-edge collaborative systems with access constraints. Ghodsi et al. [17] proposed the Choosy algorithm to solve the problem of fair allocation of resources with constraints in data centers. Wang et al. [1] studied the multi-resource problem in a heterogeneous computing system with a bounded number of tasks and presented a generalized water-filling algorithm. However, the running time of water-filling is pseudo-polynomial. It would be desirable to design an efficient polynomial-time algorithm. By extending the DRF algorithm, Li et al. [18] proposed a dynamic multi-resource fair allocation mechanism that takes into account the constraints on the number of bounded tasks. Li et al. [18] generalized DRF to the case where each user has a limited number of tasks. However, few of the MMS-based mechanisms consider a bounded number of tasks. Therefore, it is necessary to generalize MMS to the bounded case, where users have a finite number of task demands.

When the number of completed tasks is limited, it is difficult to design an efficient mechanism that takes into account both fairness and high resource utilization. To solve this problem, we propose a polynomial-based lexicographical max–min MMS-based (LMM-MMS) fair allocation mechanism.

Table 1. Table of mechanism comparisons.

Mechanism	Bounded Number of Tasks	Complexity	High Resource Utilization	Property
AF [7]	×	Non-polynomial	×	PE, SI, EF, GSP
DRF [2]	×	Non-polynomial	√	PE, SI, EF, GSP
CMMF [17]	×	Non-polynomial	×	SI, GSP
H-MRF [19]	×	Non-polynomial	√	PE, SI, GSP
DRFB [18]	√	$O\left(n^{2}logn\right)$	√	SI, GSP
DRFH [1]	×	Non-polynomial	√	PE, EF
LMMNS [20]	√	$O\left(n\right)$	√	EF, GSP
Sequential Minmax [21]	×	$O(n^{2}m/b^{*})$	×	PE, SI, EF1
MMS-ED [16]	√	Non-polynomial	√	PE, SI, EF, GSP
Matching-BagFalling [5]	×	Non-polynomial	×	PE
Dynamic MMF [10]	×	Non-polynomial	√	PE, SI, EF
MMS-BC [14]	×	Non-polynomial	√	PE, SI, EF, GSP
MAGIKS [3]	×	$O\left(n\right)$	×	PE, SI, EF
DRFTW [8]	×	Non-polynomial	√	PE, SI, EF, GSP
SDRF [4]	×	$O\left(nlogn\right)$	√	PE, SI, GSP
TSF-CE [22]	√	$O\left(n^{8}lognU\right)$	√	PE, SI, EF, GSP
TSF-ER [12]	√	$O\left(n^{8}log{\displaystyle \frac{nU}{ϵ}}\right)$	√	PE, SI, EF, GSP
LMM-MMS	√	$O\left(n\right)$	√	PE, SI, EF, GSP

Note: In Sequential Minmax [21], $b_{ir}$ is the proportion of resource r required by agent i to execute an instance of a task. $b^{*}=mi{n}_{i\in N}ma{x}_{r\in R}{b}_{ir}$; that is, $1/b^{*}$ is an upper bound on the number of bundles that can be allocated to an agent.

compares our approach and main closely related works in 4 aspects.

In this paper, we consider the multi-resource fair allocation problem in cloud computing systems with a bounded number of tasks. We present a lexicographically max–min MMS-based (LMM-MMS) fair allocation mechanism. Moreover, we design a polynomial-time algorithm to find an LMM-MMS fair allocation and show that LMM-MMS satisfies some desirable fair allocation properties.

The LMM-MMS mechanism can make significant contributions to multi-resource fair allocation in cloud computing systems with bounded task numbers. It innovatively addresses the practical constraint of limited task quantities by introducing the MMS concept, while maintaining critical fairness properties, including strategy-proofness, sharing incentive, envy-freeness, and proportional fairness. The algorithm achieves efficient $O\left(n\right)$ time complexity, making it applicable to large-scale environments. This mechanism successfully balances efficiency and fairness, providing both theoretical guarantees and practical solutions for resource management in cloud computing environments.

The rest of this paper is organized as follows: Section 2 presents the system model and some definitions of desirable properties. Section 3 introduces the MMS-based mechanism for a bounded number of tasks. Section 4 presents a non-trivial polynomial-time optimal algorithm and analyzes the allocation properties LMM-MMS satisfies. Section 5 provides experimental results based on real data. Section 6 concludes the paper and outlines future work.

2. Preliminaries

2.1. System Model

Suppose there are m resources (e.g., CPU, memory, GPU, etc.) and n users in a cloud computing system. Let $\mathbf{C}={(c_1,c_2,\dots ,c_m)}^T$ be the capacity vector of all resources, where $c_j>0$ denotes the capacity of resource j for $j=1,2,\dots ,m$. Let ${\mathbf{D}}_i={(d_{i1},d_{i2},\dots ,d_{im})}^T$ be the resource demand vector for each user i, where $d_{ij}>0$ is the per-task demand for resource j.

Table 2. Symbols.

Symbol	Description
$\mathbf{C}$	${(c_1,c_2,\dots ,c_m)}^T$ The capacity vector of all resources
${\mathbf{D}}_i$	${(d_{i1},d_{i2},\dots ,d_{im})}^T$ The resource demand vector for each user i
${\mathbf{A}}_i$	${(a_{i1},a_{i2},\dots ,a_{im})}^T$ The resource allocation vector of user i
$\mathcal{A}$	The set of all feasible allocations
$B_i$	The bounded number of tasks submitted by the user i
$\mathit{\theta }$	$({\theta }_1,{\theta }_2,\dots ,{\theta }_n)$ The max–min share ratio vector of all users
$u_i$	The utility of user i
$MM{S}_i$	The max–min share of user i
$x_i$	The maximum (fractional) number of tasks user i can process

lists the symbols that are frequently used throughout this paper.

For convenience, let $\left[a\right]$ denote a set $\left\{1,2,\dots ,a\right\}$ for any positive integer a. For each user $i\in \left[n\right]$, let ${\mathbf{A}}_i={(a_{i1},a_{i2},\dots ,a_{im})}^T$ be the resource allocation vector of user i, where $a_{ij}>0$ is the amount of resources j allocated to user i by the system. Let $\mathbf{A}={({\mathbf{A}}_1,{\mathbf{A}}_2,\dots ,{\mathbf{A}}_n)}^T$ be the allocation matrix for all users. Given an allocation $\mathbf{A}$, if the sum of the allocation of all users for any resource $j\in \left[m\right]$ is no more than $c_j$, we say this is a feasible allocation, i.e.,

$$\sum _{i=1}^n{a}_{ij}\le c_j,j\in \left[m\right].$$

(1)

As mentioned in [20], the number of tasks that need to be processed by each user is bounded in the real system. In this paper, let $B_i$ be the bounded number of tasks submitted by the user i. As in [2], given an allocation ${\mathbf{A}}_{\mathbf{i}}$ and $B_i$, each user $i’s$ utility is the maximum number of tasks it can run by using its allocated resources bounded by $B_i$, i.e.,

$$u_i\left({\mathbf{A}}_{\mathbf{i}}\right)=min(mi{n}_j{\displaystyle \frac{a_{ij}}{d_{ij}}},B_i).$$

(2)

Let $\mathcal{A}$ be the set of all feasible allocations. A popular criterion is often used for fair allocation, called max-min share (MMS) fairness [23], the core idea of which is to compute a feasible allocation in $\mathcal{A}$. In this allocation, everyone believes that it (approximately) maximizes the utility in the worst case [13,23], i.e.,

$$MM{S}_i=ma{x}_{\mathbf{A}:\mathbf{A}\in \mathcal{A}}mi{n}_{k:k\in \left[n\right]}{u}_i\left({\mathbf{A}}_K\right),\forall i\in \left[n\right].$$

(3)

Theorem 1, proved in the full version in [13], shows that the $MM{S}_i$ of each user i is the utility through equal allocation of resources.

Theorem 1.

For each user $i\in \left[n\right]$, the value of $MM{S}_i$ is equal to $u_i\left({\displaystyle \frac{c}{n}}\right)$.

For convenience, let $x_i=u_i\left({\mathbf{A}}_i\right)$ be the maximum (fractional) number of tasks user i can process by using its allocated resources. Given a feasible allocation $\mathbf{A}\in \mathcal{A}$, let $\mathit{\theta }=({\theta }_1,{\theta }_2,\dots ,{\theta }_n)$ be the max–min share (MMS) ratio vector of all users, where ${\theta }_i=x_i/MM{S}_i$ is the ratio of the utility of user i to $MM{S}_i$.

2.2. Allocation Properties

In a cloud computing system, how to design a fair and efficient mechanism for multi-resource sharing is a critical issue. Similarly to [2,20,21], the following core properties need to be satisfied for multi-resources with a bounded number of tasks:

• Pareto efficiency (PE). It is impossible to increase the number of tasks of any user processed on the system without decreasing the allocation of another user. Formally, given a feasible allocation $\mathbf{A}$, if there exists a user i satisfying

  $$u_i\left({\mathbf{A}}_i\right)\ge u_i\left({\tilde{\mathbf{A}}}_i\right)$$

  (4)

  for any feasible allocation $\tilde{\mathbf{A}}\in \mathcal{A}$, we say $\mathbf{A}$ is Pareto efficient.
• Sharing incentive (SI). This ensures each user can receive an allocation no worse than evenly allocated. Formally, for each user i, either $x_i=B_i$ or there exists a resource $j\in \left[m\right]$ such that

  $$x_i{d}_{ij}\ge c_j/n.$$

  (5)
• Envy-freeness (EF). No user prefers another user’s allocation. Formally, for each user i, either $x_i=B_i$ or for any user k, there exists a resource $j\in \left[m\right]$ such that

  $$d_{ij}{x}_i\ge d_{kj}{x}_k.$$

  (6)
• Group strategy-proofness (GSP). No user can process more tasks by forming a demand misreporting strategy coalition $\mathcal{C}$. Formally, suppose any user $i\in \mathcal{C}$ misreports its demand as ${\tilde{\mathbf{D}}}_i$, and the returned allocation is ${\tilde{\mathbf{A}}}_i$. The number of tasks user i can process will be no more than that of under true reporting, i.e.,

  $$u_i\left({\mathbf{A}}_i\right)\ge u_i\left({\tilde{\mathbf{A}}}_i\right).$$

  (7)

3. LMM-MMS Mechanism

In this section, we design a multi-resource fair allocation mechanism for fair resource sharing with a bounded number of tasks.

3.1. Lexicographic Max–Min Allocation

In the multi-resource fair allocation problem, the main problem is how to define ‘fair’. The well-known lexicographic max–min fairness [24] (LMM) is an interesting choice. Given a feasible allocation $\mathbf{A}\in \mathcal{A}$, we compute the max–min share (MMS) ratio vector $\mathit{\theta }$ for all users.

Definition 1.

An MMS ratio vector $\mathit{\theta }$ is called lexicographically max-min (LMM)-optimal, if for any feasible MMS ratio vector $\tilde{\mathit{\theta }}$, ${\mathit{\theta }}_r$ is lexicographically greater than ${\tilde{\mathit{\theta }}}_r$, where ${\mathit{\theta }}_r\left({\tilde{\mathit{\theta }}}_r\right)$ is the vector obtained by arranging the MMS ratio vector $\mathit{\theta }\left(\tilde{\mathit{\theta }}\right)$ in order of no decreasing magnitude.

For example, given two feasible MMS ratio vectors $\mathit{\theta }=(1.1,1.2,0.1)$ and $\tilde{\mathit{\theta }}=(0.5,0.4,0.6)$, $\mathit{\theta }$ is not LMM-optimal, as ${\tilde{\mathit{\theta }}}_r=(0.4,0.5,0.6)$ is lexicographically greater than ${\mathit{\theta }}_r=(0.1,1.1,1.2)$.

3.2. LMM-MMS Mechanism

An LMM-optimal max–min share (LMM-MMS) mechanism can be formally formulated as the following program (LMM-MMS):

$$\begin{array}{c}\hfill MAX({\theta }_1,{\theta }_2,\dots ,{\theta }_n)\\ \hfill st:\sum _{i=1}^n{x}_i·d_{ij}\le c_j,& \hfill \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall j\in \left[m\right]\end{array}$$

$$\begin{array}{cc}{x}_i\le B_i,\hfill & \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\forall i\in \left[n\right]\hfill \\ {\theta }_i=x_i/MM{S}_i,\hfill \\ x_i\ge 0.\hfill \end{array}$$

(8)

The first constraint ensures that the total amount of allocated resources does not exceed the capacity. The second constraint ensures that the number of tasks a user runs does not exceed its requirements. The third constraint defines the max–min share ratio.

Example 1.

Consider a scenario in a cloud computing system with two users and two types of resources (CPU and memory). The resource demands and requested task numbers of two users are (0.5, 1; 1) and (1, 0.5; 10), respectively, and the capacity vector of the two resources is (10, 4). By definition of the max–min share, we obtain $MM{S}_1=1$, $MM{S}_2=4$. The corresponding LMM-MMS is

$$\begin{array}{cc}\hfill MAX& ({\theta }_1,{\theta }_2)\hfill \\ \hfill st:& 0.5x_1+x_2\le 10\hfill \\ & x_1+0.5x_2\le 4\hfill \\ & x_1\le 1\hfill \\ & x_2\le 10\hfill \\ & {\theta }_1=x_1/1\hfill \\ & {\theta }_2=x_2/4\hfill \\ & x_1,x_2\ge 0\hfill \end{array}$$

Whose optimal value is (1, 1.5), achieved by setting $x_1=1$, $x_2=6$.

4. Scheduling Algorithm

The LMM-MMS optimal solution can be computed in an approximate way using the water-filling algorithm [1], by simulating the ‘water injection’ process, treating resource allocation as the process of injecting water into the container. The user with the lowest share of resources is determined and resources are allocated to that user. When computed using other variants [13,16], the running time is quite high. In this section, an efficient scheduling algorithm is designed to find the LMM-MMS optimal solution.

4.1. The LMM-MMS Scheduling Algorithm

Since each user i will not run more tasks than its task requirements $B_i$, the MMS ratios of user i in any feasible allocation are

$${\theta }_i^{max}=B_i/MM{S}_i.$$

(9)

Similarly to [20], for a positive number $\theta >0$, let $\mathbf{A}\left(\theta \right)=({\theta }_1,\dots ,{\theta }_n)$ be the MMS ratios, where ${\theta }_i=min\left\{{\theta }_i^{max},\theta \right\}$. We have the following lemma:

Lemma 1.

There exists a positive number ${\theta }^{*}$, where $\mathbf{A}\left({\theta }^{*}\right)$ is the LMM-optimal MMS ratio vector.

Proof of Lemma 1.

Let $\mathbf{A}\left({\theta }^{*}\right)=({\theta }_1^{*},\dots ,{\theta }_n^{*})$ be an LMM-optimal MMS ratio vector, where ${\theta }^{*}=ma{x}_i{\theta }_i^{*}$. Now suppose a contradictory scenario: if there exists a user $k\in \left[n\right]$, whose ${\theta }_k^{*}\ne min\left\{{\theta }_k^{max},{\theta }^{*}\right\}$, we have ${\theta }_k^{*}<{\theta }_k^{max}$ and ${\theta }_k^{*}<{\theta }^{*}$. Consider another user $h\ne k$, where ${\theta }_h^{*}={\theta }^{*}>{\theta }_k^{*}$. Since ${\theta }_k^{*}<{\theta }_k^{max}$, we have $x_k^{*}<B_k$, and we can construct a new MMS ratio vector $\tilde{\mathit{\theta }}=({\tilde{\theta }}_1,\dots ,{\tilde{\theta }}_n)$ by releasing a small enough number of resources from user h to user k, where

$$\begin{array}{c}\hfill {\tilde{\theta }}_i=\left\{\begin{array}{ccc}& (x_h^{*}-{\epsilon }_1)/MM{S}_h,& i=h,\\ & (x_k^{*}+{\epsilon }_2)/MM{S}_k,& i=k,\\ & {\theta }_i^{*},& i\ne k,h.\end{array}\right.\end{array}$$

(10)

Here, ${\epsilon }_1$ and ${\epsilon }_2$ are small enough positive numbers, where ${\epsilon }_2\le {\epsilon }_{1}mi{n}_j{r}_{hj}/r_{kj}$ and ${\tilde{\theta }}_h>{\tilde{\theta }}_k$. Clearly, ${\epsilon }_2{r}_{kj}\le {\epsilon }_1{r}_{hj}$ for each resource $j\in \left[m\right]$, which implies that $\tilde{\mathit{\theta }}$ is a feasible MMS ratio vector. Thus, ${\theta }_k^{*}<{\tilde{\theta }}_k<{\tilde{\theta }}_h<{\theta }_h^{*}$ and ${\tilde{\theta }}_i={\theta }_i^{*}$, $i\ne k,h$. This contradicts the assumption that $({\theta }_1^{*},\dots ,{\theta }_n^{*})$ is an LMM-optimal MMS ratio vector.    □

Theorem 2.

The LMM-MMS optimal solution can be found within time $O\left(n\right)$.

Proof of Theorem 2.

According to (9), the max MMS ratio set of all users, $\left\{{\theta }_1^{max},\dots ,{\theta }_n^{max}\right\}$ can be computed using the PICK method [25] to find the median value $\theta$ in $\left\{{\theta }_1^{max},\dots ,{\theta }_n^{max}\right\}$. Let ${\theta }_i=min\left\{{\theta }_i^{max},\theta \right\}$ and $x_i={\theta }_{i}MM{S}_i$. Obviously, if the above allocation is feasible, i.e., ${\sum }_{i=1}^n{x}_i{d}_{ij}\le c_j,\forall j\in \left[m\right]$, we have ${\theta }^{*}\ge \theta$. Otherwise, ${\theta }^{*}<\theta$. We distinguish the following two cases: (1) ${\theta }^{*}\ge \theta$. In this case, there must be at least half of the users i satisfying ${\theta }_i={\theta }_i^{max}$. Since ${\theta }_i=min\left\{{\theta }_i^{max},\theta \right\}$, we have ${\theta }_i^{max}<\theta <{\theta }^{*}$. Based on Lemma 1, we have ${\theta }_i^{*}=min\left\{{\theta }_i^{max},{\theta }^{*}\right\}={\theta }_i^{max}$, which implies the number of tasks these users can run is the same as their requirement, i.e., $x_i=B_i$. Now delete these users i and decrease the corresponding resources consumed by these users. (2) ${\theta }^{*}<\theta$. In this case, there must be at least half of the users i satisfying ${\theta }_i^{max}\ge \theta >{\theta }^{*}$ and ${\theta }_i=\theta$. Based on Lemma 1, we have ${\theta }_i^{*}=min\left\{{\theta }_i^{max},{\theta }^{*}\right\}={\theta }^{*}$. Thus, it is not feasible for the MMS ratio of these users i to be ${\theta }_i=\theta$. We merge these users i with ${\theta }_i=\theta$ into a ‘dummy’ user set $U_{dum}$. Given a feasible MMS ratio ${\theta }_{dum}$ for each user in $U_{dum}$, we have $x_i={\theta }_{dum}MM{S}_i$. Correspondingly, each user i in $U_{dum}$ consumes each resource $j\in \left[m\right]$ as $A_j^{dum}={\sum }_{i\in U_{dum}}{x}_{ij}{d}_{ij}={\sum }_{i\in U_{dum}}{\theta }_{dum}MM{S}_i{d}_{ij}$. For convenience, let ${\delta }_j={\sum }_{i\in U_{dum}}MM{S}_i{d}_{ij}$ and $A_j^{dum}={\theta }_{dum}{\delta }_j$.

Note that the number of users is reduced by at least half in both of the two cases. Again, use the PICK method [15] to find the median value $\theta$ in $\left\{{\theta }_i^{max}\right|$ i is the remaining user and is not the dummy user}. Then, compare the same two cases of $\theta$ and ${\theta }^{*}$ discussed above and delete the users by half correspondingly until there is only one dummy user. Finally, we find the user k with the biggest ${\theta }_k^{max}$ such that ${\theta }_k^{max}\le {\theta }^{*}$. For each user i satisfying ${\theta }_i^{max}\le {\theta }_k^{max}\le {\theta }^{*}$, let their LMM-optimal MMS ratio be ${\theta }_i^{*}={\theta }_i^{max}$. For each dummy user i satisfying ${\theta }_i^{max}>{\theta }_k^{max}$, after decreasing the resources consumed by these users i with ${\theta }_i^{max}\le {\theta }_k^{max}$, we can obtain the LMM-optimal MMS ratio by solving the following linear program (LP):

$$\begin{array}{cc}\hfill & max\theta \hfill \\ \hfill & \sum _{i\in U_{dum}}\theta MM{S}_i{d}_{ij}\le c_j-\sum _{i:{\theta }_i^{max}\le {\theta }_k^{max}}{B}_i{d}_{ij},\forall j\in \left[m\right].\hfill \end{array}$$

(11)

The optimal value of the above LP is

$${\theta }^{*}=mi{n}_j{\displaystyle \frac{c_j-{\sum }_{i:{\theta }_i^{max}\le {\theta }_k^{max}}{B}_i{d}_{ij}}{{\sum }_{i\in U_{dum}}MM{S}_i{d}_{ij}}}=mi{n}_j{\displaystyle \frac{c_j-{\sum }_{i:{\theta }_i^{max}\le {\theta }_k^{max}}{B}_i{d}_{ij}}{{\delta }_j}}.$$

(12)

For each dummy user $i\in U_{dum}$, set ${\theta }_i^{*}={\theta }^{*}$, and then we obtain the LMM-optimal MMS ratio vector $\mathbf{A}\left({\theta }^{*}\right)=({\theta }_1^{*},\dots ,{\theta }_n^{*})$. The scheduling algorithm is described in Algorithm 1.

At each iteration $k(1\le k\le lo{g}_{2}n)$, at most $n/(2^{k-1}+1)$ users remain, determining whether $\theta \ge {\theta }^{*}$ can be carried out within $O(mn/2^{k-1})$. Thus, the overall running time is $O\left(m(n+n/2+n/2^2+\dots +1)\right)=O\left(mn\right)$. Since the resource type m is a bound number in a cloud computing system [21], the running time is linear in n, and the time complexity of the entire process is $O\left(n\right)$.    □

To express the steps of the algorithm more clearly, we give an example.

Example 2.

Consider a scenario in a cloud computing system with three users and two types of resources (CPU and memory). The resource demands and number of requested tasks of three users are (1, 1; 2), (2, 2; 3), and (3, 3; 2), respectively, and the capacity vector of the two resources is (6, 6). By definition of the max–min share, we obtain $MM{S}_1=2$, $MM{S}_2=1$, and $MM{S}_3={\displaystyle \frac{2}{3}}$.

Algorithm 1 LMM-MMS scheduling algorithm

1: INPUT: $\mathbf{C}={(c_1,c_2,\dots ,c_m)}^T$, ${\mathbf{D}}_{\mathbf{i}}={(d_{i1},d_{i2},\dots ,d_{im})}^T$,$\left\{B_i\right\}$   2: OUTPUT: ${\mathit{\theta }}^{*}=({\theta }_1^{*},\dots ,{\theta }_n^{*})$   3: Step 1.  Initialization   4: ${\theta }_i^{*}=0,\forall i\in \left[n\right]$   5: $U=\left\{1,\dots ,n\right\}{U}_{dum}=\varnothing$,   6: $\mathcal{Q}=({\theta }_1^{max},\dots ,{\theta }_n^{max})$,   7: ${\theta }_{dum}=0,{\delta }_j=0,\forall j\in \left[m\right]$.   8: Step 2.  Using PICK method [25] to find median $\theta$ in $\mathcal{Q}$,   9: set ${\theta }_i=min\left\{{\theta }_i^{max},\theta \right\},\forall i\in \left[n\right],{\theta }_{dum}=\theta$. 10: if ${\theta }_{dum}{\delta }_j+{\sum }_{i\in U}{B}_i{d}_{ij}\le c_j,\forall j\in \left[m\right]$ then 11:     $c_j\Leftarrow c_j-{\sum }_{i:{\theta }_i^{*}={\theta }_i^{max}}{B}_i{d}_{ij},\forall j\in \left[m\right]$; 12:     $U\Leftarrow U\setminus \left\{i|{\theta }_i^{*}={\theta }_i^{max}\right\}$; 13: else 14:     ${\delta }_j\Leftarrow {\delta }_j+{\sum }_{i:{\theta }_i^{*}<{\theta }_i^{max}}MM{S}_i{d}_{ij},\forall j\in \left[m\right]$; 15:     $U_{dum}\Leftarrow U_{dum}\cup \left\{i|{\theta }_i^{*}<{\theta }_i^{max}andi\in U\right\}$; 16:     $U\Leftarrow U\setminus \left\{i|{\theta }_i^{*}<{\theta }_i^{max}andi\in U\right\}$; 17: end if 18: Step 3.   19: if $U\ne \varnothing$ then 20:     go to Step 2; 21: else 22:     for i in $U_{dum}$ do 23:     ${\theta }_i^{max}\Leftarrow mi{n}_j{\displaystyle \frac{c_j-{\sum }_{i:{\theta }_i^{max}\le \theta }{B}_i{d}_{ij}}{{\delta }_j}}$; 24: end if 25: Step 4.  Output ${\mathit{\theta }}^{*}=({\theta }_1^{*},\dots ,{\theta }_n^{*})$

First, the initialization operation is performed. The ${\theta }^{*}$ of all users is 0, $U=\left\{1,2,3\right\}$, and $U_{d}um$ is an empty set. According to the definition, we can calculate the set $\mathcal{Q}=({\theta }_1^{max},{\theta }_2^{max},{\theta }_3^{max})=(1,3,3)$. At the same time, ${\theta }_{dum}=0$, and any type ${\delta }_j$ is also 0, $\forall j\in \left[m\right]$. Next, consider picking out the median value $\theta$ from the set tm by the PICK method, and then all users are compared according to $\theta$ and the largest request task numbers ${\theta }_i^{max}$. In this case ${\theta }_{dum}=\theta =3$, the $\theta$ of the three users is ${\theta }_1=1,{\theta }_2=3,{\theta }_3=3$. In this setting, due to the median value $\theta$ being selected from $\mathcal{Q}$, the amount allocated can ensure that some users can reach the bounded number of requested tasks. Here, user 1 is satisfied, $\theta ={\theta }_1^{max}$, while user 2 and user 3 are not satisfied, so they are removed from the set U and enter the set $U_{dum}=\left\{2,3\right\}$. The current total allocation ${\delta }_j=4$ of resource j is updated, and the resource is first allocated to the user with a feasible allocation. On the premise of ensuring that the allocation of user 1 does not exceed the resource capacity, user 1 is allowed to allocate resources according to the maximum number of requested tasks that it can complete. The remaining resources are then updated, and user 1 is removed from set U. At this time, U is an empty set, and users in the $U_{dum}$ are considered, and the remaining resources are maximized and allocated to user 2 and user 3. Finally, the number of tasks completed by the three users is (2, 1, ${\displaystyle \frac{2}{3}}$). The total resource consumption is (6, 6), which means that all resources are consumed, due to the assumption that each user has the same demand for the two resources. So the amount of different resources allocated for three users is the same, which is (2, 2), (2, 2), and (2, 2), respectively.

4.2. Allocation Property Analysis

In this section, we analyze the allocation properties of LMM-MMS.

Lemma 2.

For any user $i\in \left[n\right]$, if $x_i^{*}<B_i$, we have ${\theta }_i^{*}\ge {\theta }_k^{*},k\in \left[n\right]$.

Proof of Lemma 2.

Considering the contradiction scenario, a user $h\ne i$ satisfies ${\theta }_h^{*}>{\theta }_i^{*}$. Based on (10), we can construct a feasible allocation and $\tilde{\mathit{\theta }}=({\tilde{\theta }}_1,{\tilde{\theta }}_2,\dots ,{\tilde{\theta }}_n)$, where ${\theta }_h^{*}>{\tilde{\theta }}_h>{\tilde{\theta }}_i>{\theta }_i^{*}$, and ${\tilde{\theta }}_h={\theta }_h^{*}$, $\forall h\ne i,k$. It is easy to verify that ${\tilde{\mathit{\theta }}}_r$ is lexicographically greater than ${\mathit{\theta }}_{\mathbf{r}}^{*}$, which contradicts ${\mathit{\theta }}^{*}$ being the LMM-MMS optimal vector. □

Theorem 3.

In a cloud environment with n users and m resource types, there is a clear upper limit on the number of tasks submitted by each user, LMM-MMS satisfies the PE property.

Proof of Theorem 3.

Suppose the contradictory scenario that LMM-MMS cannot satisfy PE, i.e., there is another feasible allocation $\tilde{\mathbf{A}}$ and at least a user i satisfies $u_i\left(\tilde{\mathbf{A}}\right)=u_i\left(\mathbf{A}\right)+\delta >u_i\left(\mathbf{A}\right)$ and $u_h\left(\tilde{\mathbf{A}}\right)=u_h\left(\mathbf{A}\right)$, $h\ne i$, where $\delta$ is a small enough positive number. Correspondingly, the MMS ratio vector under $\tilde{\mathbf{A}}$ is $\tilde{\mathit{\theta }}=({\tilde{\theta }}_1,{\tilde{\theta }}_2,\dots ,{\tilde{\theta }}_n)$, where $B_i/MM{S}_i\ge {\tilde{\theta }}_i>{\theta }_i^{*}$ and ${\tilde{\theta }}_h={\theta }_h$, $h\ne i$. Clearly, ${\tilde{\mathit{\theta }}}_r$ is lexicographically greater than ${\mathit{\theta }}_{\mathbf{r}}^{*}$, which contradicts ${\mathit{\theta }}^{*}$ being the LMM-MMS optimal vector. □

Lemma 3.

If $x_i^{*}<B_i$ for any user $i\in \left[n\right]$, then at least one resource is saturated.

Proof of Lemma 3.

Suppose the contradictory scenario that no resource is saturated. By Theorem 3, user i with $x_i^{*}<B_i$ can be allocated more resources to process more tasks, without reducing the other allocation, i.e., ${\tilde{x}}_i=x_i^{*}+\delta >x_i^{*}$, where $\delta =mi{n}_j(c_j-{\sum }_{h=1}^n{x}_h{d}_{hj})/d_{ij}$. Correspondingly, the new MMS ratio vector is $\tilde{\mathit{\theta }}=({\tilde{\theta }}_1,{\tilde{\theta }}_2,\dots ,{\tilde{\theta }}_n)$, where ${\tilde{\theta }}_i=(x_i^{*}+\delta )/MM{S}_i>{\theta }_i^{*}$, and ${\tilde{\theta }}_h={\theta }_h^{*}$, $h\ne i$. Clearly, ${\tilde{\mathit{\theta }}}_r$ is lexicographically greater than ${\mathit{\theta }}_{\mathbf{r}}^{*}$, which contradicts ${\mathit{\theta }}^{*}$ being the LMM-MMS optimal vector. □

Theorem 4.

In a cloud environment with n users and m resource types, there is a clear upper limit on the number of tasks submitted by each user, and LMM-MMS satisfies the SI property.

Proof of Theorem 4.

If $x_i^{*}=B_i$ for every user $i\in \left[n\right]$, then LMM-MMS satisfies the SI property. Otherwise, if there is a user k with $x_k<B_k$, we consider this situation in two cases: (1) For all users $i\in \left[n\right]$, there exists at least one resource j satisfying $x_k^{*}{d}_{kj}\ge c_j/n$. In this case, LMM-MMS satisfies the SI property. (2) For a user $k\in \left[n\right]$ with $x_k<B_k$ and for all resources $j\in \left[m\right]$, satisfying $x_k^{*}{d}_{kj}<c_j/n$. Since $x_k<B_k$, based on Lemma 3, without loss of generality, assume that resource j is saturated, i.e., ${\sum }_{i=1}^n{x}_i^{*}{d}_{ij}=c_j$. Based on Theorem 3, there must be at least one other user $h\ne k$ whose allocation is greater than an even allocation, i.e., $x_h^{*}{d}_{hj}>c_j/n$, and we have ${\theta }_h^{*}=x_h^{*}/MM{S}_h>1>{\theta }_k^{*}$, which contradicts Lemma 1. □

Theorem 5.

In a cloud environment with n users and m resource types, there is a clear upper limit on the number of tasks submitted by each user, LMM-MMS satisfies the EF property.

Proof of Theorem 5.

For any user $i\in \left[n\right]$, if $x_i^{*}=B_i$, user i will not envy other users. Now suppose a contradiction scenario in that $x_i^{*}<B_i$ and user i envies another user $h\ne i$. Clearly, we have $x_h^{*}{d}_{hj}>x_i^{*}{d}_{ij}={\theta }_i^{*}MM{S}_i{d}_{ij},\forall j\in \left[m\right]$. Thus, $x_h^{*}>{\theta }_i^{*}MM{S}_{i}ma{x}_j{\displaystyle \frac{d_{ij}}{d_{hj}}}$. Based on the definition of MMS ratio, we have $x_h^{*}>{\theta }_i^{*}mi{n}_j{\displaystyle \frac{c_j}{n{d}_{ij}}}ma{x}_j{\displaystyle \frac{d_{ij}}{d_{hj}}}\ge {\theta }_i^{*}mi{n}_j{\displaystyle \frac{c_j}{n{d}_{hj}}}={\theta }_i^{*}MM{S}_h$. According to Lemma 2, we have ${\theta }_i^{*}\ge {\theta }_k^{*},\forall k\in \left[n\right]$. Thus, $x_h^{*}>{\theta }_i^{*}MM{S}_h\ge {\theta }_h^{*}MM{S}_h=x_h^{*}$. A contradiction. Therefore, LMM-MMS satisfies the EF property. □

Theorem 6.

In a cloud environment with n users and m resource types, there is a clear upper limit on the number of tasks submitted by each user, LMM-MMS satisfies the GSP property.

Proof of Theorem 6.

Let $\tilde{\mathit{\theta }}=({\tilde{\theta }}_1,{\tilde{\theta }}_2,\dots ,{\tilde{\theta }}_n)$ be the LMM-MMS optimal MMS ratio vector when a coalition $\tilde{U}\subseteq \left[n\right]$ misreports their demand as ${\tilde{\mathbf{D}}}_i\ne {\mathbf{D}}_i,\forall i\in \tilde{U}$. We consider this scenario in two cases:

(1) If $x_i^{*}=B_i$ for any user $i\in \tilde{U}$. In this case, the user i can not increase its utility by misreporting.

(2) If $x_i^{*}<B_i$ for any user $i\in \tilde{U}$. Based on Lemma 2, we have

$${\theta }_i^{*}\ge {\theta }_h^{*},\forall h\in \left[n\right].$$

(13)

Let $({\tilde{x}}_1,\dots ,{\tilde{x}}_n)$ be the number of tasks processed vector under the LMM-MMS allocation of misreporting. For user $i\in \tilde{U}$, we have ${\tilde{\theta }}_i={\tilde{x}}_i/{\widetilde{MMS}}_i$. Where ${\widetilde{MMS}}_i=mi{n}_j{c}_j/n{\tilde{d}}_{ij}$. Meanwhile, for user $h\in \left[n\right]/\tilde{U}$, we have ${\tilde{\theta }}_h={\tilde{x}}_h/MM{S}_h$. Now, Suppose the contradictory scenario, where $x_i^{*}\le {\tilde{x}}_i$, $\forall i\in \tilde{U}$, we have

$$x_i^{*}{d}_{ij}<{\tilde{x}}_i{\tilde{d}}_{ij},\forall j\in \left[m\right]and{\theta }_i^{*}<{\tilde{\theta }}_i.$$

(14)

Based on Lemma 3, since $x_i^{*}<B_i$ in the original case, there is at least one resource j saturated, i.e., ${\sum }_{k=1}^n{x}_k^{*}{d}_{kj}=c_j$. When user $i\in \tilde{U}$ misreports its demand, we have ${\sum }_{i\in \tilde{U}}{\tilde{x}}_i{\tilde{d}}_{ij}+{\sum }_{i\in \left[n\right]/\tilde{U}}{\tilde{x}}_i{d}_{ij}\le c_j$ and $x_i^{*}{d}_{ij}<{\tilde{x}}_i{\tilde{d}}_{ij},\forall i\in \tilde{U}$. Clearly, at least one user $h\in \left[n\right]/\tilde{U}$ receives fewer resources than if all users were truthful, i.e., $x_h^{*}{d}_{hj}<{\tilde{x}}_h{d}_{hj}$, which implies ${\tilde{x}}_h<x_h^{*}\le B_h$, and

$${\tilde{\theta }}_h={\tilde{x}}_h/MM{S}_h<x_h^{*}/MM{S}_h={\theta }_h^{*}.$$

(15)

Since ${\tilde{x}}_h<B_h$, based on Lemma 2, we have

$${\tilde{\theta }}_h\ge {\tilde{\theta }}_i.$$

(16)

combining (11)–(14), we can conclude ${\tilde{\theta }}_h\ge {\tilde{\theta }}_i>{\theta }_i^{*}\ge {\theta }_h^{*}>{\tilde{\theta }}_h$. A contradiction. Therefore, no user in a coalition $\tilde{U}$ can increase its utility by demand misreporting. Thus, LMM-MMS satisfies the GSP property. □

5. Experimental Results

The performance of our proposed method is evaluated in this section using trace-driven simulation data provided by Alibaba. In particular, we compare LMM-MMS with DRF and AF. We compare all three mechanisms in terms of performance indicators related to the average resource utilization effectiveness, the completion rate of user jobs, and the sharing degree. Specifically, resource utilization represents the ratio of each resource (CPU, memory) allocated to the user from the system resource capacity. The user job completion rate represents what percentage of task requests (maximum number) submitted by users reach completion status. The sharing incentive property of LMM-MMS, as outlined in Section 4.2, is assessed through the sharing degree metric. Our simulation setup is described as follows.

5.1. Experimental Setup

To evaluate LMM-MMS at a larger scale, we simulated cluster replay logs from Alibaba clusters. The simulation replicated key characteristics from the original trace, including resource requirements (CPU, memory) for tasks and the quantity of tasks within each job that the users submitted. The simulation settings were as follows:

(1) Alibaba’s trace data provide comprehensive details about user-submitted tasks on a 4000-server cluster spanning an 8-day period. This information is categorized into machine_meta, machine_usage, container_meta, container_usage, batch_instance, and batch_task, as outlined in the scheme [26]. Our simulation extracted relevant data from batch_task, specifically task_name, plan_cpu, plan_mem, and instance_num.

(2) Each user’s resource requirements included both CPU and memory, generated according to the actual probability distribution of demands found in the batch_task data. For our purposes, we considered plan_cpu and plan_mem as representative of a user’s task resource requirements. Figure 1 depicts the memory and CPU consumption patterns across the various tasks. The area of each circle is logarithmic to the number of tasks represented within that region.

(3) For system resource capacity, we represent this as a column vector $R={(100,100)}^T$, indicating that the system comprises a total of 100 CPU cores and 100 GB of memory. Furthermore, all requirements were stochastically generated following the actual probability distribution of resource demands observed in the cluster trace. We evaluated the effect of user requirements at different scales on resource utilization.

(4) The task requirements of the users and the number of tasks were extracted according to the probability distribution of the Alibaba cluster dataset. In addition, the dataset was divided into normal task requirements and large task requirements, and quantitative extraction was carried out according to the proportion of large tasks.

(5) In order to simulate the provider specifications in real scenarios, four cloud servers with different specifications (100, 100), (500, 500), (50, 500), and (500, 50) were set up. Each specification corresponded to different CPU and memory capacities, and different experiments were set up for different specifications for comparison.

(6) Each experimental setting involved generating 100 random samples. We used the average of the experimental results to overcome randomness.

(7) We used the following metrics to evaluate the algorithm performance: Resource utilization reflects the efficiency of the mechanism and is a direct indicator for evaluating performance from a system perspective. Task completion rate reflects the effectiveness of the mechanism and is a key indicator for evaluating performance from a user’s perspective. The cumulative distribution function provides an intuitive representation of resource allocation fairness and helps understand the allocation characteristics of the mechanism.

5.2. The Impact of User Requirement Scale on Allocation

We first evaluated the performance of LMM-MMS with respect to the other two mechanisms under the setting of various user requirement scales. Figure 2 illustrates the resource utilization of LMM-MMS, DRF, and AF. Figure 2a shows that the LMM-MMS mechanism maintained a CPU resource utilization rate of nearly 100% under all user scales (50–300 users). Figure 2b shows it also performed well in memory utilization, maintaining around 80–85% for all user scales. When resources were not saturated, LMM-MMS demonstrated superior performance compared to both DRF and AF regarding resource utilization. This advantage stemmed primarily from LMM-MMS’s dual objective: ensuring fair allocation, while simultaneously maximizing efficiency of resource usage.

The experiments revealed that as the number of users grew, the LMM-MMS mechanism maintained stability and high efficiency at all scales, showing good adaptation to different scales. While ensuring fairness, it could achieve high resource utilization, which successfully solves the problem of the inefficiency of traditional fair distribution mechanisms (such as AF).

5.3. The Impact of Resource Capacity on Allocation

Real-world data centers exhibit varying configurations, resulting in disparate capacities across different resource types. Substantial gaps may exist between various resource capacities. For instance, data centers primarily processing computational workloads might feature extensive CPU capacity but limited memory resources. Conversely, data centers focused on data processing tasks may predominantly possess memory-centric configurations.

Our experimental setup involved 100 users across three distinct scenarios with varying resource capacity vectors: $R_1={(500,500)}^T$, $R_2={(500,50)}^T$, and $R_3={(50,500)}^T$ to show how capacity variations influenced allocation outcomes. Figure 3 presents a comparative analysis of the resource utilization across four allocation mechanisms under these different capacity configurations. The results demonstrate that LMM-MMS performed at least as effectively as alternative mechanisms when the resource capacities were balanced. In scenarios with significant capacity differences, LMM-MMS exhibited a performance advantage ranging from 12.3% to 15.59% over the other mechanisms.

These experimental results show the effectiveness of the proposed resource allocation mechanism based on the maximum and minimum share in improving the resource utilization rate of cloud computing environments, and also verify the applicability and advantage of this mechanism under the constraints of bounded tasks.

5.4. The Impact of the User Requirement Workload Type on Allocation

Our experiment showed how varying types of workload requirements affect resource utilization. With a total of 100 user requirements, we established five test scenarios with different proportions of elephant requirements: 0%, 5%, 10%, 20%, and 50%. The resource utilization across these different experimental configurations is illustrated in Figure 4. The results revealed that LMM-MMS achieved a progressively higher resource utilization as the proportion of elephant requirements increased, compared to alternative mechanisms. Specifically, when the elephant requirements accounted for 50% of the total requirements, the utilization rates exceeded those observed in scenarios with 20%, 10%, and 5% elephant requirements. This result demonstrates the significant influence that elephant requirement ratios exert on overall resource utilization. Notably, LMM-MMS delivered strong performance across all configurations, with particularly impressive results in scenarios characterized by high percentages of large requirements.

The results from these experiments demonstrate the efficacy of our proposed allocation mechanism based on the maximum and minimum share in improving the resource utilization rate of the cloud computing environment, especially in complex scenarios of a bounded number of task constraints and the existence of elephants.

5.5. The Completion Rate of User Jobs Under Different User Scales

To evaluate the efficiency of user task execution under LMM-MMS allocation, this experiment evaluated the user job completion rate under different user sizes, where the user completion rate refers to the ratio of the number of users completing the task to the number of all users. Figure 5 illustrates that LMM-MMS outperformed DRF and AF for user task completion rate unless the resource was saturated.

The experimental results strongly demonstrate the effectiveness of the proposed max–min share-based resource allocation mechanism in improving the task completion ratio, especially in complex scenarios with bounded task number constraints and a large number of users.

5.6. Sharing Incentive

In our final experiment, we evaluated the sharing incentive property of LMM-MMS. As previously demonstrated in Section 4.2, LMM-MMS satisfies this property, which ensures that the allocations for each user are at least as favorable as what they would receive through an equal division of the available resources. To achieve this, we calculated task completion under a basic allocation where each user i received exactly $1/n$ of every resource from the data center, enabling them to execute $min(mi{n}_j\left\{{\displaystyle \frac{C}{n{d}_{ij}}}\right\},B_i)$ tasks. The completion ratio achieved through this elementary allocation (EA) was then compared against the results obtained using LMM-MMS allocation. The cumulative distribution function (CDF) outcomes from 100 experimental runs with 100 and 300 users are presented in Figure 6. Figure 6 demonstrates that allocations via LMM-MMS were consistently preferred by all users when compared to executing tasks within dedicated resource pools. This further validated that LMM-MMS satisfies the sharing incentive property.

The above experimental results show that compared with the other two mechanisms, the LMM-MMS mechanism had significant advantages in sharing degree distribution, see Figure 6. The experimental results strongly demonstrate the effectiveness of the proposed max–min share-based resource allocation mechanism in improving resource utilization, while maintaining reasonable fairness.

6. Conclusions and Future Work

In this paper, we proposed a polynomial-time lexicographic Maximin Share-based (LMM-MMS) fair allocation mechanism. We showed that LMM-MMS satisfies PE, SI, EF, and GSP properties. Our large-scale simulation, driven by Alibaba, showed that, compared to traditional fair allocation mechanisms such as DRF and AF, LMM-MMS achieved better results for resource utilization and the completion rate of user jobs over other mechanisms. In addition, LMM-MMS satisfied the property of sharing incentive in all cases.

As mentioned in [23], the MMS-based mechanism can satisfy PE, SI, and EF1 in the indivisible case. It would be interesting to design an efficient mechanism to find a solution satisfying the above three properties with a bounded number and indivisible tasks. In addition, the LMM-MMS mechanism can solve the static fair resource allocation problem, while cloud computing environments typically experience dynamic resource fluctuations due to node failures or elastic scaling. In the future, we will study the dynamic mechanism to solve the fair allocation problem and ensure high task completion rates, while maintaining fairness. Such extensions would further enhance the practical applicability of our approach in real-world cloud computing systems.