No abstract

In this paper 1 we present two versions of a parallel working-set map on p processors that supports searches, insertions and deletions. In both versions, the total work of all operations when the map has size at least p is bounded by the working-set bound, i.e., the cost of an item depends on how recently it was accessed (for some linearization): accessing an item in the map with recency r takes O(1+logr ) work. In the simpler version each map operation has O (logp) 2 + logn span (where n is the maximum size of the map). In the pipelined version each map operation on an item with recency r has O (logp) 2 + logr span. (Operations in parallel may have overlapping span; span is additive only for operations in sequence.)Both data structures are designed to be used by a dynamic multithreading parallel program that at each step executes a unittime instruction or makes a data structure call. To achieve the stated bounds, the pipelined version requires a weak-priority scheduler, which supports a limited form of 2-level prioritization. At the end we explain how the results translate to practical implementations using work-stealing schedulers.To the best of our knowledge, this is the first parallel implementation of a self-adjusting search structure where the cost of an operation adapts to the access sequence. A corollary of the working-set bound is that it achieves work static optimality: the total work is bounded by the access costs in an optimal static search tree.

Garlic is a herb and has been used as a spice with a long history in different types of cuisine. Garlic and its components are believed to be able to bring benefits to the health of an individual. The gut microbiota is closely related to an individual's health, and garlic is shown to have an effect on the gut microbiota as well. Hence, this literature review aims to portray the uses of garlic and its bioactive constituents on human health, particularly looking at how it modulates the gut microbiota and subsequently affects an individual's health directly or indirectly. These studies have shown the ameliorative effects of garlic and its bioactive constituents on various chronic diseases, including hypertension, diabetes mellitus, hyperlipidaemia and liver diseases.

In this paper 1 we present two versions of a parallel finger structure FS on p processors that supports searches, insertions and deletions, and has a finger at each end. This is to our knowledge the first implementation of a parallel search structure that is work-optimal with respect to the finger bound and yet has very good parallelism (within a factor of O (log p) 2 of optimal). We utilize an extended implicit batching framework that transparently facilitates the use of FS by any parallel program P that is modelled by a dynamically generated DAG D where each node is either a unit-time instruction or a call to FS. The total work done by either version of FS is bounded by the finger bound F L (for some linearization L of D), i.e. each operation on an item with distance r from a finger takes O(log r + 1) amortized work. Running P using the simpler version takes O T 1 +F L p + T ∞ + d • (log p) 2 + log n time on a greedy scheduler, where T 1 , T ∞ are the size and span of D respectively, and n is the maximum number of items in FS, and d is the maximum number of calls to FS along any path in D. Using the faster version, this is reduced to, where s L is the weighted span of D where each call to FS is weighted by its cost according to F L . We also sketch how to extend FS to support a fixed number of movable fingers. The data structures in our paper fit into the dynamic multithreading paradigm, and their performance bounds are directly composable with other data structures given in the same paradigm. Also, the results can be translated to practical implementations using work-stealing schedulers.

In this paper we look at the problem of scheduling tasks on a single-processor system, where each task requires unit time and must be scheduled within a certain time window, and each task can be added to or removed from the system at any time. On each operation, the system is allowed to reschedule any tasks, but the goal is to minimize the number of rescheduled tasks. Our main result is an allocator that maintains a valid schedule for all tasks in the system if their time windows have constant size and reschedules O 1 ε log( 1 ε ) tasks on each insertion as ε → 0, where ε is a certain measure of the schedule flexibility of the system. We also show that it is optimal for any allocator that works on arbitrary instances. We also briefly mention a few variants of the problem, such as if the tasks have time windows of difference sizes, for which we have an allocator that we conjecture reschedules only 1 task on each insertion if the schedule flexibility remains above a certain threshold.Let span( S) = max X∈S X.end− min X∈S X.start for any finite set/sequence of intervals S.Let ( P ? X : Y ) evaluate to X iff P = true and Y otherwise for any boolean P and expressions X, Y . Reallocation problem terminologyTake any instance I = (n, T, W ) that comprises a set of n unit tasks T [1..n] and their windows W [1..n]. For convenience we shall often not mention the tasks but associate an allocated slot directly with the task's window.Call S a valid allocation for I iff it is an allocation of tasks in I such that each taskis unallocated, and no two tasks in I are allocated to overlapping slots. For convenience we shall use "slot" to refer to a unit interval unless otherwise specified.Call I ordered iff W [1..n] is ordered. If so, call a valid allocation S for I ordered iff S[1..n] is ordered. (Unallocated tasks are ignored.) Call S a solution for I iff S is a valid allocation for I that allocates all tasks in I.Call S a partial solution for (I, k) iff S is a valid allocation for I that allocates all tasks inCall S a γ-solution for I iff S is a solution for I ′ where I ′ is I with all task lengths multiplied by γ.Call S a γ-partial solution for (I, k) iff S is a partial solution for (I ′ , k) where I ′ is I with all task lengths multiplied by γ.Call I feasible iff there is a solution for I, and call I γ-underallocated iff there is a γ-solution for I.Call I ε-slack iff I is (1 + ε)-underallocated, and let the underallocation of I be the maximum such ε, which clearly exists.Call (I, S, k) an insert state iff S is a partial solution for (I, k), and call it ordered iff I is ordered, feasible iff I is feasible, and (1 + ε)-underallocated or equivalently ε-slack iff there is a (1 + ε)-partial solution for (I, k).Call an insertion of a new task feasible iff the resulting instance is feasible, or equivalently iff it creates a feasible insert state.Call an algorithm A an allocator iff it maintains a solution on any feasible task insertion.