Pag-optimize ng mga binary sa C/C++ gamit ang GCC at Clang

Kapag nagsimula kang maglaro gamit ang mga opsyon sa compilation sa C at C++ Madaling mahulog sa tukso na paganahin ang lahat ng "cool" na flag na nakikita mo online. Ngunit ang totoo ay ang isang masamang kombinasyon ng mga parameter ay maaaring maging sanhi ng hindi matatag na sistema, masira ang mga build, o mas malala pa, makabuo ng mga binary na nabibigo sa napaka-banayad na paraan o nangangailangan ng pagkuha ng impormasyon; sa mga kasong iyon, maaari itong maging kapaki-pakinabang. i-extract ang nakatagong text sa mga binary para mag-imbestiga.

Ang layunin ng gabay na ito ay para maunawaan mo, sa praktikal at direktang paraan, kung paano Pag-optimize ng mga binary sa C/C++ gamit ang GCC at Clang gamit ang mga tamang opsyon: mula sa mga klasiko -O2, -march y -pipe...sa mga advanced na pamamaraan tulad ng LTO, PGO, OpenMP, Graphite, at security hardening. Makikita mo rin kung paano magkakaugnay ang lahat ng ito sa CMake, MinGW/MSYS2, Visual Studio, Xcode, o Ninja upang bumuo ng isang portable at maintainable na kapaligiran.

Ano ang CFLAGS at CXXFLAGS at paano gamitin ang mga ito nang hindi nagkakaproblema?

Sa halos lahat ng uri ng sistema Unix (Linux, BSD, atbp.) ang mga baryabol ay ginagamit CFLAGS y CXXFLAGS para makapasa sa mga opsyon sa C at C++ compiler. Hindi sila bahagi ng anumang pormal na pamantayan, ngunit ang mga ito ay karaniwan kaya't iginagalang sila ng anumang mahusay na nakasulat na build system (Make, Autotools, CMake, Meson…).

Sa mga distribusyon tulad ng Gentoo, ang mga baryabol na ito ay binibigyang kahulugan sa buong mundo sa /etc/portage/make.confMula roon, minana ang mga ito ng lahat ng mga paketeng na-compile gamit ang Portage. Sa ibang mga sistema, maaari mo itong i-export sa shell o ilagay sa isang... Makefile, A script mula sa CMake o katulad nito.

Karaniwan nang tukuyin ang CXXFLAGS muling paggamit ng nilalaman ng CFLAGS at, kung kinakailangan, magdagdag ng anumang partikular na opsyon para sa C++. Halimbawa: CXXFLAGS="${CFLAGS} -fno-exceptions"Ang mahalaga ay huwag basta-basta magdagdag ng mga flag doon, dahil ilalapat ang mga ito sa lahat ng iyong iko-compile.

Mahalagang malinaw iyon Ang mga agresibong opsyon sa CFLAGS/CXXFLAGS ay maaaring makasira sa mga buildMaaari itong magdulot ng mga bug na napakahirap i-debug o kahit na pabagalin ang mga binary. Ang mataas na antas ng pag-optimize ay hindi laging nagreresulta sa mas mahusay na pagganap, at ang ilang mga pagbabago ay maaaring gumamit ng mga pagpapalagay na hindi natutugunan ng iyong code.

Pangunahing pag-optimize: mga antas ng -march, -mtune at -O

Ang batayan ng anumang makatwirang pagsasaayos ay kinabibilangan ng tatlong piraso: Piliin ang arkitektura ng CPU, piliin ang antas ng pag-optimize, at kung minsan ay i-activate ang maliliit at hindi nakakapinsalang mga pagpapahusay. bilang -pipeHalos lahat ng iba pa ay dapat dumating mamaya, at nang may malinaw na pag-iisip.

Pagpili ng arkitektura: -march, -mtune at kumpanya

Ang pagpipilian -march=<cpu> nagsasabi sa GCC/Clang kung aling partikular na pamilya ng processor va a bumuo ng codePinapayagan nito ang paggamit ng mga partikular na tagubilin (SSE, AVX, AVX2, AVX-512, atbp.) at mga pagsasaayos sa ABI. Kung masyado kang matalino at pipili ng CPU na masyadong moderno, hindi magbo-boot ang binary sa mga lumang makina.

Para malaman kung ano ang sinusuportahan ng iyong processor, sa Linux maaari mong tingnan ang /proc/cpuinfo o paggamit comandos mula mismo sa style compiler gcc -Q -O2 --help=targetSa mga modernong sistemang x86-64, ang mga generic na profile ay na-standardize na tulad ng x86-64-v2, x86-64-v3 y x86-64-v4kung aling grupo ang nagpapataas ng mga set ng instruksyon at sinusuportahan simula noong GCC 11.

At -march, mayroon -mtune=<cpu> para "pinuhin" ang pagpaplano mula sa code patungo sa isang partikular na modelo nang hindi gumagamit ng mga bagong tagubilin. Lumilitaw din ang mga ito sa mga arkitekturang hindi x86 -mcpu y -mtune Kabilang sa mga kaugnay na opsyon ang (ARM, PowerPC, SPARC…). Sa x86, -mcpu Sa katunayan, ito ay lipas na sa panahon.

Ang isang karaniwang ginagamit na panlilinlang ay -march=nativeNagbibigay-daan ito sa compiler na matukoy ang CPU ng lokal na makina at awtomatikong i-activate ang mga naaangkop na extension. Mainam ito sa mga kapaligiran kung saan patatakbuhin mo lamang ang mga binary sa parehong makina kung saan mo sila kino-compile, ngunit isa itong nakamamatay na bitag kung bubuo ka ng mga pakete para sa ibang mga CPU.

Sa mga kamakailang processor ng Intel At AMD, isinasama ng GCC ang mga partikular na pangalan para sa bawat pamilya, tulad ng -march=rocketlake, -march=sapphirerapids, -march=znver2 o -march=znver3Pinagsasama-sama ng mga opsyong ito ang mga advanced na instruksyon (AVX2, AVX-512, FMA, atbp.) ng bawat henerasyon at nagbibigay-daan sa iyong lubos na makinabang mula sa hardware kapag alam mo na kung saan ka magde-deploy.

Mga antas ng pag-optimize -O: kailan gagamitin ang bawat isa

Ang pagpipilian -O kinokontrol ang pangkalahatang antas ng pag-optimize inilapat sa code. Ang bawat hakbang ay nagpapagana ng mas malawak na hanay ng mga transpormasyon, na nakakaapekto sa parehong oras ng compilation at pagkonsumo ng memorya at kadalian ng pag-debug.

• -O0Hindi na-optimize. Ito ang default na opsyon kung wala kang tinukoy na kahit ano. Mabilis itong nagko-compile at bumubuo ng code na napakadaling i-debug, ngunit mabagal at malaki ito. Mainam para sa maagang pag-develop at pagsisiyasat ng mga kumplikadong bug.
• -O1Unang antas ng pag-optimize. Naglalapat ng medyo murang mga pagpapabuti na karaniwang nagbibigay ng disenteng pagpapahusay ng pagganap nang hindi ginagawang masyadong mabigat ang compilation.
• -O2: ay ang inirerekomendang antas para sa pangkalahatang paggamit sa karamihan ng mga proyekto. Nakakamit nito ang isang mahusay na balanse sa pagitan ng pagganap, oras ng compilation, at katatagan., at iyon ang dahilan kung bakit ito ang value na ginagamit ng maraming distribution bilang default.
• -O3: pinapagana ang lahat ng pag-optimize ng -O2 Mas agresibong mga transpormasyon, tulad ng napakalakas na loop unwinding o mas matinding vectorization. Maaari itong gumana nang mahusay sa ilang numeric code, ngunit mas malamang din na matuklasan ang UB sa code o mapalaki ang executable size.
• -OsSinusubukan nitong bawasan ang laki ng binary sa pamamagitan ng pagbibigay-priyoridad sa espasyo kaysa sa bilis. Ito ay kapaki-pakinabang sa mga kapaligirang may imbakan o napakalimitadong cache.
• -Oz (GCC 12+): lubos na nakakatipid sa laki, tumatanggap ng malaking pagbaba sa performance. Kapaki-pakinabang para sa napakaliit na binary o napaka-espesipikong mga sitwasyon.
• -OfastParang isang -O3 Hindi ito mahigpit na sumusunod sa mga pamantayan ng C/C++. Pinapayagan ka nitong labagin ang ilang garantiya ng wika upang makakuha ng karagdagang pagganap, lalo na sa mga kalkulasyon ng floating-point. Dapat mo itong gamitin nang may lubos na pag-unawa sa iyong ginagawa.
• -OgDinisenyo para sa pag-debug. Naglalapat lamang ito ng mga pag-optimize na hindi masyadong nakakasagabal sa debugger at nag-iiwan ng code sa gitnang punto sa pagitan -O0 y -O1.

Mga antas sa itaas -O3 bilang -O4 o -O9 Lahat sila ay usok at salaminTinatanggap sila ng compiler ngunit sa loob ay tinatrato sila bilang -O3Walang nakatagong mahika doon, puro pag-asta lang.

Kung magsisimula kang makakita ng mga build na misteryosong nabibigo, kakaibang pag-crash, o magkakaibang resulta depende sa optimizer, isang mahusay na hakbang sa pag-diagnose ang pansamantalang bumaba sa -O1 o kahit -O0 -g2 -ggdb para makakuha ng mga binary na madaling i-debug at iulat ang bug na may kapaki-pakinabang na impormasyon.

-pipe at iba pang mga pangunahing opsyon

ang bandila -pipe nagsasabi sa compiler na gumamit ng mga pipe sa memorya Sa halip na mga pansamantalang file sa disk sa pagitan ng mga yugto ng compilation (preprocessing, compilation, assembly). Karaniwan nitong pinapabilis ang proseso, bagama't mas malaki ang konsumo nito ng RAM. Sa mga makinang may napakakaunting memorya, maaari itong maging sanhi ng pag-crash ng system sa compiler, kaya gamitin ito nang matipid sa mga ganitong pagkakataon.

Iba pang tradisyonal na mga opsyon tulad ng -fomit-frame-pointer Pinapayagan ka nitong palayain ang stack pointer register upang makabuo ng mas maraming code, ngunit ginagawang mas mahirap ang pag-debug gamit ang malinis na backtraces. Sa mga modernong arkitektura ng x86-64, mahusay itong naaasikaso ng compiler, at kadalasan ay hindi na kinakailangan pang manu-manong itakda ito.

Mga extension ng SIMD, Graphite, at loop vectorization

Awtomatikong pinapagana ng mga modernong compiler para sa x86-64 ang maraming instruksyon ng SIMD depende sa napiling CPU gamit ang -marchGayunpaman, makakakita ka ng mga watawat tulad ng -msse2, -mavx2 o mga katulad nito na maaaring tahasang idagdag.

Sa pangkalahatan, kung gumagamit ka ng -march Angkop ito; hindi mo na kailangang manu-manong i-activate ito. -msse, -msse2, -msse3, -mmmx o -m3dnowdahil naka-enable na ang mga ito bilang default. Makatuwiran lamang na ipilit ang mga ito sa mga partikular na CPU kung saan hindi ito pinapagana ng GCC/Clang bilang default.

Para sa mga kumplikadong loop, kasama sa GCC ang hanay ng mga pag-optimize grapaytna umaasa sa ISL library. Sa pamamagitan ng mga flag tulad ng -ftree-loop-linear, -floop-strip-mine y -floop-block Sinusuri ng compiler ang mga loop at maaaring baguhin ang mga ito upang mapabuti ang lokalidad ng data at parallelization; para sa mga partikular na kaso, tingnan ang mga halimbawa ng mababang antas C Nakakatulong ito sa pag-aangkop ng code para sa mga pagbabagong ito.

Ang mga transpormasyong ito ay maaaring magbunga ng magagandang resulta sa mabibigat na numeric code, ngunit Hindi sila nakakapinsalaMaaari nilang lubos na mapataas ang pagkonsumo ng RAM habang nagko-compile at magdulot ng mga pag-crash sa malalaking proyekto na hindi idinisenyo para sa mga ito. Samakatuwid, inirerekomenda na paganahin lamang ang mga ito sa mga partikular na snippet ng code o mga proyekto kung saan nasubukan at napatunayang gumagana nang tama ang mga ito.

Paralelismo: OpenMP, -fopenmp at -ftree-parallelize-loops

Kung ang iyong code ay gumagamit ng OpenmpParehong nag-aalok ang GCC at Clang ng medyo matibay na suporta sa pamamagitan ng opsyon -fopenmpPinapayagan nito ang mga seksyon ng code, lalo na ang mga loop, na maiparalel gamit ang mga direktiba sa mismong source code, at para sa compiler na makabuo ng trabaho sa maraming thread.

At -fopenmpKasama sa GCC ang opsyon -ftree-parallelize-loops=NSaan N Karaniwan itong nakatakda sa bilang ng mga magagamit na core (halimbawa gamit ang $(nproc) (sa mga build script). Sinusubukan nitong awtomatikong i-parallelize ang mga loop nang hindi kinakailangang magdagdag ng mga manu-manong direktiba, bagaman ang tagumpay ay lubos na nakasalalay sa kung paano isinusulat ang code.

Isaisip na ang Ang pagpapagana ng OpenMP sa buong mundo sa isang buong sistema ay maaaring maging lubhang problematiko.Ang ilang mga proyekto ay hindi handa para dito, ang iba ay gumagamit ng sarili nilang mga modelo ng concurrency, at ang ilan ay nabibigong mag-compile kapag nakatagpo nila ito. -fopenmpAng makatuwirang gawin ay paganahin ito sa bawat proyekto o kahit sa bawat module, hindi sa pandaigdigang CFLAGS ng system.

Pag-optimize ng oras ng link: LTO

La Pag-optimize ng Oras ng Link (LTO) Pinapayagan nito ang compiler na hindi limitado sa iisang source file kapag nag-o-optimize, ngunit upang makita ang buong programa sa yugto ng pag-link at maglapat ng mga pandaigdigang pag-optimize sa lahat ng mga bagay na kasangkot.

Sa GCC, ito ay isinaaktibo gamit ang -fltoat maaaring tukuyin ang ilang mga thread, halimbawa -flto=4, o hayaan itong matukoy ang bilang ng mga core gamit ang -flto=autoKung gagamitin din ito -fuse-linker-plugin kasama ang tagapag-ugnay ginto At dahil naka-install ang LTO plugin sa binutils, maaaring kumuha ang compiler ng impormasyon ng LTO kahit mula sa mga static library na kasangkot sa binding.

Karaniwang bumubuo ang LTO ng medyo mas maliit at, sa maraming pagkakataon, mas mabilis na mga executabledahil inaalis nito ang mga patay na code at pinapayagan ang pag-inlining sa pagitan ng mga module. Bilang kapalit, oras Ang oras ng compilation at pagkonsumo ng memorya ay tumataas nang husto, lalo na sa malalaking proyekto na may libu-libong object file.

Sa mga kapaligirang tulad ng Gentoo, kung saan ang buong sistema ay muling kino-compile mula sa pinagmulan, ang paglalapat ng LTO sa buong mundo ay itinuturing pa ring isang maselang bagay: Maraming mga pakete na hindi pa rin gumagana nang maayos sa LTO. at nangangailangan ng piling pag-disable nito. Kaya naman karaniwang inirerekomenda na paganahin lamang ito sa mga partikular na proyekto o mga GCC/Clang build kung saan tunay na kapansin-pansin ang benepisyo.

PGO: Pag-optimize na Ginagabayan ng Profile

La Pag-optimize na ginagabayan ng profile (PGO) Binubuo ito ng pag-compile ng programa nang isang beses gamit ang instrumentasyon, pagpapatakbo nito gamit ang mga representatibong workload upang mangolekta ng mga istatistika ng pagpapatupad, at pagkatapos ay muling pag-compile nito gamit ang mga profile na iyon upang gabayan ang optimizer.

Sa GCC, ang karaniwang daloy ay: unang i-compile gamit ang -fprofile-generatepatakbuhin ang programa (o ang mga pagsubok nito) upang makabuo ng datos ng profile, at pagkatapos magtipon gamit ang -fprofile-use na nakaturo sa direktoryo kung saan nakaimbak ang mga profile file. May mga karagdagang opsyon tulad ng -fprofile-correction o sa pamamagitan ng pag-disable ng ilang partikular na notification (-Wno-error=coverage-mismatch) maiiwasan ang mga madalas na error na nagreresulta mula sa mga pagbabago ng code sa pagitan ng mga phase; kadalasan din itong kapaki-pakinabang subaybayan ang pagganap gamit ang eBPF at perf para makakuha ng mga tumpak na profile.

Kapag maayos na naipatupad, magagawa ng PGO makapagbibigay ng mga pagpapabuti sa pagganap na higit pa sa simpleng pagpapataas ng antas ng -ODahil gumagawa ito ng mga desisyon batay sa totoong datos ng pagpapatupad, hindi sa mga pangkalahatang modelo. Ang problema ay ito ay isang masalimuot na proseso: kailangan itong ulitin sa bawat kaugnay na pag-update ng code, at lubos itong umaasa sa senaryo ng pagsubok na kumakatawan sa aktwal na paggamit.

Ang ilang proyekto (kabilang ang GCC mismo sa ilang distribusyon) ay nag-aalok na mga partikular na watawat o script para awtomatikong i-activate ang PGO, ngunit sa pangkalahatan, nananatili itong isang pamamaraan para sa mga advanced na user na handang maglaan ng oras sa proseso.

Pagpapatigas: seguridad batay sa bandila

Higit pa sa bilis, maraming kapaligiran ang nakatuon sa pagpapatigas ng mga binary laban sa mga kahinaan, kahit na may kapalit na kaunting pagkawala ng pagganap. Nag-aalok ang GCC at mga modernong linker ng mahusay na hanay ng mga opsyon sa pagpapatigas na maaaring i-activate mula sa CFLAGS/CXXFLAGS at LDFLAGS.

Ilan sa mga pinakakaraniwan tunog:

• -D_FORTIFY_SOURCE=2 o =3: nagdaragdag ng mga karagdagang pagsusuri sa ilang partikular na libc function upang matukoy ang mga buffer overflow sa runtime.
• -D_GLIBCXX_ASSERTIONS: ina-activate ang mga boundary check sa mga container at C++ string sa STL, na nagde-detect ng mga out-of-range access.
• -fstack-protector-strong: naglalagay ng mga kanaryo sa stack upang matukoy ang mga write na sumisira dito.
• -fstack-clash-protection: pinapagaan ang mga atake batay sa mga banggaan sa pagitan ng stack at iba pang mga rehiyon ng memorya.
• -fcf-protection: nagdaragdag ng mga proteksyon sa daloy ng kontrol (hal., laban sa mga pag-atake ng ROP) sa mga arkitektura na sumusuporta dito.
• -fpie kasama -Wl,-pie: bumubuo ng mga positionable executable, na kinakailangan para sa epektibong ASLR.
• -Wl,-z,relro y -Wl,-z,nowPinapatigas nila ang relocation table at hindi pinapagana ang lazy binding ng mga simbolopagpigil sa ilang partikular na daluyan ng pag-atake.

Ang mga "Hardened" na profile ng ilang distribusyon ay mayroon nang maraming opsyong ito na naka-enable bilang default. Ang manu-manong pag-activate ng mga ito nang hindi nauunawaan ang epekto ay maaaring humantong sa kapansin-pansing mas mabagal na mga binary., lalo na sa malalaki o napaka-malawak na memorya na mga application, ngunit sa mga nakalantad na server o sensitibong desktop, kadalasan ay makatwirang presyo ito.

Pumili ng compiler at environment: GCC, Clang, MSVC, MinGW, Xcode…

Sa pagsasagawa, madalas hindi ka lang basta pumipili ng mga watawat, kundi Aling compiler at aling kumpletong toolchain ang gagamitin mo? sa bawat plataporma. Ang GCC at Clang ay karaniwang halos magkapareho sa pagganap, at ang mga pagkakaiba ay mas kapansin-pansin sa mga diagnostic, oras ng compilation, o compatibility sa ilang partikular na extension.

En Windows Mayroon kang ilang mga ruta: Visual Studio (MSVC) gamit ang kanilang mga kagamitan v143, v142atbp.; o MinGW-w64 sa pamamagitan ng MSYS2 na nagbibigay sa iyo ng katutubong Windows GCC at Clang kasama ang mga kinakailangang Win32 library. Ang MSYS2 ay pinamamahalaan gamit ang pacman at nag-aalok ng mga kapaligirang MinGW64 (batay sa klasikong MSVCRT) at UCRT64 (na may Universal CRT, mas moderno).

Sa macOS, ang karaniwang landas ay Xcode gamit ang clang/clang++, kung saan ang pangunahing konsepto ay ang Batayang SDK (ang bersyon ng sistema kung saan ito na-compile) at ang Target ng Pag-deploy (ang minimum na bersyon ng macOS kung saan mo gustong patakbuhin ang iyong app). Ang wastong pagsasaayos ng pares na ito ay nakakaiwas sa klasikong sakuna ng pag-compile lamang para sa pinakabagong bersyon ng system at ang pagkabigong tumakbo ng iyong mga binary sa bahagyang mas lumang mga bersyon.

Sa Linux, ang karaniwang ginagawa ay ang paggamit ng GCC at Gumawa o NinjaMarahil ay ginagamit ang CMake bilang meta-generator. Bukod pa rito, ang mga distribusyon tulad ng Ubuntu ay nagbibigay-daan sa iyong mag-install ng maraming bersyon ng GCC at piliin ang mga ito gamit ang update-alternatives, katulad ng kung paano mo ito ginagamit sa macOS xcode-select para lumipat mula sa Xcode.

Kung kailangan mo ng komportableng mga debugging environment para sa mga proyektong nabuo gamit ang Make o Ninja (na single-configuration), Eclipse CDT y Visual Studio Code Ito ang dalawang napakadaling opsyon: Maaaring gumawa ang CMake ng mga project file na kailangan mo o direktang i-integrate sa mga ito para i-configure, i-compile, at i-debug.

Portability at CMake: parehong code, magkakaibang toolchain

Ang pagpapa-compile ng isang C/C++ project nang hindi naaapektuhan ang code sa Windows, Linux, at macOS ay nangangailangan ng mahusay na kombinasyon ng pareho. Ang CMake, ang mga magagamit na generator at ang iba't ibang compilerAng ideya ay ang file CMakeLists.txt Ilarawan ang proyekto sa isang abstraktong paraan at bubuo ang CMake ng naaangkop na uri ng proyekto sa bawat platform.

Sa Windows, maaari mong gamitin ang CMake gamit ang -G "Visual Studio 17 2022" para makagawa ng solusyon gamit ang msbuild, o gamit ang -G "Ninja" para mas mabilis na mabuo ang mga console. Bukod pa rito, sa pamamagitan ng -T v143, v142atbp., pipiliin mo ang Platform Toolset (bersyon ng MSVC compiler) at kasama ang -A x64, Win32 o arm64 Ikaw ang pipili ng arkitektura.

Sa MinGW/MSYS2, ang normal na gamitin ay -G "MinGW Makefiles" o -G "Ninja" at, sa pamamagitan ng mga baryabol CMAKE_C_COMPILER y CMAKE_CXX_COMPILERPiliin kung GCC o Clang ang gusto mo. Sa kasong ito, ang mga configuration (Debug, Release, atbp.) ay kinokontrol sa pamamagitan ng -DCMAKE_BUILD_TYPE, dahil ang Make at Ninja ay iisang configuration lamang.

Sa macOS, -G Xcode Nagbibigay ito sa iyo ng perpektong proyekto para sa pag-debug sa IDE, at maaari mong kontrolin ang SDK at Deployment Target gamit ang mga variable tulad ng CMAKE_OSX_DEPLOYMENT_TARGETKung Make o Ninja lang ang gusto mo, pareho lang ang mga generator na gagamitin mo gaya ng sa Linux.

Ang kagandahan ng lahat ng ito ay, kung maayos na na-set up, maaari mong mapanatili ang isang codebase at isang pare-parehong hanay ng mga flag (minsan ay partikular sa platform) at mag-compile sa anumang kapaligiran nang hindi kinakailangang palaging baguhin ang source code. Gayunpaman, mahalagang tandaan ang pangunahing prinsipyo: Una, siguraduhing gumagana ito nang maayos, pagkatapos ay mapapabilis natin ang proseso ng pag-optimize..

Sa lahat ng nakikita, ang pangkalahatang ideya ay manatili sa isang katamtaman ngunit epektibong kombinasyon (isang bagay na katulad nito) -O2 -march=<cpu adecuada> -pipe kasama ang ilang makatwirang pagpapatibay) at ilaan ang malalaking grupo —LTO, PGO, Graphite, agresibong OpenMP — para sa mga proyekto o modyul kung saan ang mga pagpapabuti ay tunay na nasusukat at tinatanggap ang mga gastos sa pagpapanatili at pag-debug na dulot nito.