ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം
ഒരു ശൃംഖലയിലെ ഡാറ്റയുടെ തിരക്കിനെ നിയന്ത്രിക്കുന്നതിനുള്ള ഒരു അൽഗോരിതമാണ് ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം.[1] ലീക്കീ ബക്കറ്റ് അൽഗോരിതവുമായി ഇതിനു സാമ്യമുണ്ട്. എന്നാൽ അതിൽ നിന്ന് വ്യത്യസ്താമായി ഇവിടെ ഡാറ്റാ നിരക്കിനെ നിയന്ത്രിക്കുന്നത് ടോക്കണുകൾ ഉപയോഗിച്ചിട്ടാണ്. സിസ്റ്റത്തിൽ നിന്ന് ശൃംഖലയിലേക്ക് ഇടയ്ക്കിടയ്ക്ക് ടോക്കണുകൾ അയയ്ക്കുന്നു. ഇവയെ സ്റ്റേഷനിൽ ഒരു ബക്കറ്റിലായി (ക്യൂവിൽ) ശേഖരിക്കുന്നു. എത്രമാത്രം ടോക്കണുകൾ ബക്കറ്റിൽ അവശേഷിക്കന്നുവോ അത്രമാത്രം ഡാറ്റയെ മാത്രമേ പിന്നീട് ശൃംഖലയിലേക്ക് അയക്കാൻ കഴിയൂ. ഒരു പക്ഷേ ബക്കറ്റിനുള്ളിൽ ടോക്കൺ അവശേഷിക്കുന്നില്ലെങ്കിൽ അവ വരുന്നത് വരെ കാത്തിരിക്കേണ്ടി വരും. ഇത് നെറ്റ്‌വർക്കിലേക്ക് വ്യത്യസ്ത നിരക്കിൽ ഡാറ്റ അയയ്ക്കാൻ സഹായിക്കും.
അവലോകനം തിരുത്തുക
ടോക്കൺ ബക്കറ്റ് അൽഗോരിതം ഒരു നിശ്ചിത ശേഷിയുള്ള ബക്കറ്റിന്റെ സാമ്യത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, അതിൽ സാധാരണയായി ഒരു യൂണിറ്റ് ബൈറ്റുകളെ പ്രതിനിധീകരിക്കുന്ന അല്ലെങ്കിൽ മുൻകൂട്ടി നിശ്ചയിച്ച വലുപ്പത്തിലുള്ള ഒരു പാക്കറ്റിനെ പ്രതിനിധീകരിക്കുന്ന ടോക്കണുകൾ ഒരു നിശ്ചിത നിരക്കിൽ ചേർക്കുന്നു. ഒരു പാക്കറ്റ് നിർവചിക്കപ്പെട്ട പരിധിക്ക് അനുസൃതമാണോ എന്ന് പരിശോധിക്കുമ്പോൾ, ബക്കറ്റിൽ ആ സമയത്ത് മതിയായ ടോക്കണുകൾ ഉണ്ടോ എന്ന് പരിശോധിക്കും. അങ്ങനെയെങ്കിൽ, ടോക്കണുകളുടെ ഉചിതമായ എണ്ണം, ഉദാ. ബൈറ്റുകളിൽ പാക്കറ്റിന്റെ ലെങ്തിന് തുല്യമായത്, നീക്കം ചെയ്യപ്പെടുന്നു ("കാഷ് ഇൻ"), പാക്കറ്റ് കൈമാറുന്നു, ഉദാ., പ്രക്ഷേപണത്തിനായി ഉപയോഗിക്കുന്നു. ബക്കറ്റിൽ മതിയായ ടോക്കണുകൾ ഇല്ലെങ്കിൽ പാക്കറ്റുമായി പൊരുത്തപ്പെടില്ല, ആയതിനാൽ ബക്കറ്റിലെ ഉള്ളടക്കം മാറ്റപ്പെടുന്നില്ല. സ്ഥീകരിക്കാത്ത പാക്കറ്റുകൾ വിവിധ രീതികളിൽ ട്രീറ്റ് ചെയ്യാം:[2]
- അവയെ ഒഴിവാക്കിയേക്കാം.
- ബക്കറ്റിൽ മതിയായ ടോക്കണുകൾ ലഭ്യമാകുമ്പോൾ അവ തുടർന്നുള്ള സംപ്രേക്ഷണത്തിനായി ക്യൂവിൽ നിൽക്കും.
- അവ കൈമാറ്റം ചെയ്യപ്പെടാം, പക്ഷേ അനുരൂപമല്ലെന്ന് അടയാളപ്പെടുത്തി, നെറ്റ്‌വർക്ക് ഓവർലോഡ് ആണെങ്കിൽ പിന്നീട് ഉപേക്ഷിക്കപ്പെടാം.[3]