තොගය සහ ගොඩවල් මොනවාද සහ කොහේද?

ක්රමලේඛන භාෂාව පොත් අගය වර්ග මත නිර්මාණය කළ පැහැදිලි අඩුක්කුව , සහ යොමු වර්ග මත නිර්මාණය කරනු ගොඩක් මේ දේවල් දෙකක් කුමක් ද යන්න පැහැදිලි නැති,. මම මේ පිළිබඳ පැහැදිලි පැහැදිලි කිරීමක් කියවා නැත. තොගයක් යනු කුමක්දැයි මට තේරේ . එහෙත්,

• ඒවා කොහේද සහ මොනවාද (භෞතිකව සැබෑ පරිගණකයක මතකයේ)?
• මෙහෙයුම් පද්ධතිය හෝ භාෂා ධාවන කාලය මඟින් ඒවා කොතෙක් දුරට පාලනය වේද?
• ඔවුන්ගේ විෂය පථය කුමක්ද?
• එක් එක් ප්‍රමාණය තීරණය කරන්නේ කුමක් ද?
• එකක් වේගවත් කරන්නේ කුමක් ද?

තොගය යනු ක්‍රියාත්මක කිරීමේ නූල් සඳහා සීරීම් අවකාශයක් ලෙස වෙන් කර ඇති මතකයයි. ශ්‍රිතයක් හැඳින්වූ විට, දේශීය විචල්‍යයන් සහ පොත් තැබීමේ දත්ත සඳහා තොගයේ මුදුනේ බ්ලොක් එකක් වෙන් කර ඇත. එම ශ්‍රිතය නැවත පැමිණෙන විට, වාරණය භාවිතයට නොගන්නා අතර ඊළඟ වතාවේ ශ්‍රිතයක් හැඳින්වූ විට එය භාවිතා කළ හැකිය. තොගය සෑම විටම LIFO (පළමු වරට අවසන්) අනුපිළිවෙලකට වෙන් කර ඇත; වඩාත්ම මෑතකදී වෙන් කර ඇති කොටස සෑම විටම නිදහස් කළ යුතු ඊළඟ කොටසයි. මෙය තොගයේ සටහන් තබා ගැනීම සැබවින්ම සරල කරයි; තොගයෙන් කොටස නිදහස් කිරීම යනු එක් දර්ශකයක් සකස් කිරීමට වඩා වැඩි දෙයක් නොවේ.

සංචය යනු ගතික වෙන් කිරීම සඳහා වෙන් කර ඇති මතකයයි. තොගය මෙන් නොව, ගොඩවල් වලින් කුට්ටි වෙන් කිරීම හා බෙදා හැරීම සඳහා බලාත්මක රටාවක් නොමැත; ඔබට ඕනෑම වේලාවක වාරණයක් වෙන් කර ඕනෑම වේලාවක එය නිදහස් කළ හැකිය. ඕනෑම වේලාවක ගොඩවල් වෙන් කර ඇති හෝ නිදහස් කර ඇති කොටස් මොනවාදැයි සොයා බැලීම වඩාත් සංකීර්ණ කරයි; විවිධ භාවිත රටාවන් සඳහා ගොඩවල් ක්‍රියාකාරිත්වය සුසර කිරීම සඳහා අභිරුචි ගොඩවල් වෙන් කරන්නන් බොහෝ ඇත.

සෑම නූල් එකකටම තොගයක් ලැබෙන අතර, යෙදුම සඳහා සාමාන්‍යයෙන් ඇත්තේ එක ගොඩකි (විවිධ වර්ගවල වෙන් කිරීම් සඳහා බහු ගොඩවල් තිබීම සාමාන්‍ය දෙයක් නොවේ).

ඔබේ ප්‍රශ්න වලට කෙලින්ම පිළිතුරු දීමට:

මෙහෙයුම් පද්ධතිය හෝ භාෂා ධාවන කාලය මඟින් ඒවා කොතෙක් දුරට පාලනය වේද?

නූල් නිර්මාණය කරන විට මෙහෙයුම් පද්ධතිය එක් එක් පද්ධති මට්ටමේ නූල් සඳහා තොගය වෙන් කරයි. යෙදුම සඳහා ගොඩවල් වෙන් කිරීම සඳහා සාමාන්‍යයෙන් මෙහෙයුම් පද්ධතිය භාෂා ධාවන වේලාව මගින් හැඳින්වේ.

ඔවුන්ගේ විෂය පථය කුමක්ද?

තොගය නූල් එකකට අමුණා ඇත, එබැවින් නූල් තොගයෙන් පිටවන විට නැවත ගොඩගනු ලැබේ. යෙදුම් වේලාවේදී ගොඩගැසීම සාමාන්‍යයෙන් වෙන් කරනු ලබන්නේ ධාවන වේලාව වන අතර, යෙදුම (තාක්ෂණික ක්‍රියාවලිය) පිටවන විට එය නැවත ලබා ගනී.

එක් එක් ප්‍රමාණය තීරණය කරන්නේ කුමක් ද?

නූල් එකක් සාදන විට තොගයේ ප්‍රමාණය සකසා ඇත. යෙදුම් ආරම්භයේ දී සංචයේ ප්‍රමාණය සකසා ඇත, නමුත් අවකාශය අවශ්‍ය වන විට වර්ධනය විය හැකිය (විබෙදුම්කරු මෙහෙයුම් පද්ධතියෙන් වැඩි මතකයක් ඉල්ලා සිටී).

එකක් වේගවත් කරන්නේ කුමක් ද?

පැකේජය වේගවත් වන්නේ ප්‍රවේශ රටාව නිසා එයින් මතකය වෙන් කිරීම හා විස්ථාපනය කිරීම ඉතා සුළු කාරණයක් වන බැවිනි (දර්ශකයක් / නිඛිලයක් සරලව වැඩි කිරීම හෝ අඩු කිරීම), සහ ගොඩට වඩා සංකීර්ණ පොත් තැබීමක් වෙන් කිරීමකට හෝ වෙන් කිරීමකට සම්බන්ධ වේ. එසේම, තොගයේ ඇති සෑම බයිටයක්ම නැවත නැවත භාවිතා කිරීමට නැඹුරු වන අතර එයින් අදහස් වන්නේ එය ප්‍රොසෙසරයේ හැඹිලියට සිතියම් ගත කිරීමට නැඹුරු වන අතර එය ඉතා වේගවත් කරයි. ගොඩට තවත් කාර්ය සාධනයක් වන්නේ ගොඩවල් බොහෝ දුරට ගෝලීය සම්පතක් වන බැවින් සාමාන්‍යයෙන් බහු-නූල් ආරක්ෂිත විය යුතුය, එනම් එක් එක් වෙන් කිරීම සහ බැහැර කිරීම අවශ්‍ය වේ - සාමාන්‍යයෙන් - වැඩසටහනේ ඇති “සියලු” ගොඩවල් ප්‍රවේශයන් සමඟ සමමුහුර්ත කිරීම.

පැහැදිලි නිරූපණයක්:
_{රූප මූලාශ්‍රය: vikashazrati.wordpress.com}

සිරස්:

• ගොඩවල් මෙන් පරිගණක RAM තුළ ගබඩා කර ඇත.
• තොගයේ නිර්මාණය කරන ලද විචල්‍යයන් විෂය පථයෙන් බැහැර වී ස්වයංක්‍රීයව ඉවත් කරනු ලැබේ.
• සංචයේ විචල්‍යයන්ට සාපේක්ෂව වෙන් කිරීමට වඩා වේගවත්.
• සත්‍ය තොග දත්ත ව්‍යුහයක් සමඟ ක්‍රියාත්මක කර ඇත.
• පරාමිති සම්මත කිරීම සඳහා භාවිතා කරන දේශීය දත්ත, ආපසු ලිපින, ගබඩා කරයි.
• තොගයේ වැඩි ප්‍රමාණයක් භාවිතා කරන විට (බොහෝ දුරට අනන්ත හෝ ගැඹුරු පුනරාවර්තනයෙන්, ඉතා විශාල ප්‍රතිපාදන වලින්) තොග පිටාර ගැලීමක් සිදුවිය හැකිය.
• පොකුරේ සාදන ලද දත්ත දර්ශකයන් නොමැතිව භාවිතා කළ හැකිය.
• කාලය සම්පාදනය කිරීමට පෙර කොපමණ දත්ත ප්‍රමාණයක් වෙන් කළ යුතුදැයි ඔබ හරියටම දන්නේ නම් සහ එය එතරම් විශාල නොවේ නම් ඔබ තොගය භාවිතා කරනු ඇත.
• සාමාන්‍යයෙන් ඔබේ වැඩසටහන ආරම්භ වන විට දැනටමත් තීරණය කර ඇති උපරිම ප්‍රමාණය ඇත.

ගොඩවල්:

• පරිගණක RAM තුළ ගබඩා කර ඇති ආකාරයටම ගබඩා කර ඇත.
• C ++ හි, සංචයේ විචල්‍යයන් අතින් විනාශ කළ යුතු අතර කිසි විටෙකත් විෂය පථයෙන් බැහැර නොවේ. දත්ත සමඟ දින්නත් delete, delete[]හෝ free.
• තොගයේ විචල්‍යයන්ට සාපේක්ෂව වෙන් කිරීම මන්දගාමී වේ.
• වැඩසටහන භාවිතා කිරීම සඳහා දත්ත කාණ්ඩයක් වෙන් කිරීම සඳහා ඉල්ලුම මත භාවිතා වේ.
• විශාල ප්‍රතිපාදන හා විසර්ජන ඇති විට ඛණ්ඩනය විය හැකිය.
• C ++ හෝ C දී, ගොඩවල් මත සාදන ලද දත්ත දර්ශකයන් විසින් පෙන්වා ඒවා පිළිවෙලින් newහෝ වෙන් කරනු ලැබේ malloc.
• බෆරයේ විශාල ප්‍රමාණයක් වෙන් කිරීමට ඉල්ලා සිටියහොත් ප්‍රතිපාදන අසමත්වීම් සිදුවිය හැකිය.
• ධාවන වේලාවේදී ඔබට කොපමණ දත්ත ප්‍රමාණයක් අවශ්‍ය දැයි ඔබ නොදන්නේ නම් හෝ ඔබට විශාල දත්ත ප්‍රමාණයක් වෙන් කිරීමට අවශ්‍ය නම් ඔබ ගොඩවල් භාවිතා කරනු ඇත.
• මතක කාන්දුවීම් සඳහා වගකිව යුතු ය.

උදාහරණයක්:

int foo()
{
  char *pBuffer; //<--nothing allocated yet (excluding the pointer itself, which is allocated here on the stack).
  bool b = true; // Allocated on the stack.
  if(b)
  {
    //Create 500 bytes on the stack
    char buffer[500];

    //Create 500 bytes on the heap
    pBuffer = new char[500];

   }//<-- buffer is deallocated here, pBuffer is not
}//<--- oops there's a memory leak, I should have called delete[] pBuffer;

වැදගත්ම කරුණ නම්, ගොඩවල් සහ සිරස් යනු මතකය වෙන් කළ හැකි ක්‍රම සඳහා වූ සාමාන්‍ය පද වේ. ඒවා විවිධාකාරයෙන් ක්‍රියාත්මක කළ හැකි අතර නියමයන් මූලික සංකල්පවලට අදාළ වේ.

• අයිතම රාශියක් තුළ, අයිතමයන් ඒවා තැබූ අනුපිළිවෙලට එකින් එක උඩින් හිඳින අතර ඔබට කළ හැක්කේ ඉහළම එක පමණි (සියල්ල පෙරළා නොගෙන).

  

  තොගයක සරල බව නම්, වෙන් කරන ලද මතකයේ එක් එක් කොටස පිළිබඳ වාර්තාවක් අඩංගු වගුවක් පවත්වා ගැනීමට ඔබට අවශ්‍ය නොවන බවයි; ඔබට අවශ්‍ය එකම රාජ්‍ය තොරතුරු තොගයේ අවසානය දක්වා තනි දර්ශකයක් පමණි. වෙන් කිරීම සහ වෙන් කිරීම සඳහා, ඔබ එම තනි දර්ශකය වැඩි කර අඩු කරන්න. සටහන: සමහර විට මතක කොටසක ඉහළින් ආරම්භ කර ඉහළට වැඩෙනවාට වඩා පහළට විහිදීමට තොගයක් ක්‍රියාත්මක කළ හැකිය.

• ගොඩක දී, අයිතම තබා ඇති ආකාරය පිළිබඳ නිශ්චිත අනුපිළිවෙලක් නොමැත. පැහැදිලි 'ඉහළ' අයිතමයක් නොමැති නිසා ඔබට ඕනෑම අනුපිළිවෙලකට අයිතම වෙත ළඟා වී ඉවත් කළ හැකිය.

  

  ගොඩවල් වෙන් කිරීම සඳහා මතකය වෙන් කර ඇති දේ සහ නැති දේ පිළිබඳ සම්පූර්ණ වාර්තාවක් පවත්වා ගැනීම මෙන්ම ඛණ්ඩනය අඩු කිරීම සඳහා සමහර පොදු කාර්ය නඩත්තු කිරීම, ඉල්ලූ ප්‍රමාණයට සරිලන තරම් විශාල පරස්පර මතක කොටස් සොයා ගැනීම යනාදිය අවශ්‍ය වේ. මතකය ඕනෑම වේලාවක නිදහස් ඉඩක් අතහැර දැමිය හැකිය. සමහර විට මතක විබෙදන්නෙකු විසින් වෙන් කරන ලද මතකය වටා චලනය කිරීමෙන් මතකය විකෘති කිරීම හෝ කසළ එකතු කිරීම වැනි නඩත්තු කාර්යයන් සිදු කරනු ඇත - මතකය තවදුරටත් විෂය පථයේ නොමැති විට ධාවන වේලාවේදී හඳුනා ගැනීම සහ එය අවලංගු කිරීම.

මෙම පින්තූර මඟින් තොගයක් සහ ගොඩවල් තුළ මතකය වෙන් කිරීම හා නිදහස් කිරීම යන ක්‍රම දෙක විස්තර කිරීමේ තරමක් හොඳ කාර්යයක් කළ යුතුය. ඔව්!

• මෙහෙයුම් පද්ධතිය හෝ භාෂා ධාවන කාලය මඟින් ඒවා කොතෙක් දුරට පාලනය වේද?

  සඳහන් කළ පරිදි, ගොඩවල් සහ සිරස් යනු සාමාන්‍ය යෙදුම් වන අතර ඒවා බොහෝ ආකාරවලින් ක්‍රියාත්මක කළ හැකිය. පරිගණක වැඩසටහන් වල සාමාන්‍යයෙන් ඇමතුම් තොගයක් ලෙස හැඳින්වෙන තොගයක් ඇති අතර එය වර්තමාන ශ්‍රිතයට අදාළ තොරතුරු ගබඩා කරයි. කාර්යයන් වෙනත් කාර්යයන් අමතා නැවත පැමිණෙන නිසා, ඇමතුම් තොගයේ පහළට පහළින් ශ්‍රිතයන්ගෙන් තොරතුරු රඳවා ගැනීමට තොගය වර්ධනය වන අතර හැකිලී යයි. වැඩසටහනකට එය මත ධාවන කාල පාලනයක් නොමැත. එය තීරණය වන්නේ ක්‍රමලේඛන භාෂාව, මෙහෙයුම් පද්ධතිය සහ පද්ධති ගෘහ නිර්මාණ ශිල්පයෙනි.

  සංචය යනු ගතිකව හා අහඹු ලෙස වෙන් කර ඇති ඕනෑම මතකයක් සඳහා භාවිතා කරන සාමාන්‍ය යෙදුමකි; එනම් පිළිවෙලට නැත. මෙම වෙන් කිරීම සිදු කිරීම සඳහා යෙදුම් ඇමතුම් API කාර්යයන් සමඟ මතකය සාමාන්‍යයෙන් මෙහෙයුම් පද්ධතිය විසින් වෙන් කරනු ලැබේ. ගතිකව වෙන් කරන ලද මතකය කළමනාකරණය කිරීම සඳහා තරමක් ඉහළින් අවශ්‍ය වන අතර එය සාමාන්‍යයෙන් හසුරුවනු ලබන්නේ ක්‍රමලේඛන භාෂාවේ හෝ භාවිතා කරන පරිසරයේ ධාවන කාල කේතය මගිනි.

• ඔවුන්ගේ විෂය පථය කුමක්ද?

  ඇමතුම් තොගය එතරම් පහත් මට්ටමේ සංකල්පයක් වන අතර එය ක්‍රමලේඛනයේ අර්ථයෙන් 'විෂය පථයට' සම්බන්ධ නොවේ. ඔබ යම් කේතයක් විසුරුවා හරිනු ලැබුවහොත්, තොගයේ කොටස් වලට සාපේක්ෂව දර්ශක ශෛලීය යොමු දැක්වීම් ඔබට පෙනෙනු ඇත, නමුත් ඉහළ මට්ටමේ භාෂාවක් සම්බන්ධයෙන් ගත් කල, භාෂාව තමන්ගේම විෂය පථය නියම කරයි. කෙසේ වෙතත්, තොගයක එක් වැදගත් අංගයක් නම්, ශ්‍රිතයක් නැවත පැමිණි විට, එම ශ්‍රිතයට දේශීය ඕනෑම දෙයක් වහාම තොගයෙන් නිදහස් වේ. ඔබේ ක්‍රමලේඛන භාෂා ක්‍රියා කරන ආකාරය අනුව එය ක්‍රියාත්මක වනු ඇතැයි ඔබ අපේක්ෂා කරන ආකාරයට එය ක්‍රියාත්මක වේ. ගොඩක දී, නිර්වචනය කිරීම ද දුෂ්කර ය. මෙහෙයුම් පද්ධතිය මඟින් නිරාවරණය වන ඕනෑම දෙයක් විෂය පථය වේ, නමුත් ඔබේ ක්‍රමලේඛන භාෂාව ඔබේ යෙදුමේ “විෂය පථය” යනු කුමක්ද යන්න පිළිබඳ නීති රීති එකතු කරයි. ප්‍රොසෙසර් ගෘහ නිර්මාණ ශිල්පය සහ මෙහෙයුම් පද්ධතිය අථත්‍ය ලිපින භාවිතා කරයි, ප්‍රොසෙසරය භෞතික ලිපින වලට පරිවර්ථනය කරන අතර පිටු දෝෂ ආදිය ඇත. ඒවා කුමන යෙදුම් වලට අයත් පිටුද යන්න නිරීක්ෂණය කරයි. කෙසේ වෙතත්, ඔබ කිසි විටෙකත් මේ ගැන කරදර විය යුතු නැත, මන්ද ඔබ ඔබේ ක්‍රමලේඛන භාෂාව මතකය වෙන් කිරීම සහ නිදහස් කිරීම සඳහා භාවිතා කරන ඕනෑම ක්‍රමයක් භාවිතා කරන නිසා සහ දෝෂ සඳහා පරීක්ෂා කරන්න (වෙන් කිරීම / නිදහස් කිරීම කිසියම් හේතුවක් නිසා අසමත් වුවහොත්).

• එක් එක් ප්‍රමාණය තීරණය කරන්නේ කුමක් ද?

  නැවතත්, එය භාෂාව, සම්පාදක, මෙහෙයුම් පද්ධතිය සහ ගෘහ නිර්මාණ ශිල්පය මත රඳා පවතී. තොගයක් සාමාන්‍යයෙන් කලින් වෙන් කර ඇත, මන්ද අර්ථ දැක්වීම අනුව එය පරස්පර මතකයක් විය යුතුය. භාෂා සම්පාදකයා හෝ මෙහෙයුම් පද්ධතිය එහි ප්‍රමාණය තීරණය කරයි. ඔබ විශාල දත්ත ප්‍රමාණයක් තොගයේ ගබඩා නොකරයි, එබැවින් අනවශ්‍ය නිමක් නැති පුනරාවර්තනයක් (එබැවින් "සිරස් පිටාර ගැලීම") හෝ වෙනත් අසාමාන්‍ය ක්‍රමලේඛන තීරණ හැර එය කිසි විටෙකත් සම්පූර්ණයෙන් භාවිතා නොකළ යුතු තරම් විශාල වනු ඇත.

  සංචය යනු ගතිකව වෙන් කළ හැකි ඕනෑම දෙයකට පොදු යෙදුමකි. ඔබ එය දෙස බලන ආකාරය අනුව, එය නිරන්තරයෙන් ප්‍රමාණය වෙනස් කරයි. නවීන ප්‍රොසෙසර සහ මෙහෙයුම් පද්ධති වලදී එය ක්‍රියා කරන ආකාරය කෙසේ වෙතත් ඉතා වියුක්ත වේ, එබැවින් සාමාන්‍යයෙන් එය ගැඹුරින් ක්‍රියා කරන්නේ කෙසේද යන්න ගැන කරදර වීමට අවශ්‍ය නැත, හැර (එය ඔබට ඉඩ දෙන භාෂාවලින්) ඔබ මතකය භාවිතා නොකළ යුතුය ඔබ තවම හෝ ඔබ නිදහස් කළ මතකය වෙන් කර නැත.

• එකක් වේගවත් කරන්නේ කුමක් ද?

  සියලු නිදහස් මතකය සැමවිටම පරස්පර වන බැවින් තොගය වේගවත් වේ. නිදහස් මතකයේ සියලුම කොටස් ලැයිස්තුවක් පවත්වා ගෙන යා යුතු නැත, තොගයේ වත්මන් මුදුනට තනි දර්ශකයක් පමණි. සංග්රාහක සාමාන්යයෙන් විශේෂ වේගවත්, මෙම පහිටුම් දක්වනය ගබඩා ලේඛනය මෙම අරමුණු ඉටු කර ගැනීම සඳහා. එපමණක්ද නොව, තොගයක් මත පසුකාලීන මෙහෙයුම් සාමාන්‍යයෙන් සංකේන්ද්‍රණය වී ඇත්තේ මතකයේ ඉතා ආසන්න ප්‍රදේශයක වන අතර එය ප්‍රොසෙසරය ඔන් ඩයි හැඹිලි මඟින් ප්‍රශස්තිකරණය සඳහා ඉතා අඩු මට්ටමක පවතී.

(මම මෙම පිළිතුර වෙනත් ප්‍රශ්නයකින් මෙම ප්‍රශ්නයට වඩා අඩු හෝ වැඩි වශයෙන් ගෙන ගියෙමි.)

ඔබේ ප්‍රශ්නයට පිළිතුර ක්‍රියාත්මක කිරීම විශේෂිත වන අතර එය සම්පාදක සහ ප්‍රොසෙසර් ගෘහ නිර්මාණ අතර වෙනස් විය හැකිය. කෙසේ වෙතත්, මෙන්න සරල කළ පැහැදිලි කිරීමකි.

• තොගය සහ ගොඩවල් යන දෙකම යටින් පවතින මෙහෙයුම් පද්ධතියෙන් වෙන් කරන ලද මතක ප්‍රදේශ වේ (බොහෝ විට අථත්‍ය මතකය ඉල්ලුම මත භෞතික මතකයට අනුරූප වේ).
• බහු නූල් සහිත පරිසරයක සෑම නූල් එකකටම සම්පූර්ණයෙන්ම ස්වාධීන තොගයක් ඇති නමුත් ඒවා ගොඩවල් බෙදා ගනී. සමගාමී ප්‍රවේශය ගොඩවල් මත පාලනය කළ යුතු අතර එය තොගයේ කළ නොහැක.

ගොඩවල්

• භාවිතා කළ හා නිදහස් කොටස් වල සම්බන්ධිත ලැයිස්තුවක් ගොඩවල අඩංගු වේ. එක් නිදහස් බ්ලොක් එකකින් සුදුසු බ්ලොක් එකක් සෑදීමෙන් ගොඩවල් සඳහා නව ප්‍රතිපාදන (මගින් newහෝ malloc) සෑහීමකට පත්වේ. මේ සඳහා ගොඩවල ඇති කොටස් ලැයිස්තුව යාවත්කාලීන කිරීම අවශ්‍ය වේ. ගොඩවල ඇති කුට්ටි පිළිබඳ මෙම මෙටා තොරතුරු සෑම බ්ලොක් එකක් ඉදිරිපිටම කුඩා ප්‍රදේශයක ගොඩගැසී ඇත.
• ගොඩවල් වැඩෙන විට නව කුට්ටි බොහෝ විට පහළ ලිපිනවල සිට ඉහළ ලිපින වෙත වෙන් කරනු ලැබේ. ඒ නිසා ඔබ ලෙස ෙයාදා සිතිය හැකි ගල් ගොඩ මතක වෙන් කර ලෙස ප්රමාණයෙන් වර්ධනය බව මතක බිම් කොටස්. වෙන් කිරීමකට ගොඩවල් ඉතා කුඩා නම්, යටින් පවතින මෙහෙයුම් පද්ධතියෙන් වැඩි මතකයක් ලබා ගැනීමෙන් බොහෝ විට ප්‍රමාණය වැඩි කළ හැකිය.
• බොහෝ කුඩා කුට්ටි වෙන් කිරීම හා වෙන් කිරීම, භාවිතා කළ කොටස් අතර කුඩා නිදහස් කුට්ටි විශාල ප්‍රමාණයක් පවතින තත්වයක ගොඩවල් ඉතිරි විය හැකිය. විශාල බ්ලොක් එකක් වෙන් කිරීම සඳහා වන ඉල්ලීමක් අසාර්ථක විය හැකිය, මන්ද නිදහස් බ්ලොක් කිසිවක් වෙන්කිරීමේ ඉල්ලීම සපුරාලීමට තරම් විශාල නොවන නමුත් නිදහස් බ්ලොක් වල ඒකාබද්ධ ප්‍රමාණය ප්‍රමාණවත් තරම් විශාල විය හැකි බැවිනි. මෙය ගොඩවල් ඛණ්ඩනය ලෙස හැඳින්වේ .
• නිදහස් බ්ලොක් එකකට යාබදව භාවිතා කරන ලද බ්ලොක් එකක් අවලංගු කළ විට, නව නිදහස් බ්ලොක් යාබද නිදහස් බ්ලොක් සමඟ ඒකාබද්ධ වී විශාල නිදහස් බ්ලොක් එකක් නිර්මාණය කිරීම සඳහා සංචයේ ඛණ්ඩනය effectively ලදායී ලෙස අඩු කරයි.

තොගය

• මෙම තොගය බොහෝ විට CPU හි විශේෂ ලේඛනයක් සමඟ සමීපව ක්‍රියා කරයි අඩුක්කුව පහිටුම් දක්වනය . මුලදී තොග දර්ශකය තොගයේ මුදුනට යොමු කරයි (තොගයේ ඉහළම ලිපිනය).
• අගයන් තොගයට තල්ලු කිරීම සහ ඒවා නැවත තොගයෙන් පිටතට ගෙන ඒම සඳහා විශේෂ උපදෙස් CPU සතුව ඇත . සෑම තල්ලුවක්ම අගය ස්ටක් පොයින්ටරයේ වත්මන් ස්ථානයේ ගබඩා කරන අතර ස්ටක් පොයින්ටරය අඩු කරයි. ඒ පොප් වටිනාකම අඩුක්කුව පොයින්ටර් පෙන්වා පසුව අඩුක්කුව පහිටුම් දක්වනය වැඩි (බව, ඒ මගින් පටලවා නැහැ retrieves එකතු අඩුක්කුව සඳහා අගය අඩු අඩුක්කුව pointer සහ ඉවත් අගය වැඩි එය. අඩුක්කුව දක්වා වර්ධනය වේ බව මතක තබා ගන්න පතුල). ගබඩා කර ලබා ගත් අගයන් CPU ලේඛනයේ අගයන් වේ.
• ශ්‍රිතයක් හැඳින්වූ විට CPU විසින් වර්තමාන උපදෙස් දර්ශකය තල්ලු කරන විශේෂ උපදෙස් භාවිතා කරයි , එනම් තොගයේ ක්‍රියාත්මක වන කේතයේ ලිපිනය. CPU පසුව ශ්‍රිතයට පනින්නේ උපදෙස් දර්ශකය හැඳින්වෙන ශ්‍රිතයේ ලිපිනයට සැකසීමෙනි. පසුව, ශ්‍රිතය නැවත පැමිණෙන විට, පැරණි උපදෙස් දර්ශකය තොගයෙන් ඉවත් කර ශ්‍රිතයට ඇමතුමෙන් පසුව කේතයේ ක්‍රියාත්මක කිරීම නැවත ආරම්භ වේ.
• ශ්‍රිතයක් ඇතුළත් කළ විට, දේශීය (ස්වයංක්‍රීය) විචල්‍යයන් සඳහා තොගයේ වැඩි ඉඩක් වෙන් කිරීම සඳහා තොග දර්ශකය අඩු වේ. ශ්‍රිතයට එක් දේශීය 32 බිට් විචල්‍යයක් තිබේ නම් බයිට් හතරක් තොගයේ තබා ඇත. ශ්‍රිතය නැවත පැමිණෙන විට, වෙන් කළ ප්‍රදේශය නිදහස් කිරීම සඳහා තොග දර්ශකය ආපසු ගෙන යනු ලැබේ.
• ශ්‍රිතයකට පරාමිතීන් තිබේ නම්, මේවා ශ්‍රිතයට ඇමතුමට පෙර තොගයට තල්ලු කරනු ලැබේ. මෙම අගයන් සොයා ගැනීම සඳහා ශ්‍රිතයේ ඇති කේතයට වත්මන් සිරස් පොයින්ටරයේ සිට තොගයේ සැරිසැරීමට හැකි වේ.
• කැදැල්ල ක්‍රියාකාරී ඇමතුම් චාම් එකක් මෙන් ක්‍රියා කරයි. සෑම නව ඇමතුමකටම ක්‍රියාකාරී පරාමිතීන්, දේශීය විචල්‍යයන් සඳහා ආපසු ලිපිනය සහ අවකාශය වෙන් කරනු ඇති අතර මෙම සක්‍රිය කිරීමේ වාර්තා කැදැලි ඇමතුම් සඳහා සිරස්ව තැබිය හැකි අතර ශ්‍රිත නැවත පැමිණෙන විට නිවැරදි ආකාරයෙන් එය මුදා හරිනු ඇත.
• තොගය සීමිත මතක ප්‍රමාණයක් බැවින්, ඔබට වැඩිපුර කැදැලි ශ්‍රිතයන් ඇමතීමෙන් සහ / හෝ දේශීය විචල්‍යයන් සඳහා වැඩි ඉඩක් වෙන් කිරීමෙන් ඔබට තොග පිටාර ගැලීමක් සිදුවිය හැකිය . බොහෝ විට තොගය සඳහා භාවිතා කරන මතක ප්‍රදේශය සකසා ඇත්තේ තොගයේ පහළ (පහළ ලිපිනය) ට පහළින් ලිවීම CPU තුළ උගුලක් හෝ ව්‍යතිරේකයක් අවුලුවන අයුරිනි. මෙම සුවිශේෂී කොන්දේසිය පසුව ධාවන වේලාවට හසු කර යම් ආකාරයක තොග පිටාර ගැලීමේ ව්‍යතිරේකයක් බවට පරිවර්තනය කළ හැකිය.

ගොඩගැසීමක් වෙනුවට ගොඩවල් මත ශ්‍රිතයක් වෙන් කළ හැකිද?

නැත, ශ්‍රිත සඳහා සක්‍රිය කිරීමේ වාර්තා (එනම් දේශීය හෝ ස්වයංක්‍රීය විචල්‍යයන්) වෙන් කරනු ලබන්නේ මෙම විචල්‍යයන් ගබඩා කිරීමට පමණක් නොව, කැදැලි ක්‍රියාකාරී ඇමතුම් පිළිබඳව සොයා බැලීමටය.

ගොඩවල් කළමනාකරණය කරන්නේ කෙසේද යන්න ඇත්ත වශයෙන්ම ධාවන කාල පරිසරය දක්වා වේ. සී භාවිතය mallocසහ සී ++ භාවිතය new, නමුත් වෙනත් බොහෝ භාෂාවල කසළ එකතු වේ.

කෙසේ වෙතත්, තොගය ප්‍රොසෙසර් ගෘහ නිර්මාණ ශිල්පයට සමීපව බැඳී ඇති වඩා පහත් මට්ටමේ ලක්ෂණයකි. ප්‍රමාණවත් ඉඩක් නොමැති විට ගොඩවල් වැඩීම එතරම් අපහසු නොවේ. මන්දයත් එය ගොඩගැසීමේ පුස්තකාල ඇමතුම තුළ ක්‍රියාත්මක කළ හැකි බැවිනි. කෙසේවෙතත්, තොගය වැඩීම බොහෝ විට කළ නොහැක්කකි. ක්‍රියාත්මක කිරීමේ නූල් වසා දැමීම එකම ශක්‍ය විකල්පයයි.

පහත දැක්වෙන C # කේතයේ

public void Method1()
{
    int i = 4;
    int y = 2;
    class1 cls1 = new class1();
}

මෙන්න මතකය කළමනාකරණය කරන ආකාරය

Local Variablesඑය පැවතිය යුත්තේ ශ්‍රිත ආයාචනය තොගයේ පවතින තාක් කල් පමණි. ගොඩවල් භාවිතා කරනුයේ විචල්‍යයන් සඳහා වන අතර ඔවුන්ගේ ජීවිත කාලය අප නොදන්නා නමුත් ඒවා ටික කලක් පවතිනු ඇතැයි අපි අපේක්ෂා කරමු. බොහෝ භාෂාවල විචල්‍යයක් කොතරම් විශාලද යන්න සම්පාදනය කරන වේලාවේදී අප දැන සිටීම ඉතා වැදගත් වේ.

වස්තූන් (අප ඒවා යාවත්කාලීන කරන විට ප්‍රමාණයෙන් වෙනස් වේ) ගොඩවල් මතට යන්නේ ඒවා මැවීමේ වේලාවේදී ඒවා කොපමණ කාලයක් පවතිනු ඇත්දැයි අප නොදන්නා බැවිනි. බොහෝ භාෂාවල සංචය යනු කිසිදු සඳහනක් නොමැති වස්තු (cls1 වස්තුව වැනි) සොයා ගැනීම සඳහා එකතු කරන ලද කසළ වේ.

ජාවා හි බොහෝ වස්තූන් කෙලින්ම ගොඩට යයි. සී / සී ++ වැනි භාෂාවල, ඔබ දර්ශකයන් සමඟ ගනුදෙනු නොකරන විට ව්‍යුහයන් සහ පන්ති බොහෝ විට සිරස්ව පවතී.

වැඩි විස්තර මෙතැනින් සොයාගත හැකිය:

තොග සහ ගොඩවල් මතක වෙන් කිරීම අතර වෙනස «timmurphy.org

මෙහි:

ගොඩවල් සහ ගොඩවල් මත වස්තු නිර්මාණය කිරීම

මෙම ලිපිය ඉහත පින්තූරයේ ප්‍රභවය වේ: වැදගත් .නෙට් සංකල්ප හයක්: ගොඩගැසීම, ගොඩවල්, අගය වර්ග, විමර්ශන වර්ග, බොක්සිං සහ නොබැඳීම - කෝඩ් ප්‍රොජෙක්ට්

නමුත් එහි සමහර සාවද්‍යතාවයන් අඩංගු විය හැකි බව මතක තබා ගන්න.

අට්ටාලය ඔබ ශ්‍රිතයක් අමතන විට එම ශ්‍රිතයට තර්ක සහ තවත් පොදු කාර්යයක් තොගයේ තබා ඇත. සමහර තොරතුරු (ආපසු යා යුත්තේ කොතැනටද යන්න වැනි) ද එහි ගබඩා කර ඇත. ඔබේ ශ්‍රිතය තුළ ඔබ විචල්‍යයක් ප්‍රකාශ කරන විට, එම විචල්‍යය ද තොගයේ වෙන් කරනු ලැබේ.

ඔබ වෙන් කරන ප්‍රතිලෝම අනුපිළිවෙලෙහි ඔබ සැමවිටම ගනුදෙනු කරන නිසා තොගය ඉවත් කිරීම ඉතා සරල ය. ඔබ කාර්යයන් ඇතුළත් කරන විට සිරස් දේවල් එකතු කරනු ලැබේ, ඔබ ඒවායින් පිටවන විට අනුරූප දත්ත ඉවත් කරනු ලැබේ. මෙයින් අදහස් කරන්නේ ඔබ වෙනත් කාර්යයන් රාශියක් කැඳවන (හෝ පුනරාවර්තන විසඳුමක් නිර්මාණය කරන) බොහෝ කාර්යයන් අමතන්නේ නැත්නම් ඔබ තොගයේ කුඩා කලාපයක් තුළ රැඳී සිටීමට නැඹුරු වන බවයි.

ගොඩවල් ගොඩවල් යනු ඔබ නිර්මාණය කරන දත්ත මැස්සන් මත තැබූ ස්ථානය සඳහා සාමාන්‍ය නමකි. ඔබේ වැඩසටහන කොපමණ අභ්‍යවකාශ නැව් නිර්මාණය කිරීමට යන්නේ දැයි ඔබ නොදන්නේ නම්, එක් එක් අභ්‍යවකාශ නැව නිර්මාණය කිරීම සඳහා ඔබ නව (හෝ malloc හෝ ඊට සමාන) ක්‍රියාකරු භාවිතා කිරීමට ඉඩ ඇත. මෙම ප්‍රතිපාදන ටික කලක් රැඳී පවතිනු ඇත, එබැවින් බොහෝ විට අපි ඒවා නිර්මාණය කිරීමට වඩා වෙනස් අනුපිළිවෙලකට නිදහස් කරමු.

මේ අනුව, සංචය වඩාත් සංකීර්ණ වේ, මන්දයත් භාවිතයේ නොමැති කොටස් කැබලි සමඟ අන්තර් සම්බන්ධිත මතක කලාප ඇති බැවිනි - මතකය ඛණ්ඩනය වේ. ඔබට අවශ්‍ය ප්‍රමාණය පිළිබඳ නිදහස් මතකය සොයා ගැනීම දුෂ්කර ගැටලුවකි. මේ නිසා ගොඩවල් වළක්වා ගත යුතුය (එය තවමත් බොහෝ විට භාවිතා වුවද).

ක්‍රියාත්මක කිරීම තොග සහ ගොඩවල් දෙකම ක්‍රියාත්මක කිරීම සාමාන්‍යයෙන් ධාවන කාලය / මෙහෙයුම් පද්ධතිය දක්වා පහත බැස ඇත. බොහෝ විට කාර්ය සාධන විවේචනාත්මක ක්‍රීඩා සහ වෙනත් යෙදුම් ඔවුන්ගේම මතක විසඳුම් නිර්මාණය කරන අතර එමඟින් විශාල මතක ප්‍රමාණයක් ගොඩවල් වලින් උදුරාගෙන මතකය සඳහා මෙහෙයුම් පද්ධතිය මත යැපීම වළක්වා ගැනීම සඳහා එය අභ්‍යන්තරව ඉවතට විසි කරයි.

මෙය ප්‍රායෝගික වන්නේ ඔබේ මතක භාවිතය සම්මතයට වඩා බෙහෙවින් වෙනස් නම් පමණි - එනම් ඔබ එක් විශාල මෙහෙයුමක මට්ටමක් පටවන සහ තවත් විශාල මෙහෙයුමක දී මුළු කොටසම ඉවතට ඇද දැමිය හැකි ක්‍රීඩා සඳහා ය.

මතකයේ භෞතික පිහිටීම මෙය ඔබ සිතනවාට වඩා අඩු වැදගත්කමක් වන්නේ වර්චුවල් මෙමරි නම් තාක්‍ෂණය නිසා ඔබේ වැඩසටහන ඔබට භෞතික දත්ත වෙනත් තැනක (දෘඩ තැටියේ පවා) ඇති යම් ලිපිනයකට පිවිසිය හැකි යැයි සිතීමට සලස්වයි. ඔබගේ ඇමතුම් ගස ගැඹුරු වන විට තොගය සඳහා ඔබට ලැබෙන ලිපින වැඩිවෙමින් පවතී. ගොඩවල් සඳහා වන ලිපින අනාවැකි කිව නොහැකි ය (එනම් ආවේගාත්මක විශේෂිත) සහ අවංකවම වැදගත් නොවේ.

පැහැදිලි කිරීම සඳහා, මෙම පිළිතුරෙහි වැරදි තොරතුරු ඇත ( තෝමස් අදහස් දැක්වීමෙන් පසු ඔහුගේ පිළිතුර සවි කළේය, සිසිල් :)). වෙනත් පිළිතුරු මගින් ස්ථිතික වෙන් කිරීම යන්නෙන් අදහස් කරන්නේ කුමක්ද යන්න පැහැදිලි කිරීමෙන් වළකින්න. එබැවින් වෙන්කිරීමේ ප්‍රධාන ආකාර තුන සහ ඒවා සාමාන්‍යයෙන් ගොඩවල්, තොග සහ දත්ත අංශයට සම්බන්ධ වන්නේ කෙසේද යන්න මම පහදා දෙන්නෙමි. මිනිසුන්ට තේරුම් ගැනීමට උපකාර කිරීම සඳහා මම සී / සී ++ සහ පයිතන් යන දෙඅංශයෙන්ම උදාහරණ කිහිපයක් පෙන්වමි.

"ස්ථිතික" (AKA සංඛ්‍යානමය වශයෙන් වෙන් කරන ලද) විචල්යයන් තොගයේ වෙන් නොකෙරේ. එසේ නොසිතන්න - බොහෝ අය එසේ කරන්නේ "ස්ථිතික" ශබ්දය "සිරස්" ලෙස පෙනෙන නිසා පමණි. ඒවා සැබවින්ම පවතින්නේ තොගයේ හෝ ගොඩවල නොවේ. ඒවා දත්ත අංශය ලෙස හැඳින්වෙන කොටසකි .

කෙසේ වෙතත්, සාමාන්‍යයෙන් "සිරස්" සහ "ගොඩවල්" වලට වඩා " විෂය පථය " සහ " ජීවිත කාලය " සලකා බැලීම වඩා හොඳය .

විෂය පථය යනු විචල්‍යයට ප්‍රවේශ විය හැකි කේතයේ කොටස් මොනවාද යන්නයි. සාමාන්‍යයෙන් අප සිතන්නේ දේශීය විෂය පථයට (වර්තමාන ශ්‍රිතයට පමණක් ප්‍රවේශ විය හැකි) ගෝලීය විෂය පථයට එදිරිව (ඕනෑම තැනකට පිවිසිය හැකි) විෂය පථය වඩාත් සංකීර්ණ විය හැකි නමුත්.

ජීවිත කාලය යනු වැඩසටහන් ක්‍රියාත්මක කිරීමේදී විචල්‍යයක් වෙන් කර අවලංගු කරන විටය. සාමාන්‍යයෙන් අපි ස්ථිතික වෙන් කිරීම ගැන සිතමු (විචල්‍යය වැඩසටහනේ මුළු කාලසීමාව පුරාම පවතිනු ඇත, එමඟින් එකම තොරතුරු ක්‍රියාකාරී ඇමතුම් කිහිපයක් හරහා ගබඩා කිරීම ප්‍රයෝජනවත් වේ) එදිරිව ස්වයංක්‍රීය වෙන් කිරීම (විචල්‍යය පවතින්නේ ශ්‍රිතයකට එක් ඇමතුමකදී පමණක් වන අතර එය ප්‍රයෝජනවත් වේ ඔබේ ශ්‍රිතය තුළ පමණක් භාවිතා වන තොරතුරු ගබඩා කිරීම සහ ඔබ අවසන් වූ පසු ඉවත දැමිය හැකිය) එදිරිව ගතික වෙන් කිරීම (ස්ථිතික හෝ ස්වයංක්‍රීය වැනි සංයුක්ත කාලය වෙනුවට ධාවන වේලාවේ කාලසීමාව අර්ථ දක්වා ඇති විචල්‍යයන්).

බොහෝ සම්පාදකයින් සහ පරිවර්තකයන් මෙම හැසිරීම තොග, ගොඩවල් ආදිය භාවිතා කිරීමේදී සමාන ආකාරයකින් ක්‍රියාත්මක කළද, හැසිරීම නිවැරදි නම් තාක් කල් සම්පාදකයෙකුට මෙම සම්මුතීන් බිඳ දැමිය හැකිය. නිදසුනක් ලෙස, ප්‍රශස්තිකරණය හේතුවෙන් දේශීය විචල්‍යයක් පැවතිය හැක්කේ ලේඛනයක පමණි හෝ සම්පූර්ණයෙන්ම ඉවත් කළ හැකිය. අදහස් කිහිපයකින් පෙන්වා දී ඇති පරිදි, ඔබට තොගයක් හෝ ගොඩවල් පවා භාවිතා නොකරන සම්පාදකයෙකු ක්‍රියාත්මක කිරීමට නිදහස ඇත, නමුත් ඒ වෙනුවට වෙනත් ගබඩා යාන්ත්‍රණ (කලාතුරකින් සිදු කරනු ලැබේ, මේ සඳහා තොග සහ ගොඩවල් විශාල බැවින්).

මේ සියල්ල නිදර්ශනය කිරීම සඳහා මම සරල විවරණය කළ සී කේත කිහිපයක් ලබා දෙන්නෙමි. ඉගෙන ගැනීමට ඇති හොඳම ක්‍රමය වන්නේ නිදොස් කිරීමක් යටතේ වැඩසටහනක් ක්‍රියාත්මක කර හැසිරීම නිරීක්ෂණය කිරීමයි. ඔබ පයිතන් කියවීමට කැමති නම්, පිළිතුරේ අවසානය වෙත යන්න :)

// Statically allocated in the data segment when the program/DLL is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in the code
int someGlobalVariable;

// Statically allocated in the data segment when the program is first loaded
// Deallocated when the program/DLL exits
// scope - can be accessed from anywhere in this particular code file
static int someStaticVariable;

// "someArgument" is allocated on the stack each time MyFunction is called
// "someArgument" is deallocated when MyFunction returns
// scope - can be accessed only within MyFunction()
void MyFunction(int someArgument) {

    // Statically allocated in the data segment when the program is first loaded
    // Deallocated when the program/DLL exits
    // scope - can be accessed only within MyFunction()
    static int someLocalStaticVariable;

    // Allocated on the stack each time MyFunction is called
    // Deallocated when MyFunction returns
    // scope - can be accessed only within MyFunction()
    int someLocalVariable;

    // A *pointer* is allocated on the stack each time MyFunction is called
    // This pointer is deallocated when MyFunction returns
    // scope - the pointer can be accessed only within MyFunction()
    int* someDynamicVariable;

    // This line causes space for an integer to be allocated in the heap
    // when this line is executed. Note this is not at the beginning of
    // the call to MyFunction(), like the automatic variables
    // scope - only code within MyFunction() can access this space
    // *through this particular variable*.
    // However, if you pass the address somewhere else, that code
    // can access it too
    someDynamicVariable = new int;


    // This line deallocates the space for the integer in the heap.
    // If we did not write it, the memory would be "leaked".
    // Note a fundamental difference between the stack and heap
    // the heap must be managed. The stack is managed for us.
    delete someDynamicVariable;

    // In other cases, instead of deallocating this heap space you
    // might store the address somewhere more permanent to use later.
    // Some languages even take care of deallocation for you... but
    // always it needs to be taken care of at runtime by some mechanism.

    // When the function returns, someArgument, someLocalVariable
    // and the pointer someDynamicVariable are deallocated.
    // The space pointed to by someDynamicVariable was already
    // deallocated prior to returning.
    return;
}

// Note that someGlobalVariable, someStaticVariable and
// someLocalStaticVariable continue to exist, and are not
// deallocated until the program exits.

ජීවිත කාලය සහ විෂය පථය අතර වෙනස හඳුනා ගැනීම වැදගත් වන්නේ මන්ද යන්න පිළිබඳ විශේෂයෙන් පැහැදිලි උදාහරණයක් නම්, විචල්‍යයකට දේශීය විෂය පථයක් තිබිය හැකි නමුත් ස්ථිතික ජීවිත කාලයයි - නිදසුනක් ලෙස, ඉහත කේත සාම්පලයේ “someLocalStaticVariable”. එවැනි විචල්‍යයන් නිසා අපගේ පොදු නමුත් අවිධිමත් නම් කිරීමේ පුරුදු ඉතා ව්‍යාකූල විය හැකිය. උදාහරණයක් ලෙස අපි " දේශීය " යැයි කියන විට සාමාන්‍යයෙන් අදහස් කරන්නේ " දේශීයව විෂය පථය ස්වයංක්‍රීයව වෙන් කරන ලද විචල්‍යය " යන්නයි. ගෝලීය යැයි කියන විට අපි සාමාන්‍යයෙන් අදහස් කරන්නේ " ගෝලීය වශයෙන් විෂය පථය වෙන් කළ විචල්‍යය " යන්නයි. අවාසනාවට, " ලිපිගොනු විෂය පථයෙන් වෙන් කරන ලද විචල්යයන් " වැනි දේ ගැන බොහෝ අය පවසන විට ... " හාහ් ??? ".

සී / සී ++ හි ඇති සමහර සින්ටැක්ස් තේරීම් මෙම ගැටළුව උග්‍ර කරයි - නිදසුනක් ලෙස බොහෝ අය සිතන්නේ පහත දැක්වෙන සින්ටැක්ස් නිසා ගෝලීය විචල්‍යයන් “ස්ථිතික” නොවන බවයි.

int var1; // Has global scope and static allocation
static int var2; // Has file scope and static allocation

int main() {return 0;}

ඉහත ප්‍රකාශයේ “ස්ථිතික” යන පදය තැබීමෙන් var2 ගෝලීය විෂය පථය ඇතිවීම වළක්වන බව සලකන්න. එසේ වුවද, ගෝලීය var1 හි ස්ථිතික වෙන් කිරීමක් ඇත. මෙය බුද්ධිමත් නොවේ! මේ හේතුව නිසා, විෂය පථය විස්තර කිරීමේදී "ස්ථිතික" යන වචනය කිසි විටෙකත් භාවිතා නොකිරීමට මම උත්සාහ කරමි, ඒ වෙනුවට "ගොනුව" හෝ "ගොනු සීමිත" විෂය පථය වැනි දෙයක් පවසමි. කෙසේ වෙතත් බොහෝ අය එක් කේත ගොනුවකින් පමණක් ප්‍රවේශ විය හැකි විචල්‍යයක් විස්තර කිරීමට “ස්ථිතික” හෝ “ස්ථිතික විෂය පථය” යන වාක්‍ය ඛණ්ඩය භාවිතා කරති. ජීවිත කාලය සන්දර්භය තුළ, "ස්ථිතික" සෑම විටම විචල්ය වැඩසටහන ආරම්භයේ දී වෙන් කරන විට ඒ හා වැඩසටහන පිටවීම් දොරටු විබෙදේ අදහස් වන්නේ,.

සමහර අය මෙම සංකල්ප C / C ++ විශේෂිත යැයි සිතති. ඔවුන් නොවේ. නිදසුනක් ලෙස, පහත දැක්වෙන පයිතන් නියැදිය මඟින් වෙන්කිරීම් වර්ග තුනම නිරූපණය කරයි (අර්ථ නිරූපණය කරන ලද භාෂාවල සියුම් වෙනස්කම් කිහිපයක් මා මෙහි නොපැමිණේ).

from datetime import datetime

class Animal:
    _FavoriteFood = 'Undefined' # _FavoriteFood is statically allocated

    def PetAnimal(self):
        curTime = datetime.time(datetime.now()) # curTime is automatically allocatedion
        print("Thank you for petting me. But it's " + str(curTime) + ", you should feed me. My favorite food is " + self._FavoriteFood)

class Cat(Animal):
    _FavoriteFood = 'tuna' # Note since we override, Cat class has its own statically allocated _FavoriteFood variable, different from Animal's

class Dog(Animal):
    _FavoriteFood = 'steak' # Likewise, the Dog class gets its own static variable. Important to note - this one static variable is shared among all instances of Dog, hence it is not dynamic!


if __name__ == "__main__":
    whiskers = Cat() # Dynamically allocated
    fido = Dog() # Dynamically allocated
    rinTinTin = Dog() # Dynamically allocated

    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

    Dog._FavoriteFood = 'milkbones'
    whiskers.PetAnimal()
    fido.PetAnimal()
    rinTinTin.PetAnimal()

# Output is:
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is steak
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is tuna
# Thank you for petting me. But it's 13:05:02.255000, you should feed me. My favorite food is milkbones
# Thank you for petting me. But it's 13:05:02.256000, you should feed me. My favorite food is milkbones

තවත් සමහරු පුළුල් පහරවල් වලට ඉතා හොඳින් පිළිතුරු දී ඇත, එබැවින් මම විස්තර කිහිපයක් විසි කරමි.

1. ගොඩවල් සහ ගොඩවල් තනි විය යුතු නැත. ඔබට එකකට වඩා වැඩි ගණනක් ඇති පොදු තත්වයක් නම් ක්‍රියාවලියක ඔබට නූල් එකකට වඩා තිබේ නම්. මෙම අවස්ථාවේ දී එක් එක් නූල් වලට තමන්ගේම තොගයක් ඇත. ඔබට එක ගොඩකට වඩා තිබිය හැකිය, නිදසුනක් ලෙස සමහර ඩීඑල්එල් වින්‍යාසයන් විවිධ ඩීඑල්එල් විවිධ ගොඩවල් වලින් වෙන් කිරීමට හේතු විය හැක, එබැවින් සාමාන්‍යයෙන් වෙනත් පුස්තකාලයකින් වෙන් කරන ලද මතකය මුදා හැරීම නරක අදහසකි.

2. C හි ඔබට විචල්‍ය දිග වෙන්කිරීමේ වාසිය ලබා ගත හැකිය , එය වෙන් කිරීම වෙනුවට , ගොඩවල් මත වෙන් කරන ඇලෝකා භාවිතා කිරීමෙනි . මෙම මතකය ඔබගේ ආපසු ප්‍රකාශයෙන් නොනැසී පවතිනු ඇත, නමුත් එය සීරීම් බෆරයකට ප්‍රයෝජනවත් වේ.

3. ඔබ බොහෝ දේ භාවිතා නොකරන වින්ඩෝස් හි විශාල තාවකාලික බෆරයක් සෑදීම නොමිලේ නොවේ. මෙයට හේතුව, සම්පාදකයා විසින් ඔබේ ශ්‍රිතය ඇතුලත් කරන සෑම අවස්ථාවකම හැඳින්වෙන තොග පිරික්සුම් ලූපයක් ජනනය කරනු ඇති අතර එය තොගය පවතින බව තහවුරු කර ගැනීම සඳහා ය. ඔබ තොගයේ කෙළවරේ පිටු එකකට වඩා මතකයට ප්‍රවේශ වුවහොත් ඔබ බිඳ වැටෙනු ඇත). උදාහරණයක්:

void myfunction()
{
   char big[10000000];
   // Do something that only uses for first 1K of big 99% of the time.
}

අනෙක් අය ඔබේ ප්‍රශ්නයට කෙලින්ම පිළිතුරු දී ඇත, නමුත් තොගය සහ ගොඩවල් තේරුම් ගැනීමට උත්සාහ කරන විට, සාම්ප්‍රදායික යුනික්ස් ක්‍රියාවලියක (නූල් සහ mmap()පදනම් වූ විබෙදන්නන් නොමැතිව ) මතක සැකැස්ම සලකා බැලීම ප්‍රයෝජනවත් යැයි මම සිතමි . මෙම මතකය කළමනාකරණ පාරිභාෂික ශබ්ද මාලාව වෙබ් පිටුව මෙම මතක සැකැස්ම පිළිබඳ සටහන ඇත.

සිරස් සහ ගොඩවල් සාම්ප්‍රදායිකව ක්‍රියාවලියේ අථත්‍ය ලිපින අවකාශයේ ප්‍රතිවිරුද්ධ කෙළවරේ පිහිටා ඇත. ප්‍රවේශ වන විට තොගය ස්වයංක්‍රීයව වර්ධනය වේ, කර්නලය මඟින් සකසා ඇති ප්‍රමාණය දක්වා (ඒවා සමඟ සකස් කළ හැකිය setrlimit(RLIMIT_STACK, ...)). මතක විබෙදුම්කරු brk()හෝ sbrk()පද්ධති ඇමතුම ඉල්ලා සිටින විට ගොඩවල් වර්ධනය වේ, භෞතික මතකයේ තවත් පිටු ක්‍රියාවලියේ අථත්‍ය ලිපින අවකාශයට අනුරූපණය කරයි.

අථත්ය මතකයක් නොමැති පද්ධති, සමහර කාවැද්දූ පද්ධති වැනි, එකම මූලික පිරිසැලසුම බොහෝ විට අදාළ වේ. කෙසේ වෙතත්, වෙනත් කාවැද්දූ පද්ධතිවල (මයික්‍රොචිප් පීඅයිසී මයික්‍රොකොන්ට්රෝලර් මත පදනම් වූ), වැඩසටහන් තොගය යනු දත්ත චලන උපදෙස් මගින් ආමන්ත්‍රණය කළ නොහැකි වෙනම මතක කොටසකි, එය වෙනස් කළ හැකිය හෝ වැඩසටහන් ප්‍රවාහ උපදෙස් මඟින් වක්‍රව කියවිය හැකිය (අමතන්න, ආපසු ආදිය). ඉන්ටෙල් ඉටේනියම් ප්‍රොසෙසර් වැනි අනෙකුත් ගෘහ නිර්මාණ ශිල්පයට බහු කොටස් තිබේ. මෙම අර්ථයෙන් ගත් කල, තොගය CPU ගෘහ නිර්මාණ ශිල්පයේ අංගයකි.

තොගයක් යනු කුමක්ද?

තොගයක් යනු සාමාන්‍යයෙන් පිළිවෙලට පිළිවෙලට සකස් කර ඇති වස්තු ගොඩකි.

පරිගණක ගෘහ නිර්මාණ ශිල්පයේ කොටස් යනු මතකයේ ඇති ප්‍රදේශ වන අතර දත්ත මුලින්ම එකතු කරන හෝ ඉවත් කරනු ලැබේ.
බහු-නූල් යෙදුමක, එක් එක් නූල් වලට තමන්ගේම තොගයක් ඇත.

ගොඩවල් යනු කුමක්ද?

ගොඩවල් යනු අශෝභන ලෙස ගොඩ ගසා ඇති අපිරිසිදු දේවල් එකතුවකි.

පරිගණක ගෘහ නිර්මාණ ශිල්පයෙහි සංචය යනු ගතිකව වෙන් කරන ලද මතක ප්‍රදේශයකි, එය මෙහෙයුම් පද්ධතිය හෝ මතක කළමනාකරණ පුස්තකාලය විසින් ස්වයංක්‍රීයව කළමනාකරණය කරනු ලැබේ.
ක්‍රමලේඛය ක්‍රියාත්මක කිරීමේදී ගොඩවල් මතකය වෙන් කිරීම, වෙන් කිරීම සහ ප්‍රතිප්‍රමාණනය කිරීම නිතිපතා සිදු කරනු ලැබේ.
කුඩා මතක අවකාශයන් සමඟ මතක වස්තු වෙන් කර ඇති විට අමතර මතක වස්තු රඳවා ගැනීමට නොහැකි තරම් කුඩා වේ.
ශුද්ධ ප්‍රති result ලය යනු තවදුරටත් මතක වෙන් කිරීම සඳහා භාවිතා කළ නොහැකි ගොඩවල් අවකාශයේ ප්‍රතිශතයකි.

දෙදෙනාම එකට

බහු-නූල් යෙදුමක, එක් එක් නූල් වලට තමන්ගේම තොගයක් ඇත. නමුත්, විවිධ නූල් සියල්ලම ගොඩවල් බෙදා ගනී.
විවිධ නූල් බහු-නූල් යෙදුමක ගොඩවල් බෙදා ගන්නා නිසා, මෙයින් අදහස් කරන්නේ නූල් අතර යම් සම්බන්ධීකරණයක් තිබිය යුතු අතර එමඟින් ගොඩවල ඇති එකම මතක කොටස් (කොටස්) වෙත ප්‍රවේශ වීමට සහ හැසිරවීමට උත්සාහ නොකරනු ඇත. එකම වේලාවක.

වඩා වේගවත් - තොගය හෝ ගොඩවල්? සහ ඇයි?

තොගය ගොඩට වඩා වේගවත් ය.
මෙයට හේතුව වන්නේ තොගය මතකය වෙන් කර ඇති ආකාරයයි.
තොගයේ මතකය වෙන් කිරීම තොග දර්ශකය ඉහළට ගෙනයාම තරම් සරල ය.

ක්‍රමලේඛයට නව පුද්ගලයින් සඳහා, එය පහසු බැවින් තොගය භාවිතා කිරීම හොඳ අදහසකි.
තොගය කුඩා බැවින්, ඔබේ දත්ත සඳහා ඔබට කොපමණ මතකයක් අවශ්‍ය දැයි හරියටම දැනගත් විට හෝ ඔබේ දත්තවල ප්‍රමාණය ඉතා කුඩා බව ඔබ දන්නේ නම් එය භාවිතා කිරීමට ඔබට අවශ්‍ය වනු ඇත.
ඔබේ දත්ත සඳහා ඔබට විශාල මතකයක් අවශ්‍ය බව ඔබ දන්නා විට ගොඩවල් භාවිතා කිරීම වඩා හොඳය, නැතහොත් ඔබට කොපමණ මතකයක් අවශ්‍යදැයි ඔබට විශ්වාස නැත (ගතික අරාවකින් මෙන්).

ජාවා මතක ආකෘතිය

තොගය යනු දේශීය විචල්‍යයන් (ක්‍රම පරාමිතීන් ඇතුළුව) ගබඩා කර ඇති මතක ප්‍රදේශයයි. වස්තු විචල්‍යයන් සම්බන්ධයෙන් ගත් කල, මේවා හුදෙක් ගොඩවල ඇති සත්‍ය වස්තූන් සඳහා යොමු කිරීම් (දර්ශකයන්) වේ.
වස්තුවක් ක්ෂණිකව ක්‍රියාත්මක වන සෑම අවස්ථාවකම, එම වස්තුවේ දත්ත (තත්වය) රඳවා තබා ගැනීම සඳහා ගොඩවල් මතකයක් වෙන් කරනු ලැබේ. වස්තූන්ට වෙනත් වස්තූන් අඩංගු විය හැකි බැවින්, මෙම දත්තවලින් සමහරක් ඇත්ත වශයෙන්ම එම කැදැලි වස්තූන් වෙත යොමු විය හැකිය.

තොගය යනු මතකයේ කොටසක් වන අතර එකලස් කිරීමේ භාෂා උපදෙස් කිහිපයක් හරහා හැසිරවිය හැකිය, එනම් 'පොප්' (තොගයෙන් වටිනාකමක් ඉවත් කර ආපසු එවීම) සහ 'තල්ලු කිරීම' (අගයට අගයක් තල්ලු කිරීම), නමුත් අමතන්න ( සබ්ට්‍රවුටයින් අමතන්න - මෙය ලිපිනය නැවත තොගයට තල්ලු කරයි) සහ ආපසු (සබ්ට්‍රවුටින් එකකින් ආපසු යන්න - මෙය තොගයේ ලිපිනය ඉවත් කර එයට පනිනවා). එය අවශ්‍ය පරිදි සැකසිය හැකි ස්ටක් පොයින්ටර් ලේඛනයට පහළින් ඇති මතක කලාපයකි. සබ්මැරීන වෙත තර්ක යැවීම සඳහා ද, සබ්ට්‍රවුටින් ඇමතීමට පෙර ලේඛනයේ ඇති අගයන් ආරක්ෂා කිරීම සඳහා ද මෙම තොගය භාවිතා වේ.

සංචය යනු මෙහෙයුම් පද්ධතිය විසින් යෙදුමකට ලබා දෙන මතකයේ කොටසකි, සාමාන්‍යයෙන් malloc වැනි syscall හරහා. නවීන මෙහෙයුම් පද්ධති වල මෙම මතකය ඇමතුම් ක්‍රියාවලියට පමණක් ප්‍රවේශ විය හැකි පිටු සමූහයකි.

ධාවන වේලාවේදී තොගයේ ප්‍රමාණය තීරණය වන අතර සාමාන්‍යයෙන් වැඩසටහන දියත් කිරීමෙන් පසුව එය වර්ධනය නොවේ. සී වැඩසටහනක දී, එක් එක් ශ්‍රිතය තුළ ප්‍රකාශිත සෑම විචල්‍යයක්ම රඳවා තබා ගැනීමට ප්‍රමාණවත් තරම් විශාල විය යුතුය. ගොඩවල් අවශ්‍ය පරිදි ගතිකව වර්ධනය වනු ඇත, නමුත් මෙහෙයුම් පද්ධතිය අවසානයේ ඇමතුම ලබා දෙයි (එය බොහෝ විට මැල්ලොක් විසින් ඉල්ලා ඇති වටිනාකමට වඩා ගොඩගැසෙනු ඇත, එවිට අවම වශයෙන් අනාගත මැලොක් වලට කර්නලය වෙත ආපසු යාමට අවශ්‍ය නොවනු ඇත. වැඩි මතකයක් ලබා ගන්න. මෙම හැසිරීම බොහෝ විට අභිරුචිකරණය කළ හැකිය)

වැඩසටහන දියත් කිරීමට පෙර ඔබ තොගය වෙන් කර ඇති නිසා, ඔබට තොගය භාවිතා කිරීමට පෙර කිසි විටෙකත් malloc කිරීමට අවශ්‍ය නොවේ, එබැවින් එහි සුළු වාසියක් ඇත. ප්‍රායෝගිකව, අතථ්‍ය මතක උප පද්ධති ඇති නවීන මෙහෙයුම් පද්ධතිවල වේගවත් වන්නේ කුමක්ද සහ මන්දගාමී වන්නේ කුමක් දැයි පුරෝකථනය කිරීම ඉතා අසීරු ය, මන්ද පිටු ක්‍රියාත්මක වන ආකාරය සහ ඒවා ගබඩා කර ඇති ආකාරය ක්‍රියාත්මක කිරීමේ විස්තරයකි.

මම හිතන්නේ තවත් බොහෝ අය මේ සම්බන්ධයෙන් ඔබට බොහෝ දුරට නිවැරදි පිළිතුරු ලබා දී ඇත.

කෙසේ වෙතත්, මග හැරී ඇති එක් විස්තරයක් නම්, “ගොඩවල්” ඇත්ත වශයෙන්ම “නිදහස් ගබඩාව” ලෙස හැඳින්විය යුතුය. මෙම වෙනස සඳහා හේතුව වන්නේ මුල් නිදහස් ගබඩාව "ද්විමය ගොඩවල්" ලෙස හැඳින්වෙන දත්ත ව්‍යුහයක් සමඟ ක්‍රියාත්මක කිරීමයි. එම හේතුව නිසා, malloc () / free () හි මුල් ක්‍රියාත්මක කිරීම් වලින් වෙන් කිරීම ගොඩවල් වලින් වෙන් කිරීමකි. කෙසේ වෙතත්, මෙම නවීන දිනවලදී, බොහෝ නිදහස් වෙළඳසැල් ද්විමය ගොඩවල් නොවන ඉතා සවිස්තරාත්මක දත්ත ව්‍යුහයන් සමඟ ක්‍රියාත්මක වේ.

ඔබට තොගය සමඟ රසවත් දේවල් කළ හැකිය. නිදසුනක් ලෙස, ඔබට ඇලෝකා වැනි කාර්යයන් ඇත (එහි භාවිතය පිළිබඳ විශාල අනතුරු ඇඟවීම් ඔබට ලබා ගත හැකි යැයි උපකල්පනය කරයි), එය මතකය සඳහා ගොඩවල් නොව ගොඩගැසීම විශේෂයෙන් භාවිතා කරන malloc ආකාරයකි.

එයින් කියැවෙන්නේ, සිරස් මත පදනම් වූ මතක දෝෂ මා අත්විඳින නරකම ඒවා බවයි. ඔබ ගොඩවල් මතකය භාවිතා කරන්නේ නම් සහ ඔබ විසින් වෙන් කරන ලද කොටසෙහි සීමාවන් ඉක්මවා ගියහොත්, අංශ දෝෂයක් අවුලුවාලීමට ඔබට හොඳ අවස්ථාවක් තිබේ. . මගේ වැඩසටහන තර්කනයේ නීතිවලට අවනත වීම නවතා දමා ඇති බව මට හැඟෙන සෑම විටම එය ස්වාරක්ෂක පිටාර ගැලීමක් බව මම ඉගෙන ගතිමි.

සරලවම, තොගය යනු දේශීය විචල්‍යයන් නිර්මාණය වන ස්ථානයයි. එසේම, ඔබ උපසිරැසියක් අමතන සෑම අවස්ථාවකම වැඩසටහන් කවුන්ටරය (ඊළඟ යන්ත්‍ර උපදෙස් සඳහා දර්ශකය) සහ ඕනෑම වැදගත් ලේඛනයක්, සමහර විට පරාමිතීන් තොගයට තල්ලු වේ. එවිට සබ්ට්‍රවුටින් තුළ ඇති ඕනෑම දේශීය විචල්‍යයක් තොගයට තල්ලු කරනු ලැබේ (සහ එතැන් සිට භාවිතා වේ). සබ්මැරීනය අවසන් වූ විට, එම දේවල් සියල්ලම නැවත තොගයෙන් ඉවත් වේ. පරිගණකය සහ ලියාපදිංචි දත්ත ලබාගෙන එය තිබූ තැනට නැවත දමන්න, එවිට ඔබේ වැඩසටහනට එහි ප්‍රීතිමත් ගමන යා හැකිය.

සංචය යනු මතක ගතික මතක විබෙදුම් වලින් සෑදී ඇති ප්‍රදේශයයි (පැහැදිලි "නව" හෝ "වෙන් කරන්න" ඇමතුම්). එය විශේෂ දත්ත ව්‍යුහයක් වන අතර එය විවිධ ප්‍රමාණයේ මතක කොටස් සහ ඒවායේ වෙන් කිරීමේ තත්ත්වය නිරීක්ෂණය කළ හැකිය.

"සම්භාව්‍ය" පද්ධති වලදී RAM සකස් කර ඇති අතර එමඟින් තොගයේ දර්ශකය මතකයේ පතුලෙන් ආරම්භ වන අතර, ගොඩවල් දර්ශකය ඉහළින් ආරම්භ වන අතර ඒවා එකිනෙකා දෙසට වර්ධනය විය. ඒවා අතිච්ඡාදනය වුවහොත්, ඔබ RAM වලින් බැහැරයි. එය නවීන බහු-නූල් මෙහෙයුම් පද්ධති සමඟ ක්‍රියා නොකරයි. සෑම නූලකටම තමන්ගේම තොගයක් තිබිය යුතු අතර ඒවා ගතිකව නිර්මාණය කළ හැකිය.

විකී ඇන්වර්සර් වෙතින්.

සිරස්

ශ්‍රිතයක් හෝ ක්‍රමයක් වෙනත් ශ්‍රිතයක් කැඳවන විට එය වෙනත් ශ්‍රිතයක් ලෙස හැඳින්වේ. අවසාන ශ්‍රිතය එහි අගය ලබා දෙන තෙක් එම සියලු ශ්‍රිත ක්‍රියාත්මක කිරීම අත්හිටවනු ලැබේ.

අත්හිටවූ ශ්‍රිත ඇමතුම් දාමය තොගය වේ, මන්දයත් තොගයේ මූලද්‍රව්‍ය (ශ්‍රිත ඇමතුම්) එකිනෙකා මත රඳා පවතින බැවිනි.

ව්‍යතිරේකය හැසිරවීමේදී සහ නූල් ක්‍රියාත්මක කිරීමේදී සලකා බැලිය යුතු කොටස වැදගත් වේ.

ගොඩවල්

සංචය යනු විචල්‍යයන් ගබඩා කිරීම සඳහා වැඩසටහන් භාවිතා කරන මතකයයි. සංචයේ මූලද්රව්යය (විචල්යයන්) එකිනෙකා සමඟ පරායත්තතාවයක් නොමැති අතර සෑම විටම ඕනෑම වේලාවක අහඹු ලෙස ප්රවේශ විය හැකිය.

සිරස්

• ඉතා වේගවත් ප්‍රවේශය
• විචල්යයන් පැහැදිලිව වෙන් කිරීම අවශ්ය නොවේ
• CPU විසින් අවකාශය කාර්යක්ෂමව කළමනාකරණය කරයි, මතකය ඛණ්ඩනය නොවනු ඇත
• දේශීය විචල්යයන් පමණි
• තොගයේ ප්‍රමාණය සීමා කරන්න (OS මත යැපෙන)
• විචල්‍යයන් ප්‍රමාණය වෙනස් කළ නොහැක

ගොඩවල්

• විචල්‍යයන්ට ගෝලීයව ප්‍රවේශ විය හැකිය
• මතක ප්‍රමාණයට සීමාවක් නැත
• (සාපේක්ෂව) මන්දගාමී ප්‍රවේශය
• අවකාශය කාර්යක්ෂමව භාවිතා කිරීම සහතික කිරීමක් නොමැත, කාලයත් සමඟ මතකය ඛණ්ඩනය වී මතක කුට්ටි වෙන් කර නිදහස් කරනු ලැබේ
• ඔබ මතකය කළමනාකරණය කළ යුතුය (විචල්‍යයන් වෙන් කිරීම සහ නිදහස් කිරීම ඔබ භාරව සිටී)
• Realloc () භාවිතයෙන් විචල්‍යතා ප්‍රමාණය වෙනස් කළ හැකිය

හරි, සරලව හා කෙටියෙන් කිවහොත්, එයින් අදහස් කරන්නේ ඇණවුම් කර ඇණවුම් කර නොමැති බවයි ...!

සිරස් : අඩුක්කුව භාණ්ඩ දී දේවල් එක් එක්-වෙනත් මුදුනේ, මාර්ගයෙන් සකස් කිරීමට වඩා වේගයෙන් හා වඩා කාර්යක්ෂම විය ඇහුණා ...!

එබැවින් නිශ්චිත අයිතමය යොමු කිරීම සඳහා සෑම විටම දර්ශකයක් ඇත, එසේම සැකසීම වේගවත් වනු ඇත, අයිතම අතර සම්බන්ධතාවයක් ද ඇත ... ...

ගොඩවල් : කිසිදු ඇණවුමක්, සැකසීම මන්දගාමී වන අතර නිශ්චිත අනුපිළිවෙලක් හෝ දර්ශකයක් නොමැතිව අගයන් අවුල් වී ඇත ... අහඹු ලෙස පවතින අතර ඒවා අතර කිසිදු සම්බන්ධයක් නොමැත ... එබැවින් ක්‍රියාත්මක කිරීම සහ භාවිතා කිරීමේ කාලය වෙනස් විය හැකිය ...

ඒවා කෙබඳු විය හැකිදැයි පෙන්වීමට මම පහත රූපය ද නිර්මාණය කරමි:

කෙටියෙන්

ස්ථිතික මතක විබෙදුම සඳහා තොගයක් සහ ගතික මතක වෙන් කිරීම සඳහා ගොඩවල් භාවිතා කරයි, දෙකම පරිගණකයේ RAM තුළ ගබඩා කර ඇත.

විස්තරාත්මකව

තොගය

තොගය යනු "LIFO" (අවසාන වශයෙන්, පළමුවෙන්ම) දත්ත ව්‍යුහයකි, එය CPU විසින් තරමක් සමීපව කළමනාකරණය කර ප්‍රශස්ත කරනු ලැබේ. ශ්‍රිතයක් නව විචල්‍යයක් ප්‍රකාශයට පත් කරන සෑම අවස්ථාවකම එය “තල්ලු” කරනු ලැබේ. ශ්‍රිතයක් පිටවන සෑම අවස්ථාවකම, එම ශ්‍රිතය මඟින් තොගයට තල්ලු කරන ලද සියලු විචල්‍යයන් නිදහස් වේ (එනම් ඒවා මකා දමනු ලැබේ). සිරස් විචල්‍යයක් නිදහස් වූ පසු, එම මතක කලාපය වෙනත් සිරස් විචල්‍යයන් සඳහා ලබා ගත හැකිය.

විචල්යයන් ගබඩා කිරීම සඳහා තොගය භාවිතා කිරීමේ වාසිය නම්, මතකය ඔබ වෙනුවෙන් කළමනාකරණය කිරීමයි. ඔබට අතින් මතකය වෙන් කිරීමට අවශ්‍ය නැත, නැතහොත් ඔබට එය තවදුරටත් අවශ්‍ය නොවන විට එය නිදහස් කරන්න. එපමණක්ද නොව, CPU විසින් තොග මතකය ඉතා කාර්යක්ෂමව සංවිධානය කරන හෙයින්, විචල්‍යයන් කියවීම සහ ලිවීම ඉතා වේගවත් වේ.

තවත් බොහෝ දේ මෙහි සොයාගත හැකිය .

ගොඩවල්

සංචය යනු ඔබේ පරිගණකයේ මතකයේ කලාපයක් වන අතර එය ඔබ වෙනුවෙන් ස්වයංක්‍රීයව කළමනාකරණය නොවන අතර CPU විසින් තදින් කළමනාකරණය නොකෙරේ. එය මතකයේ වඩා නිදහස්-පාවෙන කලාපයකි (එය විශාල වේ). සංචය මත මතකය වෙන් කිරීම සඳහා, ඔබ විසින් C ශ්‍රිත ගොඩනගා ඇති malloc () හෝ calloc () භාවිතා කළ යුතුය. ඔබ සංචය මතකය වෙන් කළ පසු, ඔබට එම මතකය තවදුරටත් අවශ්‍ය නොවන විට එය අවලංගු කිරීමට නිදහස් () භාවිතා කිරීමේ වගකීම ඔබ සතුය.

ඔබ මෙය කිරීමට අපොහොසත් වුවහොත්, ඔබේ වැඩසටහනට මතක කාන්දුවක් ලෙස හැඳින්වේ. එනම්, ගොඩවල මතකය තවමත් පසෙකට දමනු ඇත (එය වෙනත් ක්‍රියාවලි සඳහා ලබා ගත නොහැක). නිදොස් කිරීමේ කොටසේ අප දකින පරිදි, මතක කාන්දු වීම හඳුනා ගැනීමට ඔබට උපකාර කළ හැකි Valgrind නම් මෙවලමක් තිබේ.

තොගය මෙන් නොව, ගොඩට විචල්‍ය ප්‍රමාණය මත ප්‍රමාණ සීමා නොමැත (ඔබේ පරිගණකයේ පැහැදිලි භෞතික සීමාවන් හැරුණු විට). ගොඩවල් මතකය කියවීමට හා ලිවීමට තරමක් මන්දගාමී වේ, මන්ද යත්, ගොඩවල මතකය වෙත ප්‍රවේශ වීම සඳහා යමෙකුට දර්ශක භාවිතා කළ යුතු බැවිනි. අපි ළඟදීම දර්ශකයන් ගැන කතා කරමු.

තොගයේ මෙන් නොව, සංචය මත සාදන ලද විචල්‍යයන් ඔබේ වැඩසටහනේ ඕනෑම තැනක සිට ඕනෑම ශ්‍රිතයකට ප්‍රවේශ විය හැකිය. ගොඩවල් විචල්‍යයන් ගෝලීය වශයෙන් විෂය පථයට අයත් වේ.

තවත් බොහෝ දේ මෙහි සොයාගත හැකිය .

තොගයේ වෙන් කර ඇති විචල්‍යයන් කෙලින්ම මතකයට ගබඩා කර ඇති අතර මෙම මතකයට ප්‍රවේශය ඉතා වේගවත් වන අතර, වැඩසටහන වෙන් කරන විට එහි ප්‍රතිපාදන සමඟ කටයුතු කරනු ලැබේ. ශ්‍රිතයක් හෝ ක්‍රමයක් වෙනත් ශ්‍රිතයක් කැඳවන විට එය වෙනත් ශ්‍රිතයක් ලෙස හැඳින්වේ. අවසාන ශ්‍රිතය එහි අගය ලබා දෙන තෙක් එම සියලු ශ්‍රිත ක්‍රියාත්මක කිරීම අත්හිටවනු ලැබේ. තොගය සැමවිටම LIFO අනුපිළිවෙලකට වෙන් කර ඇත, වඩාත්ම මෑතකදී වෙන් කර ඇති කොටස සෑම විටම නිදහස් කළ යුතු ඊළඟ කොටසයි. මෙය තොගයේ ලුහුබැඳීම සැබවින්ම සරල කරයි, තොගයෙන් කොටසක් නිදහස් කිරීම එක් දර්ශකයක් සැකසීමට වඩා වැඩි දෙයක් නොවේ.

ගොඩවල් මත වෙන් කර ඇති විචල්‍යයන් ඒවායේ මතකය ධාවන වේලාවට වෙන් කර ඇති අතර මෙම මතකයට ප්‍රවේශ වීම ටිකක් මන්දගාමී වේ, නමුත් ගොඩවල් ප්‍රමාණය සීමා වන්නේ අථත්‍ය මතකයේ ප්‍රමාණයෙන් පමණි. සංචයේ මූලද්‍රව්‍යයන් එකිනෙකා සමඟ පරායත්තතාවයක් නොමැති අතර ඕනෑම වේලාවක අහඹු ලෙස ප්‍රවේශ විය හැකිය. ඔබට ඕනෑම වේලාවක වාරණයක් වෙන් කර ඕනෑම වේලාවක එය නිදහස් කළ හැකිය. ඕනෑම වේලාවක ගොඩවල කුමන කොටස් වෙන් කර ඇත්ද යන්න පිළිබඳව සොයා බැලීම වඩාත් සංකීර්ණ කරයි.

සම්පාදනය කරන වේලාවට පෙර ඔබට කොපමණ දත්ත ප්‍රමාණයක් වෙන් කළ යුතුදැයි ඔබ හරියටම දන්නේ නම් ඔබට තොගය භාවිතා කළ හැකිය, එය විශාල නොවේ. ධාවන වේලාවේදී ඔබට කොපමණ දත්ත ප්‍රමාණයක් අවශ්‍ය දැයි ඔබ නොදන්නේ නම් හෝ ඔබට විශාල දත්ත ප්‍රමාණයක් වෙන් කිරීමට අවශ්‍ය නම් ඔබට ගොඩවල් භාවිතා කළ හැකිය.

බහු-නූල් තත්වයක් තුළ සෑම නූල් එකකටම සම්පූර්ණයෙන්ම ස්වාධීන තොගයක් ඇත, නමුත් ඒවා ගොඩවල් බෙදා ගනී. තොගය නූල් විශේෂිත වන අතර සංචය යෙදුම් විශේෂිත වේ. ව්‍යතිරේකය හැසිරවීමේදී සහ නූල් ක්‍රියාත්මක කිරීමේදී සලකා බැලිය යුතු කොටස වැදගත් වේ.

සෑම නූල් එකකටම තොගයක් ලැබෙන අතර, යෙදුම සඳහා සාමාන්‍යයෙන් ඇත්තේ එක ගොඩකි (විවිධ වර්ගවල වෙන් කිරීම් සඳහා බහු ගොඩවල් තිබීම සාමාන්‍ය දෙයක් නොවේ).

ධාවන වේලාවේදී, යෙදුමට වැඩි සංචයක් අවශ්‍ය නම්, එයට නිදහස් මතකයෙන් මතකය වෙන් කළ හැකි අතර, තොගයට මතකය අවශ්‍ය නම්, යෙදුම සඳහා නොමිලේ මතක වෙන් කළ මතකයෙන් මතකය වෙන් කළ හැකිය.

පවා, වැඩි විස්තර මෙහි සහ මෙහි දක්වා ඇත.

දැන් ඔබේ ප්‍රශ්නයේ පිළිතුරු වෙත එන්න .

මෙහෙයුම් පද්ධතිය හෝ භාෂා ධාවන කාලය මඟින් ඒවා කොතෙක් දුරට පාලනය වේද?

නූල් නිර්මාණය කරන විට මෙහෙයුම් පද්ධතිය එක් එක් පද්ධති මට්ටමේ නූල් සඳහා තොගය වෙන් කරයි. යෙදුම සඳහා ගොඩවල් වෙන් කිරීම සඳහා සාමාන්‍යයෙන් මෙහෙයුම් පද්ධතිය භාෂා ධාවන වේලාව මගින් හැඳින්වේ.

තවත් බොහෝ දේ මෙහි සොයාගත හැකිය .

ඔවුන්ගේ විෂය පථය කුමක්ද?

දැනටමත් ඉහළින් ලබා දී ඇත.

"සම්පාදනය කිරීමට පෙර ඔබට කොපමණ දත්ත ප්‍රමාණයක් වෙන් කළ යුතුදැයි ඔබ හරියටම දන්නේ නම් ඔබට තොගය භාවිතා කළ හැකිය. එය එතරම් විශාල නොවේ. ධාවන වේලාවේදී ඔබට කොපමණ දත්ත ප්‍රමාණයක් අවශ්‍ය දැයි ඔබ නොදන්නේ නම් ඔබට ගොඩවල් භාවිතා කළ හැකිය. ඔබට විශාල දත්ත ප්‍රමාණයක් වෙන් කිරීමට අවශ්‍යයි.

තවත් බොහෝ දේ මෙහි සොයාගත හැකිය .

එක් එක් ප්‍රමාණය තීරණය කරන්නේ කුමක් ද?

නූල් එකක් සෑදූ විට තොගයේ ප්‍රමාණය OS විසින් සකසා ඇත . යෙදුම් ආරම්භයේ දී සංචයේ ප්‍රමාණය සකසා ඇත, නමුත් අවකාශය අවශ්‍ය වන විට එය වර්ධනය විය හැකිය (විබෙදුම්කරු මෙහෙයුම් පද්ධතියෙන් වැඩි මතකයක් ඉල්ලා සිටී).

එකක් වේගවත් කරන්නේ කුමක් ද?

තොග වෙන් කිරීම වඩා වේගවත් බැවින් එය සැබවින්ම කරන්නේ තොග දර්ශකය ගෙනයාම පමණි. මතක තටාක භාවිතා කරමින්, ඔබට ගොඩවල් වෙන් කිරීමෙන් සැසඳිය හැකි කාර්ය සාධනයක් ලබා ගත හැකිය, නමුත් එය සුළු වශයෙන් එකතු වූ සංකීර්ණතාවයක් සහ එහි හිසරදයක් සමඟ පැමිණේ.

එසේම, ස්ටැක් එදිරිව ගොඩවල් කාර්ය සාධනය සලකා බැලීම පමණක් නොවේ; එය වස්තූන්ගේ අපේක්ෂිත ආයු කාලය ගැන ද ඔබට බොහෝ දේ කියයි.

විස්තර මෙතැනින් සොයාගත හැකිය .

1980 දශකයේ දී යුනික්ස් විශාල සමාගම් තමන්ගේම දෑ පෙරළා ගනිමින් බනිස් මෙන් ප්‍රචාරය කළේය. එක්සෝන් සතුව වෙළඳ නාම දුසිම් ගණනක් ඉතිහාසයට අහිමි විය. මතකය සකසා ඇති ආකාරය බොහෝ ක්‍රියාත්මක කරන්නන්ගේ අභිමතය පරිදි විය.

සාමාන්‍ය C වැඩසටහනක් මතකයේ සමතලා කර ඇති අතර එය brk () අගය වෙනස් කිරීමෙන් වැඩි කිරීමට අවස්ථාවක් ලබා දෙයි. සාමාන්‍යයෙන්, HEAP මෙම brk අගයට වඩා මඳක් අඩු වූ අතර brk වැඩි කිරීමෙන් පවතින ගොඩවල් ප්‍රමාණය වැඩි විය.

තනි STACK සාමාන්‍යයෙන් HEAP ට වඩා අඩු ප්‍රදේශයක් වූ අතර එය ඊළඟ ස්ථාවර මතක කොටසෙහි මුදුන දක්වා වටිනාකමක් නැති මතක පත්‍රිකාවක් විය. මෙම මීළඟ කොටස බොහෝ විට CODE වූ අතර එය එහි යුගයේ සුප්‍රසිද්ධ හක්කක ඇති දත්ත මගින් නැවත ලිවිය හැකිය.

එක් සාමාන්‍ය මතක වාරණයක් වූයේ එක් නිෂ්පාදකයෙකුගේ පිරිනැමීමේදී අහම්බෙන් ශුන්‍ය නොවූ BSS (ශුන්‍ය අගයන් සහිත කොටසකි). තවත් එකක් වූයේ නූල් සහ සංඛ්‍යා ඇතුළුව ආරම්භක අගයන් අඩංගු ඩේටා ය. තුනෙන් එකක් වූයේ සීආර්ටී (සී ධාවන කාලය), ප්‍රධාන, කාර්යයන් සහ පුස්තකාල අඩංගු කෝඩ් ය.

යුනික්ස් හි අථත්‍ය මතකයේ පැමිණීම බොහෝ බාධක වෙනස් කරයි. මෙම කුට්ටි එකිනෙකට පරස්පර, හෝ ප්‍රමාණයෙන් සවි කිරීමට හෝ විශේෂිත ආකාරයකින් ඇණවුම් කිරීමට අවශ්‍ය වෛෂයික හේතුවක් නොමැත. ඇත්ත වශයෙන්ම, යුනික්ස් වලට පෙර මෙම බාධක වලින් පීඩා විඳි මල්ටික්ස් නොවීය. මෙන්න එම යුගයේ මතක පිරිසැලසුමක් පෙන්වන ක්‍රමානුරූප සටහනකි.

අතථ්‍ය මතකයේ එක් එක් ක්‍රියාවලියෙහි සිරස් , ගොඩවල් සහ දත්ත :

ශත කිහිපයක්: මම සිතන්නේ, මතක චිත්‍රක හා වඩාත් සරල ලෙස ඇඳීම හොඳ වනු ඇත:

ඊතල - වැඩෙන තොග සහ ගොඩවල් කොතැනදැයි පෙන්වන්න, ක්‍රියාවලි තොගයේ ප්‍රමාණයට සීමාවක් ඇති බව, මෙහෙයුම් පද්ධතිය තුළ අර්ථ දක්වා ඇත, නූල් පොකුරේ ප්‍රමාණයේ සීමාවන් සාමාන්‍යයෙන් නූල් සාදන්න API. ගොඩවල් සාමාන්‍යයෙන් ක්‍රියාවලිය මඟින් උපරිම අථත්‍ය මතක ප්‍රමාණය සීමා කරයි, උදාහරණයක් ලෙස 32 බිට් 2-4 GB සඳහා.

ඉතා සරල ක්‍රමයක්: ක්‍රියාවලි ගොඩවල් ක්‍රියාවලිය සඳහා සාමාන්‍ය වන අතර ඇතුළත ඇති සියලුම නූල්, malloc () වැනි දෙයක් සමඟ පොදු අවස්ථාවකදී මතක වෙන් කිරීම සඳහා භාවිතා කරයි .

ස්ටැක් යනු පොදු අවස්ථා ශ්‍රිත ප්‍රතිලාභ දර්ශක සහ විචල්‍යයන්හි ගබඩා කිරීම සඳහා ඉක්මන් මතකයක් වන අතර එය ක්‍රියාකාරී ඇමතුමේ පරාමිතීන් ලෙස සකසනු ලැබේ, දේශීය ශ්‍රිත විචල්‍යයන්.

සමහර පිළිතුරු නිට්පික් කිරීම නිසා, මම මගේ මයිටාවට දායක වන්නෙමි.

පුදුමයට කරුණක් නම්, බහු (එනම් ධාවනය වන මෙහෙයුම් මට්ටමේ නූල් ගණනට සම්බන්ධ නොවේ) ඇමතුම් තොග විදේශීය භාෂාවලින් (පෝස්ට් ස්ක්‍රිප්ට්) හෝ වේදිකාවල (ඉන්ටෙල් ඉටේනියම්) පමණක් නොව, තන්තු , හරිත නූල් වලින් ද සොයාගත යුතු බව කිසිවෙකු සඳහන් කර නැත. සහ කොරෝටීන් සමහරක් ක්‍රියාත්මක කිරීම .

තන්තු, කොළ පැහැති කෙඳි සහ කොරෝටීන් බොහෝ ආකාරවලින් සමාන වන අතර එය බොහෝ ව්‍යාකූලත්වයට හේතු වේ. තන්තු සහ හරිත නූල් අතර ඇති වෙනස නම්, කලින් භාවිතා කළ සමුපකාර බහු කාර්යයන් වන අතර, දෙවැන්න සමුපකාර හෝ පූර්වගාමී එකක් (හෝ දෙකම) ඇතුළත් විය හැකිය. තන්තු සහ කොරෝටීන් අතර වෙනස සඳහා මෙහි බලන්න .

කෙසේ වෙතත්, තන්තු, හරිත කෙඳි සහ කොරෝටීන් යන දෙකෙහිම අරමුණ සමගාමීව ක්‍රියාත්මක වන බහුවිධ කාර්යයන් ඇත, නමුත් සමාන්තරව නොවේ (වෙනස සඳහා මෙම SO ප්‍රශ්නය බලන්න ) තනි මෙහෙයුම් මට්ටමේ නූල් තුළ, පාලනය එකිනෙකාගෙන් ඉදිරියට සහ පසුපසට මාරු කරයි සංවිධානාත්මක ආකාරයකින්.

තන්තු, කොළ පැහැති නූල් හෝ කොරොටින් භාවිතා කරන විට, සාමාන්‍යයෙන් ඔබට එක් ශ්‍රිතයකට වෙනම තොගයක් ඇත. (තාක්ෂණික වශයෙන්, එක් කාර්යයක් සඳහා පමණක් නොව, ක්‍රියාත්මක කිරීමේ සමස්ත සන්දර්භයම වේ. වඩාත්ම වැදගත් දෙය නම්, CPU ලියාපදිංචි වීමයි.) සෑම නූලකටම සමගාමීව ක්‍රියාත්මක වන කාර්යයන් තරම් විශාල ප්‍රමාණයක් ඇති අතර, එක් එක් ශ්‍රිතය ක්‍රියාත්මක කිරීම අතර නූල් මාරු වේ. ඔබේ වැඩසටහනේ තර්කනයට අනුව. ශ්‍රිතයක් එහි අවසානය දක්වා දිවෙන විට, එහි තොගය විනාශ වේ. ඉතින්, තොගවල සංඛ්‍යාව සහ ආයු කාලය ගතික වන අතර ඒවා OS මට්ටමේ නූල් ගණන අනුව තීරණය නොවේ!

" සාමාන්‍යයෙන් එක් ශ්‍රිතයකට වෙනම තොගයක් තිබිය යුතුය " යනුවෙන් මා පැවසූ බව සලකන්න . කුරූටයින්වල සිරස්ව හා සිරස්ව ක්‍රියාත්මක කිරීම යන දෙකම තිබේ . වඩාත්ම කැපී පෙනෙන සිරස් C ++ ක්‍රියාත්මක කිරීම් වන්නේ Boost.Coroutine සහ Microsoft PPL ය async/await. (කෙසේ වෙතත්, C ++ 17 සඳහා යෝජනා කරන ලද C ++ හි නැවත ආරම්භ කළ හැකි කාර්යයන් (aka " asyncසහ await"), සිරස් රහිත කොරෝටීන් භාවිතා කිරීමට ඉඩ ඇත.)

සී ++ සම්මත පුස්තකාලයට තන්තු යෝජනාව එළඹෙනු ඇත. එසේම, තෙවන පාර්ශවීය පුස්තකාල කිහිපයක් තිබේ. හරිත කෙඳි පයිතන් සහ රූබි වැනි භාෂාවලින් අතිශයින් ජනප්‍රියයි.

ප්‍රධාන කරුණු දැනටමත් ආවරණය කර තිබුණද මට බෙදා ගැනීමට යමක් තිබේ.

සිරස්

• ඉතා වේගවත් ප්‍රවේශය.
• RAM හි ගබඩා කර ඇත.
• සම්මත කරන ලද දේශීය විචල්‍යයන් සහ ක්‍රියාකාරී පරාමිතීන් සමඟ ක්‍රියාකාරී ඇමතුම් මෙහි පටවනු ලැබේ.
• වැඩසටහන විෂය පථයෙන් බැහැර වූ විට අවකාශය ස්වයංක්‍රීයව නිදහස් වේ.
• අනුක්‍රමික මතකයේ ගබඩා කර ඇත.

ගොඩවල්

• තොගයට සාපේක්ෂව මන්දගාමී ප්‍රවේශය.
• RAM හි ගබඩා කර ඇත.
• ගතිකව සාදන ලද විචල්‍යයන් මෙහි ගබඩා කර ඇති අතර, පසුව භාවිතයෙන් පසු වෙන් කළ මතකය නිදහස් කිරීම අවශ්‍ය වේ.
• මතක වෙන් කිරීම සිදු කරන ඕනෑම තැනක ගබඩා කර ඇත, සෑම විටම දර්ශකය මඟින් ප්‍රවේශ වේ.

සිත්ගන්නා සටහන:

• ක්‍රියාකාරී ඇමතුම් ගොඩවල් වල ගබඩා කර තිබුනේ නම්, එහි ප්‍රති ulted ලය වනුයේ අවුල් සහගත කරුණු 2 ක් වනු ඇත:
  1. අනුපිළිවෙලින් ගබඩා කිරීම නිසා, ක්‍රියාත්මක කිරීම වේගවත් වේ. ගොඩවල්වල ගබඩා කිරීම නිසා විශාල කාලයක් වැය වීමට ඉඩ ඇති අතර එමඟින් සමස්ත වැඩසටහනම මන්දගාමී වේ.
  2. කාර්යයන් ගොඩවල් වල ගබඩා කර තිබුනේ නම් (දර්ශකය මඟින් පෙන්වා ඇති අවුල් සහගත ආචයනය), නැවත අමතන්නාගේ ලිපිනය වෙත ආපසු යාමට ක්‍රමයක් නොතිබෙනු ඇත (මතකයේ අනුක්‍රමික ගබඩා කිරීම නිසා එම තොගය ලබා දෙයි).

වාව්! මෙතරම් පිළිතුරු ප්‍රමාණයක් ඇති අතර මම හිතන්නේ නැහැ ඔවුන්ගෙන් එක් කෙනෙක් එය නිවැරදිව තේරුම් ගත්තා ...

1) ඒවා කොහේද සහ මොනවාද (භෞතිකව සැබෑ පරිගණකයක මතකයේ)?

තොගය යනු ඔබේ වැඩසටහන් රූපයට වෙන් කර ඇති ඉහළම මතක ලිපිනය ලෙස ආරම්භ වන මතකය වන අතර එය එතැන් සිට වටිනාකම අඩු වේ. එය හැඳින්වෙන්නේ ශ්‍රිත පරාමිතීන් සඳහා සහ ශ්‍රිතවල භාවිතා වන සියලුම තාවකාලික විචල්‍යයන් සඳහා ය.

ගොඩවල් දෙකක් තිබේ: පොදු සහ පෞද්ගලික.

පුද්ගලික සංචය ඔබේ වැඩසටහනේ අවසාන බයිට් කේතයෙන් පසුව බයිට් 16 ක මායිමකින් (බිට් 64 වැඩසටහන් සඳහා) හෝ බයිට් 8 ක මායිමකින් (බිට් 32 වැඩසටහන් සඳහා) ආරම්භ වන අතර එතැන් සිට වටිනාකම වැඩි වේ. එය පෙරනිමි සංචය ලෙසද හැඳින්වේ.

පුද්ගලික සංචය විශාල වුවහොත් එය තොග ප්‍රදේශය අතිච්ඡාදනය වන අතර, තොගය විශාල වුවහොත් ගොඩවල් අතිච්ඡාදනය වේ. මක්නිසාද යත්, තොගය ඉහළ ලිපිනයකින් ආරම්භ වී පහළ ලිපිනය දක්වා ක්‍රියා කරන නිසා, නිසි ලෙස අනවසරයෙන් ඇතුළුවීම මඟින් ඔබට තොගය විශාල කරගත හැකි අතර එය පුද්ගලික ගොඩවල් ප්‍රදේශය අභිබවා කේත ප්‍රදේශය අතිච්ඡාදනය වේ. එවිට උපක්‍රමය නම් ඔබට කේතයට සම්බන්ධ කළ හැකි කේත ප්‍රදේශය ප්‍රමාණවත් තරම් අතිච්ඡාදනය කිරීමයි. එය කිරීමට ටිකක් උපක්‍රමශීලී වන අතර ඔබ ක්‍රමලේඛ බිඳවැටීමක් අවදානමට ලක් කරයි, නමුත් එය පහසු සහ ඉතා .ලදායී වේ.

පොදු සංචිතය ඔබේ වැඩසටහන් රූප අවකාශයෙන් පිටත එහි මතක අවකාශයේ වාසය කරයි. මතක සම්පත් හිඟ වුවහොත් මෙම මතකය දෘඩ තැටියට දමනු ලැබේ.

2) මෙහෙයුම් පද්ධතිය හෝ භාෂා ධාවන කාලය මඟින් ඒවා කොතෙක් දුරට පාලනය වේද?

තොගය පාලනය කරනු ලබන්නේ ක්‍රමලේඛකයා විසිනි, පුද්ගලික ගොඩවල් කළමනාකරණය කරනු ලබන්නේ මෙහෙයුම් පද්ධතිය විසිනි, සහ පොදු ගොඩවල් කිසිවෙකු විසින් පාලනය නොකෙරේ, එය මෙහෙයුම් පද්ධතියක් වන බැවින් - ඔබ ඉල්ලීම් කරන අතර ඒවා ප්‍රදානය කිරීම හෝ ප්‍රතික්ෂේප කිරීම.

2 ආ) ඔවුන්ගේ විෂය පථය කුමක්ද?

ඒවා සියල්ලම වැඩසටහනට ගෝලීය ය, නමුත් ඒවායේ අන්තර්ගතය පුද්ගලික, පොදු හෝ ගෝලීය විය හැකිය.

2c) එක් එක් ප්‍රමාණය තීරණය කරන්නේ කුමක් ද?

තොගයේ ප්‍රමාණය සහ පුද්ගලික ගොඩවල් තීරණය වන්නේ ඔබේ සම්පාදක ධාවන කාල විකල්පයන් මගිනි. ප්‍රමාණයේ පරාමිතියක් භාවිතා කර ධාවන වේලාවේදී පොදු ගොඩවල් ආරම්භ කරනු ලැබේ.

2d) එකක් වේගවත් කරන්නේ කුමක් ද?

ඒවා වේගවත් ලෙස නිර්මාණය කර නැත, ඒවා ප්‍රයෝජනවත් වන පරිදි නිර්මාණය කර ඇත. ක්‍රමලේඛකයා ඒවා භාවිතා කරන ආකාරය තීරණය වන්නේ ඒවා “වේගවත්” හෝ “මන්දගාමී” ද යන්නයි

REF:

https://norasandler.com/2019/02/18/Write-a-Compiler-10.html

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-getprocessheap

https://docs.microsoft.com/en-us/windows/desktop/api/heapapi/nf-heapapi-heapcreate

සංකල්ප ලෙස පිළිතුරු බොහොමයක් නිවැරදි ය, නමුත් සබ්ට්‍රවුටින් (එකලස් කිරීමේ භාෂාවෙන් අමතන්න ..) ඇමතීමට ඉඩ දීම සඳහා දෘඩාංග (එනම් මයික්‍රොප්‍රොසෙසරය) සඳහා තොගයක් අවශ්‍ය බව අපි සටහන් කළ යුතුය. (OOP යාලුවනේ එය ක්‍රම ලෙස හඳුන්වනු ඇත )

තොගයේ ඔබ ආපසු ලිපින සුරකින අතර call push / ret → pop ඇමතීම දෘඩාංග තුළ කෙලින්ම කළමනාකරණය වේ.

පරාමිතීන් සම්මත කිරීම සඳහා ඔබට තොගය භාවිතා කළ හැකිය .. එය රෙජිස්ටර් භාවිතා කිරීමට වඩා මන්දගාමී වුවද (මයික්‍රොප්‍රොසෙසර් ගුරු කියන්නේ හෝ 1980 දශකයේ හොඳ BIOS පොතක් ...)

• සිරස් නොමැතිව කිසිදු මයික්‍රොප්‍රොසෙසරයකට ක්‍රියා කළ නොහැක. (උපසිරැසි / ශ්‍රිත නොමැතිව එකලස් කිරීමේ භාෂාවෙන් පවා අපට වැඩසටහනක් සිතාගත නොහැකිය)
• ගොඩවල් නොමැතිව එයට හැකිය. (එකලස් කිරීමේ භාෂා වැඩසටහනකින් තොරව ක්‍රියා කළ හැකිය, ගොඩවල් යනු OS සංකල්පයක් වන බැවින් malloc ලෙස එය OS / Lib ඇමතුමකි.

තොග භාවිතය පහත පරිදි වේ:

• දෘඩාංගද, තල්ලු / පොප් පවා ඉතා කාර්යක්ෂම වේ.
• malloc ට කර්නල් මාදිලියට ඇතුළු වීම, අගුළු / සෙමෆෝර් (හෝ වෙනත් සමමුහුර්ත ප්‍රාථමිකයන්) භාවිතා කර යම් කේතයක් ක්‍රියාත්මක කිරීම සහ ප්‍රතිපාදන පිළිබඳ සටහන් තබා ගැනීමට අවශ්‍ය ව්‍යුහයන් කළමනාකරණය කිරීම අවශ්‍ය වේ.

තොගය අත්‍යවශ්‍යයෙන්ම පහසුවෙන් ප්‍රවේශ විය හැකි මතකයක් වන අතර එහි අයිතම හොඳින් හා හොඳින් ගබඩා කරයි. ප්‍රමාණය කල්තියා දන්නා අයිතම සඳහා පමණක් තොගයට යා හැකිය . අංක, නූල්, බූලියන් සඳහා තත්වය මෙයයි.

මෙම ගල් ගොඩ වන ඔබ ගෙවිමක් හා ව්යුහය predetermine නොහැකි භාණ්ඩ සඳහා මතකය . වස්තූන් සහ අරා විකෘති වී ධාවන වේලාවේදී වෙනස් විය හැකි බැවින් ඒවා ගොඩට යා යුතුය.

මුලාශ්‍රය: ඇකඩමි

හොඳ සාකච්ඡාවකට ස්තූතියි, නමුත් නියම පුද්ගලයෙක් ලෙස මම කල්පනා කරන්නේ උපදෙස් තබා ඇත්තේ කොහේද? ආරම්භයේ දී විද්‍යා scientists යින් විසින් ගෘහ නිර්මාණ ශිල්පයන් දෙකක් අතර තීරණයක් ගනු ලැබීය. අවසානයේදී, අපි වොන් නියුමාන් සැලසුම සමඟ ගිය අතර දැන් සියල්ල 'එකම' ලෙස සැලකේ. මම එකලස් කිරීම ඉගෙන ගන්නා විට මෙය මට අපහසු විය https://www.cs.virginia.edu/~evans/cs216/guides/x86.html ඔවුන් රෙජිස්ටර් සහ ස්ටැක් පොයින්ටර් ගැන කතා කරන නිසා.

ඉහත සෑම දෙයක්ම ඩේටා ගැන කතා කරයි. මගේ අනුමානය නම්, උපදෙස් යනු නිශ්චිත මතක අඩිපාරක් සහිත අර්ථ දක්වා ඇති දෙයක් බැවින්, එය සිරස් අතට යන අතර එකලස් කිරීමේදී සාකච්ඡා කරන ලද සියලුම 'එම' ලේඛණ තොගයේ ඇත. ඇත්ත වශයෙන්ම එවිට වස්තු දිශානත ක්‍රමලේඛයක් පැමිණියේ උපදෙස් හා දත්ත ගතික ව්‍යුහයකට ඇතුළත් කර ඇති නිසා දැන් උපදෙස් ගොඩවල ද තබා ගත හැකිද?