02
අප විසින් සකස් කරන program එකක් අවසන් වශයෙන් පරිගණකය තුළ execute වී‍ම සිදුවන ආකාරය පැහැදිලි කරන්නට මෙම ලිපියෙන් බලාපොරොත්තු වෙනවා. මේකෙදි කතා කරන්නෙ execute වී‍මට අවශ්‍ය මූලිකම දේවල් ටිකක් ගැන විතරයි.
අපි program එකක් සකස් කළ විට ඒක ගොඩක් සංවිධානාත්මකව තියෙනවා. ඒක බලපු ගමන් අපට එයින් සිදුවන දේ පැහැදිලිව තේරුම් ගන්න පුළුවන්. නමුත් පරිගණකයට ඒ දේ කරන්න බැහැ. එයට එකින් එක සිදු කල යුතු සියලුම දේවල් කියන්න ඕනි. මේ අපි තේරුම් ගත යුතු වැදගත්ම දෙයක්. කල යුතු ඉතාමත් සුළු පිය‍වරක් උනත් පරිගණකයට අපි විසින් කියන්න ඕනි. මේක මෙහෙම කියද්දි හොදට දන්න දෙයක් කියල හිතුනත් ඒක එච්චර ලේසියෙන් තේරුම් යන්නෙ නෑ. ඒ ගැන හොදින් හිතල බලන්න. ඒත් ඔබ code එකක් ලියද්දි මේ හැම පියවරක්ම ලියන්නෙ නෑනෙ. ඒත් ඔබ code එක compile කලාම compiler එක ඔබ වෙනුවෙන් ඒ දේවල් සිදු කරල දෙනවා. Assembly code එකක් ලියද්දි ඔබ මේ කරුණ ගැන හරියටම තේරුම් අරගෙන තියෙන්න ඕනි. මොකද assembly code එකක් කියන්නෙ compile කලාට පස්සෙ ලැබෙන එකක්.
අපි සරල code එකක් භාවිතා කරල මේ ක්‍රියාවලිය පැහැදිලි කර ගනිමු.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | int main() { int a = 10; int b = 5; int c = add(a,b); return 0; } int add(int x, int y) { int z = x+y; return z; } |
ඉහත code එක compile කලාම කලින් කිව්ව විදියට compiler එක ඔබ වෙනුවෙන් අවශ්‍ය එකතු කිරීම් කරල RAM එක තුළ එක් එක් instruction එක තැබිය යුතු memory address දක්වාම වූ සියලු විස්තර file එකකට ලියනවා. එම program එක run වෙද්දි RAM එක තුළ දත්ත පහත විදියට විහිදෙනවා කියල හිතමු.
assembly code ලිවීමේ දී සලකන විවිධ segment භාවිත කරන ක්‍රියාවලිය මදකට අමතක කරන්න. මේකෙ පැහැදිලි කරන්නෙ එක් method එකකට අදාල දත්ත එක තැනක තියෙනව කියල සලකලයි.
ඉහත පින්තූරයේ තියෙන විදියට memory address 1000-1050 වන තුරු main method එකත් 1100-1120 වන තුරු add method එකත් තියෙනව කියල හිතමු. Code එක compile කරන කොටම මොන memory address වලද program එක ලියවෙන්න ඕනි කියන එක file එකේ ලියවෙනවා. මොකද jump statement එකක් එහෙම තිබ්බොත් යන්න ඕනි මොන memory address එකටද කියන එක program එක දැනන් ඉන්න ඕනි. Code එක compile කරද්දිම memory address ලියවෙනවා නම් ප්‍රශ්නයක් තියෙනවා. Program එක compile කරන්නෙ එක වෙලාවක ඒත් ඊට පස්සෙ විවිධ වෙලා වලදි ඒක run කරනව. නමුත් ඒ හැම වෙලාවකදිම එකම memory එකේ ස්ථාන හිස්ව තියෙනවා කියල කියන්න බැහැ. මොකද එකම වෙලාවෙ program කිහිපයක් වැඩ කරන්න පුළුවන්නෙ. නමුත් අපි දැනට සලකමු අපේ program එකට මුළු memory එකම භාවිත කරන්න පුළුවන් කියල. එහෙම උනොත් ඉහත code එකේ ගැටලුවක් එ‍න්නෙ නෑ. ඒත් ඉහත code එකේ main method එකත් add method එකත් file දෙකක ලියල තියෙනව නම් ඒ file දෙක වෙන වෙනම compile කරන්න පුළුවන්නෙ. එතකොට....????
එතකොට එක් file එකක් අනිත් file එක භාවිත කරන memory address පිළිබද අව‍බෝධයක් නැහැ. File දෙකම එකම memory address භාවිත කරන්න ඉඩ තියෙනවා. එවිට එම program එක run වෙන්න විදියක් නැහැ. මෙම තත්වය මග හරවා ගන්නෙ linker එක භාවිතයෙන්.
| main.c | |
1 2 3 4 5 6 7 8 | int main() { int a = 10; int b = 5; int c = add(a,b); return 0; } |
| add.c | |
1 2 3 4 5 6 | int add(int x, int y) { int z = x+y; return z; } |
main method එක main.c file එකෙත් add method එක add.c file එකෙත් තියෙනව කියල හිතමු. compiler එකෙන් මේ file දෙක main.o add.o කියල file දෙකකට වෙන වෙනම compile කරනව කියල හිතමු. linker එකෙන් කරන්නෙ මේ file දෙකේ තියෙන දත්ත තනි file එකකට අලුතෙන් ලියන එක. එහෙම ලියද්දි memory address වල ගැටලුවක් වෙන්නෙ නැති විදියට memory එකේ තැන් දෙකකට එන විදියටයි ඒක ලියන්නෙ.
