एनएस-3-ट्यूटोरियल - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

एनएस-3-ट्यूटोरियल - एनएस-3 ट्यूटोरियल

यह वह जगह है एनएस- 3 ट्यूटोरियल. एनएस-3 परियोजना के लिए प्राथमिक दस्तावेज़ीकरण पाँच में उपलब्ध है
रूपों:

· एनएस- 3 Doxygen: सिम्युलेटर के सार्वजनिक एपीआई का दस्तावेज़ीकरण

· ट्यूटोरियल (इस दस्तावेज़), मैनुअल और मॉडल लाइब्रेरी के लिए ताज़ा और और
विकास पेड़

· एनएस- 3 विकि

यह दस्तावेज़ . में लिखा गया है reStructuredText एसटी गूढ़ व्यक्ति और में बनाए रखा है
दस्तावेज़/ट्यूटोरियल एनएस -3 के स्रोत कोड की निर्देशिका।

परिचय

RSI एनएस- 3 सिम्युलेटर एक असतत-घटना नेटवर्क सिम्युलेटर है जो मुख्य रूप से अनुसंधान के लिए लक्षित है
और शैक्षिक उपयोग. एनएस- 3 परियोजना2006 में शुरू हुआ, एक ओपन-सोर्स प्रोजेक्ट है
विकासशील एनएस- 3.

इस ट्यूटोरियल का उद्देश्य नया परिचय देना है एनएस- 3 सिस्टम में उपयोगकर्ताओं को एक संरचित
रास्ता। कभी-कभी नए उपयोगकर्ताओं के लिए विस्तृत जानकारी प्राप्त करना कठिन होता है
मैनुअल और इस जानकारी को कार्यशील सिमुलेशन में परिवर्तित करना। इस ट्यूटोरियल में, हम
प्रमुख अवधारणाओं को प्रस्तुत करने और समझाने के लिए कई उदाहरण सिमुलेशन तैयार करेंगे
जैसे-जैसे हम आगे बढ़ते हैं सुविधाएँ।

जैसे ही ट्यूटोरियल सामने आएगा, हम पूरा परिचय देंगे एनएस- 3 दस्तावेज़ीकरण और प्रदान करें
की कार्यप्रणाली को गहराई से जानने में रुचि रखने वालों के लिए स्रोत कोड की ओर संकेत
प्रणाली।

शुरुआत में कुछ मुख्य बातें ध्यान देने योग्य हैं:

· एनएस- 3 खुला-स्रोत है, और परियोजना एक खुला वातावरण बनाए रखने का प्रयास करती है
शोधकर्ता अपने सॉफ़्टवेयर में योगदान दें और साझा करें।

· एनएस- 3 का पश्चगामी-संगत विस्तार नहीं है एनएस- 2; यह एक नया सिम्युलेटर है. दो
सिमुलेटर दोनों C++ में लिखे गए हैं लेकिन एनएस- 3 एक नया सिम्युलेटर है जो इसका समर्थन नहीं करता है
एनएस- 2 एपीआई. से कुछ मॉडल एनएस- 2 से पहले ही पोर्ट किया जा चुका है एनएस- 2 सेवा मेरे एनएस- 3।
परियोजना का रखरखाव जारी रहेगा एनएस- 2 जब एनएस- 3 बनाया जा रहा है, और अध्ययन करेंगे
संक्रमण और एकीकरण तंत्र.

मेरे बारे में एनएस- 3
एनएस- 3 के लिए एक खुला, एक्स्टेंसिबल नेटवर्क सिमुलेशन प्लेटफ़ॉर्म प्रदान करने के लिए विकसित किया गया है
नेटवर्किंग अनुसंधान और शिक्षा। संक्षिप्त, एनएस- 3 पैकेट डेटा के मॉडल प्रदान करता है
नेटवर्क काम करते हैं और प्रदर्शन करते हैं, और उपयोगकर्ताओं को संचालन के लिए एक सिमुलेशन इंजन प्रदान करते हैं
अनुकरण प्रयोग. उपयोग करने के कुछ कारण एनएस- 3 इसमें अध्ययन करना शामिल है
सिस्टम व्यवहार का अध्ययन करने के लिए वास्तविक सिस्टम के साथ प्रदर्शन करना अधिक कठिन या संभव नहीं है
अत्यधिक नियंत्रित, प्रतिलिपि प्रस्तुत करने योग्य वातावरण में, और यह जानने के लिए कि नेटवर्क कैसे काम करते हैं।
उपयोगकर्ता ध्यान देंगे कि उपलब्ध मॉडल सेट है एनएस- 3 इंटरनेट कैसे मॉडलिंग पर केंद्रित है
प्रोटोकॉल और नेटवर्क काम करते हैं, लेकिन एनएस- 3 इंटरनेट सिस्टम तक सीमित नहीं है; अनेक उपयोगकर्ता
का उपयोग कर रहे हैं एनएस- 3 गैर-इंटरनेट-आधारित प्रणालियों को मॉडल करना।

नेटवर्क सिमुलेशन अध्ययन के लिए कई सिमुलेशन उपकरण मौजूद हैं। नीचे कुछ हैं
की विशिष्ट विशेषताएं एनएस- 3 अन्य उपकरणों के विपरीत.

· एनएस- 3 इसे पुस्तकालयों के एक सेट के रूप में डिज़ाइन किया गया है जिसे एक साथ और दूसरे के साथ भी जोड़ा जा सकता है
बाहरी सॉफ़्टवेयर लाइब्रेरी. जबकि कुछ सिमुलेशन प्लेटफ़ॉर्म उपयोगकर्ताओं को एक प्रदान करते हैं
एकल, एकीकृत ग्राफिकल यूजर इंटरफ़ेस वातावरण जिसमें सभी कार्य किए जाते हैं
बाहर, एनएस- 3 इस संबंध में अधिक मॉड्यूलर है। कई बाहरी एनिमेटर और डेटा विश्लेषण
और विज़ुअलाइज़ेशन टूल का उपयोग किया जा सकता है एनएस- 3. हालाँकि, उपयोगकर्ताओं को काम करने की उम्मीद करनी चाहिए
कमांड लाइन और C++ और/या Python सॉफ़्टवेयर डेवलपमेंट टूल के साथ।

· एनएस- 3 मुख्य रूप से Linux सिस्टम पर उपयोग किया जाता है, हालाँकि FreeBSD, Cygwin के लिए समर्थन मौजूद है
(विंडोज़ के लिए), और मूल विंडोज विज़ुअल स्टूडियो समर्थन होने की प्रक्रिया में है
विकसित की है।

· एनएस- 3 किसी भी कंपनी का आधिकारिक रूप से समर्थित सॉफ़्टवेयर उत्पाद नहीं है। के लिए समर्थन एनएस- 3
एनएस-3-उपयोगकर्ता मेलिंग सूची पर सर्वोत्तम प्रयास के आधार पर किया जाता है।

के लिए एनएस- 2 उपयोगकर्ता
उन परिचितों के लिए एनएस- 2 (एक लोकप्रिय उपकरण जो पहले आया था एनएस- 3), सबसे बाहर की ओर दिखाई देने वाला
चलते समय बदलें एनएस- 3 स्क्रिप्टिंग भाषा का विकल्प है। में कार्यक्रम एनएस- 2 रहे
ओटीसीएल में स्क्रिप्टेड और सिमुलेशन के परिणामों को नेटवर्क एनिमेटर का उपयोग करके देखा जा सकता है
नाम. इसमें सिमुलेशन चलाना संभव नहीं है एनएस- 2 विशुद्ध रूप से C++ से (यानी, एक मुख्य() के रूप में)
बिना किसी ओटीसीएल के कार्यक्रम)। इसके अलावा, के कुछ घटक एनएस- 2 C++ में लिखे गए हैं और
ओटीसीएल में अन्य। में एनएस- 3, सिम्युलेटर वैकल्पिक पायथन के साथ पूरी तरह से C++ में लिखा गया है
बंधन. इसलिए सिमुलेशन स्क्रिप्ट C++ या Python में लिखी जा सकती हैं। नए एनिमेटर
और विज़ुअलाइज़र उपलब्ध हैं और वर्तमान विकास के अधीन हैं। तब से एनएस- 3 पीकैप उत्पन्न करता है
पैकेट ट्रेस फ़ाइलों के अलावा, अन्य उपयोगिताओं का उपयोग ट्रेस का विश्लेषण करने के लिए भी किया जा सकता है। इस में
ट्यूटोरियल में, हम सबसे पहले सीधे C++ में स्क्रिप्टिंग और परिणामों की व्याख्या पर ध्यान केंद्रित करेंगे
ट्रेस फ़ाइलों के माध्यम से.

लेकिन समानताएं भी हैं (दोनों, उदाहरण के लिए, C++ ऑब्जेक्ट पर आधारित हैं, और कुछ
से कोड एनएस- 2 पहले ही पोर्ट किया जा चुका है एनएस- 3). हम मतभेदों को उजागर करने का प्रयास करेंगे
के बीच एनएस- 2 और एनएस- 3 जैसा कि हम इस ट्यूटोरियल में आगे बढ़ते हैं।

एक प्रश्न जो हम अक्सर सुनते हैं वह है "क्या मुझे अभी भी इसका उपयोग करना चाहिए एनएस- 2 या आगे बढ़ें एनएस- 3?" इस में
लेखक की राय, जब तक कि उपयोगकर्ता किसी तरह इसमें निहित न हो एनएस- 2 (या तो मौजूदा पर आधारित
व्यक्तिगत आराम और ज्ञान एनएस- 2, या एक विशिष्ट सिमुलेशन मॉडल पर आधारित है
में ही उपलब्ध है एनएस- 2), उपयोगकर्ता अधिक उत्पादक होगा एनएस- 3 निम्नलिखित के लिए
कारण हैं:

· एनएस- 3 जबकि, एक सक्रिय, प्रतिक्रियाशील उपयोगकर्ता मेलिंग सूची के साथ सक्रिय रूप से बनाए रखा जाता है एनएस- 2 is
केवल हल्के ढंग से बनाए रखा गया है और इसके मुख्य कोड ट्री में कोई महत्वपूर्ण विकास नहीं देखा गया है
एक दशक से अधिक के लिए

· एनएस- 3 ऐसी सुविधाएँ प्रदान करता है जो उपलब्ध नहीं हैं एनएस- 2, जैसे कार्यान्वयन कोड निष्पादन
पर्यावरण (उपयोगकर्ताओं को सिम्युलेटर में वास्तविक कार्यान्वयन कोड चलाने की अनुमति देना)

· एनएस- 3 की तुलना में अमूर्तता का निम्न आधार स्तर प्रदान करता है एनएस- 2, इसे संरेखित करने की अनुमति देता है
वास्तविक प्रणालियों को एक साथ कैसे रखा जाए, यह बेहतर है। में कुछ सीमाएँ पाई गईं एनएस- 2 (जैसे
नोड्स पर कई प्रकार के इंटरफेस का सही ढंग से समर्थन करना) का समाधान किया गया है एनएस- 3.

एनएस- 2 की तुलना में इसमें योगदान किए गए मॉड्यूल का अधिक विविध सेट है एनएस- 3, इसके लंबे होने के कारण
इतिहास। तथापि, एनएस- 3 अनुसंधान के कई लोकप्रिय क्षेत्रों में अधिक विस्तृत मॉडल हैं
(परिष्कृत एलटीई और वाईफाई मॉडल सहित), और इसके कार्यान्वयन कोड का समर्थन
उच्च-निष्ठा मॉडल के एक बहुत व्यापक स्पेक्ट्रम को स्वीकार करता है। यह जानकर उपयोगकर्ता आश्चर्यचकित हो सकते हैं
संपूर्ण लिनक्स नेटवर्किंग स्टैक को एक में समाहित किया जा सकता है एनएस- 3 नोड, डायरेक्ट का उपयोग करते हुए
कोड निष्पादन (डीसीई) ढांचा। एनएस- 2 मॉडलों को कभी-कभी पोर्ट किया जा सकता है एनएस- 3, खासकर
यदि उन्हें C++ में लागू किया गया है।

यदि संदेह है, तो एक अच्छा दिशानिर्देश दोनों सिमुलेटरों (साथ ही अन्य) को देखना होगा
सिमुलेटर), और विशेष रूप से आपके शोध के लिए उपलब्ध मॉडल, लेकिन ध्यान रखें
सक्रिय रूप से विकसित किए जा रहे टूल का उपयोग करने में आपका अनुभव बेहतर हो सकता है
बनाए रखा (एनएस- 3).

योगदान
एनएस- 3 अनुसंधान समुदाय द्वारा और उसके लिए एक अनुसंधान और शैक्षिक सिम्युलेटर है। यह
नए मॉडल विकसित करने, डिबग करने या करने के लिए समुदाय के चल रहे योगदान पर भरोसा करें
मौजूदा को बनाए रखें, और परिणाम साझा करें। ऐसी कुछ नीतियां हैं जिनसे हमें उम्मीद है कि ऐसा होगा
लोगों को योगदान देने के लिए प्रोत्साहित करें एनएस- 3 जैसे उनके पास है एनएस- 2:

· GNU GPLv2 अनुकूलता पर आधारित ओपन सोर्स लाइसेंसिंग

· विकि

· योगदान दिया कोड पेज, के समान एनएस- 2का लोकप्रिय योगदान कोड पृष्ठ

· खुला हुआ बग ट्रैकर

हमें एहसास है कि यदि आप इस दस्तावेज़ को पढ़ रहे हैं, तो परियोजना में वापस योगदान देना है
संभवतः इस बिंदु पर आपकी सबसे बड़ी चिंता नहीं है, लेकिन हम चाहते हैं कि आप इससे अवगत रहें
योगदान देना परियोजना की भावना के अनुरूप है और यहां तक ​​कि हमें एक नोट छोड़ने का कार्य भी
आपके शुरुआती अनुभव के बारे में एनएस- 3 (उदाहरण के लिए "यह ट्यूटोरियल अनुभाग स्पष्ट नहीं था..."),
पुराने दस्तावेज़ों आदि की रिपोर्टों की बहुत सराहना की जाती है।

ट्यूटोरियल संगठन"
ट्यूटोरियल मानता है कि नए उपयोगकर्ता प्रारंभ में निम्नलिखित पथ का अनुसरण कर सकते हैं:

· डाउनलोड करने और उसकी एक प्रति बनाने का प्रयास करें;

· कुछ नमूना कार्यक्रम चलाने का प्रयास करें;

· सिमुलेशन आउटपुट देखें, और इसे समायोजित करने का प्रयास करें।

परिणामस्वरूप, हमने उपरोक्त व्यापक अनुक्रमों के अनुसार ट्यूटोरियल को व्यवस्थित करने का प्रयास किया है
आयोजन।

संसाधन

RSI वेब
इनमें से कई महत्वपूर्ण संसाधन हैं एनएस- 3 उपयोगकर्ता को जागरूक होना चाहिए. मुख्य वेब
साइट स्थित है http://www.nsnam.org और के बारे में बुनियादी जानकारी तक पहुंच प्रदान करता है
एनएस- 3 प्रणाली। विस्तृत दस्तावेज़ीकरण मुख्य वेब साइट पर उपलब्ध है
http://www.nsnam.org/documentation/. आप सिस्टम से संबंधित दस्तावेज़ भी पा सकते हैं
इस पृष्ठ से वास्तुकला.

एक विकी है जो मुख्य का पूरक है एनएस- 3 वेब साइट जो आपको मिलेगी
http://www.nsnam.org/wiki/. आपको वहां उपयोगकर्ता और डेवलपर के अक्सर पूछे जाने वाले प्रश्न भी मिलेंगे
समस्या निवारण मार्गदर्शिकाएँ, तृतीय पक्ष द्वारा योगदान किया गया कोड, कागजात इत्यादि।

स्रोत कोड यहां पाया और ब्राउज़ किया जा सकता है http://code.nsnam.org/. वहां तुम्हें मिलेगा
रिपॉजिटरी में वर्तमान विकास वृक्ष का नाम दिया गया है एनएस-3-देव. पिछली रिलीज़ और
मुख्य डेवलपर्स के प्रायोगिक भंडार भी वहां पाए जा सकते हैं।

अस्थिर
जटिल सॉफ्टवेयर सिस्टम को संगठन और उसमें बदलावों को प्रबंधित करने के लिए किसी तरीके की आवश्यकता होती है
अंतर्निहित कोड और दस्तावेज़ीकरण। इस उपलब्धि को करने के कई तरीके हैं, और आप भी कर सकते हैं
ऐसी कुछ प्रणालियों के बारे में सुना है जो वर्तमान में ऐसा करने के लिए उपयोग की जाती हैं। समवर्ती
संस्करण प्रणाली (सीवीएस) संभवतः सबसे प्रसिद्ध है।

RSI एनएस- 3 परियोजना अपने स्रोत कोड प्रबंधन प्रणाली के रूप में मर्क्यूरियल का उपयोग करती है। हालाँकि आप ऐसा नहीं करते
इस ट्यूटोरियल को पूरा करने के लिए आपको मर्क्यूरियल के बारे में बहुत कुछ जानने की जरूरत है, हम अनुशंसा करते हैं
मर्क्यूरियल से परिचित होना और स्रोत कोड तक पहुंचने के लिए इसका उपयोग करना। मर्क्यूरियल में एक है
वेब साइट पर http://www.selenic.com/mercurial/, जिससे आप बाइनरी या सोर्स प्राप्त कर सकते हैं
इस सॉफ़्टवेयर कॉन्फ़िगरेशन प्रबंधन (एससीएम) प्रणाली की रिलीज़। सेलेनिक (डेवलपर
ऑफ मर्क्यूरियल) पर एक ट्यूटोरियल भी प्रदान करता है
http://www.selenic.com/mercurial/wiki/index.cgi/Tutorial/, और एक क्विकस्टार्ट गाइड
http://www.selenic.com/mercurial/wiki/index.cgi/QuickStart/.

आप मर्क्यूरियल और के उपयोग के बारे में महत्वपूर्ण जानकारी भी पा सकते हैं एनएस- 3 मुख्य पर एनएस- 3 वेब
साइट.

waf
एक बार जब आपके स्थानीय सिस्टम में स्रोत कोड डाउनलोड हो जाए, तो आपको उसे संकलित करने की आवश्यकता होगी
प्रयोग करने योग्य प्रोग्राम तैयार करने का स्रोत। जैसा कि स्रोत कोड प्रबंधन के मामले में होता है
इस कार्य को करने के लिए कई उपकरण उपलब्ध हैं। संभवतः इनमें से सबसे प्रसिद्ध
उपकरण है बनाना. सबसे प्रसिद्ध होने के साथ-साथ, बनाना संभवतः सबसे कठिन है
एक बहुत बड़े और उच्च विन्यास योग्य सिस्टम में उपयोग करने के लिए। इस वजह से, कई विकल्प
विकसित किया गया है। हाल ही में इन प्रणालियों को पायथन का उपयोग करके विकसित किया गया है
भाषा।

बिल्ड सिस्टम Waf का उपयोग किया जाता है एनएस- 3 परियोजना। यह नई पीढ़ी में से एक है
पायथन-आधारित बिल्ड सिस्टम। इसे बनाने के लिए आपको किसी Python को समझने की आवश्यकता नहीं होगी
मौजूदा एनएस- 3 प्रणाली।

वफ़ के रक्तरंजित विवरण में रुचि रखने वालों के लिए, मुख्य वेबसाइट यहां पाई जा सकती है
http://code.google.com/p/waf/.

विकास वातावरण
जैसा कि ऊपर बताया गया है, स्क्रिप्टिंग में एनएस- 3 C++ या Python में किया जाता है। के सबसे एनएस- 3 एपीआई है
पायथन में उपलब्ध है, लेकिन किसी भी स्थिति में मॉडल C++ में लिखे गए हैं। एक कामकाजी
इस दस्तावेज़ में C++ और ऑब्जेक्ट-ओरिएंटेड अवधारणाओं का ज्ञान माना गया है। हम लेंगे
कुछ अधिक उन्नत अवधारणाओं या संभवतः अपरिचित भाषा की समीक्षा करने के लिए कुछ समय
विशेषताएँ, मुहावरे और डिज़ाइन पैटर्न जैसे वे दिखाई देते हैं। हम यह ट्यूटोरियल नहीं चाहते
हालाँकि, इसे C++ ट्यूटोरियल में विकसित करें, इसलिए हम भाषा पर बुनियादी कमांड की अपेक्षा करते हैं।
C++ पर जानकारी के लगभग अकल्पनीय संख्या में स्रोत उपलब्ध हैं
वेब या प्रिंट में।

यदि आप C++ में नए हैं, तो आप एक ट्यूटोरियल- या कुकबुक-आधारित पुस्तक या वेब साइट ढूंढना चाह सकते हैं
और आगे बढ़ने से पहले कम से कम भाषा की बुनियादी विशेषताओं पर काम करें। के लिए
उदाहरण के लिए, इसका ट्यूटोरियल.

RSI एनएस- 3 सिस्टम विकास के लिए GNU "टूलचेन" के कई घटकों का उपयोग करता है। ए
सॉफ़्टवेयर टूलचेन दिए गए वातावरण में उपलब्ध प्रोग्रामिंग टूल का सेट है। के लिए
जीएनयू टूलचेन में क्या शामिल है इसकी त्वरित समीक्षा देखें,
http://en.wikipedia.org/wiki/GNU_toolchain. एनएस- 3 जीसीसी, जीएनयू बिनुटिल्स और जीडीबी का उपयोग करता है।
हालाँकि, हम GNU बिल्ड सिस्टम टूल्स, न तो मेक और न ही ऑटोटूल्स का उपयोग करते हैं। हम वफ़ का उपयोग करते हैं
इन कार्यों के लिए.

आम तौर पर an एनएस- 3 लेखक लिनक्स या लिनक्स जैसे वातावरण में काम करेगा। उन लोगों के लिए
विंडोज़ के अंतर्गत चलने पर, ऐसे वातावरण मौजूद होते हैं जो लिनक्स वातावरण का अनुकरण करते हैं
विभिन्न डिग्री. एनएस- 3 परियोजना को अतीत में (लेकिन वर्तमान में नहीं) समर्थन मिला है
इन उपयोगकर्ताओं के लिए सिगविन परिवेश में विकास। देखना http://www.cygwin.com/ एसटी
डाउनलोड करने पर विवरण, और पर जाएँ एनएस- 3 सिगविन और के बारे में अधिक जानकारी के लिए विकी
एनएस- 3. MinGW वर्तमान में आधिकारिक तौर पर समर्थित नहीं है। सिगविन का एक अन्य विकल्प है
एक वर्चुअल मशीन वातावरण स्थापित करें जैसे कि VMware सर्वर और एक लिनक्स वर्चुअल स्थापित करें
मशीन।

गर्तिका प्रोग्रामिंग
हम इसमें उपयोग किए गए उदाहरणों में बर्कले सॉकेट एपीआई के साथ एक बुनियादी सुविधा मानेंगे
ट्यूटोरियल. यदि आप सॉकेट में नए हैं, तो हम एपीआई और कुछ सामान्य उपयोग की समीक्षा करने की सलाह देते हैं
मामले. प्रोग्रामिंग के अच्छे अवलोकन के लिए टीसीपी/आईपी सॉकेट्स की हम अनुशंसा करते हैं टीसीपी / आईपी सॉकेट in
C, डोनाहु और Calvert.

एक संबद्ध वेब साइट है जिसमें पुस्तक में उदाहरणों के लिए स्रोत शामिल है
आप यहां पा सकते हैं: http://cs.baylor.edu/~donahoo/practical/CSockets/.

यदि आप पुस्तक के पहले चार अध्यायों को समझते हैं (या उन लोगों के लिए जिनके पास पहुंच नहीं है
पुस्तक की एक प्रति, ऊपर वेबसाइट में दिखाए गए इको क्लाइंट और सर्वर) आप ऐसा करेंगे
ट्यूटोरियल को समझने के लिए अच्छी स्थिति में रहें। मल्टीकास्ट पर ऐसी ही एक किताब है
सॉकेट, बहुस्त्र्पीय सॉकेट, Makofske और अलमेरोथ. इसमें वह सामग्री शामिल है जिसकी आपको आवश्यकता हो सकती है
यदि आप वितरण में मल्टीकास्ट उदाहरणों को देखें तो समझें।

मिल रहा शुरू कर दिया है

इस अनुभाग का उद्देश्य उपयोगकर्ता को मशीन से शुरू करके कार्यशील स्थिति में लाना है
शायद कभी नहीं हुआ होगा एनएस- 3 स्थापित. इसमें समर्थित प्लेटफ़ॉर्म, पूर्वापेक्षाएँ, तरीके शामिल हैं
प्राप्त एनएस- 3, निर्माण के तरीके एनएस- 3, और अपने निर्माण को सत्यापित करने और सरल प्रोग्राम चलाने के तरीके।

अवलोकन
एनएस- 3 सॉफ्टवेयर लाइब्रेरीज़ की एक प्रणाली के रूप में बनाया गया है जो एक साथ काम करती है। उपयोगकर्ता प्रोग्राम हो सकते हैं
लिखा है कि इन पुस्तकालयों से लिंक (या आयात) किया जाता है। उपयोगकर्ता प्रोग्राम लिखे जाते हैं
या तो C++ या Python प्रोग्रामिंग भाषाएँ।

एनएस- 3 स्रोत कोड के रूप में वितरित किया जाता है, जिसका अर्थ है कि लक्ष्य प्रणाली के लिए एक होना आवश्यक है
पहले पुस्तकालयों का निर्माण करने के लिए सॉफ़्टवेयर विकास वातावरण, फिर उपयोगकर्ता का निर्माण करना
कार्यक्रम. एनएस- 3 सैद्धांतिक रूप से चयनित लोगों के लिए पूर्व-निर्मित पुस्तकालयों के रूप में वितरित किया जा सकता है
सिस्टम, और भविष्य में इसे इस तरह वितरित किया जा सकता है, लेकिन वर्तमान में, कई उपयोगकर्ता
वास्तव में अपना कार्य संपादन द्वारा करते हैं एनएस- 3 स्वयं, इसलिए पुनर्निर्माण के लिए स्रोत कोड मौजूद है
पुस्तकालय उपयोगी है. यदि कोई व्यक्ति पूर्व-निर्मित बनाने का कार्य करना चाहेगा
ऑपरेटिंग सिस्टम के लिए लाइब्रेरी और पैकेज, कृपया एनएस-डेवलपर्स मेलिंग से संपर्क करें
सूची।

निम्नलिखित में, हम डाउनलोड करने और निर्माण करने के दो तरीकों पर गौर करेंगे एनएस- 3। पहला है
मुख्य वेब साइट से आधिकारिक रिलीज़ डाउनलोड करने और बनाने के लिए। दूसरा लाना है
और इसकी विकास प्रतियां बनाएं एनएस- 3. हम टूल के बाद से दोनों उदाहरणों पर चलेंगे
शामिल थोड़े अलग हैं।

डाउनलोडिंग एनएस- 3
RSI एनएस- 3 समग्र रूप से प्रणाली एक काफी जटिल प्रणाली है और इस पर कई निर्भरताएँ हैं
अन्य घटक. सिस्टम के साथ-साथ आप संभवतः हर दिन निपटेंगे
जीएनयू टूलचेन, मर्क्यूरियल, एक टेक्स्ट एडिटर) आपको यह सुनिश्चित करने की आवश्यकता होगी कि कई
आगे बढ़ने से पहले आपके सिस्टम पर अतिरिक्त लाइब्रेरी मौजूद हैं। एनएस- 3 एक विकी प्रदान करता है
वह पृष्ठ जिसमें कई उपयोगी संकेत और सुझाव वाले पृष्ठ शामिल हैं। ऐसा ही एक पेज है
"स्थापना" पृष्ठ, http://www.nsnam.org/wiki/Installation.

इस विकि पृष्ठ का "आवश्यकताएँ" अनुभाग बताता है कि किन पैकेजों की आवश्यकता है
आम का समर्थन करें एनएस- 3 विकल्प, और उन्हें स्थापित करने के लिए उपयोग किए जाने वाले कमांड भी प्रदान करता है
सामान्य Linux वैरिएंट. सिगविन उपयोगकर्ताओं को सिगविन इंस्टॉलर का उपयोग करना होगा (यदि आप एक हैं)।
सिगविन उपयोगकर्ता, आपने इसका उपयोग सिगविन स्थापित करने के लिए किया था)।

हो सकता है कि आप इस अवसर का लाभ उठाना चाहें एनएस- 3 थोड़ा विकी क्योंकि वास्तव में वहाँ है
वहां प्रचुर मात्रा में जानकारी है।

इस बिंदु से आगे, हम यह मानने जा रहे हैं कि पाठक लिनक्स या लिनक्स में काम कर रहा है
लिनक्स इम्यूलेशन वातावरण (लिनक्स, सिगविन, आदि) और इसमें जीएनयू टूलचेन स्थापित है
ऊपर उल्लिखित आवश्यक शर्तों के साथ सत्यापित किया गया। हम भी यही मानकर चल रहे हैं
आपके पास मर्क्यूरियल और वेफ़ स्थापित हैं और लक्ष्य सिस्टम पर चल रहे हैं।

RSI एनएस- 3 कोड सर्वर पर मर्क्यूरियल रिपॉजिटरी में उपलब्ध है http://code.nsnam.org.
आप टारबॉल रिलीज़ को यहां से भी डाउनलोड कर सकते हैं http://www.nsnam.org/release/, या आप काम कर सकते हैं
मर्क्यूरियल का उपयोग करके रिपॉजिटरी के साथ। जब तक कोई अच्छा न हो हम मर्क्यूरियल का उपयोग करने की सलाह देते हैं
न करने का कारण. टारबॉल कैसे प्राप्त करें, इस पर निर्देशों के लिए इस अनुभाग का अंत देखें
रिलीज.

मर्क्यूरियल रिपॉजिटरी का उपयोग शुरू करने का सबसे सरल तरीका इसका उपयोग करना है एनएस-3-एलिनोन
पर्यावरण। यह स्क्रिप्ट का एक सेट है जो डाउनलोडिंग और निर्माण का प्रबंधन करता है
के विभिन्न उपप्रणालियाँ एनएस- 3 आपके लिए। हमारा सुझाव है कि आप अपनी शुरुआत करें एनएस- 3 इसमें काम करें
पर्यावरण.

एक अभ्यास एक निर्देशिका बनाने का है जिसे कहा जाता है कार्यस्थान किसी की होम निर्देशिका में जिसके अंतर्गत
कोई स्थानीय मर्क्यूरियल रिपॉजिटरी रख सकता है। कोई भी निर्देशिका नाम काम करेगा, लेकिन हम मान लेंगे
कि कार्यस्थान यहाँ प्रयोग किया गया है (नोट: रेपो कुछ दस्तावेज़ों में भी इसका उपयोग किया जा सकता है
उदाहरण निर्देशिका नाम).

डाउनलोडिंग एनएस- 3 का प्रयोग a टारबॉल
टारबॉल सॉफ्टवेयर संग्रह का एक विशेष प्रारूप है जहां कई फाइलें बंडल की जाती हैं
एक साथ और संग्रह संभवतः संकुचित हो गया। एनएस- 3 सॉफ़्टवेयर रिलीज़ a के माध्यम से प्रदान की जाती हैं
डाउनलोड करने योग्य टारबॉल। डाउनलोड करने की प्रक्रिया एनएस- 3 टारबॉल के माध्यम से सरल है; आप बस
एक रिलीज़ चुननी होगी, उसे डाउनलोड करना होगा और उसे डीकंप्रेस करना होगा।

आइए मान लें कि आप, एक उपयोगकर्ता के रूप में, निर्माण करना चाहते हैं एनएस- 3 नामक स्थानीय निर्देशिका में
कार्यस्थान. यदि आप अपनाते हैं कार्यस्थान निर्देशिका दृष्टिकोण, आप रिलीज़ की एक प्रति प्राप्त कर सकते हैं
अपने Linux शेल में निम्नलिखित टाइप करके (उचित संस्करण संख्याएँ प्रतिस्थापित करें,
बिल्कुल):

$ सीडी
$ एमकेडीआईआर कार्यक्षेत्र
$ सीडी कार्यक्षेत्र
$ wget http://www.nsnam.org/release/ns-allinone-3.22.tar.bz2
$ tar xjf ns-allinone-3.22.tar.bz2

यदि आप निर्देशिका में बदलते हैं एनएस-एलिनोन-3.22 आपको कई फ़ाइलें देखनी चाहिए:

$ एल.एस.
बेक स्थिरांक.py ns-3.22 README
build.py नेतनिम-3.105 pybindgen-0.16.0.886 util.py

अब आप आधार बनाने के लिए तैयार हैं एनएस- 3 वितरण.

डाउनलोडिंग एनएस- 3 का प्रयोग सेंकना
बेक वितरित एकीकरण और निर्माण के लिए एक उपकरण है, जिसे के लिए विकसित किया गया है एनएस- 3 परियोजना.
बेक का उपयोग विकास संस्करण लाने के लिए किया जा सकता है एनएस- 3 सॉफ्टवेयर, और डाउनलोड करने के लिए और
आधार पर एक्सटेंशन बनाएं एनएस- 3 वितरण, जैसे प्रत्यक्ष कोड निष्पादन
पर्यावरण, नेटवर्क सिमुलेशन क्रैडल, नए पायथन बाइंडिंग बनाने की क्षमता, और अन्य।

हाल ही में एनएस- 3 रिलीज़, बेक को रिलीज़ टारबॉल में शामिल किया गया है। विन्यास
जारी किए गए संस्करण में शामिल फ़ाइल किसी भी सॉफ़्टवेयर को डाउनलोड करने की अनुमति देगी
रिलीज़ के समय वर्तमान। उदाहरण के लिए, यह बेक का संस्करण है
के साथ वितरित किया गया एनएस- 3.21 रिलीज़ का उपयोग उसके लिए घटकों को लाने के लिए किया जा सकता है एनएस- 3 और
या पहले, लेकिन बाद के रिलीज़ के लिए घटकों को लाने के लिए इसका उपयोग नहीं किया जा सकता (जब तक कि
बेककॉन्फ.xml फ़ाइल अद्यतन है)।

आप इसकी नवीनतम प्रति भी प्राप्त कर सकते हैं सेंकना अपने लिनक्स में निम्नलिखित टाइप करके
शेल (यह मानते हुए कि आपने मर्क्यूरियल स्थापित किया है):

$ सीडी
$ एमकेडीआईआर कार्यक्षेत्र
$ सीडी कार्यक्षेत्र
$ एचजी क्लोन http://code.nsnam.org/bake

जैसे ही hg (Mercurial) कमांड निष्पादित होता है, आपको निम्न जैसा कुछ देखना चाहिए
प्रदर्शित,

...
गंतव्य निर्देशिका: सेंकना
सभी परिवर्तनों का अनुरोध
परिवर्तनसेट जोड़ना
मैनिफ़ेस्ट जोड़ना
फ़ाइल परिवर्तन जोड़ना
339 फ़ाइलों में 796 परिवर्तनों के साथ 63 परिवर्तन सेट जोड़े गए
शाखा डिफ़ॉल्ट पर अद्यतन किया जा रहा है
45 फ़ाइलें अद्यतन की गईं, 0 फ़ाइलें मर्ज की गईं, 0 फ़ाइलें हटाई गईं, 0 फ़ाइलें अनसुलझी हैं

क्लोन कमांड पूरा होने के बाद, आपके पास एक निर्देशिका होनी चाहिए जिसे कहा जाता है सेंकना, सामग्रियां
जिनमें से कुछ इस प्रकार दिखना चाहिए:

$ एल.एस.
बेक बेककॉन्फ.एक्सएमएल डॉक जनरेट-बाइनरी.पाइ कार्य
बेक.पी उदाहरण परीक्षण

ध्यान दें कि आपने वास्तव में कुछ पायथन स्क्रिप्ट और एक पायथन मॉड्यूल डाउनलोड किया है
सेंकना. अगला कदम उन स्क्रिप्ट्स को डाउनलोड करने और बनाने के लिए उपयोग करना होगा एनएस- 3
अपनी पसंद का वितरण.

कुछ कॉन्फ़िगरेशन लक्ष्य उपलब्ध हैं:

1. एनएस- 3.22: रिलीज़ के अनुरूप मॉड्यूल; यह समान घटकों को डाउनलोड करेगा
रिलीज टारबॉल के लिए.

2. एनएस-3-देव: एक समान मॉड्यूल लेकिन विकास कोड ट्री का उपयोग करना

3. एनएस-एलिनोन-3.22: वह मॉड्यूल जिसमें क्लिक जैसी अन्य वैकल्पिक सुविधाएं शामिल हैं
रूटिंग, ओपनफ्लो के लिए एनएस- 3, और नेटवर्क सिमुलेशन पालना

4. एनएस-3-एलिनोन: एलिनोन मॉड्यूल के जारी संस्करण के समान, लेकिन इसके लिए
विकास कोड.

का वर्तमान विकास स्नैपशॉट (अप्रकाशित)। एनएस- 3 पर पाया जा सकता है
http://code.nsnam.org/ns-3-dev/. डेवलपर्स इन रिपॉजिटरी को अंदर रखने का प्रयास करते हैं
सुसंगत, कार्यशील अवस्थाएँ लेकिन वे अप्रकाशित कोड वाले विकास क्षेत्र में हैं
मौजूद है, इसलिए यदि आपको आवश्यकता नहीं है तो आप आधिकारिक विज्ञप्ति के साथ बने रहने पर विचार कर सकते हैं
नव-प्रवर्तित सुविधाएँ.

आप रिपॉजिटरी सूची का निरीक्षण करके कोड का नवीनतम संस्करण पा सकते हैं
या पर जाकर "एनएस-3 रिलीज" वेब पेज और नवीनतम रिलीज़ लिंक पर क्लिक करें।
हम इस ट्यूटोरियल उदाहरण में आगे बढ़ेंगे एनएस- 3.22.

अब हम विभिन्न टुकड़ों को नीचे खींचने के लिए बेक टूल का उपयोग करने जा रहे हैं एनएस- 3 तुम होगे
का उपयोग कर रहे हैं। सबसे पहले, हम रनिंग बेक के बारे में एक शब्द कहेंगे।

बेक सोर्स पैकेज को सोर्स डायरेक्टरी में डाउनलोड करके और इंस्टॉल करके काम करता है
लाइब्रेरीज़ को एक बिल्ड निर्देशिका में। बेक को बाइनरी को संदर्भित करके चलाया जा सकता है, लेकिन यदि एक
जिस निर्देशिका में इसे डाउनलोड किया गया था, उसके बाहर से बेक चलाने का चयन करना उचित है
अपने पथ में बेक डालने के लिए, जैसे कि निम्नानुसार (लिनक्स बैश शेल उदाहरण)। सबसे पहले, बदलो
'बेक' निर्देशिका में, और फिर निम्नलिखित पर्यावरण चर सेट करें

$ निर्यात BAKE_HOME=`pwd`
$ निर्यात पथ=$पथ:$बेक_होम:$बेक_होम/बिल्ड/बिन
$ निर्यात PythonPATH=$PYTHONPATH:$BAKE_HOME:$BAKE_HOME/build/lib

यह बेकहोम प्रोग्राम को शेल के पथ में डाल देगा, और अन्य प्रोग्रामों को इसकी अनुमति देगा
बेक द्वारा निर्मित निष्पादनयोग्य और लाइब्रेरी खोजें। हालाँकि कई बेक उपयोग के मामले ऐसा नहीं करते हैं
ऊपर बताए अनुसार PATH और PythonPATH सेट करने की आवश्यकता है, ns-3-allinone का पूर्ण निर्माण (के साथ)
वैकल्पिक पैकेज) आम तौर पर करते हैं।

कार्यक्षेत्र निर्देशिका में कदम रखें और अपने शेल में निम्नलिखित टाइप करें:

$ ./bake.py कॉन्फिगर -e ns-3.22

इसके बाद, हम बेक से यह जांचने के लिए कहेंगे कि क्या हमारे पास विभिन्न घटकों को डाउनलोड करने के लिए पर्याप्त उपकरण हैं।
प्रकार

$ ./bake.py चेक

आपको निम्नलिखित जैसा कुछ देखना चाहिए,

> पायथन - ठीक है
> जीएनयू सी++ कंपाइलर - ठीक है
> मर्क्यूरियल - ठीक है
> सीवीएस - ठीक है
> जीआईटी - ठीक है
> बाज़ार - ठीक है
> टार टूल - ठीक है
> अनज़िप टूल - ठीक है
> अनरर टूल - गायब है
> 7z डेटा संपीड़न उपयोगिता - ठीक है
> XZ डेटा संपीड़न उपयोगिता - ठीक है
> बनाओ - ठीक है
> सीमेक - ठीक है
> पैच टूल - ठीक है
> ऑटोरेकॉन्फ टूल - ठीक है

> टूल के लिए खोजा गया पथ: /usr/lib64/qt-3.3/bin /usr/lib64/ccache
/ Usr / स्थानीय / बिन / bin / Usr / bin / usr / स्थानीय / sbin / usr / sbin / sbin
/होम/टॉम/बिन बिन

विशेष रूप से, मर्क्यूरियल, सीवीएस, जीआईटी और बाज़ार जैसे डाउनलोड टूल हमारे प्रमुख हैं
इस बिंदु पर चिंताएँ हैं, क्योंकि वे हमें कोड लाने की अनुमति देते हैं। कृपया अनुपलब्ध स्थापित करें
इस स्तर पर उपकरण, आपके सिस्टम के लिए सामान्य तरीके से (यदि आप सक्षम हैं), या संपर्क करें
आपके सिस्टम प्रशासक को इन उपकरणों को स्थापित करने की आवश्यकता है।

अगला, सॉफ़्टवेयर डाउनलोड करने का प्रयास करें:

$ ./bake.py डाउनलोड

कुछ इस प्रकार उत्पन्न होना चाहिए:

>> सिस्टम निर्भरता pygoocanvas की खोज - ठीक है
>> सिस्टम निर्भरता पायथन-डेव की खोज - ठीक है
>> सिस्टम निर्भरता पाइग्राफविज़ की खोज - ठीक है
>> pybindgen-0.16.0.886 डाउनलोड हो रहा है - ठीक है
>> सिस्टम निर्भरता g++ की खोज - ठीक है
>> सिस्टम निर्भरता qt4 की खोज - ठीक है
>> नेतनिम-3.105 डाउनलोड हो रहा है - ठीक है
>> एनएस-3.22 डाउनलोड हो रहा है - ठीक है

उपरोक्त से पता चलता है कि तीन स्रोत डाउनलोड किए गए हैं। जाँचें स्रोत डायरेक्टरी
अभी और टाइप करें ls; किसी को देखना चाहिए:

$ एल.एस.
netanim-3.105 एनएस-3.22 pybindgen-0.16.0.886

अब आप निर्माण के लिए तैयार हैं एनएस- 3 वितरण.

इमारत एनएस- 3
इमारत साथ में बिल्ड.py
जारी टारबॉल से काम करते समय, पहली बार जब आप निर्माण करते हैं एनएस- 3 प्रोजेक्ट आप कर सकते हैं
में पाए गए सुविधा प्रोग्राम का उपयोग करके निर्माण करें ऑल - इन - वन निर्देशिका। इस प्रोग्राम को कहा जाता है
बिल्ड.py. यह प्रोग्राम आपके लिए सबसे सामान्य रूप से प्रोजेक्ट कॉन्फ़िगर कर देगा
उपयोगी तरीका. हालाँकि, कृपया ध्यान दें कि अधिक उन्नत कॉन्फ़िगरेशन और इसके साथ काम करें एनएस- 3 मर्जी
आम तौर पर मूल निवासी का उपयोग करना शामिल होता है एनएस- 3 बिल्ड सिस्टम, वाफ़, को इसमें बाद में पेश किया जाएगा
ट्यूटोरियल।

यदि आपने टारबॉल का उपयोग करके डाउनलोड किया है तो आपके पास एक निर्देशिका होनी चाहिए जिसे कुछ इस तरह कहा जाता है
एनएस-एलिनोन-3.22 के तहत अपने ~/कार्यक्षेत्र निर्देशिका। निम्नलिखित टाइप करें:

$ ./build.py --enable-examples --enable-tests

क्योंकि हम इस ट्यूटोरियल में उदाहरणों और परीक्षणों के साथ काम कर रहे हैं, और क्योंकि वे नहीं हैं
डिफ़ॉल्ट रूप से निर्मित एनएस- 3, build.py के तर्क इसे हमारे लिए बनाने के लिए कहते हैं।
प्रोग्राम सभी उपलब्ध मॉड्यूल बनाने में भी चूक करता है। बाद में, आप निर्माण कर सकते हैं एनएस- 3
उदाहरणों और परीक्षणों के बिना, या उन मॉड्यूल को हटा दें जो आपके काम के लिए आवश्यक नहीं हैं,
यदि आप चाहते हैं।

बिल्ड स्क्रिप्ट के निर्माण के दौरान आपको बहुत सारे विशिष्ट कंपाइलर आउटपुट संदेश प्रदर्शित होते दिखाई देंगे
आपके द्वारा डाउनलोड किए गए विभिन्न टुकड़े। अंततः आपको निम्नलिखित देखना चाहिए:

वफ़: निर्देशिका `/path/to/workspace/ns-allinone-3.22/ns-3.22/build' को छोड़ना
'बिल्ड' सफलतापूर्वक समाप्त हुआ (6m25.032s)

मॉड्यूल निर्मित:
एंटीना एओडीवी अनुप्रयोग
ब्रिज बिल्डिंग कॉन्फिग-स्टोर
कोर सीएसएमए सीएसएमए-लेआउट
डीएसडीवी डीएसआर ऊर्जा
एफडी-नेट-डिवाइस फ्लो-मॉनिटर इंटरनेट
एलआर-डब्ल्यूपीएएन एलटीई जाल
गतिशीलता एमपीआई नेतनिम (कोई पायथन नहीं)
नेटवर्क निक्स-वेक्टर-रूटिंग ओएलएसआर
बिंदु-से-बिंदु बिंदु-से-बिंदु-लेआउट प्रसार
सिक्सलोपैन स्पेक्ट्रम आँकड़े
टैप-ब्रिज टेस्ट (कोई पायथन नहीं) टोपोलॉजी-रीड
यूएएन वर्चुअल-नेट-डिवाइस तरंग
वाईफ़ाई वाइमैक्स

मॉड्यूल नहीं बनाए गए (स्पष्टीकरण के लिए एनएस-3 ट्यूटोरियल देखें):
ब्राइट क्लिक ओपनफ्लो
विजुआलाइज़र

निर्देशिका छोड़ना `./ns-3.22'

निर्मित नहीं किए गए मॉड्यूल के बारे में भाग के संबंध में:

मॉड्यूल नहीं बनाए गए (स्पष्टीकरण के लिए एनएस-3 ट्यूटोरियल देखें):
ब्राइट क्लिक ओपनफ्लो
विजुआलाइज़र

इसका मतलब सिर्फ इतना है कि कुछ एनएस- 3 जिन मॉड्यूलों की निर्भरता बाहरी पुस्तकालयों पर है, वे नहीं हो सकते हैं
बनाया गया है, या कि कॉन्फ़िगरेशन ने विशेष रूप से उन्हें न बनाने के लिए कहा है। ऐसा होता है
इसका मतलब यह नहीं है कि सिम्युलेटर सफलतापूर्वक नहीं बना या यह गलत प्रदान करेगा
निर्मित के रूप में सूचीबद्ध मॉड्यूल के परिणाम।

इमारत साथ में सेंकना
यदि आपने प्रोजेक्ट रिपॉजिटरी से स्रोत कोड लाने के लिए उपरोक्त बेक का उपयोग किया है, तो आप इसे जारी रख सकते हैं
निर्माण के लिए इसका उपयोग करें एनएस- 3। प्रकार

$ ./bake.py बिल्ड

और आपको कुछ इस तरह देखना चाहिए:

>> बिल्डिंग पाइबिंडजेन-0.16.0.886 - ठीक है
>> बिल्डिंग नेतनिम-3.105 - ठीक है
>> बिल्डिंग एनएस-3.22 - ठीक है

सुझाव: इसलिए आप कर सकते हैं भी निष्पादन के छात्रों कदम, डाउनलोड और निर्माण by बुला 'bake.py तैनात करना'।

यदि कोई विफलता होती है, तो कृपया देखें कि निम्नलिखित आदेश क्या बताता है
आप; यह किसी लुप्त निर्भरता का संकेत दे सकता है:

$ ./bake.py शो

यह उन पैकेजों की विभिन्न निर्भरताओं को सूचीबद्ध करेगा जिन्हें आप बनाने का प्रयास कर रहे हैं।

इमारत साथ में waf
इस बिंदु तक, हमने या तो उपयोग किया है बिल्ड.py स्क्रिप्ट, या सेंकना उपकरण, पाने के लिए
निर्माण से शुरुआत हुई एनएस- 3. ये उपकरण भवन निर्माण के लिए उपयोगी हैं एनएस- 3 और समर्थन कर रहा है
पुस्तकालय, और वे इसमें कॉल करते हैं एनएस- 3 करने के लिए वफ़ बिल्ड टूल को कॉल करने के लिए निर्देशिका
वास्तविक भवन. अधिकांश उपयोगकर्ता जल्दी से कॉन्फ़िगर करने के लिए सीधे वफ़ का उपयोग करने के लिए संक्रमण करते हैं
निर्माण एनएस- 3. इसलिए, आगे बढ़ने के लिए, कृपया अपनी कार्यशील निर्देशिका को इसमें बदलें एनएस- 3 डायरेक्टरी
जिसे आपने प्रारंभ में बनाया है।

इस बिंदु पर इसकी सख्ती से आवश्यकता नहीं है, लेकिन थोड़ा सा बदलाव करना मूल्यवान होगा
और देखें कि प्रोजेक्ट की कॉन्फ़िगरेशन में परिवर्तन कैसे करें। शायद सबसे ज्यादा
उपयोगी कॉन्फ़िगरेशन परिवर्तन जो आप कर सकते हैं वह इसका अनुकूलित संस्करण बनाना होगा
कोड. डिफ़ॉल्ट रूप से आपने डिबग संस्करण बनाने के लिए अपने प्रोजेक्ट को कॉन्फ़िगर किया है। चलिए बताते हैं
एक अनुकूलित निर्माण करने की परियोजना। वफ़ को समझाने के लिए कि उसे अनुकूलित करना चाहिए
ऐसे बिल्ड जिनमें उदाहरण और परीक्षण शामिल हैं, आपको निम्नलिखित निष्पादित करने की आवश्यकता होगी
आदेश:

$ ./waf साफ़
$ ./waf --बिल्ड-प्रोफ़ाइल=अनुकूलित --सक्षम-उदाहरण --सक्षम-परीक्षण कॉन्फ़िगर करें

यह वफ़ को स्थानीय निर्देशिका से बाहर चलाता है (जो आपके लिए एक सुविधा के रूप में प्रदान की जाती है)।
पिछले निर्माण को साफ करने के लिए पहला आदेश आमतौर पर सख्ती से आवश्यक नहीं है
अच्छा अभ्यास है (लेकिन देखें बनाएँ प्रोफाइल, नीचे); यह पहले से निर्मित को हटा देगा
निर्देशिका में लाइब्रेरी और ऑब्जेक्ट फ़ाइलें मिलीं निर्माण /. जब प्रोजेक्ट पुन: कॉन्फ़िगर किया जाता है
और बिल्ड सिस्टम विभिन्न निर्भरताओं की जांच करता है, आपको वह आउटपुट देखना चाहिए जो दिखता है
निम्नलिखित के समान:

शीर्ष पर सेट करना : .
के लिए प्रस्थान : निर्माण
'जीसीसी' (सी कंपाइलर) की जांच हो रही है: /usr/bin/gcc
सीसी संस्करण की जाँच हो रही है: 4.2.1
'g++' (c++ कंपाइलर) की जाँच हो रही है: /usr/bin/g++
चेकिंग बूस्ट में शामिल हैं: 1_46_1
बूस्ट लिब की जाँच कर रहा है: ठीक है
बूस्ट लिंकेज की जाँच कर रहा है: ठीक है
क्लिक स्थान की जाँच की जा रही है: नहीं मिला
प्रोग्राम pkg-config की जाँच कर रहा है: /sw/bin/pkg-config
'gtk+-2.0' >= 2.12 की जाँच की जा रही है: हाँ
'libxml-2.0' >= 2.7 की जाँच हो रही है: हाँ
uint128_t प्रकार की जाँच की जा रही है: नहीं मिला
__uint128_t प्रकार की जाँच की जा रही है: हाँ
उच्च परिशुद्धता कार्यान्वयन की जाँच करना: 128-बिट पूर्णांक (डिफ़ॉल्ट)
हेडर stdint.h की जाँच कर रहा है: हाँ
हेडर inttypes.h की जाँच की जा रही है: हाँ
हेडर sys/inttypes.h की जाँच की जा रही है: नहीं मिला
हेडर sys/types.h की जाँच कर रहा है: हाँ
हेडर sys/stat.h की जाँच कर रहा है: हाँ
हेडर के लिए जाँच की जा रही है dirent.h : हाँ
हेडर stdlib.h की जाँच कर रहा है: हाँ
हेडर सिग्नल की जाँच की जा रही है.h: हाँ
हेडर pthread.h की जाँच कर रहा है: हाँ
हेडर stdint.h की जाँच कर रहा है: हाँ
हेडर inttypes.h की जाँच की जा रही है: हाँ
हेडर sys/inttypes.h की जाँच की जा रही है: नहीं मिला
लाइब्रेरी आरटी की जाँच की जा रही है: नहीं मिला
हेडर नेटपैकेट/पैकेट.एच की जांच की जा रही है: नहीं मिला
हेडर sys/ioctl.h की जाँच कर रहा है: हाँ
हेडर नेट/आईएफ.एच की जांच की जा रही है: नहीं मिला
हेडर नेट/ईथरनेट.एच के लिए जाँच की जा रही है: हाँ
हेडर linux/if_tun.h की जाँच की जा रही है: नहीं मिला
हेडर नेटपैकेट/पैकेट.एच की जांच की जा रही है: नहीं मिला
एनएससी स्थान की जांच की जा रही है: नहीं मिला
'mpic++' की जाँच हो रही है: हाँ
'Sqlite3' की जाँच हो रही है: हाँ
हेडर linux/if_tun.h की जाँच की जा रही है: नहीं मिला
प्रोग्राम sudo के लिए जाँच कर रहा है: /usr/bin/sudo
प्रोग्राम वालग्रिंड की जाँच हो रही है: /sw/bin/valgrind
'जीएसएल' की जाँच हो रही है: हाँ
संकलन ध्वज की जाँच -Wno-error=deprecated-d... समर्थन : ठीक है
संकलन ध्वज की जाँच -Wno-error=deprecated-d... समर्थन : ठीक है
संकलन ध्वज की जाँच -fstrict-aliasing... समर्थन : ठीक है
संकलन ध्वज की जाँच -fstrict-aliasing... समर्थन : ठीक है
संकलन ध्वज की जाँच -Wstrict-aliasing... समर्थन: ठीक है
संकलन ध्वज की जाँच -Wstrict-aliasing... समर्थन: ठीक है
प्रोग्राम डॉक्सीजन की जाँच की जा रही है: /usr/local/bin/dxygen
---- वैकल्पिक एनएस-3 सुविधाओं का सारांश:
प्रोफ़ाइल बनाएँ: डीबग करें
निर्देशिका बनाएँ: build
पायथन बाइंडिंग्स: सक्षम
ब्राइट एकीकरण: सक्षम नहीं (BRITE सक्षम नहीं (विकल्प देखें --with-brite))
एनएस-3 क्लिक एकीकरण: सक्षम नहीं (एनएसक्लिक सक्षम नहीं (विकल्प देखें --साथ-एनएसक्लिक))
GtkConfigStore : सक्षम
XmlIo : सक्षम
सूत्रण आदिम: सक्षम
रीयल टाइम सिम्युलेटर: सक्षम (librt उपलब्ध नहीं है)
अनुकरणीय नेट डिवाइस: सक्षम ( शामिल नहीं पाया गया)
फ़ाइल डिस्क्रिप्टर नेटडिवाइस: सक्षम
FdNetDevice पर टैप करें: सक्षम नहीं है (linux/if_tun.h की आवश्यकता है)
अनुकरण FdNetDevice: सक्षम नहीं (netpacket/packet.h की आवश्यकता है)
प्लैनेटलैब FdNetDevice: सक्षम नहीं (प्लैनेटलैब ऑपरेटिंग सिस्टम का पता नहीं चला (विकल्प देखें --force-planetlab))
नेटवर्क सिमुलेशन पालना: सक्षम नहीं (NSC नहीं मिला (विकल्प देखें --with-nsc))
एमपीआई समर्थन: सक्षम
एनएस-3 ओपनफ्लो एकीकरण: सक्षम नहीं (आवश्यक बूस्ट लाइब्रेरी नहीं मिली, अनुपलब्ध: सिस्टम, सिग्नल, फ़ाइल सिस्टम)
SQLite आँकड़े डेटा आउटपुट: सक्षम
ब्रिज टैप करें: सक्षम नहीं ( शामिल नहीं पाया गया)
पायविज़ विज़ुअलाइज़र: सक्षम
suid बिट सेट करने के लिए sudo का उपयोग करें: सक्षम नहीं (विकल्प --enable-sudo चयनित नहीं)
परीक्षण बनाएँ: सक्षम
उदाहरण बनाएँ: सक्षम
जीएनयू वैज्ञानिक पुस्तकालय (जीएसएल): सक्षम
'कॉन्फ़िगर' सफलतापूर्वक समाप्त हुआ (1.944 सेकंड)

उपरोक्त आउटपुट के अंतिम भाग पर ध्यान दें। कुछ एनएस- 3 विकल्प डिफ़ॉल्ट रूप से सक्षम नहीं हैं या
ठीक से काम करने के लिए अंतर्निहित सिस्टम से समर्थन की आवश्यकता होती है। उदाहरण के लिए, सक्षम करने के लिए
XmlTo, लाइब्रेरी libxml-2.0 सिस्टम पर अवश्य मिलनी चाहिए। यदि यह पुस्तकालय नहीं होता
पाया, संगत एनएस- 3 सुविधा सक्षम नहीं होगी और एक संदेश होगा
प्रदर्शित. आगे ध्यान दें कि प्रोग्राम का उपयोग करने की एक सुविधा है sudo सूद सेट करने के लिए
कुछ निश्चित कार्यक्रम. यह डिफ़ॉल्ट रूप से सक्षम नहीं है और इसलिए यह सुविधा रिपोर्ट की गई है
जैसा कि "सक्षम नहीं है।"

अब आगे बढ़ें और डिबग बिल्ड पर वापस जाएं जिसमें उदाहरण और परीक्षण शामिल हैं।

$ ./waf साफ़
$ ./waf --build-profile=debug --enable-examples --enable-tests कॉन्फ़िगर करें

बिल्ड सिस्टम अब कॉन्फ़िगर हो गया है और आप इसका डिबग संस्करण बना सकते हैं एनएस- 3
केवल टाइप करके प्रोग्राम

$ ./वफ़ा

ठीक है, क्षमा करें, मैंने आपसे इसका निर्माण कराया एनएस- 3 सिस्टम का दो बार हिस्सा, लेकिन अब आप जानते हैं कि कैसे करना है
कॉन्फ़िगरेशन बदलें और अनुकूलित कोड बनाएं।

ऊपर चर्चा की गई बिल्डहोम स्क्रिप्ट भी इसका समर्थन करती है --सक्षम-उदाहरण और सक्षम-परीक्षण
तर्क, लेकिन सामान्य तौर पर, अन्य वफ़ विकल्पों का सीधे समर्थन नहीं करता है; उदाहरण के लिए, यह
काम नहीं कर पाया:

$ ./build.py --अक्षम-पायथन

में परिणाम होगा

build.py: त्रुटि: ऐसा कोई विकल्प नहीं: --disable-python

हालाँकि, विशेष ऑपरेटर -- WAF के माध्यम से अतिरिक्त विकल्प पारित करने के लिए उपयोग किया जा सकता है, इसलिए
उपरोक्त के बजाय, निम्नलिखित काम करेगा:

$ ./build.py -- --अक्षम-पायथन

क्योंकि यह अंतर्निहित कमांड उत्पन्न करता है ./वफ़ कॉन्फ़िगर --अक्षम-पायथन.

यहां वफ़ के बारे में कुछ और परिचयात्मक सुझाव दिए गए हैं।

कॉन्फ़िगर बनाम बनाएँ
कुछ वफ़ कमांड केवल कॉन्फ़िगर चरण के दौरान ही सार्थक होते हैं और कुछ कमांड होते हैं
निर्माण चरण में मान्य. उदाहरण के लिए, यदि आप अनुकरण सुविधाओं का उपयोग करना चाहते हैं
एनएस- 3, हो सकता है कि आप ऊपर बताए अनुसार sudo का उपयोग करके suid बिट सेट करना सक्षम करना चाहें। यह
यह एक कॉन्फ़िगरेशन-टाइम कमांड बन जाता है, और इसलिए आप इसका उपयोग करके पुन: कॉन्फ़िगर कर सकते हैं
निम्नलिखित आदेश जिसमें उदाहरण और परीक्षण भी शामिल हैं।

$ ./waf कॉन्फ़िगर --enable-sudo --enable-examples --enable-tests

यदि आप ऐसा करते हैं, तो वफ़ ने सॉकेट क्रिएटर प्रोग्राम को बदलने के लिए sudo चलाया होगा
रूट के रूप में चलाने के लिए इम्यूलेशन कोड।

वफ़ में कई अन्य कॉन्फ़िगर- और बिल्ड-टाइम विकल्प उपलब्ध हैं। इनका पता लगाने के लिए
विकल्प, प्रकार:

$ ./waf --मदद

हम अगले भाग में परीक्षण-संबंधित कुछ आदेशों का उपयोग करेंगे।

बनाएँ प्रोफाइल
हमने पहले ही देखा कि आप WAF को कैसे कॉन्फ़िगर कर सकते हैं डिबग or अनुकूलित बनाता है:

$ ./waf --build-profile=debug

एक मध्यवर्ती बिल्ड प्रोफ़ाइल भी है, और . -d के लिए एक पर्याय है
--बिल्ड-प्रोफ़ाइल.

डिफ़ॉल्ट रूप से Waf बिल्ड कलाकृतियों को इसमें डालता है निर्माण निर्देशिका। आप एक निर्दिष्ट कर सकते हैं
के साथ भिन्न आउटपुट निर्देशिका --बाहर विकल्प, उदा

$ ./waf कॉन्फ़िगर --out=foo

इसे बिल्ड प्रोफ़ाइल के साथ संयोजित करने से आप विभिन्न संकलन विकल्पों के बीच स्विच कर सकते हैं
साफ़ तरीके से:

$ ./waf कॉन्फ़िगर --बिल्ड-प्रोफाइल=डीबग --आउट=बिल्ड/डीबग
$ ./waf बिल्ड
...
$ ./waf कॉन्फ़िगर --बिल्ड-प्रोफ़ाइल=अनुकूलित --आउट=बिल्ड/अनुकूलित
$ ./waf बिल्ड
...

यह आपको हमेशा अंतिम को ओवरराइट करने के बजाय एकाधिक बिल्ड के साथ काम करने की अनुमति देता है
निर्माण। जब आप स्विच करते हैं, तो Waf पुनः संकलित करने के बजाय केवल वही संकलित करेगा जो उसे करना है
सब कुछ।

जब आप बिल्ड प्रोफ़ाइल को इस तरह से स्विच करते हैं, तो आपको इसे देने में सावधानी बरतनी होगी
हर बार कॉन्फ़िगरेशन पैरामीटर। कुछ वातावरण को परिभाषित करना सुविधाजनक हो सकता है
गलतियों से बचने में आपकी सहायता के लिए चर:

$ निर्यात NS3CONFIG='-सक्षम-उदाहरण--सक्षम-परीक्षण'
$ निर्यात NS3DEBUG='-बिल्ड-प्रोफ़ाइल=डीबग-आउट=बिल्ड/डीबग'
$ निर्यात NS3OPT=='-बिल्ड-प्रोफ़ाइल=अनुकूलित --आउट=बिल्ड/अनुकूलित'

$ ./waf कॉन्फ़िगर $NS3CONFIG $NS3DEBUG
$ ./waf बिल्ड
...
$ ./waf कॉन्फ़िगर $NS3CONFIG $NS3OPT
$ ./waf बिल्ड

संकलनकर्ता
उपरोक्त उदाहरणों में, Waf GCC C++ कंपाइलर का उपयोग करता है, जी ++, निर्माण के लिए एनएस- 3. हालांकि,
इसे परिभाषित करके Waf द्वारा प्रयुक्त C++ कंपाइलर को बदलना संभव है सीएक्सएक्स वातावरण
चर। उदाहरण के लिए, क्लैंग सी++ कंपाइलर का उपयोग करने के लिए, क्लैंग++,

$ CXX='clang++' ./waf कॉन्फ़िगर करें
$ ./waf बिल्ड

कोई भी वितरित संकलन करने के लिए वफ़ की स्थापना कर सकता है व्याकुल करना एक समान तरीके से:

$ CXX='distcc g++' ./waf कॉन्फ़िगर करें
$ ./waf बिल्ड

पर और जानकारी व्याकुल करना और वितरित संकलन इस पर पाया जा सकता है परियोजना पृष्ठ के अंतर्गत
दस्तावेज़ीकरण अनुभाग.

स्थापित करें
सिस्टम पर विभिन्न स्थानों पर लाइब्रेरी स्थापित करने के लिए वफ़ का उपयोग किया जा सकता है। डिफ़ॉल्ट
वह स्थान जहां पुस्तकालय और निष्पादन योग्य बनाए गए हैं निर्माण निर्देशिका, और क्योंकि
वफ़ इन पुस्तकालयों और निष्पादनयोग्यों का स्थान जानता है, इसे स्थापित करना आवश्यक नहीं है
अन्यत्र पुस्तकालय।

यदि उपयोगकर्ता बिल्ड निर्देशिका के बाहर चीजों को स्थापित करना चुनते हैं, तो उपयोगकर्ता जारी कर सकते हैं
./वफ़ स्थापित आज्ञा। डिफ़ॉल्ट रूप से, इंस्टॉलेशन के लिए उपसर्ग है / Usr / स्थानीय, इतना ./वफ़
स्थापित में प्रोग्राम इंस्टॉल करेगा / Usr / स्थानीय / बिन, पुस्तकालयों में / Usr / स्थानीय / lib, तथा
में शीर्षलेख /usr/स्थानीय/शामिल करें. इंस्टॉल करने के लिए आमतौर पर सुपरयूज़र विशेषाधिकारों की आवश्यकता होती है
डिफ़ॉल्ट उपसर्ग, इसलिए सामान्य आदेश होगा sudo ./वफ़ स्थापित. दौड़ते समय
Waf के साथ प्रोग्राम, Waf पहले बिल्ड निर्देशिका में साझा लाइब्रेरी का उपयोग करना पसंद करेंगे,
फिर स्थानीय परिवेश में कॉन्फ़िगर किए गए पुस्तकालय पथ में पुस्तकालयों की तलाश करेगा। इसलिए
सिस्टम में लाइब्रेरी स्थापित करते समय, यह जांचना अच्छा अभ्यास है कि क्या इरादा है
पुस्तकालयों का उपयोग किया जा रहा है।

उपयोगकर्ता पास करके किसी भिन्न उपसर्ग पर इंस्टॉल करना चुन सकते हैं उपसर्ग पर विकल्प
समय कॉन्फ़िगर करें, जैसे:

./waf कॉन्फ़िगर --prefix=/opt/local

यदि बाद में निर्माण के बाद उपयोगकर्ता जारी करता है ./वफ़ स्थापित आदेश, उपसर्ग /ऑप्ट/स्थानीय
इस्तेमाल किया जाएगा।

RSI ./वफ़ स्वच्छ यदि वफ़ होगा तो प्रोजेक्ट को पुन: कॉन्फ़िगर करने से पहले कमांड का उपयोग किया जाना चाहिए
किसी भिन्न उपसर्ग पर चीज़ों को स्थापित करने के लिए उपयोग किया जाता है।

संक्षेप में, कॉल करना आवश्यक नहीं है ./वफ़ स्थापित उपयोग करने के लिए एनएस- 3. अधिकांश उपयोगकर्ता नहीं करेंगे
इस आदेश की आवश्यकता है क्योंकि Waf वर्तमान पुस्तकालयों को उठाएगा निर्माण निर्देशिका,
लेकिन कुछ उपयोगकर्ताओं को यह उपयोगी लग सकता है यदि उनके उपयोग के मामले में बाहर के कार्यक्रमों के साथ काम करना शामिल है
का एनएस- 3 निर्देशिका.

एक waf
के शीर्ष स्तर पर केवल एक वफ़ स्क्रिप्ट है एनएस- 3 स्रोत वृक्ष. जैसे आप काम करते हैं, आप
हो सकता है कि आप अपना बहुत सारा समय व्यतीत करते हुए पाएं खरोंचना/, या गहराई में स्रोत/..., और इसकी आवश्यकता है
वफ़ का आह्वान करें। आप बस यह याद रख सकते हैं कि आप कहां हैं, और वफ़ का आह्वान इस तरह कर सकते हैं:

$ ../../../waf ...

लेकिन यह थकाऊ है, और त्रुटि प्रवण है, और बेहतर समाधान भी हैं।

अगर आपके पास पूरा है एनएस- 3 यह छोटा सा रत्न भंडार एक शुरुआत है:

$ सीडी $(एचजी रूट) && ./waf ...

इसे शेल फ़ंक्शन के रूप में परिभाषित करना और भी बेहतर है:

$ फ़ंक्शन वफ़ { सीडी $(एचजी रूट) && ./waf $* ; }

$ वफ़ निर्माण

यदि आपके पास केवल टारबॉल है, तो एक पर्यावरण चर मदद कर सकता है:

$ निर्यात NS3DIR='$PWD'
$ फ़ंक्शन वफ़ { सीडी $NS3DIR && ./waf $* ; }

$ सीडी स्क्रैच
$ वफ़ निर्माण

किसी मॉड्यूल निर्देशिका में कोई मामूली चीज़ जोड़ना आकर्षक हो सकता है WAF की तर्ज पर स्क्रिप्ट
कार्यकारी ../../waf. कृपया ऐसा न करें. यह नए लोगों के लिए भ्रमित करने वाला है, और जब इसे खराब तरीके से किया जाता है
सूक्ष्म निर्माण त्रुटियों की ओर ले जाता है। उपरोक्त समाधान ही रास्ता है।

परीक्षण एनएस- 3
आप का यूनिट परीक्षण चला सकते हैं एनएस- 3 चलाकर वितरण ./test.py -c मूल
स्क्रिप्ट:

$ ./test.py -सी कोर

ये परीक्षण वफ़ द्वारा समानांतर रूप से चलाए जाते हैं। अंततः आपको यह कहने वाली एक रिपोर्ट देखनी चाहिए

92 में से 92 परीक्षण उत्तीर्ण हुए (92 उत्तीर्ण, 0 असफल, 0 क्रैश, 0 वालग्रिंड त्रुटियाँ)

यह महत्वपूर्ण संदेश है.

आप वफ़ और प्रत्येक परीक्षण को क्रियान्वित करने वाले परीक्षण धावक से सारांश आउटपुट भी देखेंगे,
जो वास्तव में कुछ इस तरह दिखेगा:

वफ़: निर्देशिका `/path/to/workspace/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/path/to/workspace/ns-3-allinone/ns-3-dev/build' को छोड़ना
'निर्माण' सफलतापूर्वक समाप्त हुआ (1.799 सेकंड)

मॉड्यूल निर्मित:
एओडीवी एप्लीकेशन ब्रिज
कॉन्फिग-स्टोर कोर पर क्लिक करें
सीएसएमए सीएसएमए-लेआउट डीएसडीवी
एमु ऊर्जा प्रवाह-मॉनिटर
इंटरनेट एलटीई जाल
गतिशीलता एमपीआई नेतानिम
नेटवर्क निक्स-वेक्टर-रूटिंग एनएस3टीसीपी
एनएस3वाईफाई ओएलएसआर ओपनफ्लो
बिंदु-से-बिंदु बिंदु-से-बिंदु-लेआउट प्रसार
स्पेक्ट्रम आँकड़े टैप-ब्रिज
टेम्पलेट परीक्षण उपकरण
टोपोलॉजी-यूएएन वर्चुअल-नेट-डिवाइस पढ़ें
विज़ुअलाइज़र वाईफ़ाई वाइमैक्स

पास: TestSuite ns3-वाईफ़ाई-हस्तक्षेप
पास: टेस्टसुइट हिस्टोग्राम

...

पास: टेस्टसुइट ऑब्जेक्ट
पास: टेस्टसुइट रैंडम-नंबर-जनरेटर
92 में से 92 परीक्षण उत्तीर्ण हुए (92 उत्तीर्ण, 0 असफल, 0 क्रैश, 0 वालग्रिंड त्रुटियाँ)

यह कमांड आम तौर पर उपयोगकर्ताओं द्वारा त्वरित रूप से सत्यापित करने के लिए चलाया जाता है एनएस- 3 वितरण है
सही ढंग से बनाया गया. (के आदेश पर ध्यान दें उत्तीर्ण: ... पंक्तियाँ भिन्न-भिन्न हो सकती हैं, जो ठीक है। क्या है?
महत्वपूर्ण यह है कि अंत में सारांश पंक्ति यह बताती है कि सभी परीक्षण उत्तीर्ण हुए हैं; कोई भी असफल नहीं हुआ या
दुर्घटनाग्रस्त हो गया।)

रनिंग a लिपि
हम आम तौर पर वफ़ के नियंत्रण में स्क्रिप्ट चलाते हैं। यह बिल्ड सिस्टम को सुनिश्चित करने की अनुमति देता है
कि साझा लाइब्रेरी पथ सही ढंग से सेट हैं और लाइब्रेरी यहां उपलब्ध हैं
चलाने का समय. किसी प्रोग्राम को चलाने के लिए, बस इसका उपयोग करें --Daud वफ़ में विकल्प। चलिए चलाते हैं एनएस- 3
निम्नलिखित टाइप करके सर्वव्यापी हैलो वर्ल्ड प्रोग्राम के समतुल्य:

$ ./waf--हैलो-सिम्युलेटर चलाएँ

Waf पहले यह सुनिश्चित करने के लिए जाँच करता है कि प्रोग्राम सही ढंग से बनाया गया है और यदि कोई बिल्ड निष्पादित करता है
आवश्यक। Waf फिर प्रोग्राम निष्पादित करता है, जो निम्नलिखित आउटपुट उत्पन्न करता है।

नमस्ते सिम्युलेटर

बधाई हो! अब आप एनएस-3 उपयोगकर्ता हैं!

क्या do I do if I नहीं है देखना la आउटपुट?

यदि आप वफ़ संदेश देखते हैं तो यह संकेत मिलता है कि निर्माण सफलतापूर्वक पूरा हो गया था, लेकिन नहीं
"हैलो सिम्युलेटर" आउटपुट देखें, संभावना है कि आपने अपना बिल्ड मोड स्विच कर लिया है
अनुकूलित में इमारत साथ में waf अनुभाग, लेकिन वापस परिवर्तन से चूक गए हैं डिबग मोड।
इस ट्यूटोरियल में उपयोग किए गए सभी कंसोल आउटपुट एक विशेष का उपयोग करते हैं एनएस- 3 लॉगिंग घटक वह
उपयोगकर्ता संदेशों को कंसोल पर प्रिंट करने के लिए उपयोगी है। इस घटक से आउटपुट है
जब आप अनुकूलित कोड संकलित करते हैं तो स्वचालित रूप से अक्षम हो जाता है - यह "अनुकूलित" होता है। अगर आप
"हैलो सिम्युलेटर" आउटपुट न देखें, निम्न टाइप करें:

$ ./waf कॉन्फ़िगर --बिल्ड-प्रोफ़ाइल=डीबग --सक्षम-उदाहरण --सक्षम-परीक्षण

वफ़ को इसके डिबग संस्करण बनाने के लिए कहने के लिए एनएस- 3 ऐसे प्रोग्राम जिनमें उदाहरण शामिल हैं
और परीक्षण. आपको अभी भी टाइप करके कोड का वास्तविक डिबग संस्करण बनाना होगा

$ ./वफ़ा

अब, यदि आप चलाते हैं हैलो-सिम्युलेटर प्रोग्राम, आपको अपेक्षित आउटपुट देखना चाहिए।

कार्यक्रम तर्क
किसी को कमांड लाइन तर्क फ़ीड करने के लिए एनएस- 3 प्रोग्राम इस पैटर्न का उपयोग करें:

$ ./waf --run --कमांड-टेम्पलेट='%s "

अपने प्रोग्राम का नाम प्रतिस्थापित करें , और इसके लिए तर्क ।
--कमांड-टेम्पलेट वफ़ का तर्क मूल रूप से वास्तविक निर्माण का एक नुस्खा है
प्रोग्राम को निष्पादित करने के लिए कमांड लाइन Waf का उपयोग करना चाहिए। वफ़ जाँचता है कि निर्माण क्या है
पूर्ण, साझा लाइब्रेरी पथ सेट करता है, फिर दिए गए का उपयोग करके निष्पादन योग्य को आमंत्रित करता है
कमांड लाइन टेम्प्लेट, प्रोग्राम का नाम सम्मिलित करते हुए %s प्लेसहोल्डर. (मैं यह स्वीकार करता हूं
थोड़ा अजीब है, लेकिन ऐसा ही है। पैच का स्वागत है!)

एक अन्य विशेष रूप से उपयोगी उदाहरण स्वयं परीक्षण सूट चलाना है। आइए मान लें कि ए
मेरा परीक्षण परीक्षण सूट मौजूद है (यह नहीं है)। ऊपर, हमने इसका उपयोग किया ./test.py संपूर्ण चलाने के लिए स्क्रिप्ट
वास्तविक परीक्षण कार्यक्रम को बार-बार लागू करके, समानांतर में कई परीक्षण किए गए, परीक्षण धावक.
आह्वान करने के लिए परीक्षण धावक सीधे एकल परीक्षण के लिए:

$ ./waf --run test-runner --command-template='%s --suite=mytest --verbose'

यह तर्कों को पास कर देता है परीक्षण धावक कार्यक्रम. तब से मेरा परीक्षण अस्तित्व में नहीं है, ए
त्रुटि संदेश उत्पन्न होगा. उपलब्ध प्रिंट करने के लिए परीक्षण धावक विकल्प हैं:

$ ./waf --run test-runner --command-template='%s --help'

डीबगिंग
चलाने के लिए एनएस- 3 किसी अन्य उपयोगिता के नियंत्रण में प्रोग्राम, जैसे डिबगर (जैसे जी.डी.बी.)
या मेमोरी चेकर (जैसे वालग्रिंड), आप एक समान का उपयोग करते हैं --कमांड-टेम्पलेट='...' प्रपत्र.

उदाहरण के लिए, अपना चलाने के लिए एनएस- 3 कार्यक्रम हैलो-सिम्युलेटर तर्कों के साथ नीचे
जी.डी.बी. डीबगर:

$ ./waf --run=हैलो-सिम्युलेटर --कमांड-टेम्पलेट='gdb %s --args "

गौर करें कि द एनएस- 3 प्रोग्राम का नाम इसके साथ जाता है --Daud तर्क, और नियंत्रण उपयोगिता
(यहाँ जी.डी.बी.) में पहला टोकन है --कमांड-टेम्पलेट बहस। --आर्ग्स बताता है जी.डी.बी.
कि कमांड लाइन का शेष भाग "निचले" प्रोग्राम से संबंधित है। (कुछ जी.डी.बी.'s
समझ में नहीं आता --आर्ग्स विशेषता। इस मामले में, प्रोग्राम तर्कों को हटा दें
--कमांड-टेम्पलेट, और का उपयोग करें जी.डी.बी. आदेश सेट आर्ग.)

हम डिबगर के अंतर्गत परीक्षण चलाने के लिए इस रेसिपी और पिछले वाले को जोड़ सकते हैं:

$ ./waf --run test-runner --command-template='gdb %s --args --suite=mytest --verbose'

काम कर रहे निर्देशिका
वफ़ को शीर्ष पर स्थित अपने स्थान से चलने की आवश्यकता है एनएस- 3 पेड़। यह काम बन जाता है
निर्देशिका जहां आउटपुट फ़ाइलें लिखी जाएंगी। लेकिन क्या होगा यदि आप उन्हें यथावत रखना चाहते हैं
la एनएस- 3 स्रोत वृक्ष? उपयोग --सीडब्ल्यूडी तर्क:

$ ./waf --cwd=...

अपनी कार्यशील निर्देशिका से शुरुआत करना अधिक सुविधाजनक हो सकता है जहां आप आउटपुट चाहते हैं
फ़ाइलें, जिस स्थिति में थोड़ा संकेत मदद कर सकता है:

$ फ़ंक्शन वफ़ {
सीडब्ल्यूडी='$पीडब्ल्यूडी'
सीडी $NS3DIR >/dev/null
./waf --cwd='$CWD' $*
सीडी - >/dev/null
}

पिछले संस्करण का यह अलंकरण वर्तमान कार्यशील निर्देशिका को सहेजता है, cdका है
Waf निर्देशिका, फिर Waf को कार्यशील निर्देशिका को बदलने का निर्देश देती है वापस बचाए गए को
प्रोग्राम चलाने से पहले वर्तमान कार्यशील निर्देशिका।

वैचारिक अवलोकन

वास्तव में देखना या लिखना शुरू करने से पहले सबसे पहली चीज़ जो हमें करने की ज़रूरत है एनएस- 3 कोड है
प्रणाली में कुछ मूल अवधारणाओं और अमूर्तताओं की व्याख्या करें। इसमें से बहुत कुछ सामने आ सकता है
कुछ लोगों के लिए यह स्पष्ट रूप से स्पष्ट है, लेकिन हम इसे पढ़ने के लिए समय निकालने की सलाह देते हैं
अनुभाग केवल यह सुनिश्चित करने के लिए कि आप एक मजबूत आधार पर शुरुआत कर रहे हैं।

कुंजी कपोल-कल्पना
इस अनुभाग में, हम कुछ ऐसे शब्दों की समीक्षा करेंगे जो आमतौर पर नेटवर्किंग में उपयोग किए जाते हैं, लेकिन एक हैं
में विशिष्ट अर्थ एनएस- 3.

आसंधि
इंटरनेट शब्दजाल में, एक कंप्यूटिंग डिवाइस जो किसी नेटवर्क से जुड़ती है उसे कहा जाता है मेजबान or
कभी-कभी एक समाप्त प्रणाली। इसलिये एनएस- 3 एक नेटवर्क सिम्युलेटर, विशेष रूप से नहीं
इंटरनेट सिम्युलेटर, हम जानबूझकर होस्ट शब्द का उपयोग नहीं करते हैं क्योंकि यह निकट है
इंटरनेट और उसके प्रोटोकॉल से संबद्ध। इसके बजाय, हम अधिक सामान्य शब्द का भी उपयोग करते हैं
ग्राफ़ थ्योरी में उत्पन्न होने वाले अन्य सिमुलेटरों द्वारा उपयोग किया जाता है --- नोड.

In एनएस- 3 मूल कंप्यूटिंग डिवाइस एब्स्ट्रैक्शन को नोड कहा जाता है। यह अमूर्तन है
वर्ग द्वारा C++ में दर्शाया गया है आसंधि। आसंधि क्लास प्रबंधन के लिए तरीके प्रदान करता है
सिमुलेशन में कंप्यूटिंग उपकरणों का प्रतिनिधित्व।

आपको एक के बारे में सोचना चाहिए आसंधि एक कंप्यूटर के रूप में जिसमें आप कार्यक्षमता जोड़ेंगे। एक जोड़ता है
एप्लिकेशन, प्रोटोकॉल स्टैक और परिधीय कार्ड जैसी चीजें उनके साथ जुड़ी हुई हैं
कंप्यूटर को उपयोगी कार्य करने में सक्षम बनाने के लिए ड्राइवर। हम उसी मूल मॉडल का उपयोग करते हैं एनएस- 3.

आवेदन
आमतौर पर, कंप्यूटर सॉफ़्टवेयर को दो व्यापक वर्गों में विभाजित किया जाता है। प्रणाली सॉफ्टवेयर का आयोजन
विभिन्न कंप्यूटर संसाधन जैसे मेमोरी, प्रोसेसर चक्र, डिस्क, नेटवर्क, आदि।
कुछ कंप्यूटिंग मॉडल के अनुसार. सिस्टम सॉफ़्टवेयर आमतौर पर उन संसाधनों का उपयोग नहीं करता है
उन कार्यों को पूरा करने के लिए जिनसे उपयोगकर्ता को सीधे लाभ होता है। एक उपयोगकर्ता आम तौर पर एक चलाएगा आवेदन
जो कुछ हासिल करने के लिए सिस्टम सॉफ़्टवेयर द्वारा नियंत्रित संसाधनों को प्राप्त करता है और उनका उपयोग करता है
लक्ष्य.

अक्सर, सिस्टम और एप्लिकेशन सॉफ़्टवेयर के बीच पृथक्करण की रेखा बनाई जाती है
विशेषाधिकार स्तर का परिवर्तन जो ऑपरेटिंग सिस्टम ट्रैप में होता है। में एनएस- 3 कोई वास्तविक नहीं है
ऑपरेटिंग सिस्टम की अवधारणा और विशेष रूप से विशेषाधिकार स्तर या सिस्टम कॉल की कोई अवधारणा नहीं।
हालाँकि, हमारे पास एक एप्लिकेशन का विचार है। जैसे सॉफ्टवेयर एप्लीकेशन चलते हैं
"वास्तविक दुनिया" में कार्य करने के लिए कंप्यूटर एनएस- 3 एप्लिकेशन चालू रहते हैं एनएस- 3 नोड्स सेवा मेरे
सिम्युलेटेड दुनिया में सिमुलेशन चलाएं।

In एनएस- 3 एक उपयोगकर्ता प्रोग्राम के लिए बुनियादी अमूर्तता जो कुछ गतिविधि उत्पन्न करती है
अनुप्रयोग सिम्युलेटेड है। यह अमूर्त वर्ग द्वारा C++ में दर्शाया गया है
आवेदन। आवेदन वर्ग अभ्यावेदन के प्रबंधन के लिए तरीके प्रदान करता है
सिमुलेशन में उपयोगकर्ता-स्तरीय अनुप्रयोगों का हमारा संस्करण। डेवलपर्स से अपेक्षा की जाती है
विशेषज्ञ आवेदन नया बनाने के लिए ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग अर्थ में क्लास
अनुप्रयोग। इस ट्यूटोरियल में, हम कक्षा की विशेषज्ञता का उपयोग करेंगे आवेदन बुलाया
UdpEchoClientएप्लिकेशन और UdpEchoServerअनुप्रयोग. जैसा कि आप उम्मीद कर सकते हैं, ये
एप्लिकेशन एक क्लाइंट/सर्वर एप्लिकेशन सेट बनाते हैं जिसका उपयोग सिम्युलेटेड और इको उत्पन्न करने के लिए किया जाता है
नेटवर्क पैकेट

चैनल
वास्तविक दुनिया में, कोई कंप्यूटर को नेटवर्क से जोड़ सकता है। जिस पर अक्सर मीडिया चर्चा करता रहता है
इन नेटवर्कों में डेटा प्रवाह को कहा जाता है चैनलों. जब आप अपने ईथरनेट केबल को कनेक्ट करते हैं
दीवार में प्लग, आप अपने कंप्यूटर को ईथरनेट संचार से जोड़ रहे हैं
चैनल। की नकली दुनिया में एनएस- 3, एक जोड़ता है ए आसंधि किसी वस्तु का प्रतिनिधित्व करने के लिए
बातचीत का माध्यम। यहां बुनियादी संचार सबनेटवर्क अमूर्तन कहा जाता है
चैनल और क्लास द्वारा C++ में दर्शाया गया है चैनल.

RSI चैनल क्लास संचार सबनेटवर्क ऑब्जेक्ट्स के प्रबंधन के लिए तरीके प्रदान करता है
उनसे नोड्स जोड़ना। चैनल ऑब्जेक्ट में डेवलपर्स द्वारा विशेषज्ञता भी प्राप्त की जा सकती है
उन्मुख प्रोग्रामिंग भावना. ए चैनल विशेषज्ञता किसी चीज़ को सरल रूप में प्रस्तुत कर सकती है
तार। विशिष्ट चैनल बड़े ईथरनेट जैसी जटिल चीज़ों का मॉडल भी बना सकता है
स्विच, या वायरलेस नेटवर्क के मामले में बाधाओं से भरा त्रि-आयामी स्थान।

हम इसके विशेष संस्करणों का उपयोग करेंगे चैनल बुलाया Csmaचैनल, पॉइंटटूपॉइंटचैनल
और वाईफ़ाईचैनल इस ट्यूटोरियल में. Csmaचैनलउदाहरण के लिए, a का एक संस्करण मॉडल करता है
संचार सबनेटवर्क जो कार्यान्वित करता है वाहक भावना विभिन्न पहुँच संचार
मध्यम। यह हमें ईथरनेट जैसी कार्यक्षमता प्रदान करता है।

जाल युक्ति
पहले ऐसा होता था कि यदि आप किसी कंप्यूटर को किसी नेटवर्क से जोड़ना चाहते थे, तो आपको ऐसा करना पड़ता था
एक विशिष्ट प्रकार की नेटवर्क केबल और एक हार्डवेयर डिवाइस खरीदें जिसे (पीसी शब्दावली में) कहा जाता है
परिधीय कार्ड जिसे आपके कंप्यूटर में इंस्टॉल करना आवश्यक है। यदि परिधीय कार्ड
कुछ नेटवर्किंग फ़ंक्शन लागू किए, उन्हें नेटवर्क इंटरफ़ेस कार्ड कहा गया, या एनआईसी.
आज अधिकांश कंप्यूटर नेटवर्क इंटरफ़ेस हार्डवेयर के साथ आते हैं और उपयोगकर्ता इसे नहीं देख पाते हैं
ये बिल्डिंग ब्लॉक्स.

हार्डवेयर को नियंत्रित करने के लिए एक एनआईसी सॉफ्टवेयर ड्राइवर के बिना काम नहीं करेगा। यूनिक्स में (या
लिनक्स), परिधीय हार्डवेयर का एक टुकड़ा के रूप में वर्गीकृत किया गया है युक्ति. उपकरणों को नियंत्रित किया जाता है
का उपयोग युक्ति ड्राइवरों, और नेटवर्क डिवाइस (एनआईसी) का उपयोग करके नियंत्रित किया जाता है नेटवर्क युक्ति
ड्राइवरों सामूहिक रूप से जाना जाता है जाल उपकरणों. यूनिक्स और लिनक्स में आप इन नेट का उल्लेख करते हैं
जैसे नामों से उपकरण eth0.

In एनएस- 3 la जाल युक्ति एब्स्ट्रैक्शन सॉफ्टवेयर ड्राइवर और सिम्युलेटेड दोनों को कवर करता है
हार्डवेयर. एक नेट डिवाइस "स्थापित" है आसंधि सक्षम करने के लिए आसंधि सेवा मेरे
दूसरे के साथ संवाद करें नोड्स के माध्यम से अनुकरण में चैनल. बिल्कुल एक वास्तविक कंप्यूटर की तरह,
a आसंधि एक से अधिक से जुड़ा हो सकता है चैनल एकाधिक के माध्यम से नेटडिवाइसेस.

नेट डिवाइस एब्स्ट्रैक्शन को C++ में क्लास द्वारा दर्शाया जाता है नेटडिवाइस। नेटडिवाइस
क्लास कनेक्शन प्रबंधित करने के तरीके प्रदान करता है आसंधि और चैनल वस्तुएं; और शायद
ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग अर्थ में डेवलपर्स द्वारा विशेषज्ञता। हम उपयोग करेंगे
के कई विशिष्ट संस्करण नेटडिवाइस बुलाया सीएसएमएनेटडिवाइस, पॉइंटटूप्वाइंटनेटडिवाइस,
और वाईफ़ाईनेटडिवाइस इस ट्यूटोरियल में. जिस तरह एक ईथरनेट एनआईसी को एक के साथ काम करने के लिए डिज़ाइन किया गया है
ईथरनेट नेटवर्क, सीएसएमएनेटडिवाइस के साथ काम करने के लिए डिज़ाइन किया गया है Csmaचैनल;
पॉइंटटूप्वाइंटनेटडिवाइस के साथ काम करने के लिए डिज़ाइन किया गया है पॉइंटटूपॉइंटचैनल और एक वाईफ़ाईनेटनेविस
के साथ काम करने के लिए डिज़ाइन किया गया है वाईफ़ाईचैनल.

टोपोलॉजी सहायकों
वास्तविक नेटवर्क में, आपको अतिरिक्त (या अंतर्निर्मित) एनआईसी के साथ होस्ट कंप्यूटर मिलेंगे। में एनएस- 3 we
कहेंगे कि तुम पाओगे नोड्स संलग्न है नेटडिवाइसेस. एक बड़े सिम्युलेटेड नेटवर्क में
आपको बीच में कई कनेक्शनों की व्यवस्था करने की आवश्यकता होगी नोड्स, नेटडिवाइसेस और चैनल.

जुड़ने के बाद से नेटडिवाइसेस सेवा मेरे नोड्स, नेटडिवाइसेस सेवा मेरे चैनल, आईपी पते निर्दिष्ट करना,
इत्यादि ऐसे सामान्य कार्य हैं एनएस- 3, हम वह प्रदान करते हैं जिसे हम कहते हैं टोपोलॉजी सहायकों इसे बनाने के लिए
जितना संभव हो उतना आसान. उदाहरण के लिए, इसमें कई अलग-अलग चीज़ें लग सकती हैं एनएस- 3 करने के लिए मुख्य संचालन
एक नेटडिवाइस बनाएं, एक मैक एड्रेस जोड़ें, उस नेट डिवाइस को इंस्टॉल करें आसंधि, कॉन्फ़िगर करें
नोड का प्रोटोकॉल स्टैक, और फिर कनेक्ट करें नेटडिवाइस एक करने के लिए चैनल. और भी अधिक ऑपरेशन
मल्टीपॉइंट चैनलों पर एकाधिक डिवाइस कनेक्ट करने और फिर कनेक्ट करने की आवश्यकता होगी
व्यक्तिगत नेटवर्क एक साथ इंटरनेटवर्क में। हम टोपोलॉजी सहायक ऑब्जेक्ट प्रदान करते हैं
अपनी सुविधा के लिए उन कई अलग-अलग परिचालनों को एक उपयोग में आसान मॉडल में संयोजित करें।

A प्रथम एनएस- 3 लिपि
यदि आपने ऊपर बताए अनुसार सिस्टम डाउनलोड किया है, तो आपके पास एक रिलीज़ होगी एनएस- 3 में
निर्देशिका कहा जाता है रेपो आपके होम निर्देशिका के अंतर्गत. उस रिलीज़ निर्देशिका में बदलें, और
आपको एक निर्देशिका संरचना कुछ इस प्रकार मिलनी चाहिए:

लेखक उदाहरण स्क्रैच यूटिल्स waf.bat*
बाइंडिंग LICENSE src utils.py waf-tools
ns3 test.py* utils.pyc wscript बनाएँ
CHANGES.html README टेस्टपी-आउटपुट संस्करण wutils.py
दस्तावेज़ RELEASE_NOTES testpy.supp waf* wutils.pyc

में बदलें उदाहरण/ट्यूटोरियल निर्देशिका। आपको नाम की एक फ़ाइल देखनी चाहिए प्रथम.सीसी स्थित
वहाँ। यह एक स्क्रिप्ट है जो दो नोड्स के बीच एक सरल पॉइंट-टू-पॉइंट लिंक बनाएगी
और नोड्स के बीच एक एकल पैकेट को प्रतिध्वनित करें। आइए उस स्क्रिप्ट लाइन पर एक नजर डालें
लाइन, तो आगे बढ़ें और खोलें प्रथम.सीसी अपने पसंदीदा संपादक में.

बॉयलरप्लेट
फ़ाइल की पहली पंक्ति एक एमएसीएस मोड लाइन है। यह एमएसीएस को फ़ॉर्मेटिंग के बारे में बताता है
कन्वेंशन (कोडिंग शैली) हम अपने स्रोत कोड में उपयोग करते हैं।

/* -*- मोड:C++; सी-फ़ाइल-शैली:"gnu"; इंडेंट-टैब-मोड:शून्य; -*- */

यह हमेशा कुछ हद तक विवादास्पद विषय होता है, इसलिए हम इसे रास्ते से हटा भी सकते हैं
हाथोंहाथ। एनएस- 3 परियोजना ने, अधिकांश बड़ी परियोजनाओं की तरह, एक कोडिंग शैली अपनाई है
जिसका सभी योगदान कोड को पालन करना होगा। यदि आप इसमें अपना कोड योगदान करना चाहते हैं
प्रोजेक्ट, आपको अंततः इसके अनुरूप होना होगा एनएस- 3 कोडिंग मानक जैसा कि वर्णित है
फ़ाइल दस्तावेज़/कोडिंगएसटीडी.टीएक्सटी या प्रोजेक्ट वेब पेज पर दिखाया गया है यहाँ उत्पन्न करें.

हम अनुशंसा करते हैं कि आप, बस इसके रूप और अनुभव के आदी हो जाएं एनएस- 3 कोड करें और अपनाएं
जब भी आप हमारे कोड के साथ काम कर रहे हों तो यह मानक। समस्त विकास दल और
योगदानकर्ताओं ने विभिन्न प्रकार की शिकायतों के साथ ऐसा किया है। ऊपर दी गई Emacs मोड लाइन
यदि आप एमएसीएस संपादक का उपयोग करते हैं तो फ़ॉर्मेटिंग को सही करना आसान हो जाता है।

RSI एनएस- 3 सिम्युलेटर को जीएनयू जनरल पब्लिक लाइसेंस का उपयोग करके लाइसेंस प्राप्त है। आप देखेंगे
प्रत्येक फ़ाइल के शीर्ष पर उपयुक्त जीएनयू वैधानिकता एनएस- 3 वितरण। अक्सर आप
इसमें शामिल संस्थानों में से किसी एक के लिए कॉपीराइट नोटिस देखेंगे एनएस- 3 उपरोक्त परियोजना
जीपीएल पाठ और नीचे सूचीबद्ध एक लेखक।

/*
* यह प्रोग्राम निःशुल्क सॉफ्टवेयर है; आप इसे पुनर्वितरित और/या संशोधित कर सकते हैं
* यह जीएनयू जनरल पब्लिक लाइसेंस संस्करण 2 की शर्तों के तहत है
* फ्री सॉफ्टवेयर फाउंडेशन द्वारा प्रकाशित;
*
*यह कार्यक्रम इस आशा से वितरित किया गया है कि यह उपयोगी होगा,
*लेकिन बिना किसी वारंटी के; की निहित वारंटी के बिना भी
* किसी विशेष उद्देश्य के लिए अनुरूपता या फिटनेस। देखें
* अधिक जानकारी के लिए जीएनयू जनरल पब्लिक लाइसेंस।
*
* आपको जीएनयू जनरल पब्लिक लाइसेंस की एक प्रति प्राप्त होनी चाहिए
*इस कार्यक्रम के साथ-साथ; यदि नहीं, तो फ्री सॉफ्टवेयर को लिखें
* फाउंडेशन, इंक., 59 टेम्पल प्लेस, सुइट 330, बोस्टन, एमए 02111-1307 यूएसए
*/

मॉड्यूल शामिल है
कोड उचित रूप से कई सम्मिलित कथनों से शुरू होता है।

#शामिल "ns3/core-module.h"
#शामिल है "ns3/network-module.h"
#शामिल "ns3/इंटरनेट-मॉड्यूल.एच"
#शामिल है "ns3/point-to-point-module.h"
#शामिल "ns3/applications-module.h"

हमारे उच्च-स्तरीय स्क्रिप्ट उपयोगकर्ताओं को बड़ी संख्या में मौजूद फ़ाइलों से निपटने में मदद करने के लिए
सिस्टम को हम अपेक्षाकृत बड़े मॉड्यूल के अनुसार समूहित करते हैं। हम एक एकल प्रदान करते हैं
include फ़ाइल जो प्रत्येक मॉड्यूल में उपयोग की गई सभी फ़ाइलों को पुनरावर्ती रूप से लोड करेगी।
बजाय यह देखने के कि आपको वास्तव में किस हेडर की आवश्यकता है, और संभवतः एक प्राप्त करना होगा
निर्भरताओं की संख्या सही है, हम आपको फ़ाइलों के एक समूह को बड़े पैमाने पर लोड करने की क्षमता देते हैं
ग्रैन्युलैरिटी यह सबसे कारगर तरीका नहीं है लेकिन यह निश्चित रूप से लेखन को आसान बनाता है
स्क्रिप्ट बहुत आसान है.

हर एक एनएस- 3 include फ़ाइलों को एक निर्देशिका में रखा जाता है जिसे कहा जाता है ns3 (निर्माण के तहत
निर्देशिका) निर्माण प्रक्रिया के दौरान फ़ाइल नाम टकराव से बचने में मदद करने के लिए।
ns3/कोर-मॉड्यूल.एच फ़ाइल ns-3 मॉड्यूल से मेल खाती है जो आपको निर्देशिका में मिलेगी
स्रोत/कोर आपके डाउनलोड किए गए रिलीज़ वितरण में। यदि आप इस निर्देशिका को सूचीबद्ध करेंगे तो आप ऐसा करेंगे
बड़ी संख्या में हेडर फ़ाइलें ढूंढें. जब आप कोई निर्माण करते हैं, तो वफ़ सार्वजनिक हेडर रखेगा
एक में फ़ाइलें ns3 उपयुक्त के अंतर्गत निर्देशिका निर्माण/डीबग करें or निर्माण/अनुकूलित डायरेक्टरी
आपके कॉन्फ़िगरेशन के आधार पर. वफ़ स्वचालित रूप से एक मॉड्यूल भी शामिल करेगा
सभी सार्वजनिक हेडर फ़ाइलों को लोड करने के लिए फ़ाइल।

चूंकि आप निश्चित रूप से इस ट्यूटोरियल का ईमानदारी से पालन कर रहे हैं, आप पहले ही कर चुके होंगे
a

$ ./waf -d डिबग --सक्षम-उदाहरण --सक्षम-परीक्षण कॉन्फ़िगर करें

डिबग बिल्ड करने के लिए प्रोजेक्ट को कॉन्फ़िगर करने के लिए जिसमें उदाहरण और परीक्षण शामिल हैं।
आपने भी किया होगा

$ ./वफ़ा

प्रोजेक्ट बनाने के लिए. तो अब यदि आप निर्देशिका में देखें ../../बिल्ड/डिबग/ns3 आप करेंगे
चार मॉड्यूल ढूंढें जिनमें ऊपर दिखाई गई फ़ाइलें शामिल हैं। आप इसकी सामग्री पर एक नज़र डाल सकते हैं
इन फ़ाइलों और पाया कि उनमें सभी सार्वजनिक फ़ाइलें शामिल हैं
संबंधित मॉड्यूल.

एनएस3 नाम स्थान
में अगली पंक्ति प्रथम.सीसी स्क्रिप्ट एक नेमस्पेस घोषणा है।

नेमस्पेस ns3 का उपयोग करना;

RSI एनएस- 3 प्रोजेक्ट को C++ नेमस्पेस में कार्यान्वित किया जाता है जिसे कहा जाता है ns3. यह सभी को समूहित करता है
एनएस- 3-वैश्विक नामस्थान के बाहर के दायरे में संबंधित घोषणाएँ, जिनसे हमें आशा है कि मदद मिलेगी
अन्य कोड के साथ एकीकरण के साथ। सी++ का उपयोग कथन का परिचय देता है एनएस- 3 नाम स्थान
वर्तमान (वैश्विक) घोषणात्मक क्षेत्र में। उसके बाद यह कहने का यह एक शानदार तरीका है
इस डिक्लेरेशन को आपको टाइप करने की जरूरत नहीं पड़ेगी एनएस3:: सभी से पहले स्कोप रिज़ॉल्यूशन ऑपरेटर
la एनएस- 3 इसका उपयोग करने के लिए कोड। यदि आप नामस्थानों से अपरिचित हैं, तो कृपया परामर्श लें
लगभग किसी भी C++ ट्यूटोरियल और तुलना करें ns3 के उदाहरणों के साथ यहां नामस्थान और उपयोग
एसटीडी नेमस्पेस और का उपयोग नाम स्थान एसटीडी; ऐसे बयान आपको अक्सर चर्चाओं में मिल जाएंगे
of अदालत और धाराएँ.

लॉगिंग
स्क्रिप्ट की अगली पंक्ति निम्नलिखित है,

NS_LOG_COMPONENT_DEFINE ("फर्स्टस्क्रिप्ट उदाहरण");

हम इस कथन का उपयोग अपने डॉक्सीजन दस्तावेज़ीकरण के बारे में बात करने के लिए एक सुविधाजनक स्थान के रूप में करेंगे
प्रणाली। यदि आप प्रोजेक्ट वेब साइट को देखें, एनएस- 3 परियोजना, आपको एक लिंक मिलेगा
नेविगेशन बार में "दस्तावेज़ीकरण"। यदि आप इस लिंक का चयन करते हैं, तो आपको हमारे पास ले जाया जाएगा
दस्तावेज़ीकरण पृष्ठ. "नवीनतम रिलीज़" का एक लिंक है जो आपको ले जाएगा
की नवीनतम स्थिर रिलीज़ के लिए दस्तावेज़ीकरण एनएस- 3. यदि आप "एपीआई" चुनते हैं
दस्तावेज़ीकरण" लिंक, आपको ले जाया जाएगा एनएस- 3 एपीआई दस्तावेज़ीकरण पृष्ठ।

बाईं ओर, आपको इसकी संरचना का एक चित्रमय प्रतिनिधित्व मिलेगा
दस्तावेज़ीकरण. शुरुआत करने के लिए एक अच्छी जगह है एन एस-3 मॉड्यूल में "पुस्तक"। एनएस- 3 पथ प्रदर्शन
पेड़। यदि आप विस्तार करते हैं मॉड्यूल आपको इसकी एक सूची दिखाई देगी एनएस- 3 मॉड्यूल दस्तावेज़ीकरण.
यहां मॉड्यूल की अवधारणा सीधे मॉड्यूल से जुड़ती है जिसमें ऊपर चर्चा की गई फ़ाइलें शामिल हैं।
एनएस- 3 लॉगिंग सबसिस्टम पर चर्चा की गई है सी + + निर्माणों प्रयुक्त by सब मॉड्यूल अनुभाग, तो
आगे बढ़ें और उस दस्तावेज़ीकरण नोड का विस्तार करें। अब, विस्तार करें डीबगिंग किताब और फिर
चयन लॉगिंग इस पृष्ठ पर ज़ूम कई वीडियो ट्यूटोरियल और अन्य साहायक साधन प्रदान करता है।

अब आपको लॉगिंग मॉड्यूल के लिए डॉक्सीजन दस्तावेज़ देखना चाहिए। में
की सूची #defineपृष्ठ के शीर्ष पर आपको इसकी प्रविष्टि दिखाई देगी
NS_LOG_COMPONENT_DEFINE. कूदने से पहले, संभवतः इसे देखना अच्छा रहेगा
समग्र संचालन का अनुभव प्राप्त करने के लिए लॉगिंग मॉड्यूल का "विस्तृत विवरण"। आप
आप या तो नीचे स्क्रॉल कर सकते हैं या सहयोग आरेख के अंतर्गत "अधिक..." लिंक का चयन कर सकते हैं
इस।

एक बार जब आपको इस बात का सामान्य अंदाज़ा हो जाए कि क्या हो रहा है, तो आगे बढ़ें और विशिष्ट चीज़ों पर नज़र डालें
NS_LOG_COMPONENT_DEFINE दस्तावेज़ीकरण. मैं यहां दस्तावेज़ की नकल नहीं करूंगा, लेकिन
संक्षेप में, यह पंक्ति एक लॉगिंग घटक घोषित करती है जिसे कहा जाता है फर्स्टस्क्रिप्ट उदाहरण वह आज्ञा देता है
आप नाम के संदर्भ में कंसोल संदेश लॉगिंग को सक्षम और अक्षम कर सकते हैं।

मुख्य समारोह
स्क्रिप्ट की अगली पंक्तियाँ आपको मिलेंगी,

int
मुख्य (int argc, char *argv[])
{

यह आपके प्रोग्राम (स्क्रिप्ट) के मुख्य कार्य की घोषणा मात्र है। बिल्कुल वैसे ही जैसे
किसी भी C++ प्रोग्राम में, आपको एक मुख्य फ़ंक्शन को परिभाषित करने की आवश्यकता है जो पहला फ़ंक्शन रन होगा।
यहां कुछ भी खास नहीं है. आपका एनएस- 3 स्क्रिप्ट सिर्फ एक C++ प्रोग्राम है।

अगली पंक्ति समय रिज़ॉल्यूशन को एक नैनोसेकंड पर सेट करती है, जो डिफ़ॉल्ट होता है
मूल्य:

समय::सेटरिज़ॉल्यूशन (समय::एनएस);

रिज़ॉल्यूशन सबसे छोटा समय मान है जिसे दर्शाया जा सकता है (साथ ही सबसे छोटा भी)।
दो समय मूल्यों के बीच प्रतिनिधित्व योग्य अंतर)। आप रिज़ॉल्यूशन को बिल्कुल बदल सकते हैं
एक बार। इस लचीलेपन को सक्षम करने वाला तंत्र कुछ हद तक स्मृति भूखा है, इसलिए एक बार
रिज़ॉल्यूशन स्पष्ट रूप से सेट कर दिया गया है, हम मेमोरी को रिलीज़ करते हैं, जिससे आगे के अपडेट को रोका जा सकता है।
(यदि आप रिज़ॉल्यूशन को स्पष्ट रूप से सेट नहीं करते हैं, तो यह एक नैनोसेकंड पर डिफ़ॉल्ट हो जाएगा, और
सिमुलेशन शुरू होने पर मेमोरी रिलीज़ हो जाएगी।)

स्क्रिप्ट की अगली दो पंक्तियों का उपयोग निर्मित दो लॉगिंग घटकों को सक्षम करने के लिए किया जाता है
इको क्लाइंट और इको सर्वर अनुप्रयोगों में:

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable('UdpEchoServerApplication', LOG_LEVEL_INFO);

यदि आपने लॉगिंग घटक दस्तावेज़ पढ़ा है तो आपने उसे वहां देखा होगा
लॉगिंग वर्बोसिटी/विवरण के कई स्तर हैं जिन्हें आप प्रत्येक घटक पर सक्षम कर सकते हैं।
कोड की ये दो पंक्तियाँ इको क्लाइंट के लिए INFO स्तर पर डिबग लॉगिंग को सक्षम बनाती हैं
सर्वर. इसके परिणामस्वरूप पैकेट भेजे जाने पर एप्लिकेशन संदेशों को प्रिंट कर देगा
और अनुकरण के दौरान प्राप्त हुआ।

अब हम सीधे टोपोलॉजी बनाने और सिमुलेशन चलाने के व्यवसाय पर उतरेंगे।
इस कार्य को यथासंभव आसान बनाने के लिए हम टोपोलॉजी सहायक ऑब्जेक्ट का उपयोग करते हैं।

टोपोलॉजी सहायकों
नोडकंटेनर
हमारी स्क्रिप्ट में कोड की अगली दो पंक्तियाँ वास्तव में बनेंगी एनएस- 3 आसंधि वह वस्तुएं
सिमुलेशन में कंप्यूटर का प्रतिनिधित्व करेगा।

नोडकंटेनर नोड्स;
नोड्स.बनाएँ (2);

आइए इसके लिए दस्तावेज़ ढूंढें नोडकंटेनर जारी रखने से पहले कक्षा। एक और तरीका
किसी दिए गए वर्ग के दस्तावेज़ीकरण में जाने के लिए इसके माध्यम से है क्लासेज डॉक्सीजन में टैब
पन्ने. यदि आपके पास अभी भी डॉक्सीजन उपलब्ध है, तो बस पृष्ठ के शीर्ष तक स्क्रॉल करें और
चयन क्लासेज टैब. आपको टैब का एक नया सेट दिखाई देना चाहिए, जिनमें से एक है वर्ग
सूची. उस टैब के अंतर्गत आपको सभी की एक सूची दिखाई देगी एनएस- 3 कक्षाएं. नीचे स्क्रॉल करें,
के लिए तलाश ns3::NodeContainer. जब आपको कक्षा मिल जाए, तो आगे बढ़ें और जाने के लिए उसे चुनें
कक्षा के लिए दस्तावेज़ीकरण.

आपको याद होगा कि हमारे प्रमुख निष्कर्षों में से एक है आसंधि. यह एक कंप्यूटर का प्रतिनिधित्व करता है
जिसमें हम प्रोटोकॉल स्टैक, एप्लिकेशन और पेरीफेरल जैसी चीजें जोड़ने जा रहे हैं
पत्ते। नोडकंटेनर टोपोलॉजी हेल्पर बनाने, प्रबंधित करने और करने का एक सुविधाजनक तरीका प्रदान करता है
किसी तक पहुंचें आसंधि ऑब्जेक्ट जो हम सिमुलेशन चलाने के लिए बनाते हैं। ऊपर पहली पंक्ति
बस एक NodeContainer घोषित करता है जिसे हम कहते हैं नोड्स. दूसरी पंक्ति कॉल करती है बनाएं
पर विधि नोड्स ऑब्जेक्ट और कंटेनर को दो नोड बनाने के लिए कहता है। जैसा कि इसमें वर्णित है
डॉक्सीजन, कंटेनर नीचे बुलाता है एनएस- 3 दो बनाने के लिए उचित प्रणाली आसंधि
ऑब्जेक्ट और उन ऑब्जेक्ट के पॉइंटर्स को आंतरिक रूप से संग्रहीत करता है।

स्क्रिप्ट में मौजूद नोड्स कुछ भी नहीं करते हैं। के निर्माण में अगला कदम
टोपोलॉजी हमारे नोड्स को एक नेटवर्क में एक साथ जोड़ना है। नेटवर्क का सबसे सरल रूप हम
समर्थन दो नोड्स के बीच एक एकल बिंदु-से-बिंदु लिंक है। हम उनमें से एक का निर्माण करेंगे
लिंक यहाँ.

पॉइंटटूप्वाइंटहेल्पर
हम एक बिंदु से बिंदु लिंक का निर्माण कर रहे हैं, और, एक पैटर्न में जो काफी बन जाएगा
जैसा कि आप जानते हैं, हम आवश्यक निम्न-स्तरीय कार्य करने के लिए टोपोलॉजी हेल्पर ऑब्जेक्ट का उपयोग करते हैं
एक साथ लिंक. याद रखें कि हमारे दो प्रमुख सार हैं नेटडिवाइस और
चैनल. वास्तविक दुनिया में, ये शब्द मोटे तौर पर परिधीय कार्डों से मेल खाते हैं और
नेटवर्क केबल. आमतौर पर ये दोनों चीजें एक-दूसरे के साथ घनिष्ठ रूप से जुड़ी हुई हैं और कोई ऐसा नहीं कर सकता
उदाहरण के लिए, ईथरनेट उपकरणों और वायरलेस चैनलों के आदान-प्रदान की अपेक्षा करें। हमारी टोपोलॉजी
सहायक इस अंतरंग युग्मन का पालन करते हैं और इसलिए आप एकल का उपयोग करेंगे
पॉइंटटूप्वाइंटहेल्पर कॉन्फ़िगर करने और कनेक्ट करने के लिए एनएस- 3 पॉइंटटूप्वाइंटनेटडिवाइस और
पॉइंटटूपॉइंटचैनल इस स्क्रिप्ट में ऑब्जेक्ट.

स्क्रिप्ट में अगली तीन पंक्तियाँ हैं,

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;
पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));
पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

पहली पंक्ति,

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;

त्वरित करता है ए पॉइंटटूप्वाइंटहेल्पर स्टैक पर वस्तु. उच्च स्तरीय दृष्टिकोण से
अगली पंक्ति,

पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));

कहता है पॉइंटटूप्वाइंटहेल्पर मान "5Mbps" (प्रति सेकंड पांच मेगाबिट) का उपयोग करने के लिए ऑब्जेक्ट करें
"डेटारेट" जब यह बनाता है पॉइंटटूप्वाइंटनेटडिवाइस वस्तु।

अधिक विस्तृत परिप्रेक्ष्य से, स्ट्रिंग "डेटारेट" जिसे हम कहते हैं उससे मेल खाती है
विशेषता का पॉइंटटूप्वाइंटनेटडिवाइस. यदि आप क्लास के लिए डॉक्सीजन को देखें
एनएस3::प्वाइंटटूप्वाइंटनेटडिवाइस और इसके लिए दस्तावेज़ ढूंढें GetTypeId विधि, आप करेंगे
की एक सूची खोजें गुण डिवाइस के लिए परिभाषित। इनमें से एक है "डेटारेट"
विशेषता. सर्वाधिक उपयोगकर्ता-दृश्यमान एनएस- 3 वस्तुओं की समान सूचियाँ होती हैं गुण. हम इसका उपयोग करते हैं
जैसा कि आप देखेंगे, पुन: संकलन किए बिना सिमुलेशन को आसानी से कॉन्फ़िगर करने का तंत्र
निम्नलिखित अनुभाग.

पर "डेटारेट" के समान पॉइंटटूप्वाइंटनेटडिवाइस आपको "विलंब" मिलेगा विशेषता
के साथ जुड़े पॉइंटटूपॉइंटचैनल. अंतिम पंक्ति,

पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

कहता है पॉइंटटूप्वाइंटहेल्पर के मान के रूप में "2ms" (दो मिलीसेकंड) का उपयोग करने के लिए
इसके बाद बनने वाले प्रत्येक बिंदु से बिंदु चैनल के प्रसारण में देरी होती है।

नेटडिवाइसकंटेनर
स्क्रिप्ट के इस बिंदु पर, हमारे पास एक है नोडकंटेनर जिसमें दो नोड हैं। हमारे पास एक
पॉइंटटूप्वाइंटहेल्पर वह तैयार है और बनाने के लिए तैयार है पॉइंट टू पॉइंट नेट डिवाइसेस और तार
पॉइंटटूपॉइंटचैनल उनके बीच की वस्तुएँ। जैसा कि हमने उपयोग किया है नोडकंटेनर टोपोलॉजी
सहायक वस्तु बनाने के लिए नोड्स हमारे अनुकरण के लिए, हम पूछेंगे पॉइंटटूप्वाइंटहेल्पर
हमारे लिए हमारे उपकरणों को बनाने, कॉन्फ़िगर करने और स्थापित करने से संबंधित कार्य करना। हम
बनाए गए सभी नेटडिवाइस ऑब्जेक्ट की एक सूची की आवश्यकता होगी, इसलिए हम इसका उपयोग करते हैं
उन्हें होल्ड करने के लिए NetDeviceContainer का उपयोग करें जैसे कि हमने नोड्स को होल्ड करने के लिए NodeContainer का उपयोग किया था
बनाया था। कोड की निम्नलिखित दो पंक्तियाँ,

नेटडिवाइसकंटेनर डिवाइस;
डिवाइस = पॉइंटटूप्वाइंट.इंस्टॉल (नोड्स);

डिवाइस और चैनल को कॉन्फ़िगर करना समाप्त हो जाएगा। पहली पंक्ति डिवाइस की घोषणा करती है
ऊपर उल्लिखित कंटेनर और दूसरा भारी सामान उठाने का काम करता है। स्थापित करें उसकि विधि
la पॉइंटटूप्वाइंटहेल्पर लिया जाता है एक नोडकंटेनर एक पैरामीटर के रूप में. आंतरिक रूप से, ए
नेटडिवाइसकंटेनर बनाया गया है। में प्रत्येक नोड के लिए नोडकंटेनर (वहाँ बिल्कुल होना चाहिए
पॉइंट-टू-पॉइंट लिंक के लिए दो) a पॉइंटटूप्वाइंटनेटडिवाइस डिवाइस में बनाया और सहेजा जाता है
कंटेनर. ए पॉइंटटूपॉइंटचैनल बनाया गया है और दो पॉइंट टू पॉइंट नेट डिवाइसेस रहे
जुड़ा हुआ। जब वस्तुओं का निर्माण किया जाता है पॉइंटटूप्वाइंटहेल्पर, गुण पहले से
हेल्पर में सेट का उपयोग संबंधित को आरंभ करने के लिए किया जाता है गुण निर्मित में
वस्तुओं।

निष्पादित करने के बाद पॉइंटटूपॉइंट.इंस्टॉल करें (नोड्स) कॉल करें हमारे पास दो नोड होंगे, प्रत्येक में एक
स्थापित पॉइंट-टू-पॉइंट नेट डिवाइस और उनके बीच एक सिंगल पॉइंट-टू-पॉइंट चैनल।
दोनों डिवाइसों को प्रति सेकंड पांच मेगाबिट्स पर डेटा संचारित करने के लिए कॉन्फ़िगर किया जाएगा
चैनल जिसमें दो मिलीसेकंड ट्रांसमिशन विलंब है।

इंटरनेटस्टैकहेल्पर
अब हमारे पास नोड्स और डिवाइस कॉन्फ़िगर हैं, लेकिन हमारे पास कोई प्रोटोकॉल स्टैक स्थापित नहीं है
हमारे नोड्स पर. कोड की अगली दो पंक्तियाँ इसका ध्यान रखेंगी।

इंटरनेटस्टैकहेल्पर स्टैक;
स्टैक.इंस्टॉल (नोड्स);

RSI इंटरनेटस्टैकहेल्पर एक टोपोलॉजी सहायक है जो इंटरनेट स्टैक के लिए है
पॉइंटटूप्वाइंटहेल्पर पॉइंट-टू-पॉइंट नेट डिवाइसेस के लिए है। स्थापित करें विधि एक लेता है
नोडकंटेनर एक पैरामीटर के रूप में. जब इसे निष्पादित किया जाएगा, तो यह एक इंटरनेट स्टैक स्थापित करेगा
(टीसीपी, यूडीपी, आईपी, आदि) नोड कंटेनर में प्रत्येक नोड पर।

आईपीवी4पता हेल्पर
इसके बाद हमें अपने नोड्स पर डिवाइस को आईपी पते के साथ जोड़ना होगा। हम एक प्रदान करते हैं
आईपी ​​पते के आवंटन को प्रबंधित करने के लिए टोपोलॉजी सहायक। एकमात्र उपयोगकर्ता-दृश्यमान एपीआई है
वास्तविक पता निष्पादित करते समय उपयोग करने के लिए आधार आईपी पता और नेटवर्क मास्क सेट करें
आवंटन (जो सहायक के अंदर निचले स्तर पर किया जाता है)।

हमारी उदाहरण स्क्रिप्ट में कोड की अगली दो पंक्तियाँ, प्रथम.सीसी,

Ipv4AddressHelper पता;
पता.सेटबेस ("10.1.1.0", "255.255.255.0");

एक एड्रेस हेल्पर ऑब्जेक्ट घोषित करें और उसे बताएं कि उसे आईपी एड्रेस आवंटित करना शुरू करना चाहिए
आवंटन योग्य बिट्स को परिभाषित करने के लिए मास्क 10.1.1.0 का उपयोग करके नेटवर्क 255.255.255.0 से। द्वारा
डिफ़ॉल्ट रूप से आवंटित पते एक से शुरू होंगे और एकरस रूप से बढ़ेंगे, इसलिए पहले
इस आधार से आवंटित पता 10.1.1.1 होगा, उसके बाद 10.1.1.2, आदि होगा। निम्न
स्तर एनएस- 3 सिस्टम वास्तव में आवंटित सभी आईपी पते को याद रखता है और एक उत्पन्न करेगा
घातक त्रुटि यदि आप गलती से एक ही पता दो बार उत्पन्न कर देते हैं (जो कि एक है)।
वैसे, त्रुटि को डीबग करना बहुत कठिन है)।

कोड की अगली पंक्ति,

Ipv4InterfaceContainer इंटरफ़ेस = पता.असाइन (डिवाइस);

वास्तविक पता असाइनमेंट निष्पादित करता है। में एनएस- 3 हम एक आईपी के बीच संबंध बनाते हैं
पता और एक उपकरण का उपयोग कर आईपीवी4इंटरफेस वस्तु। जैसे हमें कभी-कभी एक सूची की आवश्यकता होती है
भविष्य में संदर्भ के लिए किसी सहायक द्वारा बनाए गए नेट उपकरणों की हमें कभी-कभी एक सूची की आवश्यकता होती है
आईपीवी4इंटरफेस वस्तुओं। IPv4InterfaceContainer यह कार्यक्षमता प्रदान करता है।

अब हमारे पास एक पॉइंट-टू-पॉइंट नेटवर्क निर्मित है, जिसमें स्टैक स्थापित हैं और आईपी पते हैं
सौंपा गया। इस बिंदु पर हमें ट्रैफ़िक उत्पन्न करने वाले एप्लिकेशन की आवश्यकता है।

अनुप्रयोगों
एनएस-3 प्रणाली का एक और मुख्य सार है आवेदन. इस में
स्क्रिप्ट में हम कोर की दो विशेषज्ञताओं का उपयोग करते हैं एनएस- 3 कक्षा आवेदन बुलाया
UdpEchoServerअनुप्रयोग और UdpEchoClientएप्लिकेशन. ठीक वैसे ही जैसे हमारे अतीत में था
स्पष्टीकरण, हम अंतर्निहित वस्तुओं को कॉन्फ़िगर और प्रबंधित करने में सहायता के लिए सहायक वस्तुओं का उपयोग करते हैं।
यहाँ, हम उपयोग करते हैं UdpEchoServerHelper और UdpEchoClientHelper हमारे जीवन को आसान बनाने वाली वस्तुएँ।

UdpEchoServerHelper
हमारी उदाहरण स्क्रिप्ट में कोड की निम्नलिखित पंक्तियाँ, प्रथम.सीसी, का उपयोग यूडीपी इको स्थापित करने के लिए किया जाता है
हमारे द्वारा पहले बनाए गए नोड्स में से एक पर सर्वर एप्लिकेशन।

UdpEchoServerHelper इकोसर्वर (9);

एप्लिकेशनकंटेनर सर्वरएप्स = इकोसर्वर.इंस्टॉल (नोड्स.गेट (1));
सर्वरएप्स.स्टार्ट (सेकंड्स (1.0));
सर्वरएप्स.स्टॉप (सेकंड्स (10.0));

उपरोक्त स्निपेट में कोड की पहली पंक्ति घोषित करती है UdpEchoServerHelper. हमेशा की तरह,
यह स्वयं एप्लिकेशन नहीं है, यह एक ऑब्जेक्ट है जिसका उपयोग हमें वास्तविक बनाने में मदद करने के लिए किया जाता है
अनुप्रयोग। हमारा एक सम्मेलन रखना है अपेक्षित गुण सहायक में
निर्माता. इस मामले में, सहायक तब तक कुछ भी उपयोगी नहीं कर सकता जब तक कि उसे उपलब्ध न कराया जाए
एक पोर्ट नंबर जिसके बारे में ग्राहक को भी पता होता है। सिर्फ एक को चुनने और उम्मीद करने के बजाय
यह सब काम करता है, हमें कंस्ट्रक्टर के पैरामीटर के रूप में पोर्ट नंबर की आवश्यकता होती है।
कंस्ट्रक्टर, बदले में, बस एक करता है गुण सेट करें पारित मूल्य के साथ. यदि आप चाहें, तो आप
"पोर्ट" सेट कर सकते हैं विशेषता बाद में किसी अन्य मान का उपयोग करना गुण सेट करें.

कई अन्य सहायक वस्तुओं के समान, UdpEchoServerHelper ऑब्जेक्ट में एक है स्थापित करें
तरीका। यह इस पद्धति का निष्पादन है जो वास्तव में अंतर्निहित प्रतिध्वनि का कारण बनता है
सर्वर एप्लिकेशन को तत्काल चालू किया जाएगा और एक नोड से जोड़ा जाएगा। दिलचस्प बात यह है कि स्थापित करें
विधि एक लेता है नोडकंटेनर दूसरे की तरह ही एक पैरामीटर के रूप में स्थापित करें हमारे पास जो तरीके हैं
देखा गया। यह वास्तव में वही है जो विधि को पारित किया जाता है, भले ही यह ऐसा न लगे
इस मामले में। एक C++ है अंतर्निहित रूपांतरण यहाँ काम पर जो परिणाम लेता है
नोड्स.प्राप्त करें (1) (जो एक स्मार्ट पॉइंटर को एक नोड ऑब्जेक्ट पर लौटाता है --- पीटीआर) और उसका उपयोग करता है
एक अनाम के लिए एक कंस्ट्रक्टर में नोडकंटेनर फिर उसे पास कर दिया जाता है स्थापित करें। अगर आप
कभी भी संकलित और चलने वाले C++ कोड में एक विशेष विधि हस्ताक्षर ढूंढने में कठिनाई होती है
ठीक है, इस प्रकार के अंतर्निहित रूपांतरणों को देखें।

अब हम इसे देखते हैं इकोसर्वर.इंस्टॉल करें स्थापित करने जा रहा है UdpEchoServerअनुप्रयोग पर
के सूचकांक क्रमांक एक पर नोड पाया गया नोडकंटेनर हम अपने नोड्स का प्रबंधन करते थे। स्थापित करें
एक कंटेनर लौटाएगा जिसमें सभी अनुप्रयोगों के लिए पॉइंटर्स होंगे (इस मामले में एक)।
चूँकि हमने ए पास कर लिया है नोडकंटेनर जिसमें एक नोड शामिल है) सहायक द्वारा बनाया गया।

एप्लिकेशन को ट्रैफ़िक उत्पन्न करने के लिए "प्रारंभ" करने के लिए एक समय की आवश्यकता होती है और इसमें वैकल्पिक समय लग सकता है
"रुकना"। हम दोनों प्रदान करते हैं. ये समय का उपयोग करके निर्धारित किए जाते हैं एप्लीकेशनकंटेनर तरीकों
प्रारंभ और रुकें. ये तरीके अपनाते हैं पहर पैरामीटर. इस मामले में, हम एक का उपयोग करते हैं स्पष्ट सी + +
C++ डबल 1.0 लेने और इसे एक में बदलने के लिए रूपांतरण अनुक्रम एनएस- 3 पहर वस्तु का उपयोग
a सेकंड ढालना। ध्यान रखें कि रूपांतरण नियमों को मॉडल लेखक द्वारा नियंत्रित किया जा सकता है,
और C++ के अपने नियम हैं, इसलिए आप हमेशा यह नहीं मान सकते कि पैरामीटर ख़ुशी से होंगे
आपके लिए परिवर्तित. दो पंक्तियाँ,

सर्वरएप्स.स्टार्ट (सेकंड्स (1.0));
सर्वरएप्स.स्टॉप (सेकंड्स (10.0));

इको सर्वर एप्लिकेशन का कारण बनेगा प्रारंभ (स्वयं को सक्षम करें) एक सेकंड में
अनुकरण और करने के लिए रुकें (स्वयं को अक्षम करें) सिमुलेशन में दस सेकंड में। के आधार पर
तथ्य यह है कि हमने एक सिमुलेशन इवेंट (एप्लिकेशन स्टॉप इवेंट) घोषित किया है
दस सेकंड में निष्पादित, अनुकरण चलेगा at कम से कम दस सेकंड।

UdpEchoClientHelper
इको क्लाइंट एप्लिकेशन को काफी हद तक उसी विधि के समान सेट किया गया है
सर्वर. एक अंतर्निहित बात है UdpEchoClientएप्लिकेशन जिसका प्रबंधन एक द्वारा किया जाता है
UdpEchoClientHelper.

UdpEchoClientHelper इकोक्लाइंट (इंटरफ़ेस.गेटएड्रेस (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("अंतराल", टाइमवैल्यू (सेकंड (1.0)));
echoClient.SetAttribute ("पैकेटसाइज़", UintegerValue (1024));

एप्लिकेशनकंटेनर क्लाइंटएप्स = इकोक्लाइंट.इंस्टॉल (नोड्स.गेट (0));
clientApps.Start (सेकेंड (2.0));
clientApps.Stop (सेकेंड (10.0));

हालाँकि, इको क्लाइंट के लिए, हमें पाँच अलग-अलग सेट करने की आवश्यकता है गुण. पहले दो
गुण के निर्माण के दौरान स्थापित किए गए हैं UdpEchoClientHelper. हम पैरामीटर पास करते हैं
जिनका उपयोग (आंतरिक रूप से सहायक के लिए) "रिमोटएड्रेस" और "रिमोटपोर्ट" को सेट करने के लिए किया जाता है
गुण हमारे सम्मेलन के अनुसार आवश्यक बनाना गुण में पैरामीटर
सहायक निर्माता.

याद रखें कि हमने एक का उपयोग किया था IPv4InterfaceContainer हम आईपी पतों पर नज़र रखने के लिए
हमारे उपकरणों को सौंपा गया। में शून्य इंटरफ़ेस इंटरफेस कंटेनर जा रहा है
में शून्य नोड के आईपी पते के अनुरूप है नोड्स कंटेनर. पहला
इंटरफ़ेस में इंटरफेस कंटेनर पहले नोड के आईपी पते से मेल खाता है
la नोड्स कंटेनर. तो, कोड की पहली पंक्ति में (ऊपर से), हम बना रहे हैं
सहायक और इसे बताकर क्लाइंट के दूरस्थ पते को आईपी पते के रूप में सेट करें
उस नोड को असाइन किया गया है जिस पर सर्वर स्थित है। हम इसे भेजने की व्यवस्था करने के लिए भी कहते हैं
पोर्ट नौ पर पैकेट।

"मैक्सपैकेट्स" विशेषता क्लाइंट को बताता है कि हम उसे अधिकतम कितने पैकेट की अनुमति देते हैं
अनुकरण के दौरान भेजें. अंतराल" विशेषता ग्राहक को बताता है कि कब तक इंतजार करना है
पैकेट और "पैकेट आकार" के बीच विशेषता क्लाइंट को बताता है कि उसका पैकेट कितना बड़ा है
पेलोड होना चाहिए. इस विशेष संयोजन के साथ गुण, हम बता रहे हैं
ग्राहक को एक 1024-बाइट पैकेट भेजना होगा।

जैसे कि इको सर्वर के मामले में, हम इको क्लाइंट को बताते हैं प्रारंभ और रुकें, परंतु
यहां हम सर्वर सक्षम होने के एक सेकंड बाद (दो सेकंड में) क्लाइंट शुरू करते हैं
अनुकरण)।

सिम्युलेटर
इस बिंदु पर हमें वास्तव में सिमुलेशन चलाने की आवश्यकता है। इसका प्रयोग करके किया जाता है
वैश्विक कार्य सिम्युलेटर::चलाएँ.

सिम्युलेटर :: रन ();

जब हमने पहले विधियों को बुलाया था,

सर्वरएप्स.स्टार्ट (सेकंड्स (1.0));
सर्वरएप्स.स्टॉप (सेकंड्स (10.0));
...
clientApps.Start (सेकेंड (2.0));
clientApps.Stop (सेकेंड (10.0));

हमने वास्तव में सिम्युलेटर में 1.0 सेकंड, 2.0 सेकंड और दो घटनाओं पर कार्यक्रम निर्धारित किए
10.0 सेकंड पर. कब सिम्युलेटर::चलाएँ कहा जाता है, सिस्टम देखना शुरू कर देगा
निर्धारित घटनाओं की सूची और उन्हें क्रियान्वित करना। सबसे पहले यह इवेंट को 1.0 सेकंड पर चलाएगा,
जो इको सर्वर एप्लिकेशन को सक्षम करेगा (यह ईवेंट, बदले में, कई शेड्यूल कर सकता है
अन्य घटनाएँ)। फिर यह t=2.0 सेकंड के लिए निर्धारित इवेंट चलाएगा जो शुरू हो जाएगा
इको क्लाइंट एप्लिकेशन। फिर, यह इवेंट कई और इवेंट शेड्यूल कर सकता है। प्रारंभ
इको क्लाइंट एप्लिकेशन में ईवेंट कार्यान्वयन डेटा ट्रांसफर चरण शुरू करेगा
सर्वर पर एक पैकेट भेजकर सिमुलेशन।

सर्वर पर पैकेट भेजने का कार्य घटनाओं की एक श्रृंखला को ट्रिगर करेगा
पर्दे के पीछे स्वचालित रूप से शेड्यूल किया गया है और जो के यांत्रिकी का प्रदर्शन करेगा
पैकेट इको विभिन्न समय मापदंडों के अनुसार होता है जो हमने स्क्रिप्ट में निर्धारित किए हैं।

अंततः, चूंकि हम केवल एक पैकेट भेजते हैं (याद रखें)। मैक्सपैकेट्स विशेषता करने के लिए स्थापित किया गया था
एक), उस एकल क्लाइंट इको अनुरोध द्वारा ट्रिगर की गई घटनाओं की श्रृंखला कम हो जाएगी और
सिमुलेशन निष्क्रिय हो जाएगा. एक बार ऐसा हो जाने पर, शेष घटनाएँ होंगी रुकें
सर्वर और क्लाइंट के लिए ईवेंट। जब इन घटनाओं को क्रियान्वित किया जाता है, तो कोई नहीं होता है
आगे की घटनाओं को संसाधित करने के लिए और सिम्युलेटर::चलाएँ रिटर्न. इसके बाद सिमुलेशन पूरा हो गया है।

जो कुछ बचा है वह सफाई करना है। यह वैश्विक फ़ंक्शन को कॉल करके किया जाता है
सिम्युलेटर::नष्ट करें. जैसा कि सहायक कार्य करता है (या निम्न स्तर एनएस- 3 कोड) निष्पादित, वे
इसे इस प्रकार व्यवस्थित किया गया कि सभी वस्तुओं को नष्ट करने के लिए सिम्युलेटर में हुक डाले गए
जो बनाए गए थे. आपको इनमें से किसी भी वस्तु का स्वयं ट्रैक रखने की आवश्यकता नहीं थी ---
आपको बस कॉल करना था सिम्युलेटर::नष्ट करें और बाहर निकलें. एनएस- 3 सिस्टम का ख्याल रखा
आपके लिए कठिन हिस्सा. हमारी पहली की शेष पंक्तियाँ एनएस- 3 स्क्रिप्ट, प्रथम.सीसी, बस करो
कि:

सिम्युलेटर::नष्ट करें ();
0 वापसी;
}

. la सिम्युलेटर मर्जी रुकें?
एनएस- 3 एक असतत घटना (डीई) सिम्युलेटर है। ऐसे सिम्युलेटर में, प्रत्येक घटना जुड़ी होती है
इसके निष्पादन समय के साथ, और सिमुलेशन अस्थायी रूप से घटनाओं को निष्पादित करके आगे बढ़ता है
अनुकरण समय का क्रम. ईवेंट के कारण भविष्य में ईवेंट शेड्यूल किए जा सकते हैं (उदाहरण के लिए, a
टाइमर अगले अंतराल पर समाप्त होने के लिए स्वयं को पुनर्निर्धारित कर सकता है)।

प्रारंभिक घटनाएँ आमतौर पर प्रत्येक ऑब्जेक्ट द्वारा ट्रिगर की जाती हैं, उदाहरण के लिए, IPv6 राउटर को शेड्यूल करेगा
विज्ञापन, पड़ोसी आग्रह आदि, एक एप्लिकेशन पहले पैकेट को शेड्यूल करता है
ईवेंट भेजना, आदि

जब किसी ईवेंट को संसाधित किया जाता है, तो यह शून्य, एक या अधिक ईवेंट उत्पन्न कर सकता है। एक अनुकरण के रूप में
निष्पादित होता है, ईवेंट का उपभोग हो जाता है, लेकिन अधिक ईवेंट उत्पन्न हो सकते हैं (या नहीं भी)।
जब कोई अन्य ईवेंट ईवेंट कतार में न हो, या जब हो तो सिमुलेशन स्वचालित रूप से बंद हो जाएगा
एक विशेष स्टॉप इवेंट मिला है। स्टॉप इवेंट के माध्यम से बनाया गया है सिम्युलेटर::रुकें
(रुकने का समय); समारोह.

वहाँ एक विशिष्ट मामला है जहाँ सिम्युलेटर::रुकें को रोकना नितांत आवश्यक है
अनुकरण: जब कोई आत्मनिर्भर घटना होती है। आत्मनिर्भर (या आवर्ती) घटनाएँ
ऐसी घटनाएँ हैं जो हमेशा स्वयं को पुनर्निर्धारित करती हैं। परिणामस्वरूप, वे हमेशा आयोजन करते रहते हैं
कतार खाली नहीं है.

ऐसे कई प्रोटोकॉल और मॉड्यूल हैं जिनमें आवर्ती घटनाएं शामिल हैं, उदाहरण के लिए:

· फ़्लोमॉनिटर - खोए हुए पैकेटों की समय-समय पर जाँच

· RIPng - रूटिंग टेबल अपडेट का आवधिक प्रसारण

· वगैरह।

ऐसे मामलों में, सिम्युलेटर::रुकें अनुकरण को शालीनता से रोकने के लिए आवश्यक है। में
इसके अलावा, कब एनएस- 3 अनुकरण मोड में है, रीयलटाइम सिम्युलेटर रखने के लिए प्रयोग किया जाता है
मशीन घड़ी के साथ संरेखित सिमुलेशन घड़ी, और सिम्युलेटर::रुकें रोकना जरूरी है
प्रक्रिया।

ट्यूटोरियल में कई सिमुलेशन प्रोग्राम स्पष्ट रूप से कॉल नहीं करते हैं सिम्युलेटर::रुकें,
चूँकि ईवेंट कतार स्वचालित रूप से ईवेंट से बाहर हो जाएगी। हालाँकि, ये कार्यक्रम होंगे
को कॉल भी स्वीकार करें सिम्युलेटर::रुकें. उदाहरण के लिए, निम्नलिखित अतिरिक्त कथन
पहला उदाहरण प्रोग्राम 11 सेकंड पर एक स्पष्ट स्टॉप शेड्यूल करेगा:

+ सिम्युलेटर::स्टॉप (सेकेंड (11.0));
सिम्युलेटर :: रन ();
सिम्युलेटर::नष्ट करें ();
0 वापसी;
}

उपरोक्त से वास्तव में इस प्रोग्राम का व्यवहार नहीं बदलेगा, क्योंकि यह विशेष है
सिमुलेशन स्वाभाविक रूप से 10 सेकंड के बाद समाप्त हो जाता है। लेकिन अगर आपको रुकने का समय बदलना है
उपरोक्त कथन 11 सेकंड से 1 सेकंड तक, आप देखेंगे कि अनुकरण
किसी भी आउटपुट को स्क्रीन पर प्रिंट होने से पहले रुक जाता है (क्योंकि आउटपुट समय 2 के आसपास होता है
सिमुलेशन समय के सेकंड)।

कॉल करना ज़रूरी है सिम्युलेटर::रुकें से पहले बुला सिम्युलेटर::चलाएँ; अन्यथा,
सिम्युलेटर::चलाएँ स्टॉप को निष्पादित करने के लिए मुख्य प्रोग्राम पर नियंत्रण कभी नहीं लौटाया जा सकता है!

इमारत आपका लिपि
हमने आपकी सरल स्क्रिप्ट बनाना आसान बना दिया है। आपको बस अपना ड्रॉप करना है
स्क्रिप्ट को स्क्रैच निर्देशिका में डालें और यदि आप Waf चलाते हैं तो यह स्वचालित रूप से बन जाएगी।
चलो यह कोशिश करते हैं। प्रतिलिपि उदाहरण/ट्यूटोरियल/first.cc में खरोंच निर्देशिका बदलने के बाद
शीर्ष स्तरीय निर्देशिका में वापस जाएँ।

$ cd ।।/ ..
$ सीपी उदाहरण/ट्यूटोरियल/फर्स्ट.सीसी स्क्रैच/मायफर्स्ट.सीसी

अब waf का उपयोग करके अपनी पहली उदाहरण स्क्रिप्ट बनाएं:

$ ./वफ़ा

आपको संदेश देखना चाहिए कि आपका मेरा पहला उदाहरण सफलतापूर्वक बनाया गया था.

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
[614/708] सीएक्सएक्स: स्क्रैच/मायफर्स्ट.सीसी -> बिल्ड/डीबग/स्क्रैच/मायफर्स्ट_3.ओ
[706/708] cxx_link: बिल्ड/डीबग/स्क्रैच/मायफर्स्ट_3.ओ -> बिल्ड/डीबग/स्क्रैच/मायफर्स्ट
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (2.357 सेकंड)

अब आप उदाहरण चला सकते हैं (ध्यान दें कि यदि आप अपना प्रोग्राम स्क्रैच निर्देशिका में बनाते हैं
आपको इसे स्क्रैच निर्देशिका से बाहर चलाना होगा):

$ ./waf --रन स्क्रैच/मायफर्स्ट

आपको कुछ आउटपुट देखना चाहिए:

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.418 सेकंड)
1024 पर 10.1.1.2 बाइट्स भेजी गईं
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
1024 से 10.1.1.2 बाइट्स प्राप्त हुए

यहां आप देखते हैं कि बिल्ड सिस्टम यह सुनिश्चित करने के लिए जांच करता है कि फ़ाइल बनाई गई है और
फिर उसे चलाता है. आप इको क्लाइंट पर लॉगिंग घटक देखते हैं जो दर्शाता है कि उसने भेजा है
1024 पर इको सर्वर पर एक 10.1.1.2 बाइट पैकेट। आप लॉगिंग घटक भी देखें
इको सर्वर पर कहा गया है कि उसे 1024 से 10.1.1.1 बाइट्स प्राप्त हुए हैं। इको सर्वर
चुपचाप पैकेट को प्रतिध्वनित करता है और आप प्रतिध्वनि क्लाइंट लॉग देखते हैं कि उसे अपना पैकेट प्राप्त हो गया है
सर्वर से वापस.

एनएस -3 स्रोत कोड
अब जबकि आपने इनमें से कुछ का उपयोग कर लिया है एनएस- 3 सहायकों में से कुछ पर आप एक नज़र डालना चाहेंगे
स्रोत कोड जो उस कार्यक्षमता को कार्यान्वित करता है। नवीनतम कोड को ब्राउज किया जा सकता है
हमारा वेब सर्वर निम्नलिखित लिंक पर है: http://code.nsnam.org/ns-3-dev. वहां आप देखेंगे
हमारे लिए मर्क्यूरियल सारांश पृष्ठ एनएस- 3 विकास वृक्ष.

पृष्ठ के शीर्ष पर, आपको कई लिंक दिखाई देंगे,

सारांश | शॉर्टलॉग | चेंजलॉग | ग्राफ | टैग | फ़ाइलें

आगे बढ़ें और चुनें फ़ाइलों जोड़ना। हममें से अधिकांश का शीर्ष स्तर यही है
खजाने देखेंगे:

drwxr-xr-x [ऊपर]
drwxr-xr-x बाइंडिंग पायथन फ़ाइलें
drwxr-xr-x दस्तावेज़ फ़ाइलें
drwxr-xr-x उदाहरण फ़ाइलें
drwxr-xr-x ns3 फ़ाइलें
drwxr-xr-x स्क्रैच फ़ाइलें
drwxr-xr-x src फ़ाइलें
drwxr-xr-x यूटिल्स फ़ाइलें
-rw-r--r-- 2009-07-01 12:47 +0200 560 .hगिग्नोर फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 1886 .hgtags फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 1276 लेखक फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 30961 CHANGES.html फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 17987 लाइसेंस फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 3742 रीडमी फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 16171 RELEASE_NOTES फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 6 संस्करण फ़ाइल | संशोधन | एन्नोटेट
-rwxr-xr-x 2009-07-01 12:47 +0200 88110 waf फ़ाइल | संशोधन | एन्नोटेट
-rwxr-xr-x 2009-07-01 12:47 +0200 28 waf.bat फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 35395 wscript फ़ाइल | संशोधन | एन्नोटेट
-rw-r--r-- 2009-07-01 12:47 +0200 7673 wutils.py फ़ाइल | संशोधन | एन्नोटेट

हमारी उदाहरण स्क्रिप्टें इसमें हैं उदाहरण निर्देशिका। यदि आप क्लिक करते हैं उदाहरण तुम देखोगे
उपनिर्देशिकाओं की एक सूची. फ़ाइलों में से एक ट्यूटोरियल उपनिर्देशिका है प्रथम.सीसी. आप अगर
पर क्लिक करें प्रथम.सीसी आपको वह कोड मिल जाएगा जिससे आप अभी गुजरे हैं।

स्रोत कोड मुख्य रूप से है " निर्देशिका। आप स्रोत कोड को या तो देख सकते हैं
निर्देशिका नाम पर क्लिक करके या पर क्लिक करके फ़ाइलों के दाईं ओर लिंक करें
निर्देशिका का नाम. यदि आप पर क्लिक करते हैं " निर्देशिका, आपको सूची में ले जाया जाएगा
la " उपनिर्देशिकाएँ अगर आप फिर क्लिक करें मूल उपनिर्देशिका, आपको इसकी एक सूची मिलेगी
फ़ाइलें. पहली फ़ाइल जो आपको मिलेगी (इस लेखन के समय) वह है गर्भपात.एच. यदि आप पर क्लिक करते हैं
गर्भपात.एच लिंक, आपको स्रोत फ़ाइल पर भेजा जाएगा गर्भपात.एच जिसमें उपयोगी मैक्रोज़ शामिल हैं
असामान्य स्थितियों का पता चलने पर स्क्रिप्ट से बाहर निकलने के लिए।

इस अध्याय में हमने जिन सहायकों का उपयोग किया है उनका स्रोत कोड यहां पाया जा सकता है
स्रोत/अनुप्रयोग/सहायक निर्देशिका। पाने के लिए बेझिझक डायरेक्टरी ट्री में इधर-उधर ताक-झांक करें
वहाँ क्या है और उसकी शैली का एहसास एनएस- 3 कार्यक्रम.

ट्वीक

का प्रयोग la लॉगिंग मॉड्यूल
हम पहले ही इस पर एक संक्षिप्त नज़र डाल चुके हैं एनएस- 3 लॉगिंग मॉड्यूल पर जाते समय
प्रथम.सीसी लिखी हुई कहानी। अब हम बारीकी से देखेंगे और देखेंगे कि किस प्रकार के उपयोग के मामले हैं
लॉगिंग सबसिस्टम को कवर करने के लिए डिज़ाइन किया गया था।

लॉगिंग अवलोकन
कई बड़े सिस्टम किसी प्रकार की संदेश लॉगिंग सुविधा का समर्थन करते हैं, और एनएस- 3 नहीं है
अपवाद। कुछ मामलों में, केवल त्रुटि संदेश "ऑपरेटर कंसोल" पर लॉग किए जाते हैं (जो
आम तौर पर है stderr यूनिक्स-आधारित प्रणालियों में)। अन्य प्रणालियों में, चेतावनी संदेश हो सकते हैं
आउटपुट के साथ-साथ अधिक विस्तृत सूचनात्मक संदेश भी। कुछ मामलों में, लॉगिंग सुविधाएं
डिबग संदेशों को आउटपुट करने के लिए उपयोग किया जाता है जो आउटपुट को जल्दी से धुंधला कर सकता है।

एनएस- 3 यह विचार करता है कि ये सभी शब्दाडंबर स्तर उपयोगी हैं और हम एक प्रदान करते हैं
संदेश लॉगिंग के लिए चयन योग्य, बहु-स्तरीय दृष्टिकोण। लॉगिंग को पूरी तरह से अक्षम किया जा सकता है,
घटक-दर-घटक आधार पर सक्षम, या विश्व स्तर पर सक्षम; और यह चयन योग्य प्रदान करता है
वाचालता स्तर. एनएस- 3 लॉग मॉड्यूल एक सीधा, उपयोग करने में अपेक्षाकृत आसान प्रदान करता है
अपने सिमुलेशन से उपयोगी जानकारी प्राप्त करने का तरीका।

आपको यह समझना चाहिए कि हम एक सामान्य प्रयोजन तंत्र --- ट्रेसिंग --- प्रदान करते हैं
अपने मॉडलों से डेटा प्राप्त करें जिसे सिमुलेशन आउटपुट के लिए प्राथमिकता दी जानी चाहिए (देखें)।
हमारे ट्रेसिंग सिस्टम पर अधिक जानकारी के लिए ट्यूटोरियल अनुभाग ट्रेसिंग सिस्टम का उपयोग करना)।
डिबगिंग जानकारी, चेतावनियों, त्रुटि संदेशों या किसी भी चीज़ के लिए लॉगिंग को प्राथमिकता दी जानी चाहिए
जब आप आसानी से अपनी स्क्रिप्ट या मॉडल से त्वरित संदेश प्राप्त करना चाहते हैं।

वर्तमान में बढ़ती वाचालता के लॉग संदेशों के सात स्तर परिभाषित हैं
प्रणाली।

· LOG_ERROR --- लॉग त्रुटि संदेश (संबद्ध मैक्रो: NS_LOG_ERROR);

· LOG_WARN --- चेतावनी संदेश लॉग करें (संबद्ध मैक्रो: NS_LOG_WARN);

· LOG_DEBUG --- अपेक्षाकृत दुर्लभ, तदर्थ डिबगिंग संदेशों को लॉग करें (संबद्ध मैक्रो:
एनएस_लॉग_डीईबीयूजी);

· LOG_INFO --- कार्यक्रम की प्रगति के बारे में सूचनात्मक संदेश लॉग करें (संबद्ध मैक्रो:
एनएस_लॉग_इन्फो);

· LOG_FUNCTION --- नामक प्रत्येक फ़ंक्शन का वर्णन करने वाला एक संदेश लॉग करें (दो संबद्ध मैक्रोज़:
NS_LOG_FUNCTION, सदस्य कार्यों के लिए उपयोग किया जाता है, और NS_LOG_FUNCTION_NOARGS, स्थिर के लिए उपयोग किया जाता है
कार्य);

· LOG_LOGIC - किसी फ़ंक्शन के भीतर तार्किक प्रवाह का वर्णन करने वाले लॉग संदेश (संबद्ध मैक्रो:
एनएस_लॉग_लॉजिक);

· LOG_ALL --- ऊपर उल्लिखित सभी चीज़ों को लॉग करें (कोई संबद्ध मैक्रो नहीं)।

प्रत्येक LOG_TYPE के लिए LOG_LEVEL_TYPE भी है, जिसका उपयोग करने पर, सभी की लॉगिंग सक्षम हो जाती है
इसके स्तर के अतिरिक्त इसके ऊपर के स्तर। (इसके परिणामस्वरूप, LOG_ERROR और
LOG_LEVEL_ERROR और LOG_ALL और LOG_LEVEL_ALL कार्यात्मक रूप से समतुल्य हैं।)
उदाहरण के लिए, LOG_INFO को सक्षम करने से केवल NS_LOG_INFO मैक्रो द्वारा प्रदान किए गए संदेश ही सक्षम होंगे
LOG_LEVEL_INFO को सक्षम करने से NS_LOG_DEBUG, NS_LOG_WARN द्वारा प्रदान किए गए संदेश भी सक्षम हो जाएंगे
और NS_LOG_ERROR मैक्रोज़।

हम एक बिना शर्त लॉगिंग मैक्रो भी प्रदान करते हैं जो हमेशा प्रदर्शित होता है, चाहे कुछ भी हो
लॉगिंग स्तर या घटक चयन।

· NS_LOG_UNCOND -- संबंधित संदेश को बिना शर्त लॉग करें (कोई संबद्ध लॉग स्तर नहीं)।

प्रत्येक स्तर का अनुरोध अकेले या संचयी रूप से किया जा सकता है; और लॉगिंग का उपयोग करके सेट किया जा सकता है
शेल पर्यावरण चर (NS_LOG) या सिस्टम फ़ंक्शन कॉल लॉग करके। जैसा कि देखने को मिला
पहले ट्यूटोरियल में, लॉगिंग सिस्टम में डॉक्सीजन दस्तावेज़ीकरण था और अब होगा
यदि आपने ऐसा नहीं किया है तो लॉगिंग मॉड्यूल दस्तावेज़ का अध्ययन करने का अच्छा समय है।

अब जब आपने दस्तावेज़ को विस्तार से पढ़ लिया है, तो आइए उस ज्ञान का कुछ उपयोग करें
कुछ रोचक जानकारी प्राप्त करने के लिए स्क्रैच/मायफर्स्ट.सीसी उदाहरण स्क्रिप्ट आपके पास है
पहले से ही निर्मित.

सक्षम करने से लॉगिंग
आइए कुछ और लॉगिंग चालू करने के लिए NS_LOG पर्यावरण चर का उपयोग करें, लेकिन पहले, बस
हमारा मार्गदर्शन प्राप्त करें, आगे बढ़ें और अंतिम स्क्रिप्ट वैसे ही चलाएँ जैसे आपने पहले चलाया था,

$ ./waf --रन स्क्रैच/मायफर्स्ट

आपको पहले का अब परिचित आउटपुट देखना चाहिए एनएस- 3 उदाहरण कार्यक्रम

$ Waf: निर्देशिका दर्ज करना `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.413 सेकंड)
1024 पर 10.1.1.2 बाइट्स भेजी गईं
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
1024 से 10.1.1.2 बाइट्स प्राप्त हुए

इससे पता चलता है कि जो "भेजे गए" और "प्राप्त" संदेश आप ऊपर देख रहे हैं वे वास्तव में लॉगिंग कर रहे हैं
से संदेश UdpEchoClientएप्लिकेशन और UdpEchoServerअनुप्रयोग. हम पूछ सकते हैं
क्लाइंट एप्लिकेशन, उदाहरण के लिए, अपना लॉगिंग स्तर सेट करके अधिक जानकारी मुद्रित करने के लिए
NS_LOG पर्यावरण चर के माध्यम से।

मैं यहां से यह मानने जा रहा हूं कि आप एक श-जैसे शेल का उपयोग कर रहे हैं जो उपयोग करता है
"वैरिएबल=वैल्यू" सिंटैक्स। यदि आप सीएसएच-जैसे शेल का उपयोग कर रहे हैं, तो आपको करना होगा
मेरे उदाहरणों को उन शेल्स के लिए आवश्यक "सेटेनव वैरिएबल वैल्यू" सिंटैक्स में बदलें।

अभी, यूडीपी इको क्लाइंट एप्लिकेशन कोड की निम्नलिखित पंक्ति पर प्रतिक्रिया दे रहा है
स्क्रैच/मायफर्स्ट.सीसी,

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);

कोड की यह पंक्ति सक्षम बनाती है LOG_LEVEL_INFO लॉगिंग का स्तर. जब हम लॉगिंग पास करते हैं
लेवल फ़्लैग, हम वास्तव में दिए गए स्तर और सभी निचले स्तरों को सक्षम कर रहे हैं। इस मामले में,
हमने सक्षम कर दिया है एनएस_लॉग_इन्फो, एनएस_लॉग_डेबग, एनएस_लॉग_चेतावनी और एनएस_लॉग_एरर. हम बढ़ा सकते हैं
लॉगिंग स्तर और स्क्रिप्ट को बदले बिना और पुनः संकलित किए बिना अधिक जानकारी प्राप्त करें
NS_LOG पर्यावरण चर को इस प्रकार सेट करना:

$ निर्यात NS_LOG=UdpEchoClientApplication=level_all

यह शेल पर्यावरण चर सेट करता है एनएस_लॉग स्ट्रिंग के लिए,

UdpEchoClient अनुप्रयोग = Level_all

असाइनमेंट के बाईं ओर लॉगिंग घटक का नाम है जिसे हम सेट करना चाहते हैं,
और दाहिनी ओर वह ध्वज है जिसका हम उपयोग करना चाहते हैं। इस मामले में, हम चालू करने जा रहे हैं
एप्लिकेशन के लिए सभी डिबगिंग स्तर। यदि आप स्क्रिप्ट को NS_LOG सेट के साथ चलाते हैं
इस तरह, एनएस- 3 लॉगिंग सिस्टम परिवर्तन को उठाएगा और आपको निम्नलिखित देखना चाहिए
उत्पादन:

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.404 सेकंड)
UdpEchoClientएप्लिकेशन: UdpEchoClient()
UdpEchoClientएप्लिकेशन:सेटडेटाआकार(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientएप्लिकेशन: शेड्यूलट्रांसमिट()
UdpEchoClientएप्लिकेशन:भेजें()
1024 पर 10.1.1.2 बाइट्स भेजी गईं
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
1024 से 10.1.1.2 बाइट्स प्राप्त हुए
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose ()
UdpEchoClientएप्लिकेशन:~UdpEchoClient()

एप्लिकेशन द्वारा प्रदान की गई अतिरिक्त डिबग जानकारी NS_LOG_FUNCTION से है
स्तर। यह हर बार दिखाता है कि स्क्रिप्ट के दौरान एप्लिकेशन में कोई फ़ंक्शन कॉल किया जाता है
कार्यान्वयन। आम तौर पर, सदस्य कार्यों में (कम से कम) NS_LOG_FUNCTION(this) का उपयोग होता है
पसंदीदा। NS_LOG_FUNCTION_NOARGS() का उपयोग केवल स्थिर कार्यों में करें। हालाँकि, ध्यान दें
में कोई आवश्यकताएं नहीं हैं एनएस- 3 वह प्रणाली जिसे मॉडलों को किसी विशेष का समर्थन करना चाहिए
लॉगिंग कार्यक्षमता. कितनी जानकारी लॉग की गई है, इसका निर्णय उन पर छोड़ दिया गया है
व्यक्तिगत मॉडल डेवलपर। इको अनुप्रयोगों के मामले में, लॉग का एक अच्छा सौदा
आउटपुट उपलब्ध है.

अब आप एप्लिकेशन पर किए गए फ़ंक्शन कॉल का लॉग देख सकते हैं। अगर आप
ध्यान से देखें तो आपको स्ट्रिंग के बीच एक एकल कोलन दिखाई देगा UdpEchoClientएप्लिकेशन
और विधि का नाम जहां आपने C++ स्कोप ऑपरेटर की अपेक्षा की होगी (::) यह है
जानबूझकर।

नाम वास्तव में एक वर्ग का नाम नहीं है, यह एक लॉगिंग घटक का नाम है। जब वहाँ एक है
स्रोत फ़ाइल और कक्षा के बीच एक-से-एक पत्राचार, यह आम तौर पर होगा
क्लास का नाम लेकिन आपको यह समझना चाहिए कि यह वास्तव में क्लास का नाम नहीं है, और एक है
अपेक्षाकृत सूक्ष्म तरीके से आपको याद दिलाने के लिए डबल कोलन के बजाय सिंगल कोलन
लॉगिंग घटक नाम को क्लास नाम से अवधारणात्मक रूप से अलग करें।

यह पता चला है कि कुछ मामलों में, यह निर्धारित करना कठिन हो सकता है कि वास्तव में कौन सी विधि है
एक लॉग संदेश उत्पन्न करता है. यदि आप ऊपर दिए गए पाठ को देखें, तो आपको आश्चर्य हो सकता है कि स्ट्रिंग कहां है
"प्राप्त 1024 बाइट्स से 10.1.1.2" से आता है। आप इसे OR'ing द्वारा हल कर सकते हैं
उपसर्ग_func स्तर में एनएस_लॉग पर्यावरणपरिवर्ती तारक। निम्नलिखित करने का प्रयास करें,

$ निर्यात 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func'

ध्यान दें कि उद्धरण आवश्यक हैं क्योंकि ऊर्ध्वाधर पट्टी का उपयोग हम OR को इंगित करने के लिए करते हैं
ऑपरेशन भी एक यूनिक्स पाइप कनेक्टर है।

अब, यदि आप स्क्रिप्ट चलाते हैं तो आप देखेंगे कि लॉगिंग सिस्टम यह सुनिश्चित करता है कि प्रत्येक
दिए गए लॉग घटक से संदेश घटक नाम के साथ उपसर्ग किया गया है।

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.417 सेकंड)
UdpEchoClientएप्लिकेशन: UdpEchoClient()
UdpEchoClientएप्लिकेशन:सेटडेटाआकार(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientएप्लिकेशन: शेड्यूलट्रांसमिट()
UdpEchoClientएप्लिकेशन:भेजें()
UdpEchoClientApplication:Send(): 1024 पर 10.1.1.2 बाइट्स भेजे गए
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
UdpEchoClientApplication:HandleRead(): 1024 से 10.1.1.2 बाइट्स प्राप्त हुए
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose ()
UdpEchoClientएप्लिकेशन:~UdpEchoClient()

अब आप यूडीपी इको क्लाइंट एप्लिकेशन से आने वाले सभी संदेशों को देख सकते हैं
के रूप में पहचाना गया। संदेश "1024 से 10.1.1.2 बाइट्स प्राप्त हुए" अब स्पष्ट रूप से है
इको क्लाइंट एप्लिकेशन से आने के रूप में पहचाना गया। शेष संदेश होना चाहिए
यूडीपी इको सर्वर एप्लिकेशन से आ रहा है। हम a दर्ज करके उस घटक को सक्षम कर सकते हैं
NS_LOG पर्यावरण चर में घटकों की कोलन से अलग की गई सूची।

$ निर्यात 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func:
UdpEchoServerApplication=level_all|prefix_func'

चेतावनी: आपको इसके बाद नई लाइन को हटाना होगा : ऊपर दिए गए उदाहरण पाठ में
यह केवल दस्तावेज़ स्वरूपण प्रयोजनों के लिए है।

अब, यदि आप स्क्रिप्ट चलाते हैं तो आपको दोनों इको क्लाइंट के सभी लॉग संदेश दिखाई देंगे
और सर्वर अनुप्रयोग। आप देख सकते हैं कि यह डिबगिंग समस्याओं में बहुत उपयोगी हो सकता है।

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.406 सेकंड)
UdpEchoServerएप्लिकेशन: UdpEchoServer()
UdpEchoClientएप्लिकेशन: UdpEchoClient()
UdpEchoClientएप्लिकेशन:सेटडेटाआकार(1024)
UdpEchoServerApplication:StartApplication()
UdpEchoClientApplication:StartApplication()
UdpEchoClientएप्लिकेशन: शेड्यूलट्रांसमिट()
UdpEchoClientएप्लिकेशन:भेजें()
UdpEchoClientApplication:Send(): 1024 पर 10.1.1.2 बाइट्स भेजे गए
UdpEchoServerApplication:HandleRead(): 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
UdpEchoServerApplication:HandleRead(): इकोइंग पैकेट
UdpEchoClientएप्लिकेशन:हैंडलरीड(0x624920, 0x625160)
UdpEchoClientApplication:HandleRead(): 1024 से 10.1.1.2 बाइट्स प्राप्त हुए
UdpEchoServerएप्लिकेशन:स्टॉपएप्लिकेशन()
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose ()
UdpEchoServerएप्लिकेशन:DoDispose()
UdpEchoClientएप्लिकेशन:~UdpEchoClient()
UdpEchoServer अनुप्रयोग: ~ UdpEchoServer ()

कभी-कभी लॉग संदेश के सिमुलेशन समय को देखने में सक्षम होना भी उपयोगी होता है
उत्पन्न होता है। आप इसे prefix_time बिट में ORing करके कर सकते हैं।

$ निर्यात 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func|prefix_time:
UdpEchoServerApplication=level_all|prefix_func|prefix_time'

फिर से, आपको ऊपर दी गई नई लाइन को हटाना होगा। यदि आप अभी स्क्रिप्ट चलाते हैं, तो आपको ऐसा करना चाहिए
निम्नलिखित आउटपुट देखें:

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.418 सेकंड)
0s UdpEchoServerएप्लिकेशन: UdpEchoServer()
0s UdpEchoClientएप्लिकेशन: UdpEchoClient()
0s UdpEchoClientएप्लिकेशन:सेटडेटाआकार(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientएप्लिकेशन:भेजें()
2s UdpEchoClientApplication:Send(): 1024 बाइट्स 10.1.1.2 पर भेजा गया
2.00369s UdpEchoServerApplication:HandleRead(): 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
2.00369s UdpEchoServerApplication:HandleRead(): इकोइंग पैकेट
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): 1024 से 10.1.1.2 बाइट्स प्राप्त हुए
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose ()
UdpEchoServerएप्लिकेशन:DoDispose()
UdpEchoClientएप्लिकेशन:~UdpEchoClient()
UdpEchoServer अनुप्रयोग: ~ UdpEchoServer ()

आप देख सकते हैं कि UdpEchoServer के लिए कंस्ट्रक्टर को सिमुलेशन समय पर बुलाया गया था
0 सेकंड. यह वास्तव में सिमुलेशन शुरू होने से पहले हो रहा है, लेकिन समय आ गया है
शून्य सेकंड के रूप में प्रदर्शित किया गया। UdpEchoClient कंस्ट्रक्टर संदेश के लिए भी यही सच है।

याद करो कि स्क्रैच/फर्स्ट.सीसी स्क्रिप्ट ने एक सेकंड में इको सर्वर एप्लिकेशन शुरू कर दिया
अनुकरण में. अब आप देख सकते हैं कि आवेदन प्रारंभ करें सर्वर की विधि है,
वास्तव में, एक सेकंड में बुलाया गया। आप यह भी देख सकते हैं कि इको क्लाइंट एप्लिकेशन है
जैसा कि हमने स्क्रिप्ट में अनुरोध किया था, दो सेकंड के सिमुलेशन समय पर शुरू हुआ।

अब आप सिमुलेशन की प्रगति का अनुसरण कर सकते हैं शेड्यूलट्रांसमिट में कॉल करें
ग्राहक जो कॉल करता है भेजें को हैंडलरीड इको सर्वर एप्लिकेशन में कॉलबैक। टिप्पणी
पैकेट को पॉइंट-टू-पॉइंट लिंक पर भेजने का बीता हुआ समय 3.69 है
मिलीसेकंड. आप इको सर्वर को एक संदेश लॉग करते हुए देखते हैं जो आपको बताता है कि यह इको हो गया है
पैकेट और फिर, किसी अन्य चैनल की देरी के बाद, आप देखते हैं कि इको क्लाइंट को प्राप्त होता है
उसके में प्रतिध्वनित पैकेट हैंडलरीड विधि.

इस सिमुलेशन में पर्दे के पीछे बहुत कुछ ऐसा हो रहा है जो आप नहीं कर रहे हैं
देख भी रहे हैं. आप सभी को ऑन करके बहुत ही आसानी से पूरी प्रक्रिया का पालन कर सकते हैं
सिस्टम में लॉगिंग घटक। सेट करने का प्रयास करें एनएस_लॉग निम्नलिखित के लिए परिवर्तनीय,

$ निर्यात 'NS_LOG=*=level_all|prefix_func|prefix_time'

उपरोक्त तारांकन लॉगिंग घटक वाइल्डकार्ड है। यह सभी को चालू कर देगा
सिमुलेशन में प्रयुक्त सभी घटकों को लॉग इन करना। मैं आउटपुट पुन: प्रस्तुत नहीं करूंगा
यहाँ (इस लेखन के समय यह एकल पैकेट प्रतिध्वनि के लिए आउटपुट की 1265 लाइनें उत्पन्न करता है) लेकिन
आप इस जानकारी को एक फ़ाइल में पुनर्निर्देशित कर सकते हैं और इसे अपने पसंदीदा के साथ देख सकते हैं
यदि आप चाहें तो संपादक,

$ ./waf --रन स्क्रैच/मायफर्स्ट > लॉग.आउट 2>&1

जब मुझे कोई प्रस्तुत किया जाता है तो मैं व्यक्तिगत रूप से लॉगिंग के इस अत्यधिक क्रियात्मक संस्करण का उपयोग करता हूं
समस्या है और मुझे नहीं पता कि चीजें कहां गलत हो रही हैं। मैं की प्रगति का अनुसरण कर सकता हूं
ब्रेकप्वाइंट सेट किए बिना और डिबगर में कोड के माध्यम से चरणबद्ध तरीके से कोड को आसानी से पूरा किया जा सकता है।
मैं बस अपने पसंदीदा संपादक में आउटपुट को संपादित कर सकता हूं और उन चीजों की खोज कर सकता हूं जिनकी मुझे उम्मीद है,
और उन चीज़ों को घटित होते हुए देखिये जिनकी मुझे आशा नहीं है। जब मुझे इस बारे में एक सामान्य विचार है कि क्या है
गलत होने पर, मैं समस्या की सूक्ष्म जांच के लिए डिबगर में परिवर्तित हो जाता हूं।
इस प्रकार का आउटपुट विशेष रूप से तब उपयोगी हो सकता है जब आपकी स्क्रिप्ट पूरी तरह से कुछ करती है
अप्रत्याशित. यदि आप डिबगर का उपयोग करके कदम बढ़ा रहे हैं तो आप अप्रत्याशित भ्रमण से चूक सकते हैं
पूरी तरह। भ्रमण को लॉग करने से यह तुरंत दिखाई देता है।

जोड़ना लॉगिंग सेवा मेरे तुंहारे कोड
आप लॉग घटक पर कॉल करके अपने सिमुलेशन में नई लॉगिंग जोड़ सकते हैं
कई मैक्रोज़. आइये ऐसा करते हैं myfirst.cc स्क्रिप्ट हमारे पास है खरोंच निर्देशिका.

याद रखें कि हमने उस स्क्रिप्ट में एक लॉगिंग घटक परिभाषित किया है:

NS_LOG_COMPONENT_DEFINE ("फर्स्टस्क्रिप्ट उदाहरण");

अब आप जानते हैं कि आप सेट करके इस घटक के लिए सभी लॉगिंग को सक्षम कर सकते हैं
एनएस_लॉग विभिन्न स्तरों पर पर्यावरण परिवर्तनशील। आइए आगे बढ़ें और इसमें कुछ लॉगिंग जोड़ें
लिपि। सूचनात्मक स्तर लॉग संदेश जोड़ने के लिए उपयोग किया जाने वाला मैक्रो है एनएस_लॉग_इन्फो। जाओ
आगे बढ़ें और एक जोड़ें (नोड्स बनाना शुरू करने से ठीक पहले) जो आपको स्क्रिप्ट बताता है
"टोपोलॉजी बनाना" है। यह इस कोड स्निपेट के अनुसार किया जाता है,

प्रारंभिक स्क्रैच/मायफर्स्ट.सीसी अपने पसंदीदा संपादक में और पंक्ति जोड़ें,

NS_LOG_INFO ("टोपोलॉजी बनाना");

पंक्तियों के ठीक पहले,

नोडकंटेनर नोड्स;
नोड्स.बनाएँ (2);

अब waf का उपयोग करके स्क्रिप्ट बनाएं और साफ़ करें एनएस_लॉग के टोरेंट को बंद करने के लिए वैरिएबल
लॉगिंग हमने पहले सक्षम की थी:

$ ./वफ़ा
$ निर्यात NS_LOG=

अब, यदि आप स्क्रिप्ट चलाते हैं,

$ ./waf --रन स्क्रैच/मायफर्स्ट

आप करेंगे नहीं अपना नया संदेश उसके संबद्ध लॉगिंग घटक से देखें
(फर्स्टस्क्रिप्ट उदाहरण) सक्षम नहीं किया गया है. अपना संदेश देखने के लिए आपको यह करना होगा
सक्षम करें फर्स्टस्क्रिप्ट उदाहरण इससे अधिक या उसके बराबर स्तर वाला लॉगिंग घटक
एनएस_लॉग_इन्फो. यदि आप केवल लॉगिंग के इस विशेष स्तर को देखना चाहते हैं, तो आप इसे सक्षम कर सकते हैं
द्वारा द्वारा,

$ निर्यात NS_LOG=फर्स्टस्क्रिप्टउदाहरण=जानकारी

यदि आप अब स्क्रिप्ट चलाते हैं तो आपको अपना नया "क्रिएटिंग टोपोलॉजी" लॉग संदेश दिखाई देगा,

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.404 सेकंड)
टोपोलॉजी बनाना
1024 पर 10.1.1.2 बाइट्स भेजी गईं
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
1024 से 10.1.1.2 बाइट्स प्राप्त हुए

का प्रयोग आदेश लाइन तर्क
अधिभावी चूक गुण
दूसरे तरीके से आप कैसे बदल सकते हैं एनएस- 3 स्क्रिप्ट संपादन के बिना व्यवहार करती हैं और निर्माण के माध्यम से होती हैं
आदेश line तर्क। हम कमांड लाइन तर्कों को पार्स करने के लिए एक तंत्र प्रदान करते हैं
उन तर्कों के आधार पर स्वचालित रूप से स्थानीय और वैश्विक चर सेट करें।

कमांड लाइन तर्क प्रणाली का उपयोग करने में पहला कदम कमांड लाइन घोषित करना है
पार्सर. यह काफी सरलता से किया जाता है (आपके मुख्य प्रोग्राम में) जैसा कि निम्नलिखित कोड में है,

int
मुख्य (int argc, char *argv[])
{
...

कमांडलाइन सीएमडी;
cmd.Parse (argc, argv);

...
}

यह सरल दो पंक्ति का स्निपेट वास्तव में अपने आप में बहुत उपयोगी है। यह का दरवाजा खोलता है
एनएस- 3 वैश्विक चर और विशेषता सिस्टम. आगे बढ़ें और कोड की वह दो पंक्तियाँ जोड़ें
la स्क्रैच/मायफर्स्ट.सीसी की शुरुआत में स्क्रिप्ट मुख्य. आगे बढ़ें और स्क्रिप्ट बनाएं और चलाएं
यह, लेकिन स्क्रिप्ट से निम्नलिखित तरीके से मदद मांगें,

$ ./waf --रन "स्क्रैच/मायफर्स्ट --प्रिंटहेल्प"

यह वफ़ को चलाने के लिए कहेगा स्क्रैच/मायफर्स्ट स्क्रिप्ट और कमांड लाइन तर्क पास करें
--प्रिंट सहायता स्क्रिप्ट के लिए. किस प्रोग्राम को कौन सा मिलता है, इसे छांटने के लिए उद्धरणों की आवश्यकता होती है
तर्क। कमांड लाइन पार्सर अब देखेगा --प्रिंट सहायता तर्क करो और जवाब दो,

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.413 सेकंड)
TcpL4प्रोटोकॉल:TcpStateMachine()
कमांडलाइन: हैंडलआर्ग्यूमेंट(): हैंडल आर्ग नाम=प्रिंटहेल्प वैल्यू=
--प्रिंटहेल्प: इस सहायता संदेश को प्रिंट करें।
--प्रिंटग्रुप: समूहों की सूची प्रिंट करें।
--प्रिंटटाइपआईडी: सभी टाइपआईडी प्रिंट करें।
--प्रिंटग्रुप=[समूह]: समूह के सभी प्रकार के आईडी प्रिंट करें।
--PrintAttributes=[typeid]: टाइपआईडी की सभी विशेषताओं को प्रिंट करें।
--प्रिंटग्लोबल्स: ग्लोबल्स की सूची प्रिंट करें।

आइए इस पर ध्यान दें --प्रिंट विशेषताएँ विकल्प। इसका संकेत हम पहले ही दे चुके हैं एनएस- 3 विशेषता
सिस्टम से गुजरते समय प्रथम.सीसी लिखी हुई कहानी। हमने निम्नलिखित पंक्तियों को देखा
कोड,

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;
पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));
पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

और उसका उल्लेख किया आधार - सामग्री दर वास्तव में एक था विशेषता का पॉइंटटूप्वाइंटनेटडिवाइस. के जाने
इस पर नज़र डालने के लिए कमांड लाइन तर्क पार्सर का उपयोग करें गुण का
पॉइंटटूप्वाइंटनेटडिवाइस। सहायता सूची कहती है कि हमें एक प्रदान करना चाहिए टाइप आईडी। इस
उस वर्ग के वर्ग नाम से मेल खाता है जिससे गुण संबंधित। इस मामले में
यह एनएस3::प्वाइंटटूप्वाइंटनेटडिवाइस. आइए आगे बढ़ें और टाइप करें,

$ ./waf --run "scratch/myfirst --PrintAttributes=ns3::PointToPointNetDevice"

सिस्टम सभी का प्रिंट आउट ले लेगा गुण इस प्रकार की नेट डिवाइस की. बिच में
गुण आप सूचीबद्ध देखेंगे,

--ns3::PointToPointNetDevice::DataRate=[32768bps]:
पॉइंट टू पॉइंट लिंक के लिए डिफ़ॉल्ट डेटा दर

यह डिफ़ॉल्ट मान है जिसका उपयोग तब किया जाएगा जब a पॉइंटटूप्वाइंटनेटडिवाइस में बनाया गया है
प्रणाली। हमने इस डिफ़ॉल्ट को ओवरराइड कर दिया है विशेषता में स्थापित करना पॉइंटटूप्वाइंटहेल्पर
ऊपर। आइए पॉइंट-टू-पॉइंट डिवाइस और चैनलों के लिए डिफ़ॉल्ट मानों का उपयोग करें
हटाना SetDeviceAttribute कॉल करें और SetChannelAttribute से कॉल करें myfirst.cc
हमारे पास स्क्रैच निर्देशिका में है।

आपकी स्क्रिप्ट को अब बस घोषित करना चाहिए पॉइंटटूप्वाइंटहेल्पर और कुछ मत करो सेट आपरेशनों
जैसा कि निम्नलिखित उदाहरण में है,

...

नोडकंटेनर नोड्स;
नोड्स.बनाएँ (2);

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;

नेटडिवाइसकंटेनर डिवाइस;
डिवाइस = पॉइंटटूप्वाइंट.इंस्टॉल (नोड्स);

...

आगे बढ़ें और वफ़ के साथ नई स्क्रिप्ट बनाएं (./वफ़) और आइए वापस जाएं और कुछ सक्षम करें
यूडीपी इको सर्वर एप्लिकेशन से लॉगिंग करें और समय उपसर्ग चालू करें।

$ निर्यात 'NS_LOG=UdpEchoServerApplication=level_all|prefix_time'

यदि आप स्क्रिप्ट चलाते हैं, तो आपको अब निम्नलिखित आउटपुट देखना चाहिए,

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.405 सेकंड)
0s UdpEchoServerएप्लिकेशन: UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 पर 10.1.1.2 बाइट्स भेजी गईं
2.25732s को 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
2.25732s प्रतिध्वनि पैकेट
1024 से 10.1.1.2 बाइट्स प्राप्त हुए
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerएप्लिकेशन:DoDispose()
UdpEchoServer अनुप्रयोग: ~ UdpEchoServer ()

याद करें कि पिछली बार हमने सिमुलेशन समय देखा था जिस समय पैकेट था
इको सर्वर द्वारा प्राप्त, यह 2.00369 सेकंड पर था।

2.00369s UdpEchoServerApplication:HandleRead(): 1024 से 10.1.1.1 बाइट्स प्राप्त हुए

अब यह 2.25732 सेकंड पर पैकेट प्राप्त कर रहा है। ऐसा इसलिए है क्योंकि हमने अभी-अभी गिरा दिया है
की डेटा दर पॉइंटटूप्वाइंटनेटडिवाइस प्रति सेकंड 32768 बिट्स के अपने डिफ़ॉल्ट से नीचे
प्रति सेकंड पाँच मेगाबिट।

यदि हमें एक नया प्रदान करना होता आधार - सामग्री दर कमांड लाइन का उपयोग करके, हम अपने सिमुलेशन को गति दे सकते हैं
फिर से ऊपर। हम इसे सहायता द्वारा निहित सूत्र के अनुसार निम्नलिखित तरीके से करते हैं
आइटम:

$ ./waf --run "scratch/myfirst --ns3::PointToPointNetDevice::DataRate=5Mbps"

यह का डिफ़ॉल्ट मान सेट करेगा आधार - सामग्री दर विशेषता प्रति पाँच मेगाबिट पर वापस जाएँ
दूसरा। क्या आप परिणाम से आश्चर्यचकित हैं? यह पता चला है कि मूल प्राप्त करने के लिए
स्क्रिप्ट के व्यवहार के अनुसार, हमें चैनल की प्रकाश की गति में देरी को सेट करना होगा
भी। हम कमांड लाइन सिस्टम से प्रिंट आउट लेने के लिए कह सकते हैं गुण चैनल का
ठीक वैसे ही जैसे हमने नेट डिवाइस के लिए किया था:

$ ./waf --run "scratch/myfirst --PrintAttributes=ns3::PointToPointChannel"

हम खोजते हैं विलंब विशेषता चैनल का सेट निम्न प्रकार से किया गया है:

--ns3::PointToPointChannel::विलंब=[0ns]:
चैनल के माध्यम से प्रसारण में देरी

फिर हम कमांड लाइन सिस्टम के माध्यम से इन दोनों डिफ़ॉल्ट मानों को सेट कर सकते हैं,

$ ./waf --रन "स्क्रैच/मायफर्स्ट
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::विलंब=2ms"

ऐसी स्थिति में जब हम स्पष्ट रूप से सेट करते हैं तो हम उस समय को पुनः प्राप्त कर लेते हैं जो हमारे पास था आधार - सामग्री दर और विलंब
स्क्रिप्ट में:

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.417 सेकंड)
0s UdpEchoServerएप्लिकेशन: UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 पर 10.1.1.2 बाइट्स भेजी गईं
2.00369s को 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
2.00369s प्रतिध्वनि पैकेट
1024 से 10.1.1.2 बाइट्स प्राप्त हुए
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerएप्लिकेशन:DoDispose()
UdpEchoServer अनुप्रयोग: ~ UdpEchoServer ()

ध्यान दें कि पैकेट 2.00369 सेकंड पर सर्वर द्वारा फिर से प्राप्त हो जाता है। हम
वास्तव में इनमें से कोई भी सेट करें गुण स्क्रिप्ट में इस प्रकार उपयोग किया जाता है। विशेष रूप से हम कर सकते थे
स्थित UdpEchoClient विशेषता मैक्सपैकेट्स एक के अलावा किसी अन्य मूल्य के लिए।

आप इसके बारे में कैसे सोचेंगे? इसे आज़माइए। याद रखें आपको जगह के बारे में टिप्पणी करनी होगी
हम डिफ़ॉल्ट को ओवरराइड करते हैं विशेषता और स्पष्ट रूप से सेट करें मैक्सपैकेट्स स्क्रिप्ट में. फिर आप
स्क्रिप्ट को फिर से बनाना होगा. आपको वास्तव में सेटिंग के लिए सिंटैक्स भी ढूंढना होगा
कमांड लाइन सहायता सुविधा का उपयोग करके नया डिफ़ॉल्ट विशेषता मान। एक बार आपके पास यह हो
पता चला कि आपको कमांड से प्रतिध्वनित होने वाले पैकेटों की संख्या को नियंत्रित करने में सक्षम होना चाहिए
रेखा। चूँकि हम अच्छे लोग हैं, इसलिए हम आपको बताएंगे कि आपकी कमांड लाइन को अंतत: देखना चाहिए
कुछ इस तरह,

$ ./waf --रन "स्क्रैच/मायफर्स्ट
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::विलंब=2ms
--ns3::UdpEchoClient::MaxPackets=2"

हुक करना आपका खुद की मान
आप कमांड लाइन सिस्टम में अपने स्वयं के हुक भी जोड़ सकते हैं। यह काफी सरलता से किया जाता है
का उपयोग मूल्य जोड़ें कमांड लाइन पार्सर के लिए विधि.

आइए इस सुविधा का उपयोग पूरी तरह से अलग तरीके से प्रतिध्वनि करने वाले पैकेटों की संख्या निर्दिष्ट करने के लिए करें
रास्ता। आइए एक स्थानीय वैरिएबल जोड़ें जिसे कहा जाता है nपैकेट को मुख्य समारोह। हम आरंभ करेंगे
यह हमारे पिछले डिफ़ॉल्ट व्यवहार से मेल खाने के लिए एक है। कमांड लाइन पार्सर को अनुमति देने के लिए
इस मान को बदलें, हमें मान को पार्सर में जोड़ने की आवश्यकता है। हम एक कॉल जोड़कर ऐसा करते हैं
सेवा मेरे मूल्य जोड़ें. आगे बढ़ें और बदलें स्क्रैच/मायफर्स्ट.सीसी स्क्रिप्ट के साथ शुरू करने के लिए
निम्नलिखित कोड,

int
मुख्य (int argc, char *argv[])
{
uint32_t nPackets = 1;

कमांडलाइन सीएमडी;
cmd.AddValue('nPackets', 'echo करने वाले पैकेटों की संख्या', nPackets);
cmd.Parse (argc, argv);

...

स्क्रिप्ट में उस बिंदु तक नीचे स्क्रॉल करें जहां हमने सेट किया था मैक्सपैकेट्स विशेषता और इसे बदलो
ताकि यह वेरिएबल पर सेट हो जाए nपैकेट स्थिरांक के बजाय 1 जैसा कि नीचे दिखाया गया है.

echoClient.SetAttribute ("MaxPackets", UintegerValue (nPackets));

अब यदि आप स्क्रिप्ट चलाते हैं और प्रदान करते हैं --प्रिंट सहायता तर्क, आपको अपना नया देखना चाहिए
उपयोगकर्ता तर्क सहायता प्रदर्शन में सूचीबद्ध।

प्रयत्न,

$ ./waf --रन "स्क्रैच/मायफर्स्ट --प्रिंटहेल्प"

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.403 सेकंड)
--प्रिंटहेल्प: इस सहायता संदेश को प्रिंट करें।
--प्रिंटग्रुप: समूहों की सूची प्रिंट करें।
--प्रिंटटाइपआईडी: सभी टाइपआईडी प्रिंट करें।
--प्रिंटग्रुप=[समूह]: समूह के सभी प्रकार के आईडी प्रिंट करें।
--PrintAttributes=[typeid]: टाइपआईडी की सभी विशेषताओं को प्रिंट करें।
--प्रिंटग्लोबल्स: ग्लोबल्स की सूची प्रिंट करें।
उपयोगकर्ता तर्क:
--nPackets: प्रतिध्वनि करने के लिए पैकेटों की संख्या

यदि आप इको करने के लिए पैकेटों की संख्या निर्दिष्ट करना चाहते हैं, तो अब आप इसे सेट करके ऐसा कर सकते हैं
--nपैकेट कमांड लाइन में तर्क,

$ ./waf --run "स्क्रैच/मायफर्स्ट --nPackets=2"

अब आपको देखना चाहिए

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.404 सेकंड)
0s UdpEchoServerएप्लिकेशन: UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
1024 पर 10.1.1.2 बाइट्स भेजी गईं
2.25732s को 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
2.25732s प्रतिध्वनि पैकेट
1024 से 10.1.1.2 बाइट्स प्राप्त हुए
1024 पर 10.1.1.2 बाइट्स भेजी गईं
3.25732s को 1024 से 10.1.1.1 बाइट्स प्राप्त हुए
3.25732s प्रतिध्वनि पैकेट
1024 से 10.1.1.2 बाइट्स प्राप्त हुए
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerएप्लिकेशन:DoDispose()
UdpEchoServer अनुप्रयोग: ~ UdpEchoServer ()

अब आपने दो पैकेट प्रतिध्वनित कर दिए हैं। बहुत आसान है, है ना?

यदि आप एक हैं तो आप इसे देख सकते हैं एनएस- 3 उपयोगकर्ता, आप कमांड लाइन तर्क प्रणाली का उपयोग कर सकते हैं
वैश्विक मूल्यों को नियंत्रित करें और गुण. यदि आप एक मॉडल लेखक हैं, तो आप नया जोड़ सकते हैं
गुण अपने को वस्तुएँ और वे स्वचालित रूप से आपके द्वारा सेटिंग के लिए उपलब्ध होंगे
उपयोगकर्ता कमांड लाइन सिस्टम के माध्यम से। यदि आप एक स्क्रिप्ट लेखक हैं, तो आप नया जोड़ सकते हैं
वेरिएबल्स को आपकी स्क्रिप्ट में जोड़ें और उन्हें बिना किसी दर्द के कमांड लाइन सिस्टम से जोड़ दें।

का प्रयोग la ट्रेसिंग प्रणाली
सिमुलेशन का पूरा उद्देश्य आगे के अध्ययन के लिए आउटपुट उत्पन्न करना है, और एनएस- 3
ट्रेसिंग सिस्टम इसके लिए एक प्राथमिक तंत्र है। तब से एनएस- 3 एक C++ प्रोग्राम है, मानक
C++ प्रोग्राम से आउटपुट उत्पन्न करने की सुविधाओं का उपयोग किया जा सकता है:

#शामिल
...
मुख्य प्रवेश बिंदु ()
{
...
std::cout << "x का मान है" << x << std::endl;
...
}

आप अपने समाधान में थोड़ी संरचना जोड़ने के लिए लॉगिंग मॉड्यूल का भी उपयोग कर सकते हैं। वहाँ
ऐसे दृष्टिकोणों से उत्पन्न कई प्रसिद्ध समस्याएं हैं और इसलिए हमने एक प्रदान किया है
जिन मुद्दों को हमने महत्वपूर्ण समझा, उनका समाधान करने के लिए सामान्य इवेंट ट्रेसिंग सबसिस्टम।

के मूल लक्ष्य एनएस- 3 अनुरेखण प्रणाली हैं:

· बुनियादी कार्यों के लिए, ट्रेसिंग सिस्टम को उपयोगकर्ता को मानक ट्रेसिंग उत्पन्न करने की अनुमति देनी चाहिए
लोकप्रिय ट्रेसिंग स्रोतों के लिए, और यह अनुकूलित करने के लिए कि कौन सी वस्तुएं ट्रेसिंग उत्पन्न करती हैं;

· मध्यवर्ती उपयोगकर्ताओं को आउटपुट स्वरूप को संशोधित करने के लिए ट्रेसिंग सिस्टम का विस्तार करने में सक्षम होना चाहिए
उत्पन्न करना, या मूल को संशोधित किए बिना, नए ट्रेसिंग स्रोत सम्मिलित करना
सिम्युलेटर;

· उन्नत उपयोगकर्ता नए ट्रेसिंग स्रोत और सिंक जोड़ने के लिए सिम्युलेटर कोर को संशोधित कर सकते हैं।

RSI एनएस- 3 ट्रेसिंग सिस्टम स्वतंत्र ट्रेसिंग स्रोतों की अवधारणाओं पर बनाया गया है
सिंक का पता लगाना, और स्रोतों को सिंक से जोड़ने के लिए एक समान तंत्र। ट्रेस स्रोत हैं
ऐसी संस्थाएँ जो सिमुलेशन में होने वाली घटनाओं का संकेत दे सकती हैं और पहुँच प्रदान कर सकती हैं
दिलचस्प अंतर्निहित डेटा. उदाहरण के लिए, एक ट्रेस स्रोत यह संकेत दे सकता है कि पैकेट कब है
एक नेट डिवाइस द्वारा प्राप्त किया गया और इच्छुक ट्रेस के लिए पैकेट सामग्री तक पहुंच प्रदान की गई
डूब।

ट्रेस स्रोत स्वयं उपयोगी नहीं हैं, उन्हें अन्य टुकड़ों से "जुड़ा" होना चाहिए
कोड जो वास्तव में सिंक द्वारा प्रदान की गई जानकारी के साथ कुछ उपयोगी करता है। पता लगाना
सिंक ट्रेस स्रोतों द्वारा प्रदान की गई घटनाओं और डेटा के उपभोक्ता हैं। उदाहरण के लिए,
कोई एक ट्रेस सिंक बना सकता है जो (ट्रेस स्रोत से कनेक्ट होने पर) होगा
पिछला उदाहरण) प्राप्त पैकेट के दिलचस्प हिस्सों का प्रिंट आउट लें।

इस स्पष्ट विभाजन का तर्क उपयोगकर्ताओं को नए प्रकार के सिंक संलग्न करने की अनुमति देना है
मौजूदा अनुरेखण स्रोत, मूल के संपादन और पुनर्संकलन की आवश्यकता के बिना
सिम्युलेटर. इस प्रकार, उपरोक्त उदाहरण में, एक उपयोगकर्ता अपने अंदर एक नया ट्रेसिंग सिंक परिभाषित कर सकता है
स्क्रिप्ट बनाएं और इसे सिमुलेशन कोर में परिभाषित मौजूदा ट्रेसिंग स्रोत से जोड़ें
केवल उपयोगकर्ता स्क्रिप्ट का संपादन।

इस ट्यूटोरियल में, हम कुछ पूर्व-परिभाषित स्रोतों और सिंक के माध्यम से चलेंगे और दिखाएंगे कि कैसे
उन्हें उपयोगकर्ता के थोड़े से प्रयास से अनुकूलित किया जा सकता है। एनएस-3 मैनुअल या कैसे करें अनुभाग देखें
ट्रेसिंग का विस्तार करने सहित उन्नत ट्रेसिंग कॉन्फ़िगरेशन पर जानकारी के लिए
नेमस्पेस और नए ट्रेसिंग स्रोत बनाना।

ASCII ट्रेसिंग
एनएस- 3 सहायक कार्यक्षमता प्रदान करता है जो आपकी सहायता के लिए निम्न-स्तरीय ट्रेसिंग सिस्टम को लपेटता है
कुछ आसानी से समझे जाने वाले पैकेट ट्रेस को कॉन्फ़िगर करने में शामिल विवरण के साथ। अगर आप
इस कार्यक्षमता को सक्षम करें, आप ASCII फ़ाइलों में आउटपुट देखेंगे --- इस प्रकार नाम। के लिए
जो परिचित हैं एनएस- 2 आउटपुट, इस प्रकार का ट्रेस के अनुरूप है बाहर.tr उत्पन्न
अनेक लिपियों द्वारा.

आइए सीधे आगे बढ़ें और हमारे साथ कुछ ASCII ट्रेसिंग आउटपुट जोड़ें स्क्रैच/मायफर्स्ट.सीसी
लिखी हुई कहानी। को कॉल करने से ठीक पहले सिम्युलेटर::चलाएँ (), कोड की निम्नलिखित पंक्तियाँ जोड़ें:

AsciiTraceHelper ascii;
pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));

जैसे कई अन्य में एनएस- 3 मुहावरे, यह कोड ASCII बनाने में सहायता के लिए एक सहायक ऑब्जेक्ट का उपयोग करता है
निशान. दूसरी पंक्ति में दो नेस्टेड विधि कॉल हैं। "अंदर" विधि,
CreateFileStream() फ़ाइल स्ट्रीम ऑब्जेक्ट बनाने के लिए एक अनाम ऑब्जेक्ट मुहावरे का उपयोग करता है
स्टैक (ऑब्जेक्ट नाम के बिना) और इसे कॉल की गई विधि में पास करें। हम इसमें जाएंगे
भविष्य में और अधिक, लेकिन इस बिंदु पर आपको बस इतना जानना है कि आप एक बना रहे हैं
ऑब्जेक्ट "myfirst.tr" नामक फ़ाइल का प्रतिनिधित्व करता है और इसे पास करता है एनएस- 3. आप बता रहे हैं
एनएस- 3 निर्मित वस्तु के जीवनकाल के मुद्दों से निपटने के लिए और समस्याओं से निपटने के लिए भी
प्रतिलिपि से संबंधित C++ ऑफ़स्ट्रीम ऑब्जेक्ट की अल्पज्ञात (जानबूझकर) सीमा के कारण
रचनाकार।

बाहरी कॉल, को EnableAsciiAll(), सहायक को बताता है कि आप ASCII को सक्षम करना चाहते हैं
आपके सिमुलेशन में सभी पॉइंट-टू-पॉइंट डिवाइस पर ट्रेसिंग; और आप चाहते हैं (प्रदान किया गया)
ASCII प्रारूप में पैकेट संचलन के बारे में जानकारी लिखने के लिए ट्रेस सिंक।

उन परिचितों के लिए एनएस- 2, ट्रेस की गई घटनाएँ लोकप्रिय ट्रेस बिंदुओं के बराबर हैं
वह लॉग "+", "-", "डी", और "आर" ईवेंट।

अब आप स्क्रिप्ट बना सकते हैं और इसे कमांड लाइन से चला सकते हैं:

$ ./waf --रन स्क्रैच/मायफर्स्ट

जैसा कि आपने पहले भी कई बार देखा है, आपको वफ़ और उसके बाद के कुछ संदेश दिखाई देंगे
चल रहे प्रोग्राम से कुछ संख्या में संदेशों के साथ "'बिल्ड' सफलतापूर्वक समाप्त हुआ"।

जब यह चलेगा, तो प्रोग्राम ने नाम की एक फ़ाइल बना ली होगी myfirst.tr. रास्ते के कारण
वह वफ़ काम करता है, फ़ाइल स्थानीय निर्देशिका में नहीं बनाई जाती है, यह पर बनाई जाती है
डिफ़ॉल्ट रूप से रिपॉजिटरी की शीर्ष-स्तरीय निर्देशिका। यदि आप नियंत्रित करना चाहते हैं कि निशान कहाँ हैं
सहेजे गए हैं जिनका आप उपयोग कर सकते हैं --सीडब्ल्यूडी इसे निर्दिष्ट करने के लिए वफ़ का विकल्प। अत: हमने ऐसा नहीं किया है
हमें अपने रेपो की शीर्ष स्तरीय निर्देशिका में बदलाव करने और ASCII पर एक नज़र डालने की आवश्यकता है
ट्रेस फ़ाइल myfirst.tr अपने पसंदीदा संपादक में.

पदच्छेद ascii निशान
वहां बहुत सारी जानकारी काफी सघन रूप में है, लेकिन सबसे पहले ध्यान देने वाली बात यह है
यह है कि इस फ़ाइल में कई अलग-अलग पंक्तियाँ हैं। इसे देखना मुश्किल हो सकता है
यह स्पष्ट रूप से तब तक है जब तक कि आप अपनी विंडो को पर्याप्त रूप से चौड़ा न कर लें।

फ़ाइल की प्रत्येक पंक्ति a से मेल खाती है निशान घटना. इस मामले में हम घटनाओं का पता लगा रहे हैं
la संचारित करना पंक्ति सिमुलेशन में प्रत्येक पॉइंट-टू-पॉइंट नेट डिवाइस में मौजूद है।
ट्रांसमिट कतार एक कतार है जिसके माध्यम से प्रत्येक पैकेट एक पॉइंट-टू-पॉइंट चैनल के लिए नियत होता है
ज़रूर गुजरना होगा। ध्यान दें कि ट्रेस फ़ाइल में प्रत्येक पंक्ति एक अकेले वर्ण से शुरू होती है (इसमें एक है)।
इसके बाद का स्थान)। इस अक्षर का निम्नलिखित अर्थ होगा:

· +: डिवाइस कतार पर एक एन्क्यू ऑपरेशन हुआ;

· -: डिवाइस क्यू पर एक डीक्यू ऑपरेशन हुआ;

· d: एक पैकेट गिरा दिया गया, आमतौर पर क्योंकि कतार भरी हुई थी;

· r: नेट डिवाइस द्वारा एक पैकेट प्राप्त हुआ।

आइए ट्रेस फ़ाइल में पहली पंक्ति का अधिक विस्तृत दृश्य देखें। मैं इसे तोड़ दूँगा
बाईं ओर एक संदर्भ संख्या के साथ अनुभागों में (स्पष्टता के लिए इंडेंट किया गया):

+
2
/NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue
ns3::PppHeader (
पॉइंट-टू-पॉइंट प्रोटोकॉल: आईपी (0x0021))
एनएस3::आईपीवी4हेडर (
टॉस 0x0 टीटीएल 64 आईडी 0 प्रोटोकॉल 17 ऑफसेट 0 झंडे [कोई नहीं]
लंबाई: 1052 10.1.1.1 > 10.1.1.2)
एनएस3::उदपहेडर (
लंबाई: 1032 49153 > 9)
पेलोड (आकार=1024)

इस विस्तारित ट्रेस इवेंट (संदर्भ संख्या 0) का पहला खंड ऑपरेशन है। हम
एक है + चरित्र, तो यह एक से मेल खाता है कतारबद्ध करें ट्रांसमिट कतार पर संचालन।
दूसरा खंड (संदर्भ 1) सेकंड में व्यक्त सिमुलेशन समय है। आप कर सकते हैं
याद रखें कि हमने पूछा था UdpEchoClientएप्लिकेशन दो सेकंड में पैकेट भेजना शुरू करने के लिए।
यहां हम इस बात की पुष्टि देखते हैं कि वास्तव में ऐसा हो रहा है।

उदाहरण ट्रेस का अगला भाग (संदर्भ 2) हमें बताता है कि कौन सा ट्रेस स्रोत उत्पन्न हुआ
यह घटना (ट्रेसिंग नेमस्पेस में व्यक्त)। आप ट्रेसिंग नेमस्पेस के बारे में सोच सकते हैं
कुछ-कुछ आपके फ़ाइल सिस्टम नेमस्पेस जैसा। नेमस्पेस का मूल है
नोडल सूची. यह में प्रबंधित कंटेनर से मेल खाता है एनएस- 3 कोर कोड जिसमें सब कुछ शामिल है
किसी स्क्रिप्ट में बनाए गए नोड्स का. जिस प्रकार एक फ़ाइल सिस्टम में निर्देशिकाएँ हो सकती हैं
जड़ के नीचे, हमारे पास नोड संख्याएँ हो सकती हैं नोडल सूची. डोर /नोडेलिस्ट/0
इसलिए में शून्यवें नोड को संदर्भित करता है नोडल सूची जिसे हम आम तौर पर "नोड" के रूप में सोचते हैं
0"। प्रत्येक नोड में स्थापित किए गए उपकरणों की एक सूची है। यह सूची दिखाई देती है
नेमस्पेस में अगला. आप देख सकते हैं कि यह ट्रेस इवेंट कहां से आया है डिवाइस सूची/0 जो है
नोड में स्थापित शून्य डिवाइस.

अगली कड़ी, $ns3::PointToPointNetDevice आपको बताता है कि इसमें किस प्रकार का उपकरण है
नोड शून्य के लिए डिवाइस सूची की शून्यवीं स्थिति। याद रखें कि ऑपरेशन + पर मिला
संदर्भ 00 का मतलब है कि डिवाइस की ट्रांसमिट कतार पर एक एन्क्यू ऑपरेशन हुआ।
यह "ट्रेस पथ" के अंतिम खंडों में परिलक्षित होता है जो हैं TxQueue/एनक्यू.

ट्रेस में शेष अनुभाग काफी सहज होने चाहिए। सन्दर्भ 3-4 इंगित करते हैं
पैकेट को पॉइंट-टू-पॉइंट प्रोटोकॉल में एनकैप्सुलेट किया गया है। सन्दर्भ 5-7 यह दर्शाते हैं
पैकेट में आईपी संस्करण चार हेडर है और आईपी एड्रेस 10.1.1.1 से उत्पन्न हुआ है
10.1.1.2 के लिए नियत है। संदर्भ 8-9 से पता चलता है कि इस पैकेट में एक यूडीपी हेडर है और,
अंत में, संदर्भ 10 से पता चलता है कि पेलोड अपेक्षित 1024 बाइट्स है।

ट्रेस फ़ाइल में अगली पंक्ति उसी पैकेट को ट्रांसमिट से हटाते हुए दिखाती है
एक ही नोड पर कतार.

ट्रेस फ़ाइल में तीसरी पंक्ति नेट डिवाइस द्वारा प्राप्त किए जा रहे पैकेट को दिखाती है
इको सर्वर के साथ नोड। मैंने उस घटना को नीचे पुनः प्रस्तुत किया है।

r
2.25732
/NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/MacRx
एनएस3::आईपीवी4हेडर (
टॉस 0x0 टीटीएल 64 आईडी 0 प्रोटोकॉल 17 ऑफसेट 0 झंडे [कोई नहीं]
लंबाई: 1052 10.1.1.1 > 10.1.1.2)
एनएस3::उदपहेडर (
लंबाई: 1032 49153 > 9)
पेलोड (आकार=1024)

ध्यान दें कि ट्रेस ऑपरेशन अब है r और सिमुलेशन समय बढ़कर 2.25732 हो गया है
सेकंड. यदि आप ट्यूटोरियल चरणों का बारीकी से पालन कर रहे हैं तो इसका मतलब है कि आपने
छोड़ दिया आधार - सामग्री दर नेट डिवाइस और चैनल का विलंब उनके डिफ़ॉल्ट मानों पर सेट करें।
यह समय परिचित होना चाहिए क्योंकि आप इसे पहले पिछले अनुभाग में देख चुके हैं।

यह दर्शाने के लिए कि यह घटना है, ट्रेस स्रोत नेमस्पेस प्रविष्टि (संदर्भ 02) बदल गई है
नोड 1 से आ रहा है (/नोडेलिस्ट/1) और पैकेट रिसेप्शन ट्रेस स्रोत (/MacRx)। यह
आपके लिए टोपोलॉजी के माध्यम से पैकेट की प्रगति का अनुसरण करना काफी आसान होना चाहिए
फ़ाइल के बाकी निशानों को देख रहा हूँ।

पीसीएपी ट्रेसिंग
RSI एनएस- 3 डिवाइस हेल्पर्स का उपयोग ट्रेस फ़ाइलें बनाने के लिए भी किया जा सकता है .pcap प्रारूप।
संक्षिप्त नाम pcap (आमतौर पर छोटे अक्षरों में लिखा जाता है) का अर्थ पैकेट कैप्चर है, और वास्तव में यह एक है
एपीआई जिसमें ए की परिभाषा शामिल है .pcap फ़ाइल फ़ारमैट। वह सबसे लोकप्रिय कार्यक्रम है
इस प्रारूप को पढ़ और प्रदर्शित कर सकते हैं वायरशार्क (जिसे पहले ईथरियल कहा जाता था)। हालाँकि, वहाँ
कई ट्रैफ़िक ट्रेस विश्लेषक हैं जो इस पैकेट प्रारूप का उपयोग करते हैं। हम उपयोगकर्ताओं को इसके लिए प्रोत्साहित करते हैं
पीकैप निशानों का विश्लेषण करने के लिए उपलब्ध कई उपकरणों का उपयोग करें। इस ट्यूटोरियल में, हम
tcpdump के साथ pcap निशान देखने पर ध्यान केंद्रित करें।

पीकैप ट्रेसिंग को सक्षम करने के लिए उपयोग किया जाने वाला कोड एक-लाइनर है।

pointToPoint.EnablePcapAll ("myfirst");

आगे बढ़ें और कोड की इस पंक्ति को हमारे द्वारा अभी जोड़े गए ASCII ट्रेसिंग कोड के बाद डालें
स्क्रैच/मायफर्स्ट.सीसी. ध्यान दें कि हमने केवल "मायफर्स्ट" स्ट्रिंग को पास किया है, नहीं
"myfirst.pcap" या ऐसा ही कुछ। ऐसा इसलिए है क्योंकि पैरामीटर एक उपसर्ग है, a नहीं
पूरा फ़ाइल नाम. सहायक वास्तव में प्रत्येक बिंदु-से-बिंदु के लिए एक ट्रेस फ़ाइल बनाएगा
अनुकरण में उपकरण. फ़ाइल नाम उपसर्ग, नोड संख्या का उपयोग करके बनाए जाएंगे,
डिवाइस नंबर और एक ".pcap" प्रत्यय।

हमारी उदाहरण स्क्रिप्ट में, हम अंततः "myfirst-0-0.pcap" नाम की फ़ाइलें देखेंगे
"myfirst-1-0.pcap" जो नोड 0-डिवाइस 0 और नोड 1-डिवाइस 0 के लिए pcap निशान हैं,
क्रमशः.

एक बार जब आप पीकैप ट्रेसिंग को सक्षम करने के लिए कोड की लाइन जोड़ लेते हैं, तो आप स्क्रिप्ट को इसमें चला सकते हैं
हमेशा की तरह:

$ ./waf --रन स्क्रैच/मायफर्स्ट

यदि आप अपने वितरण की शीर्ष स्तरीय निर्देशिका को देखते हैं, तो आपको अब तीन लॉग देखना चाहिए
फ़ाइलें: myfirst.tr ASCII ट्रेस फ़ाइल है जिसकी हमने पहले जांच की है। myfirst-0-0.pcap
और myfirst-1-0.pcap ये नई pcap फ़ाइलें हैं जिन्हें हमने अभी जनरेट किया है।

पढ़ना उत्पादन साथ में टीसीपीडम्प
इस बिंदु पर सबसे आसान काम इसका उपयोग करना होगा टीसीपीडम्प देखने के लिए PCAP फाइलें.

$ tcpdump -nn -tt -r myfirst-0-0.pcap
फ़ाइल myfirst-0-0.pcap से पढ़ना, लिंक-प्रकार PPP (PPP)
2.000000 आईपी 10.1.1.1.49153 > 10.1.1.2.9: यूडीपी, लंबाई 1024
2.514648 आईपी 10.1.1.2.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

टीसीपीडम्प -एनएन -टीटी -आर मायफर्स्ट-1-0.pcap
फ़ाइल myfirst-1-0.pcap से पढ़ना, लिंक-प्रकार PPP (PPP)
2.257324 आईपी 10.1.1.1.49153 > 10.1.1.2.9: यूडीपी, लंबाई 1024
2.257324 आईपी 10.1.1.2.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

के डंप में देख सकते हैं myfirst-0-0.pcap (क्लाइंट डिवाइस) जो इको पैकेट है
सिमुलेशन में 2 सेकंड पर भेजा गया। यदि आप दूसरे डंप को देखें (myfirst-1-0.pcap)
आप उस पैकेट को 2.257324 सेकंड पर प्राप्त होते हुए देख सकते हैं। आप पैकेट को होते हुए देख रहे हैं
दूसरे डंप में 2.257324 सेकंड पर प्रतिध्वनि हुई, और अंत में, आप पैकेट को देखते हैं
2.514648 सेकंड पर पहले डंप में क्लाइंट को वापस प्राप्त हुआ।

पढ़ना उत्पादन साथ में Wireshark
यदि आप वायरशार्क से अपरिचित हैं, तो एक वेबसाइट उपलब्ध है जिससे आप ऐसा कर सकते हैं
प्रोग्राम और दस्तावेज़ डाउनलोड करें: http://www.wireshark.org/.

वायरशार्क एक ग्राफिकल यूजर इंटरफेस है जिसका उपयोग इन ट्रेस को प्रदर्शित करने के लिए किया जा सकता है
फ़ाइलें. यदि आपके पास वायरशार्क उपलब्ध है, तो आप प्रत्येक ट्रेस फ़ाइल को खोल सकते हैं और प्रदर्शित कर सकते हैं
सामग्री इस प्रकार है मानो आपने पैकेट का उपयोग करके कैप्चर किया हो पोटली रूमाल.

भवन टोपोलोजी

इमारत a बस नेटवर्क टोपोलॉजी
इस अनुभाग में हम अपनी महारत का विस्तार करने जा रहे हैं एनएस- 3 नेटवर्क डिवाइस और चैनल
बस नेटवर्क का एक उदाहरण कवर करें। एनएस- 3 एक नेट डिवाइस और चैनल प्रदान करता है जिसे हम CSMA कहते हैं
(करियर सेंस मल्टीपल एक्सेस)।

RSI एनएस- 3 सीएसएमए डिवाइस ईथरनेट की भावना में एक सरल नेटवर्क का मॉडल तैयार करता है। एक वास्तविक ईथरनेट
सीएसएमए/सीडी (कैरियर सेंस मल्टीपल एक्सेस विद कोलिजन डिटेक्शन) योजना का उपयोग करता है
साझा ट्रांसमिशन माध्यम के लिए प्रतिस्पर्धा में बैकऑफ़ तेजी से बढ़ रहा है। एनएस- 3
सीएसएमए डिवाइस और चैनल मॉडल इसका केवल एक उपसमूह हैं।

जैसे हमने निर्माण करते समय पॉइंट-टू-पॉइंट टोपोलॉजी सहायक ऑब्जेक्ट देखे हैं
पॉइंट-टू-पॉइंट टोपोलॉजी, हम इस अनुभाग में समकक्ष सीएसएमए टोपोलॉजी सहायक देखेंगे।
इन सहायकों की उपस्थिति और संचालन आपको काफी परिचित लगना चाहिए।

हम अपने उदाहरण/ट्यूटोरियल} निर्देशिका में एक उदाहरण स्क्रिप्ट प्रदान करते हैं। यह स्क्रिप्ट बनती है
la प्रथम.सीसी स्क्रिप्ट और पॉइंट-टू-पॉइंट सिमुलेशन में एक सीएसएमए नेटवर्क जोड़ता है जो हम पहले ही कर चुके हैं
माना। आगे बढ़ो और खोलो उदाहरण/ट्यूटोरियल/सेकेंड.सीसी अपने पसंदीदा संपादक में. आप
पहले ही काफी देख लिया होगा एनएस- 3 इसमें क्या चल रहा है, इसे समझने के लिए कोड
उदाहरण के लिए, लेकिन हम पूरी स्क्रिप्ट पर जाएंगे और कुछ आउटपुट की जांच करेंगे।

ठीक वैसे ही जैसे प्रथम.सीसी उदाहरण (और सभी ns-3 उदाहरणों में) फ़ाइल एक emacs से शुरू होती है
मोड लाइन और कुछ जीपीएल बॉयलरप्लेट।

वास्तविक कोड लोडिंग मॉड्यूल से शुरू होता है जिसमें फ़ाइलें शामिल होती हैं जैसा कि इसमें किया गया था प्रथम.सीसी
उदाहरण।

#शामिल "ns3/core-module.h"
#शामिल है "ns3/network-module.h"
#शामिल है "ns3/csma-module.h"
#शामिल "ns3/इंटरनेट-मॉड्यूल.एच"
#शामिल है "ns3/point-to-point-module.h"
#शामिल "ns3/applications-module.h"
#शामिल है "ns3/ipv4-global-routing-helper.h"

एक चीज़ जो आश्चर्यजनक रूप से उपयोगी हो सकती है वह ASCII कला का एक छोटा सा टुकड़ा है जो एक कार्टून दिखाता है
उदाहरण में निर्मित नेटवर्क टोपोलॉजी का। आपको एक समान "ड्राइंग" मिलेगी
हमारे अधिकांश उदाहरण।

इस मामले में, आप देख सकते हैं कि हम अपना पॉइंट-टू-पॉइंट उदाहरण (लिंक) का विस्तार करने जा रहे हैं
नीचे दिए गए नोड्स n0 और n1 के बीच) एक बस नेटवर्क को दाईं ओर से लटकाकर। सूचना
यह डिफ़ॉल्ट नेटवर्क टोपोलॉजी है क्योंकि आप वास्तव में नोड्स की संख्या भिन्न कर सकते हैं
LAN पर बनाया गया. यदि आप nCsma को एक पर सेट करते हैं, तो इस पर कुल दो नोड होंगे
LAN (CSMA चैनल) --- एक आवश्यक नोड और एक "अतिरिक्त" नोड। डिफ़ॉल्ट रूप से तीन हैं
"अतिरिक्त" नोड्स जैसा कि नीचे देखा गया है:

// डिफ़ॉल्ट नेटवर्क टोपोलॉजी
//
// 10.1.1.0
// n0 -------------- n1 n2 n3 n4
// पॉइंट-टू-पॉइंट | | | |
// ================
// लैन 10.1.2.0

फिर ns-3 नेमस्पेस है प्रयुक्त और एक लॉगिंग घटक परिभाषित किया गया है। ये सब वैसा ही है
यह उस में था प्रथम.सीसी, इसलिए अभी कुछ भी नया नहीं है।

नेमस्पेस ns3 का उपयोग करना;

NS_LOG_COMPONENT_DEFINE ("SecondScriptExample");

मुख्य कार्यक्रम थोड़े अलग मोड़ के साथ शुरू होता है। हम इसके लिए वर्बोज़ ध्वज का उपयोग करते हैं
निर्धारित करें कि है या नहीं UdpEchoClientएप्लिकेशन और UdpEchoServerअनुप्रयोग लॉगिंग
घटक सक्षम हैं. यह ध्वज डिफ़ॉल्ट रूप से सत्य है (लॉगिंग घटक सक्षम हैं)
लेकिन हमें इस उदाहरण के प्रतिगमन परीक्षण के दौरान लॉगिंग बंद करने की अनुमति देता है।

आपको कुछ परिचित कोड दिखाई देंगे जो आपको डिवाइसों की संख्या बदलने की अनुमति देंगे
कमांड लाइन तर्क के माध्यम से सीएसएमए नेटवर्क। जब हमने अनुमति दी तो हमने भी कुछ ऐसा ही किया
कमांड लाइन तर्कों पर अनुभाग में बदले जाने के लिए भेजे गए पैकेटों की संख्या। अंतिम
लाइन सुनिश्चित करती है कि आपके पास कम से कम एक "अतिरिक्त" नोड है।

कोड में पहले कवर किए गए एपीआई की विविधताएं शामिल हैं, इसलिए आपको पूरी तरह से ऐसा करना चाहिए
ट्यूटोरियल में इस बिंदु पर निम्नलिखित कोड के साथ सहज रहें।

बूल वर्बोज़ = सत्य;
uint32_t nCsma = 3;

कमांडलाइन सीएमडी;
cmd.AddValue ("nCsma", "\"अतिरिक्त\" CSMA नोड्स/उपकरणों की संख्या", nCsma);
cmd.AddValue ("वर्बोज़", "अगर सच है तो लॉग इन करने के लिए इको एप्लिकेशन को बताएं", वर्बोज़);

cmd.Parse (argc, argv);

यदि (क्रियात्मक)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable('UdpEchoServerApplication', LOG_LEVEL_INFO);
}

एनसीएसएमए = एनसीएसएमए == 0? 1 : एनसीएसएमए;

अगला चरण दो नोड बनाना है जिन्हें हम पॉइंट-टू-पॉइंट लिंक के माध्यम से जोड़ेंगे।
RSI नोडकंटेनर ऐसा करने के लिए इसका उपयोग वैसे ही किया जाता है जैसे में किया गया था प्रथम.सीसी.

नोडकंटेनर पी2पीनोड्स;
p2pNodes.बनाएँ (2);

अगला, हम एक और घोषणा करते हैं नोडकंटेनर उन नोड्स को पकड़ने के लिए जो बस का हिस्सा होंगे
(सीएसएमए) नेटवर्क। सबसे पहले, हम केवल कंटेनर ऑब्जेक्ट को इंस्टेंटियेट करते हैं।

नोडकंटेनर csmaNodes;
csmaNodes.जोड़ें (p2pNodes.Get (1));
csmaNodes.Create (nCsma);

कोड की अगली पंक्ति हो जाता है से पहला नोड (जैसा कि एक का सूचकांक होता है)।
पॉइंट-टू-पॉइंट नोड कंटेनर और इसे नोड्स के कंटेनर में जोड़ता है जिसे सीएसएमए मिलेगा
उपकरण। विचाराधीन नोड एक पॉइंट-टू-पॉइंट डिवाइस के साथ समाप्त होने वाला है और एक सीएसएमए
उपकरण। फिर हम कई "अतिरिक्त" नोड बनाते हैं जो CSMA के शेष भाग की रचना करते हैं
नेटवर्क। चूँकि हमारे पास सीएसएमए नेटवर्क में पहले से ही एक नोड है - वह जो होगा
पॉइंट-टू-पॉइंट और सीएसएमए नेट डिवाइस दोनों में, "अतिरिक्त" नोड्स की संख्या का मतलब संख्या है
सीएसएमए अनुभाग में आप जो नोड चाहते हैं, उसमें से एक को घटा दें।

कोड का अगला भाग अब तक काफी परिचित हो चुका होगा। हम तत्काल ए पॉइंटटूप्वाइंटहेल्पर
और संबंधित डिफ़ॉल्ट सेट करें गुण ताकि हम प्रति सेकंड पांच मेगाबिट बनाएं
सहायक का उपयोग करके बनाए गए उपकरणों पर ट्रांसमीटर और चैनलों पर दो मिलीसेकंड की देरी
सहायक द्वारा बनाया गया.

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;
पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));
पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

नेटडिवाइसकंटेनर पी2पीडिवाइसेस;
p2pDevices =pointToPoint.Install (p2pNodes);

फिर हम एक को इंस्टेंट करते हैं नेटडिवाइसकंटेनर पॉइंट-टू-पॉइंट नेट डिवाइसों पर नज़र रखने के लिए
और हम स्थापित करें पॉइंट-टू-पॉइंट नोड्स पर डिवाइस।

हमने ऊपर उल्लेख किया है कि आप सीएसएमए उपकरणों और चैनलों के लिए एक सहायक देखने जा रहे हैं, और
अगली पंक्तियाँ उनका परिचय देती हैं। सीएसएमए हेल्पर की तरह ही काम करता है पॉइंटटूप्वाइंटहेल्पर, परंतु
यह CSMA डिवाइस और चैनल बनाता और जोड़ता है। सीएसएमए डिवाइस के मामले में और
चैनल जोड़ी, ध्यान दें कि डेटा दर एक द्वारा निर्दिष्ट है चैनल विशेषता ए के बजाए
युक्ति विशेषता. ऐसा इसलिए है क्योंकि एक वास्तविक सीएसएमए नेटवर्क किसी को मिश्रण करने की अनुमति नहीं देता है
उदाहरण के लिए, किसी दिए गए चैनल पर 10Base-T और 100Base-T डिवाइस। हमने सबसे पहले डेटा दर को सेट किया
100 मेगाबिट्स प्रति सेकंड, और फिर चैनल की प्रकाश-गति विलंब को 6560 पर सेट करें
नैनो-सेकंड (मनमाने ढंग से 1 मीटर खंड पर प्रति फुट 100 नैनोसेकंड के रूप में चुना गया)।
ध्यान दें कि आप एक सेट कर सकते हैं विशेषता अपने मूल डेटा प्रकार का उपयोग करना।

सीएसएमएहेल्पर सीएसएमए;
csma.SetChannelAttribute ("डेटारेट", स्ट्रिंगवैल्यू ("100 एमबीपीएस"));
csma.SetChannelAttribute ("देरी", टाइमवैल्यू (नैनोसेकंड (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.इंस्टॉल (csmaNodes);

जैसे हमने बनाया है नेटडिवाइसकंटेनर द्वारा बनाए गए उपकरणों को पकड़ने के लिए
पॉइंटटूप्वाइंटहेल्पर हम बनाते हैं नेटडिवाइसकंटेनर हमारे द्वारा बनाए गए उपकरणों को धारण करने के लिए
सीएसएमए हेल्पर. हम कॉल करते हैं स्थापित करें की विधि सीएसएमए हेल्पर उपकरणों को स्थापित करने के लिए
के नोड्स csmaNodes नोडकंटेनर.

अब हमारे पास अपने नोड्स, डिवाइस और चैनल तैयार हैं, लेकिन हमारे पास कोई प्रोटोकॉल स्टैक नहीं है
उपस्थित। ठीक वैसे ही जैसे प्रथम.सीसी स्क्रिप्ट, हम उपयोग करेंगे इंटरनेटस्टैकहेल्पर स्थापित करने के लिए
ये ढेर.

इंटरनेटस्टैकहेल्पर स्टैक;
स्टैक.इंस्टॉल (p2pNodes.Get (0));
स्टैक.इंस्टॉल (csmaNodes);

याद रखें कि हमने इसमें से एक नोड लिया था पी2पीनोड कंटेनर और इसे इसमें जोड़ा गया
csmaNodes कंटेनर. इस प्रकार हमें केवल शेष पर स्टैक स्थापित करने की आवश्यकता है पी2पीनोड
नोड, और सभी नोड्स csmaNodes सभी नोड्स को कवर करने के लिए कंटेनर
सिमुलेशन।

ठीक वैसे ही जैसे प्रथम.सीसी उदाहरण स्क्रिप्ट, हम इसका उपयोग करने जा रहे हैं आईपीवी4पता हेल्पर सेवा मेरे
हमारे डिवाइस इंटरफेस को आईपी पते निर्दिष्ट करें। सबसे पहले हम बनाने के लिए नेटवर्क 10.1.1.0 का उपयोग करते हैं
हमारे दो पॉइंट-टू-पॉइंट डिवाइस के लिए आवश्यक दो पते।

Ipv4AddressHelper पता;
पता.सेटबेस ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
पी2पीइंटरफेस = पता.असाइन (पी2पीडिवाइस);

याद रखें कि हम बनाए गए इंटरफेस को एक कंटेनर में सहेजते हैं ताकि इसे बाहर निकालना आसान हो सके
अनुप्रयोगों को स्थापित करने में उपयोग के लिए बाद में जानकारी को संबोधित करना।

अब हमें अपने सीएसएमए डिवाइस इंटरफेस को आईपी पते निर्दिष्ट करने की आवश्यकता है। ऑपरेशन काम करता है
जैसा कि इसने पॉइंट-टू-पॉइंट मामले के लिए किया था, सिवाय इसके कि अब हम ऑपरेशन कर रहे हैं
एक कंटेनर जिसमें सीएसएमए उपकरणों की एक परिवर्तनीय संख्या होती है --- याद रखें कि हमने संख्या बनाई है
CSMA डिवाइस कमांड लाइन तर्क द्वारा परिवर्तनीय हैं। सीएसएमए उपकरण संबद्ध होंगे
इस मामले में नेटवर्क नंबर 10.1.2.0 से आईपी पते के साथ, जैसा कि नीचे देखा गया है।

पता.सेटबेस ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = पता.असाइन (csmaDevices);

अब हमारे पास एक टोपोलॉजी निर्मित है, लेकिन हमें अनुप्रयोगों की आवश्यकता है। यह अनुभाग होने जा रहा है
मूलतः के अनुप्रयोग अनुभाग के समान प्रथम.सीसी लेकिन हम जा रहे हैं
सर्वर को उन नोड्स में से एक पर इंस्टेंट करें जिसमें सीएसएमए डिवाइस और क्लाइंट है
नोड में केवल एक पॉइंट-टू-पॉइंट डिवाइस है।

सबसे पहले, हम इको सर्वर सेट करते हैं। हम एक बनाते हैं UdpEchoServerHelper और एक आवश्यक प्रदान करें
विशेषता कंस्ट्रक्टर का मान जो सर्वर पोर्ट नंबर है। स्मरण करो कि यह बंदरगाह
का उपयोग करके बाद में बदला जा सकता है गुण सेट करें विधि यदि वांछित है, लेकिन हमें इसकी आवश्यकता है
कंस्ट्रक्टर को प्रदान किया गया।

UdpEchoServerHelper इकोसर्वर (9);

ApplicationContainer serverApps = EchoServer.Install (csmaNodes.Get (nCsma));
सर्वरएप्स.स्टार्ट (सेकंड्स (1.0));
सर्वरएप्स.स्टॉप (सेकंड्स (10.0));

याद करो कि csmaNodes नोडकंटेनर के लिए बनाए गए नोड्स में से एक शामिल है
पॉइंट-टू-पॉइंट नेटवर्क और nCsma "अतिरिक्त" नोड्स. हम जो पाना चाहते हैं वह अंतिम है
"अतिरिक्त" नोड्स. की शून्यवीं प्रविष्टि csmaNodes कंटेनर पॉइंट-टू-पॉइंट होगा
नोड. इसके बारे में सोचने का आसान तरीका यह है कि यदि हम एक "अतिरिक्त" सीएसएमए नोड बनाते हैं, तो यह
के सूचकांक में से एक पर होगा csmaNodes कंटेनर. प्रेरण द्वारा, यदि हम बनाते हैं nCsma "अतिरिक्त"
अंतिम नोड इंडेक्स पर होगा nCsma. आप इसे इसमें प्रदर्शित देख सकते हैं पहले का
कोड की पंक्ति.

क्लाइंट एप्लिकेशन बिल्कुल वैसे ही सेट किया गया है जैसा हमने किया था प्रथम.सीसी उदाहरण स्क्रिप्ट. दोबारा,
हम आवश्यक प्रदान करते हैं गुण को UdpEchoClientHelper कंस्ट्रक्टर में (इस मामले में
दूरस्थ पता और पोर्ट)। हम क्लाइंट को सर्वर पर पैकेट भेजने के लिए कहते हैं
"अतिरिक्त" सीएसएमए नोड्स के अंतिम पर स्थापित। हम क्लाइंट को सबसे बाईं ओर स्थापित करते हैं
टोपोलॉजी चित्रण में देखा गया पॉइंट-टू-पॉइंट नोड।

UdpEchoClientHelper इकोक्लाइंट (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("अंतराल", टाइमवैल्यू (सेकंड (1.0)));
echoClient.SetAttribute ("पैकेटसाइज़", UintegerValue (1024));

ApplicationContainer clientApps = EchoClient.Install (p2pNodes.Get (0));
clientApps.Start (सेकेंड (2.0));
clientApps.Stop (सेकेंड (10.0));

चूंकि हमने वास्तव में यहां एक इंटरनेटवर्क बनाया है, इसलिए हमें किसी प्रकार के इंटरनेटवर्क की आवश्यकता है
मार्ग। एनएस- 3 आपकी सहायता के लिए वह सुविधा प्रदान करता है जिसे हम वैश्विक रूटिंग कहते हैं। ग्लोबल रूटिंग लेता है
इस तथ्य का लाभ यह है कि संपूर्ण इंटरनेटवर्क सिमुलेशन में पहुंच योग्य है
सिमुलेशन के लिए बनाए गए सभी नोड्स के माध्यम से चलता है --- यह कड़ी मेहनत करता है
राउटर्स को कॉन्फ़िगर किए बिना आपके लिए रूटिंग सेट करना।

मूल रूप से, होता यह है कि प्रत्येक नोड ऐसा व्यवहार करता है मानो वह कोई ओएसपीएफ राउटर हो
पर्दे के पीछे अन्य सभी राउटर्स के साथ तुरंत और जादुई तरीके से संचार करता है। प्रत्येक नोड
लिंक विज्ञापन तैयार करता है और उन्हें सीधे वैश्विक रूट मैनेजर तक पहुंचाता है
जो प्रत्येक नोड के लिए राउटिंग टेबल बनाने के लिए इस वैश्विक जानकारी का उपयोग करता है। सेटिंग
रूटिंग का यह रूप एक-लाइनर है:

Ipv4GlobalRoutingHelper::PopulatedRoutingTables ();

इसके बाद हम pcap ट्रेसिंग सक्षम करते हैं। पीकैप ट्रेसिंग को सक्षम करने के लिए कोड की पहली पंक्ति
पॉइंट-टू-पॉइंट हेल्पर से आप अब तक परिचित होंगे। दूसरी पंक्ति pcap को सक्षम बनाती है
सीएसएमए हेल्पर में ट्रेसिंग और एक अतिरिक्त पैरामीटर है जिसका आपने अभी तक सामना नहीं किया है।

pointToPoint.EnablePcapAll ("दूसरा");
csma.EnablePcap ("दूसरा", csmaDevices.Get (1), सत्य);

सीएसएमए नेटवर्क एक मल्टी-प्वाइंट-टू-प्वाइंट नेटवर्क है। इसका मतलब यह है कि वहाँ हो सकते हैं (और हैं
इस मामले में) एक साझा माध्यम पर एकाधिक समापन बिंदु। इनमें से प्रत्येक समापन बिंदु पर एक जाल है
इससे जुड़ा उपकरण. ट्रेस इकट्ठा करने के दो बुनियादी विकल्प हैं
ऐसे नेटवर्क से जानकारी. एक तरीका प्रत्येक नेट डिवाइस के लिए एक ट्रेस फ़ाइल बनाना है
और केवल उन पैकेटों को संग्रहीत करें जो उस नेट डिवाइस द्वारा उत्सर्जित या उपभोग किए जाते हैं। एक और तरीका
किसी एक डिवाइस को चुनना और उसे प्रोमिसस मोड में रखना है। तब वह एकल उपकरण
सभी पैकेटों के लिए नेटवर्क को "सूँघता" है और उन्हें एक एकल पैक फ़ाइल में संग्रहीत करता है। यह कैसे है
टीसीपीडम्प, उदाहरण के लिए, काम करता है। वह अंतिम पैरामीटर सीएसएमए सहायक को बताता है कि ऐसा करना है या नहीं
पैकेटों को प्रॉमिसस मोड में कैप्चर करने की व्यवस्था करें।

इस उदाहरण में, हम CSMA नेटवर्क पर किसी एक डिवाइस का चयन करने जा रहे हैं और उससे पूछ रहे हैं
नेटवर्क का एक अजीब सूंघ प्रदर्शन करने के लिए, जिससे अनुकरण किया जा सके टीसीपीडम्प करेंगे।
यदि आप लिनक्स मशीन पर होते तो आप कुछ ऐसा कर सकते थे टीसीपीडम्प -i eth0 पाने के लिए
पता लगाना। इस मामले में, हम उपयोग करने वाले डिवाइस को निर्दिष्ट करते हैं csmaDevices.प्राप्त करें(1), जो का चयन करता है
कंटेनर में पहला उपकरण. अंतिम पैरामीटर को सत्य पर सेट करने से प्रोमिसस सक्षम हो जाता है
पकड़ लेता है.

कोड का अंतिम भाग ठीक वैसे ही चलता है और सिमुलेशन को साफ़ करता है प्रथम.सीसी
उदाहरण।

सिम्युलेटर :: रन ();
सिम्युलेटर::नष्ट करें ();
0 वापसी;
}

इस उदाहरण को चलाने के लिए, इसकी प्रतिलिपि बनाएँ दूसरा.सीसी स्क्रैच निर्देशिका में उदाहरण स्क्रिप्ट
और निर्माण के लिए वेफ़ का उपयोग करें जैसा आपने किया था प्रथम.सीसी उदाहरण। यदि आप में हैं
आपके द्वारा टाइप की गई रिपॉजिटरी की शीर्ष-स्तरीय निर्देशिका,

$ सीपी उदाहरण/ट्यूटोरियल/सेकंड.सीसी स्क्रैच/मायसेकंड.सीसी
$ ./वफ़ा

चेतावनी: हम फ़ाइल का उपयोग करते हैं दूसरा.सीसी यह सत्यापित करने के लिए हमारे प्रतिगमन परीक्षणों में से एक के रूप में कि यह काम करता है
बिल्कुल वैसा ही जैसा हम सोचते हैं कि आपके ट्यूटोरियल अनुभव को सकारात्मक बनाने के लिए इसे करना चाहिए।
इसका मतलब है कि एक निष्पादन योग्य नाम दूसरा प्रोजेक्ट में पहले से मौजूद है. किसी से बचने के लिए
आप क्या क्रियान्वित कर रहे हैं इसके बारे में भ्रम है, कृपया नाम बदलें मायसेकंड.सीसी सुझाव
ऊपर।

यदि आप ट्यूटोरियल का निष्ठापूर्वक पालन कर रहे हैं (आप हैं, है ना) तो भी आप ऐसा करेंगे
NS_LOG वेरिएबल सेट, इसलिए आगे बढ़ें और उस वेरिएबल को साफ़ करें और प्रोग्राम चलाएं।

$ निर्यात NS_LOG=
$ ./waf --रन स्क्रैच/मायसेकंड

चूंकि हमने यूडीपी इको एप्लिकेशन को लॉग इन करने के लिए वैसे ही सेट किया है जैसे हमने किया था प्रथम.सीसी, आप
जब आप स्क्रिप्ट चलाते हैं तो समान आउटपुट देखें।

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.415 सेकंड)
1024 पर 10.1.2.4 बाइट्स भेजी गईं
1024 से 10.1.1.1 बाइट्स प्राप्त हुए
1024 से 10.1.2.4 बाइट्स प्राप्त हुए

वह पहला संदेश याद करें, "भेजे गए 1024 बाइट्स सेवा मेरे 10.1.2.4," यूडीपी इको क्लाइंट है
सर्वर पर एक पैकेट भेजना। इस स्थिति में, सर्वर किसी भिन्न नेटवर्क पर है
(10.1.2.0). दूसरा संदेश, "प्राप्त 1024 बाइट्स से 10.1.1.1," यूडीपी इको से है
सर्वर, इको पैकेट प्राप्त होने पर उत्पन्न होता है। अंतिम संदेश, "प्राप्त 1024
बाइट्स से 10.1.2.4," इको क्लाइंट से है, जो दर्शाता है कि उसे अपनी इको प्राप्त हो गई है
सर्वर से वापस.

यदि आप अब शीर्ष स्तर की निर्देशिका में जाकर देखें, तो आपको तीन ट्रेस फ़ाइलें मिलेंगी:

second-0-0.pcap second-1-0.pcap second-2-0.pcap

आइए इन फ़ाइलों के नामकरण पर एक नज़र डालें। उन सबका रूप एक ही है,
- - .pcap. उदाहरण के लिए, सूची में पहली फ़ाइल है
सेकंड-0-0.पीकैप जो नोड शून्य, डिवाइस शून्य से पीकैप ट्रेस है। यह है
नोड ज़ीरो पर पॉइंट-टू-पॉइंट नेट डिवाइस। फ़ाइल सेकंड-1-0.पीकैप के लिए pcap ट्रेस है
नोड एक पर डिवाइस शून्य, एक पॉइंट-टू-पॉइंट नेट डिवाइस भी; और फ़ाइल सेकंड-2-0.पीकैप is
नोड दो पर डिवाइस शून्य के लिए पीकैप ट्रेस।

यदि आप अनुभाग की शुरुआत में टोपोलॉजी चित्रण को देखें, तो आप देखेंगे
वह नोड शून्य पॉइंट-टू-पॉइंट लिंक का सबसे बायां नोड है और नोड एक नोड है
जिसमें पॉइंट-टू-पॉइंट डिवाइस और सीएसएमए डिवाइस दोनों हैं। आप देखेंगे कि नोड दो है
सीएसएमए नेटवर्क पर पहला "अतिरिक्त" नोड और उसके डिवाइस शून्य को डिवाइस के रूप में चुना गया था
प्रोमिसस-मोड ट्रेस को पकड़ने के लिए।

अब, आइए इंटरनेटवर्क के माध्यम से इको पैकेट का अनुसरण करें। सबसे पहले, एक tcpdump करें
सबसे बाएं बिंदु-से-बिंदु नोड --- नोड शून्य के लिए फ़ाइल ट्रेस करें।

$ tcpdump -nn -tt -r सेकंड-0-0.pcap

आपको प्रदर्शित pcap फ़ाइल की सामग्री देखनी चाहिए:

फ़ाइल सेकंड-0-0.पीकैप से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.000000 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.017607 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

डंप की पहली पंक्ति इंगित करती है कि लिंक प्रकार PPP (पॉइंट-टू-पॉइंट) है जिसे हम
अपेक्षा करना। फिर आप आईपी से जुड़े डिवाइस के माध्यम से इको पैकेट को नोड शून्य छोड़ते हुए देखते हैं
पता 10.1.1.1 आईपी पते 10.1.2.4 (सबसे दाहिना सीएसएमए नोड) की ओर जाता है। यह पैकेट
पॉइंट-टू-पॉइंट लिंक पर चला जाएगा और पॉइंट-टू-पॉइंट नेट डिवाइस द्वारा प्राप्त किया जाएगा
नोड एक. चलो एक नज़र मारें:

$ tcpdump -nn -tt -r सेकंड-1-0.pcap

अब आपको पॉइंट-टू-पॉइंट लिंक के दूसरी तरफ का पीकैप ट्रेस आउटपुट देखना चाहिए:

फ़ाइल सेकंड-1-0.पीकैप से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.003686 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.013921 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

यहां हम देखते हैं कि लिंक प्रकार भी पीपीपी है जैसा कि हम उम्मीद करते हैं। आप आईपी से पैकेट देखें
पता 10.1.1.1 (जो 2.000000 सेकंड पर भेजा गया था) आईपी पते 10.1.2.4 की ओर बढ़ रहा है
इस इंटरफ़ेस पर दिखाई दें. अब, आंतरिक रूप से इस नोड पर, पैकेट को अग्रेषित किया जाएगा
सीएसएमए इंटरफ़ेस और हमें इसे उस डिवाइस पर पॉप आउट होते हुए देखना चाहिए जो अपने चरम की ओर बढ़ रहा है
गंतव्य।

याद रखें कि हमने सीएसएमए नेटवर्क के लिए नोड 2 को प्रमुख स्निफर नोड के रूप में चुना है
आइए फिर सेकंड-2-0.pcap को देखें और देखें कि क्या वह वहां है।

$ tcpdump -nn -tt -r सेकंड-2-0.pcap

अब आपको नोड दो, डिवाइस शून्य का विशिष्ट डंप देखना चाहिए:

फ़ाइल सेकंड-2-0.pcap से पढ़ना, लिंक-प्रकार EN10MB (ईथरनेट)
2.007698 एआरपी, अनुरोध करें कि किसके पास 10.1.2.4 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.1 बताएं, लंबाई 50
2.007710 एआरपी, उत्तर 10.1.2.4 है- 00:00:00:00:00:06, लंबाई 50
2.007803 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.013815 एआरपी, अनुरोध करें कि किसके पास 10.1.2.1 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.4 बताएं, लंबाई 50
2.013828 एआरपी, उत्तर 10.1.2.1 है- 00:00:00:00:00:03, लंबाई 50
2.013921 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

जैसा कि आप देख सकते हैं, लिंक प्रकार अब "ईथरनेट" है। हालाँकि कुछ नया सामने आया है।
बस नेटवर्क की आवश्यकता एआरपी, पता समाधान प्रोटोकॉल। नोड एक जानता है कि इसे भेजने की आवश्यकता है
पैकेट का IP पता 10.1.2.4 है, लेकिन उसे इसका MAC पता नहीं पता है
संगत नोड. यह सीएसएमए नेटवर्क पर प्रसारित होता है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ)।
वह उपकरण जिसका IP पता 10.1.2.4 है। इस मामले में, सबसे दाहिना नोड यह कहते हुए उत्तर देता है
मैक पते 00:00:00:00:00:06 पर है। ध्यान दें कि नोड दो सीधे तौर पर इसमें शामिल नहीं है
एक्सचेंज, लेकिन नेटवर्क को सूँघ रहा है और देखे गए सभी ट्रैफ़िक की रिपोर्ट कर रहा है।

यह आदान-प्रदान निम्नलिखित पंक्तियों में देखा जा सकता है,

2.007698 एआरपी, अनुरोध करें कि किसके पास 10.1.2.4 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.1 बताएं, लंबाई 50
2.007710 एआरपी, उत्तर 10.1.2.4 है- 00:00:00:00:00:06, लंबाई 50

फिर नोड वन, डिवाइस वन आगे बढ़ता है और इको पैकेट को यूडीपी इको सर्वर पर भेजता है
आईपी ​​एड्रेस 10.1.2.4.

2.007803 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024

सर्वर इको अनुरोध प्राप्त करता है और पैकेट को वापस भेजने का प्रयास करता है
स्रोत। सर्वर जानता है कि यह पता दूसरे नेटवर्क पर है जिस तक वह पहुंचता है
आईपी ​​पता 10.1.2.1. ऐसा इसलिए है क्योंकि हमने वैश्विक रूटिंग आरंभ की है और इसने सब कुछ समझ लिया है
इसमें से हमारे लिए बाहर. लेकिन, इको सर्वर नोड को पहले का मैक पता नहीं पता है
सीएसएमए नोड, इसलिए इसे इसके लिए एआरपी करना होगा जैसे पहले सीएसएमए नोड को करना था।

2.013815 एआरपी, अनुरोध करें कि किसके पास 10.1.2.1 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.4 बताएं, लंबाई 50
2.013828 एआरपी, उत्तर 10.1.2.1 है- 00:00:00:00:00:03, लंबाई 50

सर्वर फिर इको को फ़ॉरवर्डिंग नोड पर वापस भेजता है।

2.013921 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

पॉइंट-टू-पॉइंट लिंक के सबसे दाहिने नोड पर पीछे मुड़कर देखें,

$ tcpdump -nn -tt -r सेकंड-1-0.pcap

अब आप प्रतिध्वनि पैकेट को अंतिम बिंदु के रूप में बिंदु-से-बिंदु लिंक पर वापस आते हुए देख सकते हैं
ट्रेस डंप की लाइन.

फ़ाइल सेकंड-1-0.पीकैप से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.003686 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.013921 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

अंत में, आप उस नोड को देख सकते हैं जिसने प्रतिध्वनि उत्पन्न की थी

$ tcpdump -nn -tt -r सेकंड-0-0.pcap

और देखें कि प्रतिध्वनि पैकेट 2.007602 सेकंड पर स्रोत पर वापस आ जाता है,

फ़ाइल सेकंड-0-0.पीकैप से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.000000 आईपी 10.1.1.1.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.017607 आईपी 10.1.2.4.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

अंत में, याद रखें कि हमने इसमें सीएसएमए उपकरणों की संख्या को नियंत्रित करने की क्षमता जोड़ी है
कमांड लाइन तर्क द्वारा अनुकरण। आप इस तर्क को उसी तरह बदल सकते हैं जैसे कब
हमने प्रतिध्वनित पैकेटों की संख्या को बदलने पर ध्यान दिया प्रथम.सीसी उदाहरण। दौड़ने का प्रयास करें
"अतिरिक्त" उपकरणों की संख्या वाला प्रोग्राम चार पर सेट:

$ ./waf --run "स्क्रैच/मायसेकंड --nCsma=4"

अब आपको देखना चाहिए,

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.405 सेकंड)
समय 2s क्लाइंट ने 1024 पोर्ट 10.1.2.5 पर 9 बाइट्स भेजे
उस समय 2.0118s सर्वर को 1024 पोर्ट 10.1.1.1 से 49153 बाइट्स प्राप्त हुए
उस समय 2.0118s सर्वर ने 1024 बाइट्स 10.1.1.1 पोर्ट 49153 पर भेजा
उस समय 2.02461 के क्लाइंट को 1024 पोर्ट 10.1.2.5 से 9 बाइट्स प्राप्त हुए

ध्यान दें कि इको सर्वर को अब सीएसएमए नोड्स के अंतिम स्थान पर स्थानांतरित कर दिया गया है, जो कि है
डिफ़ॉल्ट केस के बजाय 10.1.2.5, 10.1.2.4.

यह संभव है कि आप किसी दर्शक द्वारा उत्पन्न ट्रेस फ़ाइल से संतुष्ट न हों
सीएसएमए नेटवर्क। हो सकता है कि आप वास्तव में किसी एक डिवाइस से ट्रेस प्राप्त करना चाहें और हो सकता है नहीं भी करें
नेटवर्क पर किसी अन्य ट्रैफ़िक में रुचि रखें। आप यह काम काफी आसानी से कर सकते हैं.

आइए एक नजर डालते हैं स्क्रैच/मायसेकंड.सीसी और उस कोड को जोड़ें जिससे हम और अधिक सक्षम हो सकें
विशिष्ट। एनएस- 3 हेल्पर्स ऐसे तरीके प्रदान करते हैं जो एक नोड नंबर और डिवाइस नंबर लेते हैं
पैरामीटर. आगे बढ़ें और बदलें Pcap सक्षम करें नीचे दिए गए कॉल के साथ कॉल करें।

pointToPoint.EnablePcap ("दूसरा", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("दूसरा", csmaNodes.Get (nCsma)->GetId (), 0, गलत);
csma.EnablePcap ("दूसरा", csmaNodes.Get (nCsma-1)->GetId (), 0, गलत);

हम जानते हैं कि हम आधार नाम "सेकंड" के साथ एक पीकैप फ़ाइल बनाना चाहते हैं और हम यह भी जानते हैं
दोनों मामलों में रुचि का उपकरण शून्य होने वाला है, इसलिए वे पैरामीटर नहीं हैं
बहुत दिलचस्प।

नोड संख्या प्राप्त करने के लिए, आपके पास दो विकल्प हैं: पहला, नोड्स को एक में क्रमांकित किया गया है
आपके द्वारा बनाए गए क्रम में शून्य से प्रारंभ करके नीरस रूप से बढ़ता हुआ फ़ैशन
उन्हें। नोड नंबर प्राप्त करने का एक तरीका यह है कि इस नंबर को "मैन्युअल रूप से" निकाला जाए
नोड निर्माण के क्रम पर विचार करना। यदि आप नेटवर्क टोपोलॉजी पर एक नज़र डालें
फ़ाइल की शुरुआत में चित्रण, हमने आपके लिए यह किया है और आप देख सकते हैं कि
अंतिम सीएसएमए नोड नोड संख्या होने जा रहा है nCsma + 1. यह दृष्टिकोण कष्टप्रद हो सकता है
बड़े सिमुलेशन में मुश्किल।

एक वैकल्पिक तरीका, जिसका उपयोग हम यहां करते हैं, यह महसूस करना है कि नोडकंटेनर शामिल
की ओर संकेत करता है एनएस- 3 आसंधि वस्तुएँ। आसंधि ऑब्जेक्ट में एक विधि होती है जिसे कहा जाता है आईडी प्राप्त करें जो होगा
उस नोड की आईडी लौटाएं, जो कि वह नोड नंबर है जिसे हम चाहते हैं। आइए एक नजर डालते हैं
डॉक्सीजन के लिए आसंधि और उस विधि का पता लगाएं, जो आगे नीचे है एनएस- 3 कोर कोड
जितना हमने अब तक देखा है; लेकिन कभी-कभी आपको उपयोगी चीज़ों की खोज लगन से करनी पड़ती है।

अपनी रिलीज़ के लिए डॉक्सीजन दस्तावेज़ पर जाएँ (याद रखें कि आप इसे यहाँ पा सकते हैं
प्रोजेक्ट वेब साइट)। आप तक पहुंच सकते हैं आसंधि दस्तावेज़ीकरण को देखकर
"कक्षाएं" टैब पर जाएं और "कक्षा सूची" को तब तक नीचे स्क्रॉल करें जब तक आपको वह न मिल जाए ns3::नोड. चयन
ns3::नोड और आपको दस्तावेज़ीकरण के लिए ले जाया जाएगा आसंधि कक्षा। यदि आप अभी
नीचे स्क्रॉल करें आईडी प्राप्त करें विधि और उसका चयन करें, आपको विस्तृत जानकारी दी जाएगी
विधि के लिए दस्तावेज़ीकरण. का उपयोग आईडी प्राप्त करें विधि नोड संख्या निर्धारित कर सकती है
जटिल टोपोलॉजी में बहुत आसान।

आइए भ्रम से बचने के लिए पुरानी ट्रेस फ़ाइलों को शीर्ष-स्तरीय निर्देशिका से साफ़ करें
क्या हो रहा है,

$ आरएम *.पीकैप
$ आरएम *.tr

यदि आप नई स्क्रिप्ट बनाते हैं और सिमुलेशन सेटिंग चलाते हैं nCsma 100 के लिए,

$ ./waf --run "स्क्रैच/मायसेकंड --nCsma=100"

आपको निम्नलिखित आउटपुट दिखाई देगा:

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.407 सेकंड)
समय 2s क्लाइंट ने 1024 पोर्ट 10.1.2.101 पर 9 बाइट्स भेजे
उस समय 2.0068s सर्वर को 1024 पोर्ट 10.1.1.1 से 49153 बाइट्स प्राप्त हुए
उस समय 2.0068s सर्वर ने 1024 बाइट्स 10.1.1.1 पोर्ट 49153 पर भेजा
उस समय 2.01761 के क्लाइंट को 1024 पोर्ट 10.1.2.101 से 9 बाइट्स प्राप्त हुए

ध्यान दें कि इको सर्वर अब 10.1.2.101 पर स्थित है जो 100 होने के अनुरूप है
अंतिम पर इको सर्वर के साथ "अतिरिक्त" सीएसएमए नोड्स। यदि आप pcap फ़ाइलों को सूचीबद्ध करते हैं
शीर्ष स्तर की निर्देशिका आप देखेंगे,

second-0-0.pcap second-100-0.pcap second-101-0.pcap

ट्रेस फ़ाइल सेकंड-0-0.पीकैप "सबसे बाईं ओर" पॉइंट-टू-पॉइंट डिवाइस है जो प्रतिध्वनि है
पैकेट स्रोत. फ़ाइल सेकंड-101-0.पीकैप सबसे दाहिनी सीएसएमए डिवाइस से मेल खाता है जो
वह जगह है जहां इको सर्वर रहता है। आपने देखा होगा कि अंतिम पैरामीटर
इको सर्वर नोड पर पीकैप ट्रेसिंग सक्षम करने के लिए कॉल गलत थी। इसका मतलब है कि निशान
उस नोड पर एकत्रित किया गया डेटा नॉन-प्रोमिसस मोड में था।

प्रोमिसकस और नॉन-प्रॉमिकस ट्रेस के बीच अंतर को स्पष्ट करने के लिए, हम भी
अगले-से-अंतिम नोड के लिए एक गैर-अप्रत्याशित ट्रेस का अनुरोध किया। आगे बढ़ो और देखो
la टीसीपीडम्प एसटी सेकंड-100-0.पीकैप.

$ tcpdump -nn -tt -r सेकंड-100-0.pcap

अब आप देख सकते हैं कि इको एक्सचेंज में नोड 100 वास्तव में एक दर्शक है। केवल
इसे प्राप्त होने वाले पैकेट ARP अनुरोध हैं जो संपूर्ण CSMA पर प्रसारित होते हैं
नेटवर्क.

फ़ाइल सेकंड-100-0.pcap से पढ़ना, लिंक-प्रकार EN10MB (ईथरनेट)
2.006698 एआरपी, अनुरोध करें कि किसके पास 10.1.2.101 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.1 बताएं, लंबाई 50
2.013815 एआरपी, अनुरोध करें कि किसके पास 10.1.2.1 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.101 बताएं, लंबाई 50

अब जरा गौर कीजिए टीसीपीडम्प एसटी सेकंड-101-0.पीकैप.

$ tcpdump -nn -tt -r सेकंड-101-0.pcap

अब आप देख सकते हैं कि नोड 101 वास्तव में इको एक्सचेंज में भागीदार है।

फ़ाइल सेकंड-101-0.pcap से पढ़ना, लिंक-प्रकार EN10MB (ईथरनेट)
2.006698 एआरपी, अनुरोध करें कि किसके पास 10.1.2.101 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.1 बताएं, लंबाई 50
2.006698 एआरपी, उत्तर 10.1.2.101 है- 00:00:00:00:00:67, लंबाई 50
2.006803 आईपी 10.1.1.1.49153 > 10.1.2.101.9: यूडीपी, लंबाई 1024
2.013803 एआरपी, अनुरोध करें कि किसके पास 10.1.2.1 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.101 बताएं, लंबाई 50
2.013828 एआरपी, उत्तर 10.1.2.1 है- 00:00:00:00:00:03, लंबाई 50
2.013828 आईपी 10.1.2.101.9 > 10.1.1.1.49153: यूडीपी, लंबाई 1024

मॉडल, गुण और वास्तविकता
यह एक छोटा सा भ्रमण करने और एक महत्वपूर्ण बात कहने के लिए एक सुविधाजनक स्थान है। यह हो सकता है
या हो सकता है कि यह आपके लिए स्पष्ट न हो, लेकिन जब भी कोई सिमुलेशन का उपयोग कर रहा हो, तो यह महत्वपूर्ण है
ठीक से समझें कि क्या मॉडलिंग की जा रही है और क्या नहीं। उदाहरण के लिए, यह आकर्षक है
पिछले अनुभाग में उपयोग किए गए सीएसएमए उपकरणों और चैनलों के बारे में ऐसे सोचें जैसे कि वे वास्तविक हों
ईथरनेट उपकरण; और यह अपेक्षा करना कि सिमुलेशन परिणाम सीधे प्रतिबिंबित करेगा कि क्या होगा
एक वास्तविक ईथरनेट में. यह मसला नहीं है।

परिभाषा के अनुसार, एक मॉडल वास्तविकता का एक अमूर्त रूप है। यह अंततः जिम्मेदारी है
तथाकथित "सटीकता की सीमा" और "डोमेन" निर्धारित करने के लिए सिमुलेशन स्क्रिप्ट लेखक की
समग्र रूप से अनुकरण की प्रयोज्यता, और इसलिए इसके घटक भाग।

कुछ मामलों में, जैसे सीएसएमए, यह निर्धारित करना काफी आसान हो सकता है कि क्या है नहीं मॉडलिंग की। द्वारा
मॉडल विवरण पढ़ना (सीएसएमए.एच) आप पा सकते हैं कि कोई टकराव का पता नहीं चल रहा है
सीएसएमए मॉडल में और यह तय करें कि इसका उपयोग आपके सिमुलेशन में कितना लागू होगा या क्या होगा
चेतावनियाँ जिन्हें आप अपने परिणामों के साथ शामिल करना चाह सकते हैं। अन्य मामलों में, यह काफी आसान हो सकता है
उन व्यवहारों को कॉन्फ़िगर करने के लिए जो किसी भी वास्तविकता से सहमत नहीं हो सकते हैं, आप बाहर जा सकते हैं और खरीद सकते हैं। यह
ऐसे कुछ उदाहरणों की जांच में कुछ समय व्यतीत करना सार्थक साबित होगा, और कैसे
आप आसानी से अपने सिमुलेशन में वास्तविकता की सीमा से बाहर जा सकते हैं।

जैसा कि आपने देखा है, एनएस- 3 प्रदान करता है गुण जिसे उपयोगकर्ता आसानी से मॉडल बदलने के लिए सेट कर सकता है
व्यवहार। इनमें से दो पर विचार करें गुण का सीएसएमएनेटडिवाइस: एमटीयू और
एनकैप्सुलेशन मोड। एमटीयू विशेषता अधिकतम ट्रांसमिशन यूनिट को इंगित करती है
उपकरण। यह डिवाइस द्वारा उपयोग की जाने वाली सबसे बड़ी प्रोटोकॉल डेटा यूनिट (PDU) का आकार है
भेजना।

एमटीयू 1500 बाइट्स पर डिफॉल्ट करता है सीएसएमएनेटडिवाइस. यह डिफ़ॉल्ट एक संख्या से मेल खाता है
आरएफसी 894 में पाया गया, "ईथरनेट पर आईपी डेटाग्राम के प्रसारण के लिए एक मानक
नेटवर्क।" संख्या वास्तव में 10Base5 के लिए अधिकतम पैकेट आकार से ली गई है
(पूर्ण-विशिष्ट ईथरनेट) नेटवर्क -- 1518 बाइट्स। यदि आप DIX एनकैप्सुलेशन घटाते हैं
ईथरनेट पैकेट (18 बाइट्स) के लिए ओवरहेड, आप अधिकतम संभव डेटा आकार के साथ समाप्त हो जाएंगे
(एमटीयू) 1500 बाइट्स का। कोई यह भी पा सकता है कि एमटीयू IEEE 802.3 नेटवर्क के लिए 1492 है
बाइट्स ऐसा इसलिए है क्योंकि एलएलसी/एसएनएपी एनकैप्सुलेशन ओवरहेड के अतिरिक्त आठ बाइट्स जोड़ता है
पैकेट। दोनों मामलों में, अंतर्निहित हार्डवेयर केवल 1518 बाइट्स भेज सकता है, लेकिन डेटा
आकार भिन्न है.

एनकैप्सुलेशन मोड सेट करने के लिए, सीएसएमएनेटडिवाइस एक प्रदान करता है विशेषता बुलाया
एनकैप्सुलेशन मोड जो मूल्यों को ग्रहण कर सके डिक्स or LLC. ये ईथरनेट के अनुरूप हैं
और क्रमशः LLC/SNAP फ़्रेमिंग।

यदि कोई छोड़ देता है एमटीयू 1500 बाइट्स पर और इनकैप्सुलेशन मोड को बदल देता है LLC, परिणाम
एक नेटवर्क होगा जो एलएलसी/एसएनएपी फ्रेमिंग के साथ 1500 बाइट पीडीयू को समाहित करता है जिसके परिणामस्वरूप
1526 बाइट्स के पैकेट, जो कई नेटवर्कों में अवैध होंगे, क्योंकि वे एक संचारित कर सकते हैं
प्रति पैकेट अधिकतम 1518 बाइट्स। इसका परिणाम संभवतः एक अनुकरण होगा
यह काफी सूक्ष्मता से उस वास्तविकता को प्रतिबिंबित नहीं करता जिसकी आप अपेक्षा कर रहे हैं।

चित्र को जटिल बनाने के लिए, जंबो फ्रेम मौजूद हैं (1500 <एमटीयू <= 9000 बाइट्स) और
सुपर-जंबो (MTU> 9000 बाइट्स) फ़्रेम जो IEEE द्वारा आधिकारिक तौर पर स्वीकृत नहीं हैं, लेकिन हैं
कुछ हाई-स्पीड (गीगाबिट) नेटवर्क और एनआईसी में उपलब्ध है। कोई भी छोड़ सकता है
इनकैप्सुलेशन मोड पर सेट किया गया डिक्स, और सेट एमटीयू विशेषता एक पर सीएसएमएनेटडिवाइस 64000 बाइट्स तक
-- भले ही एक संबद्ध Csmaचैनल आधार - सामग्री दर 10 मेगाबिट प्रति सेकंड पर सेट किया गया था। यह
यह अनिवार्य रूप से वैम्पायर-टैप किए गए 1980 के दशक की शैली 10Base5 से बना एक ईथरनेट स्विच मॉडल करेगा
नेटवर्क जो सुपर-जंबो डेटाग्राम का समर्थन करते हैं। यह निश्चित रूप से ऐसा कुछ नहीं है जो था
इसे कभी बनाया गया है, न ही कभी बनाए जाने की संभावना है, लेकिन इसे कॉन्फ़िगर करना आपके लिए काफी आसान है।

पिछले उदाहरण में, आपने एक सिमुलेशन बनाने के लिए कमांड लाइन का उपयोग किया था जिसमें 100 था
सीएसएमए नोड्स. आप उतनी ही आसानी से 500 नोड्स के साथ एक सिमुलेशन बना सकते थे। अगर आप
वास्तव में हम उस 10Base5 वैम्पायर-टैप नेटवर्क का मॉडलिंग कर रहे थे, जो पूर्ण-विशेषता की अधिकतम लंबाई है
ईथरनेट केबल 500 मीटर है, जिसमें न्यूनतम नल की दूरी 2.5 मीटर है। इसका मतलब वहां है
वास्तविक नेटवर्क पर केवल 200 टैप ही हो सकते हैं। आप बहुत आसानी से अवैध निर्माण कर सकते थे
उस तरह से भी नेटवर्क। इसका परिणाम सार्थक अनुकरण हो भी सकता है और नहीं भी
यह इस पर निर्भर करता है कि आप क्या मॉडल बनाने का प्रयास कर रहे हैं।

ऐसी ही स्थितियाँ कई स्थानों पर उत्पन्न हो सकती हैं एनएस- 3 और किसी भी सिम्युलेटर में. उदाहरण के लिए,
आप नोड्स को इस तरह से व्यवस्थित करने में सक्षम हो सकते हैं कि वे समान स्थान पर कब्जा कर लें
उसी समय, या आप उल्लंघन करने वाले एम्पलीफायरों या शोर स्तरों को कॉन्फ़िगर करने में सक्षम हो सकते हैं
भौतिकी के बुनियादी नियम.

एनएस- 3 आम तौर पर लचीलेपन का समर्थन करता है, और कई मॉडल स्वतंत्र रूप से सेटिंग की अनुमति देंगे गुण
किसी भी मनमानी स्थिरता या विशेष अंतर्निहित विशिष्टता को लागू करने की कोशिश किए बिना।

इससे घर ले जाने वाली बात ये है एनएस- 3 एक सुपर-लचीला आधार प्रदान करने जा रहा है
आपके साथ प्रयोग करने के लिए. यह समझना आप पर निर्भर है कि आप सिस्टम से क्या पूछ रहे हैं
करने के लिए और यह सुनिश्चित करने के लिए कि आपके द्वारा बनाए गए सिमुलेशन के कुछ अर्थ और कुछ हैं
आपके द्वारा परिभाषित वास्तविकता के साथ संबंध।

इमारत a वायरलेस नेटवर्क टोपोलॉजी
इस अनुभाग में हम अपने ज्ञान का और विस्तार करने जा रहे हैं एनएस- 3 नेटवर्क डिवाइस और
वायरलेस नेटवर्क का एक उदाहरण कवर करने के लिए चैनल। एनएस- 3 802.11 मॉडल का एक सेट प्रदान करता है
यह 802.11 विनिर्देश का सटीक मैक-स्तरीय कार्यान्वयन प्रदान करने का प्रयास करता है
और 802.11a विनिर्देश का "इतना धीमा" PHY-स्तरीय मॉडल।

जैसे हमने पॉइंट-टू-पॉइंट और सीएसएमए टोपोलॉजी हेल्पर ऑब्जेक्ट दोनों को देखा है
पॉइंट-टू-पॉइंट टोपोलॉजी का निर्माण करते समय, हम समकक्ष देखेंगे वाईफ़ाई टोपोलॉजी में सहायक
यह अनुभाग। इन सहायकों की उपस्थिति और संचालन काफी परिचित लगना चाहिए
आप

हम अपने में एक उदाहरण स्क्रिप्ट प्रदान करते हैं उदाहरण/ट्यूटोरियल निर्देशिका। यह स्क्रिप्ट बनती है
la दूसरा.सीसी स्क्रिप्ट और एक वाईफ़ाई नेटवर्क जोड़ता है। आगे बढ़ो और खोलो
उदाहरण/ट्यूटोरियल/third.cc अपने पसंदीदा संपादक में. आप पहले ही काफी देख चुके होंगे
एनएस- 3 इस उदाहरण में जो कुछ चल रहा है उसे समझने के लिए कोड, लेकिन कुछ नए भी हैं
चीजें, इसलिए हम पूरी स्क्रिप्ट पर जाएंगे और कुछ आउटपुट की जांच करेंगे।

ठीक वैसे ही जैसे दूसरा.सीसी उदाहरण (और सभी में एनएस- 3 उदाहरण) फ़ाइल एक emacs से शुरू होती है
मोड लाइन और कुछ जीपीएल बॉयलरप्लेट।

ASCII कला (नीचे पुनरुत्पादित) पर एक नज़र डालें जो डिफ़ॉल्ट नेटवर्क टोपोलॉजी दिखाती है
उदाहरण में निर्मित. आप देख सकते हैं कि हम अपने उदाहरण को और आगे बढ़ाने जा रहे हैं
वायरलेस नेटवर्क को बाईं ओर से बंद करके। ध्यान दें कि यह एक डिफ़ॉल्ट नेटवर्क है
टोपोलॉजी क्योंकि आप वास्तव में वायर्ड और वायरलेस पर बनाए गए नोड्स की संख्या को भिन्न कर सकते हैं
नेटवर्क. ठीक वैसे ही जैसे दूसरा.सीसी स्क्रिप्ट केस, यदि आप बदलते हैं nCsma, यह आपको एक देगा
"अतिरिक्त" सीएसएमए नोड्स की संख्या। इसी तरह आप सेट कर सकते हैं nWifi कितने को नियंत्रित करने के लिए एसटीए
(स्टेशन) नोड सिमुलेशन में बनाए जाते हैं। वहाँ हमेशा एक रहेगा AP (प्रवेश बिन्दु)
वायरलेस नेटवर्क पर नोड. डिफ़ॉल्ट रूप से तीन "अतिरिक्त" सीएसएमए नोड और तीन हैं
वायरलेस एसटीए नोड्स।

कोड लोडिंग मॉड्यूल से शुरू होता है जिसमें फ़ाइलें शामिल होती हैं जैसा कि इसमें किया गया था दूसरा.सीसी उदाहरण।
वाईफ़ाई मॉड्यूल और गतिशीलता से संबंधित कुछ नई सुविधाएँ हैं
मॉड्यूल जिसके बारे में हम नीचे चर्चा करेंगे।

#शामिल "ns3/core-module.h"
#शामिल है "ns3/point-to-point-module.h"
#शामिल है "ns3/network-module.h"
#शामिल "ns3/applications-module.h"
#शामिल "ns3/wifi-module.h"
#शामिल "ns3/मोबिलिटी-मॉड्यूल.h"
#शामिल है "ns3/csma-module.h"
#शामिल "ns3/इंटरनेट-मॉड्यूल.एच"

नेटवर्क टोपोलॉजी चित्रण इस प्रकार है:

// डिफ़ॉल्ट नेटवर्क टोपोलॉजी
//
// वाईफ़ाई 10.1.3.0
// एपी
// * * * *
// | | | | 10.1.1.0
// n5 n6 n7 n0 -------------- n1 n2 n3 n4
// पॉइंट-टू-पॉइंट | | | |
// ================
// लैन 10.1.2.0

आप देख सकते हैं कि हम बाईं ओर के नोड में एक नया नेटवर्क डिवाइस जोड़ रहे हैं
पॉइंट-टू-पॉइंट लिंक जो वायरलेस नेटवर्क के लिए एक्सेस पॉइंट बन जाता है। की एक संख्या
वायरलेस एसटीए नोड्स नए 10.1.3.0 नेटवर्क को भरने के लिए बनाए गए हैं जैसा कि बाईं ओर दिखाया गया है
चित्रण का पक्ष.

चित्रण के बाद, एनएस- 3 नेमस्पेस है प्रयुक्त और एक लॉगिंग घटक परिभाषित किया गया है।
यह सब अब तक काफी परिचित हो जाना चाहिए।

नेमस्पेस ns3 का उपयोग करना;

NS_LOG_COMPONENT_DEFINE ("थर्डस्क्रिप्ट उदाहरण");

मुख्य कार्यक्रम वैसे ही शुरू होता है दूसरा.सीसी के लिए कुछ कमांड लाइन पैरामीटर जोड़कर
लॉगिंग घटकों को सक्षम या अक्षम करने और बनाए गए उपकरणों की संख्या को बदलने के लिए।

बूल वर्बोज़ = सत्य;
uint32_t nCsma = 3;
uint32_t nWifi = 3;

कमांडलाइन सीएमडी;
cmd.AddValue ("nCsma", "\"अतिरिक्त\" CSMA नोड्स/उपकरणों की संख्या", nCsma);
cmd.AddValue ("nWifi", "वाईफ़ाई STA उपकरणों की संख्या", nWifi);
cmd.AddValue ("वर्बोज़", "अगर सच है तो लॉग इन करने के लिए इको एप्लिकेशन को बताएं", वर्बोज़);

cmd.Parse (argc,argv);

यदि (क्रियात्मक)
{
LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);
LogComponentEnable('UdpEchoServerApplication', LOG_LEVEL_INFO);
}

पिछले सभी उदाहरणों की तरह, अगला चरण दो नोड बनाना है जो हम करेंगे
पॉइंट-टू-पॉइंट लिंक के माध्यम से कनेक्ट करें।

नोडकंटेनर पी2पीनोड्स;
p2pNodes.बनाएँ (2);

आगे, हम एक पुराने मित्र को देखते हैं। हम तत्काल ए पॉइंटटूप्वाइंटहेल्पर और संबंधित सेट करें
चूक गुण ताकि हम उपकरणों पर पांच मेगाबिट प्रति सेकंड ट्रांसमीटर बना सकें
सहायक का उपयोग करके बनाया गया और सहायक द्वारा बनाए गए चैनलों पर दो मिलीसेकंड की देरी हुई।
हम तो इंस्टॉल नोड्स पर उपकरण और उनके बीच का चैनल।

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;
पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));
पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

नेटडिवाइसकंटेनर पी2पीडिवाइसेस;
p2pDevices =pointToPoint.Install (p2pNodes);

अगला, हम एक और घोषणा करते हैं नोडकंटेनर उन नोड्स को पकड़ने के लिए जो बस का हिस्सा होंगे
(सीएसएमए) नेटवर्क।

नोडकंटेनर csmaNodes;
csmaNodes.जोड़ें (p2pNodes.Get (1));
csmaNodes.Create (nCsma);

कोड की अगली पंक्ति हो जाता है से पहला नोड (जैसा कि एक का सूचकांक होता है)।
पॉइंट-टू-पॉइंट नोड कंटेनर और इसे नोड्स के कंटेनर में जोड़ता है जिसे सीएसएमए मिलेगा
उपकरण। विचाराधीन नोड एक पॉइंट-टू-पॉइंट डिवाइस और एक सीएसएमए के साथ समाप्त होने जा रहा है
उपकरण। फिर हम कई "अतिरिक्त" नोड बनाते हैं जो CSMA के शेष भाग की रचना करते हैं
नेटवर्क.

फिर हम एक को इंस्टेंट करते हैं सीएसएमए हेल्पर और सेट अपने गुण जैसा कि हमने पिछले उदाहरण में किया था।
हम एक बनाते हैं नेटडिवाइसकंटेनर बनाए गए सीएसएमए नेट उपकरणों का ट्रैक रखने के लिए और फिर हम
स्थापित करें चयनित नोड्स पर सीएसएमए डिवाइस।

सीएसएमएहेल्पर सीएसएमए;
csma.SetChannelAttribute ("डेटारेट", स्ट्रिंगवैल्यू ("100 एमबीपीएस"));
csma.SetChannelAttribute ("देरी", टाइमवैल्यू (नैनोसेकंड (6560)));

NetDeviceContainer csmaDevices;
csmaDevices = csma.इंस्टॉल (csmaNodes);

इसके बाद, हम नोड्स बनाने जा रहे हैं जो वाईफ़ाई नेटवर्क का हिस्सा होंगे। हम हैं
कमांड लाइन तर्क द्वारा निर्दिष्ट कई "स्टेशन" नोड्स बनाने जा रहा है, और
हम पॉइंट-टू-पॉइंट लिंक के "सबसे बाएं" नोड को नोड के रूप में उपयोग करने जा रहे हैं
अभिगम केंद्र।

NodeContainer wifiStaNodes;
wifiStaNodes.Create (nWifi);
NodeContainer wifiApNode = p2pNodes.Get (0);

कोड का अगला बिट वाईफाई डिवाइस और उनके बीच इंटरकनेक्शन चैनल का निर्माण करता है
ये वाईफाई नोड्स. सबसे पहले, हम PHY और चैनल हेल्पर्स को कॉन्फ़िगर करते हैं:

YansWifiChannelHelper चैनल = YansWifiChannelHelper::Default ();
YansWifiPhyHelper phy = YansWifiPhyHelper::Default ();

सरलता के लिए, यह कोड डिफ़ॉल्ट PHY परत कॉन्फ़िगरेशन और चैनल मॉडल का उपयोग करता है
जो एपीआई डॉक्सिजन दस्तावेज़ में प्रलेखित हैं
YansWifiChannelHelper::डिफ़ॉल्ट और YansWifiPhyHelper::डिफ़ॉल्ट तरीके. एक बार ये वस्तुएँ
बनाए गए हैं, हम एक चैनल ऑब्जेक्ट बनाते हैं और इसे हमारे PHY लेयर ऑब्जेक्ट मैनेजर से जोड़ते हैं
यह सुनिश्चित करने के लिए कि सभी PHY परत ऑब्जेक्ट द्वारा बनाए गए हैं YansWifiPhyHelper बांटिये
एक ही अंतर्निहित चैनल, यानी, वे एक ही वायरलेस माध्यम साझा करते हैं और कर सकते हैं
संचार और हस्तक्षेप:

phy.SetChannel (channel.Create());

एक बार PHY हेल्पर कॉन्फ़िगर हो जाने पर, हम MAC परत पर ध्यान केंद्रित कर सकते हैं। यहां हम काम करना चुनते हैं
गैर-Qos MAC के साथ इसलिए हम MAC पैरामीटर सेट करने के लिए NqosWifiMacHelper ऑब्जेक्ट का उपयोग करते हैं।

वाईफ़ाईहेल्पर वाईफ़ाई = वाईफ़ाईहेल्पर::डिफ़ॉल्ट ();
wifi.SetRemoteStationManager ("ns3::AarfWifiManager");

NqosWifiMacHelper मैक = NqosWifiMacHelper :: डिफ़ॉल्ट ();

RSI सेट रिमोटस्टेशन प्रबंधक विधि सहायक को दर नियंत्रण एल्गोरिदम का प्रकार बताती है
उपयोग। यहां, यह सहायक से AARF एल्गोरिदम का उपयोग करने के लिए कह रहा है --- विवरण, निश्चित रूप से, हैं
डॉक्सिजन में उपलब्ध है.

इसके बाद, हम मैक के प्रकार, इंफ्रास्ट्रक्चर नेटवर्क के एसएसआईडी को कॉन्फ़िगर करते हैं जिसे हम चाहते हैं
सेटअप करें और सुनिश्चित करें कि हमारे स्टेशन सक्रिय जांच न करें:

एसएसआईडी एसएसआईडी = एसएसआईडी ("एनएस-3-एसएसआईडी");
mac.SetType ("ns3::StaWifiMac",
"एसएसआईडी", एसएसआईडीवैल्यू (एसएसआईडी),
"एक्टिवप्रोबिंग", बूलियनवैल्यू (झूठा));

यह कोड सबसे पहले एक 802.11 सर्विस सेट आइडेंटिफायर (एसएसआईडी) ऑब्जेक्ट बनाता है जिसका उपयोग किया जाएगा
"Ssid" का मान सेट करने के लिए विशेषता मैक परत कार्यान्वयन का। विशेष
सहायक द्वारा बनाई जाने वाली मैक परत का प्रकार निर्दिष्ट किया गया है विशेषता के होने के नाते
"ns3::StaWifiMac" प्रकार। का उपयोग NqosWifiMacHelper यह सुनिश्चित करेगा कि
"Qosसमर्थित" विशेषता निर्मित मैक ऑब्जेक्ट के लिए गलत सेट किया गया है। इनका संयोजन
दो कॉन्फ़िगरेशन का मतलब है कि अगला बनाया गया MAC इंस्टेंस एक गैर-क्यूओएस गैर-एपी होगा
बुनियादी ढांचे बीएसएस में स्टेशन (एसटीए) (यानी, एपी के साथ एक बीएसएस)। अंततः
"सक्रिय जांच" विशेषता गलत पर सेट है. इसका मतलब यह है कि जांच के अनुरोध नहीं होंगे
इस सहायक द्वारा बनाए गए MACs द्वारा भेजा गया।

एक बार सभी स्टेशन-विशिष्ट पैरामीटर MAC और PHY दोनों पर पूरी तरह से कॉन्फ़िगर हो जाते हैं
परतें, हम अपने अब-परिचित का आह्वान कर सकते हैं स्थापित करें इनमें से वाईफाई डिवाइस बनाने की विधि
स्टेशन:

NetDeviceContainer staDevices;
staDevices = wifi.Install (phy, mac, wifiStaNodes);

हमने अपने सभी एसटीए नोड्स के लिए वाईफ़ाई कॉन्फ़िगर किया है, और अब हमें एपी को कॉन्फ़िगर करने की आवश्यकता है
(पहुंच बिंदु) नोड. हम डिफ़ॉल्ट को बदलकर यह प्रक्रिया शुरू करते हैं गुण का
NqosWifiMacHelper एपी की आवश्यकताओं को प्रतिबिंबित करने के लिए।

mac.SetType ("ns3::ApWifiMac",
"एसएसआईडी", एसएसआईडीवैल्यू (एसएसआईडी));

इस मामले में, NqosWifiMacHelper "ns3::ApWifiMac" की MAC परतें बनाने जा रहा है,
उत्तरार्द्ध निर्दिष्ट करता है कि एपी के रूप में कॉन्फ़िगर किया गया एक मैक इंस्टेंस बनाया जाना चाहिए
सहायक प्रकार का अर्थ है कि "QosSupported" विशेषता गलत पर सेट किया जाना चाहिए - अक्षम करना
निर्मित APs पर 802.11e/WMM-शैली QoS समर्थन।

अगली पंक्तियाँ एकल AP बनाती हैं जो PHY-स्तर के समान सेट को साझा करती है गुण (और
चैनल) स्टेशनों के रूप में:

नेटडिवाइसकंटेनर एपीडिवाइसेस;
apDevices = wifi.Install (phy, mac, wifiApNode);

अब, हम गतिशीलता मॉडल जोड़ने जा रहे हैं। हम चाहते हैं कि एसटीए नोड्स गतिशील, गतिशील हों
एक बाउंडिंग बॉक्स के अंदर, और हम एपी नोड को स्थिर बनाना चाहते हैं। हम उपयोग करते हैं
गतिशीलता सहायक हमारे लिए इसे आसान बनाने के लिए. सबसे पहले, हम a को इंस्टेंट करते हैं गतिशीलता सहायक वस्तु
और कुछ सेट करें गुण "स्थिति आवंटनकर्ता" कार्यक्षमता को नियंत्रित करना।

मोबिलिटी हेल्पर मोबिलिटी;

गतिशीलता.सेटपोजीशनआलोकेटर ("ns3::ग्रिडपोजीशनआलोकेटर",
"मिनएक्स", डबलवैल्यू (0.0),
"मिनवाई", डबलवैल्यू (0.0),
"डेल्टाएक्स", डबलवैल्यू (5.0),
"डेल्टावाई", डबलवैल्यू (10.0),
"ग्रिडविड्थ", यूइंटेगरवैल्यू (3),
"लेआउटटाइप", स्ट्रिंगवैल्यू ("रोफर्स्ट"));

यह कोड मोबिलिटी हेल्पर को शुरुआत में दो-आयामी ग्रिड का उपयोग करने के लिए कहता है
एसटीए नोड्स. कक्षा के लिए डॉक्सीजन का अन्वेषण करने के लिए स्वतंत्र महसूस करें ns3::ग्रिडपोजीशनएलोकेटर करने के लिए देखने के
वास्तव में क्या किया जा रहा है.

हमने अपने नोड्स को प्रारंभिक ग्रिड पर व्यवस्थित किया है, लेकिन अब हमें उन्हें यह बताने की ज़रूरत है कि कैसे आगे बढ़ना है।
हम चुनते हैं RandomWalk2dMobilityModel जिसमें नोड्स यादृच्छिक दिशा में चलते हैं
एक बाउंडिंग बॉक्स के अंदर एक यादृच्छिक गति।

गतिशीलता.सेटमोबिलिटीमॉडल ("ns3::RandomWalk2dMobilityModel",
"बाउंड्स", रेक्टेंगलवैल्यू (आयत (-50, 50, -50, 50)));

अब हम बताते हैं गतिशीलता सहायक एसटीए नोड्स पर गतिशीलता मॉडल स्थापित करने के लिए।

गतिशीलता.इंस्टॉल करें (wifiStaNodes);

हम चाहते हैं कि सिमुलेशन के दौरान पहुंच बिंदु एक निश्चित स्थिति में रहे। हम
इस नोड के लिए गतिशीलता मॉडल सेट करके इसे पूरा करें
ns3::ConstantPositionMobilityModel:

मोबिलिटी।सेटमोबिलिटीमॉडल ("ns3::ConstantPositionMobilityModel");
गतिशीलता.इंस्टॉल करें (wifiApNode);

अब हमारे पास अपने नोड्स, डिवाइस और चैनल तैयार हैं, और गतिशीलता मॉडल चुने गए हैं
वाईफ़ाई नोड्स, लेकिन हमारे पास कोई प्रोटोकॉल स्टैक मौजूद नहीं है। जैसा कि हमने पहले भी कई बार किया है
कई बार, हम इसका उपयोग करेंगे इंटरनेटस्टैकहेल्पर इन ढेरों को स्थापित करने के लिए.

इंटरनेटस्टैकहेल्पर स्टैक;
स्टैक.इंस्टॉल (csmaNodes);
स्टैक.इंस्टॉल (wifiApNode);
स्टैक.इंस्टॉल (wifiStaNodes);

ठीक वैसे ही जैसे दूसरा.सीसी उदाहरण स्क्रिप्ट, हम इसका उपयोग करने जा रहे हैं आईपीवी4पता हेल्पर सेवा मेरे
हमारे डिवाइस इंटरफेस को आईपी पते निर्दिष्ट करें। सबसे पहले हम बनाने के लिए नेटवर्क 10.1.1.0 का उपयोग करते हैं
हमारे दो पॉइंट-टू-पॉइंट डिवाइस के लिए आवश्यक दो पते। फिर हम नेटवर्क 10.1.2.0 का उपयोग करते हैं
सीएसएमए नेटवर्क को पते निर्दिष्ट करने के लिए और फिर हम नेटवर्क 10.1.3.0 से पते निर्दिष्ट करते हैं
वायरलेस नेटवर्क पर एसटीए डिवाइस और एपी दोनों के लिए।

Ipv4AddressHelper पता;

पता.सेटबेस ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer p2pInterfaces;
पी2पीइंटरफेस = पता.असाइन (पी2पीडिवाइस);

पता.सेटबेस ("10.1.2.0", "255.255.255.0");
Ipv4InterfaceContainer csmaInterfaces;
csmaInterfaces = पता.असाइन (csmaDevices);

पता.सेटबेस ("10.1.3.0", "255.255.255.0");
पता.असाइन करें (staDevices);
पता.असाइन करें (एपीडिवाइसेस);

हमने शुरुआत में चित्रण में इको सर्वर को "सबसे दाएं" नोड पर रखा है
फ़ाइल। हमने पहले भी ऐसा किया है.

UdpEchoServerHelper इकोसर्वर (9);

ApplicationContainer serverApps = EchoServer.Install (csmaNodes.Get (nCsma));
सर्वरएप्स.स्टार्ट (सेकंड्स (1.0));
सर्वरएप्स.स्टॉप (सेकंड्स (10.0));

और हम इको क्लाइंट को हमारे द्वारा बनाए गए अंतिम एसटीए नोड पर डालते हैं, इसे सर्वर पर इंगित करते हैं
सीएसएमए नेटवर्क। हमने पहले भी ऐसे ऑपरेशन देखे हैं.

UdpEchoClientHelper इकोक्लाइंट (csmaInterfaces.GetAddress (nCsma), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("अंतराल", टाइमवैल्यू (सेकंड (1.0)));
echoClient.SetAttribute ("पैकेटसाइज़", UintegerValue (1024));

एप्लिकेशनकंटेनर क्लाइंटएप्स =
इको क्लाइंट। इंस्टॉल करें (wifiStaNodes.Get (nWifi - 1));
clientApps.Start (सेकेंड (2.0));
clientApps.Stop (सेकेंड (10.0));

चूंकि हमने यहां इंटरनेटवर्क बनाया है, इसलिए हमें इंटरनेटवर्क रूटिंग को भी सक्षम करने की आवश्यकता है
हमने इसमें किया दूसरा.सीसी उदाहरण स्क्रिप्ट.

Ipv4GlobalRoutingHelper::PopulatedRoutingTables ();

एक बात जो कुछ उपयोगकर्ताओं को आश्चर्यचकित कर सकती है वह यह तथ्य है कि हमने अभी जो सिमुलेशन बनाया है
कभी भी "स्वाभाविक रूप से" नहीं रुकेगा। ऐसा इसलिए है क्योंकि हमने वायरलेस एक्सेस प्वाइंट के बारे में पूछा था
बीकन उत्पन्न करें. यह हमेशा के लिए बीकन उत्पन्न करेगा, और इसका परिणाम सिम्युलेटर होगा
भविष्य में होने वाली घटनाओं को अनिश्चित काल के लिए शेड्यूल किया जा रहा है, इसलिए हमें सिम्युलेटर को रुकने के लिए कहना चाहिए
भले ही इसमें बीकन उत्पादन कार्यक्रम निर्धारित हों। कोड की निम्नलिखित पंक्ति
सिम्युलेटर को रुकने के लिए कहता है ताकि हम हमेशा के लिए बीकन का अनुकरण न करें और जो है उसे दर्ज न करें
मूलतः एक अंतहीन पाश।

सिम्युलेटर::स्टॉप (सेकंड (10.0));

हम तीनों नेटवर्क को कवर करने के लिए पर्याप्त ट्रेसिंग बनाते हैं:

pointToPoint.EnablePcapAll ("तीसरा");
phy.EnablePcap ("तीसरा", apDevices.Get (0));
csma.EnablePcap ("तीसरा", csmaDevices.Get (0), सत्य);

कोड की ये तीन पंक्तियाँ दोनों पॉइंट-टू-पॉइंट नोड्स पर पीकैप ट्रेसिंग शुरू कर देंगी
हमारी रीढ़ की हड्डी के रूप में कार्य करता है, वाईफ़ाई नेटवर्क पर एक विशिष्ट (मॉनिटर) मोड ट्रेस शुरू करेगा,
और सीएसएमए नेटवर्क पर एक संदिग्ध ट्रेस शुरू करेगा। यह हमें सब कुछ देखने देगा
ट्रेस फ़ाइलों की न्यूनतम संख्या के साथ ट्रैफ़िक।

अंत में, हम वास्तव में सिमुलेशन चलाते हैं, सफाई करते हैं और फिर प्रोग्राम से बाहर निकलते हैं।

सिम्युलेटर :: रन ();
सिम्युलेटर::नष्ट करें ();
0 वापसी;
}

इस उदाहरण को चलाने के लिए, आपको इसे कॉपी करना होगा तृतीय.सीसी उदाहरण स्क्रिप्ट में
स्क्रैच निर्देशिका बनाएं और निर्माण के लिए वेफ़ का उपयोग करें जैसा आपने किया था दूसरा.सीसी उदाहरण। अगर तुम
आपके द्वारा टाइप की जाने वाली रिपॉजिटरी की शीर्ष-स्तरीय निर्देशिका में हैं,

$ सीपी उदाहरण/ट्यूटोरियल/थर्ड.सीसी स्क्रैच/मायथर्ड.सीसी
$ ./वफ़ा
$ ./waf --रन स्क्रैच/मायथर्ड

फिर से, चूंकि हमने यूडीपी इको एप्लिकेशन को वैसे ही सेट किया है जैसे हमने इसमें किया था दूसरा.सीसी
स्क्रिप्ट, आपको समान आउटपुट दिखाई देगा।

वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.407 सेकंड)
समय 2s क्लाइंट ने 1024 पोर्ट 10.1.2.4 पर 9 बाइट्स भेजे
उस समय 2.01796s सर्वर को 1024 पोर्ट 10.1.3.3 से 49153 बाइट्स प्राप्त हुए
उस समय 2.01796s सर्वर ने 1024 बाइट्स 10.1.3.3 पोर्ट 49153 पर भेजा
उस समय 2.03364 के क्लाइंट को 1024 पोर्ट 10.1.2.4 से 9 बाइट्स प्राप्त हुए

याद करें वह पहला सन्देश, भेजे गए 1024 बाइट्स सेवा मेरे 10.1.2.4," यूडीपी इको क्लाइंट है
सर्वर पर एक पैकेट भेजना। इस स्थिति में, क्लाइंट वायरलेस नेटवर्क पर है
(10.1.3.0). दूसरा संदेश, "प्राप्त 1024 बाइट्स से 10.1.3.3," यूडीपी इको से है
सर्वर, इको पैकेट प्राप्त होने पर उत्पन्न होता है। अंतिम संदेश, "प्राप्त 1024
बाइट्स से 10.1.2.4," इको क्लाइंट से है, जो दर्शाता है कि उसे अपनी इको प्राप्त हो गई है
सर्वर से वापस.

यदि आप अब शीर्ष स्तर की निर्देशिका में जाकर देखें, तो आपको चार ट्रेस फ़ाइलें मिलेंगी
यह अनुकरण, नोड शून्य से दो और नोड एक से दो:

third-0-0.pcap third-0-1.pcap third-1-0.pcap third-1-1.pcap

फ़ाइल "थर्ड-0-0.pcap" नोड शून्य पर पॉइंट-टू-पॉइंट डिवाइस से मेल खाती है -
"रीढ़ की हड्डी" के बाईं ओर. फ़ाइल "थर्ड-1-0.pcap" पॉइंट-टू-पॉइंट से मेल खाती है
नोड एक पर डिवाइस - "रीढ़ की हड्डी" के दाईं ओर। फ़ाइल "third-0-1.pcap" होगी
वाईफ़ाई नेटवर्क से विशिष्ट (मॉनिटर मोड) ट्रेस और फ़ाइल "थर्ड-1-1.पीकैप"
सीएसएमए नेटवर्क से विशिष्ट ट्रेस होगा। क्या आप निरीक्षण करके इसकी पुष्टि कर सकते हैं?
कोड?

चूंकि इको क्लाइंट वाईफ़ाई नेटवर्क पर है, तो चलिए वहीं से शुरू करते हैं। आइये एक नजर डालते हैं
विशिष्ट (मॉनिटर मोड) ट्रेस हमने उस नेटवर्क पर कैप्चर किया।

$ tcpdump -nn -tt -r तीसरा-0-1.pcap

आपको कुछ वाईफ़ाई जैसी दिखने वाली सामग्री देखनी चाहिए जो आपने पहले यहां नहीं देखी है:

फ़ाइल थर्ड-0-1.pcap से पढ़ना, लिंक-प्रकार IEEE802_11 (802.11)
0.000025 बीकन (एनएस-3-एसएसआईडी) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी] आईबीएसएस
0.000308 एसोसिएट अनुरोध (एनएस-3-एसएसआईडी) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी]
0.000324 Acknowledgment RA:00:00:00:00:00:08
0.000402 सहयोगी प्रतिक्रिया सहायता(0) :: सफल
0.000546 Acknowledgment RA:00:00:00:00:00:0a
0.000721 एसोसिएट अनुरोध (एनएस-3-एसएसआईडी) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी]
0.000737 Acknowledgment RA:00:00:00:00:00:07
0.000824 सहयोगी प्रतिक्रिया सहायता(0) :: सफल
0.000968 Acknowledgment RA:00:00:00:00:00:0a
0.001134 एसोसिएट अनुरोध (एनएस-3-एसएसआईडी) [6.0 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी]
0.001150 Acknowledgment RA:00:00:00:00:00:09
0.001273 सहयोगी प्रतिक्रिया सहायता(0) :: सफल
0.001417 Acknowledgment RA:00:00:00:00:00:0a
0.102400 बीकन (एनएस-3-एसएसआईडी) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी] आईबीएसएस
0.204800 बीकन (एनएस-3-एसएसआईडी) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी] आईबीएसएस
0.307200 बीकन (एनएस-3-एसएसआईडी) [6.0* 9.0 12.0 18.0 24.0 36.0 48.0 54.0 एमबीटी] आईबीएसएस

आप देख सकते हैं कि लिंक प्रकार अब 802.11 है जैसा कि आप उम्मीद करेंगे। आप शायद कर सकते हैं
समझें कि क्या हो रहा है और इसमें आईपी इको अनुरोध और प्रतिक्रिया पैकेट ढूंढें
पता लगाना। हम इसे ट्रेस डंप को पूरी तरह से पार्स करने के अभ्यास के रूप में छोड़ देते हैं।

अब, पॉइंट-टू-पॉइंट लिंक के दाईं ओर की pcap फ़ाइल को देखें,

$ tcpdump -nn -tt -r तीसरा-0-0.pcap

फिर से, आपको कुछ परिचित दिखने वाली सामग्री देखनी चाहिए:

फ़ाइल थर्ड-0-0.pcap से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.008151 आईपी 10.1.3.3.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.026758 आईपी 10.1.2.4.9 > 10.1.3.3.49153: यूडीपी, लंबाई 1024

यह इको पैकेट है जो बाएं से दाएं (वाईफ़ाई से सीएसएमए तक) और फिर से वापस जाता है
बिंदु-से-बिंदु लिंक.

अब, पॉइंट-टू-पॉइंट लिंक के दाईं ओर की pcap फ़ाइल को देखें,

$ tcpdump -nn -tt -r तीसरा-1-0.pcap

फिर से, आपको कुछ परिचित दिखने वाली सामग्री देखनी चाहिए:

फ़ाइल थर्ड-1-0.pcap से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
2.011837 आईपी 10.1.3.3.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.023072 आईपी 10.1.2.4.9 > 10.1.3.3.49153: यूडीपी, लंबाई 1024

यह बाएं से दाएं (वाईफ़ाई से सीएसएमए तक) और फिर से वापस जाने वाला इको पैकेट भी है
जैसा कि आप उम्मीद कर सकते हैं, थोड़े अलग समय के साथ पॉइंट-टू-पॉइंट लिंक पर।

इको सर्वर सीएसएमए नेटवर्क पर है, आइए वहां मौजूद विशिष्ट ट्रेस को देखें:

$ tcpdump -nn -tt -r तीसरा-1-1.pcap

आपको कुछ परिचित दिखने वाली सामग्री देखनी चाहिए:

फ़ाइल थर्ड-1-1.pcap से पढ़ना, लिंक-प्रकार EN10MB (ईथरनेट)
2.017837 एआरपी, अनुरोध करें कि किसके पास 10.1.2.4 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.1 बताएं, लंबाई 50
2.017861 एआरपी, उत्तर 10.1.2.4 है- 00:00:00:00:00:06, लंबाई 50
2.017861 आईपी 10.1.3.3.49153 > 10.1.2.4.9: यूडीपी, लंबाई 1024
2.022966 एआरपी, अनुरोध करें कि किसके पास 10.1.2.1 है (एफएफ:एफएफ:एफएफ:एफएफ:एफएफ:एफएफ) 10.1.2.4 बताएं, लंबाई 50
2.022966 एआरपी, उत्तर 10.1.2.1 है- 00:00:00:00:00:03, लंबाई 50
2.023072 आईपी 10.1.2.4.9 > 10.1.3.3.49153: यूडीपी, लंबाई 1024

इसे आसानी से समझना चाहिए. यदि आप भूल गए हैं, तो वापस जाएँ और चर्चा देखें
in दूसरा.सीसी. ये वही क्रम है.

अब, हमने वायरलेस नेटवर्क आदि के लिए गतिशीलता मॉडल स्थापित करने में बहुत समय बिताया है
यह दिखाए बिना कि एसटीए नोड्स वास्तव में घूम रहे हैं, समाप्त करना शर्म की बात होगी
अनुकरण के दौरान चारों ओर। आइए इसमें शामिल होकर ऐसा करें गतिशीलता मॉडल पाठ्यक्रम
ट्रेस स्रोत बदलें. यह विस्तृत अनुरेखण अनुभाग की एक झलक मात्र है
आ रहा है, लेकिन उदाहरण पाने के लिए यह एक बहुत अच्छी जगह लगती है।

जैसा कि "ट्वीकिंग एनएस-3" अनुभाग में बताया गया है एनएस- 3 ट्रेसिंग सिस्टम को ट्रेस में विभाजित किया गया है
स्रोत और ट्रेस सिंक, और हम दोनों को जोड़ने के लिए फ़ंक्शन प्रदान करते हैं। हम उपयोग करेंगे
गतिशीलता मॉडल पूर्वनिर्धारित पाठ्यक्रम ट्रेस घटनाओं को उत्पन्न करने के लिए ट्रेस स्रोत को बदलता है। हम
उस स्रोत से जुड़ने के लिए एक ट्रेस सिंक लिखने की आवश्यकता होगी जो कुछ सुंदर प्रदर्शित करेगा
हमारे लिए जानकारी. कठिन होने की प्रतिष्ठा के बावजूद, यह वास्तव में काफी सरल है।
के मुख्य कार्यक्रम से ठीक पहले स्क्रैच/मायथर्ड.सीसी स्क्रिप्ट (अर्थात्, के ठीक बाद
NS_LOG_COMPONENT_DEFINE कथन), निम्नलिखित फ़ंक्शन जोड़ें:

शून्य
कोर्सचेंज (std::string context, Ptr नमूना)
{
वेक्टर स्थिति = मॉडल-> स्थिति प्राप्त करें ();
NS_LOG_UNCOND (संदर्भ <
" x = " << स्थिति.x << ", y = " << स्थिति.y);
}

यह कोड बिना किसी शर्त के गतिशीलता मॉडल से स्थिति की जानकारी खींचता है
नोड की x और y स्थिति को लॉग करता है। हम इस समारोह की व्यवस्था करने जा रहे हैं
हर बार कॉल किया जाता है जब इको क्लाइंट के साथ वायरलेस नोड अपनी स्थिति बदलता है। हम ये करते हैं
का उपयोग कॉन्फिग::कनेक्ट करें समारोह। बस स्क्रिप्ट में कोड की निम्नलिखित पंक्तियाँ जोड़ें
से पहले सिम्युलेटर::चलाएँ पु का र ना।

std::ओस्ट्रिंगस्ट्रीम ओएसएस;
ओस्स <
"/NodeList/" << wifiStaNodes.Get (nWifi - 1)->GetId () <
"/$ns3::मोबिलिटीमॉडल/कोर्सचेंज";

कॉन्फ़िग::कनेक्ट (oss.str (), मेककॉलबैक (&कोर्सचेंज));

हम यहां जो करते हैं वह इवेंट के ट्रेसिंग नेमस्पेस पथ वाली एक स्ट्रिंग बनाना है
जिससे हम जुड़ना चाहते हैं. सबसे पहले, हमें यह पता लगाना होगा कि हम किस नोड का उपयोग करना चाहते हैं
la आईडी प्राप्त करें विधि जैसा कि पहले बताया गया है। सीएसएमए की डिफ़ॉल्ट संख्या के मामले में और
वायरलेस नोड्स, यह नोड सात और ट्रेसिंग नेमस्पेस पथ बन जाता है
गतिशीलता मॉडल ऐसा दिखेगा,

/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज

ट्रेसिंग अनुभाग में चर्चा के आधार पर, आप अनुमान लगा सकते हैं कि यह ट्रेस पथ
वैश्विक NodeList में सातवें नोड का संदर्भ देता है। यह निर्दिष्ट करता है कि क्या कहा जाता है
प्रकार की एकत्रित वस्तु ns3::मोबिलिटीमॉडल. डॉलर चिह्न उपसर्ग का तात्पर्य है कि
मोबिलिटीमॉडल को नोड सात में एकत्रित किया गया है। पथ के अंतिम घटक का अर्थ है कि हम
उस मॉडल के "कोर्सचेंज" इवेंट से जुड़ रहे हैं।

हम कॉल करके अपने ट्रेस सिंक के साथ नोड सात में ट्रेस स्रोत के बीच संबंध बनाते हैं
कॉन्फिग::कनेक्ट करें और इस नेमस्पेस पथ को पार कर रहा हूँ। एक बार यह पूरा हो गया, तो हर पाठ्यक्रम बदल जाता है
नोड सात पर घटना हमारे ट्रेस सिंक से जुड़ी होगी, जो बदले में इसका प्रिंट आउट लेगी
नयी पदवी।

यदि आप अब सिमुलेशन चलाते हैं, तो आप पाठ्यक्रम में बदलाव होते हुए देखेंगे।

'निर्माण' सफलतापूर्वक समाप्त हुआ (5.989 सेकंड)
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10, y = 0
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.3841, y = 0.923277
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.2049, y = 1.90708
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.8136, y = 1.11368
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.8452, y = 2.11318
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.9797, y = 3.10409
समय 2s क्लाइंट ने 1024 पोर्ट 10.1.2.4 पर 9 बाइट्स भेजे
उस समय 2.01796s सर्वर को 1024 पोर्ट 10.1.3.3 से 49153 बाइट्स प्राप्त हुए
उस समय 2.01796s सर्वर ने 1024 बाइट्स 10.1.3.3 पोर्ट 49153 पर भेजा
उस समय 2.03364 के क्लाइंट को 1024 पोर्ट 10.1.2.4 से 9 बाइट्स प्राप्त हुए
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 11.3273, y = 4.04175
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 12.013, y = 4.76955
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 12.4317, y = 5.67771
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 11.4607, y = 5.91681
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 12.0155, y = 6.74878
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 13.0076, y = 6.62336
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 12.6285, y = 5.698
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 13.32, y = 4.97559
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 13.1134, y = 3.99715
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 13.8359, y = 4.68851
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 13.5953, y = 3.71789
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 12.7595, y = 4.26688
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 11.7629, y = 4.34913
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 11.2292, y = 5.19485
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 10.2344, y = 5.09394
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 9.3601, y = 4.60846
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 8.40025, y = 4.32795
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 9.14292, y = 4.99761
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 9.08299, y = 5.99581
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 8.26068, y = 5.42677
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 8.35917, y = 6.42191
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 7.66805, y = 7.14466
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 6.71414, y = 6.84456
/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 6.42489, y = 7.80181

अनुरेखण

पृष्ठभूमि
जैसा कि यूजिंगट्रेसिंगसिस्टम में बताया गया है, इसे चलाने का पूरा बिंदु एनएस- 3 अनुकरण करना है
अध्ययन के लिए आउटपुट उत्पन्न करें। आउटपुट प्राप्त करने के लिए आपके पास दो बुनियादी रणनीतियाँ हैं एनएस- 3:
सामान्य पूर्व-परिभाषित बल्क आउटपुट तंत्र का उपयोग करना और निकालने के लिए उनकी सामग्री को पार्स करना
रोचक जानकारी; या किसी तरह एक आउटपुट तंत्र विकसित करना जो सटीक संदेश देता हो
(और शायद केवल) जो जानकारी चाहिए थी।

पूर्व-परिभाषित बल्क आउटपुट तंत्र का उपयोग करने से यह फायदा होता है कि इसमें किसी भी बदलाव की आवश्यकता नहीं होती है
एनएस- 3, लेकिन रुचि के डेटा को पार्स करने और फ़िल्टर करने के लिए स्क्रिप्ट लिखने की आवश्यकता हो सकती है। अक्सर,
पीसीएपी या एनएस_लॉग आउटपुट संदेश सिमुलेशन रन के दौरान एकत्र किए जाते हैं और अलग से चलाए जाते हैं
उपयोग करने वाली स्क्रिप्ट के माध्यम से ग्रेप, प्यास or awk संदेशों को पार्स करने और कम करने तथा रूपांतरित करने के लिए
डेटा को प्रबंधनीय रूप में लाना। परिवर्तन करने के लिए प्रोग्राम लिखे जाने चाहिए, इसलिए यह
मुफ़्त में नहीं आता. एनएस_लॉग आउटपुट को का हिस्सा नहीं माना जाता है एनएस- 3 एपीआई, और कर सकते हैं
रिलीज़ के बीच चेतावनी के बिना परिवर्तन। इसके अलावा, एनएस_लॉग आउटपुट केवल में उपलब्ध है
डिबग बनाता है, इसलिए इस पर निर्भर रहने पर प्रदर्शन जुर्माना लगता है। बेशक, अगर
किसी भी पूर्व-परिभाषित आउटपुट तंत्र में रुचि की जानकारी मौजूद नहीं है
दृष्टिकोण विफल रहता है.

यदि आपको पूर्व-परिभाषित बल्क तंत्र में कुछ जानकारी जोड़ने की आवश्यकता है, तो यह कर सकता है
निश्चित रूप से किया जाएगा; और यदि आप इनमें से किसी एक का उपयोग करते हैं एनएस- 3 तंत्र, आप अपना कोड जोड़ सकते हैं
योगदान के रूप में.

एनएस- 3 ट्रेसिंग नामक एक अन्य तंत्र प्रदान करता है, जो अंतर्निहित कुछ समस्याओं से बचाता है
थोक आउटपुट तंत्र में। इसके कई महत्वपूर्ण फायदे हैं. सबसे पहले, आप कर सकते हैं
केवल अपनी रुचि की घटनाओं का पता लगाकर आपके द्वारा प्रबंधित किए जाने वाले डेटा की मात्रा कम करें
(बड़े सिमुलेशन के लिए, पोस्ट-प्रोसेसिंग के लिए सब कुछ डिस्क पर डंप करने से I/O बन सकता है
अड़चनें)। दूसरा, यदि आप इस पद्धति का उपयोग करते हैं, तो आप आउटपुट के प्रारूप को नियंत्रित कर सकते हैं
सीधे तौर पर ताकि आप पोस्टप्रोसेसिंग चरण से बच सकें प्यास, awk, पर्ल or अजगर स्क्रिप्ट. अगर
आप चाहें, तो आपके आउटपुट को सीधे gnuplot द्वारा स्वीकार्य फॉर्म में स्वरूपित किया जा सकता है
उदाहरण (GnuplotHelper भी देखें)। आप कोर में हुक जोड़ सकते हैं जो तब हो सकता है
अन्य उपयोगकर्ताओं द्वारा एक्सेस किया जा सकता है, लेकिन जब तक स्पष्ट रूप से नहीं पूछा जाएगा तब तक कोई जानकारी नहीं दी जाएगी
ऐसा करो। इन कारणों से, हमारा मानना ​​है कि एनएस- 3 ट्रेसिंग सिस्टम प्राप्त करने का सबसे अच्छा तरीका है
एक सिमुलेशन से बाहर जानकारी और इसलिए यह सबसे महत्वपूर्ण तंत्रों में से एक है
में समझने के लिए एनएस- 3.

कुंद उपकरण
किसी प्रोग्राम से जानकारी प्राप्त करने के कई तरीके हैं। सबसे सीधा तरीका है
जानकारी को सीधे मानक आउटपुट पर प्रिंट करने के लिए, जैसे:

#शामिल
...
शून्य
कुछफ़ंक्शन (शून्य)
{
uint32_t x = SOME_INTERESTING_VALUE;
...
std::cout << "x का मान है" << x << std::endl;
...
}

आपको इसके मूल में गहराई तक जाने से कोई नहीं रोक सकता एनएस- 3 और प्रिंट जोड़ना
बयान. ऐसा करना बेहद आसान है और आख़िरकार, आपके पास अपने काम पर पूरा नियंत्रण है
अपना एनएस- 3 शाखा। यह संभवतः लंबे समय तक बहुत संतोषजनक नहीं साबित होगा
हालाँकि, शब्द।

जैसे-जैसे आपके प्रोग्राम में प्रिंट स्टेटमेंट की संख्या बढ़ती है, इससे निपटने का कार्य
बड़ी संख्या में आउटपुट अधिक से अधिक जटिल हो जाएंगे। आख़िरकार, आप महसूस कर सकते हैं
यह नियंत्रित करने की आवश्यकता है कि कौन सी जानकारी किसी तरह से मुद्रित की जा रही है, शायद इसे चालू करके
और प्रिंटों की कुछ श्रेणियों को बंद करना, या उनकी मात्रा को बढ़ाना या घटाना
जो जानकारी आप चाहते हैं. यदि आप इस रास्ते पर आगे बढ़ते हैं तो आपको पता चल सकता है कि आपके पास है
को पुनः क्रियान्वित किया एनएस_लॉग तंत्र (यूज़िंग लॉगिंग देखें)। उससे बचने के लिए, इनमें से एक
पहली चीज़ जिस पर आप विचार कर सकते हैं वह है उपयोग करना एनएस_लॉग ही.

हमने ऊपर जानकारी प्राप्त करने का एक तरीका बताया है एनएस- 3 मौजूदा को पार्स करना है एनएस_लॉग
रोचक जानकारी के लिए आउटपुट. यदि आपको वह जानकारी मिलती है तो आप
मौजूदा लॉग आउटपुट में आवश्यकता मौजूद नहीं है, आप इसके मूल को संपादित कर सकते हैं एनएस- 3 और बस जोड़ें
आउटपुट स्ट्रीम के लिए आपकी रोचक जानकारी। अब, यह निश्चित रूप से इससे बेहतर है
अपना खुद का प्रिंट स्टेटमेंट जोड़ रहा हूं क्योंकि यह इस प्रकार है एनएस- 3 कोडिंग कन्वेंशन और कर सकते हैं
संभावित रूप से मौजूदा कोर के पैच के रूप में अन्य लोगों के लिए उपयोगी हो सकता है।

आइए एक यादृच्छिक उदाहरण चुनें. यदि आप इसमें अधिक लॉगिंग जोड़ना चाहते हैं एनएस- 3 टीसीपी सॉकेट
(टीसीपी-सॉकेट-बेस.सीसी) आप कार्यान्वयन में बस एक नया संदेश जोड़ सकते हैं। सूचना
में है कि TcpSocketBase::ReceivedAck() नो एसीके मामले के लिए कोई लॉग संदेश नहीं है। आप
कोड को बदलकर बस एक जोड़ा जा सकता है। यहाँ मूल है:

/** नए प्राप्त ACK को संसाधित करें */
शून्य
TcpSocketBase::ReceivedAck (Ptr पैकेट, स्थिरांक TcpHeader और tcpHeader)
{
NS_LOG_FUNCTION (यह << tcpHeader);

// ACK प्राप्त हुआ। ACK नंबर की तुलना उच्चतम अनैक्ड सेकनो से करें
यदि (0 == (tcpHeader.GetFlags () और TcpHeader::ACK))
{// यदि कोई ACK फ़्लैग नहीं है तो ध्यान न दें
}
...

नो ACK केस लॉग करने के लिए, आप एक नया जोड़ सकते हैं एनएस_लॉग_लॉजिक में if कथन का मुख्य भाग:

/** नए प्राप्त ACK को संसाधित करें */
शून्य
TcpSocketBase::ReceivedAck (Ptr पैकेट, स्थिरांक TcpHeader और tcpHeader)
{
NS_LOG_FUNCTION (यह << tcpHeader);

// ACK प्राप्त हुआ। ACK नंबर की तुलना उच्चतम अनैक्ड सेकनो से करें
यदि (0 == (tcpHeader.GetFlags () और TcpHeader::ACK))
{// यदि कोई ACK फ़्लैग नहीं है तो ध्यान न दें
NS_LOG_LOGIC ("TcpSocketBase " << यह << " कोई ACK फ़्लैग नहीं");
}
...

पहली नज़र में यह काफी सरल और संतोषजनक लग सकता है, लेकिन विचार करने लायक बात है
जिसे आप जोड़ने के लिए कोड लिख रहे होंगे एनएस_लॉग स्टेटमेंट्स और आपको भी लिखना होगा
कोड (जैसे कि) ग्रेप, प्यास or awk स्क्रिप्ट्स) आपके अलग करने के लिए लॉग आउटपुट को पार्स करने के लिए
जानकारी। ऐसा इसलिए है क्योंकि भले ही आपके पास आउटपुट पर कुछ नियंत्रण है
लॉगिंग सिस्टम में, आपके पास केवल लॉग घटक स्तर तक ही नियंत्रण होता है, जो आमतौर पर होता है
एक संपूर्ण स्रोत कोड फ़ाइल।

यदि आप किसी मौजूदा मॉड्यूल में कोड जोड़ रहे हैं, तो आपको आउटपुट के साथ भी रहना होगा
जो कि हर दूसरे डेवलपर को दिलचस्प लगा है। पाने के लिए आपको वह मिल सकता है
आपको जितनी छोटी जानकारी की आवश्यकता है, आपको बड़ी मात्रा में जानकारी से गुजरना पड़ सकता है
अनावश्यक संदेश जिनमें आपकी कोई रुचि नहीं है। आपको विशाल लॉग सहेजने के लिए बाध्य होना पड़ सकता है
जब भी आप कुछ करना चाहें तो फ़ाइलों को डिस्क पर रखें और उन्हें कुछ पंक्तियों में संसाधित करें।

चूंकि इसमें कोई गारंटी नहीं है एनएस- 3 की स्थिरता के बारे में एनएस_लॉग आउटपुट, आप भी कर सकते हैं
पता लगाएं कि लॉग आउटपुट के वे टुकड़े जिन पर आप निर्भर हैं वे गायब हो जाते हैं या बीच में बदल जाते हैं
जारी करता है. यदि आप आउटपुट की संरचना पर निर्भर हैं, तो आपको अन्य संदेश मिल सकते हैं
जोड़ा या हटाया गया जो आपके पार्सिंग कोड को प्रभावित कर सकता है।

अंत में, एनएस_लॉग आउटपुट केवल डिबग बिल्ड में उपलब्ध है, आप लॉग आउटपुट प्राप्त नहीं कर सकते
अनुकूलित बिल्ड, जो लगभग दोगुनी तेजी से चलते हैं। पर भरोसा एनएस_लॉग एक प्रदर्शन थोपता है
दंड।

इन कारणों से, हम प्रिंटों पर विचार करते हैं std::cout और एनएस_लॉग संदेश त्वरित हों और
अधिक जानकारी प्राप्त करने के गंदे तरीके एनएस- 3, लेकिन गंभीर कार्य के लिए उपयुक्त नहीं है।

स्थिर एपीआई का उपयोग करके एक स्थिर सुविधा का होना वांछनीय है जो किसी को भी पहुंचने की अनुमति देता है
मूल प्रणाली और केवल आवश्यक जानकारी प्राप्त करें। ऐसा करने में सक्षम होना वांछनीय है
यह कोर सिस्टम को बदलने और पुन: संकलित किए बिना। इससे भी बेहतर होगा ए
वह प्रणाली जो रुचि की कोई वस्तु बदलने या कोई दिलचस्प घटना होने पर उपयोगकर्ता कोड को सूचित करती है
ऐसा इसलिए हुआ ताकि उपयोगकर्ता को सक्रिय रूप से सिस्टम में इधर-उधर तलाश न करनी पड़े
बातें।

RSI एनएस- 3 ट्रेसिंग सिस्टम को उन पंक्तियों के साथ काम करने के लिए डिज़ाइन किया गया है और यह अच्छी तरह से एकीकृत है
गुण और कॉन्फिग उपप्रणालियाँ अपेक्षाकृत सरल उपयोग परिदृश्यों की अनुमति देती हैं।

अवलोकन
RSI एनएस- 3 ट्रेसिंग सिस्टम स्वतंत्र ट्रेसिंग स्रोतों की अवधारणाओं पर बनाया गया है
स्रोतों को सिंक से जोड़ने के लिए एक समान तंत्र के साथ-साथ सिंक का पता लगाना।

ट्रेस स्रोत ऐसी इकाइयाँ हैं जो सिमुलेशन में होने वाली घटनाओं का संकेत दे सकती हैं और प्रदान कर सकती हैं
दिलचस्प अंतर्निहित डेटा तक पहुंच। उदाहरण के लिए, एक ट्रेस स्रोत यह संकेत दे सकता है कि कब
पैकेट एक नेट डिवाइस द्वारा प्राप्त किया जाता है और पैकेट सामग्री तक पहुंच प्रदान करता है
रुचि रखने वाले ट्रेस सिंक। एक ट्रेस स्रोत एक दिलचस्प स्थिति का संकेत भी दे सकता है
परिवर्तन एक मॉडल में होता है. उदाहरण के लिए, टीसीपी मॉडल की कंजेशन विंडो एक प्राइम है
ट्रेस स्रोत के लिए उम्मीदवार। हर बार कंजेशन विंडो कनेक्टेड ट्रेस को बदल देती है
सिंक को पुराने और नए मूल्य के साथ अधिसूचित किया जाता है।

ट्रेस स्रोत स्वयं उपयोगी नहीं हैं; उन्हें कोड के अन्य हिस्सों से जोड़ा जाना चाहिए
जो वास्तव में स्रोत द्वारा प्रदान की गई जानकारी के साथ कुछ उपयोगी करते हैं।
ट्रेस जानकारी का उपभोग करने वाली संस्थाओं को ट्रेस सिंक कहा जाता है। ट्रेस स्रोत हैं
डेटा और ट्रेस सिंक के जनरेटर उपभोक्ता हैं। यह स्पष्ट विभाजन बड़े पैमाने की अनुमति देता है
सिस्टम के चारों ओर बिखरे हुए ट्रेस स्रोतों की संख्या उन स्थानों पर होती है जो लेखकों को मॉडल करते हैं
विश्वास उपयोगी हो सकता है. ट्रेस स्रोत सम्मिलित करने से बहुत छोटा निष्पादन होता है
उपरि.

किसी ट्रेस स्रोत द्वारा उत्पन्न ट्रेस घटनाओं के शून्य या अधिक उपभोक्ता हो सकते हैं। कर सकते हैं
ट्रेस स्रोत को एक प्रकार के पॉइंट-टू-मल्टीपॉइंट सूचना लिंक के रूप में सोचें। तुम्हारा कोड
कोर कोड के किसी विशेष भाग से ट्रेस इवेंट की तलाश खुशी-खुशी सह-अस्तित्व में रह सकती है
अन्य कोड उसी जानकारी से बिल्कुल अलग कुछ कर रहा है।

जब तक कोई उपयोगकर्ता इन स्रोतों में से किसी एक से ट्रेस सिंक नहीं जोड़ता, कुछ भी आउटपुट नहीं होता है। का उपयोग करके
ट्रेसिंग सिस्टम, आपको और उसी ट्रेस स्रोत से जुड़े अन्य लोगों को मिल रहा है
बिल्कुल वही जो वे चाहते हैं और केवल वही जो वे सिस्टम से चाहते हैं। आपमें से कोई भी नहीं है
सिस्टम द्वारा आउटपुट की जाने वाली जानकारी को बदलकर किसी अन्य उपयोगकर्ता को प्रभावित करना। अगर आप
एक ट्रेस स्रोत जोड़ने के लिए, एक अच्छे ओपन-सोर्स नागरिक के रूप में आपका काम अन्य को अनुमति दे सकता है
उपयोगकर्ताओं को नई उपयोगिताएँ प्रदान करने के लिए जो संभवतः समग्र रूप से बहुत उपयोगी हैं, बिना कुछ बनाए
को बदलता है एनएस- 3 कोर।

सरल उदाहरण
आइए कुछ मिनट लें और एक सरल अनुरेखण उदाहरण देखें। हमें जरूरत पड़ने वाली है
उदाहरण में क्या हो रहा है यह समझने के लिए कॉलबैक पर थोड़ी पृष्ठभूमि, इसलिए हम
तुरंत एक छोटा सा चक्कर लगाना होगा।

कॉलबैक
कॉलबैक प्रणाली का लक्ष्य एनएस- 3 किसी फ़ंक्शन को कॉल करने के लिए कोड के एक टुकड़े को अनुमति देना है
(या C++ में विधि) बिना किसी विशिष्ट अंतर-मॉड्यूल निर्भरता के। आख़िरकार यही मतलब है
आपको किसी प्रकार के संकेत की आवश्यकता है - आप कॉल किए गए फ़ंक्शन के पते को एक के रूप में मानते हैं
चर। इस वेरिएबल को पॉइंटर-टू-फंक्शन वेरिएबल कहा जाता है। का रिश्ता
फ़ंक्शन और पॉइंटर-टू-फ़ंक्शन के बीच वास्तव में ऑब्जेक्ट और से अलग नहीं है
पॉइंटर-टू-ऑब्जेक्ट.

C में पॉइंटर-टू-फ़ंक्शन का विहित उदाहरण है a
पॉइंटर-टू-फंक्शन-रिटर्निंग-इंटीजर (पीएफआई)। एक पीएफआई के लिए int पैरामीटर, यह
जैसे घोषित किया जा सकता है,

int (*pfi)(int arg) = 0;

(लेकिन पढ़ें सी++-अक्सर पूछे जाने वाले प्रश्न अनुभाग 33 इस तरह कोड लिखने से पहले!) आपको इससे क्या मिलता है
एक वेरिएबल है जिसे सरलता से नाम दिया गया है पीएफआई इसे मान 0 से प्रारंभ किया गया है। यदि आप चाहें
इस सूचक को किसी सार्थक चीज़ से प्रारंभ करें, आपके पास एक फ़ंक्शन होना चाहिए
मिलान हस्ताक्षर. इस मामले में, आप एक फ़ंक्शन प्रदान कर सकते हैं जो इस तरह दिखता है:

int MyFunction (int arg) {}

यदि आपके पास यह लक्ष्य है, तो आप अपने फ़ंक्शन को इंगित करने के लिए वेरिएबल को प्रारंभ कर सकते हैं:

पीएफआई = माईफंक्शन;

फिर आप कॉल के अधिक विचारोत्तेजक रूप का उपयोग करके अप्रत्यक्ष रूप से MyFunction को कॉल कर सकते हैं:

पूर्णांक परिणाम = (*pfi) (1234);

यह विचारोत्तेजक है क्योंकि ऐसा लगता है कि आप केवल फ़ंक्शन पॉइंटर को डीरेफ़रेंस कर रहे हैं
जैसे आप किसी सूचक को असंदर्भित करेंगे। हालाँकि, आमतौर पर लोग इसका फायदा उठाते हैं
तथ्य यह है कि कंपाइलर जानता है कि क्या हो रहा है और वह केवल एक छोटे फॉर्म का उपयोग करेगा:

पूर्णांक परिणाम = पीएफआई (1234);

ऐसा लगता है कि आप नामक फ़ंक्शन को कॉल कर रहे हैं पीएफआई, लेकिन कंपाइलर काफी स्मार्ट है
वेरिएबल के माध्यम से कॉल करना जानते हैं पीएफआई फ़ंक्शन के लिए परोक्ष रूप से मेरा कार्य.

वैचारिक रूप से, ट्रेसिंग सिस्टम लगभग इसी तरह काम करता है। मूलतः, एक निशान
सिंक is एक कॉलबैक. जब एक ट्रेस सिंक ट्रेस इवेंट प्राप्त करने में रुचि व्यक्त करता है, तो यह
ट्रेस स्रोत द्वारा आंतरिक रूप से रखे गए कॉलबैक की सूची में स्वयं को कॉलबैक के रूप में जोड़ता है।
जब कोई दिलचस्प घटना घटती है, तो ट्रेस स्रोत उसका आह्वान करता है ऑपरेटर(...) प्रदान कर
शून्य या अधिक तर्क. ऑपरेटर(...) अंततः सिस्टम में नीचे भटक जाता है और
कुछ उल्लेखनीय रूप से आपके द्वारा देखी गई अप्रत्यक्ष कॉल की तरह, शून्य या अधिक प्रदान करता है
पैरामीटर, कॉल के समान पीएफआई ऊपर लक्ष्य फ़ंक्शन के लिए एक पैरामीटर पारित किया गया
मेरा कार्य.

ट्रेसिंग सिस्टम जो महत्वपूर्ण अंतर जोड़ता है वह प्रत्येक ट्रेस स्रोत के लिए होता है
कॉलबैक की एक आंतरिक सूची है। केवल एक अप्रत्यक्ष कॉल करने के बजाय, एक ट्रेस
स्रोत एकाधिक कॉलबैक लागू कर सकता है। जब एक ट्रेस सिंक में रुचि व्यक्त करता है
एक ट्रेस स्रोत से सूचनाएं, यह मूल रूप से केवल अपना स्वयं का फ़ंक्शन जोड़ने की व्यवस्था करती है
कॉलबैक सूची.

यदि आप इस बारे में अधिक जानकारी में रुचि रखते हैं कि वास्तव में इसकी व्यवस्था कैसे की जाती है एनएस- 3, महसूस
के कॉलबैक अनुभाग को पढ़ने के लिए निःशुल्क एनएस- 3 मैनुअल।

पूर्वाभ्यास: चौथा.सीसी
हमने वास्तव में ट्रेसिंग का सबसे सरल उदाहरण लागू करने के लिए कुछ कोड प्रदान किए हैं
जिसे असेंबल किया जा सकता है. आप इस कोड को ट्यूटोरियल निर्देशिका में पा सकते हैं चौथा.सीसी.
आइए इसके माध्यम से चलें:

/* -*- मोड:C++; सी-फ़ाइल-शैली:"gnu"; इंडेंट-टैब-मोड:शून्य; -*- */
/*
* यह प्रोग्राम निःशुल्क सॉफ्टवेयर है; आप इसे पुनर्वितरित और/या संशोधित कर सकते हैं
* यह जीएनयू जनरल पब्लिक लाइसेंस संस्करण 2 की शर्तों के तहत है
* फ्री सॉफ्टवेयर फाउंडेशन द्वारा प्रकाशित;
*
*यह कार्यक्रम इस आशा से वितरित किया गया है कि यह उपयोगी होगा,
*लेकिन बिना किसी वारंटी के; की निहित वारंटी के बिना भी
* किसी विशेष उद्देश्य के लिए अनुरूपता या फिटनेस। देखें
* अधिक जानकारी के लिए जीएनयू जनरल पब्लिक लाइसेंस।
*
* आपको जीएनयू जनरल पब्लिक लाइसेंस की एक प्रति प्राप्त होनी चाहिए
*इस कार्यक्रम के साथ-साथ; यदि नहीं, तो फ्री सॉफ्टवेयर को लिखें
* फाउंडेशन, इंक., 59 टेम्पल प्लेस, सुइट 330, बोस्टन, एमए 02111-1307 यूएसए
*/

#शामिल है "ns3/object.h"
#शामिल है "ns3/uinteger.h"
#शामिल है "ns3/traced-value.h"
#शामिल है "ns3/trace-source-accessor.h"

#शामिल

नेमस्पेस ns3 का उपयोग करना;

इस कोड का अधिकांश भाग आपको भली-भांति परिचित होना चाहिए। जैसा ऊपर बताया गया है, ट्रेस सिस्टम
ऑब्जेक्ट और एट्रिब्यूट सिस्टम का भारी उपयोग करता है, इसलिए आपको उन्हें शामिल करने की आवश्यकता होगी।
पहले दो में उन प्रणालियों के लिए स्पष्ट रूप से घोषणाएँ शामिल हैं। आप
सब कुछ एक साथ प्राप्त करने के लिए कोर मॉड्यूल हेडर का उपयोग किया जा सकता है, लेकिन हम इसमें शामिल करते हैं
यहां स्पष्ट रूप से यह बताने के लिए कि यह सब वास्तव में कितना सरल है।

फ़ाइल, ट्रेस-वैल्यू.एच डेटा का पता लगाने के लिए आवश्यक घोषणाएँ लाता है
मूल्य शब्दार्थ का पालन करता है। सामान्य तौर पर, मूल्य शब्दार्थ का मतलब सिर्फ यह है कि आप इसे पास कर सकते हैं
ऑब्जेक्ट का पता पास करने के बजाय, ऑब्जेक्ट को स्वयं चारों ओर घुमाएं। वास्तव में यह सब क्या है
इसका मतलब यह है कि आप वास्तव में ट्रेस्डवैल्यू में किए गए सभी परिवर्तनों का पता लगाने में सक्षम होंगे
सरल तरीका।

चूँकि ट्रेसिंग सिस्टम विशेषताओं के साथ एकीकृत है, और विशेषताएँ ऑब्जेक्ट के साथ काम करती हैं,
वहाँ एक होना चाहिए एनएस- 3 वस्तु ट्रेस स्रोत के रहने के लिए। अगला कोड स्निपेट
एक साधारण वस्तु को घोषित और परिभाषित करता है जिसके साथ हम काम कर सकते हैं।

क्लास मायऑब्जेक्ट: सार्वजनिक ऑब्जेक्ट
{
सार्वजनिक:
स्थिर टाइपआईडी GetTypeId (शून्य)
{
स्थिर टाइपआईडी tid = टाइपआईडी ("मायऑब्जेक्ट")
.सेटपेरेंट (ऑब्जेक्ट::गेटटाइपआईडी ())
.कंस्ट्रक्टर जोड़ें ()
.AddTraceSource ("MyInteger",
"ट्रेस करने के लिए एक पूर्णांक मान।",
मेकट्रेससोर्सएक्सेसर (&MyObject::m_myInt),
"ns3::ट्रेस्ड::वैल्यू::Int32Callback")
;
वापसी बोली;
}

मायऑब्जेक्ट () {}
ट्रेस्डवैल्यू m_myInt;
};

ट्रेसिंग के संबंध में उपरोक्त कोड की दो महत्वपूर्ण पंक्तियाँ हैं .ट्रेससोर्स जोड़ें
और ट्रेस्डवैल्यू की घोषणा m_myInt.

RSI .ट्रेससोर्स जोड़ें ट्रेस स्रोत को कनेक्ट करने के लिए उपयोग किए जाने वाले "हुक" प्रदान करता है
कॉन्फ़िग सिस्टम के माध्यम से बाहरी दुनिया। पहला तर्क इस ट्रेस के लिए एक नाम है
स्रोत, जो इसे कॉन्फ़िगरेशन सिस्टम में दृश्यमान बनाता है। दूसरा तर्क एक सहायता स्ट्रिंग है.
अब तीसरे तर्क पर गौर करें, दरअसल इस पर ध्यान केंद्रित करें तर्क तीसरे तर्क का:
&MyObject::m_myInt. यह ट्रैस्डवैल्यू है जिसे कक्षा में जोड़ा जा रहा है; यह है
हमेशा एक क्लास डेटा सदस्य। (अंतिम तर्क a का नाम है टंकण के लिए
ट्रेस्डवैल्यू प्रकार, एक स्ट्रिंग के रूप में। इसका उपयोग सही के लिए दस्तावेज़ तैयार करने के लिए किया जाता है
कॉलबैक फ़ंक्शन हस्ताक्षर, जो विशेष रूप से अधिक सामान्य प्रकारों के लिए उपयोगी है
कॉलबैक.)

RSI ट्रेस्डवैल्यू<> घोषणा कॉलबैक को संचालित करने वाला बुनियादी ढांचा प्रदान करती है
प्रक्रिया। किसी भी समय अंतर्निहित मान बदले जाने पर ट्रैस्डवैल्यू तंत्र प्रदान करेगा
इस मामले में, उस चर का पुराना और नया दोनों मान int32_t कीमत। निशान
इस ट्रेस्डवैल्यू के लिए सिंक फ़ंक्शन को हस्ताक्षर की आवश्यकता होगी

शून्य (* ट्रेस्डवैल्यूकॉलबैक)(स्थिरांक int32_t पुरानावैल्यू, स्थिरांक int32_t नयावैल्यू);

इस ट्रेस स्रोत को हुक करने वाले सभी ट्रेस सिंक में यह हस्ताक्षर होना चाहिए। हम नीचे चर्चा करेंगे
आप अन्य मामलों में आवश्यक कॉलबैक हस्ताक्षर कैसे निर्धारित कर सकते हैं।

निश्चित रूप से, जारी रहेगा चौथा.सीसी हम देखते हैं:

शून्य
IntTrace (int32_t OldValue, int32_t newValue)
{
std::cout << "ट्रेस किया गया" << OldValue << " से " << newValue << std::endl;
}

यह मैचिंग ट्रेस सिंक की परिभाषा है। यह सीधे कॉलबैक से मेल खाता है
फ़ंक्शन हस्ताक्षर. एक बार कनेक्ट होने के बाद, यह फ़ंक्शन जब भी कॉल किया जाएगा
ट्रेस्डवैल्यू परिवर्तन।

हमने अब ट्रेस स्रोत और ट्रेस सिंक देखा है। कनेक्ट करने के लिए कोड शेष है
सिंक का स्रोत, जो होता है मुख्य:

int
मुख्य (int argc, char *argv[])
{
पीटीआर myObject = CreateObject ();
myObject->TraceConnectWithoutContext ("MyInteger", MakeCallback(&IntTrace));

myObject->m_myInt = 1234;
}

यहां हम सबसे पहले MyObject इंस्टेंस बनाते हैं जिसमें ट्रेस स्रोत रहता है।

अगला कदम, ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट, ट्रेस के बीच संबंध बनाता है
स्रोत और ट्रेस सिंक। पहला तर्क केवल ट्रेस स्रोत नाम "MyInteger" है
हमने ऊपर देखा. ध्यान दें मेककॉलबैक टेम्पलेट फ़ंक्शन. यह फ़ंक्शन जादू करता है
अंतर्निहित बनाने के लिए आवश्यक है एनएस- 3 ऑब्जेक्ट को कॉलबैक करें और इसे फ़ंक्शन के साथ संबद्ध करें
IntTrace. ट्रेसकनेक्ट आपके प्रदत्त फ़ंक्शन और के बीच संबंध बनाता है
अतिभारित ऑपरेटर() "MyInteger" विशेषता द्वारा संदर्भित ट्रेस किए गए वेरिएबल में।
यह संबद्धता बन जाने के बाद, ट्रेस स्रोत आपके प्रदत्त कॉलबैक को "फायर" कर देगा
समारोह.

यह सब घटित करने वाला कोड, बेशक, गैर-तुच्छ है, लेकिन सार यही है
आप किसी ऐसी चीज़ की व्यवस्था कर रहे हैं जो बिल्कुल वैसी ही दिखती है पीएफआई() ऊपर दिए गए उदाहरण को बुलाया जाएगा
ट्रेस स्रोत द्वारा. की घोषणा ट्रेस्डवैल्यू m_myInt; वस्तु में
अतिभारित असाइनमेंट ऑपरेटरों को प्रदान करने के लिए आवश्यक जादू खुद ही करता है
उपयोग ऑपरेटर() वास्तव में वांछित मापदंडों के साथ कॉलबैक शुरू करने के लिए।
.ट्रेससोर्स जोड़ें कॉलबैक को कॉन्फ़िगरेशन सिस्टम से कनेक्ट करने का जादू करता है, और
ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट आपके फ़ंक्शन को ट्रेस से जोड़ने का जादू करता है
स्रोत, जो विशेषता नाम द्वारा निर्दिष्ट है।

आइए अभी संदर्भ के बारे में थोड़ी सी बात को नजरअंदाज करें।

अंत में, मान निर्दिष्ट करने वाली रेखा m_myInt:

myObject->m_myInt = 1234;

के आह्वान के रूप में व्याख्या की जानी चाहिए ऑपरेटर= सदस्य चर पर m_myInt साथ में
पूर्णांक 1234 एक पैरामीटर के रूप में पारित किया गया।

जबसे m_myInt एक ट्रेस्डवैल्यू, इस ऑपरेटर को कॉलबैक निष्पादित करने के लिए परिभाषित किया गया है
शून्य लौटाता है और पैरामीटर के रूप में दो पूर्णांक मान लेता है --- एक पुराना मान और एक नया मान
प्रश्न में पूर्णांक के लिए. यह बिल्कुल कॉलबैक के लिए फ़ंक्शन हस्ताक्षर है
फ़ंक्शन जो हमने प्रदान किया --- IntTrace.

संक्षेप में, एक ट्रेस स्रोत, संक्षेप में, एक वेरिएबल है जो कॉलबैक की एक सूची रखता है। ए
ट्रेस सिंक एक फ़ंक्शन है जिसका उपयोग कॉलबैक के लक्ष्य के रूप में किया जाता है। गुण और वस्तु प्रकार
सूचना प्रणालियों का उपयोग ट्रेस स्रोतों को ट्रेस सिंक से जोड़ने का तरीका प्रदान करने के लिए किया जाता है।
किसी ट्रेस स्रोत को "हिट" करने का कार्य ट्रेस स्रोत पर एक ऑपरेटर को निष्पादित करना है
कॉलबैक सक्रिय करता है। इसके परिणामस्वरूप ट्रेस सिंक कॉलबैक में रुचि दर्ज की जाती है
स्रोत को स्रोत द्वारा उपलब्ध कराए गए मापदंडों के साथ बुलाया जा रहा है।

यदि आप अब यह उदाहरण बनाते और चलाते हैं,

$ ./waf --चौथा भागो

आप इससे आउटपुट देखेंगे IntTrace ट्रेस स्रोत होते ही फ़ंक्शन निष्पादित हो जाता है
मार:

0 से 1234 तक ट्रेस किया गया

जब हमने कोड निष्पादित किया, myObject->m_myInt = 1234;, ट्रेस स्रोत निकाल दिया गया और
ट्रेस सिंक को स्वचालित रूप से पहले और बाद के मान प्रदान किए जाते हैं। कार्यक्रम
IntTrace फिर इसे मानक आउटपुट पर मुद्रित किया।

जुड़ें साथ में कॉन्फिग
RSI ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट सरल उदाहरण में ऊपर दिखाया गया कॉल वास्तव में बहुत है
सिस्टम में शायद ही कभी उपयोग किया जाता है। अधिक सामान्यतः, कॉन्फिग ट्रेस का चयन करने के लिए सबसिस्टम का उपयोग किया जाता है
सिस्टम में स्रोत जिसे a कहा जाता है उसका उपयोग करना कॉन्फिग पथ. इसका एक उदाहरण हमने यहां देखा
पिछला भाग जहां हम प्रयोग करते समय "कोर्सचेंज" इवेंट से जुड़े थे
तृतीय.सीसी.

याद रखें कि हमने गतिशीलता से पाठ्यक्रम परिवर्तन की जानकारी प्रिंट करने के लिए एक ट्रेस सिंक को परिभाषित किया था
हमारे सिमुलेशन के मॉडल। अब यह आपके लिए और अधिक स्पष्ट हो जाएगा कि यह फ़ंक्शन क्या है
कर रहा है:

शून्य
कोर्सचेंज (std::string context, Ptr नमूना)
{
वेक्टर स्थिति = मॉडल-> स्थिति प्राप्त करें ();
NS_LOG_UNCOND (संदर्भ <
" x = " << स्थिति.x << ", y = " << स्थिति.y);
}

जब हमने "कोर्सचेंज" ट्रेस स्रोत को उपरोक्त ट्रेस सिंक से जोड़ा, तो हमने इसका उपयोग किया
जब हम पूर्व-परिभाषित के बीच एक कनेक्शन की व्यवस्था करते हैं तो स्रोत को निर्दिष्ट करने के लिए कॉन्फ़िगरेशन पथ
ट्रेस स्रोत और नया ट्रेस सिंक:

std::ओस्ट्रिंगस्ट्रीम ओएसएस;
ओएस << "/नोडेलिस्ट/"
<< wifiStaNodes.Get (nWifi - 1)->GetId ()
<< "/$ns3::मोबिलिटीमॉडल/कोर्सचेंज";

कॉन्फ़िग::कनेक्ट (oss.str (), मेककॉलबैक (&कोर्सचेंज));

आइए कुछ समझने का प्रयास करें जिसे कभी-कभी अपेक्षाकृत रहस्यमय कोड माना जाता है।
चर्चा के प्रयोजनों के लिए, मान लें कि नोड संख्या लौटा दी गई है GetId() is
"7"। इस स्थिति में, उपरोक्त पथ निकलता है

"/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज"

कॉन्फ़िगरेशन पथ का अंतिम खंड एक होना चाहिए विशेषता एक की वस्तु. वास्तव में, यदि आपके पास होता
के लिए एक सूचक वस्तु जिसमें "कोर्सचेंज" है विशेषता आसान, आप इसे लिख सकते हैं
ठीक वैसे ही जैसे हमने पिछले उदाहरण में किया था। अब तक आप जानते हैं कि हम आम तौर पर भंडारण करते हैं
हमारे लिए संकेत नोड्स एक NodeContainer में. में तृतीय.सीसी उदाहरण के लिए, रुचि के नोड्स
में संग्रहीत हैं wifiStaNodes नोडकंटेनर। वास्तव में, पथ को एक साथ रखते समय,
हमने इस कंटेनर का उपयोग एक प्राप्त करने के लिए किया पीटीआर जिसे हम कहते थे GetId(). हम कर सकते थे
इसका इस्तेमाल किया पीटीआर कनेक्ट विधि को सीधे कॉल करने के लिए:

पीटीआर ऑब्जेक्ट = wifiStaNodes.Get (nWifi - 1);
ऑब्जेक्ट->TraceConnectWithoutContext ("कोर्सचेंज", मेककॉलबैक (&कोर्सचेंज));

में तृतीय.सीसी उदाहरण के लिए, हम वास्तव में एक अतिरिक्त "संदर्भ" देना चाहते थे
कॉलबैक पैरामीटर के साथ (जिसे नीचे समझाया जाएगा) ताकि हम वास्तव में इसका उपयोग कर सकें
निम्नलिखित समकक्ष कोड:

पीटीआर ऑब्जेक्ट = wifiStaNodes.Get (nWifi - 1);
ऑब्जेक्ट->ट्रेसकनेक्ट ("कोर्सचेंज", मेककॉलबैक (&कोर्सचेंज));

यह पता चला है कि के लिए आंतरिक कोड कॉन्फिग::कनेक्टविथआउटकॉन्टेक्स्ट और कॉन्फिग::कनेक्ट करें
वास्तव में एक खोजें पीटीआर और उपयुक्त को कॉल करें ट्रेसकनेक्ट सबसे कम विधि
स्तर.

RSI कॉन्फिग फ़ंक्शंस एक पथ लेते हैं जो एक श्रृंखला का प्रतिनिधित्व करता है वस्तु सूचक. प्रत्येक खंड
पथ का एक ऑब्जेक्ट विशेषता से मेल खाता है। अंतिम खंड का गुण है
वस्तुओं को शामिल करने या ढूंढने के लिए रुचि और पूर्व खंडों को टाइप किया जाना चाहिए। कॉन्फिग कोड
पार्स करता है और इस पथ पर "चलता" है जब तक कि यह पथ के अंतिम खंड तक नहीं पहुंच जाता। यह तो
अंतिम खंड की व्याख्या एक के रूप में करता है विशेषता चलते समय मिली आखिरी वस्तु पर
पथ। कॉन्फिग फ़ंक्शंस फिर उपयुक्त को कॉल करते हैं ट्रेसकनेक्ट or
ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट अंतिम वस्तु पर विधि. देखते हैं थोड़ी देर में क्या होता है
उपरोक्त पथ पर चलने पर अधिक विवरण।

पथ में अग्रणी "/" वर्ण तथाकथित नामस्थान को संदर्भित करता है। निम्न में से एक
कॉन्फिग सिस्टम में पूर्वनिर्धारित नेमस्पेस "नोडेलिस्ट" है जो सभी की एक सूची है
अनुकरण में नोड्स. सूची में आइटम को सूची में सूचकांकों द्वारा संदर्भित किया जाता है
"/NodeList/7" सिमुलेशन के दौरान बनाए गए नोड्स की सूची में आठवें नोड को संदर्भित करता है
(याद रखें सूचकांक प्रारंभ होते हैं 0'). इस संदर्भ is वास्तव में a ``पीटीआर ` और ऐसा ही एक है
एक का उपवर्ग ns3::ऑब्जेक्ट.

जैसा कि ऑब्जेक्ट मॉडल अनुभाग में वर्णित है एनएस- 3 मैनुअल, हम व्यापक रूप से उपयोग करते हैं
वस्तु एकत्रीकरण. यह हमें विभिन्न वस्तुओं के बीच संबंध बनाने की अनुमति देता है
एक जटिल वंशानुक्रम वृक्ष का निर्माण किए बिना या यह पूर्वनिर्धारित किए बिना कि कौन सी वस्तुएं इसका हिस्सा होंगी
एक नोड का. एकत्रीकरण में प्रत्येक वस्तु तक अन्य वस्तुओं से पहुंचा जा सकता है।

हमारे उदाहरण में अगला पथ खंड "$" अक्षर से शुरू होता है। यह
कॉन्फ़िगरेशन सिस्टम को इंगित करता है कि खंड एक ऑब्जेक्ट प्रकार का नाम है, इसलिए a
गेटऑब्जेक्ट उस प्रकार की तलाश में कॉल किया जाना चाहिए। यह पता चला है कि गतिशीलता सहायक
में इस्तेमाल किया तृतीय.सीसी प्रत्येक के लिए एक गतिशीलता मॉडल एकत्र करने या संबद्ध करने की व्यवस्था करता है
वायरलेस नोड्स. जब आप "$" जोड़ते हैं तो आप किसी अन्य ऑब्जेक्ट के लिए पूछ रहे होते हैं
संभवतः पहले एकत्रित किया गया था। आप इसे पॉइंटर्स को स्विच करने के रूप में सोच सकते हैं
मूल पीटीआर जैसा कि "/NodeList/7" द्वारा इसके संबद्ध गतिशीलता मॉडल को निर्दिष्ट किया गया है ---
जो प्रकार का है ns3::मोबिलिटीमॉडल. यदि आप परिचित हैं गेटऑब्जेक्ट, हमने पूछा है
सिस्टम को निम्नलिखित कार्य करने होंगे:

पीटीआर गतिशीलतामॉडल = नोड->गेटऑब्जेक्ट ()

अब हम पथ की अंतिम वस्तु पर हैं, इसलिए हम अपना ध्यान गुणों की ओर केंद्रित करते हैं
वह वस्तु. गतिशीलता मॉडल क्लास "कोर्सचेंज" नामक एक विशेषता को परिभाषित करता है। तुम कर सकते हो
स्रोत कोड को देखकर इसे देखें src/गतिशीलता/मॉडल/गतिशीलता-model.cc और
अपने पसंदीदा संपादक में "कोर्सचेंज" खोज रहे हैं। आपको ढूंढना चाहिए

.ट्रेससोर्स जोड़ें ("कोर्सचेंज",
"स्थिति और/या वेग वेक्टर का मान बदल गया",
मेकट्रेससोर्सएक्सेसर (&मोबिलिटीमॉडल::एम_कोर्सचेंजट्रेस),
"ns3::मोबिलिटीमॉडल::कोर्सचेंजकॉलबैक")

जो इस बिंदु पर बहुत परिचित दिखना चाहिए।

यदि आप अंतर्निहित ट्रेस किए गए वैरिएबल की संबंधित घोषणा की तलाश करते हैं
गतिशीलता-मॉडल.एच आप पाएंगे

ट्रैस्डकॉलबैक > m_courseChangeTrace;

प्रकार की घोषणा ट्रैस्डकॉलबैक पहचानती m_courseChangeTrace की एक विशेष सूची के रूप में
कॉलबैक जिन्हें ऊपर वर्णित कॉन्फ़िगरेशन फ़ंक्शन का उपयोग करके हुक किया जा सकता है। टंकण एसटी
कॉलबैक फ़ंक्शन हस्ताक्षर को हेडर फ़ाइल में भी परिभाषित किया गया है:

टाइपडेफ़ शून्य (* कोर्सचेंजकॉलबैक)(पीटीआर * नमूना);

RSI गतिशीलता मॉडल क्लास को एक बेस क्लास के रूप में डिज़ाइन किया गया है जो एक सामान्य इंटरफ़ेस प्रदान करता है
सभी विशिष्ट उपवर्ग। यदि आप फ़ाइल के अंत तक खोजते हैं, तो आपको एक दिखाई देगा
विधि परिभाषित कहा जाता है अधिसूचना पाठ्यक्रम बदलें():

शून्य
MobilityModel::NotifyCourseChange (शून्य) स्थिरांक
{
m_courseChangeTrace(यह);
}

जब भी व्युत्पन्न कक्षाएं समर्थन के लिए पाठ्यक्रम में बदलाव करेंगी तो वे इस पद्धति को अपनाएंगी
अनुरेखण यह विधि आह्वान करती है ऑपरेटर() अंतर्निहित पर m_courseChangeTrace, जो
बदले में, सभी पंजीकृत कॉलबैक को आमंत्रित करेगा, सभी ट्रेस को कॉल करने से वह डूब जाएगा
कॉन्फिग फ़ंक्शन को कॉल करके ट्रेस स्रोत में रुचि दर्ज की है।

तो, में तृतीय.सीसी उदाहरण हमने देखा, जब भी किसी एक में पाठ्यक्रम परिवर्तन किया जाता है
RandomWalk2dMobilityModel स्थापित उदाहरण, वहाँ एक होगा अधिसूचना पाठ्यक्रम बदलें() कॉल
जो अंदर बुलाता है गतिशीलता मॉडल आधार वर्ग. जैसा कि ऊपर देखा गया, यह आह्वान करता है ऑपरेटर()
on m_courseChangeTrace, जो बदले में, किसी भी पंजीकृत ट्रेस सिंक को कॉल करता है। उदाहरण में,
रुचि दर्ज करने वाला एकमात्र कोड वह कोड था जो कॉन्फ़िगरेशन पथ प्रदान करता था।
इसलिए पाठ्यक्रम परिवर्तन नोड संख्या सात से जो फ़ंक्शन हुक किया गया था वह होगा
केवल कॉलबैक कॉल किया गया।

पहेली का अंतिम भाग "संदर्भ" है। याद रखें कि हमने एक आउटपुट देखते हुए देखा था
निम्नलिखित की तरह कुछ तृतीय.सीसी:

/NodeList/7/$ns3::मोबिलिटीमॉडल/कोर्सचेंज x = 7.27897, y =
2.22677

आउटपुट का पहला भाग संदर्भ है। यह बस वह मार्ग है जिसके माध्यम से
कॉन्फिग कोड ट्रेस स्रोत का पता लगाता है। जिस मामले में हम देख रहे हैं वहां हो सकता है
सिस्टम में किसी भी संख्या में नोड्स के अनुरूप ट्रेस स्रोतों की कोई भी संख्या
गतिशीलता मॉडल. यह पहचानने का कोई तरीका होना चाहिए कि वास्तव में कौन सा ट्रेस स्रोत है
वह जिसने कॉलबैक सक्रिय किया। इससे जुड़ने का आसान तरीका है कॉन्फिग::कनेक्ट करें, बजाय
of कॉन्फिग::कनेक्टविथआउटकॉन्टेक्स्ट.

खोज सूत्रों का कहना है
ट्रेसिंग सिस्टम के नए उपयोगकर्ताओं के लिए पहला प्रश्न अनिवार्य रूप से सामने आता है, "ठीक है,
I जानना कि वहाँ चाहिए be निशान स्त्रोत in la अनुकार सार, लेकिन कैसे do I खोज आउट क्या
निशान स्त्रोत रहे उपलब्ध सेवा मेरे मुझे?"

दूसरा प्रश्न है, "ठीक है, I पाया a निशान स्रोत, कैसे do I आंकड़ा आउट la कॉन्फिग पथ
सेवा मेरे उपयोग कब I कनेक्ट सेवा मेरे यह?"

तीसरा प्रश्न है, "ठीक है, I पाया a निशान स्रोत और la कॉन्फिग पथ, कैसे do I आंकड़ा
आउट क्या la वापसी टाइप और औपचारिक तर्क of my वापस कॉल करें समारोह आवश्यकता सेवा मेरे होना?"

चौथा प्रश्न है, "ठीक है, I आपके द्वारा लिखा गया कि सब in और मिला इसका अविश्वसनीय रूप से विचित्र त्रुटि
संदेश क्या in la विश्व कर देता है it अर्थ?"

हम इनमें से प्रत्येक को बारी-बारी से संबोधित करेंगे।

उपलब्ध सूत्रों का कहना है
ठीक है, I जानना कि वहाँ चाहिए be निशान स्त्रोत in la अनुकार सार, लेकिन कैसे do I खोज
आउट क्या निशान स्त्रोत रहे उपलब्ध सेवा मेरे मुझे?

पहले प्रश्न का उत्तर इसमें मिलता है एनएस- 3 एपीआई दस्तावेज़ीकरण. यदि आप जाते हैं
प्रोजेक्ट वेब साइट, एनएस- 3 परियोजना, आपको नेविगेशन में "दस्तावेज़ीकरण" का एक लिंक मिलेगा
छड़। यदि आप इस लिंक का चयन करते हैं, तो आपको हमारे दस्तावेज़ीकरण पृष्ठ पर ले जाया जाएगा। वहां एक है
"नवीनतम रिलीज़" से लिंक करें जो आपको नवीनतम स्थिरीकरण के लिए दस्तावेज़ीकरण तक ले जाएगा
की रिहाई एनएस- 3. यदि आप "एपीआई दस्तावेज़ीकरण" लिंक का चयन करते हैं, तो आपको ले जाया जाएगा
एनएस- 3 एपीआई दस्तावेज़ीकरण पृष्ठ।

साइडबार में आपको एक पदानुक्रम देखना चाहिए जो शुरू होता है

· एनएस-3

· एनएस-3 दस्तावेज़ीकरण

· सभी ट्रेस स्रोत

· सभी गुण

· सभी वैश्विक मूल्य

यहां हमारी रुचि की सूची "सभी ट्रेसस्रोत" है। आगे बढ़ें और उस लिंक का चयन करें।
आप देखेंगे, शायद बहुत आश्चर्य की बात नहीं, उपलब्ध सभी ट्रेस स्रोतों की एक सूची
in एनएस- 3.

उदाहरण के तौर पर, नीचे स्क्रॉल करें ns3::मोबिलिटीमॉडल. आपको इसके लिए एक प्रविष्टि मिलेगी

पाठ्यक्रम परिवर्तन: स्थिति और/या वेग वेक्टर का मान बदल गया

आपको इसे हमारे द्वारा उपयोग किए गए ट्रेस स्रोत के रूप में पहचानना चाहिए तृतीय.सीसी उदाहरण। ध्यानपूर्वक पढ़ने
यह सूची सहायक होगी.

कॉन्फिग पथ
ठीक है, I पाया a निशान स्रोत, कैसे do I आंकड़ा आउट la कॉन्फिग पथ सेवा मेरे उपयोग कब I कनेक्ट सेवा मेरे
यह?

यदि आप जानते हैं कि आप किस वस्तु में रुचि रखते हैं, तो इसके लिए "विस्तृत विवरण" अनुभाग
क्लास सभी उपलब्ध ट्रेस स्रोतों को सूचीबद्ध करेगी। उदाहरण के लिए, "सभी" की सूची से शुरू करना
ट्रेससोर्सेस," पर क्लिक करें ns3::मोबिलिटीमॉडल लिंक, जो आपको ले जाएगा
के लिए दस्तावेज गतिशीलता मॉडल कक्षा। पृष्ठ के लगभग शीर्ष पर एक पंक्ति है
कक्षा का संक्षिप्त विवरण, "अधिक..." लिंक में समाप्त होता है। स्किप करने के लिए इस लिंक पर क्लिक करें
एपीआई सारांश और कक्षा के "विस्तृत विवरण" पर जाएं। के अंत में
विवरण (अधिकतम) तीन सूचियाँ होंगी:

· कॉन्फिग पथ: इस वर्ग के लिए विशिष्ट कॉन्फिग पथों की एक सूची।

· गुण: इस वर्ग द्वारा प्रदत्त सभी विशेषताओं की एक सूची।

· ट्रेसस्रोत: इस वर्ग से उपलब्ध सभी ट्रेस स्रोतों की एक सूची।

पहले हम कॉन्फिग पथों पर चर्चा करेंगे।

आइए मान लें कि आपको अभी-अभी "ऑल" में "कोर्सचेंज" ट्रेस स्रोत मिला है
ट्रेससोर्स" सूची और आप यह पता लगाना चाहते हैं कि इससे कैसे जुड़ना है। आप जानते हैं कि आप हैं
(फिर से, से) का उपयोग करना तृतीय.सीसी उदाहरण) ए ns3::RandomWalk2dMobilityModel. तो या तो
"सभी ट्रेसस्रोत" सूची में कक्षा के नाम पर क्लिक करें, या खोजें
ns3::RandomWalk2dMobilityModel "वर्ग सूची" में। किसी भी तरह से अब आपको तलाश करनी चाहिए
"ns3::RandomWalk2dMobilityModel क्लास रेफरेंस" पृष्ठ पर।

यदि आप अब सारांश सूची के बाद, "विस्तृत विवरण" अनुभाग तक नीचे स्क्रॉल करते हैं
क्लास के तरीके और विशेषताएँ (या बस क्लास के अंत में "अधिक..." लिंक पर क्लिक करें
पृष्ठ के शीर्ष पर संक्षिप्त विवरण) आप इसके लिए समग्र दस्तावेज़ देखेंगे
कक्षा। नीचे स्क्रॉल करना जारी रखते हुए, "कॉन्फ़िगर पथ" सूची ढूंढें:
कॉन्फिग पथ

ns3::RandomWalk2dMobilityModel निम्नलिखित पथों के माध्यम से पहुँचा जा सकता है
कॉन्फिग::सेट और कॉन्फिग::कनेक्ट करें:

· "/NodeList/[i]/$ns3::MobilityModel/$ns3::RandomWalk2dMobilityModel"

दस्तावेज़ आपको बताता है कि कैसे पहुँचें RandomWalk2dMobilityModel वस्तु। तुलना करना
उपरोक्त स्ट्रिंग उस स्ट्रिंग के साथ है जिसका उपयोग हमने वास्तव में उदाहरण कोड में किया था:

"/NodeList/7/$ns3::मोबिलिटीमॉडल"

अंतर इस तथ्य के कारण है कि दो गेटऑब्जेक्ट कॉल पाए गए स्ट्रिंग में निहित हैं
दस्तावेज़ीकरण में. सबसे पहले, के लिए $ns3::मोबिलिटीमॉडल के लिए एकत्रीकरण से पूछताछ करेगा
आधार वर्ग. दूसरा निहित है गेटऑब्जेक्ट के लिए कॉल $ns3::RandomWalk2dMobilityModel,
बेस क्लास को ठोस कार्यान्वयन क्लास में डालने के लिए उपयोग किया जाता है। दस्तावेज़ीकरण
आपके लिए ये दोनों ऑपरेशन दिखाता है। इससे पता चलता है कि वास्तविक ट्रेस स्रोत आप ही हैं
खोज आधार वर्ग में पाया जाता है।

ट्रेस स्रोतों की सूची के लिए "विस्तृत विवरण" अनुभाग में और नीचे देखें।
आप पाएंगे
इस प्रकार के लिए कोई ट्रेससोर्स परिभाषित नहीं हैं।

ट्रेसस्रोत परिभाषित in माता - पिता कक्षा `ns3::MobilityModel``

· पाठ्यक्रम परिवर्तन: स्थिति और/या वेग वेक्टर का मान बदल गया।

कॉलबैक हस्ताक्षर: एनएस3 :: मोबिलिटी मॉडल :: कोर्स चेंज कॉलबैक

यह बिल्कुल वही है जो आपको जानना आवश्यक है। रुचि का ट्रेस स्रोत पाया जाता है
ns3::मोबिलिटीमॉडल (जो आप वैसे भी जानते थे)। एपीआई का यह बिट दिलचस्प बात है
दस्तावेज़ीकरण आपको बताता है कि आपको उपरोक्त कॉन्फ़िगरेशन पथ में उस अतिरिक्त कास्ट की आवश्यकता नहीं है
कंक्रीट क्लास पर जाएं, क्योंकि ट्रेस स्रोत वास्तव में बेस क्लास में है।
इसलिए अतिरिक्त गेटऑब्जेक्ट आवश्यक नहीं है और आप बस पथ का उपयोग करें:

"/NodeList/[i]/$ns3::मोबिलिटीमॉडल"

जो उदाहरण पथ से पूरी तरह मेल खाता है:

"/NodeList/7/$ns3::मोबिलिटीमॉडल"

एक तरफ, कॉन्फिग पथ खोजने का दूसरा तरीका है ग्रेप चारों ओर एनएस- 3 codebase
किसी ऐसे व्यक्ति के लिए जिसने पहले ही इसका पता लगा लिया है। आपको हमेशा किसी और की नकल करने की कोशिश करनी चाहिए
अपना खुद का लिखना शुरू करने से पहले कामकाजी कोड। कुछ इस तरह प्रयास करें:

$ खोजें . -नाम '*.cc' | xargs grep कोर्सचेंज | ग्रेप कनेक्ट

और आपको कामकाजी कोड के साथ अपना उत्तर मिल सकता है। उदाहरण के लिए, इस मामले में,
src/गतिशीलता/उदाहरण/main-random-topology.cc कुछ ऐसा है जो बस आपके उपयोग की प्रतीक्षा कर रहा है:

कॉन्फ़िगरेशन::कनेक्ट ("/NodeList/*/$ns3::मोबिलिटीमॉडल/कोर्सचेंज",
मेककॉलबैक (&कोर्सचेंज));

हम एक क्षण में इस उदाहरण पर लौटेंगे।

कॉलबैक हस्ताक्षर
ठीक है, I पाया a निशान स्रोत और la कॉन्फिग पथ, कैसे do I आंकड़ा आउट क्या la वापसी टाइप
और औपचारिक तर्क of my वापस कॉल करें समारोह आवश्यकता सेवा मेरे हो सकता है?

कॉलबैक हस्ताक्षर की जांच करना सबसे आसान तरीका है टंकण, जो में दिया गया है
कक्षा के लिए "विस्तृत विवरण" में ट्रेस स्रोत का "कॉलबैक हस्ताक्षर"।
ऊपर दिखाए गए।

"कोर्सचेंज" ट्रेस स्रोत प्रविष्टि को दोहराते हुए ns3::RandomWalk2dMobilityModel we
है:

· पाठ्यक्रम परिवर्तन: स्थिति और/या वेग वेक्टर का मान बदल गया।

कॉलबैक हस्ताक्षर: एनएस3 :: मोबिलिटी मॉडल :: कोर्स चेंज कॉलबैक

कॉलबैक हस्ताक्षर प्रासंगिक के लिंक के रूप में दिया गया है टंकण, जहां हम पाते हैं
टंकण शून्य (* कोर्सचेंजकॉलबैक)(const एसटीडी :: स्ट्रिंग संदर्भ, पीटीआर
मोबिलिटीमॉडल> * नमूना);

ट्रैस्डकॉलबैक पाठ्यक्रम परिवर्तन अधिसूचना के लिए हस्ताक्षर।

यदि कॉलबैक का उपयोग करके कनेक्ट किया गया है कनेक्टविथआउटकॉन्टेक्स्ट को छोड़ें प्रसंग से तर्क
द सिगनेचर।

पैरामीटर्स:
[में] संदर्भ ट्रेस स्रोत द्वारा आपूर्ति की गई संदर्भ स्ट्रिंग।
[में] मॉडल मोबिलिटी मॉडल जो पाठ्यक्रम बदल रहा है।

जैसा कि ऊपर बताया गया है, इसे उपयोग में देखने के लिए ग्रेप चारों ओर एनएस- 3 उदाहरण के लिए कोडबेस। उदाहरण
ऊपर, से src/गतिशीलता/उदाहरण/main-random-topology.cc, "कोर्सचेंज" को जोड़ता है
स्रोत का पता लगाएं पाठ्यक्रम परिवर्तन एक ही फ़ाइल में कार्य करें:

स्थिर शून्य
कोर्सचेंज (std::string context, Ptr नमूना)
{
...
}

ध्यान दें कि यह फ़ंक्शन:

· एक "संदर्भ" स्ट्रिंग तर्क लेता है, जिसका वर्णन हम एक मिनट में करेंगे। (यदि कॉलबैक
का उपयोग करके जुड़ा हुआ है कनेक्टविथआउटकॉन्टेक्स्ट कार्य करें प्रसंग तर्क होगा
छोड़ा गया।)

· है गतिशीलता मॉडल अंतिम तर्क के रूप में प्रदान किया गया (या केवल तर्क यदि
कनेक्टविथआउटकॉन्टेक्स्ट प्रयोग किया जाता है)।

· रिटर्न शून्य.

यदि, संयोग से, कॉलबैक हस्ताक्षर का दस्तावेजीकरण नहीं किया गया है, और इसका कोई उदाहरण नहीं है
सही कॉलबैक फ़ंक्शन हस्ताक्षर का निर्धारण करना चुनौतीपूर्ण हो सकता है
वास्तव में स्रोत कोड से पता लगाएं।

कोड का पूर्वाभ्यास शुरू करने से पहले, मैं दयालु होऊंगा और आपको बस एक सरल तरीका बताऊंगा
इसका पता लगाने के लिए: आपके कॉलबैक का रिटर्न मान हमेशा रहेगा शून्य. औपचारिक
ए के लिए पैरामीटर सूची ट्रैस्डकॉलबैक में टेम्पलेट पैरामीटर सूची से पाया जा सकता है
घोषणा। याद रखें कि हमारे वर्तमान उदाहरण के लिए, यह अंदर है गतिशीलता-मॉडल.एच, हम कहाँ
पहले पाया है:

ट्रैस्डकॉलबैक > m_courseChangeTrace;

इसमें टेम्प्लेट पैरामीटर सूची के बीच एक-से-एक पत्राचार होता है
कॉलबैक फ़ंक्शन की घोषणा और औपचारिक तर्क। यहाँ, वहाँ एक है
टेम्प्लेट पैरामीटर, जो एक है पीटीआर मोबिलिटीमॉडल>. यह आपको बताता है कि आपको एक की आवश्यकता है
फ़ंक्शन जो शून्य लौटाता है और a लेता है पीटीआर मोबिलिटीमॉडल>। उदाहरण के लिए:

शून्य
पाठ्यक्रम परिवर्तन (पीटीआर) नमूना)
{
...
}

यदि आप चाहते हैं तो आपको बस यही चाहिए कॉन्फिग::कनेक्टविथआउटकॉन्टेक्स्ट. यदि आप एक संदर्भ चाहते हैं,
आप की जरूरत है कॉन्फिग::कनेक्ट करें और एक कॉलबैक फ़ंक्शन का उपयोग करें जो एक स्ट्रिंग संदर्भ लेता है
टेम्पलेट तर्क:

शून्य
कोर्सचेंज (const std::string context, Ptr नमूना)
{
...
}

यदि आप यह सुनिश्चित करना चाहते हैं कि आपका कोर्सचेंजकॉलबैक फ़ंक्शन केवल आपके में दिखाई देता है
स्थानीय फ़ाइल, आप कीवर्ड जोड़ सकते हैं स्थिर और साथ आओ:

स्थिर शून्य
कोर्सचेंज (स्थिरांक std::स्ट्रिंग पथ, Ptr नमूना)
{
...
}

जो बिल्कुल वैसा ही है जैसा हमने इसमें उपयोग किया था तृतीय.सीसी उदाहरण।

कार्यान्वयन
यह अनुभाग पूर्णतः वैकल्पिक है. यह एक ऊबड़-खाबड़ सवारी होने वाली है, खासकर उनके लिए
टेम्प्लेट के विवरण से अपरिचित. हालाँकि, यदि आप इससे पार पा लेते हैं, तो आपके पास होगा
बहुत सारे पर बहुत अच्छा नियंत्रण एनएस- 3 निम्न स्तर के मुहावरे.

तो, फिर से, आइए जानें कि कॉलबैक फ़ंक्शन के किस हस्ताक्षर की आवश्यकता है
"कोर्सचेंज" ट्रेस स्रोत। यह दर्दनाक होने वाला है, लेकिन आपको केवल ऐसा करने की आवश्यकता है
एक बार। इसे पूरा करने के बाद, आप बस एक को देख पाएंगे ट्रैस्डकॉलबैक और
इसे समझिए।

पहली चीज़ जिस पर हमें ध्यान देने की ज़रूरत है वह है ट्रेस स्रोत की घोषणा। याद करें कि
यह अंदर है गतिशीलता-मॉडल.एच, जहां हमने पहले पाया है:

ट्रैस्डकॉलबैक > m_courseChangeTrace;

यह घोषणा एक टेम्पलेट के लिए है. टेम्प्लेट पैरामीटर कोण-कोष्ठक के अंदर है,
इसलिए हम वास्तव में यह जानने में रुचि रखते हैं कि वह क्या है ट्रैस्डकॉलबैक<> है। यदि आपके पास है
बिल्कुल पता नहीं यह कहाँ पाया जा सकता है, ग्रेप आपका दोस्त है।

संभवत: हमें किसी प्रकार की घोषणा में रुचि होगी एनएस- 3 स्रोत, तो
सबसे पहले में बदलें " निर्देशिका। फिर, हम जानते हैं कि यह घोषणा करनी होगी
किसी प्रकार की हेडर फ़ाइल में हो, तो बस ग्रेप इसका उपयोग करने के लिए:

$ खोजें . -नाम '*.h' | xargs grep ट्रेस्डकॉलबैक

आप 303 लाइनें उड़ते हुए देखेंगे (मैंने इसे पाइप से पार किया है wc यह देखने के लिए कि यह कितना बुरा था)। हालांकि
यह बहुत अधिक लग सकता है, वास्तव में यह बहुत अधिक नहीं है। बस आउटपुट को पाइप करें अधिक और
इसके माध्यम से स्कैन करना शुरू करें. पहले पन्ने पर आपको कुछ बेहद संदेहास्पद नजर आएंगे
टेम्पलेट-दिखने वाला सामान।

TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::TracedCallback ()
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::ConnectWithoutContext (c ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Connect (const CallbackB ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::DisconnectWithoutContext ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::Disconnect (const Callba ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (void) const ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1) const ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::operator() (T1 a1, T2 a2 ...

यह पता चला है कि यह सब हेडर फ़ाइल से आता है ट्रेस-कॉलबैक.एच जो लगता है
बहुत आशाजनक। फिर आप देख सकते हैं गतिशीलता-मॉडल.एच और देखिये कि वहां एक लाइन है
जो इस अनुमान की पुष्टि करता है:

#शामिल है "ns3/traced-callback.h"

बेशक, आप इसे दूसरी दिशा से देख सकते थे और देखना शुरू कर सकते थे
में शामिल है गतिशीलता-मॉडल.एच और इसमें शामिल होने पर ध्यान देना ट्रेस-कॉलबैक.एच और
यह अनुमान लगाते हुए कि यह वही फ़ाइल होनी चाहिए जो आप चाहते हैं।

किसी भी स्थिति में, अगला कदम इस पर गौर करना है src/core/model/traced-callback.h in
क्या हो रहा है यह देखने के लिए आपका पसंदीदा संपादक।

आपको फ़ाइल के शीर्ष पर एक टिप्पणी दिखाई देगी जो आरामदायक होनी चाहिए:
एक ns3::TracedCallback में लगभग सामान्य ns3::Callback जैसा ही API होता है लेकिन
किसी एकल फ़ंक्शन पर कॉल अग्रेषित करने के बजाय (जैसा कि ns3::कॉलबैक सामान्य रूप से करता है),
यह कॉल को ns3::Callback की श्रृंखला में अग्रेषित करता है।

यह बहुत परिचित लगना चाहिए और आपको बताना चाहिए कि आप सही रास्ते पर हैं।

बस इस टिप्पणी के बाद, आप पाएंगे

खाका
टाइपनेम T3 = खाली, टाइपनेम T4 = खाली,
टाइपनेम T5 = खाली, टाइपनेम T6 = खाली,
टाइपनाम T7 = खाली, टाइपनाम T8 = खाली>
क्लास ट्रैस्डकॉलबैक
{
...

यह आपको बताता है कि ट्रेस्डकॉलबैक एक टेम्प्लेटेड क्लास है। इसके आठ संभावित प्रकार हैं
डिफ़ॉल्ट मान वाले पैरामीटर. वापस जाएं और इसकी तुलना अपनी घोषणा से करें
समझने की कोशिश करो:

ट्रैस्डकॉलबैक > m_courseChangeTrace;

RSI नाम लिखो T1 टेम्पलेटेड वर्ग घोषणा में से मेल खाता है पीटीआर
मोबिलिटीमॉडल> उपरोक्त घोषणा में. अन्य सभी प्रकार के मापदंडों को वैसे ही छोड़ दिया गया है
चूक कंस्ट्रक्टर को देखना वास्तव में आपको बहुत कुछ नहीं बताता है। एक जगह जहां
आपने देखा है कि आपके कॉलबैक फ़ंक्शन और ट्रेसिंग सिस्टम के बीच एक कनेक्शन बना हुआ है
में जुड़ें और कनेक्टविथआउटकॉन्टेक्स्ट कार्य. यदि आप नीचे स्क्रॉल करेंगे तो आपको एक दिखाई देगा
कनेक्टविथआउटकॉन्टेक्स्ट विधि यहाँ:

खाका
नाम टाइप करें T3, टाइपनाम T4,
नाम टाइप करें T5, टाइपनाम T6,
टाइपनाम T7, टाइपनाम T8>
शून्य
TracedCallback<T1,T2,T3,T4,T5,T6,T7,T8>::ConnectWithoutContext ...
{
Callback<void,T1,T2,T3,T4,T5,T6,T7,T8> cb;
सीबी.असाइन (कॉलबैक);
m_callbackList.push_back (सीबी);
}

अब आप जानवर के पेट में हैं। जब टेम्प्लेट को इंस्टेंट किया जाता है
उपरोक्त घोषणा, संकलक प्रतिस्थापित कर देगा T1 साथ में पीटीआर मोबिलिटीमॉडल>.

शून्य
ट्रैस्डकॉलबैक ::ConnectWithoutContext... सीबी
{
वापस बुलाओ > सीबी;
सीबी.असाइन (कॉलबैक);
m_callbackList.push_back (सीबी);
}

अब आप उन सभी बातों का कार्यान्वयन देख सकते हैं जिनके बारे में हम बात कर रहे हैं। कोड
सही प्रकार का कॉलबैक बनाता है और उसमें आपका फ़ंक्शन निर्दिष्ट करता है। यह है
के समकक्ष पीएफआई = मेरा कार्य हमने इस अनुभाग की शुरुआत में चर्चा की। कोड
फिर इस स्रोत के लिए कॉलबैक की सूची में कॉलबैक जोड़ता है। केवल एक चीज बची है
कॉलबैक की परिभाषा को देखने के लिए। उसी का उपयोग कर रहे हैं ग्रेप ट्रिक जैसा कि हम ढूंढते थे
ट्रैस्डकॉलबैक, आप उस फ़ाइल को ढूंढने में सक्षम होंगे ./core/callback.h वही हम हैं
देखने की जरूरत है.

यदि आप फ़ाइल को नीचे देखेंगे, तो आपको संभवतः लगभग समझ से बाहर बहुत कुछ दिखाई देगा
टेम्पलेट कोड. आप अंततः कॉलबैक के लिए कुछ एपीआई दस्तावेज़ीकरण तक पहुंचेंगे
हालाँकि, टेम्पलेट क्लास। सौभाग्य से, वहाँ कुछ अंग्रेजी है:
कॉलबैक टेम्पलेट वर्ग.

यह क्लास टेम्पलेट फ़ंक्टर डिज़ाइन पैटर्न लागू करता है। इसका उपयोग घोषित करने के लिए किया जाता है
ए का प्रकार कॉलबैक:

· पहला गैर-वैकल्पिक टेम्पलेट तर्क कॉलबैक के रिटर्न प्रकार का प्रतिनिधित्व करता है।

· शेष (वैकल्पिक) टेम्पलेट तर्क बाद के प्रकार का प्रतिनिधित्व करते हैं
कॉलबैक के लिए तर्क।

· अधिकतम नौ तर्क समर्थित हैं।

हम यह पता लगाने की कोशिश कर रहे हैं कि क्या है

वापस बुलाओ > सीबी;

घोषणा का मतलब है. अब हम यह समझने की स्थिति में हैं कि पहला (गैर-वैकल्पिक)
टेम्पलेट तर्क, शून्य, कॉलबैक के रिटर्न प्रकार का प्रतिनिधित्व करता है। दूसरा
(वैकल्पिक) टेम्पलेट तर्क, पीटीआर मोबिलिटीमॉडल> पहले के प्रकार का प्रतिनिधित्व करता है
कॉलबैक के लिए तर्क.

विचाराधीन कॉलबैक ट्रेस ईवेंट प्राप्त करने का आपका कार्य है। इससे आप कर सकते हैं
अनुमान लगाएं कि आपको एक ऐसे फ़ंक्शन की आवश्यकता है जो वापस आए शून्य और एक लेता है पीटीआर मोबिलिटीमॉडल>.
उदाहरण के लिए,

शून्य
कोर्सचेंजकॉलबैक (Ptr नमूना)
{
...
}

यदि आप चाहते हैं तो आपको बस यही चाहिए कॉन्फिग::कनेक्टविथआउटकॉन्टेक्स्ट. यदि आप एक संदर्भ चाहते हैं,
आप की जरूरत है कॉन्फिग::कनेक्ट करें और एक कॉलबैक फ़ंक्शन का उपयोग करें जो एक स्ट्रिंग संदर्भ लेता है। यह
है क्योंकि जुड़ें फ़ंक्शन आपके लिए संदर्भ प्रदान करेगा. तुम्हें लगेगा:

शून्य
कोर्सचेंजकॉलबैक (std::string context, Ptr नमूना)
{
...
}

यदि आप यह सुनिश्चित करना चाहते हैं कि आपका कोर्सचेंजकॉलबैक केवल आपकी स्थानीय फ़ाइल में दिखाई देता है,
आप कीवर्ड जोड़ सकते हैं स्थिर और साथ आओ:

स्थिर शून्य
कोर्सचेंजकॉलबैक (std::string पथ, Ptr नमूना)
{
...
}

जो बिल्कुल वैसा ही है जैसा हमने इसमें उपयोग किया था तृतीय.सीसी उदाहरण। शायद आपको अब वापस जाना चाहिए और
पिछले अनुभाग को दोबारा पढ़ें (इसके लिए मेरा शब्द लें)।

यदि आप कॉलबैक के कार्यान्वयन के संबंध में अधिक विवरण में रुचि रखते हैं, तो बेझिझक
पर एक नजर डालने के लिए एनएस- 3 नियमावली। वे सबसे अधिक उपयोग किए जाने वाले निर्माणों में से एक हैं
के निम्न-स्तरीय भाग एनएस- 3. मेरी राय में, यह एक बहुत सुंदर चीज़ है।

ट्रेस्डवैल्यूज़
इससे पहले इस खंड में, हमने कोड का एक सरल टुकड़ा प्रस्तुत किया था जिसमें एक का उपयोग किया गया था
ट्रेस्डवैल्यू ट्रेसिंग कोड की मूल बातें प्रदर्शित करने के लिए। हमने बस नज़रअंदाज़ कर दिया
ट्रैस्डवैल्यू वास्तव में क्या है और इसके लिए रिटर्न प्रकार और औपचारिक तर्क कैसे खोजें
कॉलबैक.

जैसा कि हमने बताया, फ़ाइल, ट्रेस-वैल्यू.एच ट्रेसिंग के लिए आवश्यक घोषणाएँ लाता है
डेटा का जो मूल्य शब्दार्थ का पालन करता है। सामान्य तौर पर, मूल्य शब्दार्थ का मतलब सिर्फ इतना है कि आप कर सकते हैं
ऑब्जेक्ट का पता पास करने के बजाय, ऑब्जेक्ट को स्वयं पास करें। हम विस्तार करते हैं
इसमें असाइनमेंट-शैली ऑपरेटरों के पूरे सेट को शामिल करने की आवश्यकता है
सादे-पुराने-डेटा (पीओडी) प्रकारों के लिए पूर्व-परिभाषित:

┌─────────────────────────────────┬──── ────────┐
│ऑपरेटर= (असाइनमेंट) │ │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर*= │ ऑपरेटर/= │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर+= │ ऑपरेटर-= │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर++ (दोनों उपसर्ग और │ │
│पोस्टफिक्स) │ │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर-- (दोनों उपसर्ग और │ │
│पोस्टफिक्स) │ │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर<<= │ ऑपरेटर>>= │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर&= │ ऑपरेटर|= │
├─────────────────────────────────┼──── ────────┤
│ऑपरेटर%= │ ऑपरेटर^= │
└─────────────────────────────────┴──── ────────┘

इन सबका वास्तव में मतलब यह है कि आप उनका उपयोग करके किए गए सभी परिवर्तनों का पता लगाने में सक्षम होंगे
C++ ऑब्जेक्ट के लिए ऑपरेटर, जिसमें वैल्यू सेमेन्टिक्स है।

RSI ट्रेस्डवैल्यू<> घोषणा जो हमने ऊपर देखी वह बुनियादी ढाँचा प्रदान करती है जो ओवरलोड करती है
ऊपर उल्लिखित ऑपरेटर कॉलबैक प्रक्रिया को संचालित करते हैं। किसी भी ऑपरेटर के उपयोग पर
ऊपर ए के साथ ट्रेस्डवैल्यू यह उस वेरिएबल के पुराने और नए दोनों मान प्रदान करेगा,
इस मामले में ए int32_t कीमत। का निरीक्षण करके ट्रेस्डवैल्यू घोषणा, हम जानते हैं
ट्रेस सिंक फ़ंक्शन में तर्क होंगे (स्थल int32_t पुराना मूल्य, const int32_t नया मूल्य).
ए के लिए रिटर्न प्रकार ट्रेस्डवैल्यू कॉलबैक फ़ंक्शन हमेशा होता है शून्य, तो अपेक्षित
कॉलबैक हस्ताक्षर होगा:

शून्य (* ट्रेस्डवैल्यूकॉलबैक)(स्थिरांक int32_t पुरानावैल्यू, स्थिरांक int32_t नयावैल्यू);

RSI .ट्रेससोर्स जोड़ें में GetTypeId विधि कनेक्ट करने के लिए उपयोग किए जाने वाले "हुक" प्रदान करती है
कॉन्फ़िग सिस्टम के माध्यम से बाहरी दुनिया में स्रोत का पता लगाएं। हम पहले ही चर्चा कर चुके हैं
पहले तीन समझौते ट्रेसस्रोत जोड़ें: कॉन्फिग सिस्टम के लिए विशेषता नाम, एक सहायता
स्ट्रिंग, और ट्रैस्डवैल्यू क्लास डेटा सदस्य का पता।

उदाहरण में अंतिम स्ट्रिंग तर्क, "ns3::Traced::Value::Int32", एक का नाम है
टंकण कॉलबैक फ़ंक्शन हस्ताक्षर के लिए। हमें इन हस्ताक्षरों को परिभाषित करने की आवश्यकता है,
और पूर्णतः योग्य प्रकार का नाम दें ट्रेसस्रोत जोड़ें, तो एपीआई दस्तावेज़ीकरण कर सकते हैं
किसी ट्रेस स्रोत को फ़ंक्शन हस्ताक्षर से लिंक करें। ट्रेस्डवैल्यू के लिए हस्ताक्षर है
सीधा; ट्रैस्डकॉलबैक के लिए हम पहले ही देख चुके हैं कि एपीआई दस्तावेज़ वास्तव में मदद करते हैं।

वास्तविक उदाहरण
आइए टीसीपी पर सबसे प्रसिद्ध पुस्तकों में से एक से लिया गया एक उदाहरण लें। "टीसीपी/आईपी
इलस्ट्रेटेड, खंड 1: द प्रोटोकॉल्स, डब्ल्यू रिचर्ड स्टीवंस द्वारा लिखित एक क्लासिक है। मैंने अभी-अभी पलटा
किताब खुली और कंजेशन विंडो और अनुक्रम दोनों का एक अच्छा कथानक सामने आया
पृष्ठ 366 पर संख्या बनाम समय। स्टीवंस इसे कहते हैं, "चित्र 21.10। cwnd का मान और
जब डेटा प्रसारित हो रहा हो तो अनुक्रम संख्या भेजें।" आइए बस cwnd भाग को फिर से बनाएं
उस कथानक में एनएस- 3 ट्रेसिंग सिस्टम का उपयोग करना और ग्नूप्लोट.

उपलब्ध सूत्रों का कहना है
सोचने वाली पहली बात यह है कि हम डेटा कैसे निकालना चाहते हैं। ऐसा क्या है हम
पता लगाने की आवश्यकता है? तो आइए यह देखने के लिए कि हमें क्या काम करना है, "सभी ट्रेस स्रोत" सूची देखें
साथ। याद रखें कि यह इसमें पाया जाता है एनएस- 3 एपीआई दस्तावेज़ीकरण। यदि आप स्क्रॉल करते हैं
सूची, आप अंततः पाएंगे:
ns3::TcpNewReno

· कंजेशनविंडो: टीसीपी कनेक्शन की कंजेशन विंडो

· स्लोस्टार्टथ्रेसहोल्ड: टीसीपी धीमी शुरुआत सीमा (बाइट्स)

यह पता चला है कि एनएस- 3 टीसीपी कार्यान्वयन फ़ाइल में (अधिकतर) रहता है
src/internet/model/tcp-socket-base.cc जबकि कंजेशन कंट्रोल वेरिएंट ऐसी फाइलों में हैं
as src/internet/model/tcp-newreno.cc. अगर आप ये नहीं जानते a प्राथमिकताओं, आप का उपयोग कर सकते हैं
पुनरावर्ती ग्रेप छल:

$ खोजें . -नाम '*.cc' | xargs grep -i tcp

आपको उस फ़ाइल की ओर इशारा करते हुए टीसीपी के उदाहरणों के पृष्ठ दर पृष्ठ मिलेंगे।

के लिए कक्षा दस्तावेज़ीकरण लाना टीसीपीन्यूरेनो और की सूची पर जा रहा हूँ
ट्रेसस्रोत आपको मिलेंगे
ट्रेसस्रोत

· कंजेशनविंडो: टीसीपी कनेक्शन की कंजेशन विंडो

कॉलबैक हस्ताक्षर: ns3::ट्रेस्ड::वैल्यू::Uint322Callback

कॉलबैक पर क्लिक करना टंकण लिंक पर हम वह हस्ताक्षर देखते हैं जिसकी अब आप अपेक्षा करना जानते हैं:

typedef शून्य (* ns3 :: पता लगाया :: मान :: Int32Callback) (स्थिरांक int32_t पुराना मूल्य, स्थिरांक int32_t नया मूल्य)

अब आपको यह कोड पूरी तरह समझ में आ जाना चाहिए. यदि हमारे पास कोई सूचक है टीसीपीन्यूरेनो,
हम कर सकते हैं ट्रेसकनेक्ट यदि हम उपयुक्त प्रदान करते हैं तो "कंजेशनविंडो" ट्रेस स्रोत पर
कॉलबैक लक्ष्य. यह उसी प्रकार का ट्रेस स्रोत है जिसे हमने सरल उदाहरण में देखा था
इस खंड की शुरुआत में, सिवाय इसके कि हम बात कर रहे हैं uint32_t के बजाय
int32_t. और हम जानते हैं कि हमें उस हस्ताक्षर के साथ एक कॉलबैक फ़ंक्शन प्रदान करना होगा।

खोज उदाहरण
इसके बजाय, ऐसे कामकाजी कोड को खोजने का प्रयास करना हमेशा सर्वोत्तम होता है जिसे आप संशोधित कर सकें
खरोंच से शुरू करने की तुलना में. तो अब व्यवसाय का पहला क्रम कुछ कोड ढूंढना है
पहले से ही "कंजेशनविंडो" ट्रेस स्रोत को हुक करता है और देखता है कि क्या हम इसे संशोधित कर सकते हैं। हमेशा की तरह,
ग्रेप आपका दोस्त है:

$ खोजें . -नाम '*.cc' | xargs ग्रेप कंजेशनविंडो

यह कुछ होनहार उम्मीदवारों को इंगित करेगा: उदाहरण/tcp/tcp-large-transfer.cc
और src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc.

हमने अभी तक किसी भी परीक्षण कोड का दौरा नहीं किया है, तो आइए वहां एक नज़र डालें। आप करेंगे
आम तौर पर पाया जाता है कि परीक्षण कोड काफी न्यूनतम है, इसलिए यह संभवतः एक बहुत अच्छा दांव है।
प्रारंभिक src/test/ns3tcp/ns3tcp-cwnd-test-suite.cc अपने पसंदीदा संपादक में खोजें और खोजें
"कंजेशनविंडो"। आप पाएंगे,

ns3TcpSocket->TraceConnectWithoutContext ("कंजेशनविंडो",
मेककॉलबैक (&Ns3TcpCwndTestCase1::CwndChange, यह));

यह आपको बहुत परिचित लगना चाहिए. हमने ऊपर उल्लेख किया है कि यदि हमारे पास कोई सूचक होता
टीसीपीन्यूरेनो, हम ट्रेसकनेक्ट "कंजेशनविंडो" ट्रेस स्रोत के लिए। बिलकुल यही है
हमारे यहाँ क्या है; तो यह पता चला कि कोड की यह पंक्ति बिल्कुल वही करती है जो हम चाहते हैं।
आइए आगे बढ़ें और इस फ़ंक्शन से वह कोड निकालें जिसकी हमें आवश्यकता है (Ns3TcpCwndTestCase1::DoRun
(शून्य)). यदि आप इस फ़ंक्शन को देखेंगे, तो आप पाएंगे कि यह बिल्कुल एक जैसा दिखता है एनएस- 3
लिखी हुई कहानी। यह पता चला कि यह बिल्कुल वैसा ही है। यह परीक्षण द्वारा संचालित एक स्क्रिप्ट है
ढांचा, इसलिए हम इसे बाहर खींच सकते हैं और इसमें लपेट सकते हैं मुख्य के बजाय में भागो. की अपेक्षा
इसके बाद, चरण दर चरण, हमने वह फ़ाइल प्रदान की है जो पोर्टिंग से उत्पन्न होती है
यह परीक्षण मूल निवासी के पास वापस जाता है एनएस- 3 लिखी हुई कहानी -- उदाहरण/ट्यूटोरियल/पांचवां.सीसी.

गतिशील निशान सूत्रों का कहना है
RSI पांचवां.सीसी उदाहरण एक अत्यंत महत्वपूर्ण नियम को दर्शाता है जिसे आपको अवश्य समझना चाहिए
किसी भी प्रकार के ट्रेस स्रोत का उपयोग करने से पहले: आपको यह सुनिश्चित करना होगा कि a
कॉन्फिग::कनेक्ट करें इसका उपयोग करने का प्रयास करने से पहले कमांड मौजूद है। यह कहने से अलग नहीं है
किसी ऑब्जेक्ट को कॉल करने का प्रयास करने से पहले उसे तुरंत चालू करना होगा। हालाँकि यह स्पष्ट प्रतीत हो सकता है
जब इस तरह कहा जाता है, तो यह पहली बार सिस्टम का उपयोग करने का प्रयास करने वाले कई लोगों को परेशान करता है
समय है.

आइए एक पल के लिए बुनियादी बातों पर वापस आएं। इसमें तीन बुनियादी निष्पादन चरण मौजूद हैं
कोई एनएस- 3 लिखी हुई कहानी। पहले चरण को कभी-कभी "कॉन्फ़िगरेशन समय" या "सेटअप" कहा जाता है
समय," और उस अवधि के दौरान मौजूद है जब मुख्य आपकी स्क्रिप्ट का फ़ंक्शन चल रहा है, लेकिन
से पहले सिम्युलेटर::चलाएँ कहा जाता है। दूसरे चरण को कभी-कभी "सिमुलेशन टाइम" कहा जाता है
और उस समय अवधि के दौरान मौजूद रहता है जब सिम्युलेटर::चलाएँ सक्रिय रूप से अपनी घटनाओं को अंजाम दे रहा है।
सिमुलेशन निष्पादित करने के बाद, सिम्युलेटर::चलाएँ नियंत्रण वापस लौटा देंगे
la मुख्य समारोह। जब ऐसा होता है, तो स्क्रिप्ट में प्रवेश होता है जिसे "टियरडाउन" कहा जा सकता है
चरण," जो तब होता है जब सेटअप के दौरान बनाई गई संरचनाओं और वस्तुओं को अलग कर दिया जाता है
का विमोचन किया।

शायद ट्रेसिंग सिस्टम का उपयोग करने की कोशिश में की जाने वाली सबसे आम गलती यह मान लेना है
संस्थाओं का निर्माण गतिशील रूप से किया गया है दौरान अनुकार पहर कॉन्फ़िगरेशन के दौरान उपलब्ध हैं
समय। विशेष रूप से, ए एनएस- 3 गर्तिका एक गतिशील वस्तु है जिसे अक्सर बनाया जाता है अनुप्रयोगों सेवा मेरे
के बीच संवाद नोड्स. एक एनएस- 3 आवेदन हमेशा एक "प्रारंभ समय" और एक "स्टॉप" होता है
समय" इसके साथ जुड़ा हुआ है। अधिकांश मामलों में, ए आवेदन प्रयास नहीं करेंगे
एक गतिशील वस्तु बनाने के लिए जब तक कि यह न हो जाए आवेदन प्रारंभ करें विधि को कुछ "प्रारंभ" पर कहा जाता है
समय"। यह सुनिश्चित करना है कि ऐप से पहले सिमुलेशन पूरी तरह से कॉन्फ़िगर किया गया है
कुछ भी करने का प्रयास करता है (क्या होगा यदि यह किसी ऐसे नोड से जुड़ने का प्रयास करे जो अस्तित्व में ही नहीं है
अभी तक कॉन्फ़िगरेशन समय के दौरान?) परिणामस्वरूप, कॉन्फ़िगरेशन चरण के दौरान आप ऐसा नहीं कर सकते
यदि उनमें से एक को गतिशील रूप से बनाया गया है तो ट्रेस स्रोत को ट्रेस सिंक से कनेक्ट करें
सिमुलेशन।

इस पहेली के दो समाधान हैं

1. एक सिम्युलेटर इवेंट बनाएं जो डायनेमिक ऑब्जेक्ट बनने और हुक करने के बाद चलाया जाता है
पता लगाएं कि वह घटना कब निष्पादित होती है; या

2. कॉन्फ़िगरेशन समय पर डायनामिक ऑब्जेक्ट बनाएं, फिर उसे हुक करें और ऑब्जेक्ट दें
सिमुलेशन समय के दौरान उपयोग की जाने वाली प्रणाली।

हमने दूसरा तरीका अपनाया पांचवां.सीसी उदाहरण। इस निर्णय के लिए हमें निर्माण करना पड़ा
la MyApp आवेदन, जिसका पूरा उद्देश्य एक लेना है गर्तिका एक पैरामीटर के रूप में.

पूर्वाभ्यास: पांचवां.सीसी
अब, आइए उस उदाहरण कार्यक्रम पर एक नज़र डालें जो हमने भीड़भाड़ को विच्छेदित करके बनाया था
विंडो परीक्षण. खुला उदाहरण/ट्यूटोरियल/पांचवां.सीसी अपने पसंदीदा संपादक में. तुम्हें देखना चाहिए
कुछ परिचित दिखने वाला कोड:

/* -*- मोड:C++; सी-फ़ाइल-शैली:"gnu"; इंडेंट-टैब-मोड:शून्य; -*- */
/*
* यह प्रोग्राम निःशुल्क सॉफ्टवेयर है; आप इसे पुनर्वितरित और/या संशोधित कर सकते हैं
* यह जीएनयू जनरल पब्लिक लाइसेंस संस्करण 2 की शर्तों के तहत है
* फ्री सॉफ्टवेयर फाउंडेशन द्वारा प्रकाशित;
*
*यह कार्यक्रम इस आशा से वितरित किया गया है कि यह उपयोगी होगा,
*लेकिन बिना किसी वारंटी के; की निहित वारंटी के बिना भी
* किसी विशेष उद्देश्य के लिए अनुरूपता या फिटनेस। देखें
* अधिक जानकारी के लिए जीएनयू जनरल पब्लिक लाइसेंस।
*
* आपको जीएनयू जनरल पब्लिक लाइसेंस की एक प्रति प्राप्त होनी चाहिए
*इस कार्यक्रम के साथ-साथ; यदि नहीं, तो फ्री सॉफ्टवेयर को लिखें
* फाउंडेशन, शामिल, 59 टेम्पल प्लेस, सुइट 330, बोस्टन, एमए 02111-1307 यूएसए
*/

#शामिल करना
#शामिल "ns3/core-module.h"
#शामिल है "ns3/network-module.h"
#शामिल "ns3/इंटरनेट-मॉड्यूल.एच"
#शामिल है "ns3/point-to-point-module.h"
#शामिल "ns3/applications-module.h"

नेमस्पेस ns3 का उपयोग करना;

NS_LOG_COMPONENT_DEFINE ("फिफ्थस्क्रिप्ट उदाहरण");

यह सब कवर कर लिया गया है, इसलिए हम इसे दोबारा नहीं दोहराएंगे। स्रोत की अगली पंक्तियाँ हैं
नेटवर्क चित्रण और ऊपर वर्णित समस्या को संबोधित करने वाली एक टिप्पणी गर्तिका.

// ============================================== ==========================
//
// नोड 0 नोड 1
// +--+ +--+
// | एनएस-3 टीसीपी | | एनएस-3 टीसीपी |
// +--+ +--+
// | 10.1.1.1 | | 10.1.1.2 |
// +--+ +--+
// | बिंदु-दर-बिंदु | | बिंदु-दर-बिंदु |
// +--+ +--+
// | |
// +----------------------+
// 5 एमबीपीएस, 2 एमएस
//
//
// हम एनएस-3 टीसीपी कंजेशन विंडो में बदलाव देखना चाहते हैं। ज़रुरत है
// प्रवाह को क्रैंक करने और सॉकेट पर CongestionWindow विशेषता को हुक करने के लिए
// प्रेषक का. आम तौर पर कोई व्यक्ति जनरेट करने के लिए ऑन-ऑफ एप्लिकेशन का उपयोग करेगा
// प्रवाह, लेकिन इसमें कुछ समस्याएं हैं। सबसे पहले, ऑन-ऑफ का सॉकेट
// एप्लिकेशन प्रारंभ समय तक एप्लिकेशन नहीं बनाया गया है, इसलिए हम नहीं बनाएंगे
// कॉन्फ़िगरेशन समय पर सॉकेट (अब) को हुक करने में सक्षम। दूसरा, भले ही हम
// प्रारंभ समय के बाद कॉल की व्यवस्था कर सकते हैं, सॉकेट सार्वजनिक नहीं है इसलिए हम
// इस तक नहीं पहुंच सका.
//
// तो, हम ऑन-ऑफ एप्लिकेशन का एक सरल संस्करण तैयार कर सकते हैं जो क्या करता है
// हम चाहते हैं। अच्छी बात यह है कि हमें ऑन-ऑफ की सारी जटिलताओं की आवश्यकता नहीं है
// आवेदन पत्र। नकारात्मक पक्ष यह है कि हमारे पास कोई सहायक नहीं है, इसलिए हमें मदद लेनी होगी
// विवरण में थोड़ा और शामिल है, लेकिन यह मामूली है।
//
// तो सबसे पहले, हम एक सॉकेट बनाते हैं और उस पर ट्रेस कनेक्ट करते हैं; फिर हम गुजर जाते हैं
// इस सॉकेट को हमारे सरल एप्लिकेशन के कंस्ट्रक्टर में डालें जिसे हम तब उपयोग करते हैं
// स्रोत नोड में स्थापित करें।
// ============================================== ==========================
//

यह भी स्व-व्याख्यात्मक होना चाहिए।

अगला भाग की घोषणा है MyApp आवेदन जिसे हमने अनुमति देने के लिए एक साथ रखा है
la गर्तिका कॉन्फ़िगरेशन समय पर बनाया जाना है.

क्लास MyApp: सार्वजनिक अनुप्रयोग
{
सार्वजनिक:

मायऐप ();
आभासी ~MyApp();

शून्य सेटअप (Ptr सॉकेट, पता पता, uint32_t पैकेट आकार,
uint32_t nPackets, डेटारेट डेटारेट);

निजी:
वर्चुअल शून्य स्टार्टएप्लिकेशन (शून्य);
वर्चुअल शून्य स्टॉपएप्लिकेशन (शून्य);

शून्य शेड्यूल टीएक्स (शून्य);
शून्य सेंडपैकेट (शून्य);

पीटीआर m_सॉकेट;
पता m_peer;
uint32_t m_packetSize;
uint32_t m_nPackets;
डेटारेट m_dataRate;
इवेंटआईडी m_sendEvent;
बूल एम_रनिंग;
uint32_t m_packetsSent;
};

आप देख सकते हैं कि यह वर्ग इससे विरासत में मिला है एनएस- 3 आवेदन कक्षा। पर एक नज़र डालें
src/नेटवर्क/मॉडल/application.h यदि आप विरासत में मिली चीज़ में रुचि रखते हैं। MyApp
वर्ग ओवरराइड करने के लिए बाध्य है आवेदन प्रारंभ करें और आवेदन रोकें तरीके. इन
जब विधियां स्वचालित रूप से कॉल की जाती हैं MyApp डेटा भेजना शुरू करने और बंद करने के लिए आवश्यक है
अनुकरण के दौरान.

प्रारंभ/रोकना अनुप्रयोगों
यह समझाने में थोड़ा समय व्यतीत करना सार्थक है कि घटनाएँ वास्तव में कैसे शुरू होती हैं
प्रणाली। यह एक और काफी गहरी व्याख्या है, और यदि आप ऐसा नहीं करते हैं तो इसे अनदेखा किया जा सकता है
सिस्टम की गहराई में उतरने की योजना बना रहा हूं। हालाँकि, यह उसमें उपयोगी है
चर्चा इस बात पर चर्चा करती है कि कैसे कुछ अत्यंत महत्वपूर्ण भाग हैं एनएस- 3 काम करें और कुछ को उजागर करें
महत्वपूर्ण मुहावरे. यदि आप नए मॉडल लागू करने की योजना बना रहे हैं, तो संभवतः आप ऐसा करना चाहेंगे
इस अनुभाग को समझें.

पम्पिंग इवेंट शुरू करने का सबसे आम तरीका है आवेदन. इस प्रकार किया जाता है
निम्नलिखित (उम्मीद है) की परिचित पंक्तियों का परिणाम एनएस- 3 स्क्रिप्ट:

एप्लिकेशनकंटेनर ऐप्स = ...
ऐप्स.प्रारंभ (सेकेंड (1.0));
ऐप्स.स्टॉप (सेकंड्स (10.0));

एप्लिकेशन कंटेनर कोड (देखें src/नेटवर्क/हेल्पर/एप्लिकेशन-कंटेनर.एच अगर आप
रुचि) इसके निहित अनुप्रयोगों और कॉलों के माध्यम से लूप करता है,

ऐप->सेटस्टार्टटाइम (स्टार्टटाइम);

का एक परिणाम के रूप में ऐप्स.प्रारंभ कॉल करें और

ऐप->सेटस्टॉपटाइम (स्टॉपटाइम);

का एक परिणाम के रूप में क्षुधा.बंद करो पु का र ना।

इन कॉलों का अंतिम परिणाम यह है कि हम सिम्युलेटर को स्वचालित रूप से रखना चाहते हैं
हमारे में कॉल करें अनुप्रयोगों उन्हें बताएं कि कब शुरू करना है और कब रुकना है। के मामले में
MyApp, यह वर्ग से विरासत में मिला है आवेदन और ओवरराइड करता है आवेदन प्रारंभ करें, तथा
आवेदन रोकें. ये वे फ़ंक्शन हैं जिन्हें सिम्युलेटर द्वारा कॉल किया जाएगा
उपयुक्त समय। के मामले में MyApp तुम्हें वह मिल जाएगा MyApp :: एप्लिकेशन प्रारंभ करें कर देता है
प्रारंभिक बाँध, तथा जुड़ें सॉकेट पर, और फिर कॉल करके डेटा प्रवाहित करना प्रारंभ करता है
MyApp::SendPacket. MyApp :: एप्लिकेशन रोकें किसी को भी रद्द करके पैकेट बनाना बंद कर देता है
लंबित प्रेषण ईवेंट फिर सॉकेट बंद कर देता है।

के बारे में अच्छी चीज़ों में से एक एनएस- 3 बात यह है कि आप कार्यान्वयन को पूरी तरह से अनदेखा कर सकते हैं
आपका विवरण कैसा है आवेदन सिम्युलेटर द्वारा सही पर "स्वचालित रूप से" कॉल किया जाता है
समय। लेकिन चूंकि हम पहले ही गहराई में उतर चुके हैं एनएस- 3 पहले से ही, चलो इसके लिए चलते हैं।

अगर तुम देखो स्रोत/नेटवर्क/मॉडल/application.cc आप पाएंगे कि सेटस्टार्टटाइम तरीका
एक की आवेदन बस सदस्य चर सेट करता है m_startTime और सेटस्टॉपटाइम तरीका
बस सेट हो जाता है m_stopसमय. वहां से, बिना किसी संकेत के, राह शायद ख़त्म हो जाएगी।

राह को फिर से चुनने की कुंजी यह जानना है कि सभी की एक वैश्विक सूची है
सिस्टम में नोड्स. जब भी आप सिमुलेशन में एक नोड बनाते हैं, तो उस नोड के लिए एक सूचक
वैश्विक में जोड़ा गया है नोडल सूची.

पर एक नज़र रखना स्रोत/नेटवर्क/मॉडल/नोड-list.cc और के लिए खोज NodeList::जोड़ें. सार्वजनिक
स्थैतिक कार्यान्वयन को एक निजी कार्यान्वयन कहा जाता है NodeListPriv::जोड़ें। इस
में एक अपेक्षाकृत सामान्य मुहावरा है एनएस- 3. तो, देखिये NodeListPriv::जोड़ें. ये हुई न बात
पता कर लेंगे,

सिम्युलेटर::ScheduleWithContext (सूचकांक, टाइमस्टेप (0), &नोड::इनिशियलाइज़, नोड);

यह आपको बताता है कि जब भी सिमुलेशन में एक नोड बनाया जाता है, तो साइड-इफ़ेक्ट के रूप में, एक कॉल होता है
उस नोड के लिए हस्ताक्षर करना विधि आपके लिए निर्धारित है जो समय शून्य पर होती है। नहीं
अभी भी उस नाम के बारे में बहुत कुछ पढ़ा गया है। इसका मतलब यह नहीं है कि नोड काम करना शुरू करने जा रहा है
कुछ भी, इसे नोड में एक सूचनात्मक कॉल के रूप में समझा जा सकता है जो यह बताता है कि
सिमुलेशन शुरू हो गया है, नोड को कुछ करना शुरू करने के लिए कहने वाली कार्रवाई के लिए कॉल नहीं।

तो, NodeList::जोड़ें अप्रत्यक्ष रूप से किसी कॉल को शेड्यूल करता है नोड::प्रारंभ करें समय शून्य पर सलाह देने के लिए
नया नोड कि सिमुलेशन शुरू हो गया है। यदि आप अंदर देखें src/network/model/node.h इसलिए आप
हालाँकि, नामक कोई विधि नहीं मिलेगी नोड::प्रारंभ करें. यह पता चला है कि
हस्ताक्षर करना विधि कक्षा से विरासत में मिली है वस्तु. सिस्टम में सभी ऑब्जेक्ट हो सकते हैं
सिमुलेशन शुरू होने पर अधिसूचित किया जाता है, और क्लास नोड की वस्तुएं उनमें से सिर्फ एक प्रकार की होती हैं
वस्तुओं।

पर एक नज़र रखना src/core/model/object.cc अगला और खोजें ऑब्जेक्ट::प्रारंभ करें. यह कोड
यह उतना सीधा नहीं है जितना आपने अपेक्षा की होगी एनएस- 3 वस्तुएँ समर्थन
एकत्रीकरण. में कोड ऑब्जेक्ट::प्रारंभ करें फिर सभी वस्तुओं के माध्यम से लूप करता है
एक साथ एकत्रित किया गया है और उन्हें कॉल करता है प्रारंभ करें तरीका। यह एक और मुहावरा है
यह बहुत आम बात है एनएस- 3, जिसे कभी-कभी "टेम्पलेट डिज़ाइन पैटर्न" भी कहा जाता है: एक सार्वजनिक
गैर-वर्चुअल एपीआई विधि, जो कार्यान्वयन के दौरान स्थिर रहती है, और जो कॉल करती है
निजी आभासी कार्यान्वयन विधि जो विरासत में मिली है और उपवर्गों द्वारा कार्यान्वित की गई है।
नाम आमतौर पर कुछ इस तरह होते हैं विधि का नाम सार्वजनिक एपीआई के लिए और DoMethodName एसटी
निजी एपीआई.

यह हमें बताता है कि हमें इसकी तलाश करनी चाहिए नोड::प्रारंभ करें में विधि
src/network/model/node.cc उस विधि के लिए जो हमारी राह जारी रखेगी। यदि आप इसका पता लगाते हैं
कोड, आपको एक ऐसी विधि मिलेगी जो नोड में सभी उपकरणों के माध्यम से लूप करती है
नोड कॉलिंग में सभी एप्लिकेशन डिवाइस->इनिशियलाइज़ करें और एप्लिकेशन->प्रारंभ करें
क्रमशः.

आप शायद पहले से ही जानते होंगे कि कक्षाएं युक्ति और आवेदन दोनों वर्ग से विरासत में मिले हैं वस्तु
और इसलिए अगला कदम यह देखना होगा कि कब क्या होता है आवेदन::प्रारंभ करें is
बुलाया। पर एक नज़र डालें स्रोत/नेटवर्क/मॉडल/application.cc और आप पाएंगे:

शून्य
आवेदन::प्रारंभिक करें (शून्य)
{
m_startEvent = सिम्युलेटर::शेड्यूल (m_startTime, &Application::StartApplication, यह);
यदि (m_stopTime != टाइमस्टेप (0))
{
m_stopEvent = सिम्युलेटर::शेड्यूल (m_stopTime, &Application::StopApplication, यह);
}
ऑब्जेक्ट::DoInitialize ();
}

यहाँ, हम अंततः पथ के अंत पर आ गए हैं। यदि आपने यह सब सीधा रखा है, जब आप
एक लागू करें एनएस- 3 आवेदन, आपका नया एप्लिकेशन क्लास से इनहेरिट होता है आवेदन. आप
ओवरराइड करें आवेदन प्रारंभ करें और आवेदन रोकें तरीके और तंत्र प्रदान करते हैं
आपके नए से डेटा का प्रवाह शुरू करना और रोकना आवेदन. जब एक नोड होता है
सिमुलेशन में बनाया गया, इसे ग्लोबल में जोड़ा गया है नोडल सूची. एक नोड जोड़ने का कार्य
इसका नोडल सूची समय शून्य के लिए एक सिम्युलेटर इवेंट को शेड्यूल करने का कारण बनता है जो कॉल करता है
नोड::प्रारंभ करें सिमुलेशन शुरू होने पर नए जोड़े गए नोड को कॉल करने की विधि।
चूंकि एक नोड से विरासत में मिला है वस्तु, यह कॉल करता है ऑब्जेक्ट::प्रारंभ करें नोड पर विधि
जो, बदले में, को कॉल करता है प्रारंभ करें सभी पर तरीके वस्तुएँ में एकत्रित किया गया
नोड (गतिशीलता मॉडल के बारे में सोचें)। नोड के बाद से वस्तु ओवरराइड हो गया है प्रारंभ करेंकि,
सिमुलेशन शुरू होने पर विधि को कॉल किया जाता है। नोड::प्रारंभ करें विधि कॉल करती है
हस्ताक्षर करना सभी के तरीके अनुप्रयोगों नोड पर. तब से अनुप्रयोगों भी हैं
वस्तुएँ, इसकी वजह से आवेदन::प्रारंभ करें कहा जा सकता है। कब
आवेदन::प्रारंभ करें कहा जाता है, यह के लिए ईवेंट शेड्यूल करता है आवेदन प्रारंभ करें और
आवेदन रोकें पर कॉल करता है आवेदन. ये कॉल शुरू करने और रोकने के लिए डिज़ाइन की गई हैं
से डेटा का प्रवाह आवेदन

यह एक और काफी लंबी यात्रा रही है, लेकिन इसे केवल एक बार ही पूरा किया जाना है, और आपको अभी
एक और बहुत गहरा अंश समझिए एनएस- 3.

RSI MyApp आवेदन
RSI MyApp आवेदन बेशक, एक कंस्ट्रक्टर और एक डिस्ट्रक्टर की जरूरत है:

MyApp::MyApp ()
: m_सॉकेट (0),
m_peer (),
m_packetआकार (0),
m_nपैकेट (0),
m_dataRate (0),
m_sendEvent (),
m_running (झूठा),
m_packetsSent (0)
{
}

MyApp::~MyApp()
{
एम_सॉकेट = 0;
}

कोड के अगले बिट का अस्तित्व ही वह संपूर्ण कारण है जिसके लिए हमने इसे लिखा आवेदन in
प्रथम स्थान।

शून्य
MyApp::सेटअप (Ptr सॉकेट, पता पता, uint32_t पैकेट आकार,
uint32_t nPackets, डेटारेट डेटारेट)
{
m_सॉकेट = सॉकेट;
m_peer = पता;
m_packetSize = पैकेट आकार;
m_nपैकेट = nपैकेट;
m_dataRate = डेटारेट;
}

यह कोड काफी आत्म-व्याख्यात्मक होना चाहिए। हम केवल सदस्य चर प्रारंभ कर रहे हैं।
ट्रेसिंग के नजरिए से अहम है पीटीआर सॉकेट जो हम
कॉन्फ़िगरेशन समय के दौरान एप्लिकेशन को प्रदान करना आवश्यक है। याद रखें कि हम जा रहे हैं
बनाने के लिए गर्तिका एक के रूप में टीसीपी सॉकेट (जो द्वारा कार्यान्वित किया गया है टीसीपीन्यूरेनो) और इसे हुक करें
इसे पास करने से पहले "कंजेशनविंडो" स्रोत का पता लगाएं व्यवस्था विधि.

शून्य
MyApp::StartApplication (शून्य)
{
m_running = सत्य;
m_packetsSent = 0;
m_socket->बाइंड ();
m_socket->कनेक्ट (m_peer);
सेंडपैकेट ();
}

उपरोक्त कोड ओवरराइड कार्यान्वयन है आवेदन::प्रारंभआवेदन वह होगा
हमारे प्रारंभ करने के लिए सिम्युलेटर द्वारा स्वचालित रूप से कॉल किया जाता है आवेदन उचित पर चल रहा है
समय। आप देख सकते हैं कि यह एक करता है गर्तिका बाँध संचालन। यदि आप परिचित हैं
बर्कले सॉकेट्स यह कोई आश्चर्य की बात नहीं होनी चाहिए। यह स्थानीय स्तर पर आवश्यक कार्य करता है
कनेक्शन का पक्ष बिल्कुल वैसा ही जैसा आप उम्मीद कर सकते हैं। निम्नलिखित जुड़ें जो है वही करेंगे
टीसीपी के साथ कनेक्शन स्थापित करने की आवश्यकता है पता m_peer. यह अब स्पष्ट हो जाना चाहिए
हमें इसमें से अधिकांश को सिमुलेशन समय के लिए स्थगित करने की आवश्यकता क्यों है, क्योंकि जुड़ें की आवश्यकता पड़ने वाली है
पूरा करने के लिए एक पूरी तरह से कार्यशील नेटवर्क। के बाद जुड़ें, आवेदन फिर शुरू होता है
कॉल करके सिमुलेशन इवेंट बनाना पैकेट भेजें.

कोड का अगला भाग इसे समझाता है आवेदन सिमुलेशन ईवेंट बनाना कैसे रोकें।

शून्य
MyApp::StopApplication (शून्य)
{
m_running = गलत;

यदि (m_sendEvent.IsRunning ())
{
सिम्युलेटर::रद्द करें (m_sendEvent);
}

यदि (m_socket)
{
m_socket->बंद करें ();
}
}

हर बार जब कोई सिमुलेशन कार्यक्रम निर्धारित होता है, तो कार्यक्रम बनाया गया है। यदि कार्यक्रम लंबित है
क्रियान्वयन या क्रियान्वित करना, उसकी विधि चल रहा है वापस होगा <strong>उद्देश्य</strong>. इस कोड में, यदि
चल रहा है() सच लौटाता है, हम रद्द करना वह ईवेंट जो इसे सिम्युलेटर ईवेंट से हटा देता है
कतार। ऐसा करने से हम घटनाओं की शृंखला को तोड़ देते हैं आवेदन रखने के लिए उपयोग कर रहा है
इसे भेज रहा हूँ पैकेट और आवेदन शांत हो जाता है. हम शांत होने के बाद आवेदन we
समापन सॉकेट जो टीसीपी कनेक्शन को तोड़ देता है।

सॉकेट वास्तव में डिस्ट्रक्टर में हटा दिया जाता है जब m_सॉकेट = 0 निष्पादित किया जाता है। यह
अंतर्निहित Ptr का अंतिम संदर्भ हटा देता है जो विनाशक का कारण बनता है
वह वस्तु जिसे बुलाया जाना है।

याद करें कि आवेदन प्रारंभ करें बुलाया पैकेट भेजें वर्णन करने वाली घटनाओं की श्रृंखला शुरू करने के लिए
la आवेदन व्यवहार.

शून्य
MyApp::SendPacket (शून्य)
{
पीटीआर पैकेट = बनाएँ (m_packetSize);
m_socket->भेजें (पैकेट);

यदि (++m_packetsSent < m_nPackets)
{
शेड्यूलटीएक्स ();
}
}

यहाँ, आप वह देखें पैकेट भेजें बस यही करता है. यह एक बनाता है पैकेट और फिर एक करता है भेजें
जो, यदि आप बर्कले सॉकेट्स को जानते हैं, तो संभवतः वही है जो आपने देखने की अपेक्षा की थी।

की जिम्मेदारी है आवेदन घटनाओं की श्रृंखला को शेड्यूल करते रहने के लिए, इसलिए
अगली पंक्तियाँ कॉल करें शेड्यूल टीएक्स किसी अन्य प्रेषण ईवेंट को शेड्यूल करने के लिए (a पैकेट भेजें) जब तक
आवेदन यह तय करता है कि उसने काफी कुछ भेजा है।

शून्य
MyApp::ScheduleTx (शून्य)
{
यदि (m_running)
{
समय tNext (सेकंड (m_packetSize * 8 / static_cast (m_dataRate.GetBitRate ())));
m_sendEvent = सिम्युलेटर::शेड्यूल (tNext, &MyApp::SendPacket, this);
}
}

यहाँ, आप वह देखें शेड्यूल टीएक्स बिलकुल वैसा ही करता है. यदि आवेदन चल रहा है (यदि
आवेदन रोकें नहीं बुलाया गया है) यह एक नया ईवेंट शेड्यूल करेगा, जो कॉल करता है पैकेट भेजें
दोबारा। सतर्क पाठक कुछ ऐसा देखेगा जो नए उपयोगकर्ताओं को भी आकर्षित करता है। डेटा दर
एक की आवेदन बस इतना ही है. इसका किसी अंतर्निहित डेटा दर से कोई लेना-देना नहीं है
चैनल. यह वह दर है जिस पर आवेदन बिट्स पैदा करता है. यह अंदर नहीं लेता
परिवहन के लिए उपयोग किए जाने वाले विभिन्न प्रोटोकॉल या चैनलों के लिए किसी भी ओवरहेड का हिसाब रखें
डेटा। यदि आप किसी की डेटा दर निर्धारित करते हैं आवेदन आपके अंतर्निहित डेटा दर के समान
चैनल आपको अंततः एक बफ़र ओवरफ़्लो मिलेगा।

निशान डूब
इस अभ्यास का संपूर्ण उद्देश्य टीसीपी से संकेतित ट्रेस कॉलबैक प्राप्त करना है
कंजेशन विंडो को अपडेट कर दिया गया है. कोड का अगला भाग संबंधित को लागू करता है
ट्रेस सिंक:

स्थिर शून्य
CwndChange (uint32_t पुरानाCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (सिम्युलेटर::अभी ().GetSeconds () << "\t" << newCwnd);
}

यह अब आपको भली-भांति परिचित हो जाना चाहिए, इसलिए हम विवरणों पर ध्यान नहीं देंगे। यह फ़ंक्शन
बस वर्तमान सिमुलेशन समय और कंजेशन विंडो के हर नए मान को लॉग करता है
समय बदल गया है. आप शायद कल्पना कर सकते हैं कि आप परिणामी आउटपुट को लोड कर सकते हैं
एक ग्राफ़िक्स प्रोग्राम (gnuplot या Excel) में और तुरंत इसका एक अच्छा ग्राफ़ देखें
समय के साथ कंजेशन विंडो व्यवहार।

हमने यह दिखाने के लिए एक नया ट्रेस सिंक जोड़ा कि पैकेट कहाँ गिराए गए हैं। हम एक त्रुटि जोड़ने जा रहे हैं
इस कोड को भी मॉडल करें, इसलिए हम इस कार्यप्रणाली को प्रदर्शित करना चाहते थे।

स्थिर शून्य
आरएक्सड्रॉप (पीटीआर) पी)
{
NS_LOG_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
}

यह ट्रेस सिंक पॉइंट-टू-पॉइंट के "PhyRxDrop" ट्रेस स्रोत से जुड़ा होगा
नेटडिवाइस। यह ट्रेस स्रोत तब सक्रिय होता है जब किसी पैकेट को भौतिक परत द्वारा गिराया जाता है
नेटडिवाइस. यदि आप स्रोत की ओर एक छोटा सा चक्कर लगाते हैं
(src/पॉइंट-टू-पॉइंट/मॉडल/पॉइंट-टू-पॉइंट-नेट-डिवाइस.सीसी) आप देखेंगे कि यह निशान
स्रोत को संदर्भित करता है पॉइंट टू पॉइंट नेट डिवाइस :: m_phyRxDropTrace. यदि आप फिर अंदर देखें
src/प्वाइंट-टू-प्वाइंट/मॉडल/प्वाइंट-टू-प्वाइंट-नेट-डिवाइस.एच इस सदस्य चर के लिए, आप करेंगे
पाते हैं कि इसे एक के रूप में घोषित किया गया है ट्रैस्डकॉलबैक पैकेट> >. यह आपको बताना चाहिए
कि कॉलबैक लक्ष्य एक ऐसा फ़ंक्शन होना चाहिए जो शून्य लौटाता है और एक लेता है
पैरामीटर जो एक है पीटीआर पैकेट> (यह मानते हुए कि हम उपयोग करते हैं कनेक्टविथआउटकॉन्टेक्स्ट) -- अभी
हमारे पास ऊपर क्या है.

मुख्य कार्यक्रम
निम्नलिखित कोड से अब तक आप भली-भांति परिचित हो गए होंगे:

int
मुख्य (int argc, char *argv[])
{
नोडकंटेनर नोड्स;
नोड्स.बनाएँ (2);

प्वाइंटटूप्वाइंटहेल्पर प्वाइंटटूप्वाइंट;
पॉइंटटूप्वाइंट.सेटडिवाइसएट्रिब्यूट ("डेटारेट", स्ट्रिंगवैल्यू ("5एमबीपीएस"));
पॉइंटटूप्वाइंट.सेटचैनलएट्रिब्यूट ("विलंब", स्ट्रिंगवैल्यू ("2ms"));

नेटडिवाइसकंटेनर डिवाइस;
डिवाइस = पॉइंटटूप्वाइंट.इंस्टॉल (नोड्स);

यह उनके बीच एक पॉइंट-टू-पॉइंट चैनल के साथ दो नोड बनाता है, जैसा कि इसमें दिखाया गया है
फ़ाइल की शुरुआत में चित्रण।

कोड की अगली कुछ पंक्तियाँ कुछ नया दिखाती हैं। यदि हम एक कनेक्शन का पता लगाते हैं जो व्यवहार करता है
पूरी तरह से, हम एक नीरस रूप से बढ़ती भीड़भाड़ वाली खिड़की के साथ समाप्त हो जाएंगे। किसी को देखने के लिए
दिलचस्प व्यवहार, हम वास्तव में लिंक त्रुटियाँ पेश करना चाहते हैं जो पैकेट गिरा देंगी,
डुप्लिकेट ACK का कारण बनें और कंजेशन विंडो के अधिक दिलचस्प व्यवहार को ट्रिगर करें।

एनएस- 3 प्रदान करता है त्रुटि मॉडल ऐसी वस्तुएँ जिनसे जोड़ा जा सकता है चैनल. हम उपयोग कर रहे हैं
रेटएररमॉडल जो हमें त्रुटियों को प्रस्तुत करने की अनुमति देता है चैनल किसी दिए गए समय पर दर.

पीटीआर em = CreateObject ();
em->SetAttribute ("ErrorRate", DoubleValue (0.00001));
डिवाइसेस.गेट (1)->सेटएट्रिब्यूट ("रिसीवएरमॉडल", पॉइंटरवैल्यू (ईएम));

उपरोक्त कोड तुरंत चालू करता है रेटएररमॉडल ऑब्जेक्ट, और हम "ErrorRate" सेट करते हैं विशेषता
वांछित मान तक. फिर हम परिणामी इंस्टेंटियेटेड सेट करते हैं रेटएररमॉडल त्रुटि के रूप में
पॉइंट-टू-पॉइंट द्वारा उपयोग किया जाने वाला मॉडल नेटडिवाइस. इससे हमें कुछ पुन: प्रसारण और मिलेंगे
हमारे कथानक को थोड़ा और रोचक बनाएं।

इंटरनेटस्टैकहेल्पर स्टैक;
स्टैक.इंस्टॉल (नोड्स);

Ipv4AddressHelper पता;
पता.सेटबेस ("10.1.1.0", "255.255.255.252");
Ipv4InterfaceContainer इंटरफ़ेस = पता.असाइन (डिवाइस);

उपरोक्त कोड से परिचित होना चाहिए. यह हमारे दो नोड्स पर इंटरनेट स्टैक स्थापित करता है
इंटरफ़ेस बनाता है और पॉइंट-टू-पॉइंट डिवाइस के लिए आईपी पते निर्दिष्ट करता है।

चूँकि हम टीसीपी का उपयोग कर रहे हैं, हमें टीसीपी प्राप्त करने के लिए गंतव्य नोड पर कुछ चाहिए
कनेक्शन और डेटा. पैकेट सिंक आवेदन आमतौर पर में प्रयोग किया जाता है एनएस- 3 उस के लिए
उद्देश्य।

uint16_t सिंकपोर्ट = 8080;
पता सिंकएड्रेस (इनसेटसॉकेटएड्रेस(इंटरफेस.गेटएड्रेस (1), सिंकपोर्ट));
पैकेटसिंकहेल्पर पैकेटसिंकहेल्पर ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny());
एप्लिकेशनकंटेनर सिंकऐप्स = पैकेटसिंकहेल्पर.इंस्टॉल (नोड्स.गेट (1));
सिंकऐप्स.स्टार्ट (सेकेंड (0.));
सिंकऐप्स.स्टॉप (सेकेंड (20.));

इसके अपवाद के साथ, सभी को परिचित होना चाहिए,

पैकेटसिंकहेल्पर पैकेटसिंकहेल्पर ("ns3::TcpSocketFactory",
InetSocketAddress (Ipv4Address::GetAny());

यह कोड तुरंत चालू करता है पैकेटसिंक हेल्पर और उसे क्लास का उपयोग करके सॉकेट बनाने के लिए कहता है
ns3::TcpSocketFactory. यह वर्ग "ऑब्जेक्ट फ़ैक्टरी" नामक एक डिज़ाइन पैटर्न लागू करता है
जो किसी वर्ग को निर्दिष्ट करने के लिए आमतौर पर उपयोग किया जाने वाला तंत्र है जिसका उपयोग वस्तुओं को बनाने के लिए किया जाता है
अमूर्त तरीका. यहां, वस्तुओं को स्वयं बनाने की बजाय, आप प्रदान करते हैं
पैकेटसिंक हेल्पर एक स्ट्रिंग जो निर्दिष्ट करती है a टाइप आईडी स्ट्रिंग का उपयोग किसी ऑब्जेक्ट को बनाने के लिए किया जाता है
इसके बाद, फ़ैक्टरी द्वारा बनाई गई वस्तुओं के उदाहरण बनाने के लिए इसका उपयोग किया जा सकता है।

शेष पैरामीटर बताता है आवेदन इसे कौन सा पता और पोर्ट करना चाहिए बाँध सेवा मेरे।

कोड की अगली दो पंक्तियाँ सॉकेट बनाएंगी और ट्रेस स्रोत को कनेक्ट करेंगी।

पीटीआर ns3TcpSocket = Socket::CreateSocket (nodes.Get (0),
TcpSocketFactory::GetTypeId ());
ns3TcpSocket->TraceConnectWithoutContext ("कंजेशनविंडो",
मेककॉलबैक (&CwndChange));

पहला कथन स्थिर सदस्य फ़ंक्शन को कॉल करता है सॉकेट::क्रिएटसॉकेट और प्रदान करता है
नोड और एक स्पष्ट टाइप आईडी सॉकेट बनाने के लिए उपयोग की जाने वाली ऑब्जेक्ट फ़ैक्टरी के लिए। यह है एक
की तुलना में थोड़ा निचले स्तर की कॉल पैकेटसिंक हेल्पर ऊपर कॉल करें, और एक स्पष्ट C++ का उपयोग करता है
स्ट्रिंग द्वारा निर्दिष्ट एक के बजाय टाइप करें। अन्यथा, यह वैचारिक रूप से वही है
चीज़।

एक बार टीसीपी सॉकेट बनाया गया है और नोड से जुड़ा हुआ है, हम इसका उपयोग कर सकते हैं
ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट CongestionWindow ट्रेस स्रोत को हमारे ट्रेस सिंक से कनेक्ट करने के लिए।

याद रखें कि हमने एक को कोड किया था आवेदन तो हम उसे ले सकते हैं गर्तिका हमने अभी (के दौरान) बनाया है
कॉन्फ़िगरेशन समय) और सिमुलेशन समय में इसका उपयोग करें। अब हमें इसे त्वरित करना होगा
आवेदन. प्रबंधन के लिए एक सहायक तैयार करने में हमें कोई परेशानी नहीं हुई आवेदन so
हमें इसे "मैन्युअल रूप से" बनाना और इंस्टॉल करना होगा। यह वास्तव में काफी आसान है:

पीटीआर ऐप = CreateObject ();
ऐप->सेटअप (एनएस3टीसीपीसॉकेट, सिंकएड्रेस, 1040, 1000, डेटारेट ("1एमबीपीएस"));
नोड्स.प्राप्त करें (0)->एप्लिकेशन जोड़ें (ऐप);
ऐप->प्रारंभ (सेकंड (1.));
ऐप->स्टॉप (सेकेंड (20.));

पहली पंक्ति एक बनाती है वस्तु प्रकार का MyApp -- हमारा आवेदन. दूसरी पंक्ति बताती है
la आवेदन क्या गर्तिका उपयोग करना है, किस पते से कनेक्ट करना है, कितना डेटा भेजना है
प्रत्येक ईवेंट भेजें, कितने ईवेंट जेनरेट करने हैं और किस दर पर डेटा तैयार करना है
उन घटनाओं से.

इसके बाद, हम मैन्युअल रूप से जोड़ते हैं MyApp आवेदन स्रोत नोड पर और स्पष्ट रूप से कॉल करें
प्रारंभ और रुकें तरीकों पर आवेदन उसे यह बताने के लिए कि उसे कब शुरू करना है और कब बंद करना है
चीज़।

हमें वास्तव में रिसीवर से बिंदु-दर-बिंदु कनेक्ट करने की आवश्यकता है नेटडिवाइस ड्रॉप घटना
हमारे लिए आरएक्सड्रॉप अभी कॉलबैक करें.

डिवाइसेज.गेट (1)->ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट("PhyRxDrop", MakeCallback (&RxDrop));

अब यह स्पष्ट होना चाहिए कि हमें प्राप्त करने का संदर्भ मिल रहा है आसंधि नेटडिवाइस
इसके कंटेनर से और विशेषता "PhyRxDrop" द्वारा परिभाषित ट्रेस स्रोत को कनेक्ट करना
वह उपकरण ट्रेस सिंक के लिए आरएक्सड्रॉप.

अंत में, हम सिम्युलेटर को किसी को भी ओवरराइड करने के लिए कहते हैं अनुप्रयोगों और बस प्रसंस्करण बंद करो
सिमुलेशन में 20 सेकंड पर घटनाएँ।

सिम्युलेटर::रोकें (सेकंड(20));
सिम्युलेटर :: रन ();
सिम्युलेटर::नष्ट करें ();

0 वापसी;
}

एक बार उसे याद करो सिम्युलेटर::चलाएँ कहा जाता है, कॉन्फ़िगरेशन समय समाप्त होता है, और सिमुलेशन
समय शुरू होता है. सभी कार्य हमने बनाकर व्यवस्थित किए आवेदन और इसे पढ़ा रहे हैं
डेटा कैसे कनेक्ट करें और भेजें यह वास्तव में इस फ़ंक्शन कॉल के दौरान होता है।

अस सून अस सिम्युलेटर::चलाएँ रिटर्न, सिमुलेशन पूरा हो गया है और हम टियरडाउन में प्रवेश करते हैं
चरण। इस मामले में, सिम्युलेटर::नष्ट करें रक्तरंजित विवरणों का ध्यान रखता है और हम वापस लौट आते हैं
इसके पूरा होने के बाद एक सफलता कोड।

रनिंग पांचवां.सीसी
चूंकि हमने फ़ाइल उपलब्ध करा दी है पांचवां.सीसी आपके लिए, यदि आपने अपना वितरण (में) बनाया है
चूंकि यह डिबग मोड का उपयोग करता है एनएस_लॉग - याद रखें कि अनुकूलित बिल्ड ऑप्टिमाइज़ हो जाते हैं एनएस_लॉग) यह
आपके दौड़ने का इंतज़ार कर रहा होगा.

$ ./waf --पांचवां भागो
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build' दर्ज करना
वफ़: निर्देशिका `/home/craigdo/repos/ns-3-allinone-dev/ns-3-dev/build' छोड़ रहा हूँ
'निर्माण' सफलतापूर्वक समाप्त हुआ (0.684 सेकंड)
1 536
1.0093 1072
1.01528 1608
1.02167 2144
...
1.11319 8040
1.12151 8576
1.12983 9112
1.13696 पर आरएक्सड्रॉप
...

आप संभवतः अपने निशानों में किसी भी प्रकार के प्रिंट का उपयोग करने का नकारात्मक पक्ष तुरंत देख सकते हैं।
हमें वे अप्रासंगिक संदेश हमारी सभी रोचक सूचनाओं पर छपे हुए मिलते हैं
उन RxDrop संदेशों के साथ। हम जल्द ही इसका समाधान करेंगे, लेकिन मुझे यकीन है कि आप इसे देखने के लिए इंतजार नहीं कर सकते
इस सभी कार्य के परिणाम. आइए उस आउटपुट को नामक फ़ाइल पर रीडायरेक्ट करें cwnd.dat:

$ ./waf --पांचवां भाग > cwnd.dat 2>&1

अब अपने पसंदीदा संपादक में "cwnd.dat" को संपादित करें और waf बिल्ड स्थिति को हटा दें और ड्रॉप करें
लाइनें, केवल ट्रेस किए गए डेटा को छोड़कर (आप इस पर टिप्पणी भी कर सकते हैं
ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट("PhyRxDrop", मेककॉलबैक (&RxDrop)); छुटकारा पाने के लिए स्क्रिप्ट में
ड्रॉप का प्रिंट भी उतनी ही आसानी से।

अब आप gnuplot चला सकते हैं (यदि आपने इसे इंस्टॉल किया है) और इसे कुछ सुंदर उत्पन्न करने के लिए कह सकते हैं
चित्रों:

$ gnuplot
gnuplot> टर्मिनल पीएनजी आकार 640,480 सेट करें
gnuplot> आउटपुट "cwnd.png" सेट करें
gnuplot> लाइनप्वाइंट के साथ 1:2 शीर्षक 'कंजेशन विंडो' का उपयोग करके "cwnd.dat" प्लॉट करें
gnuplot> बाहर निकलें

अब आपके पास फ़ाइल में कंजेशन विंडो बनाम समय का एक ग्राफ़ होना चाहिए
"cwnd.png" लोड हो रहा है = "आलसी" जो इस तरह दिखता है:
[चित्र]

का प्रयोग मध्य स्तर सहायकों
पिछले अनुभाग में, हमने दिखाया था कि किसी ट्रेस स्रोत को कैसे जोड़ा जाए और आशापूर्वक प्राप्त किया जाए
एक अनुकरण से प्राप्त रोचक जानकारी। शायद आपको याद होगा कि हमने फोन किया था
का उपयोग करके मानक आउटपुट पर लॉगिंग करना std::cout इसमें बहुत पहले का एक "कुंद उपकरण" था
अध्याय. हमने यह भी लिखा कि लॉग आउटपुट को क्रम में पार्स करने में कितनी समस्या आ रही थी
दिलचस्प जानकारी को अलग करने के लिए. हो सकता है कि आपके मन में यह बात आई हो कि हमने बहुत सारा खर्च किया है
एक ऐसे उदाहरण को लागू करने में समय लगता है जो उन सभी समस्याओं को प्रदर्शित करता है जिन्हें हम ठीक करना चाहते हैं
la एनएस- 3 अनुरेखण प्रणाली! आप सही होंगे. लेकिन, हमारे साथ रहो. हमने अभी तक काम पूरा नहीं किया है.

सबसे महत्वपूर्ण चीजों में से एक जो हम करना चाहते हैं वह है आसानी से करने की क्षमता रखना
सिमुलेशन से निकलने वाले आउटपुट की मात्रा को नियंत्रित करें; और हम उन्हें बचाना भी चाहते हैं
एक फ़ाइल में डेटा ताकि हम बाद में इसे वापस देख सकें। हम मध्य-स्तरीय ट्रेस हेल्पर्स का उपयोग कर सकते हैं
इसमें प्रदत्त एनएस- 3 बस इतना ही करो और चित्र पूरा करो।

हम एक स्क्रिप्ट प्रदान करते हैं जो उदाहरण में विकसित सीडब्ल्यूएनडी परिवर्तन और ड्रॉप घटनाओं को लिखती है
पांचवां.सीसी अलग फ़ाइलों में डिस्क करने के लिए. Cwnd परिवर्तन एक टैब-पृथक ASCII के रूप में संग्रहीत किए जाते हैं
फ़ाइल और ड्रॉप ईवेंट को PCAP फ़ाइल में संग्रहीत किया जाता है। ऐसा करने के लिए परिवर्तन हैं
काफी छोटा।

पूर्वाभ्यास: छठा.सीसी
आइए आगे बढ़ने के लिए आवश्यक परिवर्तनों पर एक नज़र डालें पांचवां.सीसी सेवा मेरे छठा.सीसी। खुला
उदाहरण/ट्यूटोरियल/छठी.सीसी अपने पसंदीदा संपादक में. आप पहला परिवर्तन इसके द्वारा देख सकते हैं
CwndChange की खोज कर रहा हूँ। आप पाएंगे कि हमने ट्रेस के लिए हस्ताक्षर बदल दिए हैं
सिंक और प्रत्येक सिंक में एक पंक्ति जोड़ी गई है जो ट्रेस की गई जानकारी को लिखती है
स्ट्रीम एक फ़ाइल का प्रतिनिधित्व करती है।

स्थिर शून्य
CwndChange (Ptr स्ट्रीम, uint32_t OldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (सिम्युलेटर::अभी ().GetSeconds () << "\t" << newCwnd);
*स्ट्रीम->गेटस्ट्रीम () << सिम्युलेटर::अभी ().गेटसेकंड () << "\t" << OldCwnd << "\t" << newCwnd << std::endl;
}

स्थिर शून्य
आरएक्सड्रॉप (पीटीआर) फ़ाइल, पीटीआर पी)
{
NS_LOG_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
फ़ाइल->लिखें(सिम्युलेटर::अब(), पी);
}

हमने इसमें एक "स्ट्रीम" पैरामीटर जोड़ा है Cwndपरिवर्तन ट्रेस सिंक. यह एक ऐसी वस्तु है
C++ आउटपुट स्ट्रीम को होल्ड (सुरक्षित रूप से जीवित रखता है) करता है। यह पता चला है कि यह बहुत सरल है
ऑब्जेक्ट, लेकिन वह जो स्ट्रीम के लिए आजीवन मुद्दों का प्रबंधन करता है और एक समस्या को भी हल करता है
अनुभवी C++ उपयोगकर्ता इसमें भाग लेते हैं। यह पता चला है कि कॉपी कंस्ट्रक्टर के लिए एसटीडी::ओस्ट्रीम
निजी के रूप में चिह्नित किया गया है. इस का मतलब है कि std::ostreams मूल्य शब्दार्थ का पालन न करें और न ही कर सकते हैं
किसी भी तंत्र में उपयोग किया जा सकता है जिसके लिए स्ट्रीम की प्रतिलिपि बनाने की आवश्यकता होती है। इसमें शामिल है एनएस- 3
कॉलबैक सिस्टम, जैसा कि आपको याद होगा, ऐसी वस्तुओं की आवश्यकता होती है जो मूल्य शब्दार्थ का पालन करती हों।
आगे ध्यान दें कि हमने निम्नलिखित पंक्ति को इसमें जोड़ा है Cwndपरिवर्तन ट्रेस सिंक
कार्यान्वयन:

*स्ट्रीम->गेटस्ट्रीम () << सिम्युलेटर::अभी ().गेटसेकंड () << "\t" << OldCwnd << "\t" << newCwnd << std::endl;

यदि आपने इसे बदल दिया तो यह बहुत परिचित कोड होगा *स्ट्रीम->गेटस्ट्रीम () साथ में std::cout, के रूप में
में:

std::cout << Simulator::Now ().GetSeconds () << "\t" << OldCwnd << "\t" << newCwnd << std::endl;

इससे पता चलता है कि पीटीआर वास्तव में बस एक चारों ओर ले जा रहा है
एसटीडी::ऑफस्ट्रीम आपके लिए, और आप इसे किसी भी अन्य आउटपुट स्ट्रीम की तरह यहां उपयोग कर सकते हैं।

ऐसी ही स्थिति होती है आरएक्सड्रॉप सिवाय इसके कि वस्तु को चारों ओर से गुजारा जा रहा है (a
पीटीआर) एक PCAP फ़ाइल का प्रतिनिधित्व करता है। ट्रेस सिंक में एक-लाइनर है
एक टाइमस्टैम्प और पैकेट की सामग्री को PCAP फ़ाइल में लिखें:

फ़ाइल->लिखें(सिम्युलेटर::अब(), पी);

निःसंदेह, यदि हमारे पास दो फ़ाइलों का प्रतिनिधित्व करने वाली वस्तुएं हैं, तो हमें उन्हें कहीं न कहीं बनाने की आवश्यकता है
और उन्हें ट्रेस सिंक तक पहुंचाने का कारण भी बनता है। यदि आप इसमें देखें मुख्य समारोह,
ऐसा करने के लिए आपको नया कोड मिलेगा:

AsciiTraceHelper asciiTraceHelper;
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("छठा.cwnd");
ns3TcpSocket->TraceConnectWithoutContext ("कंजेशनविंडो", मेकबाउंडकॉलबैक (&CwndChange, स्ट्रीम));

...

पीकैपहेल्पर पीकैपहेल्पर;
पीटीआर फ़ाइल = pcapHelper.CreateFile ("छठा.pcap", std::ios::out, PcapHelper::DLT_PPP);
डिवाइसेज.गेट (1)->ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट("PhyRxDrop", MakeBoundCallback (&RxDrop, फाइल));

उपरोक्त कोड स्निपेट के पहले खंड में, हम ASCII ट्रेस फ़ाइल बना रहे हैं,
इसे प्रबंधित करने और कॉलबैक के एक प्रकार का उपयोग करने के लिए जिम्मेदार एक ऑब्जेक्ट बनाना
ऑब्जेक्ट को सिंक तक पहुंचाने की व्यवस्था करने के लिए निर्माण फ़ंक्शन। हमारा ASCII ट्रेस
हेल्पर्स टेक्स्ट (ASCII) फ़ाइलों के उपयोग को आसान बनाने के लिए कार्यों का एक समृद्ध सेट प्रदान करते हैं। हम हैं
यहां मैं बस फ़ाइल स्ट्रीम निर्माण फ़ंक्शन के उपयोग का वर्णन करने जा रहा हूं।

RSI फ़ाइलस्ट्रीम बनाएँ फ़ंक्शन मूल रूप से a को इंस्टेंट करने वाला है एसटीडी::ऑफस्ट्रीम वस्तु और
एक नई फ़ाइल बनाएँ (या किसी मौजूदा फ़ाइल को छोटा करें)। यह एसटीडी::ऑफस्ट्रीम में पैक किया गया है
एनएस- 3 आजीवन प्रबंधन और कॉपी कंस्ट्रक्टर समस्या समाधान के लिए ऑब्जेक्ट।

फिर हम इसे लेते हैं एनएस- 3 ऑब्जेक्ट फ़ाइल का प्रतिनिधित्व करता है और इसे पास करता है मेकबाउंडकॉलबैक().
यह फ़ंक्शन बिल्कुल वैसे ही कॉलबैक बनाता है मेककॉलबैक(), लेकिन यह एक नए मान को "बांधता" है
कॉलबैक. यह मान कॉलबैक से पहले पहले तर्क के रूप में जोड़ा जाता है
बुलाया।

मूलतः, मेकबाउंडकॉलबैक(&CwndChange, धारा) ट्रेस स्रोत को जोड़ने का कारण बनता है
लागू करने से पहले औपचारिक पैरामीटर सूची के सामने अतिरिक्त "स्ट्रीम" पैरामीटर
कॉलबैक. इससे आवश्यक हस्ताक्षर बदल जाता है Cwndपरिवर्तन एक से मेल करने के लिए सिंक करें
ऊपर दिखाया गया है, जिसमें "अतिरिक्त" पैरामीटर शामिल है पीटीआर धारा.

उपरोक्त स्निपेट में कोड के दूसरे खंड में, हम a को इंस्टेंट करते हैं PcapHelper ऐसा करने के लिए
हमारी पीसीएपी ट्रेस फ़ाइल के लिए भी यही बात हमने की थी AsciiTraceHelper. की पंक्ति
कोड,

पीटीआर फ़ाइल = pcapHelper.CreateFile ("छठा.pcap",
"w", PcapHelper::DLT_PPP);

फ़ाइल मोड "w" के साथ "सिक्स्थ.पकैप" नामक एक पीसीएपी फ़ाइल बनाता है। इसका मतलब है कि नई फ़ाइल
यदि उस नाम की कोई मौजूदा फ़ाइल मिलती है तो उसे छोटा कर दिया जाता है (सामग्री हटा दी जाती है)। अंतिम
पैरामीटर नई पीसीएपी फ़ाइल का "डेटा लिंक प्रकार" है। ये पीसीएपी के समान हैं
लाइब्रेरी डेटा लिंक प्रकारों को परिभाषित किया गया है बीपीएफ.एच यदि आप पीसीएपी से परिचित हैं। इस मामले में,
डीएलटी_पीपीपी इंगित करता है कि पीसीएपी फ़ाइल में बिंदु के साथ पहले से जुड़े पैकेट शामिल होंगे
बिंदु शीर्षलेख. यह सच है क्योंकि पैकेट हमारे पॉइंट-टू-पॉइंट डिवाइस से आ रहे हैं
चालक। अन्य सामान्य डेटा लिंक प्रकार Csma के लिए उपयुक्त DLT_EN10MB (10 MB ईथरनेट) हैं
डिवाइस और DLT_IEEE802_11 (IEEE 802.11) वाईफाई डिवाइस के लिए उपयुक्त हैं। ये परिभाषित हैं
in src/network/helper/trace-helper.h यदि आप सूची देखने में रुचि रखते हैं।
सूची में प्रविष्टियाँ उनमें से मेल खाती हैं बीपीएफ.एच लेकिन हम पीसीएपी स्रोत से बचने के लिए उनकी नकल करते हैं
निर्भरता।

A एनएस- 3 PCAP फ़ाइल का प्रतिनिधित्व करने वाली वस्तु से लौटाया जाता है फ़ाइल बनाएँ और एक सीमा में प्रयोग किया जाता है
बिल्कुल वैसा ही कॉलबैक करें जैसा कि ASCII मामले में था।

एक महत्वपूर्ण मोड़: यह ध्यान देना महत्वपूर्ण है कि भले ही ये दोनों वस्तुएँ हैं
बहुत ही समान तरीकों से घोषित किया गया,

पीटीआर फ़ाइल ...
पीटीआर धारा ...

अंतर्निहित वस्तुएं पूरी तरह से अलग हैं। उदाहरण के लिए, पीटीआर एक
एक के लिए स्मार्ट सूचक एनएस- 3 वस्तु जो काफी वजनदार चीज है जो सहारा देती है
विशेषताएँ और कॉन्फिग सिस्टम में एकीकृत है। पीटीआर, पर
दूसरी ओर, एक संदर्भ गणना वाली वस्तु के लिए एक स्मार्ट पॉइंटर है जो बहुत हल्का है
चीज़। कोई भी धारणा बनाने से पहले उस वस्तु को देखना याद रखें जिसका आप संदर्भ दे रहे हैं
उस वस्तु में मौजूद "शक्तियों" के बारे में।

उदाहरण के लिए, एक नज़र डालें src/network/utils/pcap-file-wrapper.h वितरण में और
सूचना,

क्लास PcapFileWrapper: सार्वजनिक ऑब्जेक्ट

वह वर्ग PcapFileWrapper है एक एनएस- 3 वस्तु अपनी विरासत के आधार पर। फिर देखो
src/नेटवर्क/मॉडल/आउटपुट-स्ट्रीम-रैपर.एच और ध्यान दें,

क्लास आउटपुटस्ट्रीमरैपर: सार्वजनिक
SimpleRefCount

कि यह वस्तु नहीं है एनएस- 3 ऑब्जेक्ट बिल्कुल भी, यह "केवल" एक C++ ऑब्जेक्ट है जो होता है
दखल देने वाली संदर्भ गिनती का समर्थन करें।

यहां मुद्दा यह है कि सिर्फ इसलिए कि आप पढ़ते हैं पीटीआर इसका मतलब यह जरूरी नहीं है
कि कुछ है एक एनएस- 3 वह वस्तु जिस पर आप लटका सकते हैं एनएस- 3 उदाहरण के लिए गुण.

अब, उदाहरण पर वापस आते हैं। यदि आप यह उदाहरण बनाते और चलाते हैं,

$ ./waf -- छठा भागो

आपको वही संदेश दिखाई देंगे जो आपने "पांचवें" चलाने पर दिखाए थे, लेकिन दो नई फ़ाइलें दिखाई देंगी
आपकी शीर्ष-स्तरीय निर्देशिका में दिखाई देगा एनएस- 3 वितरण.

छठा.cwnd छठा.pcap

चूँकि "छठी.cwnd" एक ASCII टेक्स्ट फ़ाइल है, आप इसे इसके साथ देख सकते हैं बिल्ली या आपकी पसंदीदा फ़ाइल
दर्शक।

1 0 536
1.0093 536 1072
1.01528 1072 1608
1.02167 1608 2144
...
9.69256 5149 5204
9.89311 5204 5259

आपके पास टाइमस्टैम्प, एक पुरानी कंजेशन विंडो और एक नई के साथ एक टैब से अलग की गई फ़ाइल है
कंजेशन विंडो सीधे आपके प्लॉट प्रोग्राम में आयात करने के लिए उपयुक्त है। यहाँ नहीं हैं
फ़ाइल में बाहरी प्रिंट, कोई पार्सिंग या संपादन की आवश्यकता नहीं है।

चूंकि "सिक्स्थ.पकैप" एक पीसीएपी फ़ाइल है, आप इसे इसके साथ फाइल कर सकते हैं टीसीपीडम्प.

फ़ाइल छठी.पीकैप से पढ़ना, लिंक-प्रकार पीपीपी (पीपीपी)
1.136956 आईपी 10.1.1.1.49153 > 10.1.1.2.8080: झंडे [.], अनुक्रम 17177:17681, एके 1, जीत 32768, विकल्प [टीएस वैल 1133 ईसीआर 1127,ईओएल], लंबाई 504
1.403196 आईपी 10.1.1.1.49153 > 10.1.1.2.8080: झंडे [.], अनुक्रम 33280:33784, एके 1, जीत 32768, विकल्प [टीएस वैल 1399 ईसीआर 1394,ईओएल], लंबाई 504
...
7.426220 आईपी 10.1.1.1.49153 > 10.1.1.2.8080: झंडे [.], अनुक्रम 785704:786240, एके 1, जीत 32768, विकल्प [टीएस वैल 7423 ईसीआर 7421,ईओएल], लंबाई 536
9.630693 आईपी 10.1.1.1.49153 > 10.1.1.2.8080: झंडे [.], अनुक्रम 882688:883224, एके 1, जीत 32768, विकल्प [टीएस वैल 9620 ईसीआर 9618,ईओएल], लंबाई 536

आपके पास सिमुलेशन में छोड़े गए पैकेटों के साथ एक पीसीएपी फ़ाइल है। यहाँ नहीं हैं
फ़ाइल में अन्य पैकेट मौजूद हैं और जीवन बनाने के लिए और कुछ भी मौजूद नहीं है
मुश्किल।

यह एक लंबी यात्रा रही है, लेकिन अब हम उस बिंदु पर हैं जहां हम इसकी सराहना कर सकते हैं एनएस- 3
अनुरेखण प्रणाली. हमने टीसीपी कार्यान्वयन के बीच से महत्वपूर्ण घटनाओं को बाहर निकाला है
और एक डिवाइस ड्राइवर. हमने उन घटनाओं को सीधे आम तौर पर ज्ञात फ़ाइलों में संग्रहीत किया
औजार। हमने इसमें शामिल किसी भी मूल कोड को संशोधित किए बिना ऐसा किया, और हमने इसे इसमें किया
कोड की केवल 18 पंक्तियाँ:

स्थिर शून्य
CwndChange (Ptr स्ट्रीम, uint32_t OldCwnd, uint32_t newCwnd)
{
NS_LOG_UNCOND (सिम्युलेटर::अभी ().GetSeconds () << "\t" << newCwnd);
*स्ट्रीम->गेटस्ट्रीम () << सिम्युलेटर::अभी ().गेटसेकंड () << "\t" << OldCwnd << "\t" << newCwnd << std::endl;
}

...

AsciiTraceHelper asciiTraceHelper;
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("छठा.cwnd");
ns3TcpSocket->TraceConnectWithoutContext ("कंजेशनविंडो", मेकबाउंडकॉलबैक (&CwndChange, स्ट्रीम));

...

स्थिर शून्य
आरएक्सड्रॉप (पीटीआर) फ़ाइल, पीटीआर पी)
{
NS_LOG_UNCOND ("RxDrop at " << Simulator::Now ().GetSeconds ());
फ़ाइल->लिखें(सिम्युलेटर::अब(), पी);
}

...

पीकैपहेल्पर पीकैपहेल्पर;
पीटीआर फ़ाइल = pcapHelper.CreateFile ("छठा.pcap", "w", PcapHelper::DLT_PPP);
डिवाइसेज.गेट (1)->ट्रेसकनेक्टविथआउटकॉन्टेक्स्ट("PhyRxDrop", MakeBoundCallback (&RxDrop, फाइल));

निशान सहायकों
RSI एनएस- 3 ट्रेस हेल्पर्स विभिन्न को कॉन्फ़िगर करने और चयन करने के लिए एक समृद्ध वातावरण प्रदान करते हैं
घटनाओं का पता लगाना और उन्हें फाइलों में लिखना। पिछले अनुभागों में, मुख्यतः
बिल्डिंगटोपोलॉजीज़ में, हमने डिज़ाइन किए गए ट्रेस हेल्पर तरीकों की कई किस्में देखी हैं
अन्य (डिवाइस) सहायकों के अंदर उपयोग के लिए।

शायद आपको इनमें से कुछ विविधताएँ देखना याद होगा:

pointToPoint.EnablePcapAll ("दूसरा");
pointToPoint.EnablePcap ("दूसरा", p2pNodes.Get (0)->GetId (), 0);
csma.EnablePcap ("तीसरा", csmaDevices.Get (0), सत्य);
pointToPoint.EnableAsciiAll (ascii.CreateFileStream ("myfirst.tr"));

हालाँकि, जो स्पष्ट नहीं हो सकता है, वह यह है कि सभी के लिए एक सुसंगत मॉडल है
सिस्टम में ट्रेस-संबंधित विधियाँ पाई गईं। अब हम थोड़ा समय निकाल कर देखेंगे
"बड़ी तस्वीर" पर.

वर्तमान में ट्रेसिंग हेल्पर्स के दो प्राथमिक उपयोग के मामले हैं एनएस- 3: डिवाइस सहायक
और प्रोटोकॉल सहायक। डिवाइस सहायक यह निर्दिष्ट करने की समस्या को देखते हैं कि कौन से निशान हैं
(नोड, डिवाइस) जोड़ी के माध्यम से सक्षम किया जाना चाहिए। उदाहरण के लिए, आप निर्दिष्ट करना चाह सकते हैं
कि पीसीएपी ट्रेसिंग को किसी विशिष्ट डिवाइस पर एक विशिष्ट नोड पर सक्षम किया जाना चाहिए। यह
से अनुसरण करता है एनएस- 3 डिवाइस वैचारिक मॉडल, और के वैचारिक मॉडल भी
विभिन्न उपकरण सहायक। इससे स्वाभाविक रूप से अनुसरण करते हुए, बनाई गई फ़ाइलें अनुसरण करती हैं
- - नामकरण परंपरा।

प्रोटोकॉल सहायक यह निर्दिष्ट करने की समस्या को देखते हैं कि किन निशानों को सक्षम किया जाना चाहिए
एक प्रोटोकॉल और इंटरफ़ेस जोड़ी। यह इस प्रकार है एनएस- 3 प्रोटोकॉल स्टैक वैचारिक
मॉडल, और इंटरनेट स्टैक हेल्पर्स के वैचारिक मॉडल भी। स्वाभाविक रूप से, निशान
फ़ाइलों को अनुसरण करना चाहिए a - - नामकरण परंपरा।

इसलिए ट्रेस सहायक स्वाभाविक रूप से द्वि-आयामी वर्गीकरण में आते हैं। वहाँ हैं
ऐसी सूक्ष्मताएँ जो सभी चार वर्गों को एक जैसा व्यवहार करने से रोकती हैं, लेकिन हम ऐसा करने का प्रयास करते हैं
उन सभी को यथासंभव समान रूप से कार्य करने दें; और जब भी संभव हो इसके लिए एनालॉग मौजूद होते हैं
सभी कक्षाओं में सभी विधियाँ।

┌────────────────┬──────┬──────┐
│ │ पीसीएपी │ एएससीआईआई │
└────────────────┴──────┴──────┘

│डिवाइस हेल्पर │ │ │
├────────────────┼──────┼──────┤
│प्रोटोकॉल हेल्पर │ │ │
└────────────────┴──────┴──────┘

हम एक दृष्टिकोण का उपयोग करते हैं जिसे a कहा जाता है mixin हमारे सहायक वर्गों में ट्रेसिंग कार्यक्षमता जोड़ने के लिए। ए
mixin एक वर्ग है जो उपवर्ग द्वारा विरासत में मिलने पर कार्यक्षमता प्रदान करता है।
मिक्सिन से विरासत प्राप्त करना विशेषज्ञता का एक रूप नहीं माना जाता है बल्कि वास्तव में यह एक तरीका है
कार्यक्षमता एकत्र करें.

आइए इन चारों मामलों और उनसे जुड़े मामलों पर एक नज़र डालें मिश्रण.

युक्ति सहायकों
पीसीएपी
इन सहायकों का लक्ष्य एक सुसंगत पीसीएपी ट्रेस सुविधा को जोड़ना आसान बनाना है
एनएस- 3 उपकरण। हम चाहते हैं कि पीसीएपी ट्रेसिंग के सभी विभिन्न फ्लेवर समान रूप से काम करें
सभी डिवाइस, इसलिए इन हेल्पर्स के तरीके डिवाइस हेल्पर्स को विरासत में मिले हैं। नज़र रखना
at src/network/helper/trace-helper.h यदि आप देखते समय चर्चा का अनुसरण करना चाहते हैं
असली कोड.

कक्षा PcapHelperForDevice एक mixin उपयोग के लिए उच्च स्तरीय कार्यक्षमता प्रदान करता है
एक में पीसीएपी ट्रेसिंग एनएस- 3 उपकरण। प्रत्येक डिवाइस को एक ही वर्चुअल विधि लागू करनी होगी
इस वर्ग से विरासत में मिला है।

वर्चुअल शून्य EnablePcapInternal (std::string prefix, Ptr दूसरा, बूल प्रोमिसकस, बूल स्पष्टफाइलनाम) = 0;

इस पद्धति का हस्ताक्षर इस स्थिति के उपकरण-केंद्रित दृष्टिकोण को दर्शाता है
स्तर। सभी सार्वजनिक विधियाँ वर्ग से विरासत में मिली हैं PcapUserHelperForDevice कम करना
इस एकल डिवाइस-निर्भर कार्यान्वयन विधि को कॉल करना। उदाहरण के लिए, निम्नतम स्तर
पीसीएपी विधि,

शून्य EnablePcap (std::string उपसर्ग, Ptr दूसरा, बूल प्रोमिसकस = गलत, बूल स्पष्टफाइलनाम = गलत);

के डिवाइस कार्यान्वयन को कॉल करेगा Pcapआंतरिक सक्षम करें सीधे. अन्य सभी सार्वजनिक पीसीएपी
अतिरिक्त उपयोगकर्ता-स्तर प्रदान करने के लिए ट्रेसिंग विधियाँ इस कार्यान्वयन पर निर्मित होती हैं
कार्यक्षमता. उपयोगकर्ता के लिए इसका मतलब यह है कि सिस्टम में सभी डिवाइस हेल्पर ऐसा करेंगे
सभी पीसीएपी ट्रेस विधियां उपलब्ध हैं; और ये सभी विधियां समान रूप से काम करेंगी
यदि डिवाइस कार्यान्वित होता है तो सभी डिवाइसों में रास्ता Pcapआंतरिक सक्षम करें सही ढंग से।

तरीके
शून्य EnablePcap (std::string उपसर्ग, Ptr दूसरा, बूल प्रोमिसकस = गलत, बूल स्पष्टफाइलनाम = गलत);
शून्य EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool exploredFilename = false);
शून्य EnablePcap (std::string prefix, NetDeviceContainer d, bool promiscuous = false);
शून्य EnablePcap (std::string prefix, NodeContainer n, bool promiscuous = false);
शून्य EnablePcap (std::string prefix, uint32_t nodeid, uint32_t डिवाइसआईडी, बूल प्रोमिसस = गलत);
शून्य EnablePcapAll (std::string prefix, bool promiscuous = false);

ऊपर दिखाए गए प्रत्येक तरीके में, एक डिफ़ॉल्ट पैरामीटर होता है जिसे कहा जाता है अनेक कि
करने के लिए चूक असत्य. यह पैरामीटर इंगित करता है कि ट्रेस को एकत्रित नहीं किया जाना चाहिए
अनेक मोड। यदि आप चाहते हैं कि आपके निशानों में डिवाइस द्वारा देखा गया सारा ट्रैफ़िक शामिल हो
(और यदि डिवाइस किसी विशिष्ट मोड का समर्थन करता है) तो बस इनमें से किसी एक में एक सही पैरामीटर जोड़ें
ऊपर कॉल करता है. उदाहरण के लिए,

पीटीआर रा;
...
helper.EnablePcap ("उपसर्ग", दूसरा, सत्य);

पर प्रोमिसस मोड कैप्चर सक्षम करेगा नेटडिवाइस इसके द्वारा निर्दिष्ट nd.

पहले दो तरीकों में एक डिफ़ॉल्ट पैरामीटर भी शामिल है जिसे कहा जाता है स्पष्टफ़ाइलनाम वो होगा
नीचे चर्चा की जाएगी।

आपको कक्षा के लिए एपीआई दस्तावेज़ीकरण का अध्ययन करने के लिए प्रोत्साहित किया जाता है PcapHelperForDevice लगता है
इन विधियों का विवरण; लेकिन संक्षेप में बताएं...

· आप एक विशेष नोड/नेट-डिवाइस जोड़ी पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
पीटीआर एक को Pcap सक्षम करें तरीका। पीटीआर नेट डिवाइस के बाद से निहित है
बिल्कुल एक नोड से संबंधित होना चाहिए। उदाहरण के लिए,

पीटीआर रा;
...
helper.EnablePcap ("उपसर्ग", एनडी);

· आप एक विशेष नोड/नेट-डिवाइस जोड़ी पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
एसटीडी :: स्ट्रिंग किसी ऑब्जेक्ट नाम सेवा स्ट्रिंग का प्रतिनिधित्व करना Pcap सक्षम करें तरीका।
पीटीआर नाम स्ट्रिंग से ऊपर देखा जाता है. फिर से, तब से निहित है
नामित नेट डिवाइस बिल्कुल एक नोड से संबंधित होना चाहिए। उदाहरण के लिए,

नाम::जोड़ें ("सर्वर"...);
नाम::जोड़ें ("सर्वर/eth0"...);
...
helper.EnablePcap ("उपसर्ग", "सर्वर/एथ0");

· आप नोड/नेट-डिवाइस जोड़े के संग्रह पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
नेटडिवाइसकंटेनर। प्रत्येक के लिए नेटडिवाइस कंटेनर में प्रकार की जाँच की जाती है। प्रत्येक के लिए
उचित प्रकार का उपकरण (उसी प्रकार का जैसा उपकरण सहायक द्वारा प्रबंधित किया जाता है), ट्रेसिंग है
सक्षम. फिर से, अंतर्निहित है क्योंकि पाया गया नेट डिवाइस अवश्य ही संबंधित होना चाहिए
बिल्कुल एक नोड. उदाहरण के लिए,

NetDeviceContainer d = ...;
...
helper.EnablePcap ("उपसर्ग", डी);

· आप नोड/नेट-डिवाइस जोड़े के संग्रह पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
नोडकंटेनर. में प्रत्येक नोड के लिए नोडकंटेनर यह संलग्न है नेटडिवाइसेस पुनरावृत्त हैं.
प्रत्येक के लिए नेटडिवाइस कंटेनर में प्रत्येक नोड से जुड़ा हुआ, उस डिवाइस का प्रकार है
जाँच की गई. उचित प्रकार के प्रत्येक डिवाइस के लिए (उसी प्रकार का जो डिवाइस द्वारा प्रबंधित किया जाता है
सहायक), ट्रेसिंग सक्षम है।

नोडकंटेनर एन;
...
helper.EnablePcap ("उपसर्ग", n);

· आप नोड आईडी और डिवाइस आईडी के आधार पर भी पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
स्पष्ट PTR. सिस्टम में प्रत्येक नोड में एक पूर्णांक नोड आईडी होती है और प्रत्येक डिवाइस जुड़ा होता है
एक नोड में एक पूर्णांक डिवाइस आईडी होती है।

helper.EnablePcap ("उपसर्ग", 21, 1);

· अंत में, आप सिस्टम में सभी उपकरणों के लिए एक ही प्रकार से पीसीएपी ट्रेसिंग सक्षम कर सकते हैं
जैसा कि डिवाइस सहायक द्वारा प्रबंधित किया जाता है।

helper.EnablePcapAll ("उपसर्ग");

फ़ाइल नाम
उपरोक्त विधि विवरण में पूर्ण फ़ाइल नाम का निर्माण निहित है
कार्यान्वयन विधि. परंपरा के अनुसार, पीसीएपी का पता चलता है एनएस- 3 सिस्टम फॉर्म के हैं
- आईडी>- आईडी>.पीकैप

जैसा कि पहले उल्लेख किया गया है, सिस्टम में प्रत्येक नोड में एक सिस्टम-निर्दिष्ट नोड आईडी होगी; और
प्रत्येक डिवाइस में उसके नोड के सापेक्ष एक इंटरफ़ेस इंडेक्स (जिसे डिवाइस आईडी भी कहा जाता है) होगा।
डिफ़ॉल्ट रूप से, फिर, पहले पर ट्रेसिंग को सक्षम करने के परिणामस्वरूप एक पीसीएपी ट्रेस फ़ाइल बनाई जाती है
नोड 21 का उपकरण उपसर्ग "उपसर्ग" का उपयोग करेगा उपसर्ग-21-1.पीकैप.

आप हमेशा इसका उपयोग कर सकते हैं एनएस- 3 इसे और अधिक स्पष्ट करने के लिए ऑब्जेक्ट नाम सेवा। उदाहरण के लिए, यदि
आप परिणामी पीसीएपी, नोड 21 को "सर्वर" नाम निर्दिष्ट करने के लिए ऑब्जेक्ट नाम सेवा का उपयोग करते हैं
ट्रेस फ़ाइल नाम स्वचालित रूप से बन जाएगा, उपसर्ग-सर्वर-1.pcap और यदि आप भी असाइन करते हैं
डिवाइस पर "eth0" नाम रखें, आपका PCAP फ़ाइल नाम स्वचालित रूप से इसे उठाएगा और हो जाएगा
बुलाया उपसर्ग-सर्वर-eth0.pcap.

अंत में, ऊपर दिखाए गए तरीकों में से दो,

शून्य EnablePcap (std::string उपसर्ग, Ptr दूसरा, बूल प्रोमिसकस = गलत, बूल स्पष्टफाइलनाम = गलत);
शून्य EnablePcap (std::string prefix, std::string ndName, bool promiscuous = false, bool exploredFilename = false);

एक डिफ़ॉल्ट पैरामीटर कहा जाता है स्पष्टफ़ाइलनाम. जब सत्य पर सेट किया जाता है, तो यह पैरामीटर
स्वचालित फ़ाइल नाम पूर्णता तंत्र को अक्षम कर देता है और आपको एक स्पष्ट नाम बनाने की अनुमति देता है
फ़ाइल का नाम। यह विकल्प केवल उन विधियों में उपलब्ध है जो पीसीएपी ट्रेसिंग को सक्षम करते हैं
एकल उपकरण.

उदाहरण के लिए, एकल विशिष्ट पीसीएपी बनाने के लिए एक डिवाइस सहायक की व्यवस्था करने के लिए
किसी विशिष्ट नाम की फ़ाइल कैप्चर करें my-pcap-file.pcap किसी दिए गए डिवाइस पर, कोई यह कर सकता है:

पीटीआर रा;
...
helper.EnablePcap ("my-pcap-file.pcap", दूसरा, सत्य, सत्य);

पहला पोस्ट <strong>उद्देश्य</strong> पैरामीटर विशिष्ट मोड ट्रेस को सक्षम बनाता है और दूसरा सहायक को बताता है
व्याख्या करने के लिए उपसर्ग पूर्ण फ़ाइल नाम के रूप में पैरामीटर।

ASCII
ASCII ट्रेस हेल्पर का व्यवहार mixin यह काफी हद तक PCAP संस्करण के समान है।
पर एक नज़र रखना src/network/helper/trace-helper.h यदि आप चर्चा का अनुसरण करना चाहते हैं
वास्तविक कोड को देखते समय।

कक्षा AsciiTraceHelperForDevice ASCII का उपयोग करने के लिए उच्च स्तरीय कार्यक्षमता जोड़ता है
डिवाइस सहायक वर्ग का पता लगाना। जैसा कि पीसीएपी मामले में होता है, प्रत्येक डिवाइस को इसे लागू करना होगा
ASCII ट्रेस से विरासत में मिली एकल वर्चुअल विधि mixin.

वर्चुअल शून्य EnableAsciiInternal (Ptr धारा,
std::स्ट्रिंग उपसर्ग,
पीटीआर रा,
बूल स्पष्टफ़ाइलनाम) = 0;

इस पद्धति का हस्ताक्षर इस स्थिति के उपकरण-केंद्रित दृष्टिकोण को दर्शाता है
स्तर; और यह तथ्य भी कि सहायक एक साझा आउटपुट स्ट्रीम पर लिख सकता है। के सभी
सार्वजनिक ASCII-ट्रेस-संबंधित विधियाँ कक्षा से विरासत में मिलीं AsciiTraceHelperForDevice
इस एकल डिवाइस-निर्भर कार्यान्वयन विधि को कॉल करना कम करें। उदाहरण के लिए,
निम्नतम स्तर की एएससीआईआई ट्रेस विधियाँ,

शून्य EnableAscii (std::string उपसर्ग, Ptr और, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAscii (Ptr स्ट्रीम, पीटीआर रा);

के डिवाइस कार्यान्वयन को कॉल करेगा Asciiआंतरिक सक्षम करें सीधे, या तो एक प्रदान करना
वैध उपसर्ग या स्ट्रीम. अन्य सभी सार्वजनिक ASCII ट्रेसिंग विधियाँ इन पर निर्मित होंगी
अतिरिक्त उपयोगकर्ता-स्तरीय कार्यक्षमता प्रदान करने के लिए निम्न-स्तरीय फ़ंक्शन। इसका क्या मतलब है
उपयोगकर्ता का कहना है कि सिस्टम के सभी डिवाइस हेल्पर्स के पास सभी ASCII ट्रेस विधियां होंगी
उपलब्ध; और यदि सभी डिवाइस हैं तो ये विधियां सभी डिवाइसों पर एक ही तरह से काम करेंगी
लागू करने के EnablAsciiआंतरिक सही ढंग से।

तरीके
शून्य EnableAscii (std::string उपसर्ग, Ptr और, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAscii (Ptr स्ट्रीम, पीटीआर रा);

शून्य EnableAscii (std::string उपसर्ग, std::string ndName, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAscii (Ptr स्ट्रीम, std::string ndName);

शून्य EnableAscii (std::string उपसर्ग, NetDeviceContainer d);
शून्य EnableAscii (Ptr स्ट्रीम, NetDeviceContainer d);

शून्य EnableAscii (std::string उपसर्ग, NodeContainer n);
शून्य EnableAscii (Ptr स्ट्रीम, नोडकंटेनर एन);

शून्य EnableAsciiAll (std::string उपसर्ग);
शून्य EnableAsciiAll (Ptr धारा);

शून्य EnableAscii (std::string prefix, uint32_t nodeid, uint32_t डिवाइसआईडी, बूल स्पष्टफाइलनाम);
शून्य EnableAscii (Ptr स्ट्रीम, uint32_t नोडिड, uint32_t डिवाइसआईडी);

आपको कक्षा के लिए एपीआई दस्तावेज़ीकरण का अध्ययन करने के लिए प्रोत्साहित किया जाता है AsciiTraceHelperForDevice सेवा मेरे
इन विधियों का विवरण प्राप्त करें; लेकिन संक्षेप में बताएं...

· ASCII ट्रेसिंग के लिए PCAP की तुलना में दोगुनी विधियाँ उपलब्ध हैं
अनुरेखण ऐसा इसलिए है, क्योंकि पीसीएपी-शैली मॉडल के अलावा जहां प्रत्येक से निशान मिलते हैं
अद्वितीय नोड/डिवाइस जोड़ी को एक अद्वितीय फ़ाइल में लिखा जाता है, हम एक मॉडल का समर्थन करते हैं जिसमें ट्रेस
कई नोड/डिवाइस जोड़े की जानकारी एक सामान्य फ़ाइल में लिखी जाती है। इसका मतलब यह है कि
- - फ़ाइल नाम निर्माण तंत्र को एक तंत्र द्वारा प्रतिस्थापित किया जाता है
एक सामान्य फ़ाइल का संदर्भ लें; और सभी को अनुमति देने के लिए एपीआई विधियों की संख्या दोगुनी कर दी गई है
संयोजन।

· पीसीएपी ट्रेसिंग की तरह, आप किसी विशेष (नोड, नेट-डिवाइस) पर एएससीआईआई ट्रेसिंग सक्षम कर सकते हैं
एक प्रदान करके जोड़ी पीटीआर एक को Ascii सक्षम करें तरीका। पीटीआर निहित है
चूंकि नेट डिवाइस बिल्कुल एक नोड से संबंधित होना चाहिए। उदाहरण के लिए,

पीटीआर रा;
...
helper.EnableAscii ("उपसर्ग", एनडी);

· पहले चार तरीकों में एक डिफ़ॉल्ट पैरामीटर भी शामिल है जिसे कहा जाता है स्पष्टफ़ाइलनाम कि
पीसीएपी मामले में समकक्ष मापदंडों के समान कार्य करें।

इस मामले में, ASCII ट्रेस फ़ाइल में कोई ट्रेस संदर्भ नहीं लिखे गए हैं क्योंकि वे होंगे
अनावश्यक। सिस्टम उन्हीं नियमों का उपयोग करके बनाए जाने वाले फ़ाइल नाम को चुनेगा
पीसीएपी अनुभाग में वर्णित है, सिवाय इसके कि फ़ाइल में प्रत्यय होगा .tr के बजाय
.pcap.

· यदि आप एक से अधिक नेट डिवाइस पर ASCII ट्रेसिंग सक्षम करना चाहते हैं और सभी ट्रेस भेजना चाहते हैं
किसी एकल फ़ाइल के लिए, आप किसी एकल फ़ाइल को संदर्भित करने के लिए किसी ऑब्जेक्ट का उपयोग करके भी ऐसा कर सकते हैं।
हम इसे ऊपर "cwnd" उदाहरण में पहले ही देख चुके हैं:

पीटीआर nd1;
पीटीआर nd2;
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
हेल्पर.EnableAscii (स्ट्रीम, एनडी1);
हेल्पर.EnableAscii (स्ट्रीम, एनडी2);

इस मामले में, संदर्भों का पता लगाएं रहे ASCII ट्रेस फ़ाइल में लिखा गया है क्योंकि वे आवश्यक हैं
दो उपकरणों से निशानों को स्पष्ट करने के लिए। ध्यान दें कि चूंकि उपयोगकर्ता पूरी तरह से है
फ़ाइल नाम निर्दिष्ट करते हुए, स्ट्रिंग में शामिल होना चाहिए ,ट्र स्थिरता के लिए प्रत्यय.

· आप एक विशेष (नोड, नेट-डिवाइस) जोड़ी पर ASCII ट्रेसिंग को सक्षम कर सकते हैं
एसटीडी :: स्ट्रिंग किसी ऑब्जेक्ट नाम सेवा स्ट्रिंग का प्रतिनिधित्व करना Pcap सक्षम करें तरीका।
पीटीआर नाम स्ट्रिंग से ऊपर देखा जाता है. फिर से, तब से निहित है
नामित नेट डिवाइस बिल्कुल एक नोड से संबंधित होना चाहिए। उदाहरण के लिए,

नाम::जोड़ें ("क्लाइंट"...);
नाम::जोड़ें ("क्लाइंट/eth0"...);
नाम::जोड़ें ("सर्वर"...);
नाम::जोड़ें ("सर्वर/eth0"...);
...
helper.EnableAscii ("उपसर्ग", "क्लाइंट/eth0");
helper.EnableAscii ("उपसर्ग", "सर्वर/eth0");

इसके परिणामस्वरूप ``prefix-client-eth0.tr`` और नामक दो फ़ाइलें प्राप्त होंगी
``prefix-server-eth0.tr`` प्रत्येक डिवाइस के लिए निशान के साथ
संबंधित ट्रेस फ़ाइल। चूँकि सभी ``EnableAscii`` कार्य करते हैं
स्ट्रीम रैपर लेने के लिए अतिभारित हैं, आप उस फॉर्म का उपयोग कर सकते हैं
कुंआ::

नाम::जोड़ें ("क्लाइंट"...);
नाम::जोड़ें ("क्लाइंट/eth0"...);
नाम::जोड़ें ("सर्वर"...);
नाम::जोड़ें ("सर्वर/eth0"...);
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
helper.EnableAscii (स्ट्रीम, "क्लाइंट/eth0");
helper.EnableAscii (स्ट्रीम, "सर्वर/eth0");

इसके परिणामस्वरूप एकल ट्रेस फ़ाइल कहलाएगी ट्रेस-फ़ाइल-नाम.tr जिसमें सब कुछ शामिल है
दोनों डिवाइसों के लिए इवेंट ट्रेस करें। घटनाओं को ट्रेस संदर्भ द्वारा स्पष्ट किया जाएगा
तार।

· आप एक प्रदान करके (नोड, नेट-डिवाइस) जोड़े के संग्रह पर ASCII ट्रेसिंग सक्षम कर सकते हैं
नेटडिवाइसकंटेनर। प्रत्येक के लिए नेटडिवाइस कंटेनर में प्रकार की जाँच की जाती है। प्रत्येक के लिए
उचित प्रकार का उपकरण (उसी प्रकार का जैसा उपकरण सहायक द्वारा प्रबंधित किया जाता है), ट्रेसिंग है
सक्षम. फिर से, अंतर्निहित है क्योंकि पाया गया नेट डिवाइस अवश्य ही संबंधित होना चाहिए
बिल्कुल एक नोड. उदाहरण के लिए,

NetDeviceContainer d = ...;
...
helper.EnableAscii ("उपसर्ग", डी);

इसके परिणामस्वरूप कई ASCII ट्रेस फ़ाइलें बनाई जाएंगी,
जिनमें से प्रत्येक `` का अनुसरण करता है - - .tr``
सम्मेलन।

सभी निशानों को एक फ़ाइल में संयोजित करना उदाहरणों की तरह ही पूरा किया जाता है
ऊपर:

NetDeviceContainer d = ...;
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
हेल्पर.EnableAscii (स्ट्रीम, डी);

· आप एक प्रदान करके (नोड, नेट-डिवाइस) जोड़े के संग्रह पर ASCII ट्रेसिंग सक्षम कर सकते हैं
नोडकंटेनर. में प्रत्येक नोड के लिए नोडकंटेनर यह संलग्न है नेटडिवाइसेस पुनरावृत्त हैं.
प्रत्येक के लिए नेटडिवाइस कंटेनर में प्रत्येक नोड से जुड़ा हुआ, उस डिवाइस का प्रकार है
जाँच की गई. उचित प्रकार के प्रत्येक डिवाइस के लिए (उसी प्रकार का जो डिवाइस द्वारा प्रबंधित किया जाता है
सहायक), ट्रेसिंग सक्षम है।

नोडकंटेनर एन;
...
helper.EnableAscii ("उपसर्ग", n);

इसके परिणामस्वरूप कई ASCII ट्रेस फ़ाइलें बनाई जाएंगी, जिनमें से प्रत्येक निम्नानुसार होंगी
la - आईडी>- आईडी>.tr सम्मेलन। सभी निशानों को एक में मिलाना
एकल फ़ाइल उपरोक्त उदाहरणों के समान ही पूरी की जाती है।

· आप नोड आईडी और डिवाइस आईडी के आधार पर भी पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
स्पष्ट PTR. सिस्टम में प्रत्येक नोड में एक पूर्णांक नोड आईडी होती है और प्रत्येक डिवाइस जुड़ा होता है
एक नोड में एक पूर्णांक डिवाइस आईडी होती है।

helper.EnableAscii ("उपसर्ग", 21, 1);

बेशक, जैसा कि ऊपर दिखाया गया है, निशानों को एक फ़ाइल में जोड़ा जा सकता है।

· अंत में, आप सिस्टम में सभी उपकरणों के लिए एक ही प्रकार से पीसीएपी ट्रेसिंग सक्षम कर सकते हैं
जैसा कि डिवाइस सहायक द्वारा प्रबंधित किया जाता है।

helper.EnableAsciiAll ("उपसर्ग");

इसके परिणामस्वरूप अनेक ASCII ट्रेस फ़ाइलें बनाई जाएंगी, प्रत्येक डिवाइस के लिए एक
सहायक द्वारा प्रबंधित प्रकार की प्रणाली में। ये सभी फ़ाइलें अनुसरण करेंगी
- आईडी>- आईडी>.tr सम्मेलन। सभी निशानों को एक में मिलाना
फ़ाइल उपरोक्त उदाहरणों के समान ही पूरी की गई है।

फ़ाइल नाम
उपरोक्त उपसर्ग-शैली विधि विवरण में निहित पूर्ण का निर्माण है
कार्यान्वयन विधि द्वारा फ़ाइल नाम। परंपरा के अनुसार, ASCII में पता चलता है एनएस- 3 प्रणाली
स्वरूप के हैं - आईडी>- आईडी>.tr

जैसा कि पहले उल्लेख किया गया है, सिस्टम में प्रत्येक नोड में एक सिस्टम-निर्दिष्ट नोड आईडी होगी; और
प्रत्येक डिवाइस में उसके नोड के सापेक्ष एक इंटरफ़ेस इंडेक्स (जिसे डिवाइस आईडी भी कहा जाता है) होगा।
डिफ़ॉल्ट रूप से, फिर, पहले पर ट्रेसिंग को सक्षम करने के परिणामस्वरूप एक ASCII ट्रेस फ़ाइल बनाई जाती है
नोड 21 का उपकरण, उपसर्ग "उपसर्ग" का उपयोग करते हुए होगा उपसर्ग-21-1.tr.

आप हमेशा इसका उपयोग कर सकते हैं एनएस- 3 इसे और अधिक स्पष्ट करने के लिए ऑब्जेक्ट नाम सेवा। उदाहरण के लिए, यदि
आप परिणामी नोड 21 को "सर्वर" नाम निर्दिष्ट करने के लिए ऑब्जेक्ट नाम सेवा का उपयोग करते हैं
ASCII ट्रेस फ़ाइल नाम स्वचालित रूप से बन जाएगा, उपसर्ग-सर्वर-1.tr और यदि आप असाइन भी करते हैं
डिवाइस का नाम "eth0", आपका ASCII ट्रेस फ़ाइल नाम स्वचालित रूप से इसे ले लेगा
और बुलाया जाए उपसर्ग-सर्वर-eth0.tr.

कई विधियों में एक डिफ़ॉल्ट पैरामीटर होता है जिसे कहा जाता है स्पष्टफ़ाइलनाम. जब सेट किया जाए
सच है, यह पैरामीटर स्वचालित फ़ाइल नाम पूर्णता तंत्र को अक्षम करता है और आपको अनुमति देता है
एक स्पष्ट फ़ाइल नाम बनाने के लिए. यह विकल्प केवल उन विधियों में उपलब्ध है जो a लेते हैं
उपसर्ग करें और एकल डिवाइस पर ट्रेसिंग सक्षम करें।

प्रोटोकॉल सहायकों
पीसीएपी
इनका लक्ष्य मिश्रण इसका उद्देश्य सुसंगत पीसीएपी ट्रेस सुविधा को जोड़ना आसान बनाना है
प्रोटोकॉल. हम चाहते हैं कि पीसीएपी ट्रेसिंग के सभी विभिन्न फ्लेवर सभी में समान रूप से काम करें
प्रोटोकॉल, इसलिए इन सहायकों की विधियाँ स्टैक हेल्पर्स द्वारा विरासत में मिली हैं। पर एक नज़र डालें
src/network/helper/trace-helper.h यदि आप देखते समय चर्चा का अनुसरण करना चाहते हैं
असली कोड.

इस अनुभाग में हम प्रोटोकॉल पर लागू होने वाली विधियों का वर्णन करेंगे आईपीवी4। सेवा मेरे
समान प्रोटोकॉल में निशान निर्दिष्ट करें, बस उचित प्रकार को प्रतिस्थापित करें। उदाहरण के लिए,
का उपयोग पीटीआर ए के बजाए पीटीआर और कॉल करें PcapIpv6 सक्षम करें के बजाय PcapIpv4 सक्षम करें.

कक्षा PcapHelperForIpv4 पीसीएपी ट्रेसिंग का उपयोग करने के लिए उच्च स्तरीय कार्यक्षमता प्रदान करता है
में आईपीवी4 शिष्टाचार। इन विधियों को सक्षम करने वाले प्रत्येक प्रोटोकॉल सहायक को एक एकल कार्यान्वित करना होगा
वर्चुअल विधि इस वर्ग से विरासत में मिली है। के लिए अलग से क्रियान्वयन होगा
आईपीवी6उदाहरण के लिए, लेकिन एकमात्र अंतर विधि के नाम और हस्ताक्षर में होगा।
वर्ग को स्पष्ट करने के लिए अलग-अलग विधि नामों की आवश्यकता होती है आईपीवी4 से आईपीवी6 जो दोनों हैं
वर्ग से व्युत्पन्न वस्तु, और विधियाँ जो समान हस्ताक्षर साझा करती हैं।

आभासी शून्य EnablePcapIpv4Internal (std::string उपसर्ग,
पीटीआर आईपीवी4,
uint32_t इंटरफ़ेस,
बूल स्पष्टफ़ाइलनाम) = 0;

इस पद्धति का हस्ताक्षर प्रोटोकॉल और इंटरफ़ेस-केंद्रित दृश्य को दर्शाता है
इस स्तर पर स्थिति सभी सार्वजनिक विधियाँ वर्ग से विरासत में मिली हैं PcapHelperForIpv4
इस एकल डिवाइस-निर्भर कार्यान्वयन विधि को कॉल करना कम करें। उदाहरण के लिए,
निम्नतम स्तर की पीसीएपी विधि,

शून्य EnablePcapIpv4 (std::string उपसर्ग, Ptr आईपीवी4, uint4_t इंटरफ़ेस, बूल स्पष्टफ़ाइलनाम = गलत);

के डिवाइस कार्यान्वयन को कॉल करेगा PcapIpv4आंतरिक सक्षम करें सीधे. बाकी सब जनता
अतिरिक्त उपयोगकर्ता-स्तर प्रदान करने के लिए पीसीएपी ट्रेसिंग विधियां इस कार्यान्वयन पर आधारित हैं
कार्यक्षमता. उपयोगकर्ता के लिए इसका मतलब यह है कि सिस्टम में सभी प्रोटोकॉल सहायक हैं
सभी पीसीएपी ट्रेस विधियां उपलब्ध होंगी; और ये सभी विधियाँ काम करेंगी
यदि सहायक लागू करता है तो प्रोटोकॉल में भी इसी तरह PcapIpv4आंतरिक सक्षम करें सही ढंग से।

तरीके
इन विधियों को नोड- और के साथ एक-से-एक पत्राचार में डिज़ाइन किया गया है
नेटडिवाइस- डिवाइस संस्करणों के केंद्रित संस्करण। नोड के बजाय और नेटडिवाइस जोड़ा
बाधाएँ, हम प्रोटोकॉल और इंटरफ़ेस बाधाओं का उपयोग करते हैं।

ध्यान दें कि डिवाइस संस्करण की तरह ही, छह विधियाँ हैं:

शून्य EnablePcapIpv4 (std::string उपसर्ग, Ptr आईपीवी4, uint4_t इंटरफ़ेस, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnablePcapIpv4 (std::string prefix, std::string ipv4Name, uint32_t इंटरफ़ेस, bool exploredFilename = false);
शून्य EnablePcapIpv4 (std::string prefix, Ipv4InterfaceContainer c);
शून्य EnablePcapIpv4 (std::string prefix, NodeContainer n);
शून्य EnablePcapIpv4 (std::string prefix, uint32_t nodeid, uint32_t इंटरफ़ेस, bool exploredFilename);
शून्य EnablePcapIpv4All (std::string उपसर्ग);

आपको कक्षा के लिए एपीआई दस्तावेज़ीकरण का अध्ययन करने के लिए प्रोत्साहित किया जाता है PcapHelperForIpv4 खोजने के लिए
इन विधियों का विवरण; लेकिन संक्षेप में बताएं...

· आप एक विशेष प्रोटोकॉल/इंटरफ़ेस जोड़ी पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
पीटीआर और इंटरफेस एक को Pcap सक्षम करें तरीका। उदाहरण के लिए,

पीटीआर ipv4 = नोड-> गेटऑब्जेक्ट ();
...
हेल्पर.EnablePcapIpv4 ("उपसर्ग", ipv4, 0);

· आप एक विशेष नोड/नेट-डिवाइस जोड़ी पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
एसटीडी :: स्ट्रिंग किसी ऑब्जेक्ट नाम सेवा स्ट्रिंग का प्रतिनिधित्व करना Pcap सक्षम करें तरीका।
पीटीआर नाम स्ट्रिंग से ऊपर देखा जाता है. उदाहरण के लिए,

नाम::जोड़ें ("सर्वरआईपीवी4"...);
...
helper.EnablePcapIpv4 ("उपसर्ग", "serverIpv4", 1);

· आप एक प्रदान करके प्रोटोकॉल/इंटरफ़ेस जोड़े के संग्रह पर पीसीएपी ट्रेसिंग सक्षम कर सकते हैं
IPv4InterfaceContainer। प्रत्येक के लिए आईपीवी4 / कंटेनर में इंटरफ़ेस जोड़ी प्रोटोकॉल
प्रकार की जाँच की जाती है। उचित प्रकार के प्रत्येक प्रोटोकॉल के लिए (उसी प्रकार का जिसे प्रबंधित किया जाता है
डिवाइस हेल्पर), संबंधित इंटरफ़ेस के लिए ट्रेसिंग सक्षम है। उदाहरण के लिए,

नोडकंटेनर नोड्स;
...
NetDeviceContainer डिवाइस = डिवाइस हेल्पर.इंस्टॉल (नोड्स);
...
आईपीवी4एड्रेसहेल्पर आईपीवी4;
आईपीवी4.सेटबेस ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer इंटरफ़ेस = ipv4.Assign (डिवाइस);
...
helper.EnablePcapIpv4 ("उपसर्ग", इंटरफ़ेस);

· आप प्रोटोकॉल/इंटरफ़ेस जोड़े के संग्रह पर पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
नोडकंटेनर. में प्रत्येक नोड के लिए नोडकंटेनर उपयुक्त प्रोटोकॉल मिल गया है।
प्रत्येक प्रोटोकॉल के लिए, इसके इंटरफेस की गणना की जाती है और परिणामी पर ट्रेसिंग सक्षम की जाती है
जोड़े। उदाहरण के लिए,

नोडकंटेनर एन;
...
helper.EnablePcapIpv4 ("उपसर्ग", n);

· आप नोड आईडी और इंटरफ़ेस के आधार पर भी पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं। इस में
मामले में, नोड-आईडी का अनुवाद किया गया है पीटीआर और उपयुक्त प्रोटोकॉल देखा जाता है
नोड में. परिणामी प्रोटोकॉल और इंटरफ़ेस का उपयोग परिणाम को निर्दिष्ट करने के लिए किया जाता है
ट्रेस स्रोत।

हेल्पर.EnablePcapIpv4 ("उपसर्ग", 21, 1);

· अंत में, आप सिस्टम में संबंधित सभी इंटरफेस के लिए पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं
प्रोटोकॉल उसी प्रकार का है जो डिवाइस हेल्पर द्वारा प्रबंधित किया जाता है।

helper.EnablePcapIpv4All ("उपसर्ग");

फ़ाइल नाम
उपरोक्त सभी विधि विवरणों में पूर्ण का निर्माण निहित है
कार्यान्वयन विधि द्वारा फ़ाइल नाम। परंपरा के अनुसार, उपकरणों के लिए पीसीएपी निशान लिए जाते हैं
la एनएस- 3 प्रणाली इस प्रकार है " - - .pcap"। के मामले में
प्रोटोकॉल ट्रेस, प्रोटोकॉल और के बीच एक-से-एक पत्राचार होता है नोड्स। इस
क्योंकि प्रोटोकॉल वस्तुएँ को एकत्रित किया जाता है आसंधि वस्तुएँ. चूँकि कोई वैश्विक नहीं है
सिस्टम में प्रोटोकॉल आईडी, हम फ़ाइल नामकरण में संबंधित नोड आईडी का उपयोग करते हैं। इसलिए
स्वचालित रूप से चुने गए ट्रेस फ़ाइल नामों में फ़ाइल नाम टकराव की संभावना है।
इस कारण से, प्रोटोकॉल ट्रेस के लिए फ़ाइल नाम कन्वेंशन बदल दिया गया है।

जैसा कि पहले उल्लेख किया गया है, सिस्टम में प्रत्येक नोड में सिस्टम द्वारा निर्दिष्ट नोड आईडी होगी।
चूँकि प्रोटोकॉल इंस्टेंसेस और नोड इंस्टेंसेस के बीच एक-से-एक पत्राचार होता है
हम नोड आईडी का उपयोग करते हैं। प्रत्येक इंटरफ़ेस में उसके प्रोटोकॉल के सापेक्ष एक इंटरफ़ेस आईडी होती है। हम उपयोग करते हैं
सम्मेलन " -एन -मैं .pcap" ट्रेस फ़ाइल नामकरण के लिए
प्रोटोकॉल सहायक.

इसलिए, डिफ़ॉल्ट रूप से, ट्रेसिंग को सक्षम करने के परिणामस्वरूप एक पीसीएपी ट्रेस फ़ाइल बनाई जाती है
नोड 1 के आईपीवी4 प्रोटोकॉल का इंटरफ़ेस 21 उपसर्ग "उपसर्ग" का उपयोग करेगा
"उपसर्ग-n21-i1.pcap"।

आप हमेशा इसका उपयोग कर सकते हैं एनएस- 3 इसे और अधिक स्पष्ट करने के लिए ऑब्जेक्ट नाम सेवा। उदाहरण के लिए, यदि
आप Ptr को "serverIpv4" नाम निर्दिष्ट करने के लिए ऑब्जेक्ट नाम सेवा का उपयोग करते हैं नोड पर
21, परिणामी पीसीएपी ट्रेस फ़ाइल नाम स्वचालित रूप से बन जाएगा,
"उपसर्ग-nserverIpv4-i1.pcap"।

कई विधियों में एक डिफ़ॉल्ट पैरामीटर होता है जिसे कहा जाता है स्पष्टफ़ाइलनाम. जब सेट किया जाए
सच है, यह पैरामीटर स्वचालित फ़ाइल नाम पूर्णता तंत्र को अक्षम करता है और आपको अनुमति देता है
एक स्पष्ट फ़ाइल नाम बनाने के लिए. यह विकल्प केवल उन विधियों में उपलब्ध है जो a लेते हैं
उपसर्ग करें और एकल डिवाइस पर ट्रेसिंग सक्षम करें।

ASCII
ASCII ट्रेस हेल्पर्स का व्यवहार काफी हद तक PCAP मामले के समान है। एक ले लो
की ओर देखें src/network/helper/trace-helper.h यदि आप चर्चा का अनुसरण करना चाहते हैं
वास्तविक कोड देख रहे हैं।

इस अनुभाग में हम प्रोटोकॉल पर लागू होने वाली विधियों का वर्णन करेंगे आईपीवी4। सेवा मेरे
समान प्रोटोकॉल में निशान निर्दिष्ट करें, बस उचित प्रकार को प्रतिस्थापित करें। उदाहरण के लिए,
का उपयोग पीटीआर ए के बजाए पीटीआर और कॉल करें AsciiIpv6 सक्षम करें के बजाय
AsciiIpv4 सक्षम करें.

कक्षा AsciiTraceHelperForIpv4 ASCII का उपयोग करने के लिए उच्च स्तरीय कार्यक्षमता जोड़ता है
एक प्रोटोकॉल सहायक का पता लगाना। प्रत्येक प्रोटोकॉल जो इन विधियों को सक्षम बनाता है उसे लागू करना होगा
इस वर्ग से विरासत में मिली एकल आभासी विधि।

वर्चुअल शून्य EnableAsciiIpv4Internal (Ptr धारा,
std::स्ट्रिंग उपसर्ग,
पीटीआर आईपीवी4,
uint32_t इंटरफ़ेस,
बूल स्पष्टफ़ाइलनाम) = 0;

इस पद्धति का हस्ताक्षर प्रोटोकॉल- और इंटरफ़ेस-केंद्रित दृश्य को दर्शाता है
इस स्तर पर स्थिति; और यह तथ्य भी कि सहायक किसी साझा को लिख सकता है
आउटपुट स्ट्रीम. सभी सार्वजनिक विधियाँ वर्ग से विरासत में मिली हैं
PcapAndAsciiTraceHelperForIpv4 इस एकल डिवाइस को आश्रित कहना कम करें
कार्यान्वयन विधि. उदाहरण के लिए, निम्नतम स्तर की ASCII ट्रेस विधियाँ,

शून्य EnableAsciiIpv4 (std::string उपसर्ग, Ptr आईपीवी4, uint4_t इंटरफ़ेस, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, पीटीआर ipv4, uint4_t इंटरफ़ेस);

के डिवाइस कार्यान्वयन को कॉल करेगा AsciiIpv4आंतरिक सक्षम करें सीधे, या तो प्रदान करना
उपसर्ग या धारा. अन्य सभी सार्वजनिक ASCII ट्रेसिंग विधियाँ इन पर निर्मित होंगी
अतिरिक्त उपयोगकर्ता-स्तरीय कार्यक्षमता प्रदान करने के लिए निम्न-स्तरीय फ़ंक्शन। इसका क्या मतलब है
उपयोगकर्ता का कहना है कि सिस्टम के सभी डिवाइस हेल्पर्स के पास सभी ASCII ट्रेस विधियां होंगी
उपलब्ध; और ये सभी विधियाँ सभी प्रोटोकॉल में समान तरीके से काम करेंगी यदि
प्रोटोकॉल लागू होते हैं EnablAsciiIpv4आंतरिक सही ढंग से।

तरीके
शून्य EnableAsciiIpv4 (std::string उपसर्ग, Ptr आईपीवी4, uint4_t इंटरफ़ेस, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, पीटीआर ipv4, uint4_t इंटरफ़ेस);

शून्य EnableAsciiIpv4 (std::string उपसर्ग, std::string ipv4Name, uint32_t इंटरफ़ेस, बूल स्पष्टफ़ाइलनाम = गलत);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, std::string ipv4Name, uint32_t इंटरफ़ेस);

शून्य EnableAsciiIpv4 (std::string prefix, Ipv4InterfaceContainer c);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, Ipv4InterfaceContainer c);

शून्य EnableAsciiIpv4 (std::string उपसर्ग, NodeContainer n);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, नोडकंटेनर एन);

शून्य EnableAsciiIpv4All (std::string उपसर्ग);
शून्य EnableAsciiIpv4All (Ptr धारा);

शून्य EnableAsciiIpv4 (std::string prefix, uint32_t nodeid, uint32_t डिवाइसआईडी, बूल स्पष्टफाइलनाम);
शून्य EnableAsciiIpv4 (Ptr स्ट्रीम, uint32_t नोडिड, uint32_t इंटरफ़ेस);

आपको कक्षा के लिए एपीआई दस्तावेज़ीकरण का अध्ययन करने के लिए प्रोत्साहित किया जाता है PcapAndAsciiHelperForIpv4 सेवा मेरे
इन विधियों का विवरण प्राप्त करें; लेकिन संक्षेप में बताएं...

· ASCII ट्रेसिंग के लिए PCAP की तुलना में दोगुनी विधियाँ उपलब्ध हैं
अनुरेखण ऐसा इसलिए है, क्योंकि पीसीएपी-शैली मॉडल के अलावा जहां प्रत्येक से निशान मिलते हैं
अद्वितीय प्रोटोकॉल/इंटरफ़ेस जोड़ी को एक अद्वितीय फ़ाइल में लिखा जाता है, हम इसमें एक मॉडल का समर्थन करते हैं
कई प्रोटोकॉल/इंटरफ़ेस जोड़े के लिए ट्रेस जानकारी एक सामान्य फ़ाइल में लिखी जाती है। यह
इसका मतलब है कि -एन - फ़ाइल नाम निर्माण तंत्र है
एक सामान्य फ़ाइल को संदर्भित करने के लिए एक तंत्र द्वारा प्रतिस्थापित; और एपीआई तरीकों की संख्या है
सभी संयोजनों की अनुमति देने के लिए दोगुना कर दिया गया।

· पीसीएपी ट्रेसिंग की तरह, आप किसी विशेष प्रोटोकॉल/इंटरफ़ेस पर ASCII ट्रेसिंग को सक्षम कर सकते हैं
एक प्रदान करके जोड़ी पीटीआर और एक इंटरफेस एक को Ascii सक्षम करें तरीका। उदाहरण के लिए,

पीटीआर आईपीवी4;
...
हेल्पर.EnableAsciiIpv4 ("उपसर्ग", आईपीवी4, 1);

इस मामले में, ASCII ट्रेस फ़ाइल में कोई ट्रेस संदर्भ नहीं लिखे गए हैं क्योंकि वे होंगे
अनावश्यक। सिस्टम उन्हीं नियमों का उपयोग करके बनाए जाने वाले फ़ाइल नाम को चुनेगा
पीसीएपी अनुभाग में वर्णित है, सिवाय इसके कि फ़ाइल में इसके बजाय प्रत्यय ".tr" होगा
".pcap" का।

· यदि आप एक से अधिक इंटरफ़ेस पर ASCII ट्रेसिंग सक्षम करना चाहते हैं और सभी ट्रेस भेजना चाहते हैं
किसी एकल फ़ाइल के लिए, आप किसी एकल फ़ाइल को संदर्भित करने के लिए किसी ऑब्जेक्ट का उपयोग करके भी ऐसा कर सकते हैं।
उपरोक्त "cwnd" उदाहरण में हमारे पास पहले से ही कुछ ऐसा ही है:

पीटीआर प्रोटोकॉल4 = नोड1->गेटऑब्जेक्ट ();
पीटीआर प्रोटोकॉल4 = नोड2->गेटऑब्जेक्ट ();
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
हेल्पर.EnableAsciiIpv4 (स्ट्रीम, प्रोटोकॉल1, 1);
हेल्पर.EnableAsciiIpv4 (स्ट्रीम, प्रोटोकॉल2, 1);

इस मामले में, ट्रेस संदर्भ ASCII ट्रेस फ़ाइल में लिखे जाते हैं क्योंकि वे आवश्यक हैं
दो इंटरफेस से निशानों को स्पष्ट करने के लिए। ध्यान दें कि चूंकि उपयोगकर्ता पूरी तरह से है
फ़ाइल नाम निर्दिष्ट करते हुए, स्ट्रिंग में स्थिरता के लिए ",tr" शामिल होना चाहिए।

· आप एक प्रदान करके किसी विशेष प्रोटोकॉल पर ASCII ट्रेसिंग को सक्षम कर सकते हैं एसटीडी :: स्ट्रिंग
किसी ऑब्जेक्ट नाम सेवा स्ट्रिंग का प्रतिनिधित्व करना Pcap सक्षम करें तरीका। पीटीआर is
नाम स्ट्रिंग से ऊपर देखा. परिणामी फ़ाइलनामों में तब से अंतर्निहित है
प्रोटोकॉल इंस्टेंसेस और नोड्स के बीच एक-से-एक पत्राचार होता है, उदाहरण के लिए,

नाम::जोड़ें ("नोड1आईपीवी4"...);
नाम::जोड़ें ("नोड2आईपीवी4"...);
...
हेल्पर.EnableAsciiIpv4 ("उपसर्ग", "नोड1आईपीवी4", 1);
हेल्पर.EnableAsciiIpv4 ("उपसर्ग", "नोड2आईपीवी4", 1);

इसके परिणामस्वरूप "prefix-nnode1Ipv4-i1.tr" नामक दो फ़ाइलें प्राप्त होंगी
संबंधित ट्रेस फ़ाइल में प्रत्येक इंटरफ़ेस के लिए ट्रेस के साथ "prefix-nnode2Ipv4-i1.tr"।
चूंकि स्ट्रीम रैपर लेने के लिए सभी EnableAscii फ़ंक्शंस अतिभारित हैं, आप ऐसा कर सकते हैं
उस फॉर्म का भी उपयोग करें:

नाम::जोड़ें ("नोड1आईपीवी4"...);
नाम::जोड़ें ("नोड2आईपीवी4"...);
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
हेल्पर.EnableAsciiIpv4 (स्ट्रीम, "नोड1आईपीवी4", 1);
हेल्पर.EnableAsciiIpv4 (स्ट्रीम, "नोड2आईपीवी4", 1);

इसके परिणामस्वरूप "trace-file-name.tr" नामक एक एकल ट्रेस फ़ाइल बनेगी जिसमें सभी शामिल होंगे
दोनों इंटरफ़ेस के लिए ट्रेस ईवेंट का। घटनाओं को ट्रेस द्वारा स्पष्ट किया जाएगा
संदर्भ तार.

· आप एक प्रदान करके प्रोटोकॉल/इंटरफ़ेस जोड़े के संग्रह पर ASCII ट्रेसिंग सक्षम कर सकते हैं
IPv4InterfaceContainer. उचित प्रकार के प्रत्येक प्रोटोकॉल के लिए (जैसा है वैसा ही प्रकार)।
डिवाइस सहायक द्वारा प्रबंधित), संबंधित इंटरफ़ेस के लिए ट्रेसिंग सक्षम है।
फिर से, अंतर्निहित है क्योंकि प्रत्येक के बीच एक-से-एक पत्राचार होता है
प्रोटोकॉल और उसका नोड. उदाहरण के लिए,

नोडकंटेनर नोड्स;
...
NetDeviceContainer डिवाइस = डिवाइस हेल्पर.इंस्टॉल (नोड्स);
...
आईपीवी4एड्रेसहेल्पर आईपीवी4;
आईपीवी4.सेटबेस ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer इंटरफ़ेस = ipv4.Assign (डिवाइस);
...
...
helper.EnableAsciiIpv4 ("उपसर्ग", इंटरफ़ेस);

इसके परिणामस्वरूप कई ASCII ट्रेस फ़ाइलें बनाई जाएंगी, जिनमें से प्रत्येक निम्नानुसार होंगी
-एन -मैं .tr सम्मेलन। सभी निशानों को एक में मिलाना
एकल फ़ाइल उपरोक्त उदाहरणों के समान ही पूरी की जाती है:

नोडकंटेनर नोड्स;
...
NetDeviceContainer डिवाइस = डिवाइस हेल्पर.इंस्टॉल (नोड्स);
...
आईपीवी4एड्रेसहेल्पर आईपीवी4;
आईपीवी4.सेटबेस ("10.1.1.0", "255.255.255.0");
Ipv4InterfaceContainer इंटरफ़ेस = ipv4.Assign (डिवाइस);
...
पीटीआर स्ट्रीम = asciiTraceHelper.CreateFileStream ("trace-file-name.tr");
...
हेल्पर.EnableAsciiIpv4 (स्ट्रीम, इंटरफेस);

· आप एक प्रदान करके प्रोटोकॉल/इंटरफ़ेस जोड़े के संग्रह पर ASCII ट्रेसिंग सक्षम कर सकते हैं
नोडकंटेनर. में प्रत्येक नोड के लिए नोडकंटेनर उपयुक्त प्रोटोकॉल मिल गया है।
प्रत्येक प्रोटोकॉल के लिए, इसके इंटरफेस की गणना की जाती है और परिणामी पर ट्रेसिंग सक्षम की जाती है
जोड़े। उदाहरण के लिए,

नोडकंटेनर एन;
...
helper.EnableAsciiIpv4 ("उपसर्ग", n);

इसके परिणामस्वरूप कई ASCII ट्रेस फ़ाइलें बनाई जाएंगी, जिनमें से प्रत्येक निम्नानुसार होंगी
- - .tr सम्मेलन। सभी निशानों को एक में मिलाना
एकल फ़ाइल उपरोक्त उदाहरणों के समान ही पूरी की जाती है।

· आप नोड आईडी और डिवाइस आईडी के आधार पर भी पीसीएपी ट्रेसिंग को सक्षम कर सकते हैं। इस में
मामले में, नोड-आईडी का अनुवाद किया गया है पीटीआर और उपयुक्त प्रोटोकॉल देखा जाता है
नोड में. परिणामी प्रोटोकॉल और इंटरफ़ेस का उपयोग परिणाम को निर्दिष्ट करने के लिए किया जाता है
ट्रेस स्रोत।

हेल्पर.EnableAsciiIpv4 ("उपसर्ग", 21, 1);

बेशक, जैसा कि ऊपर दिखाया गया है, निशानों को एक फ़ाइल में जोड़ा जा सकता है।

· अंत में, आप सिस्टम में संबंधित सभी इंटरफेस के लिए ASCII ट्रेसिंग को सक्षम कर सकते हैं
प्रोटोकॉल उसी प्रकार का है जो डिवाइस हेल्पर द्वारा प्रबंधित किया जाता है।

helper.EnableAsciiIpv4All ("उपसर्ग");

इसके परिणामस्वरूप अनेक ASCII ट्रेस फ़ाइलें बनाई जाएंगी, प्रत्येक के लिए एक
हेल्पर द्वारा प्रबंधित प्रकार के प्रोटोकॉल से संबंधित सिस्टम में इंटरफ़ेस। के सभी
ये फ़ाइलें अनुसरण करेंगी -एन -मैं
सभी निशानों को एक फ़ाइल में ऊपर दिए गए उदाहरणों की तरह ही पूरा किया जाता है।

फ़ाइल नाम
उपरोक्त उपसर्ग-शैली विधि विवरण में निहित पूर्ण का निर्माण है
कार्यान्वयन विधि द्वारा फ़ाइल नाम। परंपरा के अनुसार, ASCII में पता चलता है एनएस- 3 प्रणाली
रूप के हैं" - - .tr"

जैसा कि पहले उल्लेख किया गया है, सिस्टम में प्रत्येक नोड में सिस्टम द्वारा निर्दिष्ट नोड आईडी होगी।
चूंकि प्रोटोकॉल और नोड्स के बीच एक-से-एक पत्राचार होता है, इसलिए हम नोड-आईडी का उपयोग करते हैं
प्रोटोकॉल पहचान की पहचान करने के लिए। किसी दिए गए प्रोटोकॉल पर प्रत्येक इंटरफ़ेस में एक होगा
इसके प्रोटोकॉल के सापेक्ष इंटरफ़ेस इंडेक्स (जिसे केवल एक इंटरफ़ेस भी कहा जाता है)। डिफ़ॉल्ट रूप से,
फिर, पहले डिवाइस पर ट्रेसिंग को सक्षम करने के परिणामस्वरूप एक ASCII ट्रेस फ़ाइल बनाई गई
नोड 21, उपसर्ग "उपसर्ग" का उपयोग करते हुए, "उपसर्ग-n21-i1.tr" होगा। उपसर्ग का प्रयोग करें
प्रति नोड एकाधिक प्रोटोकॉल को स्पष्ट करें।

आप हमेशा इसका उपयोग कर सकते हैं एनएस- 3 इसे और अधिक स्पष्ट करने के लिए ऑब्जेक्ट नाम सेवा। उदाहरण के लिए, यदि
आप नोड पर प्रोटोकॉल को "serverIpv4" नाम निर्दिष्ट करने के लिए ऑब्जेक्ट नाम सेवा का उपयोग करते हैं
21, और इंटरफ़ेस एक भी निर्दिष्ट करें, जिसके परिणामस्वरूप ASCII ट्रेस फ़ाइल नाम स्वचालित रूप से होगा
बनें, "prefix-nserverIpv4-1.tr"।

कई विधियों में एक डिफ़ॉल्ट पैरामीटर होता है जिसे कहा जाता है स्पष्टफ़ाइलनाम. जब सेट किया जाए
सच है, यह पैरामीटर स्वचालित फ़ाइल नाम पूर्णता तंत्र को अक्षम करता है और आपको अनुमति देता है
एक स्पष्ट फ़ाइल नाम बनाने के लिए. यह विकल्प केवल उन विधियों में उपलब्ध है जो a लेते हैं
उपसर्ग करें और एकल डिवाइस पर ट्रेसिंग सक्षम करें।

सारांश
एनएस- 3 इसमें एक अत्यंत समृद्ध वातावरण शामिल है जो उपयोगकर्ताओं को कई स्तरों पर अनुकूलित करने की अनुमति देता है
सिमुलेशन से किस प्रकार की जानकारी निकाली जा सकती है।

उच्च-स्तरीय सहायक फ़ंक्शन हैं जो उपयोगकर्ताओं को आसानी से संग्रह को नियंत्रित करने की अनुमति देते हैं
बारीक ग्रैन्युलैरिटी के लिए पूर्व-परिभाषित आउटपुट। अनुमति देने के लिए मध्य-स्तरीय सहायक कार्य हैं
जानकारी निकालने और सहेजने के तरीके को अनुकूलित करने के लिए अधिक परिष्कृत उपयोगकर्ता; और वहाँ
विशेषज्ञ उपयोगकर्ताओं को नए और प्रस्तुत करने के लिए सिस्टम को बदलने की अनुमति देने के लिए निम्न-स्तरीय मुख्य कार्य हैं
पहले से निर्यात न की गई जानकारी इस तरह से कि उपयोगकर्ताओं के लिए तुरंत पहुंच योग्य हो जाएगी
उच्च स्तर।

यह एक बहुत व्यापक प्रणाली है, और हमें एहसास है कि विशेष रूप से इसे पचाने के लिए बहुत कुछ है
नए उपयोगकर्ताओं या उन लोगों के लिए जो C++ और इसके मुहावरों से अच्छी तरह परिचित नहीं हैं। हम विचार करते हैं
ट्रेसिंग सिस्टम का एक बहुत ही महत्वपूर्ण हिस्सा है एनएस- 3 और इसलिए उतना ही परिचित होने की सलाह देते हैं
इसके साथ संभव है. संभवतः यही मामला है कि बाकी को समझना एनएस- 3 प्रणाली
एक बार जब आप ट्रेसिंग सिस्टम में महारत हासिल कर लेंगे तो यह काफी सरल हो जाएगा

आंकड़े संग्रह

हमारा अंतिम ट्यूटोरियल अध्याय कुछ घटकों का परिचय देता है जिन्हें इसमें जोड़ा गया था एनएस- 3 संस्करण में
3.18, और वह अभी भी विकासाधीन है। यह ट्यूटोरियल अनुभाग भी एक है
कार्य प्रगति पर है।

अभिप्रेरण
सिमुलेशन चलाने का एक मुख्य बिंदु आउटपुट डेटा उत्पन्न करना है
अनुसंधान के उद्देश्य से या केवल सिस्टम के बारे में जानने के लिए। पिछले अध्याय में, हम
ट्रेसिंग सबसिस्टम और उदाहरण पेश किया छठा.सीसी. जिससे PCAP या ASCII ट्रेस होता है
फ़ाइलें उत्पन्न होती हैं. ये निशान विभिन्न प्रकार का उपयोग करके डेटा विश्लेषण के लिए मूल्यवान हैं
बाहरी उपकरण, और कई उपयोगकर्ताओं के लिए, ऐसा आउटपुट डेटा एकत्र करने का एक पसंदीदा साधन है
डेटा (बाहरी उपकरणों द्वारा विश्लेषण के लिए)।

हालाँकि, ट्रेस फ़ाइल पीढ़ी से अधिक के उपयोग के मामले भी हैं, जिनमें शामिल हैं
इस प्रकार है:

· डेटा का सृजन जो पीसीएपी या एएससीआईआई ट्रेस पर अच्छी तरह से मैप नहीं होता है, जैसे गैर-पैकेट
डेटा (जैसे प्रोटोकॉल स्टेट मशीन ट्रांज़िशन),

· बड़े सिमुलेशन जिनके लिए ट्रेस फ़ाइलें उत्पन्न करने के लिए डिस्क I/O आवश्यकताएं हैं
निषेधात्मक या बोझिल, और

· की जरूरत ऑनलाइन सिमुलेशन के दौरान डेटा में कमी या गणना।
इसका एक अच्छा उदाहरण अनुकरण के लिए समाप्ति की स्थिति को परिभाषित करना, बताना है
इसे कब रोकना है जब इसे एक संकीर्ण-पर्याप्त आत्मविश्वास बनाने के लिए पर्याप्त डेटा प्राप्त हो गया है
कुछ पैरामीटर के अनुमान के आसपास अंतराल।

RSI एनएस- 3 डेटा संग्रह ढांचा इन अतिरिक्त क्षमताओं को प्रदान करने के लिए डिज़ाइन किया गया है
ट्रेस-आधारित आउटपुट से परे। हम अनुशंसा करते हैं कि इस विषय में रुचि रखने वाले पाठक परामर्श लें
la एनएस- 3 इस ढांचे के अधिक विस्तृत उपचार के लिए मैनुअल; यहां, हम संक्षेप में प्रस्तुत करते हैं
कुछ विकासशील क्षमताओं का एक उदाहरण कार्यक्रम।

उदाहरण कोड
ट्यूटोरियल उदाहरण उदाहरण/ट्यूटोरियल/सातवां.सीसी जैसा दिखता है छठा.सीसी उदाहरण हम
कुछ बदलावों को छोड़कर, पहले समीक्षा की गई थी। सबसे पहले, इसे IPv6 के लिए सक्षम किया गया है
कमांड-लाइन विकल्प के साथ समर्थन:

कमांडलाइन सीएमडी;
cmd.AddValue ("useIpv6", "Ipv6 का प्रयोग करें", useV6);
cmd.Parse (argc, argv);

यदि उपयोगकर्ता निर्दिष्ट करता है उपयोगIpv6, विकल्प, प्रोग्राम IPv6 के बजाय IPv4 का उपयोग करके चलाया जाएगा।
RSI मदद विकल्प, सभी पर उपलब्ध है एनएस- 3 प्रोग्राम जो कमांडलाइन ऑब्जेक्ट का समर्थन करते हैं
ऊपर दिखाया गया है, इसे निम्नानुसार लागू किया जा सकता है (कृपया दोहरे उद्धरण चिह्नों के उपयोग पर ध्यान दें):

./waf --run "सातवां --help"

जो उत्पादन करता है:

ns3-dev-सातवां-डिबग [प्रोग्राम तर्क] [सामान्य तर्क]

कार्यक्रम तर्क:
--useIpv6: Ipv6 का उपयोग करें [झूठा]

सामान्य तर्क:
--प्रिंटग्लोबल्स: ग्लोबल्स की सूची प्रिंट करें।
--प्रिंटग्रुप: समूहों की सूची प्रिंट करें।
--प्रिंटग्रुप=[समूह]: समूह के सभी प्रकार के आईडी प्रिंट करें।
--प्रिंटटाइपआईडी: सभी टाइपआईडी प्रिंट करें।
--PrintAttributes=[typeid]: टाइपआईडी की सभी विशेषताओं को प्रिंट करें।
--प्रिंटहेल्प: इस सहायता संदेश को प्रिंट करें।

यह डिफ़ॉल्ट (IPv4 का उपयोग, क्योंकि useIpv6 गलत है) को बूलियन को टॉगल करके बदला जा सकता है
मूल्य इस प्रकार है:

./waf --run "सातवां --useIpv6=1"

और उत्पन्न पीकैप पर एक नजर डालें, जैसे कि टीसीपीडम्प:

टीसीपीडम्प -आर सातवां.पीकैप -एनएन -टीटी

यह IPv6 समर्थन और कमांड लाइन में एक संक्षिप्त विषयांतर है, जो कि था भी
इस ट्यूटोरियल में पहले प्रस्तुत किया गया था। कमांड लाइन उपयोग के एक समर्पित उदाहरण के लिए,
कृपया देखें src/core/examples/command-line-example.cc.

अब वापस डेटा संग्रहण पर। में उदाहरण/ट्यूटोरियल/ निर्देशिका, निम्न टाइप करें
आदेश: diff -u छठा.सीसी सातवां.सीसी, और इस अंतर की कुछ नई पंक्तियों की जाँच करें:

+ std::स्ट्रिंग जांच प्रकार;
+ std::स्ट्रिंग ट्रेसपाथ;
+ यदि (useV6 == गलत)
+ {
...
+ जांच प्रकार = "ns3::Ipv4PacketProbe";
+ ट्रेसपाथ = "/NodeList/*/$ns3::Ipv4L3Protocol/Tx";
+}
+अन्यथा
+ {
...
+ जांच प्रकार = "ns3::Ipv6PacketProbe";
+ ट्रेसपाथ = "/NodeList/*/$ns3::Ipv6L3Protocol/Tx";
+}
...
+ // समय के साथ पैकेट बाइट गिनती को प्लॉट करने के लिए GnuplotHelper का उपयोग करें
+ GnuplotHelper प्लॉटहेल्पर;
+
+ // प्लॉट कॉन्फ़िगर करें। पहला तर्क फ़ाइल नाम उपसर्ग है
+ // उत्पन्न आउटपुट फ़ाइलों के लिए। दूसरा, तीसरा और चौथा
+ // तर्क क्रमशः प्लॉट शीर्षक, एक्स-अक्ष और वाई-अक्ष लेबल हैं
+ प्लॉटहेल्पर.कॉन्फ़िगरप्लॉट ("सातवां-पैकेट-बाइट-गिनती",
+ "पैकेट बाइट गणना बनाम समय",
+ "समय (सेकंड)",
+ "पैकेट बाइट गणना");
+
+ // जांच प्रकार निर्दिष्ट करें, स्रोत पथ का पता लगाएं (कॉन्फ़िगरेशन नेमस्पेस में), और
+ // जांच आउटपुट ट्रेस स्रोत ("आउटपुटबाइट्स") प्लॉट करने के लिए। चौथा तर्क
+ // प्लॉट पर डेटा श्रृंखला लेबल का नाम निर्दिष्ट करता है। अंतिम
+ // तर्क यह निर्दिष्ट करके प्लॉट को प्रारूपित करता है कि कुंजी कहाँ रखी जानी चाहिए।
+ प्लॉटहेल्पर.प्लॉटप्रोब (जांच प्रकार,
+ ट्रेसपाथ,
+ "आउटपुटबाइट्स",
+ "पैकेट बाइट गणना",
+ GnuplotAggregator::KEY_BELOW);
+
+ // समय के साथ पैकेट बाइट गिनती लिखने के लिए फ़ाइल हेल्पर का उपयोग करें
+ फ़ाइल हेल्पर फ़ाइल हेल्पर;
+
+ // लिखी जाने वाली फ़ाइल और आउटपुट डेटा के स्वरूपण को कॉन्फ़िगर करें।
+ fileHelper.ConfigureFile ("सातवां-पैकेट-बाइट-गिनती",
+ फाइलएग्रीगेटर::फॉर्मेटेड);
+
+ // इस स्वरूपित आउटपुट फ़ाइल के लिए लेबल सेट करें।
+ fileHelper.Set2dFormat ("समय (सेकंड) = .3e\tपैकेट बाइट गणना = .0f");
+
+ // जांच प्रकार, जांच पथ (कॉन्फ़िगरेशन नेमस्पेस में), और निर्दिष्ट करें
+ // जांच आउटपुट ट्रेस स्रोत ("आउटपुटबाइट्स") लिखने के लिए।
+ fileHelper.WriteProbe (जांच प्रकार,
+ ट्रेसपाथ,
+ "आउटपुटबाइट्स");
+
सिम्युलेटर::स्टॉप (सेकंड (20));
सिम्युलेटर :: रन ();
सिम्युलेटर::नष्ट करें ();

सावधान पाठक ने उपरोक्त IPv6 कमांड लाइन विशेषता का परीक्षण करते समय ध्यान दिया होगा,
कि सातवां.सीसी कई नई आउटपुट फ़ाइलें बनाई थीं:

सातवां-पैकेट-बाइट-गिनती-0.txt
सातवां-पैकेट-बाइट-गिनती-1.txt
सातवां-पैकेट-बाइट-गिनती.dat
सातवां-पैकेट-बाइट-गिनती.plt
सातवाँ-पैकेट-बाइट-गिनती.png
सातवां-पैकेट-बाइट-गिनती.sh

ये ऊपर दिए गए अतिरिक्त बयानों द्वारा बनाए गए थे; विशेष रूप से, ए द्वारा
GnuplotHelper और एक फ़ाइल हेल्पर। यह डेटा डेटा संग्रह को हुक करके तैयार किया गया था
घटकों एनएस- 3 स्रोतों का पता लगाएं, और डेटा को एक स्वरूपित में मार्शल करें ग्नूप्लोट और
एक स्वरूपित पाठ फ़ाइल में। अगले अनुभागों में, हम इनमें से प्रत्येक की समीक्षा करेंगे।

ग्नुप्लॉट हेल्पर
GnuplotHelper एक है एनएस- 3 सहायक वस्तु के उत्पादन के उद्देश्य से ग्नूप्लोट के साथ प्लॉट
सामान्य मामलों के लिए, यथासंभव कम कथन। यह हुक करता है एनएस- 3 डेटा के साथ स्रोतों का पता लगाएं
डेटा संग्रह प्रणाली द्वारा समर्थित प्रकार। सभी नहीं एनएस- 3 ट्रेस स्रोत डेटा प्रकार हैं
समर्थित है, लेकिन कई सामान्य ट्रेस प्रकार हैं, जिनमें सादे पुराने ट्रेस्डवैल्यूज़ भी शामिल हैं
डेटा (पीओडी) प्रकार।

आइए इस सहायक द्वारा उत्पादित आउटपुट को देखें:

सातवां-पैकेट-बाइट-गिनती.dat
सातवां-पैकेट-बाइट-गिनती.plt
सातवां-पैकेट-बाइट-गिनती.sh

पहली एक gnuplot डेटा फ़ाइल है जिसमें स्पेस-सीमांकित टाइमस्टैम्प और पैकेट की एक श्रृंखला है
बाइट गिनती. हम नीचे कवर करेंगे कि यह विशेष डेटा आउटपुट कैसे कॉन्फ़िगर किया गया था, लेकिन आइए
आउटपुट फ़ाइलों के साथ जारी रखें। फ़ाइल सातवां-पैकेट-बाइट-गिनती.plt एक ग्नुप्लॉट प्लॉट है
फ़ाइल, जिसे gnuplot के भीतर से खोला जा सकता है। जो पाठक gnuplot सिंटैक्स को समझते हैं, वे ऐसा कर सकते हैं
देखें कि यह नाम से एक स्वरूपित आउटपुट पीएनजी फ़ाइल तैयार करेगा
सातवाँ-पैकेट-बाइट-गिनती.png. अंत में, एक छोटी शेल स्क्रिप्ट
सातवां-पैकेट-बाइट-गिनती.sh वांछित उत्पादन करने के लिए इस प्लॉट फ़ाइल को gnuplot के माध्यम से चलाता है
पीएनजी (जिसे एक छवि संपादक में देखा जा सकता है); अर्थात्, आदेश:

श सातवाँ-पैकेट-बाइट-गिनती.श

निकलेगा सातवाँ-पैकेट-बाइट-गिनती.png. इस पीएनजी का उत्पादन पहले क्यों नहीं किया गया
जगह? इसका उत्तर यह है कि पीएलटी फ़ाइल प्रदान करके, उपयोगकर्ता इसे हाथ से कॉन्फ़िगर कर सकता है
यदि वांछित हो, तो पीएनजी तैयार करने से पहले परिणाम प्राप्त करें।

पीएनजी छवि शीर्षक बताता है कि यह प्लॉट "पैकेट बाइट काउंट बनाम टाइम" का प्लॉट है, और
यह ट्रेस स्रोत पथ के अनुरूप जांचे गए डेटा को प्लॉट कर रहा है:

/NodeList/*/$ns3::Ipv6L3Protocol/Tx

ट्रेस पथ में वाइल्ड-कार्ड नोट करें। संक्षेप में, यह कथानक जो पकड़ रहा है वह कथानक है
Ipv6L3Protocol ऑब्जेक्ट के ट्रांसमिट ट्रेस स्रोत पर देखे गए पैकेट बाइट्स की संख्या;
मोटे तौर पर एक दिशा में 596-बाइट टीसीपी खंड, और दूसरी दिशा में 60-बाइट टीसीपी खंड (दो)
नोड ट्रेस स्रोतों का मिलान इस ट्रेस स्रोत से किया गया था)।

इसे कैसे कॉन्फ़िगर किया गया? कुछ कथन उपलब्ध कराने की आवश्यकता है. सबसे पहले, GnuplotHelper
ऑब्जेक्ट को घोषित और कॉन्फ़िगर किया जाना चाहिए:

+ // समय के साथ पैकेट बाइट गिनती को प्लॉट करने के लिए GnuplotHelper का उपयोग करें
+ GnuplotHelper प्लॉटहेल्पर;
+
+ // प्लॉट कॉन्फ़िगर करें। पहला तर्क फ़ाइल नाम उपसर्ग है
+ // उत्पन्न आउटपुट फ़ाइलों के लिए। दूसरा, तीसरा और चौथा
+ // तर्क क्रमशः प्लॉट शीर्षक, एक्स-अक्ष और वाई-अक्ष लेबल हैं
+ प्लॉटहेल्पर.कॉन्फ़िगरप्लॉट ("सातवां-पैकेट-बाइट-गिनती",
+ "पैकेट बाइट गणना बनाम समय",
+ "समय (सेकंड)",
+ "पैकेट बाइट गणना");

इस बिंदु पर, एक खाली प्लॉट कॉन्फ़िगर किया गया है। फ़ाइल नाम उपसर्ग पहला है
तर्क, कथानक का शीर्षक दूसरा है, x-अक्ष लेबल तीसरा है, और y-अक्ष लेबल है
चौथा तर्क.

अगला चरण डेटा को कॉन्फ़िगर करना है, और यहीं पर ट्रेस स्रोत जुड़ा हुआ है।
सबसे पहले, ऊपर ध्यान दें कि कार्यक्रम में हमने बाद में उपयोग के लिए कुछ चर घोषित किए हैं:

+ std::स्ट्रिंग जांच प्रकार;
+ std::स्ट्रिंग ट्रेसपाथ;
+ जांच प्रकार = "ns3::Ipv6PacketProbe";
+ ट्रेसपाथ = "/NodeList/*/$ns3::Ipv6L3Protocol/Tx";

हम उनका उपयोग यहां करते हैं:

+ // जांच प्रकार निर्दिष्ट करें, स्रोत पथ का पता लगाएं (कॉन्फ़िगरेशन नेमस्पेस में), और
+ // जांच आउटपुट ट्रेस स्रोत ("आउटपुटबाइट्स") प्लॉट करने के लिए। चौथा तर्क
+ // प्लॉट पर डेटा श्रृंखला लेबल का नाम निर्दिष्ट करता है। अंतिम
+ // तर्क यह निर्दिष्ट करके प्लॉट को प्रारूपित करता है कि कुंजी कहाँ रखी जानी चाहिए।
+ प्लॉटहेल्पर.प्लॉटप्रोब (जांच प्रकार,
+ ट्रेसपाथ,
+ "आउटपुटबाइट्स",
+ "पैकेट बाइट गणना",
+ GnuplotAggregator::KEY_BELOW);

पहले दो तर्क जांच प्रकार और ट्रेस स्रोत पथ का नाम हैं। इन
जब आप अन्य की साजिश रचने के लिए इस ढांचे का उपयोग करने का प्रयास करते हैं तो दो को निर्धारित करना संभवतः सबसे कठिन होता है
निशान. जांच का निशान यहाँ है Tx कक्षा के स्रोत का पता लगाएं आईपीवी6एल3प्रोटोकॉल। जब हम
इस वर्ग कार्यान्वयन की जांच करें (src/internet/model/ipv6-l3-protocol.cc) हम देख सकते हैं:

.AddTraceSource ("Tx", "आउटगोइंग इंटरफ़ेस पर IPv6 पैकेट भेजें।",
मेकट्रेससोर्सएक्सेसर (&Ipv6L3प्रोटोकॉल::m_txTrace))

ये तो यही कहता है Tx वेरिएबल का एक नाम है m_txTrace, जिसमें एक घोषणा है:

/ **
* \संक्षिप्त कॉलबैक TX (ट्रांसमिशन) पैकेट का पता लगाने के लिए।
*/
ट्रैस्डकॉलबैक , पीटीआर , uint6_t> m_txTrace;

यह पता चला है कि यह विशिष्ट ट्रेस स्रोत हस्ताक्षर एक जांच वर्ग (क्या) द्वारा समर्थित है
हमें यहां क्लास Ipv6PacketProbe की आवश्यकता है)। फ़ाइलें देखें
src/internet/model/ipv6-packet-probe.{h,cc}.

तो, उपरोक्त प्लॉटप्रोब स्टेटमेंट में, हम देखते हैं कि स्टेटमेंट ट्रेस को हुक कर रहा है
स्रोत (पथ स्ट्रिंग द्वारा पहचाना गया) एक मिलान के साथ एनएस- 3 जांच प्रकार Ipv6PacketProbe. अगर
हमने इस जांच प्रकार (मेल खाते ट्रेस स्रोत हस्ताक्षर) का समर्थन नहीं किया, हम नहीं कर सकते थे
इस कथन का उपयोग किया (हालाँकि कुछ अधिक जटिल निचले स्तर के कथन हो सकते थे
उपयोग किया गया, जैसा कि मैनुअल में बताया गया है)।

Ipv6PacketProbe, स्वयं, कुछ ट्रेस स्रोतों को निर्यात करता है जो डेटा को बाहर निकालते हैं
जांचा गया पैकेट ऑब्जेक्ट:

टाइप आईडी
Ipv6PacketProbe :: GetTypeId ()
{
स्टेटिक टाइपआईड टिड = टाइपआईड ("ns3::Ipv6PacketProbe")
.सेटपैरेंट ()
.AddConstructor ()
AddTraceSource ("आउटपुट",
"पैकेट प्लस इसका IPv6 ऑब्जेक्ट और इंटरफ़ेस जो इस जांच के लिए आउटपुट के रूप में काम करता है",
MakeTraceSourceAccessor (&Ipv6PacketProbe::m_output))
.AddTraceSource ("आउटपुटबाइट्स",
"पैकेट में बाइट्स की संख्या",
MakeTraceSourceAccessor (&Ipv6PacketProbe::m_outputBytes))
;
वापसी बोली;
}

हमारे प्लॉटप्रोब कथन का तीसरा तर्क निर्दिष्ट करता है कि हम इसमें रुचि रखते हैं
इस पैकेट में बाइट्स की संख्या; विशेष रूप से, "आउटपुटबाइट्स" का स्रोत ट्रेस होता है
Ipv6PacketProbe. अंत में, कथन के अंतिम दो तर्क कथानक कथा प्रदान करते हैं
इस डेटा श्रृंखला के लिए ("पैकेट बाइट काउंट"), और एक वैकल्पिक gnuplot फ़ॉर्मेटिंग स्टेटमेंट
(GnuplotAggregator::KEY_BELOW) कि हम चाहते हैं कि प्लॉट कुंजी प्लॉट के नीचे डाली जाए।
अन्य विकल्पों में NO_KEY, KEY_INSIDE, और KEY_ABOVE शामिल हैं।

समर्थित निशान प्रकार
इस लेखन के समय निम्नलिखित पता लगाए गए मान प्रोब के साथ समर्थित हैं:

┌─────────────────┬───────────────── ────────── ────────────────────┐
│TracedValue प्रकार │ जांच प्रकार │ फ़ाइल │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│double │ DoubleProbe │ stats/model/double-probe.h │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│uint8_t │ Uinteger8Probe │ आँकड़े/मॉडल/uinteger-8-probe.h │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│uint16_t │ Uinteger16Probe │ आँकड़े/मॉडल/uinteger-16-probe.h │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│uint32_t │ Uinteger32Probe │ आँकड़े/मॉडल/uinteger-32-probe.h │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│बूल │ बूलियनप्रोब │ आँकड़े/मॉडल/uinteger-16-probe.h │
├─────────────────┼─────────────────┼── ────────── ────────────────────┤
│ns3::Time │ TimeProbe │ stats/model/time-probe.h │
└─────────────────┴─────────────────┴── ────────── ────────────────────┘

इस लेखन के समय निम्नलिखित ट्रेससोर्स प्रकार प्रोब्स द्वारा समर्थित हैं:

┌────────────────────┬───────────── ──────┬─── ────────────┬────────────────────── ────────── ──────────┐
├────────────────────┼────────────── ──────┼─── ────────────┼────────────────────── ────────── ──────────┤
├────────────────────┼────────────── ──────┼─── ────────────┼────────────────────── ────────── ──────────┤
├────────────────────┼────────────── ──────┼─── ────────────┼────────────────────── ────────── ──────────┤
├────────────────────┼────────────── ──────┼─── ────────────┼────────────────────── ────────── ──────────┤
├────────────────────┼────────────── ──────┼─── ────────────┼────────────────────── ────────── ──────────┤
└────────────────────┴───────────── ──────┴─── ────────────┴────────────────────── ────────── ──────────┘

जैसा कि देखा जा सकता है, केवल कुछ ट्रेस स्रोत ही समर्थित हैं, और वे सभी इसी ओर उन्मुख हैं
पैकेट आकार (बाइट्स में) आउटपुट करना। हालाँकि, अधिकांश मूलभूत डेटा प्रकार
TracedValues ​​के रूप में उपलब्ध इन सहायकों के साथ समर्थित किया जा सकता है।

फ़ाइल हेल्पर
फ़ाइलहेल्पर वर्ग पिछले GnuplotHelper उदाहरण का एक रूप मात्र है।
उदाहरण प्रोग्राम समान टाइमस्टैम्प्ड डेटा का स्वरूपित आउटपुट प्रदान करता है, जैसे कि:

समय (सेकंड) = 9.312e+00 पैकेट बाइट गणना = 596
समय (सेकंड) = 9.312e+00 पैकेट बाइट गणना = 564

दो फ़ाइलें प्रदान की गई हैं, एक नोड "0" के लिए और एक नोड "1" के लिए जैसा कि इसमें देखा जा सकता है
फ़ाइलनाम. आइए कोड को टुकड़े-टुकड़े करके देखें:

+ // समय के साथ पैकेट बाइट गिनती लिखने के लिए फ़ाइल हेल्पर का उपयोग करें
+ फ़ाइल हेल्पर फ़ाइल हेल्पर;
+
+ // लिखी जाने वाली फ़ाइल और आउटपुट डेटा के स्वरूपण को कॉन्फ़िगर करें।
+ fileHelper.ConfigureFile ("सातवां-पैकेट-बाइट-गिनती",
+ फाइलएग्रीगेटर::फॉर्मेटेड);

फ़ाइल सहायक फ़ाइल उपसर्ग पहला तर्क है, और एक प्रारूप विनिर्देशक अगला है। कुछ
फ़ॉर्मेटिंग के अन्य विकल्पों में SPACE_SEPARATED, COMMA_SEPARATED, और TAB_SEPARATED शामिल हैं।
उपयोगकर्ता फ़ॉर्मेट स्ट्रिंग के साथ फ़ॉर्मेटिंग (यदि FORMATTED निर्दिष्ट है) को बदलने में सक्षम हैं
जैसे इस प्रकार:

+
+ // इस स्वरूपित आउटपुट फ़ाइल के लिए लेबल सेट करें।
+ fileHelper.Set2dFormat ("समय (सेकंड) = .3e\tपैकेट बाइट गणना = .0f");

अंत में, रुचि के स्रोत का पता लगाना आवश्यक है। फिर से, जांच प्रकार और ट्रेसपाथ
इस उदाहरण में चर का उपयोग किया जाता है, और जांच का आउटपुट ट्रेस स्रोत "आउटपुटबाइट्स" है
झुका हुआ:

+
+ // जांच प्रकार निर्दिष्ट करें, स्रोत पथ का पता लगाएं (कॉन्फ़िगरेशन नेमस्पेस में), और
+ // जांच आउटपुट ट्रेस स्रोत ("आउटपुटबाइट्स") लिखने के लिए।
+ fileHelper.WriteProbe (जांच प्रकार,
+ ट्रेसपाथ,
+ "आउटपुटबाइट्स");
+

इस ट्रेस स्रोत विनिर्देशक में वाइल्डकार्ड फ़ील्ड दो ट्रेस स्रोतों से मेल खाते हैं। से भिन्न
GnuplotHelper उदाहरण, जिसमें दो डेटा श्रृंखलाएं एक ही प्लॉट पर मढ़ाई गई थीं, यहां, दो
अलग-अलग फ़ाइलें डिस्क पर लिखी जाती हैं।

सारांश
डेटा संग्रह समर्थन एनएस-3.18 के रूप में नया है, और समय श्रृंखला प्रदान करने के लिए बुनियादी समर्थन है
आउटपुट जोड़ा गया है. ऊपर वर्णित मूल पैटर्न को भीतर दोहराया जा सकता है
मौजूदा जांच और ट्रेस स्रोतों के समर्थन का दायरा। सहित अधिक क्षमताएँ
सांख्यिकी प्रसंस्करण को भविष्य के रिलीज़ में जोड़ा जाएगा।

निष्कर्ष

भावी सौदे
यह दस्तावेज़ एक जीवित दस्तावेज़ के रूप में अभिप्रेत है। हम आशा करते हैं और आशा करते हैं कि समय के साथ इसमें वृद्धि होगी
के अधिक से अधिक नट और बोल्ट को कवर करने के लिए एनएस- 3.

मैनुअल और ट्यूटोरियल अध्याय लिखना कोई ऐसी चीज़ नहीं है जिसके बारे में हम सभी उत्साहित हों, लेकिन यह है
परियोजना के लिए बहुत महत्वपूर्ण है. यदि आप इनमें से किसी एक क्षेत्र में विशेषज्ञ हैं, तो कृपया
योगदान देने पर विचार करें एनएस- 3 इनमें से एक अध्याय प्रदान करके; या कोई अन्य अध्याय आप
सोच सकते हैं महत्वपूर्ण है.

बंद करना
एनएस- 3 एक बड़ी और जटिल प्रणाली है. आपकी सभी चीज़ों को कवर करना असंभव है
एक छोटे से ट्यूटोरियल में जानने की आवश्यकता होगी। जो पाठक और अधिक सीखना चाहते हैं उन्हें प्रोत्साहित किया जाता है
निम्नलिखित अतिरिक्त दस्तावेज़ पढ़ें:

· एनएस- 3 गाइड

· एनएस- 3 मॉडल लाइब्रेरी दस्तावेज़ीकरण

· एनएस- 3 डॉक्सीजन (एपीआई दस्तावेज़ीकरण)

· एनएस- 3 विकि

-- द एनएस- 3 विकास दल।

onworks.net सेवाओं का उपयोग करके ns-3-ट्यूटोरियल का ऑनलाइन उपयोग करें