SamsungRzuciłem pracę w Samsungu Czekałem na tę chwilę już od dawna. Z końcem kwietnia opuściłem R&D Samsunga. Ponad 3 lata spędzone w szeregach koreańskiej korporacji nauczyły mnie bardzo wiele, w większości tego, czego nie należy robić. Poznałem wielu ciekawych ludzi, z wieloma chciałbym dalej...

Czytaj dalej

samsung-s3Prezentacja Samsunga Galaxy SIII, a iPhona Apple Właśnie skończyłem oglądać konferencję Samsung Unpacked 2012, podczas której koreański gigant zaprezentował najnowszego przedstawiciela serii Galaxy, model SIII. Godzinna prezentacja, przeprowadzona w Londynie, a transmitowana na cały świat, była moim zdaniem bardzo...

Czytaj dalej

Android Market LogoProgramisto, zostań milionerem! Bądźmy szczerzy: dziś każdy chce być bogaty. Pieniądze czynią nas szczęśliwszymi, rozwiązują wiele problemów, spełniają marzenia. Tylko jak zdobyć na tyle dużo gotówki, aby do końca życia pić drinki na hawajskiej plaży? Jeśli jesteś programistą - miliony masz...

Czytaj dalej

wp7_logoWP7 - na razie dziękuję Moja przygoda z Windows Phone zakończyła się szybciej niż myślałem. Wróciłem do Androida z jednego prostego powodu, za bardzo jestem powiązany z ekosystemem Google. Ale zacznijmy od początku... Zanim zdecydowałem się w całości przesiąść na nowy mobilny system od...

Czytaj dalej

SE K750 ImagesSprzedaj swój stary telefon Czy masz może w szafie tak stary telefon, że wydaje się, że musiałbyś komuś zapłacić aby go od Ciebie zabrał? Jeśli tak, to mam dla Ciebie świetne rozwiązanie, zrób z niego pożytek i sprzedaj go w Top Dollar Mobile. Jakiś czas temu natrafiłem w sieci na artykuł,...

Czytaj dalej

Pamięć Transakcyjna – Od kuchni

W poprzednim poście wprowadziłem Was wstępnie w zagadnienie Pamięci Transakcyjnej. Dzisiaj kolejna porcja informacji na temat STM.

Pamiętacie przykład z Bankiem? Zależało nam, aby dwie operacje, debetowa oraz kredytowa, były wykonane, w kontekście jednej. Do tego celu zdefiniowaliśmy transakcje. Przypominam kod transferu:

  1. void transfer(account a1, account a2, double amount) {
  2.   a1.debit(amount);
  3.   a2.credit(amount);
  4. }

Zgodnie założeniem transakcji (pamięci transakcyjnej) obydwie operacje powinniśmy umieścić w atomowym bloku.

  1. void transfer(account a1, account a2, double amount) {
  2.   atomic {
  3.     a1.debit(amount);
  4.     a2.credit(amount);
  5.   }
  6. }

Przypuśćmy, że w tym samym czasie wykonywane są setki transakcji. Niektóre z nich używają tych samych kont bankowych. W takim przypadku transakcja powinna zachowywać się w następujący sposób: po wejściu w atmowy blok nic specjalnego nie powinno się wydarzyć. Pierwsza instrukcja – debetowa – modyfikuje stan konta, ale w taki sposób, że zmienione saldo tego konta widoczne jest jedynie wewnątrz transakcji (wewnątrz bloku atomic), a nie na zewnątrz. W podobny sposób wykonywana jest metoda kredytująca. Jeżeli mechnizm STM wykryje, że jakaś instrukcja modyfikuje/pobiera dane, które zmieniły się od chwili wejścia w blok atomowy, wszystkie instrukcje wykonane w tym bloku są wycofywane, a transakcja rozpoczyna się ponownie. Jeśli cała transakcja przebiegła poprawnie (bez wykrycia kolizji), to na końcu atomowego bloku zmienione dane są zatwierdzane (wykonany jest commit) i od tej chwili są widoczne dla wszystkich. Jak widać, założenie pamięci transakcyjnej jest bardzo optymistyczne.

Pewnie zadajecie sobie teraz pytanie, w jaki sposób wycofywać operacje? I słusznie. Oczywiście, w przypadku niektórych metod można zdefiniować „metodę wsteczną”, ale w ten sposób nie uzyskamy izolacji, jednej z czterech własności transakcji, a ponadto nadal będziemy zmagać się z wyścigami. Właśnie dlatego STM bardzo trudno zaimplementować jako zewnętrzną bibliotekę, ponieważ mechanizm ten musi być ściśle powiązany ze środowiskiem wykonawczym.

Każdy odczyt oraz każdy zapis w atomowym bloku powinien być umieszczany w logu. Wpisy te posłużą albo do wycofania transakcji, albo do jej zatwierdzania. Zarządzanie takim logiem jest kluczowym aspektem w mechnizmie STM. Drugą ważną kwestią jest wykrywanie konfliktów, podczas których transakcja powinna być wycofana.

Istnieją dwie metody implementacji STM: z blokowaniem lub bez, czyli podobnie jak w mechanizmie synchronizacji. Jeden z pierwszych pomysłów, opisany w dokumencie [1], przedstawia implementację STM dla języka Java. Ograniczeniem w tym rozwiązaniu jest możliwość operowania jedynie na danych długości jednego słowa. Używa się w nim dodatkowych struktur, które przechowują informacje o transakcji. Sam atomowy blok przedstawiony jest następująco:

  1. boolean done = false;
  2. while (!done) {
  3.   STMStart ();
  4.   try {
  5.     if (condition) {
  6.       statements; //tutaj umieszcza się operacje
  7.       done = STMCommit ();
  8.     }
  9.     else {
  10.       STMWait();
  11.     }
  12.   }
  13.   catch (Throwable t) {
  14.     done = STMCommit ();
  15.     if (done) {
  16.       throw t;
  17.     }
  18.   }
  19. }

Więcej informacji o tym rozwiązaniu w dokumencie [1]. W kolejnym wpisie skoncentruję się na wydajności STM oraz porównam go ze zwykłym mechanizmem synchronizacji. Zapraszam.

Źródła:

Promuj

Pamięć Transakcyjna – Wstęp

Oto kolejny wpis mający przybliżyć moje imię do przedrostka mgr. W ostatnim poście przedstawiłem Wam wskazówki, skąd najlepiej czerpać informacje o rozwiązaniu Parallel Extensions. Dzisiaj chciałbym przedstawić kolejny mechanizm ułatwiający pisanie aplikacji równoległych – bardziej zaawansowany i wyszukany, a w dodatku jeszcze niestosowany w rozwiązaniach komercyjnych. Chodzi mianowicie  o Pamięć Transakcyjną.

STM (z ang. Software Transaction Memory) to podejście zaczerpnięte od kolegów z baz danych. Skoro na jednej instancji bazy danych może pracować kilku klientów, to należy ich pracę w pewien sposób synchronizować, tak aby nie przeszkadzali sobie nawzajem. W tym celu wprowadzono transakcje. Idea jest bardzo prosta: albo wszystkie instrukcje w danej transakcji wykonają się poprawnie, albo żadna z nich nie powinna się wykonać. Cecha ta określana jest jako niepodzielność. Głównych cech jest w sumie 4. Pozostałe to spójność (transakcja nie narusza niezmienników systemowych), izolacja (częściowe zmiany dokonane w środku transakcji nie są widziane na zewnątrz) oraz stałość (po ukończeniu transakcji zmiany zapisywane są na stałe i stają się wtedy widoczne dla innych). Taką ideę chciano wprowadzić w języku programowania, wykorzystując bardzo prosty zapis:

atomic {
 instrukcja1;
 instrukcja2;
}
.

Wszystkie instrukcje wykonają się poprawnie albo żadna z nich nie wykona się w ogóle. Co to oznacza? Jeżeli w pewnej chwili natrafimy na taki moment, że transakcja nie może być kontynuowana, zostaje ona wycofana i ponowiona, a skutki wykonania instrukcji, które zdążyły się wykonać, zostają wycofane. Brzmi niewiarygodnie? Jak to wykorzystać w programowaniu równoległym? Jakie są ograniczenia, a jakie możliwości? O tym w dalszej części artykułu.

Temat jest obszerny i nie sposób napisać tu o tym wszystkim, co chciałbym Wam przekazać. Postaram się skupić na najważniejszych faktach i wierzę, że skorzystacie z podanych linków, aby zaspokoić swoją ciekawość.

Na początku najlepiej będzie posłużyć się przykładem Banku – sztandarowym, jeżeli chodzi o STM. W owym banku realizowany jest przelew pieniężny z jednego konta na drugie. Oto przykładowa funkcja (pominięto kod sprawdzający parametry, aktualny stan itp.):

void transfer(account a1, account a2, double amount) {
 a1.debit(amount);
 a2.credit(amount);
}
.

Jak wiadomo, w banku odbywają się setki, tysiące transakcji na sekundę.  Wszystkie transakcje nie odbywają się w jednym wątku/procesie, więc potrzebna jest synchronizacja, aby żadnemu klientowi banku nie zginęły pieniążki. Na pierwszy (błędny) rzut oka można zastosować monitor na banku i nie dopuścić, aby żadne dwie transakcje wykonywały się w tym samym momencie. OK? Ale przez to nie możemy w tym samym momencie wykonać przelewu z A do B i z C do D. Wydajność takiego systemu transakcyjnego byłaby bardzo słaba.

Kolejnym pomysłem byłoby zastosowanie monitorów na obiektach poszczególnych kont. Jednak powstaje kolejny problem: jeśli obciążymy jedno konto (wykonamy debit, ale jeszcze nie credit), i nastąpi przełączenie kontekstu wątku, w którym wykonywano ten transfer, to pieniądze w pewnej chwili nie znajdowałby się na żadnym z tych kont, a taka sytuacja z punktu widzenia banku jest niedopuszczalna.

Inny pomysł: użyjmy semaforów/blokad w następujący sposób:

void transfer(account a1, account a2, double amount) {
 lock(a1) {
  lock(a2) {
   a1.debit(amount);
   a2.credit(amount);
}}}
.

Wydaje się sensowne, ale zaraz, zaraz: czy możemy się zakleszczyć (deadlock)? Naturalnie, wystarczy, że w tym samym momencie wykonamy przelew z A1 na A2 i z A2 na A1. Kiepskie rozwiązanie. A jeśli bank chce operować na więcej niż dwóch kontach jednocześnie? W ten sposób powstaje co raz więcej problemów do rozwiązania.

W jaki sposób rozwiązać zatem ten problem, jeśli realizowane jest to w prawdziwych systemach bankowych? O tym w kolejnym wpisie. Zapraszam.

Źródła:

Promuj

Go Parallel, Be Master

Jeśli widzieliście moją prezentację o Programowaniu Równoległym, wiecie, że nie jest mi obcy temat równoległości, wielowątkowości i wieloprocesorowości, uff…. Teraz ta znajomość wchodzi na inny poziom. Moja praca magisterska, której obrona planowana jest na luty 2011 r., będzie ściśle powiązana z tym zagadnieniem. Tematem jest paralelizm aplikacji oraz jego weryfikacja. W skrócie: mam wymyślić, jak w możliwie automatyczny sposób zrównoleglić aplikację oraz w jaki sposób zweryfikować takie zrównoleglenie.

Pierwsza część polega na zbudowaniu narzędzia (prawdopodobnie pluginu do Visual Studio), który będzie podpowiadał programiście, które elementy kodu można zrównoleglić oraz jak to zrobić, używając znanych metod i rozwiązań. Druga część, ściśle powiązana z pierwszą, ma na celu zweryfikowanie, czy podział aplikacji na niezależne, równoległe ciągi instrukcji nie zmieni jego zachowania w każdym możliwym przypadku szeregowania; ma być to dowód formalny.

Jak widać, zagadnienie nie jest trywialne, więc na początek będę musiał się troszkę podszkolić, przekopać przez tony literatury i kodu źródłowego. W cyklu notek opatrzonych tagiem „magister” będę na bieżąco raportował moje postępy. Zatem zaczynajmy…

Jeśli chodzi o programowanie równoległe (używając tej nazwy, będą odnosił się jednocześnie do programowania wielowątkowego i wieloprocesorowego), to na samym początku należy opanować podstawy. Czym jest wątek, proces, deadlock, mutex, monitor? Nie będę tego opisywał, ale proponuję samodzielnie poczytać i pomyśleć. Dodatkowo polecam serię artykułów o wielowątkowości na blogu Piotra Zielińskiego. Zostały tam opisane wspomniane elementy oraz ich zastosowanie w środowisku .NET.

Celem pierwszego etapu mojej pracy jest zapoznanie się z możliwie jak największa liczbą zaawansowanych rozwiązań do kontroli/wprowadzania równoległości. Przez zaawansowane mam na myśli wszystko poza klasycznym mutexem, semaforem czy monitorem. Oczywiście w tych rozwiązaniach takie właśnie mechanizmy zostały użyte, ale głęboko, głęboko, pod maską. Programiście zostaje za to udostępniony zupełnie inny, bardziej przyjazny interfejs. Na początek Parallel Extensions…

Nie będę się powtarzał i odsyłam zainteresowanych do mojego artykułu na CodeGuru (część 1, bo 2 nigdy nie powstała – mój błąd). Opisuję tam podstawy tego rozwiązania, wyjaśniam, jak to naprawdę działa, i kiedy należy takie mechanizmy stosować. Dodatkowo zachęcam do subskrypcji blogu zespołu rozwijającego ten produkt – PFX Team. Przynajmniej raz na tydzień pojawia się nowa notka opisująca pewną funkcjonalność produktu. Wspomnieć należy również o Parallel Computing Developer Center w strukturach portalu MSDN. Zebrano tam dziesiątki artykułów, przykładów, screencastów i wywiadów z osobami odpowiedzialnymi za projekt. Polecam!

Na koniec warto wspomnieć o konkurencyjnym rozwiązaniu dla języków C/C++  – OpenMP.

Promuj