Abstract
Resource allocating mechanisms draw much attention from various areas, and exploring the truthfulness of these mechanisms is a very hot topic. In this paper, we focus on the max-min fair allocation in a centralized resource system and explore whether the allocation is truthful when a node behaves strategically. The max-min fair allocation enables nodes receive appropriate resources, and we introduce an efficient algorithm to find out the allocation. To explore whether the allocation is truthful, we analyze how the allocation varies when a new node is added to the system, and we discuss whether the node can gain more resources if it misreports its resource demands. Surprisingly, if a node misrepresents itself by creating several fictitious nodes but keeps the sum of these nodes’ resource demands the same, the node can achieve more resources evidently. We further present some illustrative examples to verify the results, and we show that a node can achieve times resource if it misrepresents itself as two nodes. Finally, we discuss the influence of node’s misrepresenting behavior in tree graph: some child nodes gain fewer resources even if their parent node gains more resources by creating two fictitious nodes.
1. Introduction
Fairly allocating limited resources (such as fossil fuels, clean water, and cyber source) has been widely studied. With so many competing needs and demands, lots of relevant works have been done. In early 1940s, considering the notion of proportionality, Steinhaus put forward a method to ensure participants receive at least of each participant’s own value for getting everything [1]. In a 1958 book of mathematical, Gamow and Stern [2] introduce the formal notion of “envy-freeness,” in which participants preferring to keep their own allocation to swapping with other participants. Since then, research in this area has aroused widespread concern and has been applied to solve many important real-world problems [3–5].
Motivated by sharing economy concepts [6], nodes in a multiagent system may take strategic behaviors to gain larger utility. In [7], it proves that designing a truthful mechanism that guarantees a market equilibrium outcome in general is impossible when an agent has the incentive to misreport its information (such as its resource amount or demand). Some extant works also show that the truthfulness of resource allocating mechanisms cannot hold for a cheating node [8, 9]. However, the impossibility theorem proposed in [7] is not always correct for some restricted settings. For example, the proportional sharing mechanism is proved to be robust to agents’ cheating, including an agent misreporting its resource or the connectivity with the rest of network [10, 11].
In this paper, we explore the truthfulness of resource allocation in a restricted setting. We consider a centralized resource system where only a central controller holds the resources that can be allocated to other nodes. Each node reports its resource demand to the controller who is in charge of allocating appropriate resources to the node. For example, each computer in a cluster of data center may require some resources while the central controller would make a fair resource allocation to all computers. In order to evaluate the fairness of a resource allocation, we adopt the concept of max-min fairness (a widely used concept in networks, such as window flow central protocols [12], packer-switched network [13], and data network [14]) and explore whether the max-min fair allocation in the centralized resource system could be truthful if a node behaves strategically.
To begin with, we study the property of max-min fair allocation and introduce an efficient algorithm to find out the resource allocation mechanism. Afterwards, we explore how the nodes would be affected if a new node is connected to the controller. To study the truthfulness of the max-min fair allocation, we assume the new node could misreport its resource demand, and we analyze how this behavior changes the other nodes’ allocation. In addition, we explore the effect of a novel splitting strategy that is proposed in recent work [15], where a node misrepresents itself by creating several fictitious agents but keeps the sum of the nodes’ resource demand unchanged.
We summarize the contributions of the paper as follows: (1)We introduce a simple and straightforward algorithm to find out the max-min fair allocation in a centralized resource system(2)When a new node is connected to the controller, we analyze how much resource the new node could receive and how the other nodes’ resource would be affected(3)We explore the truthfulness of the max-min fair allocation. If the new node misreports its resource demand, we show that it cannot gain more resources through this strategic behavior(4)We analyze the effect of node’s misrepresenting behavior. By splitting itself into multiple nodes, a node could gain more resources in the allocation. Specifically, if a node is split into two nodes, it can achieve about two times resource compared to the allocation that it is honest under some special situations(5)We analyze the effect of node’s misrepresenting behavior for its child nodes on tree graph. Resources are passed down from the root node layer by layer. By splitting itself into two nodes, its child node gains fewer resources in the allocation under some special situations even if it received more resources from its parent node
We also present some numerical examples to illustrate these interesting results, and the examples show that the splitting strategy could indeed help a node gain about times resource if it is split into two nodes (as shown in Table 1). What is more, some numerical examples are presented to show the influence of parent’s splitting strategy on its child on tree graph. Some children gain fewer resources by its parent’s splitting strategy.
The rest of the paper is organized as follows. The next section lists some related works about truthfulness of resource exchanging and allocation mechanisms. The preliminaries are introduced in Section 3. We present the efficient algorithm that finds out the max-min fair allocation in Section 4. When a new node is connected to the controller, we analyze the change of the allocation in Section 5. The truthfulness of the allocation is discussed in Section 6 if the new node misreports its resource, while the splitting strategy that could help gain more resources is analyzed in Section 7. The effect of node’s splitting strategy for its child nodes on tree is analyzed in Section 8. Finally, we present some numerical examples in Section 9 and conclude the paper in Section 10.
2. Related Work
The star network is generic and representative for many communication or economic networks. For example, the star network is commonly used in clustering of multityped heterogeneous networks [16], which extend the classical clustering on bityped heterogeneous networks [17]. Various networks have been mapped to the star networks [18], and we study the problem on the star network.
There are lots of researches about resource allocation in centralized system. One of the most critical resource allocating problems is the cake-cutting problem that is dividing a birthday cake among several children. During the World War II, Steinhaus, Knaster et al. [1] initiated the study of fair cake-cutting algorithms. How to help players achieve fair allocations is one of the most important strands in cake-cutting problem. Since then, a large number of related studies have emerged [5, 19, 20].
In resource exchange networks, max-min fairness is a simple and well-recognized approach to define a fair allocation in network [21–24], which has been widely adopted in economics [15, 25]. It is also used in ant colony algorithm for load balancing in could systems [26], and it is combined with convolutional neural networks for image classification [27].
In resource exchange networks, agents may be strategic, which makes the truthfulness of allocation mechanism being of paramount importance. In order to gain larger utility, an agent may misreport its true information, which may affect the market equilibrium. In [7], the authors prove that it is impossible to design a truthful mechanism that guarantees a market equilibrium outcome in general. In a Fisher market game with linear utility, agents can unilaterally deviate and get a better payoff [8]. Even more specifically, agents may double its benefit by strategic behaviors [9]. Therefore, we also discuss about the truthfulness of the max-min fair allocation in a star network in this paper.
Generally, there are two types of agent strategic behaviors: misreporting its own resource amount and cheating on its connectivity with the rest of the network. By cheating on the connectivity, such as a missing edge or splitting a node into multiple nodes may affect the resource allocation mechanism. In [28], it examines the incentive problem in mechanism design in Internet applications or peer-to-peer systems when an agent misrepresents itself by creating several fictitious agents, which is also called false name bid. In [29], it measures how an agent gains if it deviates from its truthful behavior. In [30], it shows that agents’ selfish behavior may contribute to the loss of social efficiency in Nash equilibrium in comparison to social optimality. In this paper, we adopt the splitting strategy to gain more resources in a star network.
3. Preliminaries
Consider a centralized resource system where a central node holds the resources that can be allocated to the other nodes . For any node , denote as the largest amount of resource can receive (we regard it as resource demand or resource limitation). Considering an allocation mechanism, denote as the amount of resources node receives from the central node, ; denote as the resource transfer rate due to the link quality between the nodes. We assume that the resources would decay along the link, and thus, the central node actually allocates resources to node (in traditional resource exchange or allocation mechanisms, we can set ). Hence, . Denote as the utility of node after receiving the resources from the central node, which can be represented by where is a monotone increasing function. For simplicity, we assume in this paper and denote as the utility vector. To explore the effect of nodes’ strategic behavior, we denote as the reported strategy of node , as the nodes’ reported strategy profile and as the profile without node . We denote as the utility of node when it reports its strategy as . The problem is to explore the truthfulness of the centralized max-min fair resource allocation problem. First, we are to find a max-min fair allocation vector . To begin with, we introduce the property of max-min fairness.
Definition 1 (see [31]). A vector is a max-min fair vector on set if and only if for all , if there exists such that , there must exist such that .
The definition of a max-min fair vector reveals that increasing some element of a max-min fair vector must be at the expense of decreasing some smaller (or equal) element of the vector.
Definition 2 (see [32]). A set is max-min achievable if there exists a max-min fair vector on .
The following proposition shows the uniqueness property of the max-min fair vector. If we can find out a max-min fair vector, it is the unique one.
Proposition 3 (see [31]). If a max-min fair vector exists on a set , then it is unique.
Definition 4. A mechanism is truthful if no agent can benefit strictly from misreporting its amount of resource irrespective of what is reported by other agents.
Formally, given a node with true strategy and the profile , it holds that for any reported strategy ,
In this paper, we first design a mechanism that finds out the max-min fair utility vector in a centralized resource system. Then, we explore the effect of two strategic behavior: misreporting and misrepresenting. We formalize the problems as:
Problem 5. Considering a centralized resource system where the central node holds resource that can be allocated to nodes . The problem is to design an allocation mechanism such that the utility vector is the max-min fair vector.
The problem is equivalent to finding out the max-min fair allocation vector . If one node gets more resources through another allocation mechanism, another node who receives fewer resources than (i.e., ) would get resources fewer than in the new mechanism; this implies that increasing a node’s resource of the max-min fair allocation would reduce a node’s resource who originally receives fewer resources.
The max-min fair allocation mechanism could ensure the fairness among the nodes. When the system changes, such as a new node is connected to the central node, how many resources the new node should receive and will the other nodes be affected? This is the second problem we study. We formulate the problem as follows.
Problem 6. Considering a centralized resource system and the max-min fair allocation vector , if a new node with resource limitation and transfer rate is connected to the central node, find out the max-min fair allocation vector and how the nodes are affected.
In practice, some nodes may cheat to gain more resources. A simple cheating strategy is to misreport its resource limitation . We also analyze the truthfulness of the new node in Problem 6 and show that misreporting cannot help gain more resources (see Section 6). Therefore, we propose the splitting strategy to gain more resources as the following problem.
Problem 7. Considering a centralized resource system , if a new node is connected to the central node with resource limitation and transfer rate , we denote the max-min fair allocation vector as . If the node is assumed to be split into two nodes with resource limitations () and the same transfer rate , find out the max-min fair allocation and analyze whether the node can gain more resources () compared to the received resource of the original allocation ().
4. The Max-Min Fair Allocation Algorithm
We present the max-min fair allocation algorithm as Algorithm 1. The input of the algorithm is the resource limitation of each node and the resource transfer rates . The algorithm is to find the max-min fair vector , which is equivalent to the allocation vector .
As depicted in Algorithm1, is firstly sorted by increasing order (line 3) and denotes the corresponding nodes as where for any . The resources are allocated to nodes from to according to lines 5-9. There are two situations: if the resources are adequate enough (line 5), node can receive the resources that are up to its limitation (line 6), or it is set as line 8. We show that the correctness of the algorithm by verifying the allocation vector (corresponding to the utility vector ) is the max-min fair vector.
Theorem 8. The output vector of Algorithm 1 is the max-min fair vector.
Proof. For simplicity, we assume the input vector is already ordered such that . We prove the theorem from two situations.☐
For the first case, suppose , which implies the central node has enough resources to ensure all nodes’ resource demands can be satisfied. Thus, . According to the definition of max-min vector, any element of the can not be larger; hence, is the max-min fair vector.
| ||||||||||||||||||||||||||||
For the second case, suppose ; there must exists such that , , and since Algorithm 1 computes sequentially from to . Then, we derive the output of Algorithm 1 as
For any other allocation vector , if there exists such that , for any satisfying , suppose ; then, we have , which leads to a contradiction since the allocation exceeds the amount of all resources . Therefore, there exists such that . By Definition 1, is the max-min fair vector.
Combining the two cases, the theorem holds.
From Proposition 3, the max-min fair vector is unique, and Algorithm 1 can find out the vector efficiently. We analyze the complexity of Algorithm 1 briefly. The complexity of sorting on line 3 is , and the complexity of computing each in each step (lines 5-9) is . Thus, the complexity of the algorithm is . In [32], the Max-Min Programming Algorithm (MP) is proposed to find the smallest element of the max-min fair vector by solving several linear programming. The complexity of MP algorithm is where is the complexity of a linear program. Considering the problem we study in the paper, MP algorithm can be applied to find out the max-min allocation vector, but it works much slower than Algorithm 1. In the following parts, we adopt our algorithm to find out the max-min allocation mechanism when a new node is inserted or a node is split into multiple nodes.
5. Resource Allocation Varies for a New Node
In a centralized resource system with the max-min fair allocation vector , if a new node is connected to the central node whose resource limitation is and transfer rate is , denote the max-min fair allocation vector of the new system as . We analyze the relationship between and , which implies how the nodes’ resources change regarding to the new inserted node.
Let be the spare resources under the max-min fair allocation vector before the new node is inserted; we formulate it as
For simplicity, we suppose the nodes’ resource limitations satisfy . We analyze how the max-min fair allocation changes when node is added to the system from two cases: (i)Case 1. (ii)Case 2.
To begin with, we introduce a property of the max-min allocation mechanism which implies that the nodes with fewer received resources remain the same if a node with more resources does not change.
Property 9. In the max-min allocation, if there exists such that , for all , .
Proof. Suppose there exists satisfying , according to the allocation algorithm (Algorithm 1), since , we can derive hence , which makes a contradiction.☐
We analyze how the max-min fair allocation varies for the first case.
Theorem 10. If , the new allocation holds , and does not change when the new node is inserted.
Proof. When , the spare resources are enough. It is obvious that . Suppose there exists satisfying (if , we let , and such exists), we derive According to lines 5-8 of Algorithm 1, . From Property 9, when , . For any where , we can compute Hence, from lines 5-8 of Algorithm 1, . The proof for the special cases and is similar, and we omit the details. Combining these aspects, the theorem holds.☐
We then analyze how the max-min fair allocation varies for the second case when . First, we find out a threshold such that the nodes with resources fewer than do not change their received resources (Lemma 11). Then, we analyze the change of nodes who received resources larger than from two cases: (Lemma 12) and (Lemma 13). Finally, we compute the allocated resources of the new inserted node (Lemma14).
Lemma 11. If , there exists such that any node satisfying , under the new max-min fair allocation vector.
Proof. Suppose , we derive hence Then, we find the largest integer satisfying the above inequality, and we derive Thus, we figure out the threshold value as Since , for any node with , by property 5. The lemma holds.☐
It is easy to check that the node with received resources in the original allocation vector before the new node is inserted. Finding out the threshold value , these nodes’ received resources do not change. For the nodes with , we analyze them from two cases: and .
Lemma 12. If , , for any node satisfying , under the new max-min fair allocation vector.
Proof. First, we show that under the new max-min fair allocation for any node satisfying . This means the threshold divides the nodes into two subsets; one subset contains nodes that receive resources up to its limitation as Lemma 11, while the other subset consists of nodes with resource limitation larger than and cannot receive resources up to its limitation.
Suppose there exists a node such that and . According to Property 9, node () receives resources .
There are two cases: and . For the first case that , we drive
which is a contradiction. When , we can deduce a contradiction similarly. Therefore, for node with .
Then, we show that node with receives fewer resources compared to the original max-min fair allocation; that is, . Denote , suppose , we can derive
which is a contradiction.
Combining the two sides, holds.☐
Lemma 12 implies that if the new node’s resource limitation is large , all nodes with large resources limitation () have to reduce its received resources. If , fewer nodes have to reduce its resources, and we show it in the next lemma.
Lemma 13. If , , there exists such that the following two results hold: (i)If node satisfies , (ii)If node satisfies ,
Proof. If , there exists such that ; we have
thus . According to Property 9, if , which implies . Since , nodes with more resources would reduce its resources, and there must exist such that if (nodes do not change their resources), and if (nodes reduce their resources).
Next, we show that the value . It is clear that if , . Suppose , we derive
combining the formulation of , we show that
Thus, holds. It is easy to check node with receives resources in the original allocation. Finding out the threshold value , these nodes’ received resources do not change. Under the new max-min fair allocation, the node with receives resources , and the proof is similar to that of Lemma 12.☐
Lemma 14. If , there exists such that if , and if .
Proof. According to the proof of Lemma 13, if . We show that if .
Suppose , if , we derive
which is a contradiction. Thus, the lemma holds.☐
Combining Lemmas 11, 12, 13, and 14, we conclude the situation when the spare resources are inadequate as Theorem 15.
Theorem 15. If , there exist two thresholds as Lemma 11 and Lemma 13. If , the nodes satisfy: If , the nodes satisfy:
6. Truthfulness against the Misreporting Strategy
In this section, we analyze the truthfulness of the max-min fair allocation. Denote as the allocation after the new node is inserted. Denote as the resource limitation vector where the new node’s limitation suits . Denote as the vector before the new node is inserted. We study how the allocation varies when the new node misreports its resource limitation.
As shown in the previous section, the allocated resources of the new node can be regarded as a function of when is fixed. Suppose the new node misreports its resource limitation as ; we analyze the effect from two situations (the spare resources are adequate) or .
Lemma 16. When , if the new node reports fewer resources ; if the node reports more resources (), at most resources would be wasted where .
Proof. According to Theorem 2, for any under the max-min fair allocation; this implies that the node would receive fewer resources if it reports fewer. If the node reports more resources, the central node may allocate more resources, but the resources beyond its true limitation would be wasted. From Lemma 11, the largest amount of resources that the new node could receive is ; therefore, at most resources would be wasted.☐
Lemma 17. When , there exists a real number satisfying the following conditions: (i)If , for any , is a monotonically increasing function of and no resource is wasted; for any , at most resources are wasted(ii)If , for any , ; for any ; therefore, no resources are wasted
Proof. To begin with, we derive the value of by the following three cases: (1)If , (2)If , (3)If and , from Lemma 11 to derive ☐
For simplicity, we only show the proof sketch of the third case. According to Lemma 11, when , thus is a monotonically increasing function of . Regardless of what value the new node reports, the received resources cannot be larger than . Hence, if and , , and no resource is wasted. However, when and , the new node receives more resources than its true limitation, causing at most resources wasted. Thus, the lemma holds. The proof of the other two cases are similar, and we omit the details.
According to Lemmas 16 and 17, the new node misreport that its resource limitation cannot gain more resources, and some resources would be wasted under some circumstances.
7. Truthfulness against the Spitting Strategy
The previous section shows that a node cannot gain more resources by misreporting its resource limitation. In this section, we propose a novel method which may help the node receive more resources. Suppose a new node’s resource limitation is ; it reports to the central node that two nodes are inserted, and the sum of their resource limitations is . This implies that the node is assumed to be split into two nodes with resource limitations , and ; we call this splitting strategy. We analyze when the node could achieve more resources through this method.
There are four cases according to the values of (the resource limitation of the new node), (the largest resource limitation of the original nodes), and (the spare resources before the new node is inserted, Equation (3)): (i)Case 1: (ii)Case 2: and (iii)Case 3: and
In this section, we show that the new node cannot gain more resources for the first two cases (Lemmas 18 and 19), but it can gain more resources for cases 3 (Lemma 20). Denote the two virtual nodes of as and the received resources as , respectively. Denote the received resources of node as if it does not report two nodes. We show the following lemmas:
Lemma 18. If , the splitting strategy has no effect to the new node, i.e., .
Proof. Without loss of generality, suppose and . When node is inserted, we derive then . When node is inserted, we derive then . Therefore, , which implies that the new node cannot gain more resources through the splitting strategy.☐
Lemma 19. If and , the splitting strategy has no effect to the new node, i.e., ; thus, there is still no need to split the node.
Proof. Since and , we derive , which implies . Without loss of generality, suppose , there are two cases
(1) and (2) and If , suppose ; notice that
When node is inserted, . When node is inserted, from , we have
thus the allocated resources are
Combining two nodes’ resources, .
For the second case, and ; notice that after the two nodes are inserted, for any node , . If , we derive
Therefore, . If , we derive , thus . Combining these cases, the lemma holds.☐
Lemma 20. If and , the new node can increase the received resources through the splitting method. For some special situations, the received resources could be about two times, i.e., .
Proof. If and , there exists such that the largest amount of resources two nodes can receive is . Suppose ; similar as Lemma 11, we derive
Thus, , and we can find the largest value such that and . Since , we derive
According to Algorithm 1, if , . If , we show that the sum of two nodes’ resources is no more than .
Suppose , it is easy to get and . We analyze the maximum value can achieve. Combining the inequality . and the equation , we derive
Hence, . We then analyze when the .
If , and (Equation (29)), the sum of two nodes’ resources cannot be . When , we can derive . If the node is not split, the received resources is . Since (see Equation (28)), if , we derive , and the received resources of two split nodes are , which implies that the node can receive about times resources compared to the original allocation. Therefore, the lemma holds.☐
From the lemma, we know that the new node can achieve more resources by the splitting strategy. For some special situations, the node can gain appropriate two times resources compared to a honest node. Combining Lemmas 18, 19, and 20, we conclude the theorem as follows:
If the spare resources are adequate () or inadequate () but suits , the splitting strategy has no effect on the new node. If the spare resources suit and , the node can gain more resources (), and in some special situations, the resources can be about two times ().
8. Truthfulness against Splitting Strategy in Tree Graph
In the previous section, we show that a node can gain more resources by the splitting strategy in the centralized resource system. However, in the hierarchy, resources are passed down layer by layer. The node cannot obtain resources from the original node that owns the resources but receives resources from other adjacent nodes. In this section, we will study how the splitting behavior of the parent node affects the child nodes. Suppose a node has several child nodes , the limitation of which is . Node has several child node . Node reports to its parent node that two nodes and are inserted and the sum of their resource limitation is . We analyze the influence of node ’s splitting strategy on its child node ’s received resources. is the resources node allocates to node . is the resources of node . Let be the spare resources after node allocates its resources to its child node except node . We formulate it as .
Lemma 21. If the spare resources are adequate() or inadequate() but suits , there are three cases: (i)Case 1. ; there exists a splitting strategy for node to increase node ’s received resources(ii)Case 2. ; no matter how node splits, node ’s received resources do not change(iii)Case 3. ; there exists two real number and satisfying the following: (a) there exists a real number satisfying if , ’s received resources increase and (b) there exists a real number such that if , ’s received resources decrease
Proof. Suppose node reports two false node and to node . Consider case 1 if . Let and be the amount of resources two false nodes and receive from node . If and . Therefore, . . ’s received resources increase. Consider case 2 if , , , . Node ’s received resource does not change. Consider case 3 (a): suppose , then and . There must exists a real number such that any node satisfying , , and under the new max-min fair allocation vector. . ’s received resources increase. Consider case 3 (b): for node ’s allocation, there exists an integer such that and . Similarly, for node ’s allocation, there exists an integer such that and . If , then . For node ’s allocation, we derive For false nodes ’s and ’s allocation, we derive Combining Equation (30), Equation (31), and Equation (32), we derive Therefore, ; otherwise, we derive , which makes a contradiction. Thus, the lemma holds.☐
By a similar method, the following lemma can be derived.
Lemma 22. If the spare resources suit and , there are three cases: (i)Case 1. or ; node can gain more resources by ’s splitting strategy(ii)Case 2. ; there exists two real number and satisfying (a) if , ’s received resources decrease () or increase (), and (b) there exists a real number satisfying: if , ’s received resources increase
From Lemmas 21 and 22, we know that if grandparent node’s resources are adequate, node’s resources can not increase by parent’s splitting strategy in most scenarios. However, if grandparent node’s resources are inadequate, in most cases, node’s resources can increase by parent’s splitting strategy.
9. Numerical Examples
In this section, we present some numerical examples to illustrate these results. As shown in Figure 1(a), six nodes are connected to the central node in the system, and (resource limitation, transfer rate) is depicted on each edge. For example, node has . Assume the amount of all resources the central node holds is .
(a) Six nodes in the system
(b) Node is inserted
(c) splits into two nodes
By Algorithm 1, the max-min allocation is listed in Table 2 where is the utility of the node which is equal to the received resources ; is the resources the central node allocates. There is no spare resource since . As shown in Figure 1(b), if a new node is inserted with , the max-min allocation is presented as Table 3. Nodes receive fewer resources since their resources are allocated to the new node. If the node misreports its limitation , it cannot gain more resources, and some resources would be wasted.
In order to gain more resources, the new node splits itself into two nodes such that () (as shown in Figure 1(c)). The max-min allocation is presented in Table 1; nodes receive fewer resources, and nodes both receive resources. Therefore, with the splitting strategy, the new node receives resources . Compared to the received resources in Table 3, the splitting strategy achieves times that of the original allocation.
Next, we present an example to illustrate splitting strategy in tree graph.
The overall amount of node is . As shown in Figure 2, node allocates its resources to its child . The resource demand and resource transfer rate are shown in Table 4. The amount of resource node ’s receives is . Once receiving the resources from node , node will allocate its resources to its child . The max-min allocation is presented as Table 5. The amount of resource node receives is fewer than their resource demand. When node splits itself into two false node and (as shown in Figure 3), the overall amount of resources node receives decreases. For instance, the amount of resource node allocates to node is . However, the overall resource node receives from two false nodes and equals (as presented in Table 6).
10. Conclusion
In this paper, we study the truthfulness of the max-min fair allocation in a centralized resource system. Max-min fairness is a common adopted concept in evaluating an allocation mechanism. We propose a simple but efficient algorithm to find out the allocation. On the foundation of the algorithm, we analyze how the allocation varies when a new node is added to the system. Furthermore, we explore whether the allocation is truthful against two strategic behaviors. The misreporting strategy cannot affect the allocation while the new node can gain more resources by the splitting strategy. Hence, the max-min allocation mechanism is not truthful especially against the splitting strategy. Finally, we analyze the effect of node’s splitting strategy on its child nodes on tree graph. In some situations, nodes can gain more resources despite the splitting strategy of its parents. It is still an open problem to design a fair and truthful allocation mechanism in a centralized resource system.
Data Availability
The data used to support the findings of this study are available from the corresponding author upon request.
Disclosure
The paper is an extended version of our WASA 2020 paper “Can the Max-Min Fair Allocation Be Trustful in a Centralized Resource System?”
Conflicts of Interest
The authors declare that they have no conflicts of interest.
Acknowledgments
This work was supported in part by the Guangdong Province Key Research and Development Plan under Grant No. 2019B010136003, the National Key Research and Development Program of China (2019QY1406), the National Natural Science Foundation of China under Grant No. 61972106, the Guangdong Higher Education Innovation Group (2020KCXTD007), and the Guangzhou Higher Education Innovation Group (202032854).