Ismerje meg a WebGL pipeline statisztikák gyűjtését a renderelési teljesítmény optimalizálásához. Növelje WebGL alkalmazásai hatékonyságát gyakorlatias betekintésekkel.
WebGL pipeline statisztikák gyűjtése: A renderelési teljesítménymutatók feltárása
A web alapú 3D grafika világában a teljesítmény kulcsfontosságú. Akár egy komplex játékot, egy adatvizualizációs eszközt vagy egy interaktív termékkonfigurátort készít, a zökkenőmentes és hatékony renderelés elengedhetetlen a pozitív felhasználói élményhez. A WebGL, a JavaScript API, amely interaktív 2D és 3D grafikák renderelését teszi lehetővé bármely kompatibilis webböngészőben bővítmények nélkül, erőteljes képességeket kínál, de teljesítményének elsajátítása a renderelési pipeline és az azt befolyásoló tényezők mély megértését igényli.
A WebGL alkalmazások optimalizálásának egyik legértékesebb eszköze a pipeline statisztikák gyűjtésének és elemzésének képessége. Ezek a statisztikák betekintést nyújtanak a renderelési folyamat különböző aspektusaiba, lehetővé téve a fejlesztők számára a szűk keresztmetszetek és a fejlesztési területek azonosítását. Ez a cikk a WebGL pipeline statisztikák gyűjtésének bonyodalmait vizsgálja, elmagyarázva, hogyan lehet hozzáférni ezekhez a metrikákhoz, értelmezni jelentésüket, és felhasználni őket a WebGL alkalmazások teljesítményének javítására.
Mik azok a WebGL pipeline statisztikák?
A WebGL pipeline statisztikák olyan számlálók összessége, amelyek a renderelési pipeline különböző műveleteit követik nyomon. A renderelési pipeline egy sor szakaszból áll, amelyek a 3D modelleket és textúrákat a képernyőn megjelenő végső 2D képpé alakítják. Minden szakasz számításokat és adatátvitelt foglal magában, és az egyes szakaszok terhelésének megértése feltárhatja a teljesítmény korlátait.
Ezek a statisztikák információt nyújtanak a következőkről:
- Vertex feldolgozás: Feldolgozott vertexek száma, vertex shader meghívások, vertex attribútum lekérések.
- Primitív összeállítás: Összeállított primitívek (háromszögek, vonalak, pontok) száma.
- Raszterizálás: Generált fragmentek (pixelek) száma, fragment shader meghívások.
- Pixel műveletek: A frame bufferbe írt pixelek száma, elvégzett mélységi és stencil tesztek.
- Textúra műveletek: Textúra lekérések száma, textúra cache hibák.
- Memóriahasználat: Textúrákra, pufferekre és egyéb erőforrásokra lefoglalt memória mennyisége.
- Draw callok: A kiadott egyedi renderelési parancsok száma.
Ezen statisztikák figyelésével átfogó képet kaphat a renderelési pipeline viselkedéséről, és azonosíthatja azokat a területeket, ahol az erőforrások túlzott mértékben kerülnek felhasználásra. Ez az információ kulcsfontosságú az optimalizálási stratégiákkal kapcsolatos megalapozott döntések meghozatalához.
Miért gyűjtsünk WebGL pipeline statisztikákat?
A WebGL pipeline statisztikák gyűjtése számos előnnyel jár:
- Teljesítmény szűk keresztmetszetek azonosítása: Pontosan meghatározhatja, hogy a renderelési pipeline mely szakaszai fogyasztják a legtöbb erőforrást (CPU vagy GPU időt).
- Shaderek optimalizálása: Elemezze a shader teljesítményét, hogy azonosítsa azokat a területeket, ahol a kód egyszerűsíthető vagy optimalizálható.
- Draw callok csökkentése: Meghatározhatja, hogy a draw callok száma csökkenthető-e olyan technikákkal, mint az instancing vagy a batching.
- Textúrahasználat optimalizálása: Értékelje a textúra lekérési teljesítményt és azonosítsa a textúra méretének csökkentésére vagy a mipmapping használatára vonatkozó lehetőségeket.
- Memóriakezelés javítása: Figyelje a memóriahasználatot a memóriaszivárgások megelőzése és a hatékony erőforrás-elosztás biztosítása érdekében.
- Platformfüggetlen kompatibilitás: Megértheti, hogyan változik a teljesítmény a különböző eszközökön és böngészőkben.
Például, ha a feldolgozott vertexek számához képest magas a fragment shader meghívások száma, az arra utalhat, hogy túlságosan összetett geometriát rajzol, vagy hogy a fragment shader költséges számításokat végez. Ezzel szemben a magas draw call szám arra utalhat, hogy nem hatékonyan csoportosítja a renderelési parancsokat.
Hogyan gyűjtsünk WebGL pipeline statisztikákat
Sajnos a WebGL 1.0 nem biztosít közvetlen API-t a pipeline statisztikák eléréséhez. Azonban a WebGL 2.0 és a WebGL 1.0-ban elérhető kiterjesztések lehetőséget nyújtanak ezen értékes adatok gyűjtésére.
WebGL 2.0: A modern megközelítés
A WebGL 2.0 bevezet egy szabványosított mechanizmust a teljesítményszámlálók közvetlen lekérdezésére. Ez az előnyben részesített megközelítés, ha a célközönség elsősorban WebGL 2.0-kompatibilis böngészőket használ (a legtöbb modern böngésző támogatja a WebGL 2.0-t).
Itt egy alapvető vázlat a pipeline statisztikák gyűjtéséről WebGL 2.0-ban:
- WebGL 2.0 támogatás ellenőrzése: Ellenőrizze, hogy a felhasználó böngészője támogatja-e a WebGL 2.0-t.
- WebGL 2.0 kontextus létrehozása: Szerezzen be egy WebGL 2.0 renderelési kontextust a
getContext("webgl2")segítségével. - Az
EXT_disjoint_timer_query_webgl2kiterjesztés engedélyezése (ha szükséges): Bár általában elérhető, jó gyakorlat ellenőrizni és engedélyezni a kiterjesztést, biztosítva a kompatibilitást a különböző hardverek és illesztőprogramok között. Ezt általában a `gl.getExtension('EXT_disjoint_timer_query_webgl2')` segítségével lehet megtenni. - Időzítő lekérdezések létrehozása: Használja a
gl.createQuery()metódust lekérdezési objektumok létrehozásához. Minden lekérdezési objektum egy adott teljesítménymutatót fog követni. - Lekérdezések indítása és leállítása: Vegye körül a mérni kívánt renderelési kódot
gl.beginQuery()ésgl.endQuery()hívásokkal. Adja meg a cél lekérdezés típusát (pl.gl.TIME_ELAPSED). - Lekérdezési eredmények lekérése: A renderelési kód végrehajtása után használja a
gl.getQueryParameter()metódust az eredmények lekérésére a lekérdezési objektumokból. Meg kell várnia, amíg a lekérdezés elérhetővé válik, ami általában a képkocka befejezését igényli.
Példa (koncepcionális):
```javascript const canvas = document.getElementById('myCanvas'); const gl = canvas.getContext('webgl2'); if (!gl) { console.error('WebGL 2.0 not supported!'); // Visszalépés WebGL 1.0-ra vagy hibaüzenet megjelenítése. return; } // A kiterjesztés ellenőrzése és engedélyezése (ha szükséges) const ext = gl.getExtension('EXT_disjoint_timer_query_webgl2'); const timeElapsedQuery = gl.createQuery(); // A lekérdezés indítása gl.beginQuery(gl.TIME_ELAPSED, timeElapsedQuery); // Ide jön a renderelési kód renderScene(gl); // A lekérdezés befejezése gl.endQuery(gl.TIME_ELAPSED); // Az eredmények lekérése (aszinkron módon) setTimeout(() => { // Várakozás a képkocka befejezésére const available = gl.getQueryParameter(timeElapsedQuery, gl.QUERY_RESULT_AVAILABLE); if (available) { const elapsedTime = gl.getQueryParameter(timeElapsedQuery, gl.QUERY_RESULT); console.log('Time elapsed:', elapsedTime / 1000000, 'ms'); // Nanoszekundumok átváltása ezredmásodpercre } else { console.warn('Query result not available yet.'); } }, 0); ```Fontos megfontolások a WebGL 2.0-hoz:
- Aszinkron jelleg: A lekérdezési eredmények lekérése aszinkron művelet. Általában várni kell a következő képkockára vagy egy későbbi renderelési menetre, hogy biztosítsa a lekérdezés befejeződését. Ez gyakran a `setTimeout` vagy a requestAnimationFrame használatát jelenti az eredmény lekérésének ütemezéséhez.
- Disjoint timer lekérdezések: Az `EXT_disjoint_timer_query_webgl2` kiterjesztés kulcsfontosságú a pontos időzítő lekérdezésekhez. Megold egy lehetséges problémát, ahol a GPU időzítője eltérhet a CPU időzítőjétől, ami pontatlan mérésekhez vezet.
- Elérhető lekérdezések: Bár a `gl.TIME_ELAPSED` egy gyakori lekérdezés, más lekérdezések is elérhetők lehetnek a hardvertől és az illesztőprogramtól függően. Tekintse meg a WebGL 2.0 specifikációt és a GPU dokumentációját a teljes listaért.
WebGL 1.0: A kiterjesztések segítsége
Bár a WebGL 1.0 nem rendelkezik beépített mechanizmussal a pipeline statisztikák gyűjtésére, számos kiterjesztés nyújt hasonló funkcionalitást. A leggyakrabban használt kiterjesztések a következők:
EXT_disjoint_timer_query: Ez a kiterjesztés, hasonlóan a WebGL 2.0-s megfelelőjéhez, lehetővé teszi a renderelési műveletek során eltelt idő mérését. Ez egy értékes eszköz a teljesítmény szűk keresztmetszeteinek azonosítására.- Gyártóspecifikus kiterjesztések: Néhány GPU gyártó saját kiterjesztéseket kínál, amelyek részletesebb teljesítményszámlálókat biztosítanak. Ezek a kiterjesztések általában a gyártó hardverére specifikusak, és nem feltétlenül érhetők el minden eszközön. Példák erre az NVIDIA `NV_timer_query` és az AMD `AMD_performance_monitor` kiterjesztései.
Az EXT_disjoint_timer_query használata WebGL 1.0-ban:
Az EXT_disjoint_timer_query használatának folyamata WebGL 1.0-ban hasonló a WebGL 2.0-hoz:
- A kiterjesztés ellenőrzése: Ellenőrizze, hogy az
EXT_disjoint_timer_querykiterjesztést támogatja-e a felhasználó böngészője. - A kiterjesztés engedélyezése: Szerezzen hivatkozást a kiterjesztésre a
gl.getExtension("EXT_disjoint_timer_query")segítségével. - Időzítő lekérdezések létrehozása: Használja az
ext.createQueryEXT()metódust lekérdezési objektumok létrehozásához. - Lekérdezések indítása és leállítása: Vegye körül a renderelési kódot az
ext.beginQueryEXT()ésext.endQueryEXT()hívásokkal. Adja meg a cél lekérdezés típusát (ext.TIME_ELAPSED_EXT). - Lekérdezési eredmények lekérése: Használja az
ext.getQueryObjectEXT()metódust az eredmények lekérésére a lekérdezési objektumokból.
Példa (koncepcionális):
```javascript const canvas = document.getElementById('myCanvas'); const gl = canvas.getContext('webgl'); if (!gl) { console.error('WebGL 1.0 not supported!'); return; } const ext = gl.getExtension('EXT_disjoint_timer_query'); if (!ext) { console.error('EXT_disjoint_timer_query not supported!'); return; } const timeElapsedQuery = ext.createQueryEXT(); // A lekérdezés indítása ext.beginQueryEXT(ext.TIME_ELAPSED_EXT, timeElapsedQuery); // Ide jön a renderelési kód renderScene(gl); // A lekérdezés befejezése ext.endQueryEXT(ext.TIME_ELAPSED_EXT); // Az eredmények lekérése (aszinkron módon) setTimeout(() => { const available = ext.getQueryObjectEXT(timeElapsedQuery, ext.QUERY_RESULT_AVAILABLE_EXT); if (available) { const elapsedTime = ext.getQueryObjectEXT(timeElapsedQuery, ext.QUERY_RESULT_EXT); console.log('Time elapsed:', elapsedTime / 1000000, 'ms'); // Nanoszekundumok átváltása ezredmásodpercre } else { console.warn('Query result not available yet.'); } }, 0); ```Kihívások a WebGL 1.0 kiterjesztésekkel:
- Kiterjesztés elérhetősége: Nem minden böngésző és eszköz támogatja az
EXT_disjoint_timer_querykiterjesztést, ezért használat előtt ellenőrizni kell annak elérhetőségét. - Gyártóspecifikus változatok: A gyártóspecifikus kiterjesztések, bár részletesebb statisztikákat kínálnak, nem hordozhatók a különböző GPU-k között.
- Pontossági korlátok: Az időzítő lekérdezések pontossága korlátozott lehet, különösen a régebbi hardvereken.
Alternatív technikák: Manuális mérés
Ha nem támaszkodhat a WebGL 2.0-ra vagy a kiterjesztésekre, akkor manuális méréshez folyamodhat. Ez magában foglalja az időzítő kód beillesztését a JavaScript kódba, hogy megmérje az egyes műveletek időtartamát.
Példa:
```javascript const startTime = performance.now(); // Ide jön a renderelési kód renderScene(gl); const endTime = performance.now(); const elapsedTime = endTime - startTime; console.log('Time elapsed:', elapsedTime, 'ms'); ```A manuális mérés korlátai:
- Beavatkozó jellegű: A manuális mérés zsúfolttá teheti a kódot, és megnehezítheti a karbantartást.
- Kevésbé precíz: A manuális időzítés pontosságát befolyásolhatja a JavaScript overhead és egyéb tényezők.
- Korlátozott hatókör: A manuális mérés általában csak a JavaScript kód időtartamát méri, nem a tényleges GPU végrehajtási időt.
A WebGL pipeline statisztikák értelmezése
Miután összegyűjtötte a WebGL pipeline statisztikákat, a következő lépés a jelentésük értelmezése és felhasználásuk a teljesítmény szűk keresztmetszeteinek azonosítására. Íme néhány gyakori metrika és azok következményei:
- Eltelt idő: A képkocka vagy egy adott renderelési menet renderelésére fordított teljes idő. A magas eltelt idő teljesítmény szűk keresztmetszetre utal valahol a pipeline-ban.
- Draw callok: A kiadott egyedi renderelési parancsok száma. A magas draw call szám CPU overhead-hez vezethet, mivel minden draw call kommunikációt igényel a CPU és a GPU között. Fontolja meg olyan technikák használatát, mint az instancing vagy a batching a draw callok számának csökkentésére.
- Vertex feldolgozási idő: A vertex shaderben a vertexek feldolgozására fordított idő. A magas vertex feldolgozási idő arra utalhat, hogy a vertex shader túl bonyolult, vagy túl sok vertexet dolgoz fel.
- Fragment feldolgozási idő: A fragment shaderben a fragmentek feldolgozására fordított idő. A magas fragment feldolgozási idő arra utalhat, hogy a fragment shader túl bonyolult, vagy túl sok pixelt renderel (overdraw).
- Textúra lekérések: Az elvégzett textúra lekérések száma. A magas számú textúra lekérés arra utalhat, hogy túl sok textúrát használ, vagy a textúra cache nem hatékony.
- Memóriahasználat: A textúrákra, pufferekre és egyéb erőforrásokra lefoglalt memória mennyisége. A túlzott memóriahasználat teljesítményproblémákhoz, sőt az alkalmazás összeomlásához is vezethet.
Példa forgatókönyv: Magas fragment feldolgozási idő
Tegyük fel, hogy magas fragment feldolgozási időt tapasztal a WebGL alkalmazásában. Ennek több oka is lehet:
- Komplex fragment shader: Lehet, hogy a fragment shader költséges számításokat végez, például komplex világítási vagy utófeldolgozási effekteket.
- Overdraw (felülrajzolás): Lehet, hogy ugyanazokat a pixeleket többször is rendereli, ami felesleges fragment shader meghívásokhoz vezet. Ez előfordulhat átlátszó objektumok renderelésekor vagy amikor az objektumok átfedik egymást.
- Magas pixelsűrűség: Lehet, hogy nagy felbontású képernyőre renderel, ami növeli a feldolgozandó pixelek számát.
A probléma megoldásához a következőket próbálhatja meg:
- Optimalizálja a fragment shadert: Egyszerűsítse a kódot a fragment shaderben, csökkentse a számítások számát, vagy használjon keresőtáblákat (look-up tables) az eredmények előzetes kiszámításához.
- Csökkentse az overdraw-t: Használjon olyan technikákat, mint a mélységi tesztelés (depth testing), a korai Z-culling vagy az alfa-keverés (alpha blending) a pixelek renderelési számának csökkentésére.
- Csökkentse a renderelési felbontást: Rendereljen alacsonyabb felbontásra, majd skálázza fel a képet a célfelbontásra.
Gyakorlati példák és esettanulmányok
Íme néhány gyakorlati példa arra, hogyan használhatók a WebGL pipeline statisztikák valós alkalmazások optimalizálására:
- Játékok: Egy WebGL játékban a pipeline statisztikák segítségével azonosíthatók a teljesítmény szűk keresztmetszetei a komplex jelenetekben. Például, ha a fragment feldolgozási idő magas, a fejlesztők optimalizálhatják a világítási shadereket, vagy csökkenthetik a fények számát a jelenetben. Vizsgálhatják továbbá olyan technikák használatát, mint a részletességi szint (LOD) a távoli objektumok összetettségének csökkentésére.
- Adatvizualizáció: Egy WebGL alapú adatvizualizációs eszközben a pipeline statisztikák felhasználhatók nagy adathalmazok renderelésének optimalizálására. Például, ha a vertex feldolgozási idő magas, a fejlesztők egyszerűsíthetik a geometriát, vagy használhatnak instancing-et több adatpont egyetlen draw call-al történő rendereléséhez.
- Termékkonfigurátorok: Egy interaktív 3D termékkonfigurátor esetében a textúra lekérések figyelése segíthet a nagy felbontású textúrák betöltésének és renderelésének optimalizálásában. Ha a textúra lekérések száma magas, a fejlesztők mipmapping-et vagy textúratömörítést használhatnak a textúra méretének csökkentésére.
- Építészeti vizualizáció: Interaktív építészeti bejárások készítésekor a draw callok csökkentése és az árnyék renderelés optimalizálása kulcsfontosságú a zökkenőmentes teljesítményhez. A pipeline statisztikák segíthetnek azonosítani a renderelési idő legnagyobb tényezőit és irányítani az optimalizálási erőfeszítéseket. Például olyan technikák implementálása, mint az occlusion culling (eltakarás alapú kiszűrés), drasztikusan csökkentheti a kirajzolt objektumok számát a kamera szemszögéből való láthatóságuk alapján.
Esettanulmány: Egy komplex 3D modellnézegető optimalizálása
Egy cég WebGL alapú nézegetőt fejlesztett komplex ipari berendezések 3D modelljeihez. A nézegető kezdeti verziója gyenge teljesítménytől szenvedett, különösen az alacsonyabb kategóriás eszközökön. A WebGL pipeline statisztikák gyűjtésével a fejlesztők a következő szűk keresztmetszeteket azonosították:
- Magas draw call szám: A modell több ezer különálló részből állt, mindegyiket külön draw call-al renderelték.
- Komplex fragment shaderek: A modell fizikailag alapú renderelést (PBR) használó shadereket alkalmazott komplex világítási számításokkal.
- Nagy felbontású textúrák: A modell nagy felbontású textúrákat használt a finom részletek rögzítésére.
Ezeknek a szűk keresztmetszeteknek a kezelésére a fejlesztők a következő optimalizálásokat hajtották végre:
- Draw call csoportosítás (batching): A modell több részét egyetlen draw call-ba csoportosították, csökkentve a CPU overhead-et.
- Shader optimalizálás: Egyszerűsítették a PBR shadereket, csökkentették a számítások számát, és ahol lehetséges volt, keresőtáblákat használtak.
- Textúratömörítés: Textúratömörítést alkalmaztak a textúra méretének csökkentésére és a textúra lekérési teljesítmény javítására.
Ezen optimalizálások eredményeként a 3D modellnézegető teljesítménye jelentősen javult, különösen az alacsonyabb kategóriás eszközökön. A képkockasebesség nőtt, és az alkalmazás reszponzívabbá vált.
Bevált gyakorlatok a WebGL teljesítmény optimalizálására
A pipeline statisztikák gyűjtése és elemzése mellett íme néhány általános bevált gyakorlat a WebGL teljesítmény optimalizálására:
- Minimalizálja a draw callokat: Használjon instancing-et, batching-et vagy más technikákat a draw callok számának csökkentésére.
- Optimalizálja a shadereket: Egyszerűsítse a shader kódot, csökkentse a számítások számát, és ahol lehetséges, használjon keresőtáblákat.
- Használjon textúratömörítést: Tömörítse a textúrákat a méretük csökkentése és a textúra lekérési teljesítmény javítása érdekében.
- Használjon mipmapping-et: Hozzon létre mipmapeket a textúrákhoz a renderelési minőség és teljesítmény javítása érdekében, különösen a távoli objektumok esetében.
- Csökkentse az overdraw-t: Használjon olyan technikákat, mint a mélységi tesztelés, a korai Z-culling vagy az alfa-keverés a pixelek renderelési számának csökkentésére.
- Használjon részletességi szintet (LOD): Használjon különböző részletességi szinteket az objektumokhoz a kamerától való távolságuk alapján.
- Szűrje ki a láthatatlan objektumokat: Akadályozza meg a nem látható objektumok renderelését.
- Optimalizálja a memóriahasználatot: Kerülje a memóriaszivárgásokat és biztosítsa a hatékony erőforrás-elosztást.
- Profilozza az alkalmazását: Használjon böngésző fejlesztői eszközöket vagy speciális profilozó eszközöket a teljesítmény szűk keresztmetszeteinek azonosítására.
- Teszteljen különböző eszközökön: Tesztelje az alkalmazását különféle eszközökön, hogy biztosítsa a jó teljesítményt különböző hardverkonfigurációkon. Vegye figyelembe a különböző képernyőfelbontásokat és pixelsűrűségeket, különösen mobil platformok célzása esetén.
Eszközök a WebGL profilozásához és hibakereséséhez
Számos eszköz segítheti a WebGL profilozását és hibakeresését:
- Böngésző fejlesztői eszközök: A legtöbb modern böngésző (Chrome, Firefox, Safari, Edge) hatékony fejlesztői eszközöket tartalmaz, amelyek lehetővé teszik a WebGL alkalmazások profilozását, a shader kód vizsgálatát és a GPU tevékenységének figyelését. Ezek az eszközök gyakran részletes információkat nyújtanak a draw callokról, a textúrahasználatról és a memóriafogyasztásról.
- WebGL Inspectorok: Speciális WebGL inspectorok, mint például a Spector.js és a RenderDoc, mélyebb betekintést nyújtanak a renderelési pipeline-ba. Ezek az eszközök lehetővé teszik az egyes képkockák rögzítését, a draw callokon való végiglépkedést és a WebGL objektumok állapotának vizsgálatát.
- GPU Profilerek: A GPU gyártók profilozó eszközöket kínálnak, amelyek részletes információkat nyújtanak a GPU teljesítményéről. Ezek az eszközök segíthetnek azonosítani a shaderekben lévő szűk keresztmetszeteket és optimalizálni a kódot specifikus hardverarchitektúrákhoz. Példák erre az NVIDIA Nsight és az AMD Radeon GPU Profiler.
- JavaScript Profilerek: Az általános JavaScript profilerek segíthetnek azonosítani a JavaScript kódban lévő teljesítmény szűk keresztmetszeteket, amelyek közvetve befolyásolhatják a WebGL teljesítményét.
Összegzés
A WebGL pipeline statisztikák gyűjtése elengedhetetlen technika a WebGL alkalmazások teljesítményének optimalizálásához. Annak megértésével, hogyan lehet hozzáférni és értelmezni ezeket a metrikákat, a fejlesztők azonosíthatják a teljesítmény szűk keresztmetszeteit, optimalizálhatják a shadereket, csökkenthetik a draw callokat és javíthatják a memóriakezelést. Akár játékot, adatvizualizációs eszközt vagy interaktív termékkonfigurátort készít, a WebGL pipeline statisztikák elsajátítása képessé teszi Önt arra, hogy zökkenőmentes, hatékony és lebilincselő web alapú 3D élményeket hozzon létre egy globális közönség számára.
Ne feledje, hogy a WebGL teljesítménye egy folyamatosan fejlődő terület, és a legjobb optimalizálási stratégiák az alkalmazás specifikus jellemzőitől és a célhardvertől függenek. A folyamatos profilozás, kísérletezés és a megközelítés adaptálása kulcsfontosságú lesz az optimális teljesítmény eléréséhez.