Relatibong kamakailan ay may lumabas na bago Vulkan API- maaaring sabihin ng isa, ang kahalili sa OpenGL, bagaman ang Vulkan ay batay sa Mantle API mula sa AMD.
Siyempre, ang pag-unlad at suporta ng OpenGL ay hindi huminto, at ang DirectX 12 ay inilabas din sa kasamaang palad (o marahil sa kabutihang-palad) hindi ko alam kung ano ang nangyayari sa DirectX 12 at kung bakit ito na-install lamang sa Windows 10. Ngunit ang cross-platform na Vulkan ay interesado sa akin. Ano ang mga tampok ng Vulkan at kung paano gamitin ito nang tama susubukan kong sabihin sa iyo sa artikulong ito.
Kaya, para saan ang Vulkan at saan ito magagamit? Sa mga laro at application na gumagana sa mga graphics? tiyak! Mag-compute tulad ng ginagawa ng CUDA o OpenCL? Walang problema. Kailangan ba talaga natin ng window o display para dito? Siyempre hindi, maaari mong piliin kung saan i-broadcast ang iyong resulta o hindi ito i-broadcast. Ngunit una sa lahat.
Disenyo ng API at mga pangunahing kaalaman
Marahil ay dapat nating simulan sa pinakasimpleng. Dahil ang Vulkan API ay binuo ng Khronous Group, ang syntax ay medyo katulad sa OpenGL. Ang buong API ay may vk prefix. Halimbawa, ang mga function (kung minsan kahit na may napakahabang pangalan) ay ganito ang hitsura: vkDoSomething(...), mga pangalan ng mga istruktura o handle: VkSomething, at lahat ng pare-parehong expression (macros, macro calls at enumeration elements): VK_SOMETHING. Gayundin, mayroong isang espesyal na uri ng pag-andar - mga utos, kung saan idinagdag ang Cmd prefix: vkCmdJustDoIt(...).Maaari kang sumulat sa Vulkan sa parehong C at C++. Ngunit ang pangalawang opsyon, siyempre, ay magbibigay ng higit na kaginhawahan. Mayroong (at gagawin) mga port para sa iba pang mga wika. May gumawa na ng port sa Delphi, may gusto (bakit?) ng port sa Python.
Kaya paano ka gagawa ng konteksto ng pag-render? Hindi pwede. Wala siya dito. Sa halip, nakaisip sila ng iba pang mga bagay na may iba't ibang pangalan na kahawig pa nga ng DirectX.
Pagsisimula at Pangunahing Konsepto
Pinaghihiwalay ng Vulkan ang dalawang konsepto - ito ay aparato (aparato) At host (host). Ipapatupad ng device ang lahat ng command na ipinadala dito, at ipapadala ng host ang mga ito. Sa katunayan, ang aming aplikasyon ay ang host - ang Vulkan ay may ganitong terminolohiya.Upang gumana sa Vulkan kailangan namin ng mga hawakan para dito kopyahin (halimbawa), at maaaring higit pa sa isa, pati na rin aparato (aparato), muli, maaaring hindi palaging sapat ang isa.
Ang Vulkan ay maaaring dynamic na mai-load nang madali. Sa SDK (binuo ng LunarG), kung ang VK_NO_PROTOTYPES macro ay idineklara at ikaw mismo ang nag-load ng Vulkan library (hindi gamit ang isang linker, ngunit may ilang mga paraan sa code), pagkatapos ay una sa lahat kakailanganin mo ang vkGetInstanceProcAddr function, kung saan maaari mong malaman ang mga address ng mga pangunahing pag-andar ng Vulkan - ang mga gumagana nang walang isang halimbawa, kabilang ang pag-andar ng paglikha nito, at mga pag-andar na gumagana sa halimbawa, kabilang ang pag-andar ng pagsira nito at ang pag-andar ng paglikha ng isang aparato. Pagkatapos gumawa ng device, makakakuha ka ng mga function na gumagana dito (pati na rin ang child handle nito) sa pamamagitan ng vkGetDeviceProcAddr.
Kawili-wiling katotohanan: sa Vulkan kailangan mong punan ang isang tiyak na istraktura ng data upang lumikha ng anumang bagay. At lahat ng bagay sa Vulkan ay gumagana nang humigit-kumulang sa ganitong paraan: inihanda nang maaga - maaaring gamitin nang madalas at kasama mataas na pagganap. Ang impormasyon ng instance ay maaari ding magsama ng impormasyon tungkol sa iyong application, bersyon ng engine, bersyon ng API na ginamit, at iba pang impormasyon.
Mga layer at extension
Sa purong Vulkan walang matibay na pagsusuri para sa kawastuhan ng papasok na data. Sinabihan siyang gumawa ng isang bagay - gagawin niya ito. Kahit na humantong ito sa isang error sa application, driver o video card. Ginawa ito para sa kapakanan ng pagganap. Gayunpaman, maaari kang kumonekta nang walang anumang mga problema mga layer ng pagpapatunay, at gayundin mga extension sa instance at/o device, kung kinakailangan.Mga layer
Karaniwan, ang layunin ng mga layer ay suriin ang mga papasok na data para sa mga error at subaybayan ang pagganap ng Vulkan. Gumagana ang mga ito nang napakasimple: sabihin nating tumawag tayo ng isang function, at napupunta ito sa pinakamataas na layer, na tinukoy sa paggawa ng device o instance nang mas maaga. Sinusuri niya ang lahat para sa tama, pagkatapos ay ipinasa ang tawag sa susunod. At ito ay magiging hanggang sa ito ay dumating sa Vulkan core. Siyempre, maaari kang lumikha ng iyong sariling mga layer. Halimbawa, inilabas ng Steam ang SteamOverlay layer (bagaman hindi ko alam kung ano talaga ang ginagawa nito). Gayunpaman, ang mga layer ay mananatiling tahimik, ngunit hindi mag-crash sa application. Paano mo malalaman kung ang lahat ay ginawa nang tama? May espesyal na extension para dito!Mga extension
Gaya ng ipinahihiwatig ng pangalan, pinalawak nila ang gawain ng Vulkan karagdagang pag-andar. Halimbawa, ang isang extension (ulat sa pag-debug) ay magpapakita ng mga error (at higit pa) mula sa lahat ng mga layer. Upang gawin ito, kakailanganin mong tukuyin ang kinakailangang Callback function, at kung ano ang gagawin sa impormasyong natanggap sa function na ito ay nasa iyo ang pagpapasya. Pakitandaan na ito ay isang Callback at ang pagkaantala ay maaaring magastos sa iyo nang malaki, lalo na kung direktang ilalabas mo ang lahat ng natanggap na impormasyon sa console. Pagkatapos iproseso ang mensahe, maaari mong tukuyin kung ipapasa pa ang function call (sa susunod na layer) o hindi - sa ganitong paraan maiiwasan mo kritikal na mga pagkakamali, ngunit subukang magpatuloy sa pagtatrabaho sa mga hindi gaanong mapanganib na mga error.Mayroon ding iba pang mga extension, ang ilan sa mga ito ay pag-uusapan ko mamaya sa artikulong ito.
Device
Pinaghihiwalay ng Vulkan ang mga konsepto ng pisikal at lohikal na mga aparato. Pisikal na aparato Maaaring ito ang iyong video card (at higit sa isa) o isang processor na sumusuporta sa mga graphics. Lohikal na aparato ay nilikha batay sa pisikal: ang impormasyon tungkol sa mga pisikal na aparato ay nakolekta, ang kinakailangan ay pinili, ang isa pa ay inihanda kinakailangang impormasyon at ang aparato ay nilikha. Maaaring may ilan mga lohikal na kagamitan batay sa isang pisikal, ngunit pagsamahin para sa pinag-isang gawain mga pisikal na kagamitan(pa?) imposible.Kaya anong uri ng impormasyon ang kinokolekta namin? Ito ay, siyempre, mga suportadong format, memorya, mga kakayahan at, siyempre, mga pamilya ng pila.
Mga pamilyang pila at pila
Maaaring (o maaaring hindi) gawin ng device ang sumusunod na 4 na bagay: gumuhit ng mga graphic, magsagawa ng iba't ibang kalkulasyon, kumopya ng data, at gumana sa kalat na memorya (kalat pamamahala ng memorya). Ang mga kakayahang ito ay kinakatawan bilang mga pamilya ng mga pila: sinusuportahan ng bawat pamilya ang ilang partikular na (marahil nang sabay-sabay) na mga kakayahan. At kung magkakahiwalay ang magkatulad na pamilya, ipapakita pa rin sila ng Vulkan bilang isang pamilya para hindi na tayo masyadong mahirapan sa code at piliin ang tamang pamilya.Pagkatapos mong mapili ang mga gustong (o gustong) pamilya, maaari kang makakuha ng mga pila mula sa kanila. Ang mga queue ay ang lugar kung saan darating ang mga command para sa device (pagkatapos ay dadalhin sila ng device mula sa mga pila at isasagawa ang mga ito). Nga pala, wala masyadong pila at pamilya. Karaniwang mayroong 1 pamilya ang NVIDIA na may lahat ng kakayahan para sa 16 na pila. Kapag tapos ka na sa pagpili ng mga pamilya at sa bilang ng mga pila, maaari mong gawin ang device.
Mga utos, ang kanilang pagpapatupad at pag-synchronize
Ang lahat ng mga command para sa device ay inilalagay sa isang espesyal na lalagyan - ang command buffer. Yung. Walang function sa Vulkan na nagsasabi sa device na gumawa kaagad ng isang bagay at ibalik ang kontrol sa application kapag nakumpleto na ang operasyon. Mayroon lamang mga function para sa pagpuno ng command buffer ng ilang partikular na command (halimbawa, gumuhit ng isang bagay o kopyahin ang isang imahe). Pagkatapos lamang isulat ang command buffer sa host maaari naming ipadala ito sa queue, na alam nang nasa device.Mayroong dalawang uri ng command buffer: pangunahin at pangalawa. Ang pangunahin ay direktang ipinadala sa pila. Ang pangalawa ay hindi maipadala - ito ay inilunsad sa pangunahin. Ang mga utos ay nakasulat sa parehong pagkakasunud-sunod kung saan tinawag ang mga function. Pumasok sila sa pila sa parehong pagkakasunud-sunod. Ngunit maaari silang matupad halos sa isang "magulong" pagkakasunud-sunod. Upang maiwasan ang kumpletong kaguluhan sa application, ang mga developer ng Vulkan ay nagbigay ng mga tool sa pag-synchronize.
Ngayon, ang pinakamahalagang bagay: ang host Hindi naghihintay para sa pagkumpleto ng pagpapatupad ng mga command at command buffer. Sa pamamagitan ng kahit man lang hanggang sa gawin mo itong tahasan. Pagkatapos maipadala ang mga buffer ng command sa pila, agad na bumalik ang kontrol sa application.
Mayroong 4 na mga primitive sa pag-synchronize: bakod, semaphore, kaganapan at hadlang.
Bakod Ang pinakasimpleng paraan ng pag-synchronize ay nagbibigay-daan ito sa host na maghintay para sa ilang mga bagay na mangyari. Halimbawa, ang pagkumpleto ng pagpapatupad ng isang command buffer. Ngunit ang bakod ay bihirang ginagamit.
Semaphore- paraan ng pag-synchronize sa loob ng device. Walang paraan upang tingnan ang estado nito o hintayin ito sa host, at hindi mo rin ito maaaring hintayin sa loob ng command buffer, ngunit maaari naming tukuyin kung aling semaphore ang dapat magbigay ng senyales kapag nakumpleto ang pagpapatupad ng lahat ng mga utos sa buffer, at kung aling semaphore ang hihintayin bago magsimulang magsagawa ng mga utos sa buffer. Lamang, hindi ang buong buffer ang maghihintay, ngunit isang tiyak na yugto nito.
Mga yugto ng pipeline at mga dependency sa pagpapatupad
Tulad ng nabanggit na, ang mga utos sa pila ay hindi nangangahulugang isasagawa sa pagkakasunud-sunod. Upang maging mas tumpak, ang mga kasunod na utos ay hindi maghihintay na makumpleto ang mga nauna. Maaari silang isagawa nang magkatulad, o ang pagpapatupad ng nakaraang utos ay maaaring makumpleto nang mas huli kaysa sa mga kasunod. At iyon ay medyo normal. Ngunit ilang mga koponan depende mula sa pagganap ng iba. Maaari mong hatiin ang mga ito sa dalawang baybayin: "bago" at "pagkatapos", at ipahiwatig din kung aling mga yugto ng "bago" baybayin ang kinakailangang maisakatuparan (iyon ay, ang mga utos ay maaaring hindi kumpleto o hindi lahat) bago magsimula ang tinukoy na mga yugto to be executed shore commands "pagkatapos". Halimbawa, ang pagguhit ng isang imahe ay maaaring mag-pause upang gawin ang ilang mga bagay, at pagkatapos ay magpatuloy sa pagguhit muli. Maaaring mayroon ding isang hanay ng mga dependency, ngunit huwag tayong pumunta nang malalim sa mga kagubatan ng Siberia Vulkan.
Mga kaganapan- elemento ng "pinong" tuning. Maaari kang magpadala ng signal mula sa host at mula sa device, at maaari ka ring maghintay sa device at sa host. Tinutukoy ng kaganapan ang dependency ng dalawang hanay ng mga command (bago at pagkatapos) sa command buffer. At para sa kaganapan mayroon ding isang espesyal na pseudo-stage na nagpapahintulot sa iyo na maghintay para sa host.
Harang muli ay magagamit lamang sa device, o mas tiyak, sa command buffer, na nagdedeklara ng mga dependency ng una at ikalawang hanay ng mga command. Maaari mo ring tukuyin ang mga hadlang sa memorya, na maaaring tatlong uri: global hadlang, hadlang buffer at hadlang mga larawan. Pipigilan ka nila na hindi sinasadyang basahin ang data na kasalukuyang isinusulat at/o kabaligtaran, depende sa tinukoy na mga parameter.
Mga conveyor
Nasa ibaba ang dalawang Vulkan pipeline:
Yung. May dalawang pipeline ang Vulkan: graphic At computational. Sa tulong ng mga graphics, siyempre, maaari tayong gumuhit, at sa pag-compute... maaari nating kalkulahin. ano pa ba? Ang mga resulta ng pagkalkula ay maaaring ipadala sa graphics pipeline. Sa ganitong paraan madali kang makakatipid ng oras sa isang particle system, halimbawa.
Hindi mo maaaring baguhin ang pagkakasunud-sunod o baguhin ang mga yugto ng pipeline mismo. Ang pagbubukod ay mga programmable stages (shaders). Maaari ka ring magpadala ng iba't ibang uri ng data sa mga shader (at hindi lamang) sa pamamagitan ng mga descriptor.
Maaari kang lumikha ng isang cache para sa isang pipeline na maaaring gamitin (paulit-ulit) sa iba pang mga pipeline at kahit na pagkatapos i-restart ang application.
Ang isang pipeline ay dapat na i-configure at nauugnay sa isang command buffer bago ang huli ay maaaring gumamit ng mga pipeline command.
Pamana ng pipeline
Dahil ang pipeline ay talagang lahat ng impormasyon tungkol sa kung paano magtrabaho sa papasok na data, ang pagpapalit ng pipeline (at ito ay impormasyon tungkol sa mga shader, descriptor, rasterization, atbp.) ay maaaring magastos sa mga tuntunin ng oras. Samakatuwid, ang mga developer ay nagbigay ng kakayahang magmana ng pipeline. Kapag nagpapalit ng pipeline sa isang bata, magulang, o sa pagitan ng mga bata, magkakaroon ng mas kaunting performance sa overhead. Ngunit ito rin ay isang kaginhawahan para sa mga developer, tulad ng OOP.
I-render ang pass, graphics pipeline at framebuffer
Kaya, nakukuha namin ang sumusunod na matryoshka:Upang magamit ang mga utos sa pag-render, kailangan mo ng isang graphics pipeline. Sa pipeline ng graphics kailangan mong tukuyin render pass (I-render ang Pass), na naglalaman ng impormasyon tungkol sa mga subaisles (subpass), ang kanilang mga dependencies sa isa't isa at mga kalakip (kalakip). Attachment - impormasyon tungkol sa imahe na gagamitin sa framebuffers Ang isang framebuffer ay partikular na nilikha para sa isang partikular na rendering pass, kailangan mong tukuyin ang pass mismo (at, kung kinakailangan, isang subpass) at ang framebuffer. Pagkatapos ng simula ng pass, maaari kang gumuhit Maaari ka ring lumipat sa pagitan ng mga subpass kapag kumpleto na ang pagguhit, maaari mong kumpletuhin ang pass.
Pamamahala ng memorya at mga mapagkukunan
Ang memorya sa Vulkan ay inilalaan ng host at ng host lamang (maliban sa swapchain). Kung ang isang imahe (o iba pang data) ay kailangang ilagay sa aparato, ang memorya ay inilalaan. Una, ang isang mapagkukunan ng isang tiyak na laki ay nilikha, pagkatapos ay hiniling ang mga kinakailangan sa memorya nito, ang memorya ay inilalaan para dito, pagkatapos ang mapagkukunan ay nauugnay sa isang seksyon ng memorya na ito, at pagkatapos lamang ang kinakailangang data ay maaaring kopyahin sa mapagkukunang ito. Gayundin, mayroong memorya na maaaring direktang mabago mula sa host (host visible), mayroon lokal na memorya mga device (memorya ng video card, halimbawa) at iba pang mga uri ng memorya, na sa kanilang sariling paraan ay nakakaapekto sa bilis ng pag-access sa kanila.Sa Vulkan, maaari mo ring isulat ang iyong sariling host memory allocation sa pamamagitan ng pagse-set up ng mga Callback function. Ngunit tandaan na ang mga kinakailangan sa memorya ay hindi lamang ang laki nito, kundi pati na rin leveling (pagkakahanay).
Ang mga mapagkukunan mismo ay may dalawang uri: mga buffer (mga buffer) At mga larawan (mga larawan). Parehong pinaghihiwalay ng layunin, ngunit kung ang buffer ay isang koleksyon lamang ng iba't ibang data (vertex, index o constant buffer), kung gayon ang imahe ay palaging may sariling format.
Payo sa mga nagsusulat sa Vulkan
Maglaan ng lugar ng memorya kung saan maaari kang maglagay ng ilang mapagkukunan nang sabay-sabay. Limitado ang bilang ng mga alokasyon at maaaring hindi ka sapat. Ngunit ang bilang ng mga asosasyon ay hindi limitado.
Mga shaders
Sinusuportahan ng Vulkan ang 6 na uri ng mga shader: apikal, kontrol ng tessellation, pagsusuri ng tessellation, geometriko, pira-piraso(aka pixel) At computational. Maaari mong isulat ang mga ito sa isang nababasang SPIR-V, at pagkatapos ay i-assemble ito sa byte code, na ise-seal namin sa isang module sa application, i.e. Gumawa tayo ng shader module mula sa code na ito. Siyempre, maaari nating isulat ito sa karaniwang GLSL at pagkatapos ay i-convert ito sa SPIR-V (mayroon na tayong tagasalin). At, siyempre, maaari kang sumulat ng iyong sariling tagasalin at kahit na assembler - ang mga mapagkukunan at mga detalye ay nai-post sa OpenSource, walang pumipigil sa iyo na magsulat ng isang assembler para sa iyong High Level SPIR-V. O baka may nagsulat na nito.Ang byte code ay isinalin sa mga command na partikular sa bawat video card, ngunit ito ay ginagawa nang mas mabilis kaysa sa raw GLSL code. Katulad na pagsasanay nalalapat din sa DirectX - Ang HLSL ay unang na-convert sa byte code, at ang byte code na ito ay maaaring i-save at pagkatapos ay gamitin upang hindi mag-compile ng mga shader nang paulit-ulit.
Windows at mga display
At ang artikulong ito ay magtatapos sa isang kuwento tungkol sa WSI (Window System Integration) at sa switching chain (swapchain). Upang magpakita ng isang bagay sa isang window o sa screen, kailangan ng mga espesyal na extension.Para sa mga bintana ito ay pangunahing extension eroplano at pagpapalawak ng eroplanong partikular sa bawat isa sa mga system (win32, xlib, xcb, android, mir, wayland). Ang display (i.e. FullScreen) ay nangangailangan ng display extension, ngunit sa pangkalahatan ay parehong gumagamit ng swapchain extension.
Ang switching chain ay hindi konektado sa graphics pipeline, kaya ang isang simpleng Clear Screen ay gumagana nang hindi kino-configure ang lahat ng ito. Ito ay medyo simple. Mayroong isang tiyak na makina ng pagtatanghal, na may pila ng mga imahe. Isang larawan ang ipinapakita sa screen, ang iba ay naghihintay ng kanilang pagkakataon. Maaari din naming tukuyin ang bilang ng mga larawan. Mayroon ding ilang mga mode na nagbibigay-daan sa iyong maghintay para sa vertical sync signal.
Ang paraan ng paggana nito ay ganito: humihiling kami ng index ng isang libreng larawan, tumawag ng command buffer na kokopya sa resulta mula sa Framebuffer patungo sa larawang ito, at magpadala ng command para ipadala ang larawan sa queue. Mukhang madali, ngunit dahil kailangan ang pag-synchronize, ang lahat ay medyo mas kumplikado, dahil ang tanging inaasahan ng host ay ang index ng imahe na malapit na magiging available. Ang command buffer ay naghihintay para sa isang signal ng semaphore, na magsasaad ng pagkakaroon ng imahe, at pagkatapos ay nagpapadala mismo ng isang senyas sa pamamagitan ng semaphore na ang pagpapatupad ng buffer, at dahil dito ang pagkopya, ay nakumpleto. At ang imahe ay talagang papasok sa pila sa huling signal ng semaphore. Mayroon lamang dalawang semaphores: tungkol sa availability ng larawan para sa pagkopya at tungkol sa availability ng larawan para ipakita (ibig sabihin, tungkol sa pagkumpleto ng pagkopya).
Sa pamamagitan ng paraan, napatunayan ko na ang parehong command buffer ay ipinadala nga sa pila nang maraming beses. Maaari mong isipin para sa iyong sarili kung ano ang ibig sabihin nito.
Sa artikulong ito sinubukan kong pag-usapan ang tungkol sa pinakamahalagang bahagi ng Vulkan API, ngunit marami pa rin ang hindi saklaw at maaari mong malaman para sa iyong sarili. Nais kong matatag kang FPS at kaaya-ayang coding.
Test bench No. 2 batay sa Intel Socket 2011 platform
Test bench No. 3 batay sa Intel Socket 1155 platform
Test bench No. 4 batay sa AMD Soket AM3 + platform
Test bench No. 5 batay sa Intel Socket 1150 platform
Sinuri ang lahat ng video card pinakamataas na kalidad mga graph Programa ng MSI Afterburner. Ang layunin ng pagsubok ay upang matukoy kung paano nagmula ang mga video card iba't ibang mga tagagawa sa ilalim ng parehong mga kondisyon. Nasa ibaba ang isang video ng segment ng pagsubok:
Sinuri ang aming mga video card sa mga resolution na 1920x1080, 2560x1600 at 3840x2160 sa maximum na mga setting kalidad ng graphics na pinapayagan ng Doom. Ang AMD CrossFireX at SLI ay hindi ganap na sinusuportahan ng laro at hindi namin na-activate ang mga ito sa pagsubok. Inirerekumenda pa namin na huwag paganahin ang CrossFireX, dahil kapag ito ay na-activate, ang pagganap ay bumaba nang malaki.
Pagsubok sa maximum mga setting ng kalidad 1920x1080 API OpenGL
Pagsubok sa maximum mga setting ng kalidad 1920x1080 API Vulkan
Katanggap-tanggap sa mga setting na ito Tagapagpahiwatig ng FPS nagpakita ng mga video card ng Radeon R7 370 level o GeForce GTX 750 Ti.
Pagsubok sa maximum mga setting ng kalidad 2560x1440 OpenGL API
Sa mga setting na ito, ang mga video card ng Radeon R7 370 o GeForce GTX 750 Ti na antas ay nagpakita ng katanggap-tanggap na FPS.Radeon HD 7950 o GeForce GTX 770.
Pagsubok sa maximum mga setting ng kalidad 2560x1440 API Vulkan
Sa mga setting na ito, ang mga video card ng Radeon R7 370 o GeForce GTX 750 Ti na antas ay nagpakita ng katanggap-tanggap na FPS.Mga pinakamainam na solusyon magiging Radeon R7 370 o GeForce GTX TITAN.
Pagsubok sa maximum mga setting ng kalidad 3840x2160 OpenGL API
Sa mga setting na ito, ang mga video card ng antas ng Radeon R9 290 o GeForce GTX 970 ay nagpakita ng isang katanggap-tanggap na FPS mga video card ng antas ng Radeon R9 290X o GeForce GTX 980.
Pagsubok sa maximum mga setting ng kalidad 3840x2160 API Vulkan
Sa mga setting na ito, ang mga video card ng antas ng Radeon R9 380X o GeForce GTX 970 ay nagpakita ng isang katanggap-tanggap na FPSmga video card ng antas ng Radeon R9 290 o GeForce GTX 970.
Maraming mga konklusyon ang maaaring makuha mula sa mga resultang ito. Ang mga AMD video card sa Vulkan API ay nagbibigay ng isang makabuluhang pagtaas sa pagganap, habang ang NVIDIA ay minimal (ang pamilya Kepler ay karaniwang nasa pula), tila kailangan mong maghintay para sa mga bagong driver.
Ito rin ay nagkakahalaga ng pagpuna na Mahusay lamang na magagamit ng Vulkan API ang memorya ng video card, at kung ang laro ay kumonsumo ng higit pa, ang pagganap ng mga video card ay bumaba sa isang hindi nape-play na antas...
Ang pagsubok sa memorya ng video na natupok ng laro ay isinagawa ng programa MSI Afterburner. Ang tagapagpahiwatig ay batay sa mga resulta ng nangungunang mga video card mula sa AMD at NVIDIA sa mga resolusyon 1920x1080 at 2560x1440 na may iba't ibang setting ng anti-aliasing.
Pagsubok sa maximum na memorya ng mga setting ng kalidad ng GPU
Ang inirerekomendang dami ng paggamit ng video memory para sa isang resolution na 1920x1080 ay magiging 3076 MB ng video memory, para sa isang resolution na 2560x1440 - 3076 MB ng video memory, at para sa isang resolution na 3840x2160 tungkol sa 4096 MB ng video memory.
Sinubukan namin ang pag-asa sa processor sa 16 na modelo ng mga pangunahing configuration na may kaugnayan ngayon. Ang pagsubok ay isinagawa sa mga lugar kung saan ang halaga ng video card para sa laro ay minimal at ang pag-load nito ay mas mababa sa 99%, sa oras na ito sa isang resolusyon na 1920x1080.
Pagsubok sa maximum na mga setting ng kalidad 1920x1080 OpenGL API
Pagsubok sa maximum na mga setting ng kalidad 1920x1080 API Vulkan
Pagganap ng processor sa laro sa gamit ang API Hindi lamang lumalaki ang Vulkan, ngunit inaalis din ang mga problema kung saan nagdusa ang pagganap dahil sa labis na mga core ng processor.
Gumagamit ang Doom ng hanggang 16 na mga thread, ngunit ganap lamang na gumagamit ng 4 na mga core.
Ang pagsusulit ay isinagawa sa isang basic Mga pangunahing configuration i 7 [email protected] GHz na may dami preset na memorya 32 GB DDR4 2400 MGz. Ang buong ginamit na memorya ng pagpapatakbo ay kinuha bilang isang tagapagpahiwatig. Pagsubok RAM sa buong sistema ay isinagawa sa iba't ibang mga bangko ng pagsubok nang hindi naglulunsad ng mga third-party na application (mga browser, atbp.).
Pagsubok sa pagkonsumo ng RAM ng laro sa iba't ibang mga setting kalidad
Tulad ng nakikita natin, ang dami ng RAM na natupok sa Doom ay nasa loob ng 3000 megabytes.
Pagsubok ng sistema ng pagkonsumo ng RAM
Sa isang 6GB na system, ginagamit ng Doom ang lahat ng 5.5GB ng RAM. Sa pagkakaroon ng isang system na may 8 gigabytes, ang pagkonsumo ng RAM ng buong RAM ay 6 gigabytes. Sa 16 GB system consumption nakabahaging memorya umabot sa halos 7 gigabytes. At sa 32 gigabytes ng RAM, ang system ay gumagamit ng 7.2 gigabytes ng RAM.
Ang mga ito ay ganap na magkakaibang mga bagay.
Ito ay kinakailangan upang makilala sa pagitan ng pag-aaral API, mula sa pag-aaral mga teknolohiya. Kung gusto mo lang matutunan ang API, matuto ng kahit ano, dahil mapapansin mo lang ang pagkakaiba kapag naintindihan mo na mga pangunahing kaalaman, batayan.
Ang OpenGL ay idinisenyo noong may iba pang mga arkitektura ng hardware. Ang multiprocessing ay nasa teorya lamang, at itinuturing na probinsya ng mga supercomputer at hindi kailangan para sa mga consumer PC.
Maaaring magbigay ng pagkakatulad: OpenGL == C++, Vulkan == asynchronous Assembler + hardware thread. Halimbawa, sa C++ mayroon na ngayong napakaraming problema sa arkitektura na sinusubukan nilang lutasin gamit ang mga bagong pamantayan, na nagdedeklara ng ilang bagay na lipas na dahil hindi tama ang mga ito sa konsepto at hindi umaangkop sa mga modernong katotohanan.
Ngunit, sa parehong oras, maaari mong isulat ang parehong bagay sa assembler, ngunit kailangan mong maunawaan nang mas mahusay kung paano gumagana ang processor at OS, isulat ang mga primitibo ng pag-synchronize sa iyong sarili, atbp.
Ang bulkan ay nilikha para sa parehong layunin. Upang mag-program dito, kailangan mong malaman ang lahat ng mga intricacies ng hardware, basahin ang isang bungkos ng mga papel mula sa parehong NVidia, pananaliksik, magkaroon ng mga bagong tampok para sa modernong mga arkitektura mula sa simula, na orihinal na naimbento sa OpenGL, ngunit para sa lumang hardware.
Iyon ay, sa Vulcan kailangan mong gawin higit pa sa iyong mga kamay, mag-optimize pa. Sa halip na isang tawag Mga function ng OpenGL, kakailanganin mong magsulat ng ilang daang linya sa bulkan. Kasabay nito, kung hindi mo naiintindihan ang isang subtlety, gagawa ka ng isang bagay na hindi gaanong mahusay na orihinal na mahusay na ipinatupad sa OpenGL. Bilang karagdagan, ang OpenGL ay maaaring magtapon ng mga error kapag nagkamali ka sa isang lugar. Hindi itinatapon ng Vulcan ang mga ito; umaasa ito sa katotohanang alam mo na kung paano ito gamitin. Kung paanong binago lamang ng assembler ang estado ng mga rehistro, wala itong konsepto ng error. Kung paano i-interpret ang mga register na ito ay depende sa kung gaano kahusay na basahin ng developer ang manual ng processor.
Sa huli, sasagot ako ng ganito:
Kung nag-aaral ka ng mga graphics bilang isang agham, wildly nerd out a la Carmack bilang isang mag-aaral gamit ang kanyang mga makina, magsaliksik ng isang bagay, magsulat ng ilang makikinang na algorithm, ipagtanggol ang mga disertasyon tungkol dito, i-publish ang mga ito, pagkatapos ay sabihin sa isang kumperensya kung gaano ka cool na nakayanan ang ilang kagyat na gawain , nadagdagan ang pagiging produktibo, pagkatapos ay matutunan ang Vulkan. Ang Vulkan ay tungkol sa mga graphics bilang isang teknolohiya, tungkol sa pagganap, tungkol sa disenyo ng engineering at arkitektura, at hindi tungkol sa mga API at programming mismo. Sa isang bulkan, kakailanganin mong gumugol ng mas maraming oras sa mga diagram, dokumentasyon at pagbuo ng isang arkitektura, na bumubuo ng mga pamamaraan para sa pakikipag-ugnayan ng mga bahagi ng arkitektura na ito, pag-synchronize ng mga estado, sa halip na pagsulat ng code.
Kung magsusulat ka ng mga simpleng bagay na inilapat na kailangang magpakita ng ilang uri ng graphics, pagkatapos ay matutunan ang OpenGL. Dito mo natutunan lamang ang API, na sumasang-ayon sa isang yari na, bahagyang luma, na disenyo ng arkitektura.
Kung gusto mong magsulat ng mga hindi pang-world-class na laro, pagkatapos ay matuto ng mga yari na makina, Unity o Unreal. Sinusuportahan na nila ang Vulkan para sa iyo, naisip ang API at arkitektura para sa iyo.
Bago natin pag-usapan ang mga detalye at pagkasalimuot ng Vulkan API, sa tingin ko kailangan nating magsabi ng ilang salita tungkol sa kung ano ito at kung para saan ito ginagamit. Kung ihahambing mo ang Linux sa Windows, ang Vulkan (na nasa pagbuo pa rin) ay Directx, isang hanay ng mga aklatan para sa pagpapabuti ng pagganap pangunahin sa mga laro sa computer. Gaya ng nalalaman, sa Linux platform, maaari kang magpatakbo ng mga laro gamit ang , PlayOnLinux o komersyal na bersyon. Ngunit hindi lahat ng mga laruan ay ilulunsad at gagana nang maayos, at lahat ay dahil sa mapahamak na Directx API.
Nakalimutan kong sabihin na para sa pagganap sa mga laro para sa .nix platform ay ginagamit ang OpenGL, katulad software, tulad ng Directx para sa Windows. Kaya, Vulkan API, tulad ng iniulat ng mga developer mula sa Nvidia(na, sa turn, ay interesado rin sa pagpapatupad ng proyektong ito) Ang Vulkan API ay pupunan ng legacy na OpenGL. Sa turn, nangangahulugan ito na ang mas kaunting mapagkukunan-intensive na mga bagay ay mapoproseso gamit ang OpenGL, at kapag dumating ang oras, pagkatapos ay gagana ito. bagong proyekto.
Bentahe ng Vulkan API
Bakit suportado ang proyektong ito? mga kilalang kumpanya, bukod sa kung saan ay ang Intel, AMD, Nvidia, atbp. Ano ang kagandahan ng bagong API? Dito kailangan mong magpakita ng video na malinaw na magpapakita kung ano ito sa pagsasanay...
Tulad ng nakikita mo mula sa video sa itaas, ang Vulkan API ay pinamamahalaan ang CPU multitasking nang napakahusay, na kung saan ay nagbibigay-daan sa iyo upang epektibong pamahalaan ang GPU, sa gayon ay namamahagi ng pantay na pagkarga, na nagpapakita ng napakahusay. magandang resulta sa pagiging produktibo. Habang nasa OpenGL, napupunta ang lahat ng load CPU, at kapansin-pansing lumubog ang FPS, sa Vulkan API ang lahat ay ginagawa nang matalino, ang load ay ipinamamahagi at ang FPS ay lumulubog pa rin, ngunit mas madalas.
Mga prospect para sa pagbuo ng Vulkan API
Sa kasamaang palad, eksaktong petsa hindi pa rin alam ang release, at kung aling mga laro ang makakatanggap ng suporta para sa bagong API ay pinananatiling lihim din. Sa turn, ang AMD (na ngayon ay aktibong nakikipagtulungan sa mga developer) ay nagpahiwatig na sila ay nagtatrabaho sa bagong laro, na gagamit ng Vulkan API, o ang ilang laro ay ipo-port.
Nakalimutan kong banggitin na ang bagong proyekto ay magiging cross-platform at maging ang Android ay gagana dito.
Ang karagdagang balita tungkol sa proyekto ng Vulkan API ay iaanunsyo mula Marso 14 hanggang 18, sa panahon ng The Game Developers Conference (GDC).
Iwanan ang lahat ng iyong mga saloobin tungkol sa Vulcan sa mga komento. Ito ay magiging lubhang kawili-wili upang makita kung ang Linux ay magiging platform ng paglalaro o lalabas muli ang Windows ng isang bagay na supernatural.
Pagsasalin, komento: alfabuster, lalo na para sa site
Sa pagbuo ng mga 3D application, video game at system virtual reality darating bagong yugto. Magkasama, ginawa ng mga developer mahalagang hakbang on the way to code unification at higit pa epektibong paggamit mapagkukunan ng hardware. Consortium Khronos Group, na mayroong higit sa isang daang kumpanya, opisyal na ipinakilala ang unang bersyon ng isang bukas na cross-platform API na tinatawag na Vulkan (dating GLNext). Nagbibigay ito ng direktang kontrol sa GPU at CPU, inaalis ang mga bottleneck at pagpapabuti ng pangkalahatang pagganap.
Sa mga forum madalas mong makikita ang parehong uri ng mga tanong tungkol sa kung ang processor X ay magbubukas ng video card Y at kung aling configuration na may parehong badyet ang magiging mas produktibo sa mga partikular na aplikasyon. Nangyayari ito dahil ang mga modernong GPU ay may mas mahusay na pagganap kaysa sa mga CPU ng parehong antas at henerasyon. Sa mga laro at iba pang 3D na application, may mga pagkakataon na kailangan ng CPU mabigat na kargada, at ang GP ay idle. Halimbawa, kinakalkula ng processor ang pakikipag-ugnayan ng mga manlalaro at mga bagay, at ang video card ay naghihintay ng data mula dito upang iguhit ang susunod na frame. Dahil sa kawalan ng timbang sa pag-load, nangyayari ang mga pagkaantala, at ang isang dynamic na laro ay maaaring maging isang frame-by-frame na slideshow, kahit na may malakas na video card.
Ang mga problemang ito ay tipikal para sa PC platform at halos hindi alam ng mga may-ari ng mga game console. Palaging alam ng mga developer ng console game ang mga detalyadong detalye ng mga console at maaaring magsagawa ng malalim na pag-optimize ng code na isinasaalang-alang ang kanilang mga feature. Ang mga computer, laptop, tablet ay isang zoo na hindi lamang magkakaibang mga pagsasaayos, kundi pati na rin sa panimula na magkakaibang mga arkitektura. Kapag lumilikha ng mga laro para sa isang magkakaibang platform, ang priyoridad ay ang pagiging pangkalahatan ng code, na negatibong nakakaapekto sa bilis ng pagpapatupad nito.
Mga developer mga operating system sinusubukan nilang lutasin ang problema ng mababang kahusayan ng code sa iba't ibang paraan mga application ng third party. Ang Microsoft ay nagsimulang maghanap ng mga paraan upang ma-optimize ang graphics computing matagal na ang nakalipas, ngunit ang tunay na suporta para sa mababang antas ng mga operasyon ay lumitaw lamang sa DirectX 12. Ang API na ito ay magagamit lamang sa isang OS - Windows 10. Sa turn, Posisyon ng Apple naging mas malapit sa mga tagagawa ng game console. Kapag ang parehong kumpanya ay gumagawa ng mga mobile processor at software, mas madaling makamit ang pinag-ugnay na gawain. Gayunpaman, ang Apple ay malayo sa mga naubos na paraan upang ma-optimize ang pagbuo ng mga laro at application. Lumitaw sa iOS 8 Metal API, nakatuon din sa paggamit ng mga operasyong mababa ang antas.
Pahinga malalaking kumpanya mas gusto na kumilos nang sama-sama at sa loob ng bukas na mga pamantayan. Ang Khronos Group consortium, na lumitaw 16 na taon na ang nakalilipas, ay nagdala ng higit sa isang daang mga tagagawa, kabilang ang mga kaibigan sa dugo tulad ng AMD, Nvidia at Intel. Sa isang pagkakataon, ang consortium ay inihayag bukas na mga pamantayan OpenGL, OpenCL, OpenCV at marami pang iba.
Kung ikukumpara sa OpenGL, binibigyan ng Vulkan ang mga developer ng kakayahang gumamit ng mga operasyong mababa ang antas nang hindi nakompromiso ang portability ng code. Gamit ang Vulkan sa iba't ibang mga platform posible na makamit ang halos parehong balanseng algorithm tulad ng sa dalubhasa mga game console. Tinutulungan ka ng API na ito na mas mahusay na magamit ang mga kakayahan ng hardware discrete video card at pinagsamang mga graphics chip sa 2D at 3D mode.
Katulad ng DirectX 12, sinusuportahan ng Vulkan ang direktang pag-access sa memorya ng GPU. Bukod pa rito, binabawasan ng Vulkan ang pagdepende sa bilis ng pag-render sa kalidad ng mga driver. Sa pamamagitan ng pagsasalin ng code ng mga shader program sa isang intermediate binary format, ang kanilang compilation ay maaaring maisagawa na sa yugto ng pag-unlad, at hindi sa panahon ng paglulunsad ng 3D application.
Ang Vulkan ay nasa pagbuo mula noong kalagitnaan ng 2014. Ito ay batay sa mga graphics library ng isa pang mababang antas ng API - AMD Mantle. AMD Company nagsilbi rin bilang editor ng mga opisyal na detalye. Bilang karagdagan sa kanila, ang pangkat ng Khronos ay nag-publish ng ilang mga pagsubok na nagpapakita ng mga pakinabang ng bagong API. Lahat ng mga ito ay magagamit sa GitHub portal.
"Ang Vulkan ay may malaking potensyal," sabi ni Dean Sekulic, programmer sa Croteam. – Upang ilagay ito sa isang pangungusap, ang pagdating ng Vulkan ay nagtapos ng matagal nang paghaharap sa pagitan ng mga manlalaban para sa pagganap ng code at portability. Ngayon, inilalagay namin dito ang Prinsipyo ng Talos upang kumpirmahin ang bagong konsepto ng pag-unlad.
Ini-sponsor ng Valve ang paglikha ng bukas na LunarG SDK na may Suporta sa API Vulkan. Gayunpaman, sa kabila ng bukas na mga pagtutukoy, magagamit na mga tool sa pag-unlad, ang kakayahan malalim na pag-optimize code at iba pang mga pakinabang, ang Vulkan ay magiging bihirang ginagamit na API sa loob ng ilang panahon. Karamihan sa mga gumagawa ng laro ay mananatiling tapat sa DirectX 11/12 at OpenGL. Mas madaling madagdagan kinakailangan ng system o bawasan ang kalidad ng mga graphics sa halip na makabisado ang mga bagong pamamaraan ng pag-unlad. Sa pag-unawa dito, ang Khronos Group consortium ay nagsusumikap na magbigay ng suporta para sa Vulkan hindi lamang sa mga bagong OS at mga graphic na solusyon, ngunit gayundin sa mga hindi na ginagamit na sistema.
Kasalukuyang sinusuportahan ang Vulkan sa kapaligiran ng Windows(simula sa bersyon pito), Linux, SteamOS at Android. Ang suporta sa Tizen OS ng Samsung ay inaasahang maidaragdag sa lalong madaling panahon. Ang mga beta na bersyon ng mga driver na may suporta para sa Vulkan API ay inilabas na ng AMD at Nvidia. Susunod ay ang Intel, Qualcomm, ARM at iba pang mga tagagawa na bahagi ng Khronos Group consortium. Ang isang demo ng Vulkan sa isang ARM Mali graphics chip ay makikita sa video sa ibaba.
Sa kasalukuyan, maaaring masuri ang Vulkan sa mga video card gamit ang graphics chips Nvidia GeForce GT 630 at mas mataas, AMD Radeon HD 7700 at mas bago. Sinusuportahan din ng Vulkan API ang mga AMD hybrid processor na may core ng graphics Radeon HD 8500 – 8900 at R2 – R9. Built-in na graphics para sa desktop at mga mobile processor Sinuportahan ng Intel ang Vulkan mula noon Pangunahing pamilya ikalimang henerasyon.
Ang buong potensyal ng bagong API ay ihahayag sa pamamagitan ng pag-asa Mga GPU serye ng Nvidia Pascal at AMD na may ika-apat na henerasyong arkitektura ng GCN. Ang mga kaukulang video card ay malamang na isasama sa serye ng GTX 1xxx at Radeon Rx 400. Ayon sa hindi opisyal na data, ang pagsisimula ng kanilang mga benta ay binalak para sa ikalawang quarter ng 2016.
