• Tłumaczenie: Robert Górczyński
• ISBN Książki drukowanej: 978-83-[zasłonięte]-9157-9, 978[zasłonięte][zasłonięte]46915
• Data wydania książki drukowanej: 2[zasłonięte]014-08
• Format: 168x237
• Numer z katalogu: 23127

Kompendium wiedzy o wydajności systemów!

Wszędzie tam, gdzie przetwarzane są gigantyczne ilości danych, wydajność systemu komputerowego ma fundamentalne znaczenie. W takim środowisku nawet minimalne opóźnienie pomnożone przez liczbę operacji może skutkować ogromnym wzrostem kosztów działania. Zastanawiasz się, jak zapewnić najwyższą wydajność systemów posiadanych fizycznie lub tych uruchomionych w chmurze? Jesteś inżynierem odpowiedzialnym za wydajność systemu komputerowego? A może pasjonujesz się systemami operacyjnymi i ich wydajnością? Jeżeli odpowiedziałeś twierdząco na którekolwiek z tych pytań, trafiłeś na idealny podręcznik!

W trakcie lektury przekonasz się, jak kontrolować oraz poprawiać wydajność Twoich systemów komputerowych. Poznasz popularne metodologie badań wydajności, ich zalety oraz wady. Ponadto nauczysz się planować pojemność systemu oraz go monitorować. Po tym wstępie przyjdzie czas na system Linux w detalach. Odkryjesz specyfikę jądra systemu Linux, sposób zarządzania procesami oraz pamięcią. Z kolejnych rozdziałów wyciągniesz szczegółową wiedzę na temat procesorów, systemów plików, dysków oraz sieci. Każdy z tych elementów ma kluczowe znaczenie dla wydajności konfigurowanego systemu. Książka ta jest wyjątkowym, kompletnym kompendium wiedzy na temat wydajności systemów — zajrzyj koniecznie!

Dzięki tej książce:

• zdobędziesz szczegółową wiedzę na temat systemu Linux
• nauczysz się korzystać z narzędzi do badania wydajności systemu
• przeprowadzisz wiarygodne testy wydajności
• wybierzesz odpowiedni sprzęt dla Twojego systemu komputerowego
• porównasz możliwości systemów działających w chmurze z tymi lokalnymi
• zrozumiesz wpływ poszczególnych elementów systemu na wydajność

Zbuduj wydajny system komputerowy na miarę Twoich potrzeb!

Wstęp (19)

• 1.1. Wydajność systemów (33)
• 1.2. Role (34)
• 1.3. Działania (35)
• 1.4. Perspektywy (36)
• 1.5. Zapewnienie wydajności to wyzwanie (37)
  • 1.5.1. Wydajność jest subiektywna (37)
  • 1.5.2. Systemy są skomplikowane (37)
  • 1.5.3. Może istnieć wiele problemów związanych z wydajnością (38)
• 1.6. Opóźnienie (39)
• 1.7. Monitorowanie dynamiczne (40)
• 1.8. Przetwarzanie w chmurze (41)
• 1.9. Studium przypadku (42)
  • 1.9.1. Wolno działające dyski (42)
  • 1.9.2. Zmiana oprogramowania (44)
  • 1.9.3. Co dalej? (46)

• 2.1. Terminologia (48)
• 2.2. Modele (49)
  • 2.2.1. Wydajność systemu podczas testu (49)
  • 2.2.2. Systemy kolejkowe (50)
• 2.3. Koncepcje (50)
  • 2.3.1. Opóźnienie (50)
  • 2.3.2. Skala czasu (52)
  • 2.3.3. Kompromisy (52)
  • 2.3.4. Dostrajanie wydajności (54)
  • 2.3.5. Poziomy trafności (55)
  • 2.3.6. Rekomendacje w danym momencie (56)
  • 2.3.7. Obciążenie kontra architektura (56)
  • 2.3.8. Skalowalność (57)
  • 2.3.9. Znane niewiadome (59)
  • 2.3.10. Metryki (59)
  • 2.3.11. Poziom wykorzystania (60)
  • 2.3.12. Nasycenie (62)
  • 2.3.13. Profilowanie (63)
  • 2.3.14. Buforowanie (63)
• 2.4. Perspektywy (66)
  • 2.4.1. Analiza zasobów (66)
  • 2.4.2. Analiza obciążenia (67)
• 2.5. Metodologia (68)
  • 2.5.1. Jawna antymetoda (70)
  • 2.5.2. Antymetoda losowej zmiany (70)
  • 2.5.3. Antymetoda obwiniania kogoś innego (71)
  • 2.5.4. Metoda przygotowanej ad hoc listy rzeczy do sprawdzenia (71)
  • 2.5.5. Opis problemu (72)
  • 2.5.6. Metoda naukowa (73)
  • 2.5.7. Cykl diagnostyczny (74)
  • 2.5.8. Metoda narzędzi (75)
  • 2.5.9. Metoda USE (76)
  • 2.5.10. Charakterystyka obciążenia (83)
  • 2.5.11. Analiza drążąca (84)
  • 2.5.12. Analiza opóźnienia (85)
  • 2.5.13. Metoda R (87)
  • 2.5.14. Monitorowanie zdarzeń (87)
  • 2.5.15. Dane statystyczne będące punktem odniesienia (89)
  • 2.5.16. Statyczne dostosowanie wydajności (89)
  • 2.5.17. Dostosowanie bufora (90)
  • 2.5.18. Mikrotesty wydajności (91)
• 2.6. Modelowanie (91)
  • 2.6.1. Biznes kontra chmura (92)
  • 2.6.2. Identyfikacja wizualna (92)
  • 2.6.3. Prawo skalowalności Amdahla (94)
  • 2.6.4. Prawo skalowalności uniwersalnej (95)
  • 2.6.5. Teoria kolejek (96)
• 2.7. Planowanie pojemności (100)
  • 2.7.1. Ograniczenia zasobu (100)
  • 2.7.2. Analiza współczynnika (102)
  • 2.7.3. Skalowanie rozwiązań (103)
• 2.8. Statystyka (103)
  • 2.8.1. Ocena wydajności (104)
  • 2.8.2. Wartość średnia (105)
  • 2.8.3. Odchylenie standardowe, percentyle i mediana (106)
  • 2.8.4. Współczynnik zmienności (107)
  • 2.8.5. Rozkład wielomodalny (107)
  • 2.8.6. Elementy odstające (108)
• 2.9. Monitorowanie (108)
  • 2.9.1. Wzorce na podstawie czasu (109)
  • 2.9.2. Produkty służące do monitorowania (110)
  • 2.9.3. Podsumowanie od chwili uruchomienia systemu (110)
• 2.10. Wizualizacja (111)
  • 2.10.1. Wykres liniowy (111)
  • 2.10.2. Wykres punktowy (112)
  • 2.10.3. Mapy cieplne (113)
  • 2.10.4. Wykres warstwowy (114)
  • 2.10.5. Narzędzia wizualizacji (115)
• 2.11. Ćwiczenia (115)
• 2.12. Odwołania (116)

• 3.1. Terminologia (118)
• 3.2. Środowisko (119)
  • 3.2.1. Jądro (119)
  • 3.2.2. Stosy (122)
  • 3.2.3. Przerwania i wątki przerwań (123)
  • 3.2.4. Poziom priorytetu przerwania (124)
  • 3.2.5. Procesy (125)
  • 3.2.6. Wywołania systemowe (127)
  • 3.2.7. Pamięć wirtualna (129)
  • 3.2.8. Zarządzanie pamięcią (130)
  • 3.2.9. Algorytm szeregowania (130)
  • 3.2.10. Systemy plików (132)
  • 3.2.11. Buforowanie (134)
  • 3.2.12. Sieci (134)
  • 3.2.13. Sterowniki urządzeń (135)
  • 3.2.14. Wieloprocesorowość (136)
  • 3.2.15. Wywłaszczenie (136)
  • 3.2.16. Zarządzanie zasobami (137)
  • 3.2.17. Monitorowanie (137)
• 3.3. Jądra systemów (138)
  • 3.3.1. UNIX (139)
  • 3.3.2. Systemy Solaris (139)
  • 3.3.3. Systemy Linux (143)
  • 3.3.4. Różnice (146)
• 3.4. Ćwiczenia (147)
• 3.5. Odwołania (147)

• 4.1. Rodzaje narzędzi (150)
  • 4.1.1. Liczniki (150)
  • 4.1.2. Monitorowanie (152)
  • 4.1.3. Profilowanie (153)
  • 4.1.4. Monitorowanie (sar) (154)
• 4.2. Źródła danych statystycznych (155)
  • 4.2.1. Interfejs /proc (156)
  • 4.2.2. Interfejs /sys (161)
  • 4.2.3. Framework kstat (162)
  • 4.2.4. Zliczanie opóźnienia (165)
  • 4.2.5. Zliczanie mikrostanu (166)
  • 4.2.6. Inne narzędzia monitorowania (166)
• 4.3. DTrace (168)
  • 4.3.1. Monitorowanie statyczne i dynamiczne (170)
  • 4.3.2. Sondy (171)
  • 4.3.3. Dostawcy (172)
  • 4.3.4. Argumenty (172)
  • 4.3.5. Język D (173)
  • 4.3.6. Wbudowane zmienne (173)
  • 4.3.7. Akcje (173)
  • 4.3.8. Typy zmiennych (173)
  • 4.3.9. Jednowierszowe wywołania DTrace (177)
  • 4.3.10. Skrypty (177)
  • 4.3.11. Obciążenie (178)
  • 4.3.12. Dokumentacja i zasoby (179)
• 4.4. SystemTap (180)
  • 4.4.1. Sondy (181)
  • 4.4.2. Zestawy tapset (181)
  • 4.4.3. Akcje i wbudowane zmienne (182)
  • 4.4.4. Przykłady (182)
  • 4.4.5. Obciążenie (184)
  • 4.4.6. Dokumentacja i zasoby (185)
• 4.5. perf (185)
• 4.6. Obserwowanie monitorowania (186)
• 4.7. Ćwiczenia (187)
• 4.8. Odwołania (187)

• 5.1. Podstawy dotyczące aplikacji (190)
  • 5.1.1. Cele (191)
  • 5.1.2. Optymalizacja najczęstszego sposobu użycia aplikacji (192)
  • 5.1.3. Monitorowanie (193)
  • 5.1.4. Notacja "duże O" (193)
• 5.2. Techniki sprawdzania wydajności aplikacji (194)
  • 5.2.1. Ustalenie wielkości operacji wejścia-wyjścia (194)
  • 5.2.2. Pamięć podręczna (195)
  • 5.2.3. Buforowanie (195)
  • 5.2.4. Technika odpytywania (196)
  • 5.2.5. Współbieżność i równoległość (196)
  • 5.2.6. Nieblokujące operacje wejścia-wyjścia (199)
  • 5.2.7. Powiązanie z procesorem (200)
• 5.3. Języki programowania (200)
  • 5.3.1. Języki kompilowane (201)
  • 5.3.2. Języki interpretowane (202)
  • 5.3.3. Maszyny wirtualne (203)
  • 5.3.4. Mechanizm usuwania nieużytków (203)
• 5.4. Metodologia i analiza (204)
  • 5.4.1. Analiza stanu wątku (205)
  • 5.4.2. Profilowanie procesora (208)
  • 5.4.3. Analiza wywołań systemowych (210)
  • 5.4.4. Profilowanie operacji wejścia-wyjścia (218)
  • 5.4.5. Charakterystyka obciążenia (219)
  • 5.4.6. Metoda USE (219)
  • 5.4.7. Analiza drążąca (220)
  • 5.4.8. Analiza blokad (221)
  • 5.4.9. Statyczne dostosowanie wydajności (223)
• 5.5. Ćwiczenia (224)
• 5.6. Odwołania (226)

• 6.1. Terminologia (228)
• 6.2. Modele (229)
  • 6.2.1. Architektura procesora (229)
  • 6.2.2. Pamięci podręczne w procesorze (230)
  • 6.2.3. Kolejki działania w procesorze (230)
• 6.3. Koncepcje (231)
  • 6.3.1. Częstotliwość taktowania zegara (231)
  • 6.3.2. Instrukcje (232)
  • 6.3.3. Potok instrukcji (232)
  • 6.3.4. Wielkość instrukcji (232)
  • 6.3.5. Wartości CPI, IPC (233)
  • 6.3.6. Poziom wykorzystania (233)
  • 6.3.7. Czasy użytkownika i jądra (234)
  • 6.3.8. Poziom nasycenia (234)
  • 6.3.9. Wywłaszczenie (235)
  • 6.3.10. Odwrócenie priorytetów (235)
  • 6.3.11. Wieloprocesowość, wielowątkowość (236)
  • 6.3.12. Długość słowa (237)
  • 6.3.13. Optymalizacja kodu wynikowego (238)
• 6.4. Architektura (238)
  • 6.4.1. Sprzęt (238)
  • 6.4.2. Oprogramowanie (246)
• 6.5. Metodologia (253)
  • 6.5.1. Metoda narzędzi (254)
  • 6.5.2. Metoda USE (255)
  • 6.5.3. Charakterystyka obciążenia (256)
  • 6.5.4. Profilowanie (257)
  • 6.5.5. Analiza cykli (259)
  • 6.5.6. Monitorowanie wydajności (260)
  • 6.5.7. Statyczne dostosowanie wydajności (260)
  • 6.5.8. Dostrojenie priorytetu (261)
  • 6.5.9. Kontrola zasobów (262)
  • 6.5.10. Powiązanie z procesorem (262)
  • 6.5.11. Mikrotesty wydajności (262)
  • 6.5.12. Skalowanie (263)
• 6.6. Analiza (264)
  • 6.6.1. uptime (265)
  • 6.6.2. vmstat (267)
  • 6.6.3. mpstat (268)
  • 6.6.4. sar (270)
  • 6.6.5. ps (271)
  • 6.6.6. top (272)
  • 6.6.7. prstat (273)
  • 6.6.8. pidstat (275)
  • 6.6.9. time, ptime (276)
  • 6.6.10. DTrace (277)
  • 6.6.11. SystemTap (284)
  • 6.6.12. perf (284)
  • 6.6.13. cpustat (292)
  • 6.6.14. Inne narzędzia (293)
  • 6.6.15. Wizualizacja (294)
• 6.7. Eksperymenty (297)
  • 6.7.1. Ad hoc (297)
  • 6.7.2. sysbench (298)
• 6.8. Dostrajanie (298)
  • 6.8.1. Opcje kompilatora (299)
  • 6.8.2. Klasy i priorytety szeregowania (299)
  • 6.8.3. Opcje algorytmu szeregowania (300)
  • 6.8.4. Dołączanie procesu (302)
  • 6.8.5. Grupa procesorów na wyłączność (302)
  • 6.8.6. Kontrola zasobów (303)
  • 6.8.7. Opcje procesora (dostrajanie BIOS-u) (303)
• 6.9. Ćwiczenia (303)
• 6.10. Odwołania (305)

• 7.1. Terminologia (308)
• 7.2. Koncepcje (309)
  • 7.2.1. Pamięć wirtualna (309)
  • 7.2.2. Stronicowanie (310)
  • 7.2.3. Żądanie stronicowania (311)
  • 7.2.4. Przepełnienie (313)
  • 7.2.5. Wymiana (313)
  • 7.2.6. Użycie bufora systemu plików (314)
  • 7.2.7. Poziom wykorzystania i nasycenie (314)
  • 7.2.8. Alokatory (315)
  • 7.2.9. Długość słowa (315)
• 7.3. Architektura (315)
  • 7.3.1. Architektura sprzętowa (315)
  • 7.3.2. Oprogramowanie (321)
  • 7.3.3. Przestrzeń adresowa procesu (328)
• 7.4. Metodologia (332)
  • 7.4.1. Metoda narzędzi (333)
  • 7.4.2. Metoda USE (334)
  • 7.4.3. Charakterystyka użycia pamięci (335)
  • 7.4.4. Analiza cykli (337)
  • 7.4.5. Monitorowanie wydajności (337)
  • 7.4.6. Wykrywanie wycieków pamięci (337)
  • 7.4.7. Statyczne dostrojenie wydajności (338)
  • 7.4.8. Kontrola zasobów (339)
  • 7.4.9. Mikrotesty wydajności (339)
• 7.5. Analiza (339)
  • 7.5.1. vmstat (340)
  • 7.5.2. sar (343)
  • 7.5.3. slabtop (345)
  • 7.5.4. ::kmastat (347)
  • 7.5.5. ps (348)
  • 7.5.6. top (350)
  • 7.5.7. prstat (350)
  • 7.5.8. pmap (351)
  • 7.5.9. DTrace (353)
  • 7.5.10. SystemTap (357)
  • 7.5.11. Inne narzędzia (358)
• 7.6. Dostrajanie (360)
  • 7.6.1. Parametry możliwe do dostrojenia (360)
  • 7.6.2. Różnej wielkości strony (363)
  • 7.6.3. Alokatory (364)
  • 7.6.4. Kontrola zasobów (364)
• 7.7. Ćwiczenia (365)
• 7.8. Odwołania (366)

• 8.1. Terminologia (370)
• 8.2. Modele (371)
  • 8.2.1. Interfejsy systemów plików (371)
  • 8.2.2. Bufor systemu plików (371)
  • 8.2.3. Bufory poziomu drugiego (372)
• 8.3. Koncepcje (372)
  • 8.3.1. Opóźnienie systemu plików (373)
  • 8.3.2. Buforowanie (373)
  • 8.3.3. Losowe kontra sekwencyjne operacje wejścia-wyjścia (374)
  • 8.3.4. Mechanizm prefetch (375)
  • 8.3.5. Odczyt z wyprzedzeniem (376)
  • 8.3.6. Buforowanie operacji zapisu (376)
  • 8.3.7. Synchroniczne operacje zapisu (377)
  • 8.3.8. Niezmodyfikowane i bezpośrednie operacje wejścia-wyjścia (378)
  • 8.3.9. Nieblokujące operacje wejścia-wyjścia (378)
  • 8.3.10. Mapowanie plików w pamięci (379)
  • 8.3.11. Metadane (379)
  • 8.3.12. Logiczne kontra fizyczne operacje wejścia-wyjścia (380)
  • 8.3.13. Operacje nie są jednakowe (383)
  • 8.3.14. Specjalne systemy plików (383)
  • 8.3.15. Znaczniki czasu dotyczące dostępu (383)
  • 8.3.16. Pojemność (384)
• 8.4. Architektura (384)
  • 8.4.1. Stos operacji wejścia-wyjścia systemu plików (384)
  • 8.4.2. VFS (384)
  • 8.4.3. Bufory systemu plików (386)
  • 8.4.4. Funkcje systemu plików (390)
  • 8.4.5. Rodzaje systemów plików (392)
  • 8.4.6. Woluminy i pule (399)
• 8.5. Metodologia (401)
  • 8.5.1. Analiza dysku (401)
  • 8.5.2. Analiza opóźnienia (402)
  • 8.5.3. Charakterystyka obciążenia (404)
  • 8.5.4. Monitorowanie wydajności (406)
  • 8.5.5. Monitorowanie zdarzeń (407)
  • 8.5.6. Statyczne dostosowanie wydajności (408)
  • 8.5.7. Dostrajanie bufora (408)
  • 8.5.8. Separacja obciążenia (409)
  • 8.5.9. Systemy plików w pamięci (409)
  • 8.5.10. Mikrotesty wydajności (409)
• 8.6. Analiza (411)
  • 8.6.1. vfsstat (412)
  • 8.6.2. fsstat (413)
  • 8.6.3. strace, truss (413)
  • 8.6.4. DTrace (414)
  • 8.6.5. SystemTap (425)
  • 8.6.6. LatencyTOP (425)
  • 8.6.7. free (426)
  • 8.6.8. top (426)
  • 8.6.9. vmstat (426)
  • 8.6.10. sar (427)
  • 8.6.11. slabtop (428)
  • 8.6.12. mdb ::kmastat (429)
  • 8.6.13. fcachestat (429)
  • 8.6.14. /proc/meminfo (430)
  • 8.6.15. mdb ::memstat (430)
  • 8.6.16. kstat (431)
  • 8.6.17. Inne narzędzia (432)
  • 8.6.18. Wizualizacje (433)
• 8.7. Eksperymenty (434)
  • 8.7.1. Ad hoc (435)
  • 8.7.2. Narzędzia mikrotestów wydajności (435)
  • 8.7.3. Opróżnienie bufora systemu plików (437)
• 8.8. Dostrajanie (438)
  • 8.8.1. Wywołania aplikacji (438)
  • 8.8.2. ext3 (439)
  • 8.8.3. ZFS (440)
• 8.9. Ćwiczenia (442)
• 8.10. Odwołania (443)

• 9.1. Terminologia (446)
• 9.2. Modele (447)
  • 9.2.1. Prosty dysk (447)
  • 9.2.2. Pamięć podręczna dysku (447)
  • 9.2.3. Kontroler (448)
• 9.3. Koncepcje (449)
  • 9.3.1. Pomiar czasu (449)
  • 9.3.2. Skale czasu (450)
  • 9.3.3. Buforowanie (452)
  • 9.3.4. Losowe kontra sekwencyjne operacje wejścia-wyjścia (452)
  • 9.3.5. Współczynnik odczyt/zapis (453)
  • 9.3.6. Wielkość operacji wejścia-wyjścia (454)
  • 9.3.7. Wartości IOPS nie są równe (454)
  • 9.3.8. Polecenie dyskowe niedotyczące transferu danych (454)
  • 9.3.9. Poziom wykorzystania (455)
  • 9.3.10. Nasycenie (456)
  • 9.3.11. Oczekiwanie na zakończenie operacji wejścia-wyjścia (456)
  • 9.3.12. Operacje synchroniczne kontra asynchroniczne (457)
  • 9.3.13. Dyskowe kontra aplikacji operacje wejścia-wyjścia (458)
• 9.4. Architektura (458)
  • 9.4.1. Rodzaje dysków (458)
  • 9.4.2. Interfejsy (465)
  • 9.4.3. Rodzaje pamięci masowej (466)
  • 9.4.4. Stos dyskowych operacji wejścia-wyjścia w systemie operacyjnym (469)
• 9.5. Metodologia (473)
  • 9.5.1. Metoda narzędzi (473)
  • 9.5.2. Metoda USE (474)
  • 9.5.3. Monitorowanie wydajności (475)
  • 9.5.4. Charakterystyka obciążenia (476)
  • 9.5.5. Analiza opóźnienia (478)
  • 9.5.6. Monitorowanie zdarzeń (479)
  • 9.5.7. Statyczne dopasowanie wydajności (480)
  • 9.5.8. Dostrojenie bufora (481)
  • 9.5.9. Kontrola zasobów (481)
  • 9.5.10. Mikrotesty wydajności (481)
  • 9.5.11. Skalowanie (483)
• 9.6. Analiza (484)
  • 9.6.1. iostat (484)
  • 9.6.2. sar (493)
  • 9.6.3. pidstat (495)
  • 9.6.4. DTrace (495)
  • 9.6.5. SystemTap (505)
  • 9.6.6. perf (505)
  • 9.6.7. iotop (506)
  • 9.6.8. iosnoop (509)
  • 9.6.9. blktrace (512)
  • 9.6.10. MegaCli (514)
  • 9.6.11. smartctl (515)
  • 9.6.12. Wizualizacje (516)
• 9.7. Eksperymenty (520)
  • 9.7.1. Ad hoc (520)
  • 9.7.2. Własne generatory obciążenia (520)
  • 9.7.3. Narzędzia mikrotestów wydajności (521)
  • 9.7.4. Przykład losowego odczytu (521)
• 9.8. Dostrajanie (522)
  • 9.8.1. Modyfikowalne parametry systemu operacyjnego (523)
  • 9.8.2. Modyfikowalne parametry urządzenia dyskowego (525)
  • 9.8.3. Modyfikowalne parametry kontrolera dysku (525)
• 9.9. Ćwiczenia (525)
• 9.10. Odwołania (527)

• 10.1. Terminologia (530)
• 10.2. Modele (530)
  • 10.2.1. Interfejs sieciowy (531)
  • 10.2.2. Kontroler (531)
  • 10.2.3. Stos protokołów (532)
• 10.3. Koncepcje (532)
  • 10.3.1. Sieci i routing (532)
  • 10.3.2. Protokoły (533)
  • 10.3.3. Hermetyzacja (534)
  • 10.3.4. Wielkość pakietu (534)
  • 10.3.5. Opóźnienie (535)
  • 10.3.6. Buforowanie (537)
  • 10.3.7. Dziennik połączeń (537)
  • 10.3.8. Negocjacja interfejsu (538)
  • 10.3.9. Poziom wykorzystania (538)
  • 10.3.10. Połączenia lokalne (539)
• 10.4. Architektura (539)
  • 10.4.1. Protokoły (539)
  • 10.4.2. Sprzęt (543)
  • 10.4.3. Oprogramowanie (545)
• 10.5. Metodologia (550)
  • 10.5.1. Metoda narzędzi (550)
  • 10.5.2. Metoda USE (551)
  • 10.5.3. Charakterystyka obciążenia (552)
  • 10.5.4. Analiza opóźnienia (553)
  • 10.5.5. Monitorowanie wydajności (554)
  • 10.5.6. Podsłuchiwanie pakietów (555)
  • 10.5.7. Analiza TCP (556)
  • 10.5.8. Analiza drążąca (557)
  • 10.5.9. Statyczne dostosowanie wydajności (557)
  • 10.5.10. Kontrola zasobów (558)
  • 10.5.11. Mikrotesty wydajności (559)
• 10.6. Analiza (559)
  • 10.6.1. netstat (560)
  • 10.6.2. sar (566)
  • 10.6.3. ifconfig (568)
  • 10.6.4. ip (569)
  • 10.6.5. nicstat (569)
  • 10.6.6. dladm (570)
  • 10.6.7. ping (571)
  • 10.6.8. traceroute (572)
  • 10.6.9. pathchar (573)
  • 10.6.10. tcpdump (573)
  • 10.6.11. snoop (575)
  • 10.6.12. Wireshark (578)
  • 10.6.13. Dtrace (578)
  • 10.6.14. SystemTap (592)
  • 10.6.15. perf (592)
  • 10.6.16. Inne narzędzia (593)
• 10.7. Eksperymenty (594)
  • 10.7.1. iperf (594)
• 10.8. Dostrajanie (595)
  • 10.8.1. Linux (595)
  • 10.8.2. Solaris (598)
  • 10.8.3. Konfiguracja (601)
• 10.9. Ćwiczenia (602)
• 10.10. Odwołania (603)

• 11.1. Wprowadzenie (606)
  • 11.1.1. Współczynnik cena/wydajność (606)
  • 11.1.2. Skalowalna architektura (607)
  • 11.1.3. Planowanie pojemności (608)
  • 11.1.4. Pamięć masowa (610)
  • 11.1.5. Multitenancy (610)
• 11.2. Wirtualizacja systemu operacyjnego (611)
  • 11.2.1. Obciążenie (613)
  • 11.2.2. Kontrola zasobów (615)
  • 11.2.3. Monitorowanie (619)
• 11.3. Wirtualizacja sprzętowa (625)
  • 11.3.1. Obciążenie (627)
  • 11.3.2. Kontrola zasobów (634)
  • 11.3.3. Monitorowanie (637)
• 11.4. Porównania (644)
• 11.5. Ćwiczenia (646)
• 11.6. Odwołania (647)

• 12.1. Wprowadzenie (650)
  • 12.1.1. Działania (650)
  • 12.1.2. Efektywne testy wydajności (651)
  • 12.1.3. Grzechy testów wydajności (653)
• 12.2. Rodzaje testów wydajności (660)
  • 12.2.1. Mikrotesty wydajności (660)
  • 12.2.2. Symulacja (662)
  • 12.2.3. Powtarzalność (663)
  • 12.2.4. Standardy biznesowe (663)
• 12.3. Metodologia (665)
  • 12.3.1. Pasywne testy wydajności (665)
  • 12.3.2. Aktywne testy wydajności (667)
  • 12.3.3. Profilowanie procesora (669)
  • 12.3.4. Metoda USE (671)
  • 12.3.5. Charakterystyka obciążenia (671)
  • 12.3.6. Własne testy wydajności (671)
  • 12.3.7. Stopniowa zmiana obciążenia (672)
  • 12.3.8. Sprawdzenie poprawności (674)
  • 12.3.9. Analiza statystyczna (674)
• 12.4. Pytania dotyczące testu wydajności (676)
• 12.5. Ćwiczenia (678)
• 12.6. Odwołania (678)

• 13.1. Studium przykładu: czerwony wieloryb (681)
  • 13.1.1. Zdefiniowanie problemu (682)
  • 13.1.2. Pomoc techniczna (683)
  • 13.1.3. Rozpoczęcie pracy (684)
  • 13.1.4. Wybierz własną drogę (686)
  • 13.1.5. Metoda USE (688)
  • 13.1.6. Czy to już koniec? (691)
  • 13.1.7. Podejście drugie (691)
  • 13.1.8. Podstawy (693)
  • 13.1.9. Zignorowanie czerwonego wieloryba (694)
  • 13.1.10. Sprawdzenie jądra (694)
  • 13.1.11. Dlaczego? (696)
  • 13.1.12. Epilog (698)
• 13.2. Komentarze (699)
• 13.3. Informacje dodatkowe (700)
• 13.4. Odwołania (700)

• Zasoby fizyczne (702)
• Zasoby programowe (705)
• Odwołania (706)

• Zasoby fizyczne (707)
• Zasoby programowe (710)
• Odwołania (711)

• Linux (713)
• Solaris (714)

• Dostawca syscall (715)
• Dostawca proc (718)
• Dostawca profile (718)
• Dostawca sched (720)
• Dostawca fbt (720)
• Dostawca pid (721)
• Dostawca io (722)
• Dostawca sysinfo (722)
• Dostawca vminfo (723)
• Dostawca ip (723)
• Dostawca tcp (723)
• Dostawca UDP (724)

• Funkcjonalność (725)
• Terminologia (726)
• Sondy (726)
• Wbudowane zmienne (727)
• Funkcje (727)
• Przykład 1.: Wyświetlenie sond syscall:::entry (728)
• Przykład 2.: Podsumowanie wielkości zwrotnej wywołania read() (728)
• Przykład 3.: Zliczanie wywołań systemowych według nazwy procesu (730)
• Przykład 4.: Zliczanie wywołań systemowych według nazwy wywołania systemowego dla procesu o identyfikatorze 123 (731)
• Przykład 5.: Zliczanie wywołań systemowych według nazwy wywołania systemowego dla procesu o nazwie httpd (731)
• Przykład 6.: Monitorowanie wywołania open() wraz z nazwą procesu i ścieżki (732)
• Przykład 7.: Podsumowanie opóźnienia read() dla procesów mysqld (732)
• Przykład 8.: Monitorowanie nowych procesów wraz z nazwą procesu i argumentami (733)
• Przykład 9.: Monitorowanie stosów jądra z częstotliwością 100 Hz (733)
• Odwołania (733)

• Rozdział 2. "Metodologia" (735)
• Rozdział 3. "Systemy operacyjne" (735)
• Rozdział 6. "Procesory" (735)
• Rozdział 7. "Pamięć" (736)
• Rozdział 8. "Systemy plików" (736)
• Rozdział 9. "Dyski" (737)
• Rozdział 11. "Przetwarzanie w chmurze" (737)