Kod optimallashtirish: Kompilyator usullariga chuqur kirish

Dasturiy ta'minot ishlab chiqish olamida unumdorlik birinchi o'rinda turadi. Foydalanuvchilar ilovalarning tezkor va samarali bo'lishini kutishadi va bunga erishish uchun kodni optimallashtirish har qanday dasturchi uchun muhim mahoratdir. Turli optimallashtirish strategiyalari mavjud bo'lsa-da, eng kuchlilaridan biri kompilyatorning o'zida yashiringan. Zamonaviy kompilyatorlar kodingizga keng ko'lamli o'zgartirishlarni qo'llashga qodir murakkab vositalar bo'lib, ko'pincha qo'lda kod o'zgartirishni talab qilmasdan unumdorlikni sezilarli darajada oshiradi.

Kompilyator optimallashtirishi nima?

Kompilyator optimallashtirishi - bu manba kodini samaraliroq bajariladigan ekvivalent shaklga o'zgartirish jarayoni. Bu samaradorlik bir necha usulda namoyon bo'lishi mumkin, jumladan:

• Bajarilish vaqtini qisqartirish: Dastur tezroq yakunlanadi.
• Xotira sarfini kamaytirish: Dastur kamroq xotira ishlatadi.
• Energiya sarfini kamaytirish: Dastur kamroq quvvat sarflaydi, bu ayniqsa mobil va o'rnatilgan qurilmalar uchun muhim.
• Kichikroq kod hajmi: Saqlash va uzatish xarajatlarini kamaytiradi.

Muhimi, kompilyator optimallashtirishi kodning asl semantikasini saqlashga qaratilgan. Optimallashtirilgan dastur asl nusxasi bilan bir xil natijani berishi kerak, faqat tezroq va/yoki samaraliroq. Aynan shu cheklov kompilyator optimallashtirishini murakkab va qiziqarli sohaga aylantiradi.

Optimallashtirish darajalari

Kompilyatorlar odatda bir nechta optimallashtirish darajalarini taklif qiladi, ular ko'pincha bayroqlar (masalan, GCC va Clang'da `-O1`, `-O2`, `-O3`) bilan boshqariladi. Yuqori optimallashtirish darajalari odatda agressivroq o'zgartirishlarni o'z ichiga oladi, lekin ayni paytda kompilyatsiya vaqtini va nozik xatoliklarni kiritish xavfini oshiradi (garchi bu yaxshi yo'lga qo'yilgan kompilyatorlar bilan kamdan-kam sodir bo'lsa ham). Mana odatiy tahlil:

• -O0: Optimallashtirish yo'q. Bu odatda standart holat bo'lib, tezkor kompilyatsiyaga ustuvorlik beradi. Nosozliklarni tuzatish uchun foydali.
• -O1: Asosiy optimallashtirishlar. Konstantalarni yig'ish, o'lik kodni yo'q qilish va asosiy bloklarni rejalashtirish kabi oddiy o'zgartirishlarni o'z ichiga oladi.
• -O2: O'rtacha optimallashtirishlar. Unumdorlik va kompilyatsiya vaqti o'rtasidagi yaxshi muvozanat. Umumiy quyi ifodalarni yo'q qilish, tsiklni yoyish (cheklangan darajada) va ko'rsatmalarni rejalashtirish kabi murakkabroq usullarni qo'shadi.
• -O3: Agressiv optimallashtirishlar. Kengroq tsiklni yoyish, ichki joylashtirish va vektorlashtirishni amalga oshiradi. Kompilyatsiya vaqtini va kod hajmini sezilarli darajada oshirishi mumkin.
• -Os: Hajm uchun optimallashtirish. Sof unumdorlikdan ko'ra kod hajmini kamaytirishga ustuvorlik beradi. Xotira cheklangan o'rnatilgan tizimlar uchun foydali.
• -Ofast: Barcha `-O3` optimallashtirishlarini, shuningdek, qat'iy standartlarga muvofiqlikni buzishi mumkin bo'lgan ba'zi agressiv optimallashtirishlarni (masalan, suzuvchi nuqtali arifmetika assotsiativ deb hisoblash) yoqadi. Ehtiyotkorlik bilan foydalaning.

O'zingizning maxsus ilovangiz uchun eng yaxshi kelishuvni aniqlash uchun kodingizni turli optimallashtirish darajalari bilan sinab ko'rish juda muhim. Bir loyiha uchun eng yaxshi ishlaydigan narsa boshqasi uchun ideal bo'lmasligi mumkin.

Keng tarqalgan kompilyator optimallashtirish usullari

Keling, zamonaviy kompilyatorlar tomonidan qo'llaniladigan eng keng tarqalgan va samarali optimallashtirish usullaridan ba'zilarini ko'rib chiqaylik:

1. Konstantalarni yig'ish va tarqatish

Konstantalarni yig'ish, konstant ifodalarni ish vaqtida emas, balki kompilyatsiya vaqtida baholashni o'z ichiga oladi. Konstantalarni tarqatish esa o'zgaruvchilarni ularning ma'lum bo'lgan konstanta qiymatlari bilan almashtiradi.

Misol:

int x = 10;
int y = x * 5 + 2;
int z = y / 2;

Konstantalarni yig'ish va tarqatishni amalga oshiradigan kompilyator buni quyidagicha o'zgartirishi mumkin:

int x = 10;
int y = 52;  // 10 * 5 + 2 kompilyatsiya vaqtida hisoblanadi
int z = 26;  // 52 / 2 kompilyatsiya vaqtida hisoblanadi

Ba'zi hollarda, agar `x` va `y` faqat ushbu konstanta ifodalarda ishlatilsa, ularni butunlay yo'q qilishi ham mumkin.

2. O'lik kodni yo'q qilish

O'lik kod - bu dasturning natijasiga hech qanday ta'sir ko'rsatmaydigan kod. Bunga ishlatilmaydigan o'zgaruvchilar, erishib bo'lmaydigan kod bloklari (masalan, shartsiz `return` iborasidan keyingi kod) va har doim bir xil natijaga baholanadigan shartli tarmoqlar kirishi mumkin.

Misol:

int x = 10;
if (false) {
  x = 20;  // Bu satr hech qachon bajarilmaydi
}
printf("x = %d\n", x);

Kompilyator `x = 20;` satrini yo'q qiladi, chunki u har doim `false` ga baholanadigan `if` iborasi ichida joylashgan.

3. Umumiy quyi ifodalarni yo'q qilish (CSE)

CSE ortiqcha hisob-kitoblarni aniqlaydi va yo'q qiladi. Agar bir xil ifoda bir xil operandlar bilan bir necha marta hisoblansa, kompilyator uni bir marta hisoblab, natijani qayta ishlatishi mumkin.

Misol:

int a = b * c + d;
int e = b * c + f;

`b * c` ifodasi ikki marta hisoblanadi. CSE buni quyidagicha o'zgartiradi:

int temp = b * c;
int a = temp + d;
int e = temp + f;

Bu bitta ko'paytirish amalini tejaydi.

4. Tsikllarni optimallashtirish

Tsikllar ko'pincha unumdorlikning zaif nuqtalari hisoblanadi, shuning uchun kompilyatorlar ularni optimallashtirishga katta e'tibor berishadi.

• Tsiklni yoyish: Tsikl tanasini bir necha marta takrorlash orqali tsikl bilan bog'liq xarajatlarni (masalan, tsikl hisoblagichini oshirish va shartni tekshirish) kamaytiradi. Kod hajmini oshirishi mumkin, lekin ko'pincha unumdorlikni yaxshilaydi, ayniqsa kichik tsikl tanalari uchun.

  Misol:

  for (int i = 0; i < 3; i++) {
    a[i] = i * 2;
  }

  Tsiklni yoyish (3 faktor bilan) buni quyidagicha o'zgartirishi mumkin:

  a[0] = 0 * 2;
  a[1] = 1 * 2;
  a[2] = 2 * 2;

  Tsikl bilan bog'liq xarajatlar butunlay yo'q qilinadi.

• Tsikldan o'zgarmas kodni chiqarish: Tsikl ichida o'zgarmaydigan kodni tsikl tashqarisiga chiqaradi.

Misol:

for (int i = 0; i < n; i++) {
  int x = y * z;  // y va z tsikl ichida o'zgarmaydi
  a[i] = a[i] + x;
}

Tsikldan o'zgarmas kodni chiqarish buni quyidagicha o'zgartiradi:

int x = y * z;
for (int i = 0; i < n; i++) {
  a[i] = a[i] + x;
}

`y * z` ko'paytmasi endi `n` marta emas, balki faqat bir marta bajariladi.

• Tsikllarni birlashtirish: Bir xil ma'lumotlar ustida iteratsiya qiladigan ketma-ket tsikllarni birlashtiradi. Bu ma'lumotlarning joylashuvini yaxshilashi va tsikl bilan bog'liq xarajatlarni kamaytirishi mumkin.

Misol:

for (int i = 0; i < n; i++) {
  a[i] = b[i] + 1;
}
for (int i = 0; i < n; i++) {
  c[i] = a[i] * 2;
}

Tsikllarni birlashtirish buni quyidagicha o'zgartirishi mumkin:

for (int i = 0; i < n; i++) {
  a[i] = b[i] + 1;
  c[i] = a[i] * 2;
}

Bu tsikl bilan bog'liq xarajatlarni kamaytiradi va keshdan foydalanishni yaxshilashi mumkin.

• Tsikllarni almashtirish: Ma'lumotlarning joylashuvini yaxshilash va vektorlashtirishni ta'minlash uchun ichki o'rnatilgan tsikllar tartibini o'zgartiradi. Bu ko'p o'lchovli massivlar uchun ayniqsa samarali.

Misol (Fortran tilida):

DO j = 1, N
  DO i = 1, N
    A(i,j) = B(i,j) + C(i,j)
  ENDDO
ENDDO

Agar `A`, `B` va `C` ustun-asosiy tartibda saqlansa (Fortran tilida odatiy hol), ichki tsiklda `A(i,j)` ga murojaat qilish uzluksiz bo'lmagan xotira murojaatlariga olib keladi. Tsikllarni almashtirish tsikllarni almashtiradi:

DO i = 1, N
  DO j = 1, N
    A(i,j) = B(i,j) + C(i,j)
  ENDDO
ENDDO

Endi ichki tsikl `A`, `B` va `C` elementlariga uzluksiz murojaat qiladi, bu esa kesh unumdorligini yaxshilaydi.

5. Ichki joylashtirish (Inlining)

Ichki joylashtirish funksiya chaqiruvini funksiyaning haqiqiy kodi bilan almashtiradi. Bu funksiya chaqiruvi bilan bog'liq xarajatlarni (masalan, argumentlarni stekka joylashtirish, funksiya manziliga o'tish) yo'q qiladi va kompilyatorga ichki joylashtirilgan kodda qo'shimcha optimallashtirishlarni amalga oshirishga imkon beradi.

Misol:

int square(int x) {
  return x * x;
}

int main() {
  int y = square(5);
  printf("y = %d\n", y);
  return 0;
}

`square` funksiyasini ichki joylashtirish buni quyidagicha o'zgartiradi:

int main() {
  int y = 5 * 5; // Funksiya chaqiruvi funksiya kodi bilan almashtirildi
  printf("y = %d\n", y);
  return 0;
}

Ichki joylashtirish kichik, tez-tez chaqiriladigan funksiyalar uchun ayniqsa samarali.

6. Vektorlashtirish (SIMD)

Vektorlashtirish, shuningdek, Yagona Ko'rsatma, Ko'p Ma'lumot (SIMD) deb ham ataladi, zamonaviy protsessorlarning bir vaqtning o'zida bir nechta ma'lumotlar elementi ustida bir xil operatsiyani bajarish qobiliyatidan foydalanadi. Kompilyatorlar kodni, ayniqsa tsikllarni, skalyar operatsiyalarni vektorli ko'rsatmalar bilan almashtirish orqali avtomatik ravishda vektorlashtirishi mumkin.

Misol:

for (int i = 0; i < n; i++) {
  a[i] = b[i] + c[i];
}

Agar kompilyator `a`, `b` va `c` to'g'ri joylashtirilganligini va `n` yetarlicha katta ekanligini aniqlasa, u bu tsiklni SIMD ko'rsatmalaridan foydalanib vektorlashtirishi mumkin. Masalan, x86'dagi SSE ko'rsatmalaridan foydalanib, u bir vaqtning o'zida to'rtta elementni qayta ishlashi mumkin:

__m128i vb = _mm_loadu_si128((__m128i*)&b[i]); // b dan 4 ta element yuklash
__m128i vc = _mm_loadu_si128((__m128i*)&c[i]); // c dan 4 ta element yuklash
__m128i va = _mm_add_epi32(vb, vc);           // 4 ta elementni parallel qo'shish
_mm_storeu_si128((__m128i*)&a[i], va);           // 4 ta elementni a ga saqlash

Vektorlashtirish, ayniqsa ma'lumotlarga parallel hisob-kitoblar uchun sezilarli unumdorlik yaxshilanishini ta'minlashi mumkin.

7. Ko'rsatmalarni rejalashtirish

Ko'rsatmalarni rejalashtirish quvurdagi to'xtalishlarni kamaytirish orqali unumdorlikni oshirish uchun ko'rsatmalarni qayta tartiblaydi. Zamonaviy protsessorlar bir vaqtning o'zida bir nechta ko'rsatmalarni bajarish uchun quvurdan foydalanadi. Biroq, ma'lumotlarga bog'liqliklar va resurslar ziddiyatlari to'xtalishlarga olib kelishi mumkin. Ko'rsatmalarni rejalashtirish ko'rsatmalar ketma-ketligini qayta tartibga solish orqali bu to'xtalishlarni minimallashtirishga qaratilgan.

Misol:

a = b + c;
d = a * e;
f = g + h;

Ikkinchi ko'rsatma birinchi ko'rsatma natijasiga bog'liq (ma'lumotlarga bog'liqlik). Bu quvurda to'xtalishga olib kelishi mumkin. Kompilyator ko'rsatmalarni quyidagicha qayta tartiblashi mumkin:

a = b + c;
f = g + h; // Mustaqil ko'rsatmani oldinroqqa ko'chirish
d = a * e;

Endi protsessor `b + c` natijasi tayyor bo'lishini kutayotganda `f = g + h` ni bajarishi mumkin, bu esa to'xtalishni kamaytiradi.

8. Registrlarni taqsimlash

Registrlarni taqsimlash o'zgaruvchilarni CPUdagi eng tez saqlash joylari bo'lgan registrlarga tayinlaydi. Registrlardagi ma'lumotlarga kirish xotiradagi ma'lumotlarga kirishdan ancha tezroq. Kompilyator imkon qadar ko'proq o'zgaruvchilarni registrlarga ajratishga harakat qiladi, ammo registrlar soni cheklangan. Samarali registr taqsimoti unumdorlik uchun juda muhim.

Misol:

int x = 10;
int y = 20;
int z = x + y;
printf("%d\n", z);

Kompilyator qo'shish amaliyoti paytida xotiraga murojaat qilmaslik uchun `x`, `y` va `z` ni registrlarga ajratishi ideal bo'lar edi.

Asoslardan tashqari: Ilg'or optimallashtirish usullari

Yuqoridagi usullar keng qo'llanilsa-da, kompilyatorlar yanada ilg'or optimallashtirishlarni ham qo'llaydi, jumladan:

• Protseduralararo optimallashtirish (IPO): Funksiya chegaralaridan tashqarida optimallashtirishni amalga oshiradi. Bunga turli kompilyatsiya birliklaridan funksiyalarni ichki joylashtirish, global konstantalarni tarqatish va butun dastur bo'ylab o'lik kodni yo'q qilish kirishi mumkin. Bog'lanish vaqtidagi optimallashtirish (LTO) bog'lanish vaqtida amalga oshiriladigan IPO shaklidir.
• Profilga asoslangan optimallashtirish (PGO): Dasturning bajarilishi paytida to'plangan profil ma'lumotlaridan optimallashtirish qarorlarini boshqarish uchun foydalanadi. Masalan, u tez-tez bajariladigan kod yo'llarini aniqlashi va ushbu sohalarda ichki joylashtirish va tsiklni yoyishga ustuvorlik berishi mumkin. PGO ko'pincha sezilarli unumdorlikni yaxshilashni ta'minlaydi, lekin profil yaratish uchun vakillik ish yukini talab qiladi.
• Avtomatik parallellashtirish: Ketma-ket kodni bir nechta protsessor yoki yadrolarda bajarilishi mumkin bo'lgan parallel kodga avtomatik ravishda o'zgartiradi. Bu qiyin vazifa, chunki u mustaqil hisob-kitoblarni aniqlashni va to'g'ri sinxronizatsiyani ta'minlashni talab qiladi.
• Taxminiy bajarish: Kompilyator tarmoq natijasini bashorat qilishi va tarmoq sharti haqiqatda ma'lum bo'lishidan oldin bashorat qilingan yo'l bo'ylab kodni bajarishi mumkin. Agar bashorat to'g'ri bo'lsa, bajarilish kechikishsiz davom etadi. Agar bashorat noto'g'ri bo'lsa, taxminiy bajarilgan kod bekor qilinadi.

Amaliy mulohazalar va eng yaxshi amaliyotlar

• Kompilyatoringizni tushuning: Kompilyatoringiz tomonidan qo'llab-quvvatlanadigan optimallashtirish bayroqlari va imkoniyatlari bilan tanishing. Batafsil ma'lumot uchun kompilyator hujjatlariga murojaat qiling.
• Muntazam ravishda sinab ko'ring: Har bir optimallashtirishdan so'ng kodingizning unumdorligini o'lchang. Muayyan optimallashtirish har doim unumdorlikni yaxshilaydi deb o'ylamang.
• Kodingizni profil qiling: Unumdorlikning zaif nuqtalarini aniqlash uchun profil yaratish vositalaridan foydalaning. Optimallashtirish harakatlaringizni umumiy bajarilish vaqtiga eng ko'p hissa qo'shadigan sohalarga qarating.
• Toza va o'qilishi oson kod yozing: Yaxshi tuzilgan kodni kompilyator tahlil qilishi va optimallashtirishi osonroq. Optimallashtirishga to'sqinlik qilishi mumkin bo'lgan murakkab va chalkash koddan saqlaning.
• Tegishli ma'lumotlar tuzilmalari va algoritmlardan foydalaning: Ma'lumotlar tuzilmalari va algoritmlarni tanlash unumdorlikka sezilarli ta'sir ko'rsatishi mumkin. O'zingizning maxsus muammoingiz uchun eng samarali ma'lumotlar tuzilmalari va algoritmlarni tanlang. Masalan, ko'p hollarda chiziqli qidiruv o'rniga qidiruv uchun xesh jadvalidan foydalanish unumdorlikni keskin oshirishi mumkin.
• Apparatga xos optimallashtirishlarni ko'rib chiqing: Ba'zi kompilyatorlar sizga maxsus apparat arxitekturalarini nishonga olishga imkon beradi. Bu maqsadli protsessorning xususiyatlari va imkoniyatlariga moslashtirilgan optimallashtirishlarni yoqishi mumkin.
• Vaqtidan oldin optimallashtirishdan saqlaning: Unumdorlikning zaif nuqtasi bo'lmagan kodni optimallashtirishga ko'p vaqt sarflamang. Eng muhim sohalarga e'tibor qarating. Donald Knut aytganidek: "Vaqtidan oldin optimallashtirish dasturlashdagi barcha yovuzliklarning (yoki hech bo'lmaganda uning ko'p qismining) ildizidir."
• Puxta sinovdan o'tkazing: Optimallashtirilgan kodingizning to'g'riligini puxta sinovdan o'tkazish orqali tekshiring. Optimallashtirish ba'zida nozik xatoliklarga olib kelishi mumkin.
• Kelishuvlardan xabardor bo'ling: Optimallashtirish ko'pincha unumdorlik, kod hajmi va kompilyatsiya vaqti o'rtasidagi kelishuvlarni o'z ichiga oladi. O'zingizning maxsus ehtiyojlaringiz uchun to'g'ri muvozanatni tanlang. Masalan, agressiv tsiklni yoyish unumdorlikni yaxshilashi mumkin, lekin ayni paytda kod hajmini sezilarli darajada oshiradi.
• Kompilyator maslahatlaridan foydalaning (Pragmas/Attributes): Ko'pgina kompilyatorlar ma'lum kod bo'limlarini qanday optimallashtirish haqida kompilyatorga maslahat berish uchun mexanizmlarni (masalan, C/C++ da pragmalar, Rustda atributlar) taqdim etadi. Masalan, funksiyani ichki joylashtirish yoki tsiklni vektorlashtirish mumkinligini taklif qilish uchun pragmalardan foydalanishingiz mumkin. Biroq, kompilyator bu maslahatlarga amal qilishga majbur emas.

Global kod optimallashtirish stsenariylariga misollar

• Yuqori chastotali savdo (HFT) tizimlari: Moliya bozorlarida hatto mikrosekundlik yaxshilanishlar ham sezilarli foyda keltirishi mumkin. Kompilyatorlar minimal kechikish uchun savdo algoritmlarini optimallashtirishda keng qo'llaniladi. Ushbu tizimlar ko'pincha real bozor ma'lumotlariga asoslangan ijro yo'llarini sozlash uchun PGO'dan foydalanadi. Vektorlashtirish katta hajmdagi bozor ma'lumotlarini parallel ravishda qayta ishlash uchun juda muhimdir.
• Mobil ilovalarni ishlab chiqish: Batareya quvvati mobil foydalanuvchilar uchun muhim masala. Kompilyatorlar xotira murojaatlarini minimallashtirish, tsikl bajarilishini optimallashtirish va quvvat tejamkor ko'rsatmalardan foydalanish orqali energiya sarfini kamaytirish uchun mobil ilovalarni optimallashtirishi mumkin. `-Os` optimallashtirishi ko'pincha kod hajmini kamaytirish uchun ishlatiladi, bu esa batareya quvvatini yanada yaxshilaydi.
• O'rnatilgan tizimlarni ishlab chiqish: O'rnatilgan tizimlar ko'pincha cheklangan resurslarga (xotira, qayta ishlash quvvati) ega. Kompilyatorlar ushbu cheklovlar uchun kodni optimallashtirishda muhim rol o'ynaydi. `-Os` optimallashtirishi, o'lik kodni yo'q qilish va samarali registr taqsimoti kabi usullar muhim ahamiyatga ega. Real vaqtda ishlaydigan operatsion tizimlar (RTOS) ham oldindan aytib bo'ladigan unumdorlik uchun kompilyator optimallashtirishlariga qattiq tayanadi.
• Ilmiy hisoblashlar: Ilmiy simulyatsiyalar ko'pincha hisoblash jihatidan intensiv hisob-kitoblarni o'z ichiga oladi. Kompilyatorlar ushbu simulyatsiyalarni tezlashtirish uchun kodni vektorlashtirish, tsikllarni yoyish va boshqa optimallashtirishlarni qo'llash uchun ishlatiladi. Xususan, Fortran kompilyatorlari o'zlarining ilg'or vektorlashtirish imkoniyatlari bilan mashhur.
• O'yin ishlab chiqish: O'yin ishlab chiquvchilari doimo yuqori kadrlar tezligi va yanada realistik grafika uchun harakat qilishadi. Kompilyatorlar o'yin kodini unumdorlik uchun, xususan, renderlash, fizika va sun'iy intellekt kabi sohalarda optimallashtirish uchun ishlatiladi. Vektorlashtirish va ko'rsatmalarni rejalashtirish GPU va CPU resurslaridan maksimal darajada foydalanish uchun juda muhimdir.
• Bulutli hisoblashlar: Resurslardan samarali foydalanish bulutli muhitlarda birinchi darajali ahamiyatga ega. Kompilyatorlar bulutli ilovalarni CPU ishlatilishini, xotira izini va tarmoq o'tkazuvchanligini kamaytirish uchun optimallashtirishi mumkin, bu esa operatsion xarajatlarni kamaytiradi.

Xulosa

Kompilyator optimallashtirishi dasturiy ta'minot unumdorligini oshirish uchun kuchli vositadir. Kompilyatorlar foydalanadigan usullarni tushunish orqali dasturchilar optimallashtirishga ko'proq moyil bo'lgan kod yozishlari va sezilarli unumdorlikka erishishlari mumkin. Qo'lda optimallashtirish hali ham o'z o'rniga ega bo'lsa-da, zamonaviy kompilyatorlarning kuchidan foydalanish global auditoriya uchun yuqori unumdorlikka ega, samarali ilovalarni yaratishning muhim qismidir. Optimallashtirishlar regressiyalarni kiritmasdan kerakli natijalarni berayotganiga ishonch hosil qilish uchun kodingizni sinab ko'rishni va puxta sinovdan o'tkazishni unutmang.