Bezbolesne Programowanie Współbieżne

Transkrypt

1 Bezbolesne Programowanie Współbieżne Konrad Siek 26 III 2014

2 Lata 90-te???

3 Częstotliwość procesorów Tranzystory Rok

4 Lata 90-te My new computer s got the clocks, it rocks, but it was obsolete before I opened the box. You say you ve had your desktop for over a week? Throw that junk away, man, it s an antique. Your laptop is a month old? Well, that s great. If you could use a nice, heavy paperweight... It s all about the Pentiums, Weird Al, 1999

5 Częstotliwość procesorów Taktowanie [MHz] Rok

6 Prawo Moore-a in action Tranzystory 0.0e e Rok

7 Liczby rdzeni w procesorach Rdzenie Rok

8 Od rdzeni Współbieżność

9 Od rdzeni Współbieżność... ale współbieżność boli

10 ... boli?

11 Rzeczy których nie lubie Szukanie bugów (bagów?) Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie problemów synchronizacji

12 Rzeczy których nie lubie Szukanie bugów (bagów?) Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie problemów synchronizacji

13 Rzeczy których nie lubie Szukanie Heisenbugów Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie problemów synchronizacji

14 Heisenbug

17 Wrzucanie kodu strukturalnego do funkcjonalnego class Elem: def init (self, transaction, t, next): self.transaction = transaction self.t = t self.next = next _head = None def insert(transaction, t): if _head is None: _head = Elem(transaction, t, None) return elem = _head while True: if elem.t <= t: temp = Elem(elem.transaction, elem.t, elem.next) elem.transaction = transaction elem.t = t elem.next = temp return else: if elem.next: elem = elem.next else: elem.next = Elem(transaction, t, None) return

18 Wrzucanie kodu strukturalnego do funkcjonalnego from threading import RLock, Condition class Elem: def init (self, transaction, t, next): self.transaction = transaction self.t = t self.next = next _head = None _global_lock = Condition() _transaction_lock = RLock() def insert(head, transaction, t): elem = head while True: if elem.t <= t: temp = Elem(elem.transaction, elem.t, elem.next) elem.transaction = transaction elem.t = t elem.next = temp return else: if elem.next: elem = elem.next else: elem.next = Elem(transaction, t, None) return

19 Wrzucanie kodu strukturalnego do funkcjonalnego from threading import RLock, Condition class Elem: def init (self, transaction, t, next): self.transaction = transaction self.t = t self.next = next _head = None _global_lock = Condition() _transaction_lock = RLock() def insert(head, transaction, t): elem = head while True: if elem.t <= t: temp = Elem(elem.transaction, elem.t, elem.next) elem.transaction = transaction elem.t = t elem.next = temp return else: if elem.next: elem = elem.next else: elem.next = Elem(transaction, t, None) return def lock(transaction, length): _global_lock.acquire() if _head is None: acquired = _transaction_lock.acquire(blocking=false) if acquired and _head is None: _global_lock.release() return else: if _head == null: _head = Elem(T, t, null) else: insert(_head, T, t) while True: _global_lock.wait() if _head.t = T: _transaction_lock.acquire() if _head is not None: _head = _head.next _global_lock.release() return else: _global_lock.notify() def unlock(): _global_lock.acquire() _transaction_lock.release() _global_lock.notify() _global_lock.release() return

22 Rozwiązywanie problemów synchronizacji

23 Rozwiązywanie problemów synchronizacji

25 Rzeczy których nie lubie Szukanie Heisenbugów Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie 2 problemów jednocześnie

26 Rozwiązania których szukam Szukanie Heisenbugów Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie 2 problemów jednocześnie

27 Rozwiązania których szukam Szukanie Heisenbugów Wrzucanie kodu strukturalnego do funkcjonalnego Rozwiązywanie 2 problemów jednocześnie Uniwersalne

28 Rozwiązania którzych szukam Szukanie Heisenbugów Wrzucanie kodu strukturalnego do funkcjonalnego Proste w implementacji Rozwiązywanie 2 problemów jednocześnie Uniwersalne

29 Rozwiązania których szukam Szukanie Heisenbugów Bezbłędne Wrzucanie kodu strukturalnego do funkcjonalnego Proste w implementacji Rozwiązywanie 2 problemów jednocześnie Uniwersalne

30 Rozwiązania których szukam Szukanie Heisenbugów Bezbłędne Wrzucanie kodu strukturalnego do funkcjonalnego Proste w implementacji Rozwiązywanie 2 problemów jednocześnie Uniwersalne Wydajne

31 Rozwiązania

32 Globalny zamek from threading import Thread, Lock _global_lock = Lock() _shared_data = [0, 0, 0, 0] class GLThread (Thread): def init (self, data, index): Thread. init (self) self.index = index self.data = data def run(self): with _global_lock: self.data[self.index] += 1 my_data = self.data[self.index] print( set, self.index, to, my_data) for i in range(0, 10): GLThread(_shared_data, i % len(_shared_data)).start()

33 Globalny zamek from threading import Thread, Lock _global_lock = Lock() _shared_data = [0, 0, 0, 0] class GLThread (Thread): def init (self, data, index): Thread. init (self) self.index = index self.data = data def run(self): with _global_lock: self.data[self.index] += 1 my_data = self.data[self.index] print( set, self.index, to, my_data) for i in range(0, 10): GLThread(_shared_data, i % len(_shared_data)).start()

34 Globalny zamek Bezbolesna współbieżność

37 Wątki funkcyjne

38 Duplikaty

39 Duplikaty from hashlib import md5 hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): make_hash(i)

40 Duplikat from hashlib import md5 from _thread import start_new_thread # python2: thread hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): start_new_thread(function=make_hash, args=(i,))

41 Duplikat from hashlib import md5 from _thread import start_new_thread # python2: thread hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): start_new_thread(function=make_hash, args=(i,))

42 Global Interpreter Lock A global interpreter lock (GIL) is used internally to ensure that only one thread runs in the Python VM at a time. In general, Python offers to switch among threads only between bytecode instructions; how frequently it switches can be set via sys.setswitchinterval(). Each bytecode instruction and therefore all the C implementation code reached from each instruction is therefore atomic from the point of view of a Python program.

43 Duplikaty from hashlib import md5 #from _thread import start_new_thread # python2: thread from multiprocessing import Process hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): #start_new_thread(function=make_hash, args=(i,)) Process(target=make_hash, args=(i,)).start()

44 Duplikaty from hashlib import md5 from multiprocessing import Process hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): Process(target=make_hash, args=(i,)).start()

45 Duplikaty

46 Duplikaty

47 Duplikaty from hashlib import md5 from multiprocessing import Process hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() for i in range(0, len(files)): Process(target=make_hash, args=(i,)).start()

48 Duplikaty from hashlib import md5 from multiprocessing import Pool hashes = [None] * len(files) def make_hash(i): with semaphore: source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() pool = Pool(processes=4) # define after make_hash for i in range(0, len(files)): pool.apply_async(func=make_hash, args=(i,))

49 Duplikaty from hashlib import md5 from multiprocessing import Pool hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() pool = Pool(processes=4) # define after make_hash for i in range(0, len(files)): pool.apply_async(func=make_hash, args=(i,)) pool.close() # close before joining pool.join()

50 Wątki funkcyjne Preferują solipsyzm

51 Wątki funkcyjne Preferują solipsyzm tylko odczyt bez konfliktów

52 Wątki funkcyjne Preferują solipsyzm tylko odczyt bez konfliktów Niski koszt

53 Wątki funkcyjne Preferują solipsyzm tylko odczyt bez konfliktów Niski koszt ten sam schemat <10 lini kodu

54 Wątki funkcyjne Preferują solipsyzm tylko odczyt bez konfliktów Niski koszt ten sam schemat <10 lini kodu Znaczna poprawa efektywności

55 Wątki funkcyjne (Python) from hashlib import md5 from multiprocessing import Pool hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() pool = Pool(processes=4) # define after make_hash for i in range(0, len(files)): pool.apply_async(func=make_hash, args=(i,)) pool.close() # close before joining pool.join()

56 Wątki funkcyjne (Python) map from hashlib import md5 from multiprocessing import Pool hashes = [None] * len(files) def make_hash(i): source = open(files[i], rb ) data = source.read() source.close() hashes[i] = md5(data).digest() pool = Pool(processes=4) # define after make_hash pool.map(func=make_hash, iterable=range(0, len(files)))

57 Pamięć transakcyjna

67 Pamięć transakcyjna Python: Kamaelia/Axon ( Durus ( Java Deuce STM ( C SXM (research.microsoft.com) C/C++ wbudowana w GCC (gcc.gnu.org/wiki/transactionalmemory)

68 Bank

69 Bank ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {}

70 Bank ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): for i in ids: accounts[i] = sum def total(ids): total = 0 for i in ids: total += accounts[i] return total def transfer(a, b, sum): accounts[a] -= sum accounts[b] += sum

71 Bank from random import choice, randint ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): for i in ids: accounts[i] = sum init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 transfer(a, b, sum) print total(ids) def total(ids): total = 0 for i in ids: total += accounts[i] return total def transfer(a, b, sum): accounts[a] -= sum accounts[b] += sum

72 Bank from random import choice, randint ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): # transaction start for i in ids: accounts[i] = sum # transaction end init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 # fork process transfer(a, b, sum) # join processes print total(ids) def total(ids): # transaction start total = 0 for i in ids: total += accounts[i] # transaction end return total def transfer(a, b, sum): # transaction start accounts[a] -= sum accounts[b] += sum # transaction end

73 Bank from random import choice, randint from multiprocessing import Pool ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): # transaction start for i in ids: accounts[i] = sum # transaction end init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids) def total(ids): # transaction start total = 0 for i in ids: total += accounts[i] # transaction end return total def transfer(a, b, sum): # transaction start accounts[a] -= sum accounts[b] += sum # transaction end

74 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): # transaction start for i in ids: accounts[i] = sum # transaction end init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids) def total(ids): # transaction start total = 0 for i in ids: total += accounts[i] # transaction end return total def transfer(a, b, sum): # transaction start accounts[a] -= sum accounts[b] += sum # transaction end

75 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() for i in ids: accounts[i] = sum transaction.commit() def total(ids): transaction = Connection(ClientStorage()) accounts = transaction.get_root() total = 0 for i in ids: total += accounts[i] transaction.commit() def transfer(a, b, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() accounts[a] -= sum accounts[b] += sum transaction.commit() init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids) return total

76 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage, ConflictError ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() for i in ids: accounts[i] = sum transaction.commit() def total(ids): transaction = Connection(ClientStorage()) accounts = transaction.get_root() total = 0 for i in ids: total += accounts[i] transaction.commit() return total def transfer(a, b, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() try: accounts[a] -= sum accounts[b] += sum transaction.commit() except ConflictError: transaction.abort() init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids)

77 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage, ConflictError ACCOUNTS = 10 TRANSFERS = 10 ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def init(ids, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() for i in ids: accounts[i] = sum transaction.commit() def total(ids): transaction = Connection(ClientStorage()) accounts = transaction.get_root() total = 0 for i in ids: total += accounts[i] transaction.commit() return total def transfer(a, b, sum): transaction = Connection(ClientStorage()) accounts = transaction.get_root() while True: try: accounts[a] -= sum accounts[b] += sum transaction.commit() return except ConflictError: transaction.abort() init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids)

78

79 Bank class Transaction (Process): def init (self, f, args, kwargs={}): Process. init (self) self._f, self._a, self._kw = f, args, kwargs self.ppipe, self.pipe = Pipe() self._returned, self._result = False, None def run(self): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = self._f(memory, *self._a, **self._kw) transaction.commit() self.pipe.send(result) self.pipe.close() break except ConflictError: transaction.abort() def result(self): if not self._returned: self._result = self.ppipe.recv() self._returned = True return self._result

80 Bank class Transaction (Process): def init (self, f, args, kwargs={}): Process. init (self) self._f, self._a, self._kw = f, args, kwargs self.ppipe, self.pipe = Pipe() self._returned, self._result = False, None def run(self): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = self._f(memory, *self._a, **self._kw) transaction.commit() self.pipe.send(result) self.pipe.close() break except ConflictError: transaction.abort() def result(self): if not self._returned: self._result = self.ppipe.recv() self._returned = True return self._result # pool = Pool(processes=4) # pool = Pool(processes=4, initializer=transaction) t = Transaction(init, (ids, 1000)) t.start() t.join() ts = [] for i in range(0, TRANSFERS): #... t = Transaction(transfer, (a,b,sum)) # pool.apply_async(func=t.start) t.start() ts.append(t) for t in ts: t.join() t = Transaction(total, (ids,)) t.start() t.join() print t.result()

81 Bank class Transaction (Process): def init (self, f, args, kwargs={}): Process. init (self) self._f, self._a, self._kw = f, args, kwargs self.ppipe, self.pipe = Pipe() self._returned, self._result = False, None def run(self): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = self._f(memory, *self._a, **self._kw) transaction.commit() self.pipe.send(result) self.pipe.close() break except ConflictError: transaction.abort() def result(self): if not self._returned: self._result = self.ppipe.recv() self._returned = True return self._result # pool = Pool(processes=4) # pool = Pool(processes=4, initializer=transaction) t = Transaction(init, (ids, 1000)) t.start() t.join() ts = [] for i in range(0, TRANSFERS): #... t = Transaction(transfer, (a,b,sum)) # pool.apply_async(func=t.start) t.start() ts.append(t) for t in ts: t.join() t = Transaction(total, (ids,)) t.start() t.join() print t.result()

82 Bank def transaction(f, a, kw={}): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = f(memory, *a, **kw) transaction.commit() return result except ConflictError: transaction.abort()

83 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage, ConflictError ACCOUNTS = 10 TRANSFERS = 10 def total(ids): def _total(accounts, ids): total = 0 for i in ids: total += accounts[i] return total return transaction(_total, (ids,)) ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def transaction(f, a, kw={}): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = f(memory, *a, **kw) transaction.commit() return result except ConflictError: transaction.abort() def init(ids, sum): def _init(accounts, ids, sum): for i in ids: accounts[i] = sum return transaction(_init, (ids, sum,)) def transfer(a, b, sum): def _transfer(accounts, a, b, sum): accounts[a] -= sum accounts[b] += sum return transaction(_transfer, (a, b, sum)) init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids)

84 Pamięć transakcyjna Optymistyczna

85 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod

86 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod Uniwersalność

87 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod Uniwersalność ten sam schemat rozwiązuje większość problemów

88 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod Uniwersalność ten sam schemat rozwiązuje większość problemów Poprawa efektywności

89 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod Uniwersalność ten sam schemat rozwiązuje większość problemów Poprawa efektywności (jeśli nie ma dużo konfliktów)

90 Pamięć transakcyjna Optymistyczna czynności są powtarzane jeśli są konflikty czuła na liczbę transakcji i zasobow extra kod Uniwersalność ten sam schemat rozwiązuje większość problemów Poprawa efektywności (jeśli nie ma dużo konfliktów) Akcje muszą dać się powtarzać (i nie mogą mieć nieodwracalnych efektów)

91 Bank // Deuce STM // compile with -javaagent:bin/deuceagent.jar public class Bank { public static final int TRANSFERS = 10; public static final int ACCOUNTS = 100; } private final double[] accounts = new double[accounts]; public Bank() { for (int i = 0; i < accounts.length; i++) { accounts[i] = 200; } public void total() { double total = 0d; for (int i = 0; i < accounts.length; i++) { total += accounts[i]; } public void transfer(int a, int b, double sum) { accounts[a] -= sum; accounts[b] += sum; } public static void main(string[] args) { final Random random = new Random(); final Bank bank = new Bank(); List<Thread> transactions = new LinkedList<Thread>(); } for (int i = 0; i < Bank.TRANSFERS; i++) { final int a = random.nextint(bank.accounts); final int b = random.nextint(bank.accounts); final double sum = 5d + random.nextdouble() % 15d; Thread t = new Thread() { public void run() { bank.transfer(a, b, sum); } }; t.start(); transactions.add(t); } Thread t = new Thread() { public void run() { bank.total(); } }; t.start(); transactions.add(t); for (Thread thread : transactions) { thread.join(); }

92 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage, ConflictError ACCOUNTS = 10 TRANSFERS = 10 def total(ids): def _total(accounts, ids): total = 0 for i in ids: total += accounts[i] return total return transaction(_total, (ids,)) ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def transaction(f, a, kw={}): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = f(memory, *a, **kw) transaction.commit() return result except ConflictError: transaction.abort() def init(ids, sum): def _init(accounts, ids, sum): for i in ids: accounts[i] = sum return transaction(_init, (ids, sum,)) def transfer(a, b, sum): def _transfer(accounts, a, b, sum): accounts[a] -= sum accounts[b] += sum return transaction(_transfer, (a, b, sum)) init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids)

93 Bank from random import choice, randint from multiprocessing import Pool from durus.connection import Connection from durus.client_storage import ClientStorage, ConflictError ACCOUNTS = 10 TRANSFERS = 10 def total(ids): def _total(accounts, ids): total = 0 for i in ids: total += accounts[i] return total return transaction(_total, (ids,)) ids = ["id_" + str(i) for i in range(0, ACCOUNTS)] accounts = {} def transaction(f, a, kw={}): transaction = Connection(ClientStorage()) while True: try: memory = transaction.get_root() result = f(memory, *a, **kw) transaction.commit() return result except ConflictError: transaction.abort() def init(ids, sum): def _init(accounts, ids, sum): for i in ids: accounts[i] = sum return transaction(_init, (ids, sum,)) def transfer(a, b, sum): def _transfer(accounts, a, b, sum): ask_user_for_authentication(a, b, sum) if _: accounts[a] -= sum accounts[b] += sum return transaction(_transfer, (a, b, sum)) init(ids, 1000) for i in range(0, TRANSFERS): a = choice(ids) b = choice(filter(lambda x: x!= a, ids)) sum = randint(1, 5) * 100 pool.apply_async(func=transfer, args=(a,b,sum)) pool.close() pool.join() print total(ids)

94 Globalny zamek!

95 Globalny zamek!

96 Posortowane zamki Pesymistyczne transakcje

97 Ale zamki są trudne?

98 Tak Ale zamki są trudne?

99 Ale zamki są trudne? Tak... ale dlaczego?

100 Ale zamki są trudne? Tak... ale dlaczego? Deadlock

101 Ale zamki są trudne? Tak... ale dlaczego? Deadlock Pamiętanie który zamek jest do czego i kompozycyjność

102 Ale zamki są trudne? Tak... ale dlaczego? Deadlock Pamiętanie który zamek jest do czego i kompozycyjność Dodatkowy kod

103 Ale zamki są trudne? Tak... ale dlaczego? Deadlock Pamiętanie który zamek jest do czego i kompozycyjność Dodatkowy kod zamknąć zamki w transakcje

104 Ale zamki są trudne? Tak... ale dlaczego? Deadlock Pamiętanie który zamek jest do czego i kompozycyjność po jednym zamku na obiekt współdzielony Dodatkowy kod zamknąć zamki w transakcje

105 Ale zamki są trudne? Tak... ale dlaczego? Deadlock sortowanie zamków, 2PL Pamiętanie który zamek jest do czego i kompozycyjność po jednym zamku na obiekt współdzielony Dodatkowy kod zamknąć zamki w transakcje

106 Posortowane zamki

112 Posortowane zamki from multiprocessing import Lock accounts, locks = {}, {} for i in range(0, ACCOUNTS): accounts[i] = 200 locks[i] = Lock() def transfer(a, b, sum): _locks = [locks[a], locks[b]] _locks.sort(key = lambda x: str(x)) for lock in _locks: lock.acquire() accounts[a] -= sum locks[a].release() accounts[b] += sum locks[b].release()

113 Kiedy czego używać? Wątki funcyjne

114 Kiedy czego używać? Wątki funcyjne niezależne zadania

115 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje

116 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby

117 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby Posortowane zamki

118 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby Posortowane zamki wszystko czego nie można powtarzać

119 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby Posortowane zamki wszystko czego nie można powtarzać Globalny zamek

120 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby Posortowane zamki wszystko czego nie można powtarzać Globalny zamek najlepiej nigdy

121 Kiedy czego używać? Wątki funcyjne niezależne zadania Transakcje wszystko co można powtarzać, bez bardzo dużej konkurencji o zasoby Posortowane zamki wszystko czego nie można powtarzać Globalny zamek najlepiej nigdy

122 Koło Naukowe SKiSR Koło Naukowe SKiSR

123 Koło Naukowe SKiSR Koło Naukowe SKiSR