एनएस-3 नेटवर्क सिम्युलेटर ट्यूटोरियल। अध्याय 4

अध्याय 1,2
लावा 3

4 संकल्पना सिंहावलोकन
4.1 मुख्य सार
4.1.1 नोड
4.1.2 आवेदन
4.1.3 चैनल
4.1.4 नेट डिवाइस
4.1.5 टोपोलॉजिकल सहायक
4.2 पहली एनएस-3 स्क्रिप्ट
4.2.1 बॉयलरप्लेट कोड
4.2.2 प्लग-इन
4.2.3 एनएस3 नेमस्पेस
4.2.4 लॉगिंग
4.2.5 मुख्य कार्य
4.2.6 टोपोलॉजी सहायकों का उपयोग करना
4.2.7 एप्लिकेशन का उपयोग करना
4.2.8 सिम्युलेटर
4.2.9 अपनी स्क्रिप्ट बनाना
4.3 एनएस-3 स्रोत कोड

अध्याय 4

संकल्पना सिंहावलोकन

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

4.1 मुख्य सार

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

4.1.1 नोड

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

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

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

4.1.2 आवेदन

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

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

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

4.1.3 चैनल

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

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

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

4.1.4 नेट डिवाइस

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

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

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

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

4.1.5 टोपोलॉजिकल सहायक

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

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

4.2 पहली एनएस-3 स्क्रिप्ट

यदि आपने ऊपर बताए अनुसार सिस्टम स्थापित किया है, तो आपके होम डायरेक्टरी में रेपो नामक निर्देशिका में एनएस-3 रिलीज होगी। निर्देशिका पर जाएँ और

यदि आपके पास ऐसी कोई निर्देशिका नहीं है, तो इसका मतलब है कि आपने ns-3 के रिलीज़ संस्करण का निर्माण करते समय आउटपुट निर्देशिका निर्दिष्ट नहीं की है, इस तरह बनाएं:
$ ./waf कॉन्फ़िगर करें—बिल्ड-प्रोफ़ाइल=रिलीज़—आउट=बिल्ड/रिलीज़,
$ ./waf बिल्ड

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

AUTHORS       examples      scratch       utils       waf.bat*
bindings      LICENSE       src           utils.py    waf-tools
build         ns3           test.py*      utils.pyc   wscript
CHANGES.html  README        testpy-output VERSION     wutils.py
doc           RELEASE_NOTES testpy.supp   waf*        wutils.pyc

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

4.2.1 बॉयलरप्लेट कोड
फ़ाइल की पहली पंक्ति संपादक मोड पंक्ति है Emacs. यह ईमैक को उन फ़ॉर्मेटिंग परंपराओं (कोडिंग शैली) के बारे में बताता है जिनका उपयोग हम अपने स्रोत कोड में करते हैं।

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

यह हमेशा काफी विवादास्पद मुद्दा होता है, इसलिए हमें इसे तुरंत रास्ते से हटाने के लिए रिकॉर्ड को सही करने की आवश्यकता है। अधिकांश बड़ी परियोजनाओं की तरह, एनएस-3 परियोजना ने एक कोडिंग शैली अपनाई है, जिसके अनुरूप सभी योगदान किए गए कोड का पालन करना होगा। यदि आप प्रोजेक्ट में अपना कोड योगदान करना चाहते हैं, तो आपको अंततः एनएस-3 कोडिंग मानक के अनुरूप होना होगा, जैसा कि फ़ाइल में वर्णित है दस्तावेज़/कोडिंगएसटीडी.टीएक्सटी या प्रोजेक्ट वेब पेज पर दिखाया गया है: https://www.nsnam.org/develop/contributing-code/coding-style/.

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

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

/* 
* This program is free software; you can redistribute it and/or modify 
* it under the terms of the GNU General Public License version 2 as 
* published by the Free Software Foundation; 
*
* This program is distributed in the hope that it will be useful, 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU General Public License for more details. 
* 
* You should have received a copy of the GNU General Public License 
* along with this program; if not, write to the Free Software 
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 
*/

4.2.2 प्लग-इन

कोड स्वयं समावेशन कथनों की एक श्रृंखला से शुरू होता है (शामिल).

#include "ns3/core-module.h"
#include "ns3/network-module.h"
#include "ns3/internet-module.h"
#include "ns3/point-to-point-module.h"
#include "ns3/applications-module.h"

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

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

यदि आपके पास ऐसी कोई निर्देशिका नहीं है, तो इसका मतलब है कि आपने ns-3 के रिलीज़ संस्करण का निर्माण करते समय आउटपुट निर्देशिका निर्दिष्ट नहीं की है, इस तरह बनाएं:
$ ./waf कॉन्फ़िगर --बिल्ड-प्रोफाइल=डीबग --आउट=बिल्ड/डीबग
$ ./waf बिल्ड
या
$ ./waf कॉन्फ़िगर --बिल्ड-प्रोफ़ाइल=अनुकूलित --आउट=बिल्ड/अनुकूलित
$ ./waf बिल्ड

या निर्माण/अनुकूलित, आपके कॉन्फ़िगरेशन पर निर्भर करता है। waf सभी सार्वजनिक हेडर फ़ाइलों को लोड करने के लिए स्वचालित रूप से एक मॉड्यूल शामिल फ़ाइल भी उत्पन्न करेगा। चूँकि आप निश्चित रूप से इस गाइड का धार्मिक रूप से पालन कर रहे हैं, आप पहले ही कर चुके हैं

$ ./waf -d debug --enable-examples --enable-tests configure

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

$ ./waf

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

4.2.3 एनएस3 नेमस्पेस

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

using namespace ns3;

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

4.2.4 लॉगिंग

स्क्रिप्ट की अगली पंक्ति है:

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

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

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

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

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

4.2.5 मुख्य कार्य

स्क्रिप्ट की निम्नलिखित पंक्तियों में आप देखेंगे,

int 
main (int argc, char *argv[])
{ 

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

Time::SetResolution (Time::NS);

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

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

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

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

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

4.2.6 टोपोलॉजी सहायकों का उपयोग करना

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

NodeContainer nodes;
nodes.Create (2);

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

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

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

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

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

PointToPointHelper pointToPoint;
pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps")); 
pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

पहली पंक्ति,

PointToPointHelper pointToPoint;

स्टैक पर किसी ऑब्जेक्ट का एक उदाहरण बनाता है पॉइंटटूप्वाइंटहेल्पर. शीर्ष स्तर के दृष्टिकोण से निम्नलिखित पंक्ति,

pointToPoint.SetDeviceAttribute ("DataRate", StringValue ("5Mbps"));

वस्तु को बताता है पॉइंटटूप्वाइंटहेल्पर मान "5 Mbit/s" (पांच मेगाबिट प्रति सेकंड) का उपयोग "आधार - सामग्री दर'.

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

के समान "आधार - सामग्री दर"PointToPointNetDevice में, आपको PointToPointChannel से संबद्ध "विलंब" विशेषता मिलेगी। अंतिम पंक्ति

pointToPoint.SetChannelAttribute ("Delay", StringValue ("2ms"));

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

नेटडिवाइसकंटेनर

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

NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);

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

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

इंटरनेटस्टैकहेल्पर

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

InternetStackHelper stack;
stack.Install (nodes);

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

आईपीवी4पता हेल्पर

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

Ipv4AddressHelper address;
address.SetBase ("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 interfaces = address.Assign (devices);

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

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

4.2.7 एप्लिकेशन का उपयोग करना

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

UdpEchoServerHelper

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

UdpEchoServerHelper echoServer (9);

ApplicationContainer serverApps = echoServer.Install (nodes.Get (1));
serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

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

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

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

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

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

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));

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

UdpEchoClientHelper

ग्राहक आवेदन गूंज लगभग सर्वर के समान तरीके से कॉन्फ़िगर किया गया। एक आधार वस्तु है UdpEchoClientएप्लिकेशन, जो प्रबंधित है
UdpEchoClientHelper.

UdpEchoClientHelper echoClient (interfaces.GetAddress (1), 9);
echoClient.SetAttribute ("MaxPackets", UintegerValue (1));
echoClient.SetAttribute ("Interval", TimeValue (Seconds (1.0)));
echoClient.SetAttribute ("PacketSize", UintegerValue (1024));

ApplicationContainer clientApps = echoClient.Install (nodes.Get (0));
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));;

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

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

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

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

4.2.8 सिम्युलेटर

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

Simulator::Run ();

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

serverApps.Start (Seconds (1.0));
serverApps.Stop (Seconds (10.0));
... 
clientApps.Start (Seconds (2.0));
clientApps.Stop (Seconds (10.0));

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

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

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

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

Simulator::Destroy ();
return 0;
}

सिम्युलेटर कब बंद होगा?

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

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

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

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

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

• वगैरह।

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

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

+ Simulator::Stop (Seconds (11.0));
  Simulator::Run ();
  Simulator::Destroy ();
  return 0;
}

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

Simulator::Run को कॉल करने से पहले Simulator::Stop को कॉल करना महत्वपूर्ण है; अन्यथा सिम्युलेटर::रन कभी भी स्टॉप को निष्पादित करने के लिए मुख्य प्रोग्राम पर नियंत्रण नहीं लौटा सकता है!

4.2.9 अपनी स्क्रिप्ट बनाना

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

$ cd ../.. 
$ cp examples/tutorial/first.cc scratch/myfirst.cc

अब अपनी पहली नमूना स्क्रिप्ट का उपयोग करके बनाएं WAF:

$ ./waf

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

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
[614/708] cxx: scratch/myfirst.cc -> build/debug/scratch/myfirst_3.o
[706/708] cxx_link: build/debug/scratch/myfirst_3.o -> build/debug/scratch/myfirst
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (2.357s)

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

$ ./waf --run scratch/myfirst

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

Waf: Entering directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
Waf: Leaving directory `/home/craigdo/repos/ns-3-allinone/ns-3-dev/build'
'build' finished successfully (0.418s) Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

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

4.3 एनएस-3 स्रोत कोड

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

summary | shortlog | changelog | graph | tags | files

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

drwxr-xr-x                               [up]
drwxr-xr-x                               bindings python  files
drwxr-xr-x                               doc              files
drwxr-xr-x                               examples         files
drwxr-xr-x                               ns3              files
drwxr-xr-x                               scratch          files
drwxr-xr-x                               src              files
drwxr-xr-x                               utils            files
-rw-r--r-- 2009-07-01 12:47 +0200 560    .hgignore        file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1886   .hgtags          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 1276   AUTHORS          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 30961  CHANGES.html     file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 17987  LICENSE          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 3742   README           file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 16171  RELEASE_NOTES    file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 6      VERSION          file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 88110  waf              file | revisions | annotate
-rwxr-xr-x 2009-07-01 12:47 +0200 28     waf.bat          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 35395  wscript          file | revisions | annotate
-rw-r--r-- 2009-07-01 12:47 +0200 7673   wutils.py        file | revisions | annotate

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

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

स्रोत: www.habr.com