Question

(Operating Systems) Describe how locked linked lists work. Where are the locks for such lists required? What is the performance efficiency (or lack of efficiency) of these data structures?

Answer 1

Linked Lists--- • We can make effective spin locks – Correct – Work well under contention

List-Based Sets

public interface Set

{

public boolean add(Object x);

public boolean remove(Object x);

public boolean contains

List Entry

public class Entry {

public Object object;

public int key;

public Entry next;

}

use a lock :-

Lock (L)

local := counter

local++

counter := local

Unlock(L)

Lock Free Mean :--

• First try: “never using a lock”.

• Well, is this using a lock? (word is initially zero.)

while (!CAS(&word,0,1)) {}

local := counter

local++

counter := local

word := 0

Lock-Freedom

• Realistic (though difficult): Various lock-free data structures exist in the literature (stack, queue, hashing, skiplist, trees, etc.). • Advantages: Worst-case responsiveness, scalability, no deadlocks, no livelocks, added robustness to threads fail-stop. Lock-Freedom If you schedule enough steps across all threads, one of them will make progress. Linked List: Our First

PERFORM EFFIIENCY(or lack of efficiency) OF THESE DATA STRUCTURES:--

Algorithm Efficiency

Some algorithms are more efficient than others. We would prefer to chose an efficient algorithm, so it would be nice to have metrics for comparing algorithm efficiency.

The complexity of an algorithm is a function describing the efficiency of the algorithm in terms of the amount of data the algorithm must process. Usually there are natural units for the domain and range of this function. There are two main complexity measures of the efficiency of an algorithm:

• Time complexity is a function describing the amount of time an algorithm takes in terms of the amount of input to the algorithm. "Time" can mean the number of memory accesses performed, the number of comparisons between integers, the number of times some inner loop is executed, or some other natural unit related to the amount of real time the algorithm will take. We try to keep this idea of time separate from "wall clock" time, since many factors unrelated to the algorithm itself can affect the real time (like the language used, type of computing hardware, proficiency of the programmer, optimization in the compiler, etc.). It turns out that, if we chose the units wisely, all of the other stuff doesn't matter and we can get an independent measure of the efficiency of the algorithm.
• Space complexity is a function describing the amount of memory (space) an algorithm takes in terms of the amount of input to the algorithm. We often speak of "extra" memory needed, not counting the memory needed to store the input itself. Again, we use natural (but fixed-length) units to measure this. We can use bytes, but it's easier to use, say, number of integers used, number of fixed-sized structures, etc. In the end, the function we come up with will be independent of the actual number of bytes needed to represent the unit. Space complexity is sometimes ignored because the space used is minimal and/or obvious, but sometimes it becomes as important an issue as time.

For example, we might say "this algorithm takes n² time," where n is the number of items in the input. Or we might say "this algorithm takes constant extra space," because the amount of extra memory needed doesn't vary with the number of items processed.