For at adskille PHP-udførelsestiden fra netværket og frontend måler du først et klart defineret kodeinterval med hrtime() og sammenligner det med browser- og serverværdierne for den samme anmodning. En enkelt tidsværdi udgør ikke en fuldstændig tidsopgørelse: PHP-timeren indeholder også ventetider inden for sit interval, mens browsertimere har andre grænser. Server-timing kan overføre supplerende værdier, men måler dem ikke selv. Du skal tage højde for cache-tilstand, foreløbige svar og indlejrede målinger, når du sammenligner.
Hvad de aktuelle værdier rent faktisk viser
En side, der er langsom at indlæse, kan miste tid på flere forskellige punkter: mens den venter på et svar, i PHP, ved databaseforespørgsler eller senere under behandlingen i browseren. En enkelt værdi for PHP-kørselstid kan ikke skelne mellem disse årsager. Det afgørende er, hvilken del af en konkret anmodning en måleværdi overhovedet registrerer.
En PHP-timer måler den tid, der er gået mellem to opkald i applikationskoden. Hvis der ligger et database- eller API-opkald imellem, tæller ventetiden for dette med. Resultatet er derfor ikke ren CPU-tid og siger heller ikke noget om kode, der kører før timeren starter eller efter den slutter.
Browseren observerer derimod begivenheder ud fra sit eget perspektiv: for eksempel starten på en forespørgsel og modtagelsen af et svar. Ved en dynamisk dokumentanmodning kan der mellem disse begivenheder være netværksruter, proxy-behandling og serverbaseret arbejde. Hvilke dele der indgår, afhænger af de pågældende begivenheder og den faktiske svarvej.
HTTP-headeren Server-timing sender desuden angivne værdier, som f.eks. selve applikationen beregner. Den måler ikke automatisk den samlede servervej. En værdi for en databaseforespørgsel kan desuden ligge inden for applikationens interval; i så fald kan de to tal ikke lægges sammen til en samlet varighed.
Sammenlign perspektiverne for den samme anmodning i stedet for at betragte dem som en sammenhængende tidsoversigt. Et langt applikationsinterval er et udgangspunkt for søgningen i backend. Et kort interval ved langsom visning i browseren viser derimod i første omgang blot, at årsagen kan ligge uden for dette specifikt målte kodestykke.
Fastlægge anmodning og målebetingelser
Vælg først en konkret rute og den tilhørende dokumentanmodning, f.eks. en webshops dynamiske produktside. Notér, om du undersøger en tilstand, hvor brugeren er logget ind eller er anonym, og hvilke testdata der anvendes. Forskellige indkøbskurve, tilladelser eller indhold kan ellers medføre, at applikationen ikke fungerer på samme måde.
Definer derefter Måleområder: Hvor i PHP-koden starter timeren, hvor slutter den, og hvilke database- eller API-kald ligger der imellem? Notér også, om målingen først starter efter, at frameworket er startet. Kun med disse oplysninger kan man senere vurdere, hvad en kort eller lang værdi rent faktisk betyder.
Skel mellem cache-hits og cache-misses. Hvis en forudgående cache leverer svaret uden PHP, mangler der muligvis en applikationsværdi; det er ikke et bevis på, at PHP-bearbejdningen tog nul millisekunder. Du bør også registrere omdirigeringer som separate anmodninger i stedet for ubemærket at sammenligne deres tider med det endelige dokuments.
Gentag undersøgelsen under så sammenlignelige forhold som muligt: samme browser, lignende internetforbindelse, samme brugertilstand og dokumenteret cache-status. En enkelt gennemkørsel kan afvige på grund af midlertidige forsinkelser eller en anden svarvej. Notér derfor flere værdier og de tilhørende betingelser i stedet for blot at vælge den hurtigste værdi.
Til øvelsen skal du bruge browserens udviklerværktøjer og, for at kunne bruge en PHP-timer, adgang til applikationskoden. Brug et testmiljø eller en godkendt sti til dette formål; ændringer i produktionsmiljøet og belastningstests kræver en passende godkendelse. Webserverlogfiler eller en profiler kan supplere undersøgelsen, men er ikke en forudsætning for enhver indledende sammenligning.
Knyt browserværdien og den serversidige måling til den samme anmodning, f.eks. via en identifikator, der behandles i overensstemmelse med databeskyttelsesreglerne. Indsaml ikke unødvendige personoplysninger til dette formål, og begræns adgangen til diagnostiske oplysninger. Uden denne tilknytning kan selv parallelle anmodninger eller et mellemliggende cache-skift forvride en sammenligning.
At sætte browser-timingen i det rette perspektiv
Åbn netværkssektionen i udviklerværktøjerne, og vælg først dokumentanmodningen for den undersøgte navigation. Tidsværdierne for denne anmodning omfatter ikke automatisk billeder, stylesheets eller senere API-kald. For sådanne individuelle ressourcer giver Resource Timing hvert for sig et eget overblik; deres behandling i browseren er dermed heller ikke fuldt ud forklaret.
Tidspunktet requestStart markerer starten på forespørgslen set fra browserens synspunkt. responseStart angiver begyndelsen på et modtaget svar, mens responseEnd markerer afslutningen på modtagelsen af svaret. Forskellene beskriver observerede intervaller; især skal tiden indtil svarets begyndelse ikke sidestilles med et PHP-kodeinterval.
Med foreløbige svar er det nødvendigt at udvise særlig forsigtighed: Et svar som 103 Early Hints kan allerede ved responseStart skal tages i betragtning. Hvor browseren finalResponseHeadersStart hvis man tager højde for dette, giver dette tidspunkt et indblik i begyndelsen af det endelige svar. Forskellen i forhold til requestStart må derfor ikke generelt betegnes som ventetiden indtil den endelige HTML-header.
Cache, Service Worker, omdirigeringer og en genbrugt forbindelse har indflydelse på, hvilken rute en anmodning tager, og hvordan dens tider skal fortolkes. For ressourcer fra andre kilder kan enkelte oplysninger mangle eller være nul, hvis der ikke foreligger en passende godkendelse. Kontroller disse forhold, før du sammenligner to browserværdier med hinanden.
Selv hvis browserens ventetid er lang, men det målte PHP-interval er kort, betyder det ikke nødvendigvis, at der er et netværksproblem. Der kan også gå tid i en proxy eller i en kø før PHP-målepunktet. Man skal være særlig forsigtig med sammenligningen, hvis PHP-behandlingen først finder sted efter et foreløbigt svar: De to intervaller har i så fald forskellige grænser.
Måling af PHP-kode med hrtime
Med hrtime(true) måler du den forløbne tid mellem to selvvalgte punkter i PHP-koden. Funktionen bruger en monoton tidsbasis: I denne periode beregner du forskellen mellem to opkald i stedet for at fortolke et tidspunkt som et klokkeslæt. Det målte interval kan også omfatte ventetider og er derfor ikke ren CPU-tid.
Opret i det følgende eksempel en isoleret testfil i et delt miljø med PHP 7.3 eller nyere. Åbn den via webserveren, så du bagefter kan kontrollere svarheaderen i browserens udviklerværktøjer. Pladsholderen står for den del af applikationen, hvis start og slutning du selv fastlægger.
Funktionen returnerer værdien i nanosekunder; ved at dividere med en million fås varigheden i millisekunder. På 32-bit-systemer kan returværdien være en float. Fejlkontrollen forhindrer, at der ved en returværdi på false der angives en ugyldig varighed. Enheden nanosekunder garanterer i sig selv ikke en tilsvarende målenøjagtighed.
I eksemplet slutter intervallet, før headeren sættes, og før udskriften. Det omfatter derfor hverken disse trin eller det arbejde, der finder sted før det første eller efter det andet tidsstempel. Hvis du først sætter starttidspunktet efter frameworkets start, vil den forudgående initialisering af frameworket heller ikke indgå i resultatet.
Hvis du erstatter pladsholderen med et database- eller API-kald, tæller ventetiden herfor med i intervallet. En høj værdi viser derfor i første omgang, at det indrammede afsnit varede længe; den skelner endnu ikke mellem PHP-beregninger og ventetid på andre tjenester. For at kunne skelne mellem disse to ting har du brug for yderligere, tættere placerede målepunkter.
Overførsel af måleværdier via server-timing
Overskriften Server-Timing sender de angivne måleværdier til klienten. Den måler ikke selv varigheden: Applikationen eller en involveret serverkomponent skal først beregne værdien. For dur specifikationen anbefaler millisekunder; navnet beskriver måleenheden, men ikke nødvendigvis dens målegrænser.
I PHP-eksemplet skal headeren indsættes, før den egentlige udskrift sendes. Den anden parameter false med header() tilføjer et yderligere header-felt i stedet for at erstatte et eksisterende felt med samme navn. I et framework er en response-middleware ofte et passende integrationspunkt, forudsat at målingen allerede er afsluttet dér, og at headerne endnu ikke er blevet sendt.
Følgende HTTP-svarheader viser to fiktive værdier; det er ikke en måling. Hvis vi antager, at databaseintervallet ligger fuldstændigt inden for applikationsintervallet, er værdierne indlejret. De 75 millisekunder til databasen er allerede inkluderet i de 120 millisekunder til applikationen og må ikke lægges til.
Under denne antagelse beskriver forskellen på 45 millisekunder blot den resterende tid inden for app. Det er ikke nødvendigvis PHP-CPU-tid: Også her kan der være andre ventetider inkluderet. Dokumenter derfor for hver måling, hvor den begynder og slutter, og om den omfatter andre intervaller.
Vis kun bevidst udvalgte, tilstrækkeligt grove værdier. Metriknavne og beskrivelser kan afsløre detaljer om infrastrukturen; personoplysninger hører ikke hjemme i headeren. Adgangen til timingdata på tværs af kilder via JavaScript er begrænset og kan med Timing-Allow-Origin styres. Du bør nøje kontrollere, om en sådan godkendelse er påkrævet for de pågældende oprindelsessteder.
Sammenligning af måleintervaller
Værdierne i tabellen besvarer forskellige spørgsmål. Sammenlign dem om muligt for den samme anmodning, og noter de respektive grænser: Et interval, der vises i browseren, starter og slutter ikke automatisk på de samme tidspunkter som en PHP-timer eller en NGINX-logværdi. Desuden er det særligt vigtigt, at Enhed: Millisekunder og sekunder må ikke analyseres side om side uden nærmere undersøgelse.
| Målt variabel | Start og slutning | Enhed | Ventetider og begrænsninger |
|---|---|---|---|
| PHP-kodesequence | Mellem to selvdefinerede hrtime-kald | Nanosekunder som talværdi; ofte omregnet til millisekunder | Omfatter ventetider inden for afsnittet; ingen ren CPU-tid og ingen fuldstændig anmodning. |
| Server-timing-måling | Bestemt af den målekomponent | For dig anbefales millisekunder | Overfører en beregnet værdi; de medfølgende ventetider afhænger af de definerede grænser. |
| Browserens anmodningsinterval | requestStart til responseStart | Millisekunder | Omfatter ventetiden set fra browserens perspektiv; responseStart kan registrere et foreløbigt svar. |
| Browserens svarinterval | responseStart til responseEnd | Millisekunder | Beskriver det observerede svarinterval; skal ikke forveksles med ren PHP-udførelse. |
| NGINX-anmodningstid | Første læsning af klient-bytes indtil loggen skrives efter afsendelse af de sidste bytes | Sekunder | Omfatter anmodningen set fra NGINX’ synspunkt, inklusive ventetider; grænserne adskiller sig fra PHP-timeren. |
Kontroller det faktiske logformat, før du fortolker en værdi som varigheden af hele backend-processen. NGINX-anmodningstiden har sin egen tidsramme: Den begynder allerede, når de første klient-bytes læses, og strækker sig frem til loggen skrives, efter at de sidste bytes er sendt.
Browser- og serverværdier kan bruges som supplerende perspektiver, men de bør ikke uden nærmere undersøgelse lægges sammen eller trækkes fra hinanden for at danne en fuldstændig tidsoversigt. Måleområderne kan overlappe hinanden, og klient- og serverure er ikke pålideligt synkroniseret. Notér derfor ved siden af hver værdi, hvilken anmodning og hvilken svarvej der faktisk blev observeret.
Tilføj logs og PHP-FPM
En applikationstimer viser kun den indrammede kode. Supplerende Serverens logfiler hjælper med at se på den samme anmodning fra et andet perspektiv. Til det formål skal du sammenkæde PHP-værdien og logposten ved hjælp af en anmodningsidentifikator, der er tildelt i overensstemmelse med databeskyttelsesreglerne. Kontroller først, om det rent faktisk er den samme svarsti, der er blevet gennemløbet, og at en omdirigering ikke forveksles med en separat anmodning.
Med NGINX begynder $request_time den starter ved læsning af de første klient-bytes og slutter ved skrivning af loggen efter afsendelse af de sidste svar-bytes. Denne størrelse har andre grænser end en timer inden for PHP-applikationen og kan derfor ikke sidestilles med denne.
Kontroller det konfigurerede logformat og målegrænserne, før du behandler en logværdi som en PHP-kørselstid. Den Analyse af hosting-latens for netværk, PHP og database giver yderligere udgangspunkter for undersøgelsen af hele svarførløbet.
Selv slutningen på det synlige svar behøver ikke at være slutningen på PHP-arbejdet. Med fastcgi_finish_request() kan PHP-FPM afslutte svaret og derefter udføre yderligere kode. For at vurdere belastningen på worker-processerne har du derfor også brug for overvågning på serversiden; en kortvarig værdi på klientsiden udelukker ikke, at der senere skal udføres yderligere arbejde.
Ved streaming eller allerede sendte headere kan en samlet værdi, der fastslås på et senere tidspunkt, ikke længere pålideligt indsættes i den oprindelige svarheader. Brug i stedet egnede logfiler eller sporing. Begræns adgang og opbevaring til det nødvendige, og undgå personoplysninger eller fortroligt indhold i måleværdier og korrelationskoder.
Indsnævre databasen, API’en og frontend’et
Hvis anvendelsesintervallet er langt, skal du opdele det i mindre intervaller på fagligt relevante steder. En separat målt databaseadgang kan vise, hvor meget tid der er gået inden for denne adgang. Fra et applikationsperspektiv omfatter værdien i givet fald også forbindelses- og overførselstider og skal ikke sidestilles med databasens rene beregningstid.
En lang databaseværdi er en hypotese for det næste skridt, ikke en endelig diagnose. Undersøg den pågældende forespørgsel ved hjælp af de tilgængelige database-diagnoseværktøjer og dens udførelsesplan. Først dér kan man undersøge, om der f.eks. er tale om en ugunstig adgangsvej eller en anden årsag; PHP-timeren alene beviser ikke, at der mangler et indeks.
Ved en ekstern API skal du indsætte endnu en timer umiddelbart efter det udgående kald. Et langt API-interval viser, hvor applikationen venter, men ikke automatisk hvorfor. Undersøg ved hjælp af detaljerede klient-timings eller sporing, hvis dette er tilgængeligt, om der er noget usædvanligt ved f.eks. navneopløsning, oprettelse af forbindelse, modparten eller overførslen.
Hvis HTML-koden indlæses hurtigt, men siden stadig virker langsom, skal du skifte til browserperspektivet. Undersøg de enkelte ressourceanmodninger og derefter JavaScript-behandlingen og visningen. Dokumentets PHP-timer registrerer hverken senere ressourceanmodninger automatisk eller browserens samlede arbejde; også for disse trin skal du selv foretage observationer.
Hvis der mangler en PHP-måleværdi, skal du først kontrollere Cache-sti: En cache, der er placeret foran, kan levere et svar uden at kalde PHP for denne anmodning. Fraværet af headeren betyder derfor ikke, at PHP har brugt nul millisekunder. Registrer cache-hits og dynamiske svar separat, og sammenlign kun anmodninger, der er korrekt tilknyttet hinanden.
Vurdere resultaterne og undersøge dem nærmere
Inden du udleder en foranstaltning ud fra iøjnefaldende tal, skal du kontrollere deres tilknytning: Hører browserhændelsen, headeren og loggen virkelig til den samme anmodning? Forskellige brugertilstande, cache-træffere eller omdirigeringer kan ellers skabe tilsyneladende forskelle. Dokumenter desuden grænserne og enhederne for hver værdi, før du sammenligner flere gennemløb.
Med indlejrede intervaller må du ikke lægge deltidsmålingen sammen med den samlede tid. En forskel mellem applikationen og databasen er heller ikke automatisk PHP-CPU-tid; den beskriver i første omgang blot den resterende forløbne tid inden for de valgte grænser. Ligeledes er forskellen mellem browser- og applikationsmålingen ikke nødvendigvis ren netværkstid.
Hvis det definerede anvendelsesinterval gentagne gange er langt, men den dyre kode stadig er ukendt, er en profiler det næste fornuftige skridt. Den kan hjælpe med at målrette undersøgelsen mod bestemte funktioner og opkaldsstier. Angiv i den forbindelse, hvilken anmodning og hvilket afsnit du profilerer, i stedet for at overføre resultatet til alle sider i applikationen.
Når det derimod drejer sig om adfærd ved samtidige adgangsforespørgsler, er det ikke tilstrækkeligt at måle en enkelt forespørgsel. Planlæg en reproducerbar applikationstest under godkendte betingelser, og tag højde for vellykkede svar, fejl og svartider. Artiklen om Benchmarking af server-CPU’er til reelle PHP-arbejdsbelastninger forklarer, hvordan man kan skelne mellem en regneopgave og en anvendelsesopgave.
Medtag til sidst også det arbejde, der udføres efter besvarelsen, i vurderingen: Ved brug af fastcgi_finish_request() En hurtig afslutning af browseren kan falde sammen med yderligere PHP-behandling. Vælg derfor den næste måling ud fra det konkrete formål: synlig responstid, varigheden af et kodestykke eller belastningen af workeren er forskellige mål.
Kilder og den aktuelle videnskabelige viden
Status for undersøgelsen:
Oplysningernes status: 13. november 2026. hrtime-eksemplet forudsætter PHP version 7.3 eller nyere; server-timing klassificeres i henhold til W3C’s arbejdsudkast fra 2. november 2026.
https://www.php.net/manual/en/function.hrtime.php
https://www.w3.org/TR/2026/WD-server-timing-20261102/
https://www.w3.org/TR/resource-timing/
https://www.php.net/manual/en/book.hrtime.php
https://www.php.net/manual/en/function.header.php
https://nginx.org/en/docs/http/ngx_http_log_module.html
https://www.php.net/fastcgi_finish_request




