WebGL-i renderdustoru statistika kogumine: renderdusjõudluse mõõdikute avamine

Veebipõhise 3D-graafika maailmas on jõudlus esmatähtis. Olenemata sellest, kas loote keerulist mängu, andmete visualiseerimise tööriista või interaktiivset tootekonfiguraatorit, on sujuva ja tõhusa renderdamise tagamine positiivse kasutajakogemuse jaoks ülioluline. WebGL, JavaScripti API interaktiivse 2D- ja 3D-graafika renderdamiseks mis tahes ühilduvas veebibrauseris ilma pistikprogramme kasutamata, pakub võimsaid võimalusi, kuid selle jõudlusaspektide valdamine nõuab renderdustoru ja seda mõjutavate tegurite sügavat mõistmist.

Üks väärtuslikumaid tööriistu WebGL-rakenduste optimeerimiseks on võime koguda ja analüüsida renderdustoru statistikat. See statistika pakub ülevaadet renderdusprotsessi erinevatest aspektidest, võimaldades arendajatel tuvastada kitsaskohti ja parendusvaldkondi. See artikkel süveneb WebGL-i renderdustoru statistika kogumise peensustesse, selgitades, kuidas nendele mõõdikutele juurde pääseda, nende tähendust tõlgendada ja neid oma WebGL-rakenduste jõudluse parandamiseks kasutada.

Mis on WebGL-i renderdustoru statistika?

WebGL-i renderdustoru statistika on loendurite kogum, mis jälgib erinevaid toiminguid renderdustorus. Renderdustoru on etappide jada, mis muudab 3D-mudelid ja tekstuurid lõplikuks 2D-pildiks, mida ekraanil kuvatakse. Iga etapp hõlmab arvutusi ja andmeedastusi ning iga etapi töökoormuse mõistmine võib paljastada jõudluspiiranguid.

See statistika annab teavet:

• Tiputöötlus (vertex processing): Töödeldud tippude arv, tipuvarjutaja (vertex shader) väljakutsed, tipuatribuutide (vertex attribute) lugemised.
• Primitiivide koostamine (primitive assembly): Koostatud primitiivide (kolmnurgad, jooned, punktid) arv.
• Rastrerimine (rasterization): Genereeritud fragmentide (pikslite) arv, fragmendivarjutaja (fragment shader) väljakutsed.
• Pikslioperatsioonid: Kaadripuhvrisse kirjutatud pikslite arv, sooritatud sügavus- ja šabloonitestid (depth and stencil tests).
• Tekstuurioperatsioonid: Tekstuurilugemiste arv, tekstuuri vahemälu möödalasud (texture cache misses).
• Mälukasutus: Tekstuuride, puhvrite ja muude ressursside jaoks eraldatud mälu maht.
• Joonistuskutsed (draw calls): Väljastatud individuaalsete renderduskäskude arv.

Seda statistikat jälgides saate tervikliku ülevaate renderdustoru käitumisest ja tuvastada valdkonnad, kus ressursse tarbitakse liigselt. See teave on ülioluline teadlike otsuste tegemiseks optimeerimisstrateegiate osas.

Miks koguda WebGL-i renderdustoru statistikat?

WebGL-i renderdustoru statistika kogumine pakub mitmeid eeliseid:

• Jõudluse kitsaskohtade tuvastamine: Tehke kindlaks need renderdustoru etapid, mis tarbivad kõige rohkem ressursse (protsessori või graafikaprotsessori aega).
• Varjutajate (shader) optimeerimine: Analüüsige varjutajate jõudlust, et tuvastada valdkonnad, kus koodi saab lihtsustada või optimeerida.
• Joonistuskutsete vähendamine: Tehke kindlaks, kas joonistuskutsete arvu saab vähendada selliste tehnikate abil nagu instantsimine (instancing) või pakettimine (batching).
• Tekstuurikasutuse optimeerimine: Hinnake tekstuurilugemise jõudlust ja tuvastage võimalused tekstuuri suuruse vähendamiseks või mipmappingu kasutamiseks.
• Mäluhalduse parandamine: Jälgige mälukasutust, et vältida mälulekkeid ja tagada tõhus ressursside jaotamine.
• Platvormideülene ühilduvus: Saage aru, kuidas jõudlus erineb erinevates seadmetes ja brauserites.

Näiteks, kui märkate suurt fragmendivarjutaja väljakutsete arvu võrreldes töödeldud tippude arvuga, võib see viidata sellele, et joonistate liiga keerulist geomeetriat või et teie fragmendivarjutaja teostab kulukaid arvutusi. Vastupidi, suur joonistuskutsete arv võib viidata sellele, et te ei paketi renderduskäske tõhusalt.

Kuidas koguda WebGL-i renderdustoru statistikat

Kahjuks ei paku WebGL 1.0 otsest API-d renderdustoru statistikale juurdepääsuks. Siiski pakuvad WebGL 2.0 ja WebGL 1.0-s saadaolevad laiendused võimalusi selle väärtusliku teabe kogumiseks.

WebGL 2.0: Kaasaegne lähenemine

WebGL 2.0 tutvustab standardiseeritud mehhanismi jõudlusloendurite otse pärimiseks. See on eelistatud lähenemine, kui teie sihtrühm kasutab peamiselt WebGL 2.0-ga ühilduvaid brausereid (enamik kaasaegseid brausereid toetab WebGL 2.0).

Siin on põhiline ülevaade, kuidas koguda renderdustoru statistikat WebGL 2.0-s:

1. Kontrollige WebGL 2.0 tuge: Veenduge, et kasutaja brauser toetab WebGL 2.0.
2. Looge WebGL 2.0 kontekst: Hankige WebGL 2.0 renderduskontekst kasutades getContext("webgl2").
3. Lubage EXT_disjoint_timer_query_webgl2 laiendus (vajadusel): Kuigi üldiselt saadaval, on hea tava kontrollida ja lubada laiendust, tagades ühilduvuse erineva riistvara ja draiveritega. Tavaliselt tehakse seda kasutades `gl.getExtension('EXT_disjoint_timer_query_webgl2')`.
4. Looge ajastuspäringuid (timer queries): Kasutage gl.createQuery() meetodit päringuobjektide loomiseks. Iga päringuobjekt jälgib konkreetset jõudlusmõõdikut.
5. Alustage ja lõpetage päringuid: Ümbritsege renderduskood, mida soovite mõõta, gl.beginQuery() ja gl.endQuery() kutsetega. Määrake sihtpäringu tüüp (nt gl.TIME_ELAPSED).
6. Hankige päringu tulemused: Pärast renderduskoodi täitmist kasutage gl.getQueryParameter() meetodit päringuobjektide tulemuste hankimiseks. Peate ootama, kuni päring muutub kättesaadavaks, mis tavaliselt nõuab kaadri valmimise ootamist.

Näide (kontseptuaalne):

```javascript const canvas = document.getElementById('myCanvas'); const gl = canvas.getContext('webgl2'); if (!gl) { console.error('WebGL 2.0 not supported!'); // Varulahendus WebGL 1.0-le või vea kuvamine. return; } // Kontrolli ja luba laiendus (vajadusel) const ext = gl.getExtension('EXT_disjoint_timer_query_webgl2'); const timeElapsedQuery = gl.createQuery(); // Alusta päringut gl.beginQuery(gl.TIME_ELAPSED, timeElapsedQuery); // Teie renderduskood siin renderScene(gl); // Lõpeta päring gl.endQuery(gl.TIME_ELAPSED); // Hangi tulemused (asünkroonselt) setTimeout(() => { // Oodake kaadri valmimist const available = gl.getQueryParameter(timeElapsedQuery, gl.QUERY_RESULT_AVAILABLE); if (available) { const elapsedTime = gl.getQueryParameter(timeElapsedQuery, gl.QUERY_RESULT); console.log('Kulunud aeg:', elapsedTime / 1000000, 'ms'); // Teisenda nanosekundid millisekunditeks } else { console.warn('Päringu tulemus pole veel saadaval.'); } }, 0); ```

Olulised kaalutlused WebGL 2.0 puhul:

• Asünkroonne olemus: Päringu tulemuste hankimine on asünkroonne toiming. Tavaliselt peate ootama järgmist kaadrit või järgnevat renderduskäiku, et tagada päringu lõpuleviimine. See hõlmab sageli `setTimeout` või requestAnimationFrame kasutamist tulemuste hankimise ajastamiseks.
• Katkestatud ajastuspäringud (disjoint timer queries): EXT_disjoint_timer_query_webgl2 laiendus on täpsete ajastuspäringute jaoks ülioluline. See lahendab potentsiaalse probleemi, kus GPU taimer võib olla protsessori taimerist lahus, mis viib ebatäpsete mõõtmisteni.
• Saadaolevad päringud: Kuigi gl.TIME_ELAPSED on levinud päring, võivad olenevalt riistvarast ja draiverist olla saadaval ka muud päringud. Täieliku loendi saamiseks tutvuge WebGL 2.0 spetsifikatsiooni ja oma GPU dokumentatsiooniga.

WebGL 1.0: Laiendused appi

Kuigi WebGL 1.0-l puudub sisseehitatud mehhanism renderdustoru statistika kogumiseks, pakuvad mitmed laiendused sarnast funktsionaalsust. Kõige sagedamini kasutatavad laiendused on:

• EXT_disjoint_timer_query: See laiendus, sarnaselt oma WebGL 2.0 vastele, võimaldab mõõta renderdusoperatsioonide ajal kulunud aega. See on väärtuslik tööriist jõudluse kitsaskohtade tuvastamiseks.
• Tootjaspetsiifilised laiendused: Mõned GPU tootjad pakuvad oma laiendusi, mis pakuvad üksikasjalikumaid jõudlusloendureid. Need laiendused on tavaliselt spetsiifilised tootja riistvarale ja ei pruugi olla kõigis seadmetes saadaval. Näideteks on NVIDIA `NV_timer_query` ja AMD `AMD_performance_monitor`.

EXT_disjoint_timer_query kasutamine WebGL 1.0-s:

EXT_disjoint_timer_query kasutamise protsess WebGL 1.0-s on sarnane WebGL 2.0-ga:

1. Kontrollige laienduse olemasolu: Veenduge, et kasutaja brauser toetab EXT_disjoint_timer_query laiendust.
2. Lubage laiendus: Hankige viide laiendusele, kasutades gl.getExtension("EXT_disjoint_timer_query").
3. Looge ajastuspäringuid: Kasutage ext.createQueryEXT() meetodit päringuobjektide loomiseks.
4. Alustage ja lõpetage päringuid: Ümbritsege renderduskood ext.beginQueryEXT() ja ext.endQueryEXT() kutsetega. Määrake sihtpäringu tüüp (ext.TIME_ELAPSED_EXT).
5. Hankige päringu tulemused: Kasutage ext.getQueryObjectEXT() meetodit päringuobjektide tulemuste hankimiseks.

Näide (kontseptuaalne):

```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(); // Alusta päringut ext.beginQueryEXT(ext.TIME_ELAPSED_EXT, timeElapsedQuery); // Teie renderduskood siin renderScene(gl); // Lõpeta päring ext.endQueryEXT(ext.TIME_ELAPSED_EXT); // Hangi tulemused (asünkroonselt) setTimeout(() => { const available = ext.getQueryObjectEXT(timeElapsedQuery, ext.QUERY_RESULT_AVAILABLE_EXT); if (available) { const elapsedTime = ext.getQueryObjectEXT(timeElapsedQuery, ext.QUERY_RESULT_EXT); console.log('Kulunud aeg:', elapsedTime / 1000000, 'ms'); // Teisenda nanosekundid millisekunditeks } else { console.warn('Päringu tulemus pole veel saadaval.'); } }, 0); ```

Väljakutsed WebGL 1.0 laiendustega:

• Laienduse saadavus: Kõik brauserid ja seadmed ei toeta EXT_disjoint_timer_query laiendust, seega peate enne selle kasutamist kontrollima selle saadavust.
• Tootjaspetsiifilised variatsioonid: Tootjaspetsiifilised laiendused, kuigi pakuvad üksikasjalikumat statistikat, ei ole erinevate GPU-de vahel ülekantavad.
• Täpsuse piirangud: Ajastuspäringutel võib olla täpsuse piiranguid, eriti vanemal riistvaral.

Alternatiivsed tehnikad: käsitsi instrumenteerimine

Kui te ei saa tugineda WebGL 2.0-le või laiendustele, võite kasutada käsitsi instrumenteerimist. See hõlmab ajastuskoodi lisamist oma JavaScripti koodi, et mõõta konkreetsete toimingute kestust.

Näide:

```javascript const startTime = performance.now(); // Teie renderduskood siin renderScene(gl); const endTime = performance.now(); const elapsedTime = endTime - startTime; console.log('Kulunud aeg:', elapsedTime, 'ms'); ```

Käsitsi instrumenteerimise piirangud:

• Sissetungiv: Käsitsi instrumenteerimine võib teie koodi segamini ajada ja muuta selle hooldamise keerulisemaks.
• Vähem täpne: Käsitsi ajastamise täpsust võivad mõjutada JavaScripti lisakulu ja muud tegurid.
• Piiratud ulatus: Käsitsi instrumenteerimine mõõdab tavaliselt ainult JavaScripti koodi kestust, mitte tegelikku GPU täitmisaega.

WebGL-i renderdustoru statistika tõlgendamine

Kui olete kogunud WebGL-i renderdustoru statistikat, on järgmine samm selle tähenduse tõlgendamine ja selle kasutamine jõudluse kitsaskohtade tuvastamiseks. Siin on mõned levinud mõõdikud ja nende tähendus:

• Kulunud aeg: Kogu aeg, mis kulub kaadri või konkreetse renderduskäigu renderdamiseks. Suur kulunud aeg viitab jõudluse kitsaskohale kuskil renderdustorus.
• Joonistuskutsed: Väljastatud individuaalsete renderduskäskude arv. Suur joonistuskutsete arv võib põhjustada protsessori lisakulu, kuna iga joonistuskutse nõuab suhtlust protsessori ja GPU vahel. Kaaluge tehnikate, nagu instantsimine või pakettimine, kasutamist joonistuskutsete arvu vähendamiseks.
• Tiputöötluse aeg: Aeg, mis kulub tippude töötlemiseks tipuvarjutajas. Suur tiputöötluse aeg võib viidata sellele, et teie tipuvarjutaja on liiga keeruline või et töötlete liiga palju tippe.
• Fragmenditöötluse aeg: Aeg, mis kulub fragmentide töötlemiseks fragmendivarjutajas. Suur fragmenditöötluse aeg võib viidata sellele, et teie fragmendivarjutaja on liiga keeruline või et renderdate liiga palju piksleid (ülekatmine, overdraw).
• Tekstuurilugemised: Teostatud tekstuurilugemiste arv. Suur tekstuurilugemiste arv võib viidata sellele, et kasutate liiga palju tekstuure või et teie tekstuuri vahemälu ei ole tõhus.
• Mälukasutus: Tekstuuride, puhvrite ja muude ressursside jaoks eraldatud mälu maht. Liigne mälukasutus võib põhjustada jõudlusprobleeme ja isegi rakenduse krahhe.

Näidisstsenaarium: suur fragmenditöötluse aeg

Oletame, et märkate oma WebGL-rakenduses suurt fragmenditöötluse aega. See võib olla tingitud mitmest tegurist:

• Keeruline fragmendivarjutaja: Teie fragmendivarjutaja võib teostada kulukaid arvutusi, nagu keerulised valgusefektid või järeltöötlusefektid.
• Ülekatmine (overdraw): Te võite renderdada samu piksleid mitu korda, mis põhjustab tarbetuid fragmendivarjutaja väljakutseid. See võib juhtuda läbipaistvate objektide renderdamisel või kui objektid kattuvad.
• Kõrge pikslitihedus: Te võite renderdada kõrge eraldusvõimega ekraanile, mis suurendab töödeldavate pikslite arvu.

Selle probleemi lahendamiseks võiksite proovida järgmist:

• Optimeerige oma fragmendivarjutajat: Lihtsustage oma fragmendivarjutaja koodi, vähendage arvutuste arvu või kasutage otsingutabeleid tulemuste eelarvutamiseks.
• Vähendage ülekatmist: Kasutage tehnikaid nagu sügavustestimine, varajane Z-kärpimine (early-Z culling) või alfasegamine (alpha blending), et vähendada iga piksli renderdamise kordade arvu.
• Vähendage renderdamise eraldusvõimet: Renderdage madalama eraldusvõimega ja seejärel suurendage pilt sihtresolutsioonile.

Praktilised näited ja juhtumiuuringud

Siin on mõned praktilised näited, kuidas WebGL-i renderdustoru statistikat saab kasutada reaalsete rakenduste optimeerimiseks:

• Mängud: WebGL-mängus saab renderdustoru statistikat kasutada jõudluse kitsaskohtade tuvastamiseks keerulistes stseenides. Näiteks, kui fragmenditöötluse aeg on kõrge, saavad arendajad optimeerida valgustusvarjutajaid või vähendada stseenis olevate valgusallikate arvu. Samuti võivad nad uurida tehnikate, nagu detailsusaste (LOD), kasutamist kaugete objektide keerukuse vähendamiseks.
• Andmete visualiseerimine: WebGL-põhises andmete visualiseerimise tööriistas saab renderdustoru statistikat kasutada suurte andmekogumite renderdamise optimeerimiseks. Näiteks, kui tiputöötluse aeg on kõrge, saavad arendajad lihtsustada geomeetriat või kasutada instantsimist mitme andmepunkti renderdamiseks ühe joonistuskutsega.
• Tootekonfiguraatorid: Interaktiivse 3D-tootekonfiguraatori puhul aitab tekstuurilugemiste jälgimine optimeerida kõrge eraldusvõimega tekstuuride laadimist ja renderdamist. Kui tekstuurilugemiste arv on kõrge, saavad arendajad kasutada mipmappingut või tekstuuri tihendamist tekstuuri suuruse vähendamiseks.
• Arhitektuurne visualiseerimine: Interaktiivsete arhitektuursete läbikäikude loomisel on sujuva jõudluse võtmeks joonistuskutsete vähendamine ja varjude renderdamise optimeerimine. Renderdustoru statistika aitab tuvastada suurimaid renderdusaja mõjutajaid ja suunata optimeerimispüüdlusi. Näiteks võib oklusioonkärpimise (occlusion culling) tehnikate rakendamine drastiliselt vähendada joonistatud objektide arvu, lähtudes nende nähtavusest kaamerast.

Juhtumiuuring: keerulise 3D-mudeli vaaturi optimeerimine

Üks ettevõte arendas WebGL-põhise vaaturi tööstusseadmete keeruliste 3D-mudelite jaoks. Vaaturi esialgne versioon kannatas halva jõudluse all, eriti madalama klassi seadmetes. Kogudes WebGL-i renderdustoru statistikat, tuvastasid arendajad järgmised kitsaskohad:

• Suur joonistuskutsete arv: Mudel koosnes tuhandetest üksikutest osadest, millest igaüks renderdati eraldi joonistuskutsega.
• Keerulised fragmendivarjutajad: Mudel kasutas füüsikaliselt põhistatud renderdamise (PBR) varjutajaid keeruliste valgustusarvutustega.
• Kõrge eraldusvõimega tekstuurid: Mudel kasutas peente detailide jäädvustamiseks kõrge eraldusvõimega tekstuure.

Nende kitsaskohtade lahendamiseks rakendasid arendajad järgmisi optimeerimisi:

• Joonistuskutsete pakettimine: Nad pakettisid mitu mudeli osa üheks joonistuskutseks, vähendades protsessori lisakulu.
• Varjutajate optimeerimine: Nad lihtsustasid PBR-varjutajaid, vähendades arvutuste arvu ja kasutades võimaluse korral otsingutabeleid.
• Tekstuuri tihendamine: Nad kasutasid tekstuuri tihendamist, et vähendada tekstuuri suurust ja parandada tekstuurilugemise jõudlust.

Nende optimeerimiste tulemusena paranes 3D-mudeli vaaturi jõudlus märkimisväärselt, eriti madalama klassi seadmetes. Kaadrisagedus tõusis ja rakendus muutus reageerimisvõimelisemaks.

WebGL-i jõudluse optimeerimise parimad praktikad

Lisaks renderdustoru statistika kogumisele ja analüüsimisele on siin mõned üldised parimad praktikad WebGL-i jõudluse optimeerimiseks:

• Minimeerige joonistuskutsed: Kasutage instantsimist, pakettimist või muid tehnikaid joonistuskutsete arvu vähendamiseks.
• Optimeerige varjutajaid: Lihtsustage varjutajate koodi, vähendage arvutuste arvu ja kasutage võimaluse korral otsingutabeleid.
• Kasutage tekstuuri tihendamist: Tihendage tekstuure, et vähendada nende suurust ja parandada tekstuurilugemise jõudlust.
• Kasutage mipmappingut: Genereerige tekstuuridele mipmap'e, et parandada renderduskvaliteeti ja jõudlust, eriti kaugete objektide puhul.
• Vähendage ülekatmist: Kasutage tehnikaid nagu sügavustestimine, varajane Z-kärpimine või alfasegamine, et vähendada iga piksli renderdamise kordade arvu.
• Kasutage detailsusastet (LOD): Kasutage objektide jaoks erinevaid detailsusastmeid sõltuvalt nende kaugusest kaamerast.
• Kärpige nähtamatuid objekte: Vältige objektide renderdamist, mis ei ole nähtavad.
• Optimeerige mälukasutust: Vältige mälulekkeid ja tagage tõhus ressursside jaotamine.
• Profileerige oma rakendust: Kasutage brauseri arendajate tööriistu või spetsialiseeritud profileerimisvahendeid jõudluse kitsaskohtade tuvastamiseks.
• Testige erinevates seadmetes: Testige oma rakendust erinevates seadmetes, et tagada selle hea toimimine erinevatel riistvarakonfiguratsioonidel. Arvestage erinevate ekraani eraldusvõimete ja pikslitihedustega, eriti mobiiliplatvormidele sihtides.

WebGL-i profileerimise ja silumise tööriistad

Mitmed tööriistad võivad abistada WebGL-i profileerimisel ja silumisel:

• Brauseri arendajate tööriistad: Enamik kaasaegseid brausereid (Chrome, Firefox, Safari, Edge) sisaldavad võimsaid arendajate tööriistu, mis võimaldavad teil profileerida WebGL-rakendusi, inspekteerida varjutajate koodi ja jälgida GPU tegevust. Need tööriistad pakuvad sageli üksikasjalikku teavet joonistuskutsete, tekstuuri kasutuse ja mälutarbimise kohta.
• WebGL-i inspektorid: Spetsialiseeritud WebGL-i inspektorid, nagu Spector.js ja RenderDoc, pakuvad põhjalikumat ülevaadet renderdustorust. Need tööriistad võimaldavad teil jäädvustada üksikuid kaadreid, samm-sammult läbida joonistuskutseid ja inspekteerida WebGL-objektide olekut.
• GPU profileerijad: GPU tootjad pakuvad profileerimisvahendeid, mis annavad üksikasjalikku teavet GPU jõudluse kohta. Need tööriistad aitavad teil tuvastada kitsaskohti oma varjutajates ja optimeerida oma koodi konkreetsete riistvaraarhitektuuride jaoks. Näideteks on NVIDIA Nsight ja AMD Radeon GPU Profiler.
• JavaScripti profileerijad: Üldised JavaScripti profileerijad aitavad tuvastada jõudluse kitsaskohti teie JavaScripti koodis, mis võib kaudselt mõjutada WebGL-i jõudlust.

Kokkuvõte

WebGL-i renderdustoru statistika kogumine on oluline tehnika WebGL-rakenduste jõudluse optimeerimiseks. Mõistes, kuidas nendele mõõdikutele juurde pääseda ja neid tõlgendada, saavad arendajad tuvastada jõudluse kitsaskohti, optimeerida varjutajaid, vähendada joonistuskutseid ja parandada mäluhaldust. Olenemata sellest, kas loote mängu, andmete visualiseerimise tööriista või interaktiivset tootekonfiguraatorit, annab WebGL-i renderdustoru statistika valdamine teile võimaluse luua sujuvaid, tõhusaid ja kaasahaaravaid veebipõhiseid 3D-kogemusi ülemaailmsele publikule.

Pidage meeles, et WebGL-i jõudlus on pidevalt arenev valdkond ning parimad optimeerimisstrateegiad sõltuvad teie rakenduse spetsiifilistest omadustest ja sihtriistvarast. Pidev profileerimine, katsetamine ja oma lähenemisviisi kohandamine on optimaalse jõudluse saavutamise võtmeks.