मैंने Python में Raft कंसेंसस एल्गोरिदम (वितरित एल्गोरिदमों का एक मशहूर उदाहरण) इम्प्लीमेंट किया। यह इम्प्लीमेंटेशन काफ़ी खराब है! लेकिन (कुछ हद तक) सही भी है।
ऐसी ही चुनौती लेने में दिलचस्पी रखने वाले किसी भी व्यक्ति के साथ साझा करने के लिए मेरे पास कुछ नोट्स हैं।
पीछे मुड़कर देखने पर लगता है कि Raft को समझने और सही ढंग से इम्प्लीमेंट करने के लिए ये संसाधन सबसे उपयोगी थे।
- Raft का शोधपत्र (खंड 5 तक पढ़ें और चित्र 2 को बार-बार देखें)
- Raft पर विद्यार्थियों के लिए मार्गदर्शिका
- सबसे ज़्यादा इस्तेमाल होने वाले Raft इम्प्लीमेंटेशन में से एक
- रेपो को क्लोन करें,
raft.goपर सरसरी नज़र डालें, और कोडबेस व डिज़ाइन के फैसलों को समझने के लिए किसी LLM से सवाल-जवाब करें
- रेपो को क्लोन करें,
- Eli Bendersky की ब्लॉग शृंखला
मेरा सुझाव है कि पहले लगभग एक घंटा शोधपत्र पढ़ें, फिर किसी UDP या TCP सर्वर के कोड का शुरुआती ढाँचा तैयार करें, जो आने वाले बाइट्स को पढ़कर एक ऐरे में जोड़ता हो। इसके बाद मैंने Eli के इम्प्लीमेंटेशन का अनुसरण करते हुए अपने Raft इम्प्लीमेंटेशन में उसी क्रम में सुविधाएँ जोड़ीं।
जब चुनाव जैसा कुछ काम करने लगा, तो मैंने बग और एल्गोरिदम की अपनी समझ में गलतियाँ ढूँढ़ना शुरू किया। मैंने बार-बार विद्यार्थियों के लिए मार्गदर्शिका और Raft के शोधपत्र के चित्र 2 को अपने इम्प्लीमेंटेशन से मिलाकर ध्यान से देखा कि मेरा इम्प्लीमेंटेशन कहाँ वैसा ही था (या अलग था)। मैंने इस कोड की समीक्षा के लिए भी LLM का खूब इस्तेमाल किया और उसके कॉन्टेक्स्ट में ऊपर दिए गए संसाधनों की सामग्री जोड़ी।
लॉग रेप्लिकेशन, पर्सिस्टेंस आदि के लिए यही प्रक्रिया दोहराएँ।
इम्प्लीमेंटेशन के बारे में
मैंने अपने इम्प्लीमेंटेशन के डिज़ाइन को सरल बनाने के लिए कुछ फैसले लिए। बिना किसी खास क्रम के:
- हर नोड एक ही थ्रेड पर चलता है और संदेश प्रोसेस करता है
- सिस्टम पर स्थानीय "समय" का हिसाब रखने के लिए "लॉजिकल क्लॉक" का इस्तेमाल करें (जैसे, सिस्टम का समय इस्तेमाल करने के बजाय
tick()को कॉल करें और हर नोड का अपना काउंटर बढ़ाएँ) - सारी चीज़ें एक ही फ़ाइल में रखकर इम्प्लीमेंटेशन को "उलझा हुआ" बना दें, जैसे नेटवर्क पार्सिंग, स्टोरेज/पर्सिस्टेंस, मूल Raft एल्गोरिदम, और नोड को नियंत्रित करने की यूटिलिटीज़/कमांड
2 एक ठोस और सही डिज़ाइन विकल्प लगता है (etcd के इम्प्लीमेंटेशन में लॉजिकल क्लॉक ही इस्तेमाल होती हैं)। 3 को सीखने/सिखाने के लिहाज़ से बेहतर कहा जा सकता है। सब कुछ एक ही फ़ाइल में होना अच्छा है, क्योंकि आप एक साथ सब देख सकते हैं। इससे आपके पास एक अच्छा इम्प्लीमेंटेशन भी होता है, जिसे उधेड़कर आप देख सकते हैं कि कौन-से एब्स्ट्रैक्शन एल्गोरिदम के लिए सबसे उपयुक्त हैं।
1 मुझे कुछ ज़्यादा ही गलत फैसला लगता है। इससे इम्प्लीमेंटेशन बहुत सरल ज़रूर हो जाता है (डेडलॉक में फँसने और नोड की आंतरिक स्थिति के एटॉमिक अपडेट को लेकर कम चिंता करनी पड़ती है), लेकिन नतीजे में जो बनता है वह पूरी तरह Raft नहीं होता। पहले इम्प्लीमेंटेशन के लिए यह ठीक लगता है। एल्गोरिदम अपने आप में काफ़ी जटिल है, और मेरे हिसाब से म्यूटेक्स से जूझने के बजाय मूल Raft एल्गोरिदम की तार्किक गलतियाँ डीबग करने में समय लगाना ज़्यादा बेहतर होगा।
मेरे हिसाब से इस तरह Raft इम्प्लीमेंट करना लगभग 30 घंटे का प्रोजेक्ट है। Raft के शोधपत्र की शुरुआती पढ़ाई और उससे जुड़ी सामग्री की समीक्षा में कुछ घंटे लगने चाहिए। मैंने ज़्यादातर कोडिंग छुट्टियों के दौरान लगभग 3 दिनों में की, हर दिन करीब 6-8 घंटे कोड लिखते हुए। मौजूदा इम्प्लीमेंटेशन में अभी भी कुछ चीज़ें सँवारनी और सुधारनी हैं (जैसे कुछ सूक्ष्म बग ठीक करना), जिनमें शायद आधे दिन का और काम लगे।
कुल मिलाकर, उन बुनियादी एल्गोरिदमों में से एक को समझने के लिए यह कोई बुरा सौदा नहीं है, जिनके सहारे इतना सारा इन्फ्रास्ट्रक्चर चलता है।