Process බෝ කරන fork()

මේ දවස් වල සෑහෙන ගැටලු ආපු දෙයක්නේ මේ fork(). ඊළග සතියේ දෙන Bonus Assignment එකට ආයෙ fork() එනවලු. ඒක නිසා fork() ගැන පොඩ්ඩක් ලියන්නම්. මෙන්න මේ විදියට පටන් ගන්නම් Process බෝ කරන fork() ගැන. 

fork() කියන්නේ System Call එකක්. ඒකත් හරි කතාවනේ. දැන් ඊළගට System Call කියන්නේ මොකක්ද කියන එක ප්‍රශ්නේ. System Call එකක් කියන්නේ තවත් එක් function එකක්. යම් කිසි program එකක අපි මේ function නැත්තම් System Calls, යොදාගන්නේ Operating System එකේ service එකක් ලබා ගන්න. ඉතින් ඔය විදියට System Calls ගොඩක් තියනවා. එකක් තමා fork. Linux වල වගේ නම් man fork කියලා terminal එකක ගැහුවම fork() ගැන man page එක පෙන්වනවා මේ පහළ තියන රූපයේ වගේ. අනිත් System Calls ගැන විස්තරත් මේ විදියට බලාගන්න පුළුවන්. ඉතින් මේ fork() වලට පොඩි පෙර ගමනක්.

fork() කියන System call එක භාවිතා කරන්නේ අළුතින් process නිර්මාණය කිරීම සඳහා. fork(), System call එක කිසිම argument එකක් ලබාගන්නේ නැහැ. ඒත් ඒ System Call එක execute වීමෙන් පස්සේ process ID එකක් return කරනවා. fork වලින් කරන්නේ අළුත් process එකක් නිර්මාණය කරන එක කියලා කලින්ම කිව්වනේ. ඒ process එක හඳුන්වන්නේ child process එක කියලා. fork() function එක call කලෙත් යම්කිසි process එකකින්නේ.  ඒ process එක හඳුන්වන්නේ parent process එක කියලා. fork() කියලා program එක තුල function එක call වුණ තැන සිට තියන සියලුම instructions, child process එකෙන් හා parent process එකෙන් කියන දෙකෙන්ම execute වෙනවා. ඒක නිසා අපිට සිද්ධ වෙනවා fork() execute වීමෙන් පසු parent සහ child processes වෙන වෙනම හඳුනගන්න. අන්න ඒකට තමයි fork() call කිරීමෙන් පසු return වෙන value එක අපිට පාවිච්චි කරන්න වෙන්නේ. ඇත්තටම බැලුවොත් fork() එක්ක සෙල්ලම සිද්ධ වෙන්නේ මේ return value එක එක්ක තමා...

මේ return value එකට ලැබෙන අගය  ගැන කොටස් තුනකින් කියන්නම්. මේ return value එක ඍණ අගයක් නම්, එයින් කියැවෙන්නේ child process එක නිර්මාණය වීම අසාර්ථකයි කියන එකයි. fork() function එක execute වීමෙන් පසු, අළුතින් සැකසුනු process එකට, ඒ කියන්නේ child process එකට බින්දුව (Zero) කියන value එක return කරනවා. ඒ වගේම fork() function එක execute වීමෙන් පසු එම parent process එකට ධන අගයක්(Positive Value) return කරනවා. එලෙස return කරන ධන අගය, අදාල parent process එකෙන් නිර්මාණය කරන ලද child process එකේ Process ID එක වේ. මේ return value එක ගැනත් සටහනක් තියමු. මේ  return value එක, sys/types.h කියන header file එකේ define කරල තියන pid_t කියන type එකට අයිති එකක්. මේ process id එක කියවගන්න (retrieve) කරගන්න getpid() කියන function එක පාවිච්චි කරන්න පුළුවන්. fork() එක්ක program ලියනවා කියන්නේ මේ  return value, process id එක්ක කරන සෙල්ලම තමා....

මෙතන ඉඳන් කතාව පටන් ගමු උදාහරණයක් එක්කම. මේ පහත තියන උදාහරණය ඇසුරින් තමයි විස්තරයම වෙන්නේ. හරිම සරල එකක්. මේ උදාහරණය බාගන්න ඕනි නම් මෙතන ක්ලික් කරන්න. මෙන්න උදාහරණය.....

මුල ඉදන්ම විස්තරේ පටන් ගන්නම්කෝ. sys/types.h නම් header file එක include කළ හේතුව ඉහතින් විස්තර කලානේ. ඒ වගේම unistd.h කියන header file එකත් include කරලා තියනවා. fork() function එක declare කරලා තියෙන්නේ unistd.h කියන header file එකත් එක්ක. ඊටපස්සේ main method එක යටතේ 8 වෙනි පේලියේ pid_t නම් ඉහත විස්තර කරන ලද type එකට අදාලව pid ලෙස variable එකක් හදාගෙන තියනවා. fork() function එක call කිරීමෙන් පසු return වෙන value එක ලබාගන්නේ මෙම pid නම් variable එකයි. එම variable එකේ අගය මත child හා parent වෙන් කෙරෙන ආකාරය ගැන කලින් දක්වලා තිබුනනේ. මේකෙ loop එකක් යොදාගෙන සිදු කර ඇත්තේ වැඩි වාර ගණනක් processes, run කරවීමයි. වැඩි වාර ගණනක් run කරවූ විට context switching ක්‍රියාව සිදුවීම නිසා child හා parent processes මාරුවෙන් මාරුවට සිදුවන අයුරු පැහැදිලිව බලාගන්න පුළුවන්. ඉතින් මේ උදාහරණය බොහොම සරල එකක්. ඒක බාගෙන run කරලා බලන්න. වැඩේ ඒ හැටි අමාරු නැහැ. තව උදාහරණයක් දෙන්නම්. ටිකක් ප්‍රායෝගික පැත්තක් තියන එකක්. ඕනි නම් කියන්නකෝ. ඔන්න ඔහොමයි fork()..... :)

C වලින් If else සහ switch

ගොඩක් අය Java වල මූලික කරුණු කාරණා දන්න නිසාC ගැන විස්තර කරද්දි Java වලට සාපේක්ෂව විස්තර කරන්න උත්සහ ගන්නම්. ඒක තේරුම් ගැනීමේ පහසුවක් වේවි. මාතෘකාවේ පිලිවෙලටම වැඩේ පටන් ගන්නම්....

if.....else

මේකෙන් වෙන්නේ මොකක්ද කියලා විස්තර කරන්න අවශ්‍ය වෙන එකක් නැහැ. කෙටියෙන් විස්තර කරනවා නම්, යම්කිසි සලකනු ලබන condition එකක සත්‍ය අසත්‍ය භාවය (true & false) මත යම්කිසි statement කිහිපයක් හෝ වෙනමම method එකක execute කරවීම if else භාවිතයෙන් කරගන්න පුළුවන්. C program එකක if else පාවිච්චි වෙන විදිය ගැන මෙහිදී බලමු. Java  වලට සාපේක්ෂව මෙහි වෙනසක් නැතිම තරම්.... if else භාවිතා කරන ආකාරය ගැන උදාහරණයකින් සලකමු. 

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int x = 9;
    if ( x == 5 )
    {
//     if condition is true
        printf("You are the winner\n");
    }
    else
    {
//     if condition is false
        printf("You are the looser\n");
    }
    return 0;
}


මේ උදාහරණයෙන් පැහැදිලි වෙනවා ඇති ඔබට Java හා C වලදි, if-else භාවිතයේ වෙනසක් නොමැතිම තරම් බව. මෙම උදාහරණයට අනුව සිදු වන්නේ x වල අගය 5 ට සමාන නම් You are the winner ලෙසත් එසේ නොවේ නම් You are the looser ලෙසත් print වේ. මේ ආකාරයට if statement එකක් තුළ තවත් if statement එකක් ලිවීමේ හැකියාවද තියනවා. 


Switch

If statement කිහිපයකින් කිරීමට හැකි සමහර කාර්යයන් switch statement එකක් භාවිතයෙන් කිරීමේ හැකියාවක් තියනවා. if....else සේම Switch statement එකද C වලදී හා Java වලදී වෙනසක් නැතිම තරම්. උදාහරණයක් සලකා බලමු.

#include <stdlib.h>
#include <stdio.h>

int main()
{
    int x = 1;
    switch (x)

    {
        case 1:
            printf("hello\n");
            break;

        case 2:
            printf("fool\n");
            break;

        default:
            printf("fellow\n");
            break;
    }
    return 0;
}

මෙහිදී සිදුවන දේ කෙටියෙන් පැහැදිලි කළොත්, if-else කිහිපයකින් කර ගැනීමට හැකි වැඩක් switch මගින් සිදු කරල තියනවා. මුලින්ම x කියල variable එකක් හදලා තියනවා. ඊට පස්සේ switch (x) කියන පේළියෙන් අපි සදහන් කරල තියනවා ඉස්සරහට කරන comparisons සියල්ල මේ x කියන variable එකත් සමග සිදුකළ යුතුයි කියලා. මේ variable එකට ගන්න පුළුවන් වෙන්නේ int එකක් හෝ char එකක් විතරයි.  ඒ වගේම මතක තියාගන්න char එකක් පාවිච්චි කරනව නම් char variable value එක single quotation ඇතුලේ ලියන්න. ඒක එහෙමයි. case කියලා තවත් keyword එකක් පාවිච්චි වෙලා තියනවා මෙතන. ඒකෙන් කරන්නේ x සදහා අපි compare කරන value එක මොකක්ද කියලා දෙන එකයි. break කියලා තවත් keyword එකක් තියනවා. අපි හිතමු මේ උදාහරණයට කියන code එක ගැන. ඒකෙ දැන් case 1 : කියන තැනින්ම true වෙන නිසා එතනින් පස්සේ තියන line එකේ සිට execute වෙන්න පටන් ගන්නවා. නමුත් case 1: නිසා execute වෙන්න ඕනි lines ටික අවසන් වෙන තැන අපි break කියන keyword එක use කලේ නැත්තම් case 1: වුණ තැන ඉදන් default කියන තැනට එනකං තියන සියලුම lines ටික execute වීම සිදු වෙනවා. break කියන keyword එක use කිරීමේ අරමුණ එයයි. default කියන්නේ නිකන් හරියට else වගේ තමා. case වල එක  value එකකටවත් true වුනේ නැතිනම් අවසානයට සිදුවන්නේ default යටතේ තියන lines ටික execute වෙන එක තමා. ඔන්න ඔහොමයි switch. මේකටම loops ගැනත් ලියන්න හිටියෙ. ඒකත් ලිව්ව නම් මේක මා ගලක් වගේ දික් වෙනවා. ඒක නිසා කතාව මතු සම්බන්ධයි. Loops සමගින් නැවත C ගැන ටිකක්....

ජය වේවා!!!

C නොම්මර 2 - scanf() ගැනත් බලමු ......

Command Line Argument ගැන කලින් ලියපු එක තේරුණද දන්නෙත් නැහැ. ඒක ගොඩක් අමාරු දෙයක් නෙමෙයි. තේරුම් ගන්න ලේසියි. දැන් ඉතිරි කොටස.... 

C පරිගණක භාෂාවේදී code එකක් execute  කරන්න පටන් ගන්නකොටම ඒක ඇතුලට දත්ත දෙන්න පුළුවන් විදියක් ගැන තමා කලින් ලිපියේ විස්තර කළේ. මේ ලියන්න හදන්නේ code එක execute වෙන අතරතුර ඊට දත්ත ඇතුලත් කරන විදියක් ගැන. ඒ තමා scanf().

scanf() එකේ අරමුණ කිව්වනෙ ඉතින්. execute වෙන අතරතුර char, int, float වැනි විවිධ වර්ග වල දත්ත ලබාදීමට scanf() භාවිතයෙන් පුලුවන්. උදාහරණයක් අරගෙන මේ ගැන බලමු. 

#include <stdlib.h>

int main()
{
    char scan;
    printf("Enter your letter : ");
    scanf("%c",&scan);
    printf("Your letter is %c\n",scan);
    return 0;
}

ඉහත උදාහරණයේ ඇති code එකට අනුව මෙහිදී execution එක අතරතුර ලබා ගෙන ඇත්තේ char එකක්. scanf("%c",&scan) යන පේළියේ %c යන සංකේතයෙන් අරුත් ගැන්වෙන්නේ char අගයක් ලබාගන්නා බවයි. එය scan නම් විචල්‍යයට ආදේශ වේ. ඊට පෙර පේළියක scan නමින් විචල්‍යයක් program එකට හදුන්වා දී තිබෙනවා. scanf මගින් කෙරෙනුයේ execution එකේදී ලබා ගන්නා දත්තය, හදුන්වා දෙන ලද විචල්‍යයට ආදේශ කිරීමයි. එය ඉතාමත් සරල කරුණක්.


ඊට පසු පේළියේ ඇති printf එක මගින් එම scan නම් විචල්‍යය සරල ලෙස console එක මත පෙන්වීමට සලස්වා ඇත. එය විචල්‍යයේ අගය එසේ භාවිතා නොකර වෙනත් ඕනෑම කටයුත්තක් සදහා භාවිතා කිරීමට හැකියාවක් තියනවා.

එමෙන්ම char අගයක් execution එකේදී ඇතුල් කරනවාසේම අනෙක් වර්ගවල දත්ත ද ඇතුල් කිරීමට scanf() භාවිතයෙන් පුළුවන්. පෙර උදාහරණයේ %c ලෙස සදහන් සංකේතය වෙනුවට %d භාවිතා කිරීමෙන් int අගයක් මෙන්ම %f භාවිතා කිරීමෙන් float අගයක් ඇතුල් කිරීමට හැකියාවක් තියනවා. අප ඇතුලත් කිරීමට බලාපොරොත්තු වන දත්තයේ වර්ගයට අනුකූල වෙන විදියට විචල්‍යය හදුන්වා දීමට අපි සැලකිලිමත් විය යුතු වෙනවා. ඇතුළත් කරන දත්ත වර්ගය විචල්‍යයට සුදුසු දත්තයක් නොවේනම්, program එක විසින් compilation error හෝ runtime errors ලබා දීමට ඉඩ තියනවා. ඉතින් ඔන්න ඔහොමයි scanf() මූලික වශයෙන් යෙදෙන්නේ.....

C භාවිතයෙන් Command Line Argument ලබා දීම

C පරිගණක භාෂාව ඉගෙනීමට පිවිසුමක් විදියට නම් මේ තැන ටිකක් ලොකු වැඩියි. ඒත් මේ වෙලාවේ මේ කොටස පොඩ්ඩක් වැදගත් කියලා හිතුනා. ඒකයි ලියන්න හිතුනේ... ඒත් පරිගණක භාෂාවක් ගැන සුළු හෝ දැනුමක් නොමැති අයෙකුට මේ ලිපියේ ගැටළු රැසක් ඇතිවෙන්න පුළුවන්. ඒ ගැන සමාව අයදිනවා මුලින්ම..

Command Line Argument එකකින් බලාපොරොත්තු වෙන්නේ, අපි විසින් ලියන ලද යම් කිසි code එකක් execute කිරීමට යාමේදීම ඒ තුළට යම්කිසි දත්තයක් ලබා දීමයි. C වලදී මෙම Command Line Argument එක ලබා ගන්නේ Char Array එකක් ආකාරයටයි. පහත උදාහරණය ආධාරයෙන් C වලදී එය සිදුකරගන්නා ආකාරය පිළිබද පැහැදීමටයි මේ උත්සාහය....

#include <stdio.h>

int main( int argc, char *argv[] ) 
{
     printf("%s",argv[1]);
     return 0;
}

මෙම ලිපියෙන් පැහැදීමට උත්සාහ ගන්නේ Command Line Argument ගැන නිසා ඒ පිළිබද පමණක් විසිතර කරන්නම්. මෙහිදී argc යනුවෙන් int විචල්‍යයක් සහ argv ලෙස char array එකක් හදුන්වා දී තිබෙනවා. එම int විචල්‍යයෙන් argument කීයක් char array එකට ගන්නවාද යන දදත්තය ලබා ගන්නා අතර char array මගින් එම argument එක ගැන තොරතුර ලබා ගන්නවා. ඉහත සදහන් වෙන මෙම code එක ./first යන විධානයෙන් execute කරනවා යැයි උපකල්පනය කරමු. මෙහිදී මම පළමු Argument එක Madhawa ලෙස ලබා දෙන්නම්. ඒ පහත ආකාරයටයි. 

ඉන්පසු මෙම code එක මගින් අපට පළමු Argument එක පාවිච්චි කරන්න අවශ්‍ය නම් එය Code එක තුළදී argv[1] ලෙස භාවිතයට ගත හැකියි. ඉහත උදාහරණයේ සිදුකර ඇත්තේ එම Code එක Execute වෙන වෙලාවේදී මා විසින් ලබා දුන් පළමු Argument එක නැවත Terminal එක මත පෙන්වීමයි. Java යන පරිගණක භාෂාව ඔබ දන්නවා නම් දැන් ඔබට ගැටලුවක් ඇති වේවි argv[0] ලෙස යොදා නොගන්නේ ඇයිද යන්න. නිකමට වගේ ඒ ගැනත් බලන්න. C වලදී code එක execute කිරීමට ලබා දෙන ./first (ඉහත උදාහරණය අනුව) යන කොටසද සලකනු ලබන්නේ Command Line Argument එකක් ලෙසයි. යම්හෙයකින් ඔබ code එක තුළදී argv[0] මුද්‍රණය වීමට සකස්කර තිබුණි නම් ඔබට එහි ප්‍රතිළුලය ලෙස ./first ලෙස මුද්‍රණය වනවා දැකිය හැකියි. Argument එකක් භාවිතා කළ හැකි ඉතාම සරළතම ආකාරයක් විතරයි.

මේ දෙවනි උදාහරණය භාවිතයෙන් argc ලෙස පළමු උදාහරණයේ භාවිතා වෙලා තියන int විචල්‍යය භාවිතා කළ හැක්කේ මොන ආකාරයකටද යන්න පැහැදිලි කිරීමට උත්සහ ගන්නම්.

#include <stdio.h>

int main( int argc, char *argv[] ) 
{
    if( argc == 2 )
        printf("The argument supplied is %s\n", argv[1]);
    else if( argc > 2 )
        printf("Too many arguments supplied.\n");
    else
        printf("No arguments\n");
   
    return 0;
}

මෙම code එක ඔබට පැහැදිලි ඇතැයි විශ්වාස කරනවා. මෙහි ඇත්තේ සරල ලෙස භාවිතාකර ඇති if එකකි. මෙහි පරීක්ෂා කර ඇත්තේ argc හි අගය 2ට සමානද යන කරුණයි. මෙහිදීද ඉහත සදහන් කළ කරුණ එලෙසම අදාල වේ. අප භාවිතා කරන්නේ එක Argument එකක් වුවද C වලදී Code එක execute කිරීමට භාවිතා කරන විධානය එක් Argument එකක් ලෙස සලකන නිසා සියලුම Argument ගණන දෙකක් වේ. මේ C භාෂාවේ විශේෂත්වයකි. ඉතින් Command Line Argument ගැන කෙටියෙන් කිව්වා ඔන්න.....