= 5. Moderní softwarové systémy = Interpretace požadavků od Mr. Tůmy: http://d3s.mff.cuni.cz/~ceres/adm/moderni-softwarove-systemy.php == a. Moderní architektury: == i. virtualizace paměti na paralelních architekturách (SMP, NUMA), ii. hyperthreading, iii. multicore, iv. podpora v operačním systému, v. programování v paralelních prostředích, vi. neblokující algoritmy Distribuovaný systém: nezávislé uzly, dojem jednotného systému, komunikace mezi uzly přes síť. Distribuované osy mrtvé, mechanismy využity v aplikacích, lokální os, rozšiřující vrstva, distribuovaná mezivrstva (middleware) Transparentnost - tváří se to jako jednotný systém === i. virtualizace paměti na paralelních architekturách (SMP, NUMA), === Paralelní architektury: - Těsně spřažené (tightly coupled) - multiprocesory se sdílenou pamětí - sběrnicová: sdílená sběrnice hází data do cache procesoru - přepínačová: mřížka procesory x paměti, nebo omega network nlogn - používá perfect shuffle - každá krabice spojuje dvě z předchozí úrovně, např. 1.+3., 2.+4,... - Volně spřažené (loosely coupled) - multicomputery, každý vlastní paměť - sběrnicová: běžná počítačová síť, netřeba tolik komunikace jako u tightly protože má každý svou paměť, možnost processor pool (mám logické procesory, dávám jim fyzické z poolu) - přepínačová: - mřížka: na každé pozici mřížky jeden počítač, fajn pro 2D problémy, grafy,... - hyperkrychle: obvykle 4 rozměrná, každý počítač přímo propojen se sousedy ve všech rozměrech. IBM Watson Blue Gene ==== SMP: ==== Symmetric multiprocessing: architektura, kde je víc procesorů připojeno na jednu paměť, používaná v dnešních multiprocesorech. procesor může běžet na datech ať jsou kdekoliv v paměti. přesouvání tasků po procesorech - load balancing aby se plně využily procesory, musí s tím program počítat. I když s tím nepočítá, je to rychlejší než single procesor, protože není tolik přerušení - místo přerušení se to hodí na volné procesory, když běží víc tasků, každý má svůj procesor - to musí umět os sériový přístup do paměti, typicky přes sběrnici ==== Hybridní architektura NUMA: ==== Non Uniform Memory Access, v multiprocesorech procesor má kus paměti kam může přistupovat rychleji než do zbytku, občas se musí přesouvat data. fajn pro servery, kde mají tasky přiřazená data plus mínus pevně. procesory jsou rychlejší než paměti, proto mají cache víc procesorů může lézt do paměti najednou, do svého kusu. cacheově nekoherentní NUMA se blbě zaintegrovává do klasické architektury počítače, proto se používá ccNUMA - má special hardware na udržování koherence, pokud procesy sdílí data, musí se synchronizovat. cache coherence: - jednoduchá varianta - bus sniffing. cache má bity: valid, invalid, dirty , shared (má to ještě někdo). čtou a zapisují data, posílají si broadcast signály přes sběrnici. Nedá se to moc škálovat. - Možno použít SCI Scalable Coherent Interface standard komunikace, založený na distributed directory based cache coherence model Při práci s pamětí si procesor udělá lokální kopii dat ve své cachi, původní data zůstávají v paměti S-COMA: Simple Cache-Only Memory Architecture Používá hlavní paměť jako cache, čili když pracuje s daty, tak si je přesune do svého adresového prostoru ASMP: Asymmetric Multiprocessing: specializované procesory pro specifické tasky NUMA-faktor - rozdíl latence lokálních a vzdálených paměťových přístupů === ii. hyperthreading, === ==== SMT - Simultaneous multithreading:==== narozdíl od Temporal Multithreading, kde může běžet jen jedno vlákno na procesoru v jednu dobu, tady může běžet víc. Zvyšuje Thread Level Paralelism. Procesor musí mít akorát větší registry, aby se tam vešel kontext víc vláken, a musí umět brát instrukce víc threadů najednou. Oproti superskalárním procesorům, které berou instrukce z jednoho vlákna a vykonávají je paralelně (když to jde) - tj. zvyšují Instruction Level Paralelism, berou instrukce z víc threadů. Pipelining - zatímco se čeká, dělá se něco dalšího. nemusí paralelně. Hyperthreading (HTT): technologie Intelu, která umí pouštět instrukce z víc threadů na jednom procesoru najednou (SMT). Os adresuje místo každého fyzického procesoru dva virtuální. Musí mít podporu minimálně pro SMP, ale měl by být na to optimalizovaný. Např. jeden thread může používat Integer a druhý floating point sčítačku. Některé části procesoru se duplikují, většina ne. Very long instruction word or VLIW: kompilátor vytváří instrukce včetně informací co je na čem závislé. frčí v embedded systémech. === iii. multicore, === Více procesorů v jednom integrovaném obvodu různé stupně couplingu: sdílejí cache/ne homogenní nebo heterogenní Amdahl's law: improvement = 1/((1-p)+ p/s) .. p je procentáž operací, kde se dá využít paralelizace, s .. zrychlení častěji se může provádět cache coherency synchronizace - může být uvnitř, menší spotřeba než vysokofrekvenční, nebo víceprocesorové. fajn na servery s více uživateli, např web servery === iv. podpora v operačním systému, === ASMP-L INUX, ASymmetric MultiProcessor Linux, ==== Sdílené caches, soupeření o kapacitu a udržování koherence ==== Intel Core Duo má sdílené cache. Výhody sdílených cachí: když jedno jádro spí, druhé má cache pro sebe. Rychlé sdílení dat mezi vlákny běžícími na různých jádrech se sdílenou cachí. Míň problémů s cache coherence, nemusí se tak často přistupovat do paměti. Techniky optimalizování přístupů do sdílených cachí, další pojmy: - cache blocking (data tiling): pro zpracování datasetů - nad každým kusem dat se dělají nějaké operace. rozdělit data na menší kusy, aby se vešly do cache, udělat nad nimi co se dá. - delayed approach: čeká se až se změny dostanou do L2 cache a pak se teprv druhému jádru řekne, že má pokračovat, čímž se ušetří jedno čtení z paměti do cache. - False sharing: sice každý píše někam jinam do sharované cache, ale stejně se to musí synchoronizovat přes další level paměti (L2/paměť). Řešení: dávat nesdílená data odděleně od sdílených. - Procesor affinity: vlákna, která mají sdílená data, by měly jít na stejné jádro, nebo na jádra, která sdílí cache. když dávám na stejný procesor, nebo procesory se sdílenou cachí vlákna, které nemají nic společného, tak to nebude moc fajn, budou bojovat o cache. Cache coherence: když jsou stejná data v cachích dvou procesorů a jeden je změní, tak se změna musí propagovat i do druhé cache. Musí být zachováno: - pořadí instrukcí (když něco zapíšu, nikdo to nezmění a já to znovu přečtu, mělo by to být ono), - čtení aktuálních dat, - pořadí zápisu. Udržování: - Directory based: directory hlídá všechny čtení a zápisy do cachí z hlavní paměti, procesory před čtením/zápisem se ptají jestli můžou. Když se data změní, updatuje/invaliduje to všem cache. - Snooping: každý procesor hlídá kus paměti, který má nacachovaný. Když se změní, updatuje si cache. = bus sniffing. cache má bity: valid, invalid, dirty , shared (má to ještě někdo). čtou a zapisují data, posílají si signály přes sběrnici.Nedá se to moc škálovat, ale na malých je to rychlé - Snarfing: jako snooping, ale ještě navíc to sleduje obsah paměti. ==== Optimalizace alokace (omezení kolizí, lokální alokace) ==== http://siber.cankaya.edu.tr/ozdogan/OperatingSystems/ceng328/node202.html Alokace framů na procesy, možnosti: - rovnoměrně: každý proces dostane stejně framů - proporčně: podle velikosti jejich virtuální paměti Algoritmy výběru stránky na vyhození: LRU (least recently used), hodiny (second chance): každá stránka má bit, při přístupu se nastaví na 0 při průchodu ručičky se nastaví na 1, při průchodu ručičky se vyhodí ty, které mají 1. řešení kolizí: - globální alokace: proces může sebrat jinému procesu frame, častější - lokální alokace: nemůže, nemění se počet framů na proces ==== Požadavky na plánování u hyperthreading a multicore systémů. ==== http://www.scribd.com/doc/4838281/Operating-System-Scheduling-on-multicore-architectures - cache fairness: některé thready potřebují víc místa v cachi a tím pádem utlačují ostatní. Priority ztrácí smysl, protože thread může být na procesoru zároveň s threadem, který mu sežere skoro celou cache a tím pádem poběží déle. Řešení: rozdělit cache na best-effort a cache-fair - dostanou se na procesor na delší čas. - balance core assignment: nebalancovaný - těžko se určuje kdy co doběhne. pomocí benefit function se rozhoduje jestli se vyplatí přesunout thread na jiné jádro. - maximalizovat resource utlization btw. semafory = init, up, down. čítač, fronta procesů. Když chci vstoupit, dám down, po výstupu up. monitory (condition variable) - v jazycích - např třída, ve které může běžet max jedna funkce v každém okamžiku. wait(podmínka), čekej až bude splněná; signal(podmínka) - vlákno dává najevo, že podmínka je splněná. Zprávy, např MPI: send, receive. blokující/neblokující. přímé/nepřímé adresování ==== v. programování v paralelních prostředích, ==== ===== Synchronizace, časové závislé chyby. ===== počítán zrychlení při paralelním výpočtu: - Amdahl's law: improvement = 1/((1-p)+ p/s) .. p je procentáž operací, kde se dá využít paralelizace, s .. zrychlení - Gustafson's law: speedup S(P) = P - alfa*(P-1) .. P.. počet procesorů, alfa je procentáž operací kde se NEDÁ použít paralelizace, narozdíl od Amdahla počítá, že máme fixní čas a podle toho volíme velikost problému. narozdíl od Amdahla bere část, která se nedá zpracovat paralelně jako konstantní. Datové závislosti: žádný program nemůže běžet rychleji než je doba zpracování instrukcí na jeho critical path (nejdelší cesta ze závislých instrukcí). Bernsteinovy podmínky: vstupní proměnné - pro čtení R_i, R_j, výstupní proměnné - pro zápis W_i, W_j. Podmínky: R_j \cap W_i = \varnothing: porušení - zápis a čtení v jedné proměnné - závislost toku R_i \cap W_j = \varnothing: porušení - přepsání už přečtené proměnné W_i \cap W_j = \varnothing: porušení - dva píší na stejné místo .. sdílenou proměnnou je možné akorát číst... je to příliš přísné, pouze teoretický význam race condition - výsledek záleží na pořadí provádění operací distributed deadlock - deadlock v distribuovaném prostředí. možnost udělat globální wait-for-graph, dvoufázové zamykání, dvoufázový commit (první fáze hlasování o commitu, druhá commit když všichni pro, nebo abort) úrovně Paralelismu: - bit level: n-bitové procesory - instruction-level paralelism: vykonávání instrukcí paralelně, tam kde je to možné, pipeliny, superskalární procesory, SMT - data paralelism: rozdělit data na menší kusy, na každém z nich něco v cyklu počítat, místo jednoho velkého supercyklu - task paralelism: na jedněch datech běží víc operací najednou POSIX threads - standard API na thready, implementace na unixu, windows. mutexy, condition variables, barriers, ... MPI - portabilita, de facto standard, jádro dostane jeden proces. - výkonné, škálovatelné, portabilní, Java, Python, C#, ... - point-to-point komunikace, broadcast mezi proces ve skupině, podpora standardních datových typů. - MPI2 - sdílená paměť - hezky to běží na NUMA architektuře, podporuje lokalitu paměti - Language Independent Specifications - topologie, synchronizace, komunikace mezi procesy nasazenými na různé uzly - Concepty mpi2: - komunikatory: objekty, dá procesům čísla, rozdělí je do topologie, podle toho jak komunikují - point to point: všechny možné varianty posílání zpráv mezi dvěma procesy - collective: broadcast, reduce - vychytané datové typy- structy za sebe apod. ===== Koncepty paměťových modelů. ===== Paměťový model: popisuje jak vlákna interagují přes paměť. Jaké podmínky musí kompilátor udržovat při optimalizacích. Když jazyk nemá memory model nemůžou se dělat základní optimalizace, jako třeba sloučení dvou stejných cyklů za sebou (loop fusion). Když přehodí co nemá může dojít k race condition. Model specifikuje Synchronizační bariéry - když se dostanu k bariéře (např lock), musím vidět všechny změny na sdílených proměnných, jinak ne. Tím pádem může kompilátor dělat optimalizace, musí jen zaručit, že na bariérách to bude stejné jako kdyby se kód prováděl sekvenčně. Cache se nesynchronizjí pořád - bylo by to pomalé. Z pohledu vlákna se akce, které dělá jeví být v daném pořadí. Z pohledu jiného vlákna to může vypadat jinak. standard C++0x už bude mít memory model. - Data race: vlákno čte zatímco jiné vlákno zapisuje. Zapisuje a čte se vždycky kus najednou, takže se může přepsat něco co se mezitím změnilo. Java memory model. http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html - within-thread as-if-serial: v rámci jednoho vlákna sémantika stejná jako by to běželo tak jak je nadefinováno - synchronizační akce, např uvolnění zámku: vše před akcí je vidět pro všechny po akci - happens-before uspořádání: read může přečíst hodnotu která byla zapsána jako poslední v happens-before uspořádání, nebo může přečíst hodnotu, která byla zapsaná nějakým writem neuspořádaným vůči readu. Tj. akorát nemůže číst hodnoty z budoucnosti. - záleží na procesoru, některé mohou mít strong (tj. vždy se to synchronizuje) - hýbání writy dopředu a dozadu tak aby to neovlivnilo sémantiku, ale přesto se můžou dít podivuhodné věci (např. příklad se zapisováním a čtením, a=1, b=2 na sobě nezávisí). - původní memory model se ukázal být rozbitý - když v konstruktoru neunikne reference na nový objekt, tak všichni vidí final fieldy tak jak je konstruktor nastavil, bez nutnosti synchronizace. Např. nepřidávat nový objekt doWhy should you care? Concurrency bugs are very difficult to deb nějakého listu přímo v konstruktoru. - data race: (když má data race, tak je nesprávně synchronizovaný) 1. there is a write of a variable by one thread, 2. there is a read of the same variable by another thread and 3. the write and read are not ordered by synchronization - synchronizace: při acquire a release na zámku, synchronizace (cachí, registrů, ...) - memory operations na které se váže happens-before uspořádání: čtení, psaní, lock, unlock, start thead, join (čekání až typicky child vlákno něco skončí), - ordering rules: * Each action in a thread happens before every action in that thread that comes later in the program's order. (v sémantickém smyslu) * An unlock on a monitor happens before every subsequent lock on that same monitor. * A write to a volatile field happens before every subsequent read of that same volatile. * A call to start() on a thread happens before any actions in the started thread. * All actions in a thread happen before any other thread successfully returns from a join() on that thread. - synchronizační akce musí matchovat, tj musí probíhat na stejném monitoru/čekat na stejné vlákno/.. - volatile: read vždy vrátí výsledek posledního writu. kompilátor je nesmí dávat do registrů, cacheovat. po writu hned flush a invalidovat cache, před čtením taky invalidovat cache, zápis je to samé jako monitor release, čtení jako acquire. co se stalo předtím se propaguje. zase to musí matchovat. - double checked locking - nefunguje, není zaručeno, že inicializace nového objektu se provede před vrácením z funkce - statické inicializace jsou vidět všemi, vnitřní třídy jsou lazy ===== Consistency models ====== consistency models http://en.wikipedia.org/wiki/Consistency_model http://www.cs.nmsu.edu/~pfeiffer/classes/573/notes/consistency.html pravidla, co může dělat systém při paralelním vykonávání, který podporuje daný model, z pohledu sdílené paměti. - striktní konzistence: read vrací to co zapsal poslední write, vykonávání instrukcí nad pamětí přesně v daném pořadí. intuitivně co by to dělalo bez cachí Nemožno zaručit v distribuovaném systému s cachemi. - sekvenční konzistence: jestli je něco sekvenčně konzistentní je nerozhodnutelný problém. Výsledek bude stejný jako kdyby se to dělalo v nějakém existujícím pořadí, nepřehazuju operace nodu. Node vidí všechny write operace ve stejném pořadí jako si řekl. - cache coherence: to samý jako sekvenční, ale bere se to jenom lokálně (za proměnnou). sekvenční to bere globálně. - kauzální konzistence: slabší než sekvenční, silnější než PRAM. kauzální operace vidí všichni ve stejném pořadí. čtení a pak zápis jedním nodem jsou kauzální. zápis a pak čtení jedním nodem z té samé proměnné je kauzální. dva zápisy stejným nodem jsou kauzální (počítá, že první zapsaná se nezměnila a může se promítnout do druhé). Kauzalita je tranzitivní. Co není kauzální je concurrent. špatně se implementuje v hw. - PRAM konzistence: pipelined random access memory, reflektuje sítě a latenci mezi uzly. Writy tvořené nodem vidí všichni ve správném pořadí. Od různých nodů vidí pořadí různé procesory různě (latence). - Slow memory: zápisy jedním nodem do jednoho místa musí být vidět v tom správném pořadí - slabá konzistence: ne všichni se potřebují synchronizovat se všemi. nechat proces ukončit kritickou sekci a poté rozeslat změny ostatním. jsou synchronizační (slouží jen na synchronizaci) a nesynchronizační přístupy do paměti. Podmínky: - přístup do synchronizačních je sekvenčně konzistentní - přístup do synchronizačních musí počkat až se dodělají všechny writy - přístup kamkoliv musí počkat až se dodělá synchronizace - release consistency: paměť při přístupu k synchronizačním nerozezná vstup a výstup z kritické sekce- musí propagovat vždy vše. operace acquire a release. Podmínky: - před přístupem do sdílené proměnné musím dodělat všechny acquires - před releasem musím udělat všechny ready a writy - acquire a release operace musí být sekvenčně konzistentní. implementace: eager (všechno se propaguje po rel), lazy (propagace až při acqire) - entry consistency: synchronizační proměnné vázány na sdílená data, vlastník - ten co naposled zapisoval. Zápis (exkluzivní) jen když nikdo nepřistupuje k synchronizačním proměnným, Po zápisu si musí další (neexkluzivní) vyžádat aktuální data od vlastníka. ==== vi. neblokující algoritmy ==== ===== Klasifikace neblokujících algoritmů. ===== zajišťují, že se vlákno dostane k prostředku v konečném čase. Nepotřebují krické sekce. Alternativa k zámkům. Motivace: zablokované vlákno nic nedělá, problémy s deadlocky, live locky (dávají si vzájemně přednost a nepostupujou) a priority inversion (neblokovaný s menší prioritou dostane resource před blokovaným s vyšší) Implementace: atomické read-modify-write, compare-and-swap v hw. cas(*register, old_val, new_val). Když je v registru old_val, tak tam narve new_val a vrátí true, jinak neudělá nic a vrátí false. použití: přečtu hodnotu, udělám s tím něco. při pokusu zapsat, vyzkoušim jestli tam stará hodnota ještě pořád je, když jo, tak zapíšu novou. Když ne tak opakuju postup. http://audidude.com/?p=363 ABA probém nastává když mezi mým čtením a voláním CAS někdo zapisuje a poslední jeho zapsaná hodnota je stejná jako moje, ale má jiný význam, něco se mezitím stalo. Řešení: používat counter ve skryté části proměnné, aby to nehodilo tento false positive. - wait-free: nenastane starvation per thread, existuje horní hranice na dobu výpočtu. vzácné. Každý algoritmus může být naprogramován jako wait-free, ale je to pomalé. - lock-free: nenastane starvation globálně, ale na threadu může. lock-free datové struktury - stack, fifo, ... == b. Objektové koncepty moderních jazyků, třídy, mixiny, klony, vazba na typový systém == * Definice tříd, mixinů, klonů. * Vysvětlení konceptů typové kompatibility. === Objektové koncepty, třídy === - dynamic dispatch - encapsulation - subtype polymorhism - object inheritance - open recursion (self, this) => - reusability - modularity abstraction principles: - classification/instantiation - aggregation/decomposition - generalization/specialization - grouping/individualization: lists, tables inheritance pokrývá aggregation a generalization subclassing: vytváření subclassů. Můžu subclassovat aniž bych inheritoval (všechno předefinuju) subtyping: instance subclass může být na místě class, ale members specifické pro subclass nejsou vidět - attribute hiding specialization: is-a multiple inheritance - diamond problem. C3 algorithm python self a super name collisions, implicit override method lookup - delegation (dědičnost) nebo embedding (řeknu si u objektu metody) viditelnost class members nebo access list (kdo to vidí) dynamic dispatch (virtuální metody), vs. static dispatch casting je impure === Advanced === Scala: cosi typově bohatšího, přeložitelného do Javy - všechno je objekt, i funkce - single/multiple inheritance Python: take the head of the first list, i.e L[B1][0]; if this head is not in the tail of any of the other lists, then add it to the linearization of C and remove it from the lists in the merge, otherwise look at the head of the next list and take it, if it is a good head. Then repeat the operation until all the class are removed or it is impossible to find good heads. In this case, it is impossible to construct the merge, Python 2.3 will refuse to create the class C and will raise an exception. - interfaces: seznam hlaviček metod, java umí implementovat víc interfaců - mixin: fragment funkcionality třídy, z víc mixinů udělám třídu (násobnou dědičností). Samotný mixin se neinstanciuje. Jako interface, akorát implementovaný. - traits: jako mixin, akorát je možné skládat traity různými způsoby, např. symetrický součet, rozdíl, aliasing. - type parametrization: - generics C#: generický typ jako first-class objekt. Nesmaže se informace o typu jako v Javě, rychlejší - nemusí se castovat. - templates v C++: při kompilaci se vytvoří typy s daným parametrovým typem, zvlášť pro každé použití šablony. bounding types jako constraints v c# variance: list je subtype list .. v C# nefunguje. typová konverze nebo pravidlo je covariant, když zachovává uspořádání <= na typech (typ <= subtyp) je contravariant, když ho přehazuje je invariant když ani jedno To samé v parametrech metod při subclassingu by se občas hodilo mít i subtyping, když přetěžuju metodu, tak bych měl mít jiný typ parametru - C++ private inheritance - zděděné je vidět jenom jako privátní === kompatibilní typy === http://publib.boulder.ibm.com/infocenter/comphelp/v7v91/index.jsp?topic=%2Fcom.ibm.vacpp7a.doc%2Flanguage%2Fref%2Fclrc03compatible_types.htm kompatibilita - používat dva typy beze změn, např při přiřazení, btw. signed int = int - zaměnit jeden typ za druhý beze změny, do longu dáváš int, - složit dva typy do composite type unsigned int - unsigned int = int ... řeší se ve strong-typed jazycích. Ve weak typed se udělají konverze, takže je to vždy kompatibilní (javascript, vb) staticky typované jazyky (java, C): typ svázán s proměnnou, explicitní deklarace dynamicky (python, php): typ svázán s hodnotou, implicitní deklarace === problémy s inheritance === fragile base class: když změním base class, musím překompilovat i potomky v C++. Java to řeší. mezi class a subclass existuje implicitní interface sémantická závislost - závislost subclass na implementaci base class může se změnit množina možných stavů se synchronizací jsou problémy === Prototypy, klony === jazyk bez tříd, klonování existujících objektů návrh na úrovni objektů, vyhnutí se metatřídám posílání zpráv typ objektů = objekty od stejného prototypu Omega, Self, JavaScript, Lua odkaz na parent - prototyp clone je shallow Druhy objektů: - prototype - trait - chunk of attributes, typicky metody - normal sdílení metod a proměnných - jsou jen v parentovi JavaScript nemá třídy, objekty se tvoří constructor function, každý objekt má pointer na prototyp Dědičnost: - získávání atributů od prototypu, - implicitně - shallow copy - explicitně - když si řeknu, tak deep na dané fieldy - přidávání atributů - embedding: kopírování z prototypu, každý pak má svojí kopii (deepcopy) - delegation: sdílení s prototypem, možno víc prototypů dědičnost je dynamická a dá se měnit za běhu == c. Metaprogramování, reflexe, aspekty == * Popis a příklad rozhraní pro reflexi. * Definice a příklad aspektu. == Metatřídy == metaprogramování: vytvářet programy, které manipulují s jinými prgramy, nebo sami sebou. V podstatě tři možnosti: používat API runtimového prostředí, vytvářet stringy s kódem a ty pak pouštět, transformace programů typ třídy je meta třída. V Javě je metaclass Class, ale nedá se použít žádná jiná pro vytváření tříd, v pythonu jo. ve smalltalku taky a je to úlet === Reflexe === program může číst a modifikovat svou vlastní strukturu a chování. - compile time OpenC++, ovlivňuje chování kompilátoru: přidání loggování pomocí metaclass, registrování nového klíčového slova, přidání foreach apod. - runtime Java, C#, Java třída Class má hafo metod na reflexi - změna memberů, zjišťování vlastností třídy, memberů GetType, GetMethod, Invoke, getattr, setattr, .__class__ === Aspekty: === Separation of concerns Related functionality should be defined together funkcionality bývají pohromadě. ale např. loggování dělají všechny části systému = cross-cutting concern, nemůže být snadno vyčleněno do modulu. aspect: feature která je využívána mnoha jinými částmi programu, ale není to primární funkce programu. AspectJ: implementace té srandy v Javě, rozšíření jazyka. Základní koncepty - aspect: může přidávat metody už existujícím třídám. - pointcut = set of join points: definice míst v programu, kde se něco zajímavého děje, např volání metody, instanciace objektu, ... call - caller side, execution - calee side - advice: informace, jak se má kód vykonat kolem join points daného pointcutu, může být before, after, around, k zápisu se používají regulární výrazy. Aspect Weaver: to co bere původní kód a vkládá do něj nesmysly produkované aspecty. Výsledkem je woven class nebo woven bytecode aspect vidí to samé jako třída / privileged dá se s tím měnit i hierarchie dědičnosti Jako dekorátory v pythonu akorát se do dekorovaných metod nepíše ten dekorátor, ale definuje se to mimo. == d. Softwarové komponenty == vyšší level abstrakce A software component is a unit of composition with contractually specified interfaces and explicit context dependencies only. A software component can be deployed independently and is subject to composition by third parties. možnost použít v různých kontextech (black box) soa - nezávislý deploy high level design Component model: kolekce souvisejících abstrakcí a jejich významu, pravidla použití komponenty koncepty: - rozhraní: poskytuje, vyžaduje - binding: vazby. volání funkcí, events, messages - architektura komponenty - container: co se má deployovat - composition: flat (black box), hierarchical (grey, white box) - development lifecycle: component lifecycle, application lifecycle (dávání komponent dohromady) - design, development, deployment, execution, dynamic replacement - koheze - modularita - zaměnitelnost Component jako runtime koncept: má api, navíc např xml popis Component framework: server, který hostí komponenty. threadpool, transakce, perzistence, ... Data flow komponenty - modeluje se s nimi jak proudí data, možno nested. Dá se z toho generovat kód Server, na kterém běží víc komponent: aplikační server Akademické komponentové systémy: - silný popis architektury, api, interakcí mezi komponenty. umožňují verifikaci kompozice a komunikace, spolehlivost, generování kódu. Výzkum co s komponentami. SOFA 2 - component type = frame: definice funkcionality, rozhraní - primitive components: neobsahují subkomponenty, něco dělají. - composite components: mají subkomponenty, delegují - java anotace - speciální význam metod - subkomponenty možno specifikovat pomocí architektury nebo framu - assembly: při deploymentu musí být v listech primitivní komponenty, architektury popsány pomocí assembly descriptoru - je distribuovaná, komponenty deployovány po docích. Dock - kontejner na komponenty - prostředí SOFAnode, kde to pak běží - spojování komponent pomocí Connectorů - first class objekty. Connector definuje jak se bude komunikovat - volání metod, zprávy, ... nefunkční požadavky: bezpečnost, sledování výkonu, ... Jeden connector může spojovat víc komponent. při deploymentu se vytvoří automaticky - funkcionalita používaná všude možně, např. db - dock s databází, subkomponenta sdílená více komponentami - control logic - controllers - režie komponent - vázání na sebe, životní cyklus, ... - tvorba component - factory - mikrokomponenty pomocí aspektů - má to nějaký behaviour protokol - co by se mělo volat když. Frame protocol a architekture protokol - dá se checkovat vertikál compliance, jestli children dělají to co chce parent - horizontál jestli nejsou konflikty mezi dětmi - kontrola primitivních komponent - runtime checker, code analysis - dvě úrovně vývoje: - vývoj komponent - spojování už existujících, vytváření nových - systému - integrace, vícenásobné používání - lifecycle: - development - assembly - deployment, execution - kdy kde co má běžet, - generování connectorů - aplikace controllerů, běh - repository hotových component JavaBeans jsou komponenty events: publisher-subscriber pattern. zdroj eventů, listener - zaregistruje se, po eventu se zavolá funkce. property: jako get a set introspekce - reflexe Corba: - funguje jen přes LAN - industry standard by OMG - flat - platformová a jazyková nezávislost - Object Request Broker: - jádro corby - stará se transparenci umístění objektů, komunikaci, aktivaci - při zavolání najde implementaci objektu, aktivuje ho, pošle mu request - všechny requesty jdou přes něj - Interface Definition Language: - typy objektů definovány interfacy. - pouze definice interfacu, ne implementace, není programovací jazyk - podle interfacu, který klient potřebuje se vybere implementace v libovolném jazyce, který má mapování - Dynamic Invocation Interface: - ne přes stuby (statický), bere se z databáze interfaců (Interface Repository) - v klientovi můžu použít objekty aniž bych znal implementaci za compile timu - Dynamic Skeleton Interface: - To samý jako DII ale na serveru - implementuju interface, nevim kdo mě bude volat COM, .NET (assembly), Spring: Don't call us we'll call you Proč se to nepoužívá (jen flat model): - změny za runtimu, v hierarchickém modelu se špatně pracuje s břibyvšími více instancemi jedné komponenty - spojení s externími systémy a komponentami výzvy - spojování heterogenních komponent - model check potřebuje main co s rekonfigurací: - zakázat - zploštit architekturu za běhu - ztratí se korespondence k modelu - omezit jen na dovolené předem definované změny - povolit - eroze architektury Dynamická architektura - architektura musí být dynamická, např. když připojím tiskárnu. API na rekonfiguraci za runtimu - špatně se dokumentuje a verifikuje - dovolit jenom dané změny SOA: - Service registry, service provider, service consumer - může poskytovat služby i navenek, narozdíl od komponentů, které jsou typicky local - service je např přístup do databáze, tisk, ... - špatně se zachycuje v architektuře, binding on demand - component může využívat službu, nebo se může ukazovat jako služba (na to je special connector) - jenom nabízená rozhraní - deployment a implementace uvnitř se neřeší - skládání pomocí zpráv bez fixně dané architektury - rekonfigurace není problém, on demand - SCA (service component architecture) - service je běžící component. - specifikace by IBM, Sun, ... - volná vazba mezi komponentem a jeho implementací - deklarativní popis infrastruktury v XML - Policies - specifikace pro formát předávaných dat Service Data Objects - hierarchická architektura (ne flat) == e. Softwarové služby == http://www.soapatterns.org/ SOA: - paradigma, sada principů pro vývoj a integraci systémů, systém - set služeb které mohou být využity různými systémy z různých business domén - standardy, principy, metodologie návrhu, technologická infrastruktura - standardized service contract: Co má služba dělat, (funkce, datový model, policy), bez vazby na implementaci (service abstraction) - composition: služby mohou sestávat z mnoha jiných služeb - jako api používá popis protokolů a funkcionality - služba může automatizovat business process - loose coupling - orchestration: skládání více služeb do jedné, centrální řízení - služby se mezi sebou nevolají, používají se protokoly - metadata (popis služeb) - XML, WSDL. SOAP - popis protokolu - nezávislost na programovacím jazyku principy - reuse, granularity, modularity, composability, componentization and interoperability. - standards-compliance (both common and industry-specific). - services identification and categorization, provisioning and delivery, and monitoring and tracking. podle jiného zdroje: - Standardizovaný service contract - Loose coupling - Abstraction - Reusability - Autonomy - Statelessness - Discoverability: metadata - Composability navíc: - Optimization - Relevance - Encapsulation - Location Transparency: nezávislost na skutečné poloze v síti Role - web service: - Service provider: do registru dá co dělá. brokers nabízejí služby - Service consumer - SOMF: notace na kreslení návrhu SOA systémů - dobře se to testuje (jsou nezávislé malé kusy - služby), ale nikdo to nedělá - security challenge - SOA manifesto Žemlička: - inspirace službami ve skutečném světě - radikální změna myšlení - použití stávajících systémů - deploy po menších kusech - strukturované systémy: data z jednoho systému vstupem druhého, uchovávání dočasných dat, vyměňují si soubory - proces: soubor aktivit, jejichž výsledkem je služba nebo produkt - byznys procesy standardizované a nestandardizované - agile bpm: změny v procesech dle aktuálních potřeb - standardizované procesy lze zadrátovat do aplikace - řídící systém: řídí procesy, musí být spolehlivý - druhy - dávkové systémy jsou prý taky SOA - Měkké řídící systémy: spolupráce HW a SW; ? - Aliance: dočasná spolupráce mezi jednotlivými částmi systému, vývojáři neví s čím vším to bude komunikovat. např. web services, silná standardizace - Konfederace: těsnější vazba, vývojáři jednotlivých systémů se domlouvají. - Enterprise Konfederace: silná centrální autorita, která může regulovat - Unie: integrace stávajících systémů bez velkých změn v nich, e-Government, pro SME (small and medium enterprises asi) - aplikační služby: vlastní výkonné složky, možno současné systémy s novým rozhraním: - primární brána, jako primární brána může být použit upravený klient - jemnozrnné na hrubozrnné rozhraní transformujeme předsazenou branou, možno xslt - portál: vstupní bod pro uživatele - datové úložiště: služba schraňující data - hlava složené služby: služba která je předsazená před složenými službami - služba - manažer procesů, spravuje vlastník procesu, mění dle potřeby. - návrhové vzory: - vybrat vhodný typ služby - rozhraní orientované na problém, inspirované komunikací reálných lidí - hrubozrnná rozhraní: nezabývat se drobnými detaily, ztratí se logika věci - (2): - předřazená brána: možno víc rozhraní k téže službě - datové úložiště: oddělení dat podle kvality a oprávnění - hlava kompozitní služby: složená služba se tváří jako jedna - proces manažeři: řízení procesu službou - antivzory: - nevhodný typ soa - jemnozrnná rozhraní - žádné staré systémy - stálé byznys procesy, vlastník by měl mít možnost měnit službu - výhradně interaktivní: nedají se zakomponovat dávkové systémy. řešit datovými úložišti - obecné antivzory - velký třesk: nahrazení starého komplet novým systémem - potížista: přiřadit na izolovaný úkol == f. Moderní konstrukce programovacích jazyků == (anotace, iterátory, generics, lambda výrazy, integrované dotazy, integrované XML) === Anotace === http://en.wikipedia.org/wiki/Annotation#Software_programming, http://publib.boulder.ibm.com/infocenter/iadthelp/v7r0/index.jsp?topic=/com.ibm.etools.wrd.annotation.doc/topics/coverview.html poznámky v kódu, které obvykle neovlivňují přímo běh programu, ale slouží k dokumentaci apod. Narozdíl od komentářů přežijí kompilaci ve frameworcích se používají anotace místo toho aby se to muselo dávat do externího xml filu. např mapování datových objektů na tabulky v databázi v ejb redukce počtu konfiguráků a jiných artefaktů Java annotations: - metadata, zpracována kompilátorem, mohou být použita při runtimu, při překladu. Např. deprecated, override, supress warnings - umožňuje anotovat anotace - java kompilátor má annotation processors - může házet hlášky, vyřadit, ... v C#: např. sdělit, že metoda má být thread-safe, dá se serializovat. - uživatelsky definované anotace (atributy): může se něco nadeklarovat a pak to vytáhnout z objektu. - anotace pro assembly - používáno asp, linq, web services Python - docstrings, přístupné potom v __doc__ jako nápověda k objektu, fajn v konzoli === Iterátory === http://en.wikipedia.org/wiki/Iterator btw. design pattern objekt který umožňuje procházet kontejner dvě metody: získat prvek pod, posunout se na další. Vytvořit iterátor na první prvek, zjistit jestli už je konec udělat něco s každým prvkem kontejneru, aniž bych věděl o interní struktuře kontejneru generátor: iterátor bez kontejneru, pro komplikované výpočty, nemusím držet celé pole v paměti. implicitní iterátory - foreach srovnání s indexováním: - někde rychlejší (listy, stromy) - možnost vyměnit kontejner pod tím - iterátor zvládá, když přidám prvek před aktuální v C++ musíš dát foreachi funkci co má udělat na každém prvku === Generics === http://en.wikipedia.org/wiki/Generic_programming, Program se píše s tím, že typy budou specifikovány později. Ve staticky typovaných jazycích Možno templatovat: třídy, funkce. constrainty: co musí daný typ splňovat aby se dal použít - generics C#, .NET: generický typ jako first-class objekt. reification, udělá se z něj proxy. Nesmaže se informace o typu jako v Javě, rychlejší - nemusí se castovat. - Java: ve skutečnosti tam jsou všude objecty, compilator přidává casty - templates v C++: při kompilaci se vytvoří typy s daným parametrovým typem, zvlášť pro každé použití šablony. - specializace templatu: udělám special verzi pro nějaký typ, můžu i částečně, narozdíl od generic Duck typing: metody přímo na aktuálním objektu určují co se s daným objektem dá dělat, ne jeho příslušnost k třídě, inheritance. V dynamických jazycích automaticky, v C# v 4 možno checkovat jestli je metoda přístupná až za runtimu === lambda výrazy === - pocházejí z lambda kalkulu. zápis anonymních funkcí, zkrácená syntaxe. v jazycích, kde jsou funkce first class objects, se takhle dají rovnou tvořit lambda x: x + 1 má je tak i C#, dají se tak tvořit delegáty (pointery na funkce) === integrované dotazy === Object-relational mapping: technika konverze mezi nekompatibilními typovými systémy, virtuální objektová databáze redukuje množství kódu, který se musí napsat pro přístup do databáze Bývá pomalejší než když se přímo píše SQL - joiny, delete. navázání na tabulky přímo v jazyku (django), anotacemi (EJB), nebo mapovacími fily (hibernate) === integrované XML === xml je široce používané a proto bývá jeho zpracování přímo v jazyce knihovny na zpracování xml: python, .NET parsování, udělá to nějakou fajnou strukturu, tam pak lze něco měnit, pak to zas někam zapsat. dotazy nad xml fily: linq to XML, dom serializace do xml, např. pro použití ve webových službách, python pickling == g. Middleware architektury pro komunikaci: RPC, proxies, messaging, DSM == * Princip fungování RPC. * Rozhraní pro messaging. Middleware: software in the middle. mezi distribuovanou aplikaci a platformou pod ní middleware is a distributed software layer, or platform, which abstracts over the complexity and heterogeneity of the underlying distributed environment with its multitude of network technologies, machine architectures, operating systems and programming languages. Tiered architectures: - client tiers: presentation logic, application logic (thick client - míň komunikace) - server tiers: application logic (thin client), data 3-tiers navíc - middleware: application logic vstev může být plno - authentication, resources, ... Service oriented: - independent services - independent integration Unreliable unicasting: od odesílatele k příjemci, best effort, bez záruky Routing: buď k příjemci rovnou nebo routeru Exactly one delivery. Packet se může zničit, ztratit, nebo zduplikovat Detekce - duplication, checksum, parity, cross parity (matice - řádky, sloupce), hamming code, cyclic redundancy check (polynomy mod 2) potvrzení příjmu paketu, adaptivní timeout, ACK - correct, NAK damaged, missing, timeout před unikátní číslo packetu - duplikace Dlouhá zpráva - rozdělit na packety, potvrzovat po burstech. pevná nebo dynamická velikost Idempotentní služby - nevadí vícenásobné provedení operace, exactly once, at least once, at most once Když zhyne klient : - extermizace: klient po restartu zruší službu - nová epocha, stará se zahodí - expirace: časové kvantum, po vypršení si server řekne o nové (když je komu) TCP: spolehlivý, příjemce posílá kolikátý packet dostal. flow control: posílat tak rychle aby to příjemce stíhal, congestion: aby to síť stíhala. domluva přes window soft a hard real time: jitter: fluktuace v přenosové rychlosti multicast: danému subsetu příjemců, broadcast: všem. Ve společných částech sítě to může jet jen jednou spolehlivost - moc ACKů, radši posílat NAKy, multicastovat topologie: - strom: rozesílá všem pod sebou - kruh: a token řazení: podle odesílatele, kauzální, totální http://en.wikipedia.org/wiki/Distributed_shared_memory RMI: remote method invocation - jako RPC ale na objektech - jenom mezi instancemi JVM, mimo javu corba javaspaces: - implementace sekvenčního konzistenčního modelu v Javě. (asi) - tuplespace: repository tuplů jako asociativní sdílená paměť. Někdo tam zapisuje, někdo jiný si říká podmínky co chce a ono mu to vrací tuply - object exchange - komunikace sdílením stavu - vysoký výkon, nízká latence, nepříliš spolehlivé - Master-Worker pattern: jeden říká co se bude dělat, zapíše, ostatní si to přečtou, zapíšou výsledky - hype, ale nikdo to moc nepoužívá - objekt v repository: entry === Rozhraní pro messaging. === typicky: - send(message, address - proces, nebo fronta) - receive(buffer) druhy (ve funkcích programovacího jazyka) - blokující: čeká se, nemusíme se dočkat konce, záleží na ostatních. Když je plno/prázdno, zablokuje se. Jednodušší - neblokující: místo čekání skončí, callback nebo polling druhy 2: (komunikace, která používá víc funkcí) - synchronní: skončený send == přijal to - asynchronní: naopak může být klidně neblokující synchronní, pro oznámení se použije polling (aktivně sleduju, jestli už to přišlo) nebo callback (zavolá mě, až) strukturované (mpi) nebo nestruktorované (unix ipc)zprávy === RPC === server vykonává funkce jak mu řekne klient - zabalí funkci do zprávy, server jí rozbalí, vykoná, zabalí návratovou hodnotu, pošle, klient rozbalí. Balení a rozbalování zpráv dělá middleware. V interfacu middlewaru je method stub, ten dělá marshalling (balení do zprávy) a unmarshalling. Stub se dělá v runtimu nebo compile timu. Předávání parametrů - reference, aliasing (víc pointerů na jedna data) Paralelní zpracování: thread per connection, thread per request, thread pool Lifecycle - kompilace - vytvoření stubu (klient) a skeletonu (server), rpc generátor - spojení: server se exportuje registruje, klient se binduje se serverem - vyvolání: marshalling, exception handling SOAP, WSDL problémy RPC: - reprezentace dat: endiany, kódování - globální proměnné (možno přes DSM) - ukazatele, dynamické struktury - pole - kopírování, restore - variabilní parametry - skupinová komunikace, problém s pořadím zpráv, synchronizace hodin - Cristianův algo (pasivní timeserver, synchronizace), Berkeley (aktivní time server - ptá se ostatních na čas, vrací rozdíl od průměru), distribuovaný (broadcastem). Jde o pořadí (kauzální závislosti) Lamport - hodiny se posílají zprávami, proces zvedne čítač před každou událostí, před přijetím se kouknout jestli je větší než poslední, nastavit si čítač. - bezpečnost Vzájemné vyloučení - semaforem to nejde - není společná paměť - centralizovaný algoritmus: centrální sekvencér, ostatní se ho ptají. ideově nevhodné - Lamportův algoritmus: každý proces si drží frontu požadavků, když chce vstoupit do chráněné sekce, dá si požadavek do vlastní fronty, řekne si o fronty všem ostatním, když je první, vleze tam. Když vyleze, pošle všem zprávu, aby si ho vyhodily z front. - Ricart-Agrawala: netřeba posílat release. odpovídám jen když nejsem v krické sekci a nechystám se do ní vstoupit - volby, s volebním okrskem všem vadí výpadek jednoho uzlu. Moudro: Obvykle nemá smysl řešit centralizovaný problém distribuovaným algoritmem - volba koordinátora Vektorové hodiny - čítač pro každý proces. Některé vektory neporovnatelné. každý má svůj lokální vektor, vektory se posílají zprávami. když přijde zpráva s vektorem, beru max pro každý čítač Algoritmů pro synchronizaci je ještě hafo, viz slajdy distribuované systémy. === DSM === koncept: množina uzlů sdílející adresový prostor, hafo různých implementací - v osu - Extenze virtuální paměti, pro programátora transparentní. nebo v knihovně, pak s tím musí pracovat. - možno hw cache coherent circuits organizace: - stránky stejné velikosti - nebo po objektech, jak to vyjde Výhody sdílené paměti: škálovatelné, messages netřeba, nebo schované, nemusí se replikovat data a posílat každému, extenze sekvenčního programování Nevýhody: může být pomalejší, musí chránit proti dvoum přístupům v jeden čas, programátor nemůže ovlivnit co se posílá za zprávy viz consistency Distribuované stránkování - jako virtuální paměť: když přistoupim k nenamapované, přerušení - konzistence: mapované jsou jakoby read only, při zápisu buď invalidovat ostatní nebo aktualizovat - nalezení stránky: broadcast, centralizovaný manager, distribuovaně, spodních n bitů - správa kopií: broadcast, nebo stránka má vlastníka, ten udržuje informace kdo kde to má - uvolňování: read only, vlastnictví stránky a přenos vlastnictví, lokální heuristika třeba LRU problémy: - falešné sdílení: nezávislá data na stejné stránce - kauzálně konzistentní stránkování: graf závislostí stránek - kauzálních, vektorové hodiny, při výpadku přenášim, při zápisu zneplatnim. Velká prostorová režie, problém s konkurentními zápisy Sdílené proměnné na úrovni jazyka - typicky konzistenční model se synchronizačními proměnnými - výkonné, eliminace falešného sdílení, ale podpora jen v jazyce, rekompilace Distribuované objekty: - corba, java. předek pro sdílené třídy, řeší se to samo === Proxy === btw design pattern server/aplikace/objekt, který zpracovává požadavky klientů pomocí komunikace s jinými servery. Klient se připojí k proxy, proxy to zařídí. Proxy může mít filtry. Použití: - vše za tím je anonymní - cacheování - blokování nedovoleného příchozího i odchozího - logování gateway: proxy bez filtru reverse proxy: okolnímu světu dává služby z privátní sítě. zabezpečení, load balancing, caching open proxy: použití její ip adresy uživateli odjinud === Data Distribution Service === specifikace protokolu publish subscribe pattern zápis do published témat přes write queue - DataWriter == h. Čitelnost kódu, metriky čitelnosti, refaktorizace, dokumentace == === citelnost, metriky === http://d3s.mff.cuni.cz/teaching/programming_practices/lecture02.html http://d3s.mff.cuni.cz/teaching/programming_practices/lecture03.html princip lokality - věci, které souvisí mají být u sebe inicializovat proměnné při deklaraci deklarovat a inicializovat blízko prvnímu použití oblast platnosti proměnné souvisí s jejím významem - platná jen tam kde ji potřebuju metriky (minimalizovat): - lokalita přístupu (variable span): průměrný počet řádků mezi přístupy k proměnné - doba života (variable live time): počet řádků mezi prvním a posledním přístupem - cyklomatická složitost seskupovat příkazy, které spolu souvisí Čím menší je stavový prostor programu menší, tím lépe. Používat proměnné jen k jednomu účelu. Používat konstanty - DRY, výjimky: 0 pro součty, 1 posuny o 1, 2 půlení, ... Správně pojmenovávat proměnné Název proměnné by měl přesně a úplně popisovat, co proměnná reprezentuje.- kontext nejdůležitější na začátek pozitivní název pro bool názvové konvence - podle jazyka, říkat stejným věcem stejně Primitiva kódu: - sekvence (příkazů) - zjevné uspořádání - selekce (if then else) - if: kód nad rámec běžné činnosti - if else: dominantní na začátek (rovnou za if) - iterace - známý počet - for, neznámý - while - neměnit hodnotu řídící proměnné mimo - foreach opakující se věci do metod složité výrazy do funkcí logika do rozhodovacíh tabulek - data driven funkce - čitelnost, skrývání detailů - koheze, coupling - 100-200 řádků - parametry vstupní, výstupní, dobré dávat abstraktní typy - nedávat do výrazu procedury switch nahrazovat polymorfismem používat immutable třídy === Formátování kódu === - zdůrazňovat logickou strukturu - konzistence - čitelnost - robustnost vůči modifikaci vizuální oddělovače závorkovat === refaktoring === http://d3s.mff.cuni.cz/teaching/programming_practices/lecture12.html změna v interní struktuře programu s cílem ji zesrozumitelnit a učinit lépe modifikovatelnou, aniž by se změnilo vnější chování zajistit separation of concerns: zajistit, aby se fíčury, chování nepřekrývalo musíme získat víc než vynaložíme. Je fajn mít testy, pro: bude se často měnit když kód smrdí, je dobré ho refaktorizovat. - refaktorizace dat - refaktorizace příkazů - refaktorizace funkcí - refaktorizace implementace tříd - refaktorizace rozhraní tříd - globální refaktorizace === dokumentace === http://d3s.mff.cuni.cz/teaching/programming_practices/lecture11.html - vnější: mimo kód - požadavky, architektura, popis problému, tutoriál, rozhodnutí, konvence - vnitřní - komentáře k souborům, třídám, rozhraní, metodám - v kódu: proč to dělám - při/před psaním kódu - nezakomentovávat - version system == i. Testování a ladění kódu (technické principy nástrojů), preconditions, postconditions, invariants == osnova v http://d3s.mff.cuni.cz/~kalibera/teaching/sdmt Defenzivní programování: předpokládám, že svět je zlý, minimalizuju škody. Kontrolovat data z externích zdrojů, co nejdříve převést na vlastní reprezentaci řetězcové parametry, sql injection kontrakt metody: - formální, precizní ověřitelný popis rozhraní - datové typy - preconditions: co musí být splněno před - postconditions: co musí být splněno po - invariants: co musí platit pořád vztahuje se na: - hodnoty vstupních proměnných - výstup: hodnota, význam - výjimky, za jakých podmínek - side effecty - případně, jak dlouho to bude trvat Design by contract: psát nejdřív kontrakty vynucovat dodržování, ověřovat preconditions podporuje to eiffel, C# 4.0 v jazyce Unit testing testuje modul jestli dodržuje kontrakty, integrační testování jestli to funguje pohromadě bariéry: - k vnějšku - k vnitřnímu starému a neudržovanému uvnitř důvěryhodného asserty - jen v debugu === Testování === Cíle: - odhalit chyby - dokumentace chování - zlepšení kvality kódu - změny v budoucnosti Automaticky, spustitelné jedním příkazem, jednoznačný výsledek - Unit testy: třídy, metody - Testy komponent - Integrační - systémové: celý produkt ve finálním prostředí - regresní testy - výkonnostní - zátěžové - testy použitelnosti - black box: možno před napsáním kódu - white box: pokrytí kódu testovat kontrakty, speciální případy. verifikace chyb, opravy. ladící výpisy, převést na test. mock objekty === Test driven development === - napsat testy - spustit testy - fail - napsat minimální kód - spustit testy - refaktorovat kód nutí přemýšlet nad návrhem, lepší rozhraní, ryhlá zpětná vazba X omezuje experimenty (zkusím víc variant) === Ladění === - odstranit příčinu chyby - ideální se vyhnout - snaha pochopit příčinu, odstranit Postup: - reprodukce chyby - vytvoření testu, který padá na chybě - nalezení příčiny - sběr dat, hypotéza o příčině, ověření hypotézy - oprava chyby - spuštění testu - kontrola chyb podobného druhu izolovat podezřelou část === Technická realizace krokování a breakpointů. === Debugger: na windows syscall DebugActiveProcess. nebo je na to api na virtuálním stroji event loop, eventy dělá proces debugger může číst a zapisovat do paměti procesu api nad symbol files (ne součástí os), které dokáže přeložit adresu v paměti na jméno proměnné a její pozice ve zdrojácích grafický front-end http://www.alexonlinux.com/how-debugger-works podpora v jádru os ptrace syscall - request na debuggování target proces může být potomkem debuggeru, a nebo ptrace_attach - attachnu se na target proces os říká debuggeru o všech eventech v targetu, dělá se to přes signály debugovaný musí zavolat ptrace trace me, pak dostane signal trap a debugger signal hold breakpointy - fungují na úrovni assembleru - instrukce INT3 - speciální interrupt handler, v handleru os pošle signál - debugger vkládá instrukci INT3 do instrukcí targetu (je malá), přepíše nějakou instrukci, pamatuje si co přepsal. po tom co narazí na breakpoint, to zase přepíše zpátky a nastaví RIP registr procesoru, aby nepřeskočil tu zpátky zapsanou instrukci - když dám breakpoint na řádek, logika ze symbol files zjistí kam má debugger dát INT3 krokování: - nastavení instrukce INT3 na další řádek kódu GDB je source level debugger === Vazba mezi zdrojovým kódem a binárním obrazem === na windows je pdb file, kerý mapuje zdrojáky na binár symbol file, dá se předhodit gdb na vstupu debug symbol - informace jaké jazykové konstrukce se jak přeložily, včetně názvu souboru a čísla řádku - vytváří kompilátor, linker - můžou být přímo v bináru - microsoft má server, pomocí kterého můžeš symboly rozluštit. Microsoft symbol server - formáty: - STABS: starší, původně pro pascal - DWARF: speciální struktura pro každý symbol (název proměnné, typu, ...), vazba na to kde je to definované. Line number table. designován původně s ELFem, umí ho produkovat gcc