class Shared:
def __init__(self, n):
self.N = n
self.counter = 0
self.fibonacci = [0, 1] + [0] * n
self.threads = [0] * (n + 1)
self.mutex = Mutex()
self.event = Event()
self.event.signal()
for j in range(n + 1):
self.threads[j] = Semaphore(0)
self.threads[0].signal(1)
def fnc_fibonacci_seq(self, pin):
self.threads[pin].wait()
self.fibonacci[pin + 2] = self.fibonacci[pin] + self.fibonacci[pin + 1]
self.threads[pin + 1].signal()
def fnc_fibonacci_event(self, pin):
while True:
self.event.wait()
self.mutex.lock()
if self.counter == pin:
break
self.mutex.unlock()
self.mutex.unlock()
self.mutex.lock()
self.counter += 1
self.mutex.unlock()
self.fibonacci[pin + 2] = self.fibonacci[pin] + self.fibonacci[pin + 1]
self.event.signal()
def __init__(self, capacity):
self.free_space = Semaphore(capacity)
self.items = Semaphore(0)
self.mutex = Mutex()
self.produced = 0
self.consumed = 0
self.closed = False
def __init__(self):
self.mutex = Mutex()
self.mutex2 = Mutex()
self.servings = 0
self.full_pot = Semaphore(0)
self.empty_pot = Semaphore(0)
self.barrier1 = SimpleBarrier(number_of_savages)
self.barrier2 = SimpleBarrier(number_of_savages)
def __init__(self, n, c):
self.mutex = Mutex()
self.chef_mutex = Mutex()
self.servings = 0
self.num_of_chefs = c
self.full_pot = Semaphore(0)
self.empty_pot = Semaphore(0)
self.barrier1 = SimpleBarrier(n)
self.barrier2 = SimpleBarrier(n)
self.chef_barrier2 = SimpleBarrier(c)
self.chef_barrier = SimpleBarrier(c + 1)
def __init__(self, n):
self.N = n
self.counter = 0
self.fibonacci = [0, 1] + [0] * n
self.threads = [0] * (n + 1)
self.mutex = Mutex()
self.event = Event()
self.event.signal()
for j in range(n + 1):
self.threads[j] = Semaphore(0)
self.threads[0].signal(1)
def __init__(self):
self.mutex = Mutex()
self.cooking = Mutex()
self.refill = Mutex()
self.servings = 0
self.active_cooks = 0
self.cooks_done = 0
self.full_pot = Semaphore(0)
self.empty_pot = Semaphore(0)
self.barrier1 = SimpleBarrier(N)
self.barrier2 = SimpleBarrier(N)
self.pot_ready = Semaphore(0)
class Barrier:
def __init__(self, n):
self.n = n
self.count = 0
self.mutex = Mutex()
self.event = Event()
def wait(self):
self.mutex.lock()
self.count += 1
if self.count == self.n:
self.event.signal()
self.mutex.unlock()
self.event.wait()
class SimpleBarrier:
def __init__(self, number_of_threads):
self.number_of_threads = number_of_threads
self.mutex = Mutex()
self.event = Event()
self.counter = 0
def wait(self):
self.mutex.lock()
self.counter += 1
if self.counter == self.number_of_threads:
self.event.signal()
self.mutex.unlock()
self.event.wait()
class WareHouse:
def __init__(self, capacity):
self.free_space = Semaphore(capacity)
self.items = Semaphore(0)
self.mutex = Mutex()
self.produced = 0
self.consumed = 0
self.closed = False
def produce(self, time_to_produce):
sleep(time_to_produce)
self.mutex.lock()
self.produced += 1
self.mutex.unlock()
def consume(self, time_to_consume):
sleep(time_to_consume)
self.mutex.lock()
self.consumed += 1
self.mutex.unlock()
def stop_production(self, time_period):
sleep(time_period)
self.closed = True
self.items.signal(100)
self.free_space.signal(100)
class LightSwitch:
"""Implementacia lightswitch ADT."""
def __init__(self):
self.cnt = 0
self.mutex = Mutex()
def lock(self, sem):
"""Zamknutie Semaphore objektu.
sem -- Semaphore objekt sluziaci na synchronizaciu vlakien
"""
self.mutex.lock()
self.cnt += 1
if self.cnt == 1:
sem.wait()
self.mutex.unlock()
def unlock(self, sem):
"""Odomknutie Semaphore objektu.
sem -- Semaphore objekt sluziaci na synchronizaciu vlakien
"""
self.mutex.lock()
self.cnt -= 1
if self.cnt == 0:
sem.signal()
self.mutex.unlock()
class Barrier:
def __init__(self, N):
self.N = N
self.mutex = Mutex()
self.counter = 0
self.semaphore = Semaphore(0)
def wait(self):
self.mutex.lock()
self.counter += 1
if self.counter == self.N:
self.counter = 0
self.semaphore.signal(self.N)
self.mutex.unlock()
self.semaphore.wait()
class SimpleBarrier:
def __init__(self, n):
self.N = n
self.counter = 0
self.mutex = Mutex()
self.turnstile = Semaphore(0)
def wait(self):
self.mutex.lock()
self.counter += 1
if self.counter == self.N:
self.counter = 0
self.turnstile.signal(self.N)
self.mutex.unlock()
self.turnstile.wait()
class SimpleBarrier:
def __init__(self, N):
self.N = N
self.C = 0
self.M = Mutex()
self.T = Semaphore(0)
def wait(self):
self.M.lock()
self.C += 1
if self.C == self.N:
self.C = 0 # posledne vlakno nastavi pocitadlo na nulu
self.T.signal(self.N) # uvolni N vlakien
self.M.unlock()
self.T.wait()
class SimpleBarrier:
def __init__(self, N):
self.N = N
self.C = 0
self.M = Mutex()
self.T = Semaphore(0)
def wait(self):
self.M.lock()
self.C += 1
if self.C == self.N:
self.C = 0
self.T.signal(self.N)
self.M.unlock()
self.T.wait()
def __init__(self, n):
self.mutex = Mutex()
self.servings = 0
self.full_pot = Semaphore(0)
self.empty_pot = Semaphore(0)
self.barrier1 = SimpleBarrier(n)
self.barrier2 = SimpleBarrier(n)
class SimpleBarrier:
def __init__(self, num_of_threads):
self.N = num_of_threads
self.cnt = 0
self.mutex = Mutex()
self.turnstile = Semaphore(0)
def wait(self):
self.mutex.lock()
self.cnt += 1
if self.cnt == self.N:
self.cnt = 0
for _ in range(self.N):
self.turnstile.signal()
self.mutex.unlock()
self.turnstile.wait()
class SimpleBarrierEvent:
def __init__(self, num_of_threads):
self.N = num_of_threads
self.C = num_of_threads
self.mutex = Mutex()
self.turnstile = Event()
def wait(self):
self.mutex.lock()
if self.C == 0:
self.turnstile.clear()
self.C += 1
if self.C == self.N:
self.turnstile.set()
self.mutex.unlock()
self.turnstile.wait()
def __init__(self):
self.oxygen = 0
self.hydrogen = 0
self.mutex = Mutex()
self.oxyQueue = Semaphore(0)
self.hydroQueue = Semaphore(0)
self.barrier = Barrier(3)
def __init__(self, n, n_savages):
self.servings = n
self.mutex = Mutex()
self.empty_pot = Semaphore(0)
self.full_pot = Semaphore(0)
self.barrier1 = SimpleBarrier(n_savages)
self.barrier2 = SimpleBarrier(n_savages)
class SimpleBarrier():
def __init__(self, N):
self.mutex = Mutex()
self.capacity = N
self.counter = 0
self.sem = Semaphore()
def wait(self):
self.mutex.lock()
self.counter += 1
if self.counter == self.capacity:
print(f'Lod zakotvila s posadkou {self.counter} ludi')
self.counter = 0
self.sem.signal(self.capacity)
self.mutex.unlock()
self.sem.wait()
def __init__(self):
self.hackers = 0
self.serfs = 0
self.mutex = Mutex()
self.hackers_queue = Semaphore(0)
self.serfs_queue = Semaphore(0)
self.barrier = SimpleBarrier(4)
def __init__(self):
self.mutex = Mutex()
self.dealersQ = Semaphore()
self.officersQ = Semaphore()
self.officerCounter = 0
self.dealerCounter = 0
self.barrier = SimpleBarrier(4)
class SimpleBarrier:
def __init__(self, N):
self.N = N
self.C = 0
self.M = Mutex()
self.T = Semaphore(0)
def wait(self, savage_id, barrier_id):
self.M.lock()
self.C += 1
print(f'savage {savage_id} before barrier {barrier_id}, {self.C} present')
if self.C == self.N:
print(f'savage {savage_id} opening barrier {barrier_id}')
self.C = 0 # posledne vlakno nastavi pocitadlo na nulu
self.T.signal(self.N) # uvolni N vlakien
self.M.unlock()
self.T.wait()
def __init__(self, n):
self.mutex = Mutex()
self.free_chairs = n
self.queue = []
self.customer = Semaphore(0)
self.barber = Semaphore(0)
self.customerDone = Semaphore(0)
self.barberDone = Semaphore(0)
def __init__(self, N):
self.N = N
self.customers = 0
self.queue = []
self.mutex = Mutex()
self.customer = Semaphore(0)
self.customerDone = Semaphore(0)
self.barberDone = Semaphore(0)
def test_simple_fibonacci(N):
threads = list()
fibonacci = [0, 1]
mtx = Mutex()
for thread_num in range(N):
threads.append(Thread(calculate_fibonacci_simple, mtx, fibonacci, thread_num))
for t in threads:
t.join()
class SimpleBarrier:
def __init__(self, N):
self.N = N
self.mutex = Mutex()
self.cnt = 0
self.sem = Semaphore(0)
def wait(self, print_str, id, print_last=False, print_each=False):
self.mutex.lock()
self.cnt += 1
if print_each:
print(print_str.format(id, self.cnt))
if self.cnt == self.N:
self.cnt = 0
if print_last:
print(print_str.format(id))
self.sem.signal(self.N)
self.mutex.unlock()
self.sem.wait()
def __init__(self, customer_capacity):
self.N = customer_capacity
self.customers = 0
self.mutex = Mutex()
self.barber = Semaphore(0)
self.customer = Semaphore(0)
self.barber_done = Semaphore(0)
self.customer_done = Semaphore(0)
class SimpleBarrier:
def __init__(self, n):
self.N = n
self.counter = 0
self.mutex = Mutex()
self.turnstile = Semaphore(0)
def wait(self, each=None, last=None):
self.mutex.lock()
self.counter += 1
if each:
print(each)
if self.counter == self.N:
self.counter = 0
if last:
print(last)
self.turnstile.signal(self.N)
self.mutex.unlock()
self.turnstile.wait()
class ReusableBarrier:
def __init__(self, numberOfThreads):
self.numberOfThreads = numberOfThreads
self.mutex = Mutex()
self.event = Event()
self.counter = 0
def wait(self):
self.mutex.lock()
if self.counter == 0:
self.event.clear()
self.counter += 1
if self.counter == self.numberOfThreads:
self.event.signal()
self.counter = 0
self.mutex.unlock()
self.event.wait()
