2 research outputs found

    Space Bounds for Adaptive Renaming

    Full text link
    We study the space complexity of implementing long-lived and one-shot adaptive renaming from multi-reader multi-writer registers, in an asynchronous distributed system with nn processes. As a result of an ff-adaptive renaming algorithm each participating process gets a distinct name in the range {1,…,f(k)}\{1,\dots,f(k)\} provided kk processes participate. Let f:{1,…,n}β†’Nf: \{1,\dots,n\} \rightarrow \mathbb{N} be a non-decreasing function satisfying f(1)≀nβˆ’1f(1) \leq n-1 and let d=max⁑{x ∣ f(x)≀nβˆ’1}d = \max\{x ~|~ f(x) \leq n-1\}. We show that any non-deterministic solo-terminating long-lived ff-adaptive renaming object requires d+1d + 1 registers. This implies a lower bound of nβˆ’cn-c registers for long-lived (k+c)(k+c)-adaptive renaming, which we observe is tight. We also prove a lower bound of ⌊2(nβˆ’c)c+2βŒ‹\lfloor \frac{2(n - c)}{c+2} \rfloor registers for implementing any non-deterministic solo-terminating one-shot (k+c)(k+c)-adaptive renaming. We provide two one-shot renaming algorithms: a wait-free algorithm and an obstruction-free algorithm. Each algorithm employs a parameter to depict the tradeoff between space and adaptivity. When these parameters are chosen appropriately, this results in a wait-free one-shot (3k22)(\frac{3k^2}{2})-adaptive renaming algorithm from ⌈nβŒ‰+1\lceil \sqrt{n} \rceil + 1 registers, and an obstruction-free one-shot ff-adaptive renaming algorithm from only min⁑{n,x ∣ f(x)β‰₯2n}+1\min\{n, x ~|~ f(x) \geq 2n\} + 1 registers

    Asynchronous Exclusive Selection

    Full text link
    An asynchronous system of nn processes prone to crashes, along with a number of shared read-write registers, is the distributed setting. We consider assigning integer numbers to processes in an exclusive manner, in the sense that no integer is assigned to two distinct processes. In the problem called Renaming, any k≀nk\le n processes, which hold original names from a range [N]={1,…,N}[N]=\{1,\ldots,N\}, contend to acquire unique integers in a smaller range [M][M] as new names using some rr auxiliary shared registers. We develop a wait-free (k,N)(k,N)-renaming solution operating in O(log⁑k(log⁑N+log⁑klog⁑log⁑N))O(\log k (\log N + \log k\log\log N)) local steps, for M=O(k)M=O(k), and with r=O(klog⁑(N/k))r=O(k\log(N/k)) auxiliary registers. We develop a wait-free kk-renaming algorithm operating in O(k)O(k) time, with M=2kβˆ’1M=2k-1 and with r=O(k2)r=O(k^2) registers. We develop an almost adaptive wait-free NN-renaming algorithm, with NN known, operating in O(log⁑2k(log⁑N+log⁑klog⁑log⁑N))O(\log^2 k (\log N + \log k\log\log N)) time, with M=O(k)M=O(k) and with r=O(nlog⁑(N/n))r=O(n\log(N/n)) registers. We give a fully adaptive solution of Renaming, with neither kk nor NN known, having M=8kβˆ’lg⁑kβˆ’1M=8k-\lg k-1 as the bound on new names, operating in O(k)O(k) steps and using O(n2)O(n^2) registers. As regards lower bounds, we show that a wait-free solution of Renaming requires 1+min⁑{kβˆ’2,log⁑2rN2M}1+\min\{k-2,\log_{2r} \frac{N}{2M}\} steps in the worst case. We apply renaming algorithms to obtain solutions to a problem called Store-and-Collect, which is about operations of storing and collecting under additional requirements. We consider the problem called Unbounded-Naming in which processes may repeatedly request new names, while no name can be reused once assigned, so that infinitely many integers need to be exclusively assigned as names in an execution
    corecore