റഫറൻസ് കൗണ്ടിംഗ് അൽഗോരിതങ്ങൾ: സൈക്ലിക് ഗാർബേജ് ശേഖരണം നടപ്പിലാക്കുന്നു

മെമ്മറിയിലെ ഓരോ ഒബ്ജക്റ്റും അതിലേക്ക് പോയിൻ്റ് ചെയ്യുന്ന റഫറൻസുകളുടെ എണ്ണം നിലനിർത്തുന്ന ഒരു മെമ്മറി മാനേജ്മെൻ്റ് ടെക്നിക്കാണ് റഫറൻസ് കൗണ്ടിംഗ്. ഒരു ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം പൂജ്യമായി കുറയുമ്പോൾ, മറ്റ് ഒബ്ജക്റ്റുകളൊന്നും അതിനെ റഫർ ചെയ്യുന്നില്ലെന്നും ഒബ്ജക്റ്റ് സുരക്ഷിതമായി ഡീഅലോക്കേറ്റ് ചെയ്യാമെന്നും ഇത് അർത്ഥമാക്കുന്നു. ഈ സമീപനം നിരവധി നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു, എന്നാൽ സൈക്ലിക് ഡാറ്റാ ഘടനകളുമായി ബന്ധപ്പെട്ട് ഇത് വെല്ലുവിളികളും നേരിടുന്നു. റഫറൻസ് കൗണ്ടിംഗിൻ്റെ സമഗ്രമായ വിവരണം, അതിൻ്റെ നേട്ടങ്ങൾ, പരിമിതികൾ, സൈക്ലിക് ഗാർബേജ് ശേഖരണം നടപ്പിലാക്കുന്നതിനുള്ള തന്ത്രങ്ങൾ എന്നിവ ഈ ലേഖനത്തിൽ നൽകുന്നു.

എന്താണ് റഫറൻസ് കൗണ്ടിംഗ്?

ഓട്ടോമാറ്റിക് മെമ്മറി മാനേജ്മെൻ്റിൻ്റെ ഒരു രൂപമാണ് റഫറൻസ് കൗണ്ടിംഗ്. ഉപയോഗിക്കാത്ത ഒബ്ജക്റ്റുകൾക്കായി മെമ്മറി ആനുകാലികമായി സ്കാൻ ചെയ്യാൻ ഒരു ഗാർബേജ് കളക്ടറെ ആശ്രയിക്കുന്നതിനുപകരം, റഫറൻസ് കൗണ്ടിംഗ്, റീച്ച് ചെയ്യാൻ കഴിയാത്തപ്പോൾ തന്നെ മെമ്മറി വീണ്ടെടുക്കാൻ ലക്ഷ്യമിടുന്നു. മെമ്മറിയിലെ ഓരോ ഒബ്ജക്റ്റിനും അതിനോടനുബന്ധിച്ചുള്ള ഒരു റഫറൻസ് എണ്ണം ഉണ്ട്, ഇത് ആ ഒബ്ജക്റ്റിലേക്കുള്ള റഫറൻസുകളുടെ (പോയിൻ്ററുകൾ, ലിങ്കുകൾ, മുതലായവ) എണ്ണം പ്രതിനിധീകരിക്കുന്നു. അടിസ്ഥാന പ്രവർത്തനങ്ങൾ ഇവയാണ്:

• റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കുന്നു: ഒരു ഒബ്ജക്റ്റിലേക്ക് ഒരു പുതിയ റഫറൻസ് സൃഷ്ടിക്കുമ്പോൾ, ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കും.
• റഫറൻസ് എണ്ണം കുറയ്ക്കുന്നു: ഒരു ഒബ്ജക്റ്റിലേക്കുള്ള റഫറൻസ് നീക്കം ചെയ്യുമ്പോഴോ അല്ലെങ്കിൽ പരിധിക്ക് പുറത്തുപോകുമ്പോഴോ, ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം കുറയും.
• ഡീഅലോക്കേഷൻ: ഒരു ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം പൂജ്യത്തിലെത്തിയാൽ, പ്രോഗ്രാമിൻ്റെ മറ്റേതെങ്കിലും ഭാഗം ഇനി ഒബ്ജക്റ്റിനെ റഫർ ചെയ്യുന്നില്ല എന്നാണ് ഇതിനർത്ഥം. ഈ ഘട്ടത്തിൽ, ഒബ്ജക്റ്റ് ഡീഅലോക്കേറ്റ് ചെയ്യാവുന്നതാണ്, കൂടാതെ അതിൻ്റെ മെമ്മറി വീണ്ടെടുക്കാനും കഴിയും.

ഉദാഹരണം: പൈത്തണിലെ ലളിതമായ ഒരു സാഹചര്യം പരിഗണിക്കുക (പ്രധാനമായും ഒരു ട്രേസിംഗ് ഗാർബേജ് കളക്ടർ ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും, തൽക്ഷണ ശുചീകരണത്തിനായി ഇത് റഫറൻസ് കൗണ്ടിംഗും ഉപയോഗിക്കുന്നു):

obj1 = MyObject()
obj2 = obj1  # Increment reference count of obj1
del obj1  # Decrement reference count of MyObject; object is still accessible through obj2
del obj2  # Decrement reference count of MyObject; if this was the last reference, the object is deallocated

റഫറൻസ് കൗണ്ടിംഗിൻ്റെ നേട്ടങ്ങൾ

ട്രേസിംഗ് ഗാർബേജ് ശേഖരണം പോലുള്ള മറ്റ് മെമ്മറി മാനേജ്മെൻ്റ് ടെക്നിക്കുകളെക്കാൾ റഫറൻസ് കൗണ്ടിംഗ് നിരവധി ആകർഷകമായ നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു:

• തൽക്ഷണ വീണ്ടെടുക്കൽ: ഒരു ഒബ്ജക്റ്റ് റീച്ച് ചെയ്യാത്ത ഉടൻ തന്നെ മെമ്മറി വീണ്ടെടുക്കുന്നു, ഇത് മെമ്മറി ഫുട്പ്രിൻ്റ് കുറയ്ക്കുകയും പരമ്പരാഗത ഗാർബേജ് കളക്ടറുകളുമായി ബന്ധപ്പെട്ട ദീർഘനേരമുള്ള ഇടവേളകൾ ഒഴിവാക്കുകയും ചെയ്യുന്നു. ഈ നിർണ്ണായക സ്വഭാവം തത്സമയ സംവിധാനങ്ങൾക്കോ ​​അല്ലെങ്കിൽ കർശനമായ പ്രകടനാവശ്യകതകളുള്ള ആപ്ലിക്കേഷനുകൾക്കോ ​​പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.
• ലളിതത്വം: അടിസ്ഥാന റഫറൻസ് കൗണ്ടിംഗ് അൽഗോരിതം നടപ്പിലാക്കാൻ താരതമ്യേന ലളിതമാണ്, ഇത് എംബഡഡ് സിസ്റ്റങ്ങൾക്കോ ​​പരിമിതമായ വിഭവങ്ങളുള്ള പരിതസ്ഥിതികൾക്കോ ​​അനുയോജ്യമാക്കുന്നു.
• റഫറൻസിൻ്റെ ലൊക്കാലിറ്റി: ഒരു ഒബ്ജക്റ്റ് ഡീഅലോക്കേറ്റ് ചെയ്യുന്നത്, അത് റഫർ ചെയ്യുന്ന മറ്റ് ഒബ്ജക്റ്റുകളുടെ ഡീഅലോക്കേഷനിലേക്ക് പലപ്പോഴും നയിക്കുന്നു, ഇത് കാഷെ പ്രകടനം മെച്ചപ്പെടുത്തുകയും മെമ്മറി വിഭജനം കുറയ്ക്കുകയും ചെയ്യുന്നു.

റഫറൻസ് കൗണ്ടിംഗിൻ്റെ പരിമിതികൾ

അതിൻ്റെ നേട്ടങ്ങൾ ഉണ്ടായിരുന്നിട്ടും, റഫറൻസ് കൗണ്ടിംഗ് ചില സാഹചര്യങ്ങളിൽ അതിൻ്റെ പ്രായോഗികതയെ ബാധിക്കുന്ന നിരവധി പരിമിതികൾ നേരിടുന്നു:

• ഓവർഹെഡ്: റഫറൻസ് എണ്ണങ്ങൾ വർദ്ധിപ്പിക്കുന്നതും കുറയ്ക്കുന്നതും കാര്യമായ ഓവർഹെഡ് ഉണ്ടാക്കും, പ്രത്യേകിച്ചും ഒബ്ജക്റ്റ് സൃഷ്ടിയും ഇല്ലാതാക്കലും പതിവായി നടക്കുന്ന സിസ്റ്റങ്ങളിൽ. ഈ ഓവർഹെഡ് ആപ്ലിക്കേഷൻ പ്രകടനത്തെ ബാധിക്കും.
• സർക്കുലർ റഫറൻസുകൾ: അടിസ്ഥാന റഫറൻസ് കൗണ്ടിംഗിൻ്റെ ഏറ്റവും പ്രധാനപ്പെട്ട പരിമിതി, സർക്കുലർ റഫറൻസുകൾ കൈകാര്യം ചെയ്യാനുള്ള കഴിവില്ലായിമയാണ്. രണ്ടോ അതിലധികമോ ഒബ്ജക്റ്റുകൾ പരസ്പരം റഫർ ചെയ്യുകയാണെങ്കിൽ, അവയുടെ റഫറൻസ് എണ്ണം പൂജ്യത്തിലെത്തില്ല, അവ പ്രോഗ്രാമിൻ്റെ ബാക്കി ഭാഗങ്ങളിൽ നിന്ന് ആക്സസ് ചെയ്യാൻ കഴിയാതെ വന്നാലും, ഇത് മെമ്മറി ലീക്കിലേക്ക് നയിക്കുന്നു.
• സങ്കീർണ്ണത: റഫറൻസ് കൗണ്ടിംഗ് ശരിയായി നടപ്പിലാക്കുന്നത്, പ്രത്യേകിച്ചും മൾട്ടിത്രെഡ് എൻവയോൺമെൻ്റുകളിൽ, റേസ് അവസ്ഥകൾ ഒഴിവാക്കാനും കൃത്യമായ റഫറൻസ് എണ്ണങ്ങൾ ഉറപ്പാക്കാനും സൂക്ഷ്മമായ സമന്വയം ആവശ്യമാണ്. ഇത് നടപ്പിലാക്കുന്നതിന് സങ്കീർണ്ണത ചേർക്കാൻ കഴിയും.

സർക്കുലർ റഫറൻസ് പ്രശ്നം

അജ്ഞാതമായ റഫറൻസ് കൗണ്ടിംഗിൻ്റെ ബലഹീനതയാണ് സർക്കുലർ റഫറൻസ് പ്രശ്നം. A, B എന്നീ രണ്ട് ഒബ്ജക്റ്റുകൾ പരിഗണിക്കുക, A, B-യെയും B, A-യെയും റഫർ ചെയ്യുന്നു. മറ്റ് ഒബ്ജക്റ്റുകളൊന്നും A അല്ലെങ്കിൽ B-യെ റഫർ ചെയ്യുന്നില്ലെങ്കിൽ പോലും, അവയുടെ റഫറൻസ് എണ്ണം കുറഞ്ഞത് ഒന്നായിരിക്കും, ഇത് അവയെ ഡീഅലോക്കേറ്റ് ചെയ്യുന്നതിൽ നിന്ന് തടയുന്നു. ഇത് ഒരു മെമ്മറി ലീക്ക് ഉണ്ടാക്കുന്നു, കാരണം A, B എന്നിവയുടെ മെമ്മറി അനുവദിച്ചിട്ടുണ്ട്, പക്ഷേ എത്തിച്ചേരാനാകില്ല.

ഉദാഹരണം: പൈത്തണിൽ:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Circular reference created

del node1
del node2  # Memory leak: the nodes are no longer accessible, but their reference counts are still 1

സ്മാർട്ട് പോയിൻ്റുകൾ (ഉദാഹരണത്തിന്, `std::shared_ptr`) ഉപയോഗിക്കുന്ന C++ പോലുള്ള ഭാഷകളും ഇത് ശ്രദ്ധയോടെ കൈകാര്യം ചെയ്തില്ലെങ്കിൽ ഈ സ്വഭാവം കാണിക്കും. `shared_ptr`കളുടെ സൈക്കിളുകൾ ഡീഅലോക്കേഷനെ തടയും.

സൈക്ലിക് ഗാർബേജ് ശേഖരണ തന്ത്രങ്ങൾ

സർക്കുലർ റഫറൻസ് പ്രശ്നം പരിഹരിക്കുന്നതിന്, റഫറൻസ് കൗണ്ടിംഗുമായി സംയോജിപ്പിച്ച് നിരവധി സൈക്ലിക് ഗാർബേജ് ശേഖരണ സാങ്കേതിക വിദ്യകൾ ഉപയോഗിക്കാൻ കഴിയും. ഈ സാങ്കേതിക വിദ്യകൾ, റീച്ച് ചെയ്യാൻ കഴിയാത്ത ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ തിരിച്ചറിയാനും തകർക്കാനും ലക്ഷ്യമിടുന്നു, ഇത് അവയെ ഡീഅലോക്കേറ്റ് ചെയ്യാൻ അനുവദിക്കുന്നു.

1. മാർക്ക് ആൻഡ് സ്വീപ് അൽഗോരിതം

റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റങ്ങളിൽ സൈക്ലിക് റഫറൻസുകൾ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഒരു ഗാർബേജ് ശേഖരണ സാങ്കേതികവിദ്യയാണ് മാർക്ക് ആൻഡ് സ്വീപ് അൽഗോരിതം. ഇത് രണ്ട് ഘട്ടങ്ങൾ ഉൾക്കൊള്ളുന്നു:

• മാർക്ക് ഘട്ടം: റൂട്ട് ഒബ്ജക്റ്റുകളുടെ ഒരു കൂട്ടത്തിൽ നിന്ന് (പ്രോഗ്രാമിൽ നിന്ന് നേരിട്ട് ആക്സസ് ചെയ്യാവുന്ന ഒബ്ജക്റ്റുകൾ) ആരംഭിച്ച്, അൽഗോരിതം ഒബ്ജക്റ്റ് ഗ്രാഫ് ട്രാവേഴ്സ് ചെയ്യുന്നു, എല്ലാ റീച്ച് ചെയ്യാവുന്ന ഒബ്ജക്റ്റുകളും അടയാളപ്പെടുത്തുന്നു.
• സ്വീപ് ഘട്ടം: അടയാളപ്പെടുത്തൽ ഘട്ടത്തിനുശേഷം, അൽഗോരിതം മെമ്മറി സ്പേസ് സ്കാൻ ചെയ്യുന്നു, അടയാളപ്പെടുത്തിയിട്ടില്ലാത്ത ഒബ്ജക്റ്റുകൾ തിരിച്ചറിയുന്നു. ഈ അടയാളപ്പെടുത്താത്ത ഒബ്ജക്റ്റുകൾ റീച്ച് ചെയ്യാനാവാത്തതായി കണക്കാക്കുകയും ഡീഅലോക്കേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.

റഫറൻസ് കൗണ്ടിംഗിൻ്റെ പശ്ചാത്തലത്തിൽ, റീച്ച് ചെയ്യാനാവാത്ത ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ തിരിച്ചറിയാൻ മാർക്ക് ആൻഡ് സ്വീപ് അൽഗോരിതം ഉപയോഗിക്കാം. അൽഗോരിതം താൽക്കാലികമായി എല്ലാ ഒബ്ജക്റ്റുകളുടെയും റഫറൻസ് എണ്ണം പൂജ്യമായി സജ്ജമാക്കുകയും തുടർന്ന് അടയാളപ്പെടുത്തൽ ഘട്ടം നടത്തുകയും ചെയ്യുന്നു. അടയാളപ്പെടുത്തൽ ഘട്ടത്തിന് ശേഷം ഒരു ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം പൂജ്യമായി തുടരുകയാണെങ്കിൽ, അതിനർത്ഥം ഒബ്ജക്റ്റ് ഏതെങ്കിലും റൂട്ട് ഒബ്ജക്റ്റിൽ നിന്ന് എത്തിച്ചേരാനാവുന്നതല്ല, കൂടാതെ റീച്ച് ചെയ്യാനാവാത്ത ഒരു സൈക്കിളിൻ്റെ ഭാഗവുമാണ് എന്നാണ്.

നടപ്പാക്കുന്നതിനുള്ള പരിഗണനകൾ:

• മാർക്ക് ആൻഡ് സ്വീപ് അൽഗോരിതം ആനുകാലികമായി അല്ലെങ്കിൽ മെമ്മറി ഉപയോഗം ഒരു നിശ്ചിത പരിധിയിലെത്തുമ്പോൾ ട്രിഗർ ചെയ്യാവുന്നതാണ്.
• അനന്തമായ ലൂപ്പുകൾ ഒഴിവാക്കാൻ, അടയാളപ്പെടുത്തൽ ഘട്ടത്തിൽ സർക്കുലർ റഫറൻസുകൾ ശ്രദ്ധാപൂർവ്വം കൈകാര്യം ചെയ്യേണ്ടത് പ്രധാനമാണ്.
• അൽഗോരിതം, പ്രത്യേകിച്ച് സ്വീപ് ഘട്ടത്തിൽ, ആപ്ലിക്കേഷൻ എക്സിക്യൂഷനിൽ ഇടവേളകൾ വരുത്താൻ സാധ്യതയുണ്ട്.

2. സൈക്കിൾ കണ്ടെത്തൽ അൽഗോരിതങ്ങൾ

ഒബ്ജക്റ്റ് ഗ്രാഫുകളിൽ സൈക്കിളുകൾ കണ്ടെത്തുന്നതിനായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്ത നിരവധി അൽഗോരിതങ്ങൾ ഉണ്ട്. റഫറൻസ് കൗണ്ടിംഗ് സിസ്റ്റങ്ങളിൽ റീച്ച് ചെയ്യാനാവാത്ത ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ തിരിച്ചറിയാൻ ഈ അൽഗോരിതങ്ങൾ ഉപയോഗിക്കാം.

a) ടാർജൻ്റെ ശക്തമായി ബന്ധിപ്പിച്ച ഘടക അൽഗോരിതം

ഒരു ഡയറക്ടഡ് ഗ്രാഫിലെ ശക്തമായി ബന്ധിപ്പിച്ച ഘടകങ്ങളെ (SCCs) തിരിച്ചറിയുന്ന ഒരു ഗ്രാഫ് ട്രാവേഴ്സൽ അൽഗോരിതമാണ് ടാർജൻ്റെ അൽഗോരിതം. എല്ലാ ശീർഷകവും മറ്റ് ഓരോ ശീർഷകത്തിൽ നിന്നും എത്തിച്ചേരാവുന്ന ഒരു ഉപഗ്രാഫാണ് SCC. ഗാർബേജ് ശേഖരണത്തിൻ്റെ പശ്ചാത്തലത്തിൽ, SCC-കൾക്ക് ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകളെ പ്രതിനിധീകരിക്കാൻ കഴിയും.

ഇത എങ്ങനെ പ്രവർത്തിക്കുന്നു:

• അൽഗോരിതം ഒബ്ജക്റ്റ് ഗ്രാഫിൻ്റെ ഡെപ്ത്- first search (DFS) നടത്തുന്നു.
• DFS- സമയത്ത്, ഓരോ ഒബ്ജക്റ്റിനും ഒരു അദ്വിതീയ സൂചികയും ലോലിങ്ക് മൂല്യവും നൽകുന്നു.
• ലോലിങ്ക് മൂല്യം നിലവിലെ ഒബ്ജക്റ്റിൽ നിന്ന് എത്തിച്ചേരാവുന്ന ഏതെങ്കിലും ഒബ്ജക്റ്റിൻ്റെ ഏറ്റവും ചെറിയ സൂചികയെ പ്രതിനിധീകരിക്കുന്നു.
• DFS ഇതിനകം തന്നെ സ്റ്റാക്കിലുള്ള ഒരു ഒബ്ജക്റ്റിനെ കണ്ടെത്തുമ്പോൾ, നിലവിലെ ഒബ്ജക്റ്റിൻ്റെ ലോലിങ്ക് മൂല്യം അപ്‌ഡേറ്റ് ചെയ്യുന്നു.
• DFS ഒരു SCC പ്രോസസ്സ് ചെയ്യുന്നത് പൂർത്തിയാക്കുമ്പോൾ, SCC-യിലെ എല്ലാ ഒബ്ജക്റ്റുകളും സ്റ്റാക്കിൽ നിന്ന് പോപ്പ് ചെയ്യുകയും അവയെ ഒരു സൈക്കിളിൻ്റെ ഭാഗമായി തിരിച്ചറിയുകയും ചെയ്യുന്നു.

b) പാത്ത്-ബേസ്ഡ് സ്ട്രോംഗ് ഘടക അൽഗോരിതം

ഡയറക്‌ടഡ് ഗ്രാഫിൽ SCC-കളെ തിരിച്ചറിയാനുള്ള മറ്റൊരു അൽഗോരിതമാണ് പാത്ത്-ബേസ്ഡ് സ്ട്രോംഗ് ഘടക അൽഗോരിതം (PBSCA). നേരിയ ഗ്രാഫുകൾക്ക് ഇത് ടാർജൻ്റെ അൽഗോരിതത്തേക്കാൾ കൂടുതൽ കാര്യക്ഷമമാണ്.

ഇത എങ്ങനെ പ്രവർത്തിക്കുന്നു:

• അൽഗോരിതം DFS- സമയത്ത് സന്ദർശിച്ച ഒബ്ജക്റ്റുകളുടെ ഒരു സ്റ്റാക്ക് നിലനിർത്തുന്നു.
• ഓരോ ഒബ്ജക്റ്റിനും, റൂട്ട് ഒബ്ജക്റ്റിൽ നിന്ന് നിലവിലെ ഒബ്ജക്റ്റിലേക്കുള്ള ഒരു പാത്ത് ഇത് സംഭരിക്കുന്നു.
• അൽഗോരിതം ഇതിനകം സ്റ്റാക്കിലുള്ള ഒരു ഒബ്ജക്റ്റിനെ കണ്ടെത്തുമ്പോൾ, നിലവിലെ ഒബ്ജക്റ്റിലേക്കുള്ള പാത സ്റ്റാക്കിലെ ഒബ്ജക്റ്റിലേക്കുള്ള പാതയുമായി താരതമ്യം ചെയ്യുന്നു.
• നിലവിലെ ഒബ്ജക്റ്റിലേക്കുള്ള പാത സ്റ്റാക്കിലെ ഒബ്ജക്റ്റിലേക്കുള്ള പാതയുടെ ഒരു പ്രിഫിക്സ് ആണെങ്കിൽ, നിലവിലെ ഒബ്ജക്റ്റ് ഒരു സൈക്കിളിൻ്റെ ഭാഗമാണെന്ന് ഇതിനർത്ഥം.

3. മാറ്റിവെച്ച റഫറൻസ് കൗണ്ടിംഗ്

ഈ പ്രവർത്തനങ്ങൾ പിന്നീട് നടപ്പിലാക്കുന്നതുവരെ മാറ്റിവയ്ക്കുന്നതിലൂടെ റഫറൻസ് എണ്ണങ്ങൾ വർദ്ധിപ്പിക്കുന്നതിൻ്റെയും കുറയ്ക്കുന്നതിൻ്റെയും ഓവർഹെഡ് കുറയ്ക്കാൻ മാറ്റിവെച്ച റഫറൻസ് കൗണ്ടിംഗ് ലക്ഷ്യമിടുന്നു. റഫറൻസ് എണ്ണം മാറ്റങ്ങൾ ബഫർ ചെയ്ത് ബാച്ചുകളായി പ്രയോഗിക്കുന്നതിലൂടെ ഇത് നേടാനാകും.

സാങ്കേതിക വിദ്യകൾ:

• ത്രെഡ്-ലോക്കൽ ബഫറുകൾ: ഓരോ ത്രെഡും റഫറൻസ് എണ്ണം മാറ്റങ്ങൾ സംഭരിക്കുന്നതിന് ഒരു പ്രാദേശിക ബഫർ നിലനിർത്തുന്നു. ഈ മാറ്റങ്ങൾ ആനുകാലികമായി അല്ലെങ്കിൽ ബഫർ നിറയുമ്പോൾ ആഗോള റഫറൻസ് എണ്ണങ്ങളിൽ പ്രയോഗിക്കുന്നു.
• റൈറ്റ് ബാരിയറുകൾ: ഒബ്ജക്റ്റ് ഫീൽഡുകളിലേക്ക് എഴുതുന്നത് തടയാൻ റൈറ്റ് ബാരിയറുകൾ ഉപയോഗിക്കുന്നു. ഒരു റൈറ്റ് ഓപ്പറേഷൻ ഒരു പുതിയ റഫറൻസ് ഉണ്ടാക്കുമ്പോൾ, റൈറ്റ് ബാരിയർ റൈറ്റിനെ തടയുകയും റഫറൻസ് എണ്ണം വർദ്ധനവ് മാറ്റിവയ്ക്കുകയും ചെയ്യുന്നു.

മാറ്റിവെച്ച റഫറൻസ് കൗണ്ടിംഗ് ഓവർഹെഡ് കുറയ്ക്കുമ്പോൾ തന്നെ, മെമ്മറി വീണ്ടെടുക്കുന്നത് വൈകിക്കുകയും അതുവഴി മെമ്മറി ഉപയോഗം വർദ്ധിപ്പിക്കുകയും ചെയ്യും.

4. ഭാഗിക മാർക്ക് ആൻഡ് സ്വീപ്

മുഴുവൻ മെമ്മറി സ്പേസിലും ഒരു പൂർണ്ണമായ മാർക്ക് ആൻഡ് സ്വീപ് നടത്തുന്നതിനുപകരം, ഒരു പ്രത്യേക ഒബ്ജക്റ്റിൽ നിന്നോ അല്ലെങ്കിൽ ഒബ്ജക്റ്റുകളുടെ ഒരു ഗ്രൂപ്പിൽ നിന്നോ എത്തിച്ചേരാവുന്ന മെമ്മറിയുടെ ഒരു ചെറിയ ഭാഗത്ത് ഭാഗികമായ മാർക്ക് ആൻഡ് സ്വീപ് നടത്താൻ കഴിയും. ഇത് ഗാർബേജ് ശേഖരണവുമായി ബന്ധപ്പെട്ട ഇടവേളകൾ കുറയ്ക്കാൻ സഹായിക്കും.

നടപ്പിലാക്കൽ:

• അൽഗോരിതം ഒരു കൂട്ടം സംശയാസ്പദമായ ഒബ്ജക്റ്റുകളിൽ നിന്ന് ആരംഭിക്കുന്നു (ഒരു സൈക്കിളിൻ്റെ ഭാഗമാകാൻ സാധ്യതയുള്ള ഒബ്ജക്റ്റുകൾ).
• ഈ ഒബ്ജക്റ്റുകളിൽ നിന്ന് എത്തിച്ചേരാവുന്ന ഒബ്ജക്റ്റ് ഗ്രാഫ് ട്രാവേഴ്സ് ചെയ്യുന്നു, എല്ലാ റീച്ച് ചെയ്യാവുന്ന ഒബ്ജക്റ്റുകളും അടയാളപ്പെടുത്തുന്നു.
• തുടർന്ന് അടയാളപ്പെടുത്തിയ ഭാഗം സ്വീപ് ചെയ്യുന്നു, അടയാളപ്പെടുത്താത്ത ഏതെങ്കിലും ഒബ്ജക്റ്റുകൾ ഡീഅലോക്കേറ്റ് ചെയ്യുന്നു.

വിവിധ ഭാഷകളിൽ സൈക്ലിക് ഗാർബേജ് ശേഖരണം നടപ്പിലാക്കുന്നു

സൈക്ലിക് ഗാർബേജ് ശേഖരണം നടപ്പിലാക്കുന്നത് പ്രോഗ്രാമിംഗ് ഭാഷയെയും അടിസ്ഥാന മെമ്മറി മാനേജ്മെൻ്റ് സിസ്റ്റത്തെയും ആശ്രയിച്ച് വ്യത്യാസപ്പെടാം. ചില ഉദാഹരണങ്ങൾ താഴെക്കൊടുക്കുന്നു:

പൈത്തൺ

മെമ്മറി കൈകാര്യം ചെയ്യുന്നതിന് പൈത്തൺ റഫറൻസ് കൗണ്ടിംഗും ട്രേസിംഗ് ഗാർബേജ് കളക്ടറും സംയോജിപ്പിച്ച് ഉപയോഗിക്കുന്നു. തൽക്ഷണ ഒബ്ജക്റ്റ് ഡീഅലോക്കേഷൻ റഫറൻസ് കൗണ്ടിംഗ് ഘടകം കൈകാര്യം ചെയ്യുമ്പോൾ, റീച്ച് ചെയ്യാനാവാത്ത ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ കണ്ടെത്തുകയും തകർക്കുകയും ചെയ്യുന്നത് ട്രേസിംഗ് ഗാർബേജ് കളക്ടറാണ്.

പൈത്തണിലെ ഗാർബേജ് കളക്ടർ `gc` മൊഡ്യൂളിൽ നടപ്പിലാക്കുന്നു. ഗാർബേജ് ശേഖരണം സ്വമേധയാ ട്രിഗർ ചെയ്യാൻ നിങ്ങൾക്ക് `gc.collect()` ഫംഗ്ഷൻ ഉപയോഗിക്കാം. ഗാർബേജ് കളക്ടർ പതിവായി പ്രവർത്തിക്കുകയും ചെയ്യും.

ഉദാഹരണം:

import gc

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Circular reference created

del node1
del node2

gc.collect()  # Force garbage collection to break the cycle

C++

C++-ൽ അന്തർനിർമ്മിത ഗാർബേജ് ശേഖരണം ലഭ്യമല്ല. മെമ്മറി മാനേജ്മെൻ്റ് സാധാരണയായി `new`, `delete` എന്നിവ ഉപയോഗിച്ചോ അല്ലെങ്കിൽ സ്മാർട്ട് പോയിൻ്റുകൾ ഉപയോഗിച്ചോ സ്വമേധയാ കൈകാര്യം ചെയ്യപ്പെടുന്നു.

C++-ൽ സൈക്ലിക് ഗാർബേജ് ശേഖരണം നടപ്പിലാക്കാൻ, സൈക്കിൾ കണ്ടെത്തലിനൊപ്പം സ്മാർട്ട് പോയിൻ്റുകൾ ഉപയോഗിക്കാം. സൈക്കിളുകൾ തകർക്കാൻ ഒരു സമീപനം `std::weak_ptr` ഉപയോഗിക്കുക എന്നതാണ്. ഒരു `weak_ptr` എന്നത് ഒരു സ്മാർട്ട് പോയിൻ്റാണ്, ഇത് പോയിൻ്റ് ചെയ്യുന്ന ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കില്ല. ഇത് ഡീഅലോക്കേറ്റ് ചെയ്യുന്നതിൽ നിന്ന് തടയാതെ തന്നെ ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം:

#include <iostream>
#include <memory>

class Node {
public:
    int data;
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;  // Use weak_ptr to break cycles

    Node(int data) : data(data) {}
    ~Node() { std::cout << "Node destroyed with data: " << data << std::endl; }
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>(1);
    std::shared_ptr<Node> node2 = std::make_shared<Node>(2);

    node1->next = node2;
    node2->prev = node1; // Cycle created, but prev is weak_ptr

    node2.reset();
    node1.reset(); // Nodes will now be destroyed

    return 0;
}

ഈ ഉദാഹരണത്തിൽ, `node2`-ന് `node1`-ലേക്ക് ഒരു `weak_ptr` ഉണ്ട്. `node1`, `node2` എന്നിവ രണ്ടും പരിധിക്ക് പുറത്തുപോകുമ്പോൾ, അവയുടെ പങ്കിട്ട പോയിൻ്ററുകൾ നശിപ്പിക്കപ്പെടും, ദുർബലമായ പോയിൻ്റർ റഫറൻസ് എണ്ണത്തിലേക്ക് സംഭാവന നൽകാത്തതിനാൽ ഒബ്ജക്റ്റുകൾ ഡീഅലോക്കേറ്റ് ചെയ്യപ്പെടും.

Java

ജാവ ഒരു ഓട്ടോമാറ്റിക് ഗാർബേജ് കളക്ടർ ഉപയോഗിക്കുന്നു, അത് ട്രേസിംഗും ചിലതരം റഫറൻസ് കൗണ്ടിംഗും ആന്തരികമായി കൈകാര്യം ചെയ്യുന്നു. സർക്കുലർ റഫറൻസുകളിൽ ഉൾപ്പെട്ടിട്ടുള്ളവ ഉൾപ്പെടെ, റീച്ച് ചെയ്യാനാവാത്ത ഒബ്ജക്റ്റുകൾ കണ്ടെത്തുന്നതിനും വീണ്ടെടുക്കുന്നതിനും ഗാർബേജ് കളക്ടർ ഉത്തരവാദിയാണ്. ജാവയിൽ നിങ്ങൾ സാധാരണയായി സൈക്ലിക് ഗാർബേജ് ശേഖരണം വ്യക്തമായി നടപ്പിലാക്കേണ്ടതില്ല.

എങ്കിലും, ഗാർബേജ് കളക്ടർ എങ്ങനെ പ്രവർത്തിക്കുമെന്നത് മനസ്സിലാക്കുന്നത് കൂടുതൽ കാര്യക്ഷമമായ കോഡ് എഴുതാൻ നിങ്ങളെ സഹായിക്കും. ഗാർബേജ് ശേഖരണത്തിൻ്റെ പ്രവർത്തനം നിരീക്ഷിക്കാനും മെമ്മറി ലീക്കുകൾ തിരിച്ചറിയാനും നിങ്ങൾക്ക് പ്രൊഫൈലറുകൾ പോലുള്ള ടൂളുകൾ ഉപയോഗിക്കാം.

JavaScript

മെമ്മറി കൈകാര്യം ചെയ്യാൻ ജാവാസ്ക്രിപ്റ്റ് ഗാർബേജ് ശേഖരണത്തെ (പലപ്പോഴും ഒരു മാർക്ക്-ആൻഡ്-സ്വീപ് അൽഗോരിതം) ആശ്രയിക്കുന്നു. റഫറൻസ് കൗണ്ടിംഗ്, എഞ്ചിൻ ഒബ്ജക്റ്റുകൾ ട്രാക്ക് ചെയ്യുന്നതിൻ്റെ ഭാഗമാണെങ്കിലും, ഡെവലപ്പർമാർ ഗാർബേജ് ശേഖരണം നേരിട്ട് നിയന്ത്രിക്കുന്നില്ല. സൈക്കിളുകൾ കണ്ടെത്താൻ എഞ്ചിൻ ഉത്തരവാദിയാണ്.

എങ്കിലും, അനാവശ്യമായ വലിയ ഒബ്ജക്റ്റ് ഗ്രാഫുകൾ ഉണ്ടാക്കുന്നതിനെക്കുറിച്ച് ശ്രദ്ധിക്കുക, ഇത് ഗാർബേജ് ശേഖരണ സൈക്കിളുകളെ മന്ദഗതിയിലാക്കിയേക്കാം. ആവശ്യമില്ലാത്തപ്പോൾ ഒബ്ജക്റ്റുകളിലേക്കുള്ള റഫറൻസുകൾ തകർക്കുന്നത് എഞ്ചിനെ മെമ്മറി കൂടുതൽ കാര്യക്ഷമമായി വീണ്ടെടുക്കാൻ സഹായിക്കുന്നു.

റഫറൻസ് കൗണ്ടിംഗിനും സൈക്ലിക് ഗാർബേജ് ശേഖരണത്തിനുമുള്ള മികച്ച രീതികൾ

• സർക്കുലർ റഫറൻസുകൾ കുറയ്ക്കുക: സർക്കുലർ റഫറൻസുകളുടെ സൃഷ്ടി കുറയ്ക്കുന്നതിന് നിങ്ങളുടെ ഡാറ്റാ ഘടനകൾ രൂപകൽപ്പന ചെയ്യുക. സൈക്കിളുകൾ പൂർണ്ണമായും ഒഴിവാക്കാൻ ഇതര ഡാറ്റാ ഘടനകളോ സാങ്കേതിക വിദ്യകളോ പരിഗണിക്കുക.
• ദുർബലമായ റഫറൻസുകൾ ഉപയോഗിക്കുക: ദുർബലമായ റഫറൻസുകൾ പിന്തുണയ്ക്കുന്ന ഭാഷകളിൽ, സൈക്കിളുകൾ തകർക്കാൻ അവ ഉപയോഗിക്കുക. ദുർബലമായ റഫറൻസുകൾ അവ പോയിൻ്റ് ചെയ്യുന്ന ഒബ്ജക്റ്റിൻ്റെ റഫറൻസ് എണ്ണം വർദ്ധിപ്പിക്കില്ല, ഇത് സൈക്കിളിൻ്റെ ഭാഗമാണെങ്കിൽ പോലും ഒബ്ജക്റ്റ് ഡീഅലോക്കേറ്റ് ചെയ്യാൻ അനുവദിക്കുന്നു.
• സൈക്കിൾ കണ്ടെത്തൽ നടപ്പിലാക്കുക: അന്തർനിർമ്മിത സൈക്കിൾ കണ്ടെത്തൽ ഇല്ലാത്ത ഒരു ഭാഷയിൽ നിങ്ങൾ റഫറൻസ് കൗണ്ടിംഗ് ഉപയോഗിക്കുകയാണെങ്കിൽ, റീച്ച് ചെയ്യാനാവാത്ത ഒബ്ജക്റ്റുകളുടെ സൈക്കിളുകൾ തിരിച്ചറിയാനും തകർക്കാനും ഒരു സൈക്കിൾ കണ്ടെത്തൽ അൽഗോരിതം നടപ്പിലാക്കുക.
• മെമ്മറി ഉപയോഗം നിരീക്ഷിക്കുക: മെമ്മറി ചോർച്ചകൾ കണ്ടെത്താൻ മെമ്മറി ഉപയോഗം നിരീക്ഷിക്കുക. ശരിയായി ഡീഅലോക്കേറ്റ് ചെയ്യാത്ത ഒബ്ജക്റ്റുകൾ തിരിച്ചറിയാൻ പ്രൊഫൈലിംഗ് ടൂളുകൾ ഉപയോഗിക്കുക.
• റഫറൻസ് കൗണ്ടിംഗ് പ്രവർത്തനങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യുക: ഓവർഹെഡ് കുറയ്ക്കുന്നതിന് റഫറൻസ് കൗണ്ടിംഗ് പ്രവർത്തനങ്ങൾ ഒപ്റ്റിമൈസ് ചെയ്യുക. പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിന് മാറ്റിവെച്ച റഫറൻസ് കൗണ്ടിംഗ് അല്ലെങ്കിൽ റൈറ്റ് ബാരിയറുകൾ പോലുള്ള സാങ്കേതിക വിദ്യകൾ ഉപയോഗിക്കുക.
• വ്യാപാര-ഓഫുകൾ പരിഗണിക്കുക: റഫറൻസ് കൗണ്ടിംഗും മറ്റ് മെമ്മറി മാനേജ്മെൻ്റ് ടെക്നിക്കുകളും തമ്മിലുള്ള വ്യാപാര-ഓഫുകൾ വിലയിരുത്തുക. എല്ലാ ആപ്ലിക്കേഷനുകൾക്കും റഫറൻസ് കൗണ്ടിംഗ് ഏറ്റവും മികച്ച തിരഞ്ഞെടുപ്പായിരിക്കണമെന്നില്ല. നിങ്ങളുടെ തീരുമാനമെടുക്കുമ്പോൾ റഫറൻസ് കൗണ്ടിംഗിൻ്റെ സങ്കീർണ്ണത, ഓവർഹെഡ്, പരിമിതികൾ എന്നിവ പരിഗണിക്കുക.

ഉപസംഹാരം

തൽക്ഷണ വീണ്ടെടുക്കലും ലാളിത്യവും വാഗ്ദാനം ചെയ്യുന്ന ഒരു മൂല്യവത്തായ മെമ്മറി മാനേജ്മെൻ്റ് ടെക്നിക്കാണ് റഫറൻസ് കൗണ്ടിംഗ്. എന്നിരുന്നാലും, സർക്കുലർ റഫറൻസുകൾ കൈകാര്യം ചെയ്യാനുള്ള കഴിവില്ലായിമ ഒരു പ്രധാന പരിമിതിയാണ്. മാർക്ക് ആൻഡ് സ്വീപ് അല്ലെങ്കിൽ സൈക്കിൾ കണ്ടെത്തൽ അൽഗോരിതങ്ങൾ പോലുള്ള സൈക്ലിക് ഗാർബേജ് ശേഖരണ സാങ്കേതിക വിദ്യകൾ നടപ്പിലാക്കുന്നതിലൂടെ, നിങ്ങൾക്ക് ഈ പരിമിതിയെ മറികടക്കാനും മെമ്മറി ലീക്കുകൾ ഉണ്ടാകാതെ റഫറൻസ് കൗണ്ടിംഗിൻ്റെ പ്രയോജനം നേടാനും കഴിയും. റഫറൻസ് കൗണ്ടിംഗുമായി ബന്ധപ്പെട്ട ട്രേഡ്-ഓഫുകളും മികച്ച രീതികളും മനസ്സിലാക്കുന്നത് ശക്തവും കാര്യക്ഷമവുമായ സോഫ്റ്റ്‌വെയർ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നതിന് നിർണായകമാണ്. നിങ്ങളുടെ ആപ്ലിക്കേഷൻ്റെ നിർദ്ദിഷ്ട ആവശ്യകതകൾ ശ്രദ്ധാപൂർവ്വം പരിഗണിക്കുകയും സർക്കുലർ റഫറൻസുകളുടെ വെല്ലുവിളികൾ ലഘൂകരിക്കുന്നതിന് ആവശ്യമായ സൈക്ലിക് ഗാർബേജ് ശേഖരണം ഉൾപ്പെടുത്തി നിങ്ങളുടെ ആവശ്യത്തിനനുസരിച്ച് മെമ്മറി മാനേജ്മെൻ്റ് തന്ത്രം തിരഞ്ഞെടുക്കുക. കാര്യക്ഷമമായ മെമ്മറി ഉപയോഗം ഉറപ്പാക്കാനും മെമ്മറി ചോർച്ചകൾ തടയാനും നിങ്ങളുടെ കോഡ് പ്രൊഫൈൽ ചെയ്യാനും ഒപ്റ്റിമൈസ് ചെയ്യാനും ഓർമ്മിക്കുക.