കോഡ് ഒപ്റ്റിമൈസേഷൻ: കംപൈലർ ടെക്നിക്കുകളിലേക്കുള്ള ഒരു ആഴത്തിലുള്ള വിശകലനം

സോഫ്റ്റ്‌വെയർ ഡെവലപ്‌മെൻ്റിൻ്റെ ലോകത്ത്, പ്രകടനം വളരെ പ്രധാനമാണ്. ഉപയോക്താക്കൾ ആപ്ലിക്കേഷനുകൾ വേഗതയേറിയതും കാര്യക്ഷമവുമാകണമെന്ന് പ്രതീക്ഷിക്കുന്നു, ഇത് നേടുന്നതിനായി കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നത് ഏതൊരു ഡെവലപ്പർക്കും അത്യന്താപേക്ഷിതമായ ഒരു കഴിവാണ്. വിവിധ ഒപ്റ്റിമൈസേഷൻ തന്ത്രങ്ങൾ നിലവിലുണ്ടെങ്കിലും, ഏറ്റവും ശക്തമായൊരെണ്ണം കംപൈലറിൽ തന്നെ അടങ്ങിയിരിക്കുന്നു. ആധുനിക കംപൈലറുകൾ നിങ്ങളുടെ കോഡിൽ വിപുലമായ പരിവർത്തനങ്ങൾ പ്രയോഗിക്കാൻ കഴിവുള്ള സങ്കീർണ്ണമായ ഉപകരണങ്ങളാണ്, ഇത് പലപ്പോഴും സ്വമേധയാലുള്ള കോഡ് മാറ്റങ്ങൾ ആവശ്യമില്ലാതെ തന്നെ പ്രകടനത്തിൽ കാര്യമായ പുരോഗതിക്ക് കാരണമാകുന്നു.

എന്താണ് കംപൈലർ ഒപ്റ്റിമൈസേഷൻ?

സോഴ്‌സ് കോഡിനെ കൂടുതൽ കാര്യക്ഷമമായി പ്രവർത്തിക്കുന്ന ഒരു തത്തുല്യ രൂപത്തിലേക്ക് മാറ്റുന്ന പ്രക്രിയയാണ് കംപൈലർ ഒപ്റ്റിമൈസേഷൻ. ഈ കാര്യക്ഷമത പല തരത്തിൽ പ്രകടമാകും, അവയിൽ ചിലത് താഴെ പറയുന്നവയാണ്:

• പ്രവർത്തന സമയം കുറയ്ക്കുന്നു: പ്രോഗ്രാം വേഗത്തിൽ പൂർത്തിയാകുന്നു.
• മെമ്മറി ഉപയോഗം കുറയ്ക്കുന്നു: പ്രോഗ്രാം കുറഞ്ഞ മെമ്മറി ഉപയോഗിക്കുന്നു.
• ഊർജ്ജ ഉപഭോഗം കുറയ്ക്കുന്നു: പ്രോഗ്രാം കുറഞ്ഞ പവർ ഉപയോഗിക്കുന്നു, ഇത് മൊബൈൽ, എംബഡഡ് ഉപകരണങ്ങൾക്ക് പ്രത്യേകിച്ചും പ്രധാനമാണ്.
• ചെറിയ കോഡ് വലുപ്പം: സംഭരണ, പ്രക്ഷേപണ ഓവർഹെഡ് കുറയ്ക്കുന്നു.

പ്രധാനമായി, കംപൈലർ ഒപ്റ്റിമൈസേഷനുകൾ കോഡിൻ്റെ യഥാർത്ഥ അർത്ഥം നിലനിർത്താൻ ലക്ഷ്യമിടുന്നു. ഒപ്റ്റിമൈസ് ചെയ്ത പ്രോഗ്രാം യഥാർത്ഥ പ്രോഗ്രാമിൻ്റെ അതേ ഔട്ട്പുട്ട് തന്നെ നൽകണം, പക്ഷേ വേഗത്തിലും കൂടാതെ/അല്ലെങ്കിൽ കൂടുതൽ കാര്യക്ഷമമായും. ഈ പരിമിതിയാണ് കംപൈലർ ഒപ്റ്റിമൈസേഷനെ സങ്കീർണ്ണവും ആകർഷകവുമായ ഒരു മേഖലയാക്കുന്നത്.

ഒപ്റ്റിമൈസേഷൻ്റെ തലങ്ങൾ

കംപൈലറുകൾ സാധാരണയായി ഒന്നിലധികം ഒപ്റ്റിമൈസേഷൻ തലങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, അവ പലപ്പോഴും ഫ്ലാഗുകൾ ഉപയോഗിച്ച് നിയന്ത്രിക്കപ്പെടുന്നു (ഉദാഹരണത്തിന്, GCC, Clang എന്നിവയിൽ `-O1`, `-O2`, `-O3`). ഉയർന്ന ഒപ്റ്റിമൈസേഷൻ തലങ്ങളിൽ സാധാരണയായി കൂടുതൽ ശക്തമായ പരിവർത്തനങ്ങൾ ഉൾപ്പെടുന്നു, എന്നാൽ ഇത് കംപൈലേഷൻ സമയവും സൂക്ഷ്മമായ ബഗുകൾ ഉണ്ടാകാനുള്ള സാധ്യതയും വർദ്ധിപ്പിക്കുന്നു (പ്രശസ്തമായ കംപൈലറുകളിൽ ഇത് അപൂർവമാണെങ്കിലും). ഒരു സാധാരണ വിഭജനം ഇതാ:

• -O0: ഒപ്റ്റിമൈസേഷൻ ഇല്ല. ഇത് സാധാരണയായി ഡിഫോൾട്ടാണ്, വേഗതയേറിയ കംപൈലേഷന് മുൻഗണന നൽകുന്നു. ഡീബഗ്ഗിംഗിന് ഇത് ഉപയോഗപ്രദമാണ്.
• -O1: അടിസ്ഥാന ഒപ്റ്റിമൈസേഷനുകൾ. കോൺസ്റ്റൻ്റ് ഫോൾഡിംഗ്, ഡെഡ് കോഡ് എലിമിനേഷൻ, ബേസിക് ബ്ലോക്ക് ഷെഡ്യൂളിംഗ് തുടങ്ങിയ ലളിതമായ പരിവർത്തനങ്ങൾ ഇതിൽ ഉൾപ്പെടുന്നു.
• -O2: മിതമായ ഒപ്റ്റിമൈസേഷനുകൾ. പ്രകടനവും കംപൈലേഷൻ സമയവും തമ്മിലുള്ള നല്ലൊരു സന്തുലിതാവസ്ഥ. കോമൺ സബ് എക്സ്പ്രഷൻ എലിമിനേഷൻ, ലൂപ്പ് അൺറോളിംഗ് (പരിമിതമായ അളവിൽ), ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളിംഗ് തുടങ്ങിയ കൂടുതൽ സങ്കീർണ്ണമായ ടെക്നിക്കുകൾ ചേർക്കുന്നു.
• -O3: ശക്തമായ ഒപ്റ്റിമൈസേഷനുകൾ. കൂടുതൽ വിപുലമായ ലൂപ്പ് അൺറോളിംഗ്, ഇൻലൈനിംഗ്, വെക്റ്ററൈസേഷൻ എന്നിവ നടത്തുന്നു. കംപൈലേഷൻ സമയവും കോഡിൻ്റെ വലുപ്പവും ഗണ്യമായി വർദ്ധിപ്പിച്ചേക്കാം.
• -Os: വലുപ്പത്തിനായി ഒപ്റ്റിമൈസ് ചെയ്യുക. പ്രകടനത്തേക്കാൾ കോഡിൻ്റെ വലുപ്പം കുറയ്ക്കുന്നതിന് മുൻഗണന നൽകുന്നു. മെമ്മറി പരിമിതമായ എംബഡഡ് സിസ്റ്റങ്ങൾക്ക് ഇത് ഉപയോഗപ്രദമാണ്.
• -Ofast: എല്ലാ `-O3` ഒപ്റ്റിമൈസേഷനുകളും പ്രവർത്തനക്ഷമമാക്കുന്നു, കൂടാതെ കർശനമായ സ്റ്റാൻഡേർഡ് പാലിക്കൽ ലംഘിച്ചേക്കാവുന്ന ചില ശക്തമായ ഒപ്റ്റിമൈസേഷനുകളും (ഉദാഹരണത്തിന്, ഫ്ലോട്ടിംഗ്-പോയിൻ്റ് അരിത്മെറ്റിക് അസോസിയേറ്റീവ് ആണെന്ന് അനുമാനിക്കുന്നത്). ജാഗ്രതയോടെ ഉപയോഗിക്കുക.

നിങ്ങളുടെ നിർദ്ദിഷ്ട ആപ്ലിക്കേഷന് ഏറ്റവും മികച്ചത് നിർണ്ണയിക്കാൻ വിവിധ ഒപ്റ്റിമൈസേഷൻ തലങ്ങളിൽ നിങ്ങളുടെ കോഡ് ബെഞ്ച്മാർക്ക് ചെയ്യേണ്ടത് അത്യാവശ്യമാണ്. ഒരു പ്രോജക്റ്റിന് ഏറ്റവും മികച്ചതായി പ്രവർത്തിക്കുന്നത് മറ്റൊന്നിന് അനുയോജ്യമാകണമെന്നില്ല.

സാധാരണ കംപൈലർ ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ

ആധുനിക കംപൈലറുകൾ ഉപയോഗിക്കുന്ന ഏറ്റവും സാധാരണവും ഫലപ്രദവുമായ ചില ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ നമുക്ക് പരിശോധിക്കാം:

1. കോൺസ്റ്റൻ്റ് ഫോൾഡിംഗും പ്രൊപ്പഗേഷനും

റൺടൈമിലല്ലാതെ, കംപൈൽ സമയത്ത് സ്ഥിരമായ എക്സ്പ്രഷനുകൾ വിലയിരുത്തുന്നതാണ് കോൺസ്റ്റൻ്റ് ഫോൾഡിംഗ്. കോൺസ്റ്റൻ്റ് പ്രൊപ്പഗേഷൻ വേരിയബിളുകളെ അവയുടെ അറിയപ്പെടുന്ന സ്ഥിര മൂല്യങ്ങൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു.

ഉദാഹരണം:

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

കോൺസ്റ്റൻ്റ് ഫോൾഡിംഗും പ്രൊപ്പഗേഷനും നടത്തുന്ന ഒരു കംപൈലർ ഇതിനെ ഇങ്ങനെ മാറ്റിയേക്കാം:

int x = 10;
int y = 52;  // 10 * 5 + 2 എന്നത് കംപൈൽ സമയത്ത് വിലയിരുത്തുന്നു
int z = 26;  // 52 / 2 എന്നത് കംപൈൽ സമയത്ത് വിലയിരുത്തുന്നു

ചില സന്ദർഭങ്ങളിൽ, `x`, `y` എന്നിവ ഈ സ്ഥിരമായ എക്സ്പ്രഷനുകളിൽ മാത്രം ഉപയോഗിക്കുന്നുവെങ്കിൽ അവയെ പൂർണ്ണമായും ഒഴിവാക്കിയേക്കാം.

2. ഡെഡ് കോഡ് എലിമിനേഷൻ

പ്രോഗ്രാമിൻ്റെ ഔട്ട്പുട്ടിൽ ഒരു സ്വാധീനവും ചെലുത്താത്ത കോഡാണ് ഡെഡ് കോഡ്. ഉപയോഗിക്കാത്ത വേരിയബിളുകൾ, എത്തിച്ചേരാനാകാത്ത കോഡ് ബ്ലോക്കുകൾ (ഉദാഹരണത്തിന്, ഒരു നിരുപാധികമായ `return` സ്റ്റേറ്റ്മെൻ്റിന് ശേഷമുള്ള കോഡ്), എപ്പോഴും ഒരേ ഫലം നൽകുന്ന കണ്ടീഷണൽ ബ്രാഞ്ചുകൾ എന്നിവ ഇതിൽ ഉൾപ്പെടാം.

ഉദാഹരണം:

int x = 10;
if (false) {
  x = 20;  // ഈ ലൈൻ ഒരിക്കലും പ്രവർത്തിക്കുന്നില്ല
}
printf("x = %d\n", x);

കംപൈലർ `x = 20;` എന്ന ലൈൻ ഒഴിവാക്കും, കാരണം അത് എപ്പോഴും `false` ആയി വിലയിരുത്തുന്ന ഒരു `if` സ്റ്റേറ്റ്മെൻ്റിനുള്ളിലാണ്.

3. കോമൺ സബ് എക്സ്പ്രഷൻ എലിമിനേഷൻ (CSE)

CSE ആവർത്തന ഗണനങ്ങളെ തിരിച്ചറിയുകയും ഒഴിവാക്കുകയും ചെയ്യുന്നു. ഒരേ എക്സ്പ്രഷൻ ഒരേ ഓപ്പറാൻഡുകൾ ഉപയോഗിച്ച് ഒന്നിലധികം തവണ കണക്കാക്കുകയാണെങ്കിൽ, കംപൈലറിന് അത് ഒരു തവണ കണക്കാക്കി ഫലം വീണ്ടും ഉപയോഗിക്കാൻ കഴിയും.

ഉദാഹരണം:

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

`b * c` എന്ന എക്സ്പ്രഷൻ രണ്ടുതവണ കണക്കാക്കുന്നു. CSE ഇതിനെ ഇങ്ങനെ മാറ്റും:

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

ഇത് ഒരു ഗുണന പ്രവർത്തനം ലാഭിക്കുന്നു.

4. ലൂപ്പ് ഒപ്റ്റിമൈസേഷൻ

ലൂപ്പുകൾ പലപ്പോഴും പ്രകടനത്തിലെ തടസ്സങ്ങളാണ്, അതിനാൽ കംപൈലറുകൾ അവയെ ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിൽ കാര്യമായ ശ്രദ്ധ ചെലുത്തുന്നു.

• ലൂപ്പ് അൺറോളിംഗ്: ലൂപ്പ് ഓവർഹെഡ് കുറയ്ക്കുന്നതിന് (ഉദാഹരണത്തിന്, ലൂപ്പ് കൗണ്ടർ ഇൻക്രിമെൻ്റും കണ്ടീഷൻ ചെക്കും) ലൂപ്പ് ബോഡി ഒന്നിലധികം തവണ ആവർത്തിക്കുന്നു. ഇത് കോഡിൻ്റെ വലുപ്പം വർദ്ധിപ്പിക്കുമെങ്കിലും പലപ്പോഴും പ്രകടനം മെച്ചപ്പെടുത്തുന്നു, പ്രത്യേകിച്ച് ചെറിയ ലൂപ്പ് ബോഡികൾക്ക്.

  ഉദാഹരണം:

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

  ലൂപ്പ് അൺറോളിംഗ് (3 എന്ന ഘടകം ഉപയോഗിച്ച്) ഇതിനെ ഇങ്ങനെ മാറ്റിയേക്കാം:

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

  ലൂപ്പ് ഓവർഹെഡ് പൂർണ്ണമായും ഒഴിവാക്കപ്പെടുന്നു.

• ലൂപ്പ് ഇൻവേരിയൻ്റ് കോഡ് മോഷൻ: ലൂപ്പിനുള്ളിൽ മാറ്റമില്ലാത്ത കോഡിനെ ലൂപ്പിന് പുറത്തേക്ക് നീക്കുന്നു.

ഉദാഹരണം:

for (int i = 0; i < n; i++) {
  int x = y * z;  // y, z എന്നിവ ലൂപ്പിനുള്ളിൽ മാറുന്നില്ല
  a[i] = a[i] + x;
}

ലൂപ്പ് ഇൻവേരിയൻ്റ് കോഡ് മോഷൻ ഇതിനെ ഇങ്ങനെ മാറ്റും:

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

`y * z` എന്ന ഗുണനം ഇപ്പോൾ `n` തവണയ്ക്ക് പകരം ഒരു തവണ മാത്രം നടത്തുന്നു.

• ലൂപ്പ് ഫ്യൂഷൻ: ഒരേ ഡാറ്റയിൽ പ്രവർത്തിക്കുന്ന അടുത്തടുത്തുള്ള ലൂപ്പുകളെ സംയോജിപ്പിക്കുന്നു. ഇത് ഡാറ്റാ ലോക്കാലിറ്റി മെച്ചപ്പെടുത്തുകയും ലൂപ്പ് ഓവർഹെഡ് കുറയ്ക്കുകയും ചെയ്യും.

ഉദാഹരണം:

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

ലൂപ്പ് ഫ്യൂഷൻ ഇതിനെ ഇങ്ങനെ മാറ്റിയേക്കാം:

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

ഇത് ലൂപ്പ് ഓവർഹെഡ് കുറയ്ക്കുകയും കാഷെ ഉപയോഗം മെച്ചപ്പെടുത്തുകയും ചെയ്യും.

• ലൂപ്പ് ഇൻ്റർചേഞ്ച്: ഡാറ്റാ ലോക്കാലിറ്റി മെച്ചപ്പെടുത്തുന്നതിനും വെക്റ്ററൈസേഷൻ പ്രവർത്തനക്ഷമമാക്കുന്നതിനും നെസ്റ്റഡ് ലൂപ്പുകളുടെ ക്രമം മാറ്റുന്നു. മൾട്ടി-ഡൈമൻഷണൽ അറേകൾക്ക് ഇത് പ്രത്യേകിച്ചും ഫലപ്രദമാണ്.

ഉദാഹരണം (ഫോർട്രാനിൽ):

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

ഫോർട്രാനിൽ സാധാരണമായത് പോലെ `A`, `B`, `C` എന്നിവ കോളം-മേജർ ഓർഡറിലാണ് സംഭരിക്കുന്നതെങ്കിൽ, ഇന്നർ ലൂപ്പിൽ `A(i,j)` ആക്സസ് ചെയ്യുന്നത് തുടർച്ചയല്ലാത്ത മെമ്മറി ആക്സസ്സുകൾക്ക് കാരണമാകുന്നു. ലൂപ്പ് ഇൻ്റർചേഞ്ച് ലൂപ്പുകളെ സ്വാപ്പ് ചെയ്യും:

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

ഇപ്പോൾ ഇന്നർ ലൂപ്പ് `A`, `B`, `C` എന്നിവയുടെ ഘടകങ്ങളെ തുടർച്ചയായി ആക്സസ് ചെയ്യുന്നു, ഇത് കാഷെ പ്രകടനം മെച്ചപ്പെടുത്തുന്നു.

5. ഇൻലൈനിംഗ്

ഒരു ഫംഗ്ഷൻ കോളിനെ ഫംഗ്ഷൻ്റെ യഥാർത്ഥ കോഡ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നതാണ് ഇൻലൈനിംഗ്. ഇത് ഫംഗ്ഷൻ കോളിൻ്റെ ഓവർഹെഡ് ഒഴിവാക്കുന്നു (ഉദാഹരണത്തിന്, ആർഗ്യുമെൻ്റുകൾ സ്റ്റാക്കിലേക്ക് പുഷ് ചെയ്യുക, ഫംഗ്ഷൻ്റെ വിലാസത്തിലേക്ക് ജമ്പ് ചെയ്യുക), കൂടാതെ ഇൻലൈൻ ചെയ്ത കോഡിൽ കൂടുതൽ ഒപ്റ്റിമൈസേഷനുകൾ നടത്താൻ കംപൈലറിനെ അനുവദിക്കുന്നു.

ഉദാഹരണം:

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

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

`square` ഇൻലൈൻ ചെയ്യുന്നത് ഇതിനെ ഇങ്ങനെ മാറ്റും:

int main() {
  int y = 5 * 5; // ഫംഗ്ഷൻ കോളിനെ ഫംഗ്ഷൻ്റെ കോഡ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിച്ചു
  printf("y = %d\n", y);
  return 0;
}

ചെറിയ, പതിവായി വിളിക്കുന്ന ഫംഗ്ഷനുകൾക്ക് ഇൻലൈനിംഗ് പ്രത്യേകിച്ചും ഫലപ്രദമാണ്.

6. വെക്റ്ററൈസേഷൻ (SIMD)

വെക്റ്ററൈസേഷൻ, സിംഗിൾ ഇൻസ്ട്രക്ഷൻ, മൾട്ടിപ്പിൾ ഡാറ്റ (SIMD) എന്നും അറിയപ്പെടുന്നു, ഇത് ആധുനിക പ്രോസസ്സറുകളുടെ ഒരേ സമയം ഒന്നിലധികം ഡാറ്റാ ഘടകങ്ങളിൽ ഒരേ പ്രവർത്തനം നടത്താനുള്ള കഴിവ് പ്രയോജനപ്പെടുത്തുന്നു. കംപൈലറുകൾക്ക് കോഡ്, പ്രത്യേകിച്ച് ലൂപ്പുകൾ, വെക്റ്റർ ഇൻസ്ട്രക്ഷനുകൾ ഉപയോഗിച്ച് സ്കെയിലാർ പ്രവർത്തനങ്ങൾക്ക് പകരം യാന്ത്രികമായി വെക്റ്ററൈസ് ചെയ്യാൻ കഴിയും.

ഉദാഹരണം:

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

`a`, `b`, `c` എന്നിവ അലൈൻ ചെയ്തിട്ടുണ്ടെന്നും `n` വേണ്ടത്ര വലുതാണെന്നും കംപൈലർ കണ്ടെത്തിയാൽ, അത് SIMD ഇൻസ്ട്രക്ഷനുകൾ ഉപയോഗിച്ച് ഈ ലൂപ്പിനെ വെക്റ്ററൈസ് ചെയ്യാം. ഉദാഹരണത്തിന്, x86-ൽ SSE ഇൻസ്ട്രക്ഷനുകൾ ഉപയോഗിച്ച്, ഇത് ഒരേ സമയം നാല് ഘടകങ്ങൾ പ്രോസസ്സ് ചെയ്തേക്കാം:

__m128i vb = _mm_loadu_si128((__m128i*)&b[i]); // b-ൽ നിന്ന് 4 ഘടകങ്ങൾ ലോഡ് ചെയ്യുക
__m128i vc = _mm_loadu_si128((__m128i*)&c[i]); // c-ൽ നിന്ന് 4 ഘടകങ്ങൾ ലോഡ് ചെയ്യുക
__m128i va = _mm_add_epi32(vb, vc);           // 4 ഘടകങ്ങളെ സമാന്തരമായി കൂട്ടുക
_mm_storeu_si128((__m128i*)&a[i], va);           // 4 ഘടകങ്ങളെ a-ലേക്ക് സ്റ്റോർ ചെയ്യുക

പ്രത്യേകിച്ച് ഡാറ്റാ-പാരലൽ കമ്പ്യൂട്ടേഷനുകൾക്ക് വെക്റ്ററൈസേഷൻ കാര്യമായ പ്രകടന മെച്ചപ്പെടുത്തലുകൾ നൽകാൻ കഴിയും.

7. ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളിംഗ്

പൈപ്പ്‌ലൈൻ സ്റ്റാളുകൾ കുറച്ചുകൊണ്ട് പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളിംഗ് നിർദ്ദേശങ്ങളെ പുനഃക്രമീകരിക്കുന്നു. ആധുനിക പ്രോസസ്സറുകൾ ഒരേസമയം ഒന്നിലധികം നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാൻ പൈപ്പ്‌ലൈനിംഗ് ഉപയോഗിക്കുന്നു. എന്നിരുന്നാലും, ഡാറ്റാ ഡിപൻഡൻസികളും റിസോഴ്സ് കോൺഫ്ലിക്റ്റുകളും സ്റ്റാളുകൾക്ക് കാരണമാകും. ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളിംഗ് ഈ സ്റ്റാളുകൾ കുറയ്ക്കുന്നതിന് ഇൻസ്ട്രക്ഷൻ സീക്വൻസ് പുനഃക്രമീകരിച്ച് ലക്ഷ്യമിടുന്നു.

ഉദാഹരണം:

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

രണ്ടാമത്തെ നിർദ്ദേശം ആദ്യത്തെ നിർദ്ദേശത്തിൻ്റെ ഫലത്തെ ആശ്രയിച്ചിരിക്കുന്നു (ഡാറ്റാ ഡിപൻഡൻസി). ഇത് ഒരു പൈപ്പ്‌ലൈൻ സ്റ്റാളിന് കാരണമാകും. കംപൈലർ നിർദ്ദേശങ്ങളെ ഇതുപോലെ പുനഃക്രമീകരിച്ചേക്കാം:

a = b + c;
f = g + h; // സ്വതന്ത്രമായ നിർദ്ദേശം നേരത്തെ നീക്കുക
d = a * e;

ഇപ്പോൾ, `b + c` യുടെ ഫലം ലഭ്യമാകാൻ കാത്തിരിക്കുമ്പോൾ പ്രോസസ്സറിന് `f = g + h` എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയും, ഇത് സ്റ്റാൾ കുറയ്ക്കുന്നു.

8. രജിസ്റ്റർ അലോക്കേഷൻ

സിപിയുവിലെ ഏറ്റവും വേഗതയേറിയ സ്റ്റോറേജ് ലൊക്കേഷനുകളായ രജിസ്റ്ററുകളിലേക്ക് വേരിയബിളുകളെ നിയോഗിക്കുന്നതാണ് രജിസ്റ്റർ അലോക്കേഷൻ. മെമ്മറിയിലെ ഡാറ്റ ആക്സസ് ചെയ്യുന്നതിനേക്കാൾ വളരെ വേഗത്തിലാണ് രജിസ്റ്ററുകളിലെ ഡാറ്റ ആക്സസ് ചെയ്യുന്നത്. കംപൈലർ കഴിയുന്നത്ര വേരിയബിളുകളെ രജിസ്റ്ററുകളിലേക്ക് അനുവദിക്കാൻ ശ്രമിക്കുന്നു, എന്നാൽ രജിസ്റ്ററുകളുടെ എണ്ണം പരിമിതമാണ്. കാര്യക്ഷമമായ രജിസ്റ്റർ അലോക്കേഷൻ പ്രകടനത്തിന് നിർണ്ണായകമാണ്.

ഉദാഹരണം:

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

അഡീഷൻ പ്രവർത്തന സമയത്ത് മെമ്മറി ആക്സസ് ഒഴിവാക്കാൻ കംപൈലർ `x`, `y`, `z` എന്നിവയെ രജിസ്റ്ററുകളിലേക്ക് അനുവദിക്കാൻ ശ്രമിക്കും.

അടിസ്ഥാനങ്ങൾക്കപ്പുറം: നൂതന ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കുകൾ

മുകളിൽ പറഞ്ഞ ടെക്നിക്കുകൾ സാധാരണയായി ഉപയോഗിക്കപ്പെടുന്നുണ്ടെങ്കിലും, കംപൈലറുകൾ കൂടുതൽ നൂതനമായ ഒപ്റ്റിമൈസേഷനുകളും ഉപയോഗിക്കുന്നു, അവയിൽ ചിലത്:

• ഇൻ്റർപ്രൊസീജറൽ ഒപ്റ്റിമൈസേഷൻ (IPO): ഫംഗ്ഷൻ അതിരുകൾക്കപ്പുറത്തും ഒപ്റ്റിമൈസേഷനുകൾ നടത്തുന്നു. വിവിധ കംപൈലേഷൻ യൂണിറ്റുകളിൽ നിന്നുള്ള ഫംഗ്ഷനുകൾ ഇൻലൈൻ ചെയ്യുക, ഗ്ലോബൽ കോൺസ്റ്റൻ്റ് പ്രൊപ്പഗേഷൻ നടത്തുക, പ്രോഗ്രാമിലുടനീളം ഡെഡ് കോഡ് ഒഴിവാക്കുക എന്നിവ ഇതിൽ ഉൾപ്പെടാം. ലിങ്ക് സമയത്ത് നടത്തുന്ന IPO യുടെ ഒരു രൂപമാണ് ലിങ്ക്-ടൈം ഒപ്റ്റിമൈസേഷൻ (LTO).
• പ്രൊഫൈൽ-ഗൈഡഡ് ഒപ്റ്റിമൈസേഷൻ (PGO): പ്രോഗ്രാം എക്സിക്യൂഷൻ സമയത്ത് ശേഖരിച്ച പ്രൊഫൈലിംഗ് ഡാറ്റ ഉപയോഗിച്ച് ഒപ്റ്റിമൈസേഷൻ തീരുമാനങ്ങളെ നയിക്കുന്നു. ഉദാഹരണത്തിന്, ഇത് പതിവായി എക്സിക്യൂട്ട് ചെയ്യുന്ന കോഡ് പാതകൾ തിരിച്ചറിയാനും ആ മേഖലകളിൽ ഇൻലൈനിംഗിനും ലൂപ്പ് അൺറോളിംഗിനും മുൻഗണന നൽകാനും കഴിയും. PGO പലപ്പോഴും കാര്യമായ പ്രകടന മെച്ചപ്പെടുത്തലുകൾ നൽകാൻ കഴിയും, എന്നാൽ പ്രൊഫൈൽ ചെയ്യാൻ ഒരു പ്രതിനിധി വർക്ക്ലോഡ് ആവശ്യമാണ്.
• ഓട്ടോപാരലലൈസേഷൻ: സീക്വൻഷ്യൽ കോഡിനെ ഒന്നിലധികം പ്രോസസ്സറുകളിലോ കോറുകളിലോ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയുന്ന പാരലൽ കോഡിലേക്ക് യാന്ത്രികമായി പരിവർത്തനം ചെയ്യുന്നു. ഇത് ഒരു വെല്ലുവിളി നിറഞ്ഞ ജോലിയാണ്, കാരണം ഇതിന് സ്വതന്ത്രമായ കമ്പ്യൂട്ടേഷനുകൾ തിരിച്ചറിയുകയും ശരിയായ സിൻക്രൊണൈസേഷൻ ഉറപ്പാക്കുകയും വേണം.
• സ്പെക്കുലേറ്റീവ് എക്സിക്യൂഷൻ: കംപൈലർ ഒരു ബ്രാഞ്ചിൻ്റെ ഫലം പ്രവചിക്കുകയും ബ്രാഞ്ച് കണ്ടീഷൻ യഥാർത്ഥത്തിൽ അറിയുന്നതിന് മുമ്പ് പ്രവചിച്ച പാതയിലൂടെ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്തേക്കാം. പ്രവചനം ശരിയാണെങ്കിൽ, എക്സിക്യൂഷൻ കാലതാമസമില്ലാതെ തുടരുന്നു. പ്രവചനം തെറ്റാണെങ്കിൽ, സ്പെക്കുലേറ്റീവ് ആയി എക്സിക്യൂട്ട് ചെയ്ത കോഡ് ഉപേക്ഷിക്കുന്നു.

പ്രായോഗിക പരിഗണനകളും മികച്ച രീതികളും

• നിങ്ങളുടെ കംപൈലർ മനസ്സിലാക്കുക: നിങ്ങളുടെ കംപൈലർ പിന്തുണയ്ക്കുന്ന ഒപ്റ്റിമൈസേഷൻ ഫ്ലാഗുകളും ഓപ്ഷനുകളും പരിചയപ്പെടുക. വിശദമായ വിവരങ്ങൾക്കായി കംപൈലറിൻ്റെ ഡോക്യുമെൻ്റേഷൻ പരിശോധിക്കുക.
• പതിവായി ബെഞ്ച്മാർക്ക് ചെയ്യുക: ഓരോ ഒപ്റ്റിമൈസേഷനുശേഷവും നിങ്ങളുടെ കോഡിൻ്റെ പ്രകടനം അളക്കുക. ഒരു പ്രത്യേക ഒപ്റ്റിമൈസേഷൻ എല്ലായ്പ്പോഴും പ്രകടനം മെച്ചപ്പെടുത്തുമെന്ന് കരുതരുത്.
• നിങ്ങളുടെ കോഡ് പ്രൊഫൈൽ ചെയ്യുക: പ്രകടനത്തിലെ തടസ്സങ്ങൾ തിരിച്ചറിയാൻ പ്രൊഫൈലിംഗ് ടൂളുകൾ ഉപയോഗിക്കുക. മൊത്തത്തിലുള്ള എക്സിക്യൂഷൻ സമയത്തിന് ഏറ്റവും കൂടുതൽ സംഭാവന നൽകുന്ന മേഖലകളിൽ നിങ്ങളുടെ ഒപ്റ്റിമൈസേഷൻ ശ്രമങ്ങൾ കേന്ദ്രീകരിക്കുക.
• വൃത്തിയുള്ളതും വായിക്കാൻ എളുപ്പമുള്ളതുമായ കോഡ് എഴുതുക: നന്നായി ചിട്ടപ്പെടുത്തിയ കോഡ് കംപൈലറിന് വിശകലനം ചെയ്യാനും ഒപ്റ്റിമൈസ് ചെയ്യാനും എളുപ്പമാണ്. ഒപ്റ്റിമൈസേഷനെ തടസ്സപ്പെടുത്തുന്ന സങ്കീർണ്ണവും വളഞ്ഞതുമായ കോഡ് ഒഴിവാക്കുക.
• അനുയോജ്യമായ ഡാറ്റാ സ്ട്രക്ച്ചറുകളും അൽഗോരിതങ്ങളും ഉപയോഗിക്കുക: ഡാറ്റാ സ്ട്രക്ച്ചറുകളുടെയും അൽഗോരിതങ്ങളുടെയും തിരഞ്ഞെടുപ്പ് പ്രകടനത്തിൽ കാര്യമായ സ്വാധീനം ചെലുത്തും. നിങ്ങളുടെ നിർദ്ദിഷ്ട പ്രശ്നത്തിന് ഏറ്റവും കാര്യക്ഷമമായ ഡാറ്റാ സ്ട്രക്ച്ചറുകളും അൽഗോരിതങ്ങളും തിരഞ്ഞെടുക്കുക. ഉദാഹരണത്തിന്, ഒരു ലീനിയർ സെർച്ചിന് പകരം ലുക്കപ്പുകൾക്കായി ഒരു ഹാഷ് ടേബിൾ ഉപയോഗിക്കുന്നത് പല സാഹചര്യങ്ങളിലും പ്രകടനം ഗണ്യമായി മെച്ചപ്പെടുത്താൻ കഴിയും.
• ഹാർഡ്‌വെയർ-നിർദ്ദിഷ്ട ഒപ്റ്റിമൈസേഷനുകൾ പരിഗണിക്കുക: ചില കംപൈലറുകൾ നിർദ്ദിഷ്ട ഹാർഡ്‌വെയർ ആർക്കിടെക്ചറുകളെ ലക്ഷ്യം വയ്ക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് ടാർഗെറ്റ് പ്രോസസ്സറിൻ്റെ സവിശേഷതകൾക്കും കഴിവുകൾക്കും അനുയോജ്യമായ ഒപ്റ്റിമൈസേഷനുകൾ പ്രവർത്തനക്ഷമമാക്കും.
• അകാല ഒപ്റ്റിമൈസേഷൻ ഒഴിവാക്കുക: പ്രകടനത്തിലെ തടസ്സമല്ലാത്ത കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യാൻ കൂടുതൽ സമയം ചെലവഴിക്കരുത്. ഏറ്റവും പ്രധാനപ്പെട്ട മേഖലകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുക. ഡൊണാൾഡ് നൂത്ത് പ്രസിദ്ധമായി പറഞ്ഞതുപോലെ: "അകാല ഒപ്റ്റിമൈസേഷൻ പ്രോഗ്രാമിംഗിലെ എല്ലാ തിന്മകളുടെയും (അല്ലെങ്കിൽ അതിൻ്റെ ഭൂരിഭാഗത്തിൻ്റെയും) മൂലകാരണമാണ്."
• സൂക്ഷ്മമായി പരിശോധിക്കുക: നിങ്ങളുടെ ഒപ്റ്റിമൈസ് ചെയ്ത കോഡ് സൂക്ഷ്മമായി പരിശോധിച്ച് അത് ശരിയാണെന്ന് ഉറപ്പാക്കുക. ഒപ്റ്റിമൈസേഷൻ ചിലപ്പോൾ സൂക്ഷ്മമായ ബഗുകൾക്ക് കാരണമായേക്കാം.
• പ്രതിഫലങ്ങളെക്കുറിച്ച് ബോധവാന്മാരായിരിക്കുക: ഒപ്റ്റിമൈസേഷൻ പലപ്പോഴും പ്രകടനം, കോഡിൻ്റെ വലുപ്പം, കംപൈലേഷൻ സമയം എന്നിവ തമ്മിലുള്ള പ്രതിഫലങ്ങൾ ഉൾക്കൊള്ളുന്നു. നിങ്ങളുടെ നിർദ്ദിഷ്ട ആവശ്യങ്ങൾക്കായി ശരിയായ ബാലൻസ് തിരഞ്ഞെടുക്കുക. ഉദാഹരണത്തിന്, ശക്തമായ ലൂപ്പ് അൺറോളിംഗ് പ്രകടനം മെച്ചപ്പെടുത്തുമെങ്കിലും കോഡിൻ്റെ വലുപ്പം ഗണ്യമായി വർദ്ധിപ്പിക്കും.
• കംപൈലർ സൂചനകൾ പ്രയോജനപ്പെടുത്തുക (പ്രാഗ്മകൾ/ആട്രിബ്യൂട്ടുകൾ): പല കംപൈലറുകളും ചില കോഡ് ഭാഗങ്ങൾ എങ്ങനെ ഒപ്റ്റിമൈസ് ചെയ്യണമെന്നതിനെക്കുറിച്ച് കംപൈലറിന് സൂചനകൾ നൽകാൻ സംവിധാനങ്ങൾ നൽകുന്നു (ഉദാ. C/C++ ൽ പ്രാഗ്മകൾ, റസ്റ്റിൽ ആട്രിബ്യൂട്ടുകൾ). ഉദാഹരണത്തിന്, ഒരു ഫംഗ്ഷൻ ഇൻലൈൻ ചെയ്യണമെന്നോ ഒരു ലൂപ്പ് വെക്റ്ററൈസ് ചെയ്യാമെന്നോ നിർദ്ദേശിക്കാൻ നിങ്ങൾക്ക് പ്രാഗ്മകൾ ഉപയോഗിക്കാം. എന്നിരുന്നാലും, ഈ സൂചനകൾ പാലിക്കാൻ കംപൈലർ ബാധ്യസ്ഥനല്ല.

ഗ്ലോബൽ കോഡ് ഒപ്റ്റിമൈസേഷൻ സാഹചര്യങ്ങളുടെ ഉദാഹരണങ്ങൾ

• ഹൈ-ഫ്രീക്വൻസി ട്രേഡിംഗ് (HFT) സിസ്റ്റങ്ങൾ: സാമ്പത്തിക വിപണികളിൽ, മൈക്രോസെക്കൻഡ് മെച്ചപ്പെടുത്തലുകൾ പോലും കാര്യമായ ലാഭത്തിലേക്ക് നയിച്ചേക്കാം. ഏറ്റവും കുറഞ്ഞ ലേറ്റൻസിക്കായി ട്രേഡിംഗ് അൽഗോരിതങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ കംപൈലറുകൾ വ്യാപകമായി ഉപയോഗിക്കുന്നു. ഈ സിസ്റ്റങ്ങൾ പലപ്പോഴും യഥാർത്ഥ ലോക വിപണി ഡാറ്റയെ അടിസ്ഥാനമാക്കി എക്സിക്യൂഷൻ പാതകൾ ഫൈൻ-ട്യൂൺ ചെയ്യാൻ PGO പ്രയോജനപ്പെടുത്തുന്നു. വലിയ അളവിലുള്ള മാർക്കറ്റ് ഡാറ്റ സമാന്തരമായി പ്രോസസ്സ് ചെയ്യുന്നതിന് വെക്റ്ററൈസേഷൻ നിർണ്ണായകമാണ്.
• മൊബൈൽ ആപ്ലിക്കേഷൻ ഡെവലപ്മെൻ്റ്: മൊബൈൽ ഉപയോക്താക്കൾക്ക് ബാറ്ററി ലൈഫ് ഒരു നിർണായക ആശങ്കയാണ്. മെമ്മറി ആക്സസ്സുകൾ കുറച്ചും, ലൂപ്പ് എക്സിക്യൂഷൻ ഒപ്റ്റിമൈസ് ചെയ്തും, പവർ-കാര്യക്ഷമമായ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ചും ഊർജ്ജ ഉപഭോഗം കുറയ്ക്കാൻ കംപൈലറുകൾക്ക് മൊബൈൽ ആപ്ലിക്കേഷനുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ കഴിയും. `-Os` ഒപ്റ്റിമൈസേഷൻ പലപ്പോഴും കോഡിൻ്റെ വലുപ്പം കുറയ്ക്കാൻ ഉപയോഗിക്കുന്നു, ഇത് ബാറ്ററി ലൈഫ് കൂടുതൽ മെച്ചപ്പെടുത്തുന്നു.
• എംബഡഡ് സിസ്റ്റംസ് ഡെവലപ്മെൻ്റ്: എംബഡഡ് സിസ്റ്റങ്ങൾക്ക് പലപ്പോഴും പരിമിതമായ വിഭവങ്ങളാണുള്ളത് (മെമ്മറി, പ്രോസസ്സിംഗ് പവർ). ഈ പരിമിതികൾക്കായി കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിൽ കംപൈലറുകൾ ഒരു സുപ്രധാന പങ്ക് വഹിക്കുന്നു. `-Os` ഒപ്റ്റിമൈസേഷൻ, ഡെഡ് കോഡ് എലിമിനേഷൻ, കാര്യക്ഷമമായ രജിസ്റ്റർ അലോക്കേഷൻ തുടങ്ങിയ ടെക്നിക്കുകൾ അത്യാവശ്യമാണ്. റിയൽ-ടൈം ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളും (RTOS) പ്രവചിക്കാവുന്ന പ്രകടനത്തിനായി കംപൈലർ ഒപ്റ്റിമൈസേഷനുകളെ വളരെയധികം ആശ്രയിക്കുന്നു.
• ശാസ്ത്രീയ കമ്പ്യൂട്ടിംഗ്: ശാസ്ത്രീയ സിമുലേഷനുകളിൽ പലപ്പോഴും കമ്പ്യൂട്ടേഷണൽ-ഇൻ്റൻസീവ് കണക്കുകൂട്ടലുകൾ ഉൾപ്പെടുന്നു. ഈ സിമുലേഷനുകൾ ത്വരിതപ്പെടുത്തുന്നതിന് കോഡ് വെക്റ്ററൈസ് ചെയ്യാനും ലൂപ്പുകൾ അൺറോൾ ചെയ്യാനും മറ്റ് ഒപ്റ്റിമൈസേഷനുകൾ പ്രയോഗിക്കാനും കംപൈലറുകൾ ഉപയോഗിക്കുന്നു. ഫോർട്രാൻ കംപൈലറുകൾ, പ്രത്യേകിച്ചും, അവയുടെ നൂതന വെക്റ്ററൈസേഷൻ കഴിവുകൾക്ക് പേരുകേട്ടതാണ്.
• ഗെയിം ഡെവലപ്മെൻ്റ്: ഗെയിം ഡെവലപ്പർമാർ ഉയർന്ന ഫ്രെയിം റേറ്റുകൾക്കും കൂടുതൽ റിയലിസ്റ്റിക് ഗ്രാഫിക്സിനും വേണ്ടി നിരന്തരം പരിശ്രമിക്കുന്നു. റെൻഡറിംഗ്, ഫിസിക്സ്, ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് തുടങ്ങിയ മേഖലകളിൽ പ്രകടനത്തിനായി ഗെയിം കോഡ് ഒപ്റ്റിമൈസ് ചെയ്യാൻ കംപൈലറുകൾ ഉപയോഗിക്കുന്നു. ജിപിയു, സിപിയു വിഭവങ്ങളുടെ പരമാവധി വിനിയോഗത്തിന് വെക്റ്ററൈസേഷനും ഇൻസ്ട്രക്ഷൻ ഷെഡ്യൂളിംഗും നിർണ്ണായകമാണ്.
• ക്ലൗഡ് കമ്പ്യൂട്ടിംഗ്: ക്ലൗഡ് പരിതസ്ഥിതികളിൽ കാര്യക്ഷമമായ വിഭവ വിനിയോഗം പരമപ്രധാനമാണ്. സിപിയു ഉപയോഗം, മെമ്മറി ഫൂട്ട്പ്രിൻ്റ്, നെറ്റ്‌വർക്ക് ബാൻഡ്‌വിഡ്ത്ത് ഉപഭോഗം എന്നിവ കുറയ്ക്കുന്നതിന് ക്ലൗഡ് ആപ്ലിക്കേഷനുകൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ കംപൈലറുകൾക്ക് കഴിയും, ഇത് പ്രവർത്തനച്ചെലവ് കുറയ്ക്കുന്നതിലേക്ക് നയിക്കുന്നു.

ഉപസംഹാരം

സോഫ്റ്റ്‌വെയർ പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനുള്ള ഒരു ശക്തമായ ഉപകരണമാണ് കംപൈലർ ഒപ്റ്റിമൈസേഷൻ. കംപൈലറുകൾ ഉപയോഗിക്കുന്ന ടെക്നിക്കുകൾ മനസ്സിലാക്കുന്നതിലൂടെ, ഡെവലപ്പർമാർക്ക് ഒപ്റ്റിമൈസേഷന് കൂടുതൽ അനുയോജ്യമായ കോഡ് എഴുതാനും കാര്യമായ പ്രകടന നേട്ടങ്ങൾ കൈവരിക്കാനും കഴിയും. മാനുവൽ ഒപ്റ്റിമൈസേഷന് അതിൻ്റേതായ സ്ഥാനമുണ്ടെങ്കിലും, ആധുനിക കംപൈലറുകളുടെ ശക്തി പ്രയോജനപ്പെടുത്തുന്നത് ആഗോള പ്രേക്ഷകർക്കായി ഉയർന്ന പ്രകടനമുള്ളതും കാര്യക്ഷമവുമായ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിൻ്റെ ഒരു പ്രധാന ഭാഗമാണ്. ഒപ്റ്റിമൈസേഷനുകൾ ആഗ്രഹിക്കുന്ന ഫലങ്ങൾ നൽകുന്നുണ്ടെന്നും പുതിയ പിഴവുകൾ ഉണ്ടാക്കുന്നില്ലെന്നും ഉറപ്പാക്കാൻ നിങ്ങളുടെ കോഡ് ബെഞ്ച്മാർക്ക് ചെയ്യാനും സൂക്ഷ്മമായി പരിശോധിക്കാനും ഓർമ്മിക്കുക.