top of page

Muru analizuje kompromisy związane z leniwym importowaniem w Pythonie

12 minut temu
10 minut(y) czytania
Illustrative photograph. Photo: Bibek ghosh / Pexels.

Raport deweloperski Muru z 22 listopada podważa znaną optymalizację: przyspieszenie startu aplikacji Python może spowolnić jej pierwsze żądania. Najnowsza część analizy Grahama Dumpletona bada, gdzie odroczone importy przenoszą pracę, kto na nią czeka oraz czy workery tracą możliwości współdzielenia pamięci.

Projekt to wspomagany przez AI serwer Rust przeznaczony dla aplikacji Python korzystających z ASGI, asynchronicznego interfejsu aplikacji, oraz WSGI, jego synchronicznego odpowiednika. Dumpleton przedstawił te prace wcześniej w listopadzie. Nowością jest jego analiza zachowania importów, a nie premiera nowego serwera ani niezależnie zweryfikowany kamień milowy wydajności.

Kluczowy wybór dotyczy ładowania zależności przed utworzeniem procesów workerów obsługujących żądania albo ładowania ich dopiero, gdy po raz pierwszy będą potrzebne do obsługi żądań. Gunicorn już oferuje powiązaną opcję wstępnego ładowania. Argument Dumpletona podważa podejście deweloperów, którzy uznają krótszy start za wystarczający dowód lepszej wydajności aplikacji, szczególnie gdy ich wdrożenie już chroni użytkowników przed opóźnieniami uruchamiania.

Muru skupia się na kosztach importu

Najnowszy raport traktuje optymalizację importów jako decyzję zależną od obciążenia, której konsekwencje wykraczają poza uruchamianie aplikacji.

Analiza lazy-import Dumpletona jest kontynuacją wcześniejszych części poświęconych architekturze workerów, wydaniom, narzędziom deweloperskim i śledzeniu żądań. Łączy je praktyczne pytanie: kiedy aplikacja powinna ponieść koszt ładowania swoich zależności?

Import ładuje i inicjalizuje moduł Python, czyli wielokrotnie używalną jednostkę kodu. Operacja ta może uruchamiać dodatkowe importy, tworząc łańcuch pracy. Funkcja wymagająca biblioteki arkuszy kalkulacyjnych może zatem załadować więcej niż tylko kod bezpośrednio wskazany przez aplikację.

Leniwe importy odraczają to ładowanie do chwili, w której kod po raz pierwszy użyje importowanej nazwy. Ich zaleta jest prosta: zależności, które pozostają niewykorzystane, nie muszą wydłużać czasu startu. W aplikacjach z opcjonalnymi funkcjami może to całkowicie wyeliminować część pracy.

Serwer WWW wprowadza dodatkową kwestię. Według Dumpletona serwer importuje aplikację w procesie hosta przed utworzeniem workerów. Taka kolejność pozwala workerom dziedziczyć już załadowane moduły, zmieniając zarówno moment wykonania pracy, jak i częstotliwość jej wykonywania.

Jego przykład wykorzystuje Flask, framework WWW dla Pythona, do stworzenia niewielkiego sklepu. Raport o stanie magazynowym zależy od pandas, biblioteki do analizy danych. Pobieranie arkuszy kalkulacyjnych zależy od openpyxl, biblioteki do tworzenia i odczytywania skoroszytów Excel.

Te funkcje stosują różne układy importów. Raport ładuje zależność wewnątrz funkcji obsługującej żądanie. Funkcja arkuszy początkowo ładuje swoją zależność do aplikacji podczas startu. Przykład pokazuje więc zarówno odroczone, jak i natychmiastowe ładowanie w tej samej aplikacji.

Dumpleton uruchamia przykład na Pythonie 3.14 z dwoma workerami. Opisuje narzędzia do analizowania importów hosta wraz z modułami ładowanymi później przez poszczególne workery. Istotne porównanie obejmuje oba etapy, a nie kończy się w momencie udostępnienia aplikacji.

Dzięki temu raport jest bardziej konkretny niż ogólne zalecenie odraczania ciężkich bibliotek. Pyta, czy zależności pozostają niewykorzystane przez cały rzeczywisty czas życia workerów. Biblioteka, której ostatecznie potrzebuje każdy worker, wymaga innej kalkulacji niż taka, której większość workerów nigdy nie używa.

Znaczenie ma także moment publikacji. Przegląd serwerów Python Simona Willisona z 21 listopada, Python server overview, zwrócił uwagę na projekt i szczegółowy opis jego rozwoju. Część z 22 listopada dodaje konkretne pytanie optymalizacyjne do tego szerszego wprowadzenia. Żadna z dat publikacji nie dowodzi, że serwer przeszedł pełną walidację produkcyjną.

Szybszy start nie zawsze dociera do użytkowników

Krótszy czas uruchamiania ma inne znaczenie, gdy istniejące workery nadal obsługują ruch, a inne, gdy odwiedzający czeka na przebudzenie aplikacji.

Dumpleton opisuje model wdrożenia, w którym wersja zastępcza uruchamia się obok wersji obsługującej już żądania. Ruch zostaje przełączony po osiągnięciu gotowości przez nową wersję. W takim układzie importy aplikacji wydłużają wdrożenie, ale nie muszą opóźniać odwiedzających korzystających z istniejącego wydania.

Gotowość to kontrola określająca, czy instancja może przyjmować ruch. Jeśli kontrola ta czeka na załadowanie aplikacji i inicjalizację workerów, użytkownicy nie napotykają tych kosztów startowych podczas zwykłego routingu. Odroczenie zależności może przenieść wcześniej ukrytą pracę do widocznych żądań.

To rozróżnienie umieszcza deweloperów aplikacji i właścicieli wdrożeń na tej samej ścieżce decyzyjnej. Deweloperzy mogą skrócić czas ładowania aplikacji. Operatorzy muszą ustalić, czy skrócenie to poprawia szybkość wdrożenia, opóźnienia dla użytkowników, wykorzystanie zasobów czy pewne połączenie tych korzyści.

Kontenery, czyli izolowane środowiska wykonywania aplikacji, tworzą podobną sytuację. Szybszy start może pomóc dodatkowym instancjom szybciej stać się dostępnymi. Pozostaje to użyteczne nawet wtedy, gdy routing odsuwa żądania od tych instancji do momentu pomyślnego przejścia kontroli gotowości.

Jednak ochrona początkowego ładowania aplikacji nie chroni automatycznie każdej opcjonalnej funkcji. Worker może być gotowy do obsługi głównych tras, nadal nie mając zależności potrzebnej mniej powszechnemu endpointowi. Pierwsze żądanie trafiające do tego endpointu ponosi odroczony koszt.

Skalowanie do zera ponownie zmienia równowagę. Oznacza to zatrzymanie niewykorzystywanej zdolności obsługi aż do powrotu ruchu. Dumpleton opisuje przypadek, w którym sam host został zatrzymany, przez co kolejne żądanie czeka na uruchomienie aplikacji.

W tym przypadku uniknięcie zbędnego importu może bezpośrednio skrócić czas oczekiwania odwiedzającego. Korzyść zależy jednak od funkcji, o którą prosi ten odwiedzający. Szybkie wybudzenie aplikacji niewiele pomaga, jeśli to samo żądanie natychmiast uruchamia odroczoną zależność.

Rozwój oprogramowania wprowadza inny uzasadniony priorytet. Przeładowanie oznacza ponowne uruchomienie wykonywania aplikacji po zmianie kodu. Gdy dzieje się to wielokrotnie, unikanie nieużywanych zależności może skrócić pętlę informacji zwrotnej dla deweloperów pracujących nad niezwiązanymi funkcjami.

Są to odrębne doświadczenia i wymagają odrębnych miar sukcesu. Przeładowanie podczas rozwoju, chronione wdrożenie produkcyjne i żądanie wybudzające zatrzymaną aplikację nie powinny otrzymywać tego samego werdyktu optymalizacyjnego tylko dlatego, że każde z nich wiąże się ze startem.

Wymuszoną odpowiedzią są lepsze pomiary na kolejnych etapach wdrożenia. Zespoły oceniające leniwe importy muszą wskazać, kto czeka, które zależności trafiają do obsługi żądań oraz czy usprawnienia startu utrzymują się przy realistycznym ruchu.

Wymóg ten ogranicza również szerokie twierdzenia o wydajności. Szybsze załadowanie hosta dowodzi, że jeden etap został skrócony. Nie dowodzi, że aplikacja szybciej obsługuje użytkowników, przetwarza większy ruch ani zużywa mniej pamięci przez cały okres działania.

Jednorazowe ładowanie konkuruje z ładowaniem na żądanie

Główny kompromis polega na zapłaceniu kosztu raz przed uruchomieniem workerów albo później w każdym workerze potrzebującym zależności.

Projekt serwera typu pre-fork tworzy workery przez kopiowanie zainicjalizowanego procesu. Pamięć copy-on-write pozwala tym procesom początkowo współdzielić strony pamięci, dopóki zmiany nie wymagają prywatnych kopii. Wcześniejsze ładowanie modułów może więc wspierać współdzielenie ich przez workery.

Odroczenie importu zmienia tę sekwencję. Każdy worker, który jako pierwszy potrzebuje modułu, ładuje go osobno. Workery, które nigdy go nie potrzebują, unikają tej pracy, natomiast te, które go potrzebują, ponoszą koszt inicjalizacji podczas własnego wykonywania.

Dlatego liczba workerów korzystających z zależności ma większe znaczenie niż sam koszt jej importu. Kosztowna zależność może być rozsądnym kandydatem do odroczenia, gdy niewielu workerów korzysta z jej funkcji. Ta sama zależność staje się mniej atrakcyjna, gdy każdy worker ostatecznie ją ładuje.

Podstawowy wybór poprzedza ten projekt. Udokumentowana opcja application preloading w Gunicorn ładuje kod aplikacji przed rozwidleniem workerów. Dokumentacja opisuje potencjalne oszczędności pamięci i szybszy start serwera, omawiając także różnice w przeładowywaniu aplikacji.

To porównanie zapewnia nowemu raportowi ugruntowany punkt odniesienia. Wstępne ładowanie samo w sobie jest istniejącą strategią obsługi. Charakterystyczny nacisk polega tu na połączeniu kosztów importu hosta z dowodami dotyczącymi tego, co poszczególne workery ładują później.

Architektura procesów również ogranicza porównania. Udokumentowany worker process model Uvicorn używa tworzenia nowych procesów zamiast pre-fork w swoim wbudowanym menedżerze wieloprocesowym. Tworzenie nowych procesów uruchamia oddzielne procesy, więc identyczne założenia dotyczące dziedziczonego stanu aplikacji nie mają zastosowania.

Różnice te nie wskazują uniwersalnego zwycięzcy wśród serwerów. Ustalają, dlaczego porady dotyczące importów muszą wskazywać model wdrożenia. Wynik uzyskany z odziedziczonymi modułami nie może automatycznie opisywać konfiguracji serwera uruchamiającej workery niezależnie.

Przykład sklepu Dumpletona sprawia, że rozróżnienie staje się namacalne. Początkowo zależności arkuszy potrzebuje tylko jeden worker. Drugi unika jej ładowania. Później dodatkowe pobrania docierają do obu workerów, zmieniając przesłanki wcześniejszego zalecenia.

Funkcja raportów działa w przeciwnym kierunku. Oba workery ładują jej odroczoną zależność, powielając pracę, którą host mógł wykonać przed ich utworzeniem. Według Dumpletona jawne wstępne ładowanie tego modułu przenosi inicjalizację poza te pierwsze żądania raportów.

Czas życia workerów dodatkowo komplikuje sytuację. Działający długo worker ma więcej okazji natrafić na rzadko używaną funkcję. Worker zastąpiony przed nadejściem takiego żądania może uniknąć zależności przez cały użyteczny okres działania.

Dystrybucja ruchu ma znaczenie z tego samego powodu. Funkcja może stanowić niewielki udział w żądaniach, a mimo to ostatecznie dotrzeć do każdego długo działającego workera. Określenie jej jako „rzadkiej” nie dowodzi, że odroczenie oszczędza pracę w całej puli obsługującej ruch.

Pytanie ekonomiczne ma więc charakter operacyjny, a nie stylistyczny. Zespoły muszą zestawić opóźnienie startu, opóźnienie pierwszego użycia i współdzielenie pamięci z częstotliwością, z jaką zależności pozostają niewykorzystane. Preferencja dla natychmiastowych lub leniwych importów nie może zastąpić tych faktów dotyczących obciążenia.

Pierwsze żądania ujawniają, gdzie przeniesiono pracę

Najmocniejszym dowodem w raporcie jest związek między krótszym ładowaniem hosta a pracą importową pojawiającą się wewnątrz żądań.

Dumpleton mierzy ładowanie hosta sklepu przy wyłączonym rejestrowaniu importów, uznając, że profilowanie dodaje pracę. Profilowanie to zbieranie pomiarów wykonania używanych do lokalizowania kosztów. Oddzielenie przebiegów diagnostycznych od porównań czasowych pomaga uniknąć mylenia narzutu pomiarowego z zachowaniem aplikacji.

W pięciu uruchomieniach dla każdej konfiguracji podaje medianę ładowania hosta wynoszącą 83 milisekundy bez odroczenia i 35 milisekund z nim. Mediana jest środkową obserwacją po uporządkowaniu pomiarów. Dane te opisują jego przykład, a nie ogólny benchmark serwera.

Odroczona praca pojawia się następnie w żądaniu arkusza kalkulacyjnego. Nagłówek jego przykładu przypisuje 52,03 milisekundy importowaniu modułów w odpowiedzi aplikacji trwającej 56,89 milisekundy. Krótsze ładowanie hosta nie oznacza więc, że inicjalizacja zależności stała się tańsza.

Serwer udostępnia te pomiary za pośrednictwem Server-Timing, nagłówka odpowiedzi HTTP, który przeglądarki mogą wyświetlać jako informacje o czasie. Jego wpis importu odróżnia ładowanie modułu od innej pracy związanej z żądaniem. Daje to programistom sposób na powiązanie zmiany podczas uruchamiania z jej późniejszym skutkiem.

Kolejne rozróżnienie pojawia się, gdy żądania nakładają się na siebie. Blokada importu Pythona koordynuje inicjalizację modułów, aby współbieżne wykonanie nie inicjalizowało niezależnie tego samego modułu. Żądanie oczekujące na tę blokadę może doświadczyć opóźnienia, nie wykonując samego importu.

W przykładzie współbieżnego raportu Dumpletona jedno żądanie ładuje zależność, podczas gdy inne czeka. Zarejestrowane nagłówki rozróżniają czas importu od czasu oczekiwania na import. Oba żądania doświadczają epizodu inicjalizacji, choć tylko jedno wykonuje ładowanie.

Ta obserwacja rozszerza koszt poza pojedynczego pechowego pierwszego użytkownika. Żądania współdzielące worker mogą napotykać powiązane opóźnienia, gdy potrzebują modułu, którego inicjalizacja pozostaje niedokończona. Liczenie wyłącznie żądania, które go zaimportowało, zaniża rzeczywiste doświadczenie.

Według raportu wstępne ładowanie modułu raportu zmienia te pierwsze odpowiedzi. Dumpleton rejestruje pierwsze żądania raportu trwające od 4,5 do 9 milisekund po przeniesieniu zależności do ładowania hosta. Są to wyniki zgłoszone przez autora na podstawie przykładowej aplikacji.

Przykład wspiera wąski wniosek: zmiana miejsca importu zmieniła miejsce, w którym ta aplikacja spędzała czas. Nie dowodzi przewagi w przepustowości produkcyjnej, ogólnego zmniejszenia zużycia pamięci ani wyższości nad konkurencyjnymi serwerami.

Kontekst narzędzi pomaga wyjaśnić, dlaczego Dumpleton podkreśla dowody z żądań. Jego wcześniejsza część o śledzeniu żądań łączy operacje aplikacji z diagnostyką programistyczną. Ten przykład wykorzystuje sklep do ujawnienia powtarzających się zapytań do bazy danych i wywołań wychodzących.

Są to skonstruowane przykłady, a nie wyniki wdrożeń u klientów. Ich wartość polega na pokazaniu, co programiści mogą sprawdzać. Raport importów rozszerza to podejście, łącząc ładowanie hosta, koszty pierwszego użycia oraz workery, które ostatecznie potrzebowały każdego modułu.

Zgodność z Pythonem utrzymuje warunkowy charakter werdyktu

Wsparcie języka ułatwia wyrażenie odroczenia, ale zgodność i faktyczne użycie nadal decydują o tym, czy przynosi ono korzyść.

Specyfikacja jawnych leniwych importów w Pythonie jest skierowana do Python 3.15 i definiuje ładowanie modułów w momencie pierwszego użycia importowanych nazw. Udostępnia także przejściową deklarację modułu, ignorowaną przez wcześniejsze interpretery. Nowa składnia i deklaracje zgodne wstecz wymagają zatem odmiennego traktowania.

Dumpleton opisuje użycie unwrapt, swojego pakietu do odraczania importów, aby wspierać wybrane zachowania odraczania we wcześniejszych wersjach Pythona. To rozróżnienie ma znaczenie dla zespołów obsługujących wiele interpreterów. Samo zapisanie deklaracji nie gwarantuje identycznego zachowania wykonania wszędzie.

Jego raport wskazuje konkretne ograniczenie podejścia dla starszych wersji: unwrapt może odroczyć zwykły import, podczas gdy natywne wsparcie może również odroczyć import from-import. Import from-import wiąże wybrane nazwy z modułu. Część kodu aplikacji wymaga zatem przepisania, zanim mechanizm dla starszych wersji będzie mógł go odroczyć.

Nawet skuteczne odroczenie może nic nie zaoszczędzić, gdy inicjalizacja natychmiast używa zależności. Biblioteka arkuszy kalkulacyjnych sklepu stanowi przykład: zagnieżdżona zależność jest używana, gdy importujący ją moduł nadal się ładuje. Opóźnienie tego importu jedynie przesuwa go w obrębie tej samej sekwencji inicjalizacji.

To użyteczne ograniczenie dla automatycznych sugestii. Import może wyglądać na kosztowny w raporcie, nie reprezentując pracy, której można uniknąć. Narzędzia muszą rozróżniać zależności pozostające nietknięte od zależności natychmiast wymaganych do utworzenia stanu importującego modułu.

Ta sama ostrożność dotyczy porad wyprowadzanych z ruchu. Raport workera obejmuje już zaobserwowane żądania. Jeśli opcjonalna funkcja nie została użyta, brak importu dowodzi jedynie, że próbka ruchu jej nie potrzebowała.

Szersza próbka może odwrócić rekomendację. Dumpleton pokazuje, jak zależność arkusza kalkulacyjnego przechodzi z jednego workera do obu po kolejnych pobraniach. Ta zmiana pokazuje, dlaczego programiści powinni ponownie analizować wnioski po reprezentatywnym ruchu, zamiast traktować wczesną rekomendację jako trwałą.

Istnieje również luka w weryfikacji. Przykłady pochodzą od autora projektu i nie zostały tutaj niezależnie odtworzone. Szczegółowe dane wyjściowe poprawiają możliwość kontroli, ale nie mogą zastąpić zewnętrznych testów w różnych aplikacjach, zależnościach i środowiskach wdrożeniowych.

Pomoc AI daje kolejny powód, aby uważnie badać dowody. Willison opisuje projekt jako wspomagany przez AI, podczas gdy Dumpleton podkreśla swoją odpowiedzialność za decydowanie, co pozostaje niewystarczające. Ani język implementacji, ani metoda rozwoju nie ustanawiają niezawodności operacyjnej.

Nie wymaga to odrzucenia tej pracy. Oznacza oddzielenie udokumentowanego zachowania od szerszego zaufania. Widoczność importów może być użyteczna, podczas gdy pozostają pytania o zgodność, obsługę błędów, utrzymanie i wydajność poza przykładem.

Dla zespołów inżynieryjnych te rozróżnienia powinny należeć do wspólnego rejestru eksperymentów i decyzji. Przeszukiwalna baza wiedzy może zachować założenia dotyczące obciążenia wraz z wynikami. Bez tych założeń udana optymalizacja może stać się mylącą wskazówką po skopiowaniu do innej usługi.

Co wzmocniłoby argument w kolejnym kroku

Kolejnym użytecznym dowodem jest odtwarzalne zachowanie w różnych obciążeniach, wersjach interpretera i zmieniających się populacjach workerów.

Pierwszym sygnałem jest niezależne odtworzenie wyników dotyczących miejsca importu. Testy powinny śledzić zależności od inicjalizacji hosta przez tworzenie workerów aż po pierwsze żądania. Powinny również porównywać kolejne żądania, aby krótka korzyść przy uruchamianiu nie przesłoniła powtarzających się kosztów workerów.

Przekonujące odtworzenie ujawniłoby zależności aplikacji, wersje interpretera, liczbę workerów i skład ruchu. Pomiary pamięci pomogłyby przetestować argument dotyczący współdzielenia wraz z czasem. Dowody, że te same zależności utrzymują się, wzmocniłyby analizę głównego kompromisu przedstawioną w raporcie.

Wyniki znacząco się różniące nadal byłyby pouczające. Zawęziłyby obszar, w którym pomiary mają zastosowanie, i wskazały, które zależności lub wybory wdrożeniowe dominują. Celem jest zrozumienie granicy tego zachowania, a nie uzyskanie imponującej odizolowanej liczby.

Drugim sygnałem są dowody zgodności obejmujące natywne odraczanie i odraczanie dla wcześniejszych wersji. Zespoły muszą wiedzieć, czy wybrane importy są odraczane zgodnie z zamierzeniem oraz czy użycie zależności w czasie uruchamiania niweluje oczekiwane oszczędności. Potrzebują także jasnej diagnostyki, gdy forma importu jest traktowana inaczej.

Pomyślne testy zgodności wzmocniłyby zaufanie do stosowania tej samej polityki we wspieranych środowiskach. Powtarzające się niespodzianki osłabiłyby argument za szerokim wdrożeniem i przemawiały za bardziej selektywnym użyciem. Dokumentacja powinna uwidaczniać te różnice, zanim zespoły zmienią ładowanie aplikacji.

Trzecim sygnałem jest obserwacja w realistycznych cyklach życia workerów. Użyteczny zapis wdrożenia śledziłby, które workery ładują każdą opcjonalną zależność w miarę napływu ruchu i zmian pojemności. Sprawdziłoby to, czy funkcje pozornie rzadkie pozostają rzadkie na poziomie workera.

Jeśli większość workerów unika zależności przed zastąpieniem, odroczenie ma mocniejszy argument za unikaniem niepotrzebnej inicjalizacji. Jeśli ładuje ją niemal każdy worker, warto ponownie rozważyć wstępne ładowanie. Każdy z tych wyników przekształciłby założenie o ruchu w dowód dotyczący puli obsługującej.

Te sygnały utrzymują również koncentrację oceny. Rosnąca lista funkcji sama w sobie nie rozwiązałaby pytania o importy. Liczy się to, czy diagnostyka pomaga zespołom wybrać politykę poprawiającą ich rzeczywistą kombinację uruchamiania, opóźnień żądań i wykorzystania zasobów.

Dla czytelników rozważających Muru warto zacząć od aplikacji, której opcjonalne zależności i zachowanie wdrożeniowe już rozumieją. Zachowaj punkt odniesienia, ustal, kto czeka podczas uruchamiania, i porównaj żądania pierwszego użycia z późniejszym ruchem. Powiąż pomiary z konkretnymi cyklami życia workerów i wersjami interpretera. Zapytaj, czy uniknięty import pozostaje uniknięty, czy po wystarczającej liczbie żądań po prostu pojawia się ponownie w każdym workerze. Traktuj opublikowany sklep jako przykład możliwy do przetestowania, a następnie sprawdź, czy własna aplikacja podąża tym samym wzorcem. Przeczytaj podstawowe raporty przed zmianą ustawień produkcyjnych i zachowaj warunki stojące za każdym wynikiem. Decyzja, którą warto podjąć, dotyczy tego, kiedy aplikacja powinna ponosić koszt swoich zależności, poparta dowodami dotyczącymi ludzi i procesów, które w przeciwnym razie zapłacą później.

 
 

Zacznij bezpłatnie

Asystent AI działający przede wszystkim lokalnie, z funkcją zarządzania wiedzą osobistą

Aby zapewnić lepsze działanie AI,

remio obsługuje obecnie wyłącznie Windows 10+ (x64) i M-Chip Macs.

Twój partner AI w pracy
Zrób więcej z remio

Planuj. Twórz. Dostarczaj.
Wszystko w jednym miejscu.

bottom of page