പീറ്റേഴ്സൻ്റെ അൽഗോരിതം

**പീറ്റേഴ്സൻ്റെ  അൽഗോരിതം** (അല്ലെങ്കിൽ **പീറ്റേഴ്സൻ്റെ  പരിഹാരം** ) പരസ്പര ഒഴിവാക്കലിനുള്ള ഒരു കൺകറൻ്റ്  പ്രോഗ്രാമിംഗ് അൽഗോരിതം ആണ്. രണ്ടോ അതിലധികമോ  പ്രോസസ്സുകൾക്ക് പൊതുവായി ഉപയോഗിക്കേണ്ടി വരുന്ന വിഭവങ്ങൾ പങ്കിടുമ്പോൾ പ്രശ്നങ്ങൾ സൃഷ്ടിക്കപ്പെടാതെ ഇരിക്കുന്നതിന് ഈ അൽഗോരിതം ഉപയോഗിക്കാം. 1981 ൽ ഗാരി എൽ പീറ്റേഴ്സൺ എന്ന ഗണിത ശാസ്ത്രജ്ഞനാണ് ഇത് രൂപകൽപ്പന ചെയ്തത്.  പീറ്റേഴ്‌സണിൻ്റെ യഥാർത്ഥ അൽഗോരിതം രണ്ട് പ്രോസസ്സുകൾ ഉൾപ്പെടുമ്പോൾ മാത്രമേ ഉപയോക്കുവാൻ സാധിച്ചിരുന്നുള്ളൂവെങ്കിലും, രണ്ടിൽ കൂടുതൽ പ്രോസസ്സുകൾക്കു വേണ്ടിയും സാമാന്യവൽക്കരിച്ച് ഉപയോഗിക്കുവാൻ കഴിയും. 

## അൽഗോരിതം
ലഘുചിത്രം| പീറ്റേഴ്സൻ്റെ അൽഗോരിതംഅൽഗോരിതം രണ്ട് വേരിയബിളുകളാണ് ഉപയോഗിക്കുന്നത്: `flag[n]`, `turn`. `flag[n]` ഒരു ബൂളിയൻ വേരിയബിൾ ആണ്. `flag[n] ൻ്റെ വില` `true` ആണെങ്കിൽ അത് സൂചിപ്പിക്കുന്നത്, n എന്ന പ്രോസസ്സ് നിർണ്ണായക ഭാഗത്തിൽ (ക്രിട്ടിക്കൽ സെഷൻ) പ്രവേശിക്കാൻ ആഗ്രഹിക്കുന്നു എന്നാണ്. turn എന്ന വേരിയബിൾ ക്രിട്ടിക്കൽ സെഷൻ ഉപയോഗിക്കുന്നതിന് ഏതു പ്രൊസസ്സിനാണ് മുൻഗണന നൽകേണ്ടത് എന്ന് രേഖപ്പെടുത്തുന്നതിനാണ് ഉപയോഗിക്കുന്നത്. `turn = n` ആണെങ്കിൽ n എന്ന പ്രോസസ്സിനായിരിക്കും മുൻഗണന. ഉദാഹരണത്തിന്, P0, P1 എന്നിവ രണ്ട് പ്രോസസ്സുകൾ ആണെന്നിരിക്കട്ടെ. `turn = 0` ആണെങ്കിൽ P0-ക്കും `turn=1` ആണെങ്കിൽ P1-നുമായിരിക്കും മുൻഗണന. `flag[0] = true` ആണെങ്കിൽ P0 ക്രിട്ടിക്കൽ സെഷനിലേക്ക് പ്രവേശിക്കുവാൻ ആഗ്രഹിക്കുന്നു എന്നും മനസ്സിലാക്കാം. 

ഒരു പ്രോസസ്സിന് ക്രിട്ടിക്കൽ സെഷനിലേക്ക് പ്രവേശിക്കണമെങ്കിൽ അതിന് turn ലഭിക്കുകയും, മറ്റ് പ്രോസസ്സുകൾ എല്ലാം `flag[] false` ആയി സെറ്റ് ചെയ്തിരിക്കുകയും വേണം. ഇത് പ്രകാരം P0 എന്ന പ്രോസസ്സിന് ക്രിട്ടിക്കൽ സെഷനിലേക്ക് പ്രവേശിക്കണമെങ്കിൽ `turn = 0` -യും, `flag[1] = false` -ഉം ആയിരിക്കണം.

പീറ്റേഴ്സൻ്റെ അൽഗോരിതം ഉപയോഗിക്കുന്ന രണ്ട് പ്രോസസ്സുകളുടെ പ്രോഗ്രാമിൽ നിന്നുള്ള ഭാഗങ്ങളാണ് ചുവടെ കൊടുത്തിരിക്കുന്നത്. തുടക്കത്തിൽ `flag[]`  വേരിയബിളുകൾ `false`  ആക്കിയിരിക്കുന്നു. രണ്ടു പ്രോസസ്സുകൾക്കും നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കാൻ താൽപ്പര്യമില്ല എന്നർത്ഥം. 

P0 എന്ന പ്രോസസ്സ് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു മുൻപായി തൻ്റെ `flag`, `true`  ആക്കി മാറ്റുന്നു. തുടർന്ന് `turn = 1` ആക്കുക വഴി P1 എന്ന പ്രോസസ്സിന് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു ഊഴം നൽകുന്നു. അതിനു ശേഷം ഒരു `while()` ലൂപ്പ് ഉപയോഗിച്ച് P1-ൻ്റെ `flag` , `turn` എന്നിവ തുടർച്ചയായി നിരീക്ഷിക്കുന്നു. `flag[1] = true` ,`turn = 1` എന്നീ വിലകളിൽ ഏതെങ്കിലും ഒന്ന് മാറുന്നതു വരെ ഇത് തുടരുന്നു. ഇവയിൽ എതെങ്കിലും മാറുമ്പോൾ ലൂപ്പ് ബ്രേക്ക് ആവുകയും P0 അതിൻ്റെ നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുകയും ചെയ്യുന്നു. അതായത്, ഒന്നുകിൽ `flag[1] = false` ആകണം (P1-ന് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു താൽപര്യം ഇല്ല എന്നർത്ഥം) , അല്ലെങ്കിൽ `turn = 0` ആകണം (P1 അടുത്ത ഊഴം P0-ക്ക് നൽകി എന്നർത്ഥം). നിർണ്ണായക ഭാഗം കഴിഞ്ഞതിനു ശേഷം P0 തൻ്റെ `flag`, `false` ആക്കി മാറ്റുന്നു. P1-ൻ്റെ പ്രവർത്തനവും ഇതേപോലെയാണ്.

ഒരു പ്രോസസ്സ് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു മുൻപ് turn രണ്ടാമത്തെ പ്രോസസ്സിനു നൽകുന്നത് വഴിയും, നിർണ്ണായക ഭാഗത്തിനു ശേഷം തൻ്റെ `flag` `false` ആക്കുന്നതു വഴിയും, രണ്ടാമത്തെ പ്രോസസ്സിന് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു ഊഴം ലഭിക്കുമെന്ന് ഉറപ്പ് വരുത്തുന്നതായി കാണാം.

തുടക്കത്തിൽ എല്ലാ `flag` -കളും `false` ആയി വെക്കുക വഴി ഏതെങ്കിലും ഒരു പ്രോസസ്സ് മാത്രമേ നിലവിൽ നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു ശ്രമിക്കുന്നുള്ളൂവെങ്കിൽ അതിന് തടസ്സം നേരിടുകയില്ല. `while()` ലൂപ്പ് പ്രവർത്തിക്കുമ്പോൾ `flag[n] == true` എന്ന കണ്ടീഷൻ തെറ്റുകയും അതുവഴി ലൂപ്പ് ഉടൻ തന്നെ ബ്രേക്ക് ചെയ്ത് നിർണ്ണായക ഭാഗത്തിൽ പ്രവേശിക്കുന്നതിനു കാരണമാകും.

## അവലംബം


വർഗ്ഗം:അൽഗൊരിതങ്ങൾ