Concurrency in snap-stabilizing local resource allocation

2010

The transactional approach to contention management guarantees atomicity by making sure that whenever two transactions have a conflict on a resource, only one of them proceeds. A major challenge in implementing this approach lies in guaranteeing progress, since transactions are often restarted. Inspired by the paradigm of non-clairvoyant job scheduling, we analyze the performance of a contention manager by comparison with an optimal, clairvoyant contention manager that knows the list of resource accesses that will be performed by each transaction, as well as its release time and duration. The realistic, non-clairvoyant contention manager is evaluated by the competitive ratio between the last completion time (makespan) it provides and the makespan provided by an optimal contention manager. Assuming that the amount of exclusive accesses to the resources is non-negligible, we present a simple proof that every work conserving contention manager guaranteeing the pending commit property achieves an O(s) competitive ratio, where s is the number of resources. This bound holds for the Greedy contention manager studied by Guerraoui et al. [2] and is a significant improvement over the O(s 2) bound they prove for the competitive ratio of Greedy. We show that this bound is tight for any deterministic contention manager, and under certain assumptions about the transactions, also for randomized contention managers. When transactions may fail, we show that a simple adaptation of Greedy has a competitive ratio of at most O(ks), assuming that a transaction may fail at most k times. If a

Proceedings of the first ACM SIGACT-SIGOPS symposium on Principles of distributed computing - PODC '82, 1982

In this paper we consider a resource allocation problem which is local in the sense that the maxim~a number of users competing for a particular resource at any time instant is bounded and also at any time instant the maximum number of resources that a user is willing to get is bounded. The problem may be viewed as that of achieving matchings in dynamically changing hypergraphs, via a distributed algorithm. We show that this problem is related to the fundamental problem of handshake communication (which can be viewed as achieving matchings in a dynamically changing graph, via distributed algorithms) in that an efficient solution to each of them i~?lies an efficient solution to the other. We provide realtime solutions to the resource allocation problem (that is, we give distributed algorithms with real time response). We make essential use of probabilistic techniques as first used by [Rabin, 80b], where processes are allowed to make independent probabilistic choices. On the other hand, no probability assumptions about the system behavior are made. One of our solutions assumes the existence of an underlying real-time handshake communication system, as described in [Reif, Spirakis, 81]. Our other solution is based on efficient synchronization by flag variables, which are written only by one process and read by at most one other process. The special case of equi-speed processes is first examined. Then we generalize to asynchronous processes. Applications are made to dining philosophers, scheduling and two-phase locking in databases. I.

Mutual exclusion (mutex) is fundamental problems in distributed systems in which a resource must be used at most one process at a time when some processes were communicating each other to compete in accessing. Many resource allocations problems have been constructed base on the mutual exclusion problem, and it can be generally formed to problems called (n,m,k,d)-resource allocation and further extended to (n,m,k,di)-resource allocation, i.e, the problem to synchronize accesses on k identical resources among n processes which belong to m groups and each resource can be used by at most di processes of the same group at a time. The generalized resource allocation problem can be solved using a quorum system called (m,k,d)-coterie and (m,k,di)-coterie that satisfies the relaxed safety property of the original mutual exclusion. If quorum based algorithm of mutual exclusion directly adopt to the quorum systems then the massage complexity is the same and the maximum degree of concurrency of the generalized resource allocation problem of h 𝑑 is achieved.

We introduce a solution for a concurrency control problem which is frequently encountered in practice: in a dynamic system we want that the load on a centralized resource is uniformly distributed among users, offering a predictable performance as long as it is not overloaded. We propose an original solution based on probabilistic assumptions, and we comment early experimental results.

2017

Traditional resource management systems rely on a centralized approach to manage users running on each resource. The centralized resource management system is not scalable for large-scale servers as the number of users running on shared resources is increasing dramatically and the centralized manager may not have enough information about applications' need. In this paper we propose a distributed game-theoretic resource management approach using market auction mechanism to find optimal strategy in a resource competition game. The applications learn through repeated interactions to choose their action on choosing the shared resources. Specifically, we look into two case studies of cache competition game and main processor and co-processor congestion game. We enforce costs for each resource and derive bidding strategy. Accurate evaluation of the proposed approach show that our distributed allocation is scalable and outperforms the static and traditional approaches.

Journal of Applied Mathematics and Decision Sciences, 2005

Many systems consist of a set of agents which must acquire exclusive access to resources from a shared pool. Coordination of agents in such systems is often implemented in the form of a centralized mechanism. The intervention of this type of mechanism, however, typically introduces significant computational overhead and reduces the amount of concurrent activity. Alternatives to centralized mechanisms exist, but they generally suffer from the need for extensive interagent communication. In this paper, we develop a randomized approach to make multiagent resource-allocation decisions with the objective of maximizing expected concurrency measured by the number of the active agents. This approach does not assume a centralized mechanism and has no need for interagent communication. Compared to existing autonomous-decentralized-decision-making (ADDM)-based approaches for resource-allocation, our work emphasizes achieving the highest degree of agent autonomy and is able to handle more general resource requirements.

10th IEEE International Symposium on Industrial Embedded Systems (SIES), 2015

Resource efficient approaches are of great importance for resource constrained embedded systems. In this paper, we present an approach targeting systems where tasks of a critical application are partitioned on a multi-core platform and by using resource reservation techniques, the remaining bandwidth capacity on each core is utilized for one or a set of non-critical application(s). To provide a resource efficient solution and to exploit the potential parallelism of the extra applications on the multi-core processor, global scheduling is used to schedule the tasks of the non-critical applications. Recently a specific instantiation of such a system has been studied where tasks do not share resources other than the processor. In this paper, we enable semaphore-based resource sharing among tasks within critical and non-critical applications using a suspension-based synchronization protocol. Tasks of non-critical applications have partial access to the processor bandwidth. The paper provides the systems schedulability analysis where blocking due to resource sharing is bounded. Further, we perform experimental evaluations under balanced and unbalanced allocation of tasks of a critical application to cores.

2008

Without care, Hardware Transactional Memory presents several performance pathologies that can degrade its performance. Among them, writers of commonly read variables can suffer from starvation. Though different solutions have been proposed for HTM systems, hybrid systems can still suffer from this performance problem, given that software transactions don't interact with the mechanisms used by hardware to avoid starvation.

2001

2000

Abstract Marbles schemes are a family of cooperative and adaptive algorithms for distributed resource allocation problems. Long-term goals for these schemes emphasize faulttolerance and real-time performance in which a good timely solution is preferable to an optimal but too late solution. This paper reports work in progress where we compare the performance and analyze characteristics of different Marbles schemes and centralized solvers working on large scale and complex resource allocation problems.