MeeGo 1.1 – krótka recenzja

Postanowiłem przetestować MeeGo, mobilny, otwarty i nieukończony jeszcze system dwóch znaczących graczy na rynku elektroniki użytkowej – Nokii oraz Intela.

MeeGo nie jest tylko nowym Symbianem, odpowiedzią na iOS, Androida i Windows Phone 7. Jest to jednolita platforma dla szerokiej gamy urządzeń mobilnych: telefonów, tabletów, netbooków, samochodów… Wspólny rdzeń we wszystkich tych wariantach ma zapewnić między innymi bezproblemową przenośność aplikacji pochodzących naturalnie z OviStore. Każde opcja różni się tak naprawdę interfejsem użytkownika, z angielskiego określanego jako User eXperience. Co ciekawe, dobrze zaprojektowana aplikacja sprawdzi się zarówno na netbooku, jak i telefonie. Czytaj dalej MeeGo 1.1 – krótka recenzja

Pamięć Transakcyjna – Istniejące implementacje – cz.2

W poprzednim poście przedstawiłem Wam kilka istniejących implementacji STM, a dzisiaj chciałbym dopełnić tę listę o kilka równie ważnych rozwiązań.

NSTM [2] to .NETowe rozwiązanie Ralfa Sudelbuchera, który na swoim blogu w kilku wpisach [1] wyjaśnia dokładnie, w jaki sposób z niego korzystać.  Tak jak poprzednio opisywane rozwiązania, NSTM opakowuje obiekty, ale w inny sposób, niż robi to np. SXM – opakowując wskazane metody i właściwości obiektu. NSTM trzyma wewnątrz fasady obiekt danej klasy, może go nam zwrócić (zapisze to wtedy w logu) i wtedy mamy możliwość jego modyfikacji, ale nastepnie należy go znów w całości zapisać. Przykład ze strony Ralfa:

  1. INstmObject<double> myAccount;
  2. INstmObject<double> yourAccount;
  3.  
  4. myAccount = NstmMemory.CreateObject(1000);
  5. yourAccount = NstmMemory.CreateObject(500);
  6.  
  7. using (INstmTransaction tx = NstmMemory.BeginTransaction())
  8. {
  9.    double amountToTransfer = 150;
  10.    myAccount.Write(myAccount.Read() – amountToTransfer);
  11.    yourAccount.Write(yourAccount.Read() + amountToTransfer);
  12.    tx.Commit();
  13. }

Kolejnym rozwiązaniem autorstwa trochę większego producenta niż jednoosobowy zespół Ralfa jest Intel® C++ STM Compiler, Prototype Edition 3.0 [3]. Na początek zachęcam do obejrzenia Flashowej prezentacji omawiającej problem transakcji. Choć wszystkie napisy w owej prezentacji brzmią „undefined„, to animacja przedstawiona na rysunku obok doskonale tłumaczy zasady STM. Wracając jednak do samego rozwiązania. Środowisko to oczywiście C++. Odpowiednie metody klas (te, których chcemy używać w transakcji) należy opatrzyć atrybutem __declspec(tm_callable), samą transakcję deklarujemy przy pomocy bloku __declspec(tm_callable). Przykład ze strony producenta, w powiązaniu z OpenMP:

  1. include<stdio.h>
  2.  
  3. int xx = 0;
  4.  
  5. class Base {
  6.   public:
  7.   __declspec(tm_callable)
  8.   virtual void TxnAddOne() {
  9.     xx = xx + 1;
  10.   }
  11. };
  12.  
  13. class Virtual : public Base {
  14.   public:
  15.   __declspec(tm_callable)
  16.   void TxnAddOne() {
  17.     xx = xx + 1;
  18.   }
  19. };
  20.  
  21. int main() {
  22.   Base *x, *y;
  23.  
  24.   __tm_atomic {
  25.     x = new Base();
  26.     x->TxnAddOne();
  27.   }
  28.  
  29.   __tm_atomic {
  30.     y = new Virtual();
  31.     y->TxnAddOne();
  32.   }
  33. }

[Pobierz cały kod ze strony Intela]

Na rozwiązaniu Intela chciałbym zakończyć przedstawianie implementacji STM. Większość tych, które nie zostały omówione, nie była uaktualniana od kilku lat, a jak wiemy, w branży IT 2-3 lata to przepaść.

Był to ostatni wpis na temat Pamięci Transakcyjnej. W następnych postach z cyklu „Go Parallel, be Master” postaram się opisać kolejny sposób na tworzenie aplikacji równoległych, jednak tym razem z wykorzystaniem agentów oraz wiadomości. Zapraszam.

Źródła:

Promuj