డెవలపర్లు ఇప్పుడు స్టేట్ ఫైల్స్ ఓవర్రైట్ అవుతాయేమో లేదా ఫైల్స్ మధ్య ఘర్షణలు (clashes) జరుగుతాయేమో అనే భయం లేకుండా ఒకేసారి అనేక కోడింగ్-ఏజెంట్ సెషన్లను ప్రారంభించవచ్చు. ఒక అడ్వైజరీ “share-nothing” ప్యాటర్న్ ప్రతి ఏజెంట్ యొక్క వర్క్స్పేస్ను వేరు చేస్తుంది మరియు సంభావ్య సంఘర్షణల గురించి హెచ్చరిస్తుంది. ఈ విధానం హార్డ్ లాక్ల (hard locks) బదులు ఒక లైట్వెయిట్ రిజిస్ట్రీని ఉపయోగిస్తుంది, ఇది పనులు ఒకదానికొకటి అడ్డుపడకముందే హెచ్చరిస్తుంది, తద్వారా ఒక సెషన్ క్రాష్ అయినా పైప్లైన్లు నిరంతరాయంగా కొనసాగుతాయి.
పారలల్ ఏజెంట్లు ఎందుకు ఇబ్బందులు కలిగిస్తాయి
ఒకే రిపోజిటరీలో ఒకటి కంటే ఎక్కువ ఆటోమేటెడ్ కోడింగ్ అసిస్టెంట్లను రన్ చేయడం వల్ల కోడ్ జనరేషన్, టెస్టింగ్ లేదా రిఫ్యాక్టరింగ్ వేగవంతం అవుతుంది. కానీ ఆచరణలో రెండు సమస్యలు వెంటనే తలెత్తుతాయి.
- స్టేట్ కరప్షన్ (State corruption) – రెండు ఏజెంట్లు ఒకే స్టేట్ ఫైల్కు డేటాను రాస్తే; తర్వాత రాసిన డేటా మునుపటి డేటాను ఓవర్రైట్ చేస్తుంది, దీనివల్ల జరిగిన పురోగతి (progress) పోతుంది.
- ఫైల్ కొలిజన్ (File collision) – ఒకరి గురించి ఒకరికి తెలియకుండా రెండు ఏజెంట్లు ఒకే సోర్స్ ఫైల్ను ఎడిట్ చేస్తాయి. ఒక డిఫ్ (diff) ద్వారా విభిన్న మార్పులు కనిపించినప్పుడు ఈ సంఘర్షణ తర్వాత బయటపడుతుంది.
ఈ రెండు సమస్యలు డెవలపర్ సమయాన్ని వృథా చేయడమే కాకుండా, కనిపెట్టడం కష్టమైన బగ్స్ను కూడా పరిచయం చేయవచ్చు.
“share nothing” నియమం
దీని ప్రధాన ఉద్దేశ్యం సరళమైనది: ప్రతి ఏజెంట్కు డిస్క్పై దాని స్వంత ప్రైవేట్ స్క్రాచ్ప్యాడ్ (scratchpad) ఉంటుంది మరియు అది కేవలం ఆ సెషన్కు చెందిన ఫైల్లకు మాత్రమే డేటాను రాస్తుంది. ప్రతి బ్రాంచ్కు కావాలని షేర్ చేయబడిన ఒకే ఒక ఫైల్కు అనుమతి ఉంటుంది, మరియు అది “last-writer-wins” నియమాన్ని అనుసరిస్తుంది—ఏ ఏజెంట్ చివరగా రాసినా, అదే తుది కంటెంట్గా నిర్ణయించబడుతుంది.
ఒక ప్రెజెన్స్ లేయర్ (presence layer) ప్రతి యాక్టివ్ సెషన్ను ట్రాక్ చేస్తుంది:
- బ్రాంచ్ పేరు
- తాకుతున్న (touch చేస్తున్న) ఫైళ్ల జాబితా
- చివరి యాక్టివిటీ యొక్క టైమ్స్టాంప్
కొత్త సెషన్ ప్రారంభమైనప్పుడు, అది రిజిస్ట్రీని సంప్రదిస్తుంది. ఒకవేళ మరొక సెషన్ ఇప్పటికే అదే ఫైళ్లను హ్యాండిల్ చేస్తూ ఉంటే, పని ప్రారంభం కావడానికి ముందే డెవలపర్కు హెచ్చరిక అందుతుంది.
అడ్వైజరీ వర్సెస్ బ్లాకింగ్ లాక్స్ (Advisory vs. blocking locks)
సాంప్రదాయ లాక్ ఫైల్స్ ఒక డెడ్-ఎండ్ రోడ్డులా పనిచేస్తాయి: ఒకసారి లాక్ తీసుకున్న తర్వాత, లాక్ విడుదల అయ్యే వరకు మరే ఇతర ప్రాసెస్ కూడా వేచి ఉండాల్సి ఉంటుంది. ఒకవేళ ఆ సెషన్ క్రాష్ అయితే, లాక్ అనంత కాలం అలాగే ఉండిపోవచ్చు, దీనివల్ల పాత లాక్ ఫైల్స్ కోసం మాన్యువల్గా వెతకాల్సి వస్తుంది.
అడ్వైజరీ మోడల్ మరింత సున్నితమైనది. ఇది సంభావ్య సంఘర్షణను గుర్తించినప్పుడు హెచ్చరికను జారీ చేస్తుంది కానీ కొత్త సెషన్ను ఆపదు. ఒకవేళ రిజిస్ట్రీ ఎంట్రీ పాతదైతే—అంటే దానిని సృష్టించిన ప్రాసెస్ ఇక లేకపోతే—సిస్టమ్ కేవలం హెచ్చరిస్తుంది మాత్రమే, తద్వారా డెవలపర్ ముందుకు వెళ్లాలా వద్దా అనేది నిర్ణయించుకోవచ్చు.
ఈ ప్యాటర్న్ను ఎలా అమలు చేయాలి
- రైటర్ ఆధారంగా స్టేట్ను విభజించండి (Partition state by writer) – ప్రతి ఏజెంట్కు తాత్కాలిక ఫైల్స్ మరియు స్టేట్ కోసం దాని స్వంత డైరెక్టరీని ఇవ్వండి. నిజంగా గ్లోబల్ డేటా కోసం మాత్రమే షేర్డ్ ఫైల్స్ను ఉంచండి మరియు అక్కడ మాత్రమే “last-writer-wins” నియమాన్ని వర్తింపజేయండి.
- లాంచ్ సమయంలో అవగాహనను పంపండి (Inject awareness at launch) – ఏజెంట్ ప్రారంభం కావడానికి ముందే, ప్రెజెన్స్ రిజిస్ట్రీని చదివి, అభ్యర్థించిన ఫైల్ జాబితాను ఇప్పటికే ఉన్న ఎంట్రీలతో పోల్చండి. ఓవర్ల్యాప్ (overlap) కనిపిస్తే ఆపండి లేదా హెచ్చరించండి.
- రీడ్ టైమ్లో లైవ్నెస్ను ధృవీకరించండి (Verify liveness at read time) – రిజిస్ట్రీ ఎంట్రీని సంప్రదించినప్పుడు, రికార్డ్ చేయబడిన ప్రాసెస్ ID ఇంకా OSలో నడుస్తుందో లేదో తనిఖీ చేయండి. డెడ్ ప్రాసెస్లకు చెందిన ఎంట్రీలను తొలగించండి.
- బ్లాకింగ్ కంటే అడ్వైజరీకి ప్రాధాన్యత ఇవ్వండి (Prefer advisory over blocking) – డెవలపర్లు నియంత్రణను కలిగి ఉండేలా చూడండి. హెచ్చరిక ద్వారా వారు పనిని కొనసాగించవచ్చు, ఆపవచ్చు లేదా రద్దు చేయవచ్చు, తద్వారా డెడ్లాక్ (deadlock) సమస్యను నివారించవచ్చు.
- వెయిటింగ్ స్టేట్స్ను ట్రాక్ చేయండి (Track waiting states) – అనేక ఏజెంట్లు యాక్టివ్గా ఉన్నప్పుడు, డెవలపర్ యొక్క శ్రద్ధే ఇక్కడ అడ్డంకిగా మారుతుంది. ఏ ఏజెంట్లు మానవ ఇన్పుట్ కోసం వేచి ఉన్నాయో ప్రదర్శించండి, తద్వారా పనులకు ప్రాధాన్యతను మళ్ళీ నిర్ణయించవచ్చు.
వీటన్నింటినీ సాధారణ JSON ఫైళ్ల డైరెక్టరీతో నిర్మించవచ్చు; దీనికి ఎటువంటి బాహ్య డేటాబేస్ లేదా మెసేజ్ బస్ అవసరం లేదు. ఈ సరళమైన స్టోరేజ్ ఫార్మాట్ వల్ల సిస్టమ్ను ఆడిట్ చేయడం సులభం మరియు వివిధ ఎన్విరాన్మెంట్లలో సులభంగా ఉపయోగించవచ్చు.
రిస్క్లు మరియు ప్రతిపాదనలు (Risks and counter-points)
హార్డ్ లాక్ భద్రతను గ్యారెంటీ ఇస్తుందని కొన్ని టీమ్లు వాదించవచ్చు: ఏ రెండు ఏజెంట్లు కూడా ఒకే ఫైల్కు డేటాను రాయలేరు. అయితే, దీని వల్ల రెసిలియెన్స్ (resilience) తగ్గుతుంది—క్రాష్ అయిన సెషన్లు వదిలివేసిన లాక్ల వల్ల మొత్తం వర్క్ఫ్లో ఆగిపోవచ్చు.
గమనించవలసినవి
మీరు ఒకటి కంటే ఎక్కువ AI-ఆధారిత కోడ్ అసిస్టెంట్లను ఉపయోగిస్తుంటే, “share nothing” అడ్వైజరీ ప్యాటర్న్ అవి ఒకదానికొకటి అడ్డుపడకుండా ఉండటానికి ఒక ఆచరణాత్మక మార్గాన్ని అందిస్తుంది. స్టేట్ను వేరు చేయడం, ఉద్దేశాన్ని ముందే తెలియజేయడం మరియు ఎప్పుడు ముందుకు వెళ్లాలో మనుషులకే వదిలేయడం ద్వారా, ఈ పద్ధతి భద్రతను మరియు ఆధునిక డెవలప్మెంట్ పైప్లైన్లకు అవసరమైన ఫ్లెక్సిబిలిటీని సమతుల్యం చేస్తుంది.