ns-3 ਨੈੱਟਵਰਕ ਸਿਮੂਲੇਟਰ ਟਿਊਟੋਰਿਅਲ। ਅਧਿਆਇ 4

ਅਧਿਆਇ 1,2
ਅਧਿਆਇ 3

4 ਸੰਕਲਪ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ
4.1 ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨ
੪.੧.੧ ਨੋਡ
4.1.2 ਐਪਲੀਕੇਸ਼ਨ
4.1.3 ਚੈਨਲ
4.1.4 ਨੈੱਟ ਡਿਵਾਈਸ
4.1.5 ਟੌਪੋਲੋਜੀਕਲ ਸਹਾਇਕ
4.2 ਪਹਿਲੀ ns-3 ਸਕ੍ਰਿਪਟ
4.2.1 ਬੋਇਲਰਪਲੇਟ ਕੋਡ
4.2.2 ਪਲੱਗ-ਇਨ
4.2.3 ns3 ਨਾਮਸਪੇਸ
4.2.4 ਲਾਗਿੰਗ
4.2.5 ਮੁੱਖ ਕਾਰਜ
4.2.6 ਟੋਪੋਲੋਜੀ ਸਹਾਇਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
4.2.7 ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
4.2.8 ਸਿਮੂਲੇਟਰ
4.2.9 ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣਾ
4.3 ns-3 ਸਰੋਤ ਕੋਡ

ਅਧਿਆਇ 4

ਸੰਕਲਪ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

ns-3 ਕੋਡ ਸਿੱਖਣ ਜਾਂ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਨੂੰ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਸਿਸਟਮ ਵਿੱਚ ਕੁਝ ਬੁਨਿਆਦੀ ਧਾਰਨਾਵਾਂ ਅਤੇ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਨੂੰ ਸਮਝਾਉਣਾ। ਇਸ ਵਿੱਚੋਂ ਬਹੁਤ ਕੁਝ ਕੁਝ ਲੋਕਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਇਸ ਭਾਗ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਸਮਾਂ ਕੱਢਣ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਮਜ਼ਬੂਤ ​​ਬੁਨਿਆਦ 'ਤੇ ਸ਼ੁਰੂਆਤ ਕਰ ਰਹੇ ਹੋ।

4.1 ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨ

ਇਸ ਭਾਗ ਵਿੱਚ, ਅਸੀਂ ਕੁਝ ਅਜਿਹੇ ਸ਼ਬਦਾਂ ਨੂੰ ਦੇਖਾਂਗੇ ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਵੈੱਬ 'ਤੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ ਪਰ ns-3 ਵਿੱਚ ਖਾਸ ਅਰਥ ਰੱਖਦੇ ਹਨ।

੪.੧.੧ ਨੋਡ

ਇੰਟਰਨੈਟ ਜਾਰਗਨ ਵਿੱਚ, ਇੱਕ ਕੰਪਿਊਟਰ ਯੰਤਰ ਜੋ ਇੱਕ ਨੈਟਵਰਕ ਨਾਲ ਜੁੜਦਾ ਹੈ ਨੂੰ ਹੋਸਟ ਜਾਂ ਕਈ ਵਾਰ ਇੱਕ ਅੰਤ ਸਿਸਟਮ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਕਿਉਂਕਿ ns-3 ਇੱਕ ਨੈਟਵਰਕ ਸਿਮੂਲੇਟਰ ਹੈ ਨਾ ਕਿ ਇੱਕ ਇੰਟਰਨੈਟ ਸਿਮੂਲੇਟਰ, ਅਸੀਂ ਜਾਣਬੁੱਝ ਕੇ ਹੋਸਟ ਸ਼ਬਦ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ, ਕਿਉਂਕਿ ਇਹ ਇੰਟਰਨੈਟ ਅਤੇ ਇਸਦੇ ਪ੍ਰੋਟੋਕੋਲ ਨਾਲ ਨੇੜਿਓਂ ਸਬੰਧਤ ਹੈ। ਇਸਦੀ ਬਜਾਏ, ਅਸੀਂ ਇੱਕ ਹੋਰ ਆਮ ਸ਼ਬਦ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਜੋ ਹੋਰ ਸਿਮੂਲੇਟਰਾਂ ਦੁਆਰਾ ਵੀ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਗ੍ਰਾਫ ਥਿਊਰੀ ਵਿੱਚ ਉਤਪੰਨ ਹੁੰਦਾ ਹੈ: ਨੋਡ (ਨੋਡ).

ns-3 ਵਿੱਚ, ਇੱਕ ਕੰਪਿਊਟਿੰਗ ਯੰਤਰ ਦੇ ਅੰਡਰਲਾਈੰਗ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਨੋਡ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਨੋਡ ਕਲਾਸ ਦੁਆਰਾ C++ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਕਲਾਸ ਨੋਡਨੋਡ (ਨੋਡ) ਸਿਮੂਲੇਸ਼ਨਾਂ ਵਿੱਚ ਕੰਪਿਊਟਿੰਗ ਡਿਵਾਈਸਾਂ ਦੇ ਪ੍ਰਸਤੁਤੀਆਂ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਤੁਹਾਨੂੰ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ ਨੋਡ ਇੱਕ ਕੰਪਿਊਟਰ ਦੀ ਤਰ੍ਹਾਂ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਕਾਰਜਕੁਸ਼ਲਤਾ ਜੋੜਦੇ ਹੋ। ਤੁਸੀਂ ਡ੍ਰਾਈਵਰਾਂ ਦੇ ਨਾਲ ਐਪਲੀਕੇਸ਼ਨਾਂ, ਪ੍ਰੋਟੋਕੋਲ ਸਟੈਕ, ਅਤੇ ਪੈਰੀਫਿਰਲ ਕਾਰਡਾਂ ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਜੋੜੋਗੇ ਜੋ ਕੰਪਿਊਟਰ ਨੂੰ ਉਪਯੋਗੀ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਅਸੀਂ ns-3 ਵਿੱਚ ਉਹੀ ਮੂਲ ਮਾਡਲ ਵਰਤਦੇ ਹਾਂ।

4.1.2 ਐਪਲੀਕੇਸ਼ਨ

ਆਮ ਤੌਰ 'ਤੇ, ਕੰਪਿਊਟਰ ਸਾਫਟਵੇਅਰ ਨੂੰ ਦੋ ਵਿਆਪਕ ਸ਼੍ਰੇਣੀਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ। ਸਿਸਟਮ ਸਾਫਟਵੇਅਰ ਕਈ ਕੰਪਿਊਟਰ ਸਰੋਤਾਂ ਜਿਵੇਂ ਕਿ ਮੈਮੋਰੀ, ਪ੍ਰੋਸੈਸਰ ਚੱਕਰ, ਡਿਸਕ, ਨੈੱਟਵਰਕ, ਆਦਿ ਨੂੰ ਕੁਝ ਕੰਪਿਊਟਿੰਗ ਮਾਡਲ ਦੇ ਅਨੁਸਾਰ ਸੰਗਠਿਤ ਕਰਦਾ ਹੈ। ਸਿਸਟਮ ਸੌਫਟਵੇਅਰ ਆਮ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਸਰੋਤਾਂ ਦੀ ਵਰਤੋਂ ਉਹਨਾਂ ਕਾਰਜਾਂ ਨੂੰ ਕਰਨ ਲਈ ਨਹੀਂ ਕਰਦਾ ਹੈ ਜੋ ਉਪਭੋਗਤਾ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਲਾਭ ਪਹੁੰਚਾਉਂਦੇ ਹਨ। ਇੱਕ ਉਪਭੋਗਤਾ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਖਾਸ ਟੀਚਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਂਦਾ ਹੈ, ਜੋ ਸਿਸਟਮ ਸੌਫਟਵੇਅਰ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਸਰੋਤਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਵਰਤਦਾ ਹੈ।

ਅਕਸਰ ਸਿਸਟਮ ਅਤੇ ਐਪਲੀਕੇਸ਼ਨ ਸੌਫਟਵੇਅਰ ਦੇ ਵਿਚਕਾਰ ਵੱਖ ਹੋਣ ਦੀ ਲਾਈਨ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪੱਧਰ ਦੀਆਂ ਤਬਦੀਲੀਆਂ 'ਤੇ ਖਿੱਚੀ ਜਾਂਦੀ ਹੈ ਜੋ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਜਾਲ ਵਿੱਚ ਵਾਪਰਦੀਆਂ ਹਨ। ns-3 ਕੋਲ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਕੋਈ ਅਸਲ ਧਾਰਨਾ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸਲਈ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰ ਪੱਧਰਾਂ ਜਾਂ ਸਿਸਟਮ ਕਾਲਾਂ ਦੀ ਕੋਈ ਧਾਰਨਾ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਐਪ ਲਈ ਇੱਕ ਵਿਚਾਰ ਹੈ। ਜਿਵੇਂ ਕਿ "ਅਸਲ ਸੰਸਾਰ" ਸੌਫਟਵੇਅਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਕੰਪਿਊਟਰਾਂ 'ਤੇ ਕੰਮ ਕਰਨ ਲਈ ਚਲਦੀਆਂ ਹਨ, ns-3 ਐਪਲੀਕੇਸ਼ਨ ਸਿਮੂਲੇਟਡ ਸੰਸਾਰ ਵਿੱਚ ਸਿਮੂਲੇਸ਼ਨਾਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ns-3 ਨੋਡਾਂ 'ਤੇ ਚੱਲਦੀਆਂ ਹਨ।

ns-3 ਵਿੱਚ, ਇੱਕ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ ਲਈ ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ ਜੋ ਮਾਡਲਿੰਗ ਲਈ ਕੁਝ ਗਤੀਵਿਧੀ ਪੈਦਾ ਕਰਦਾ ਹੈ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਹੈ। ਇਸ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਸ ਦੁਆਰਾ C++ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਸ ਸਿਮੂਲੇਸ਼ਨਾਂ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਸਾਡੇ ਉਪਭੋਗਤਾ-ਪੱਧਰ ਦੇ ਸੰਸਕਰਣ ਦੇ ਦ੍ਰਿਸ਼ਾਂ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਤਰੀਕੇ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ। ਡਿਵੈਲਪਰਾਂ ਤੋਂ ਉਮੀਦ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਉਹ ਨਵੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਰਥਾਂ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਸ ਨੂੰ ਮਾਹਰ ਬਣਾਉਣ। ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ, ਅਸੀਂ ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਜਿਸਨੂੰ ਕਹਿੰਦੇ ਹਨ UdpEchoClientApplication и UdpEchoServerApplication. ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹੋ, ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਕਲਾਇੰਟ/ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜੋ ਨੈੱਟਵਰਕ ਪੈਕੇਟ ਬਣਾਉਣ ਅਤੇ ਈਕੋ ਕਰਨ ਲਈ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

4.1.3 ਚੈਨਲ

ਅਸਲ ਸੰਸਾਰ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਕੰਪਿਊਟਰ ਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਕਰ ਸਕਦੇ ਹੋ। ਅਕਸਰ ਮੀਡੀਆ ਜਿਸ ਉੱਤੇ ਇਹਨਾਂ ਨੈਟਵਰਕਾਂ ਵਿੱਚ ਡੇਟਾ ਪ੍ਰਸਾਰਿਤ ਹੁੰਦਾ ਹੈ ਨੂੰ ਚੈਨਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਈਥਰਨੈੱਟ ਕੇਬਲ ਨੂੰ ਕੰਧ ਦੇ ਆਉਟਲੈਟ ਵਿੱਚ ਜੋੜਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਆਪਣੇ ਕੰਪਿਊਟਰ ਨੂੰ ਇੱਕ ਈਥਰਨੈੱਟ ਲਿੰਕ ਨਾਲ ਕਨੈਕਟ ਕਰ ਰਹੇ ਹੋ। ਸਿਮੂਲੇਟਿਡ ns-3 ਸੰਸਾਰ ਵਿੱਚ, ਇੱਕ ਨੋਡ ਇੱਕ ਸੰਚਾਰ ਚੈਨਲ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲੀ ਵਸਤੂ ਨਾਲ ਜੁੜਿਆ ਹੁੰਦਾ ਹੈ। ਇੱਥੇ, ਸੰਚਾਰ ਉਪ-ਨੈੱਟਵਰਕ ਦੇ ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਇੱਕ ਚੈਨਲ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਚੈਨਲ ਕਲਾਸ ਦੁਆਰਾ C++ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।

Класс ਚੈਨਲ ਚੈਨਲ ਸਬਨੈੱਟ ਆਬਜੈਕਟ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਪ੍ਰਬੰਧਨ ਅਤੇ ਉਹਨਾਂ ਨਾਲ ਮੇਜ਼ਬਾਨਾਂ ਨੂੰ ਜੋੜਨ ਲਈ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਚੈਨਲਾਂ ਨੂੰ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਇੱਕ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਅਰਥਾਂ ਵਿੱਚ ਵੀ ਵਿਸ਼ੇਸ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਚੈਨਲ ਮੁਹਾਰਤ ਇੱਕ ਤਾਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸਧਾਰਨ ਕੁਝ ਮਾਡਲ ਬਣਾ ਸਕਦੀ ਹੈ। ਇੱਕ ਸਮਰਪਿਤ ਚੈਨਲ ਗੁੰਝਲਦਾਰ ਚੀਜ਼ਾਂ ਨੂੰ ਵੀ ਮਾਡਲ ਬਣਾ ਸਕਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਇੱਕ ਵੱਡੇ ਈਥਰਨੈੱਟ ਸਵਿੱਚ ਜਾਂ ਵਾਇਰਲੈੱਸ ਨੈਟਵਰਕ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਰੁਕਾਵਟਾਂ ਨਾਲ ਭਰੀ ਇੱਕ ਤਿੰਨ-ਅਯਾਮੀ ਸਪੇਸ।

ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਚੈਨਲ ਦੇ ਵਿਸ਼ੇਸ਼ ਸੰਸਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ CsmaChannelCsmaChannel, PointToPointChannelPointToPointChannel и WifiChannelWifiChannel. CsmaChannel, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸੰਚਾਰ ਸਬਨੈੱਟ ਦਾ ਇੱਕ ਸੰਸਕਰਣ ਮਾਡਲ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਇੱਕ ਕੈਰੀਅਰ-ਸੈਂਸ ਮਲਟੀਪਲ ਐਕਸੈਸ ਸੰਚਾਰ ਵਾਤਾਵਰਣ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਇਹ ਸਾਨੂੰ ਈਥਰਨੈੱਟ ਵਰਗੀ ਕਾਰਜਸ਼ੀਲਤਾ ਦਿੰਦਾ ਹੈ।

4.1.4 ਨੈੱਟ ਡਿਵਾਈਸ

ਅਜਿਹਾ ਹੁੰਦਾ ਸੀ ਕਿ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਕੰਪਿਊਟਰ ਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਖਾਸ ਨੈੱਟਵਰਕ ਕੇਬਲ ਅਤੇ ਇੱਕ ਹਾਰਡਵੇਅਰ ਯੰਤਰ (ਪੀਸੀ ਸ਼ਬਦਾਵਲੀ ਵਿੱਚ) ਇੱਕ ਪੈਰੀਫਿਰਲ ਕਾਰਡ ਖਰੀਦਣਾ ਪੈਂਦਾ ਸੀ ਜਿਸਨੂੰ ਕੰਪਿਊਟਰ ਵਿੱਚ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਜੇਕਰ ਇੱਕ ਪੈਰੀਫਿਰਲ ਕਾਰਡ ਨੇ ਕੁਝ ਨੈੱਟਵਰਕਿੰਗ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਨੈੱਟਵਰਕ ਇੰਟਰਫੇਸ ਕਾਰਡ ਜਾਂ ਨੈੱਟਵਰਕ ਕਾਰਡ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਅੱਜ, ਜ਼ਿਆਦਾਤਰ ਕੰਪਿਊਟਰ ਏਕੀਕ੍ਰਿਤ ਨੈੱਟਵਰਕ ਇੰਟਰਫੇਸ ਹਾਰਡਵੇਅਰ ਦੇ ਨਾਲ ਆਉਂਦੇ ਹਨ ਅਤੇ ਉਪਭੋਗਤਾਵਾਂ ਦੁਆਰਾ ਵੱਖਰੇ ਡਿਵਾਈਸਾਂ ਵਜੋਂ ਨਹੀਂ ਦੇਖਿਆ ਜਾਂਦਾ ਹੈ।

Сетевая карта не будет работать без программного драйвера, управляющего её оборудованием. В Unix (или Linux), часть периферийного оборудования классифицируется как device. Устройства управляются с помощью драйверов устройств (device drivers), а сетевые устройства (NIC) управляются с использованием драйверов сетевых устройств (ਨੈੱਟਵਰਕ ਜੰਤਰ ਡਰਾਈਵਰ) ਅਤੇ ਸਮੂਹਿਕ ਤੌਰ 'ਤੇ ਨੈੱਟਵਰਕ ਡਿਵਾਈਸਾਂ (ਨੈੱਟ ਜੰਤਰ). В Unix и Linux вы обращаетесь к сетевым устройствам по таким именам, как например eth0.

ns-3 ਵਿੱਚ, ਨੈੱਟਵਰਕ ਜੰਤਰ ਐਬਸਟਰੈਕਸ਼ਨ ਸਾਫਟਵੇਅਰ ਡਰਾਈਵਰ ਅਤੇ ਮਾਡਲ ਕੀਤੇ ਜਾ ਰਹੇ ਹਾਰਡਵੇਅਰ ਦੋਵਾਂ ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ। ਸਿਮੂਲੇਸ਼ਨ ਵਿੱਚ, ਇੱਕ ਨੈਟਵਰਕ ਡਿਵਾਈਸ ਨੂੰ ਇੱਕ ਨੋਡ ਵਿੱਚ "ਸਥਾਪਤ" ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸਨੂੰ ਚੈਨਲਾਂ ਰਾਹੀਂ ਦੂਜੇ ਨੋਡਾਂ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਜਾ ਸਕੇ। ਇੱਕ ਅਸਲੀ ਕੰਪਿਊਟਰ ਵਾਂਗ, ਇੱਕ ਨੋਡ ਨੂੰ ਕਈ ਡਿਵਾਈਸਾਂ ਰਾਹੀਂ ਕਈ ਚੈਨਲਾਂ ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਨੈੱਟ ਡਿਵਾਈਸ.

ਇੱਕ ਡਿਵਾਈਸ ਦੇ ਨੈਟਵਰਕ ਐਬਸਟਰੈਕਸ਼ਨ ਨੂੰ ਕਲਾਸ ਦੁਆਰਾ C++ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ NetDevice. ਕਲਾਸ NetDevice ਨੋਡ ਅਤੇ ਚੈਨਲ ਆਬਜੈਕਟ ਨਾਲ ਕਨੈਕਸ਼ਨਾਂ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਢੰਗ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ; ਅਤੇ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਆਬਜੈਕਟ-ਓਰੀਐਂਟਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਅਰਥਾਂ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ NetDevice ਨਾਮ ਦੇ ਕਈ ਵਿਸ਼ੇਸ਼ ਸੰਸਕਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ CsmaNetDevice, PointToPointNetDevice и WifiNetDevice. ਜਿਵੇਂ ਕਿ ਇੱਕ ਈਥਰਨੈੱਟ ਨੈਟਵਰਕ ਅਡਾਪਟਰ ਇੱਕ ਨੈਟਵਰਕ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਈਥਰਨੈੱਟ, CsmaNetDevice ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ CsmaChannel, PointToPointNetDevice ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ PointToPointChannelਅਤੇ WifiNetDevice - ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ Wifi ਚੈਨਲ.

4.1.5 ਟੌਪੋਲੋਜੀਕਲ ਸਹਾਇਕ

ਇੱਕ ਅਸਲੀ ਨੈੱਟਵਰਕ ਵਿੱਚ, ਤੁਸੀਂ ਮੇਜ਼ਬਾਨ ਕੰਪਿਊਟਰਾਂ ਨੂੰ ਪਾਓਗੇ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਨੈੱਟਵਰਕ ਕਾਰਡ ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਹਨ (ਜਾਂ ਬਿਲਟ-ਇਨ)। ns-3 ਵਿੱਚ ਅਸੀਂ ਕਹਾਂਗੇ ਕਿ ਤੁਸੀਂ NetDevices ਨਾਲ ਜੁੜੇ ਨੋਡ ਵੇਖੋਗੇ। ਇੱਕ ਵੱਡੇ ਸਿਮੂਲੇਟਿਡ ਨੈਟਵਰਕ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਵਿਚਕਾਰ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ ਨੋਡ, NetDevice и ਚੈਨਲ.

NetDevices ਨੂੰ ਨੋਡਾਂ ਨਾਲ ਕਨੈਕਟ ਕਰਨ ਤੋਂ ਲੈ ਕੇ, NetDevices ਨੂੰ ਲਿੰਕਾਂ ਨਾਲ ਜੋੜਨਾ, IP ਐਡਰੈੱਸ ਨਿਰਧਾਰਤ ਕਰਨਾ, ਆਦਿ। ns-3 ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ, ਇਸ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਅਸੀਂ ਅਖੌਤੀ ਟੋਪੋਲੋਜੀ ਸਹਾਇਕ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ NetDevice ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੇ ns-3 ਕਰਨਲ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇੱਕ MAC ਐਡਰੈੱਸ ਜੋੜਨਾ, ਨੋਡ ਵਿੱਚ ਨੈੱਟਵਰਕ ਜੰਤਰ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨਾ, ਨੋਡ ਦੇ ਪ੍ਰੋਟੋਕੋਲ ਸਟੈਕ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨਾ, ਅਤੇ ਫਿਰ NetDevice ਨੂੰ ਚੈਨਲ ਨਾਲ ਕਨੈਕਟ ਕਰਨਾ। ਮਲਟੀਪੁਆਇੰਟ ਲਿੰਕਾਂ ਨਾਲ ਕਈ ਡਿਵਾਈਸਾਂ ਨੂੰ ਕਨੈਕਟ ਕਰਨ ਅਤੇ ਫਿਰ ਵਿਅਕਤੀਗਤ ਨੈੱਟਵਰਕਾਂ ਨੂੰ ਇੱਕ ਇੰਟਰਨੈਟਵਰਕਸ ਨੈਟਵਰਕ ਵਿੱਚ ਜੋੜਨ ਲਈ ਹੋਰ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਅਸੀਂ ਟੌਪੋਲੋਜੀ ਹੈਲਪਰ ਆਬਜੈਕਟ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ ਜੋ ਤੁਹਾਡੀ ਸਹੂਲਤ ਲਈ ਇਹਨਾਂ ਬਹੁਤ ਸਾਰੇ ਓਪਰੇਸ਼ਨਾਂ ਨੂੰ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਮਾਡਲ ਵਿੱਚ ਜੋੜਦੇ ਹਨ।

4.2 ਪਹਿਲੀ ns-3 ਸਕ੍ਰਿਪਟ

ਜੇਕਰ ਤੁਸੀਂ ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ ਸਿਸਟਮ ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੀ ਹੋਮ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੈਪੋਜ਼ ਨਾਮਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ns-3 ਰਿਲੀਜ਼ ਹੋਵੇਗੀ। ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਓ ਰੀਲਿਜ਼

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਅਜਿਹੀ ਕੋਈ ਡਾਇਰੈਕਟਰੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ns-3 ਦੇ ਰੀਲੀਜ਼ ਸੰਸਕਰਣ ਨੂੰ ਬਣਾਉਂਦੇ ਸਮੇਂ ਆਉਟਪੁੱਟ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ, ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਓ:
$./waf ਸੰਰਚਨਾ —build-profile=release —out=build/release,
$ ./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

ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਓ ਉਦਾਹਰਣਾਂ/ਟਿਊਟੋਰਿਅਲ. ਤੁਹਾਨੂੰ ਉੱਥੇ ਸਥਿਤ ਇੱਕ ਫਾਈਲ ਦਿਖਾਈ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ ਜਿਸ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ first.cc. ਇਹ ਇੱਕ ਸਕ੍ਰਿਪਟ ਹੈ ਜੋ ਦੋ ਨੋਡਾਂ ਵਿਚਕਾਰ ਇੱਕ ਸਧਾਰਨ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਕਨੈਕਸ਼ਨ ਬਣਾਏਗੀ ਅਤੇ ਨੋਡਾਂ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਪੈਕੇਟ ਪ੍ਰਸਾਰਿਤ ਕਰੇਗੀ। ਆਉ ਇਸ ਸਕ੍ਰਿਪਟ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਵੇਖੀਏ;

4.2.1 ਬੋਇਲਰਪਲੇਟ ਕੋਡ
ਫਾਈਲ ਵਿੱਚ ਪਹਿਲੀ ਲਾਈਨ ਐਡੀਟਰ ਮੋਡ ਲਾਈਨ ਹੈ emacs. ਇਹ emacs ਨੂੰ ਫਾਰਮੈਟਿੰਗ ਕਨਵੈਨਸ਼ਨਾਂ (ਕੋਡਿੰਗ ਸਟਾਈਲ) ਬਾਰੇ ਦੱਸਦਾ ਹੈ ਜੋ ਅਸੀਂ ਆਪਣੇ ਸਰੋਤ ਕੋਡ ਵਿੱਚ ਵਰਤਦੇ ਹਾਂ।

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

ਇਹ ਹਮੇਸ਼ਾ ਇੱਕ ਵਿਵਾਦਪੂਰਨ ਮੁੱਦਾ ਹੁੰਦਾ ਹੈ, ਇਸਲਈ ਸਾਨੂੰ ਇਸ ਨੂੰ ਤੁਰੰਤ ਬਾਹਰ ਕੱਢਣ ਲਈ ਰਿਕਾਰਡ ਨੂੰ ਸਿੱਧਾ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ns-3 ਪ੍ਰੋਜੈਕਟ, ਜਿਵੇਂ ਕਿ ਜ਼ਿਆਦਾਤਰ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟਾਂ ਨੇ, ਇੱਕ ਕੋਡਿੰਗ ਸ਼ੈਲੀ ਨੂੰ ਅਪਣਾਇਆ ਹੈ ਜਿਸਦਾ ਸਾਰੇ ਯੋਗਦਾਨ ਵਾਲੇ ਕੋਡ ਦੇ ਅਨੁਕੂਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਆਪਣਾ ਕੋਡ ਯੋਗਦਾਨ ਪਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਅੰਤ ਵਿੱਚ ns-3 ਕੋਡਿੰਗ ਸਟੈਂਡਰਡ ਦੇ ਅਨੁਕੂਲ ਹੋਣਾ ਪਵੇਗਾ, ਜਿਵੇਂ ਕਿ ਫਾਈਲ ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ doc/codingstd.txt ਜਾਂ ਪ੍ਰੋਜੈਕਟ ਵੈਬ ਪੇਜ 'ਤੇ ਦਿਖਾਇਆ ਗਿਆ ਹੈ: https://www.nsnam.org/develop/contributing-code/coding-style/.

ਅਸੀਂ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ns-3 ਕੋਡ ਦੀ ਦਿੱਖ ਅਤੇ ਅਨੁਭਵ ਦੀ ਆਦਤ ਪਾਓ ਅਤੇ ਜਦੋਂ ਵੀ ਤੁਸੀਂ ਸਾਡੇ ਕੋਡ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ ਤਾਂ ਇਸ ਮਿਆਰ ਨੂੰ ਲਾਗੂ ਕਰੋ। ਸਮੁੱਚੀ ਵਿਕਾਸ ਟੀਮ ਅਤੇ ਯੋਗਦਾਨ ਪਾਉਣ ਵਾਲਿਆਂ ਨੇ ਕੁਝ ਕੁ ਰੌਲਾ ਪਾਉਣ ਤੋਂ ਬਾਅਦ ਇਸ ਲਈ ਸਹਿਮਤੀ ਦਿੱਤੀ। ਜੇਕਰ ਤੁਸੀਂ emacs ਸੰਪਾਦਕ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਉੱਪਰ ਦਿੱਤੀ emacs ਮੋਡ ਲਾਈਨ ਸਹੀ ਢੰਗ ਨਾਲ ਫਾਰਮੈਟ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ।

ns-3 ਸਿਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹੈ ਜੀ ਐਨ ਯੂ ਜਨਰਲ ਪਬਲਿਕ ਲਾਇਸੈਂਸ. ਤੁਸੀਂ ਹਰੇਕ ns-3 ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਫਾਈਲ ਵਿੱਚ ਉਚਿਤ GNU ਕਾਨੂੰਨੀ ਸਿਰਲੇਖ ਵੇਖੋਗੇ। ਅਕਸਰ ਤੁਸੀਂ ਹੇਠਾਂ ਦਿਖਾਏ ਗਏ GPL ਟੈਕਸਟ ਅਤੇ ਲੇਖਕ ਦੇ ਉੱਪਰ ns-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/core-module.h ns-3 ਮੋਡੀਊਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਮਿਲੇਗਾ src/core ਤੁਹਾਡੇ ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤੀ ਰੀਲੀਜ਼ ਵਿੱਚ. ਇਸ ਡਾਇਰੈਕਟਰੀ ਦੀ ਸੂਚੀ ਵਿੱਚ ਤੁਹਾਨੂੰ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਹੈਡਰ ਫਾਈਲਾਂ ਮਿਲਣਗੀਆਂ। ਜਦੋਂ ਤੁਸੀਂ ਵਿਧਾਨ ਸਭਾ ਕਰਦੇ ਹੋ, ਵਾਫ ਜਨਤਕ ਸਿਰਲੇਖ ਫਾਈਲਾਂ ਨੂੰ ਇੱਕ ਸਬ-ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ns3 ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਰੱਖਦਾ ਹੈ ਬਿਲਡ/ਡੀਬੱਗ

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਅਜਿਹੀ ਕੋਈ ਡਾਇਰੈਕਟਰੀ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ns-3 ਦੇ ਰੀਲੀਜ਼ ਸੰਸਕਰਣ ਨੂੰ ਬਣਾਉਂਦੇ ਸਮੇਂ ਆਉਟਪੁੱਟ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤਾ, ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਓ:
$./waf ਸੰਰਚਨਾ --build-profile=debug --out=build/debug
$ ./waf ਬਿਲਡ
ਜ
$./waf ਸੰਰਚਨਾ --build-profile=optimized --out=build/optimized
$ ./waf ਬਿਲਡ

ਜ ਬਿਲਡ/ਅਨੁਕੂਲਿਤ, ਤੁਹਾਡੀ ਸੰਰਚਨਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਵਾਫ ਸਾਰੀਆਂ ਜਨਤਕ ਸਿਰਲੇਖ ਫਾਈਲਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਫਾਈਲ ਨੂੰ ਵੀ ਆਪਣੇ ਆਪ ਤਿਆਰ ਕਰੇਗਾ। ਕਿਉਂਕਿ ਤੁਸੀਂ ਬੇਸ਼ੱਕ ਇਸ ਗਾਈਡ ਦੀ ਧਾਰਮਿਕ ਤੌਰ 'ਤੇ ਪਾਲਣਾ ਕਰ ਰਹੇ ਹੋ, ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕਰ ਚੁੱਕੇ ਹੋ

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

ਡੀਬੱਗ ਬਿਲਡਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਜਿਸ ਵਿੱਚ ਉਦਾਹਰਣਾਂ ਅਤੇ ਟੈਸਟ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਤੁਸੀਂ ਵੀ ਕੀਤਾ ਸੀ

$ ./waf

ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਲਈ. ਇਸ ਲਈ ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਦੇਖਦੇ ਹੋ ../../build/debug/ns3, ਫਿਰ ਉੱਥੇ ਤੁਸੀਂ ਉੱਪਰ ਦਿਖਾਏ ਗਏ ਚਾਰ ਮੋਡੀਊਲਾਂ ਦੇ ਸਿਰਲੇਖ ਫਾਈਲਾਂ ਨੂੰ ਹੋਰਾਂ ਦੇ ਵਿਚਕਾਰ ਪਾਓਗੇ। ਤੁਸੀਂ ਇਹਨਾਂ ਫਾਈਲਾਂ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ ਅਤੇ ਲੱਭ ਸਕਦੇ ਹੋ ਕਿ ਉਹਨਾਂ ਵਿੱਚ ਸੰਬੰਧਿਤ ਮੋਡੀਊਲ ਦੁਆਰਾ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਸਾਰੀਆਂ ਜਨਤਕ ਫਾਈਲਾਂ ਸ਼ਾਮਲ ਹਨ।

4.2.3 ns3 ਨਾਮਸਪੇਸ

ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਗਲੀ ਲਾਈਨ first.cc ਇੱਕ ਨੇਮਸਪੇਸ ਘੋਸ਼ਣਾ ਹੈ।

using namespace ns3;

ns-3 ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਇੱਕ C++ ਨੇਮਸਪੇਸ ਵਿੱਚ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਸਨੂੰ ns3 ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਸਾਰੇ ns-3-ਸਬੰਧਤ ਘੋਸ਼ਣਾਵਾਂ ਨੂੰ ਗਲੋਬਲ ਨੇਮਸਪੇਸ ਤੋਂ ਬਾਹਰ ਇੱਕ ਦਾਇਰੇ ਵਿੱਚ ਸਮੂਹ ਕਰਦਾ ਹੈ, ਜੋ ਉਮੀਦ ਹੈ ਕਿ ਦੂਜੇ ਕੋਡ ਨਾਲ ਏਕੀਕਰਣ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ। C++ ਆਪਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਮੌਜੂਦਾ (ਗਲੋਬਲ) ਘੋਸ਼ਣਾਤਮਕ ਖੇਤਰ ਵਿੱਚ ns-3 ਨਾਮ-ਸਪੇਸ ਪੇਸ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਕਹਿਣ ਦਾ ਇੱਕ ਸ਼ਾਨਦਾਰ ਤਰੀਕਾ ਹੈ ਕਿ ਇਸ ਘੋਸ਼ਣਾ ਤੋਂ ਬਾਅਦ, ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਵਰਤਣ ਲਈ ਆਪਣੇ ਸਾਰੇ ns-3 ਕੋਡ ਤੋਂ ਪਹਿਲਾਂ ns3::scope ਅਨੁਮਤੀ ਆਪਰੇਟਰ ਨੂੰ ਟਾਈਪ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੋਵੇਗੀ। ਜੇਕਰ ਤੁਸੀਂ ਨੇਮਸਪੇਸ ਤੋਂ ਜਾਣੂ ਨਹੀਂ ਹੋ, ਤਾਂ ਲਗਭਗ ਕਿਸੇ ਵੀ C++ ਪਾਠ ਪੁਸਤਕ ਦਾ ਹਵਾਲਾ ਦਿਓ ਅਤੇ std ਨੇਮਸਪੇਸ ਅਤੇ ਘੋਸ਼ਣਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ns3 ਨੇਮਸਪੇਸ ਦੀ ਤੁਲਨਾ ਕਰੋ। using namespace std; ਆਉਟਪੁੱਟ ਆਪਰੇਟਰ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਵਿੱਚ cout ਅਤੇ ਧਾਰਾਵਾਂ।

4.2.4 ਲਾਗਿੰਗ

ਸਕ੍ਰਿਪਟ ਦੀ ਅਗਲੀ ਲਾਈਨ ਹੈ,

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

ਅਸੀਂ ਇਸ ਕਥਨ ਦੀ ਵਰਤੋਂ ਆਪਣੇ ਦਸਤਾਵੇਜ਼ ਪ੍ਰਣਾਲੀ 'ਤੇ ਚਰਚਾ ਕਰਨ ਲਈ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਜਗ੍ਹਾ ਵਜੋਂ ਕਰਾਂਗੇ ਆਕਸੀਜਨ. ਜੇਕਰ ਤੁਸੀਂ ns-3 ਪ੍ਰੋਜੈਕਟ ਵੈੱਬਸਾਈਟ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਨੈਵੀਗੇਸ਼ਨ ਬਾਰ ਵਿੱਚ ਇੱਕ ਦਸਤਾਵੇਜ਼ ਲਿੰਕ ਮਿਲੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਸਾਡੇ ਦਸਤਾਵੇਜ਼ ਪੰਨੇ 'ਤੇ ਲਿਜਾਇਆ ਜਾਵੇਗਾ। ਇੱਥੇ ਇੱਕ "ਨਵੀਨਤਮ ਰਿਲੀਜ਼" ਲਿੰਕ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ns-3 ਦੇ ਨਵੀਨਤਮ ਸਥਿਰ ਸੰਸਕਰਣ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਲੈ ਜਾਵੇਗਾ। ਜੇਕਰ ਤੁਸੀਂ "API ਦਸਤਾਵੇਜ਼" ਲਿੰਕ ਚੁਣਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ns-3 API ਦਸਤਾਵੇਜ਼ ਪੰਨੇ 'ਤੇ ਲਿਜਾਇਆ ਜਾਵੇਗਾ।

ਪੰਨੇ ਦੇ ਖੱਬੇ ਪਾਸੇ ਤੁਹਾਨੂੰ ਦਸਤਾਵੇਜ਼ੀ ਢਾਂਚੇ ਦੀ ਗ੍ਰਾਫਿਕਲ ਪ੍ਰਤੀਨਿਧਤਾ ਮਿਲੇਗੀ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਚੰਗੀ ਥਾਂ ns-3 ਨੈਵੀਗੇਸ਼ਨ ਟ੍ਰੀ ਵਿੱਚ ਮੋਡੀਊਲ ns-3 "ਕਿਤਾਬ" ਹੈ। ਜੇ ਤੁਸੀਂ ਪ੍ਰਗਟ ਕਰੋ ਮੋਡੀਊਲ, ਤੁਸੀਂ ns-3 ਮੋਡੀਊਲ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਵੇਖੋਗੇ। ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ, ਇੱਥੇ ਇੱਕ ਮੋਡੀਊਲ ਦੀ ਧਾਰਨਾ ਉੱਪਰਲੇ ਮੋਡੀਊਲ ਵਿੱਚ ਸ਼ਾਮਲ ਫਾਈਲਾਂ ਨਾਲ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸੰਬੰਧਿਤ ਹੈ। ns-3 ਲਾਗਿੰਗ ਸਬ-ਸਿਸਟਮ ਦੀ ਚਰਚਾ ਭਾਗ ਵਿੱਚ ਕੀਤੀ ਗਈ ਹੈ ਲੌਗਿੰਗ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਇਸ ਲਈ ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਇਸ 'ਤੇ ਵਾਪਸ ਆਵਾਂਗੇ, ਪਰ ਤੁਸੀਂ ਮੋਡੀਊਲ ਨੂੰ ਦੇਖ ਕੇ ਉਪਰੋਕਤ ਕਥਨ ਬਾਰੇ ਜਾਣ ਸਕਦੇ ਹੋ। ਕੋਰਅਤੇ ਫਿਰ ਕਿਤਾਬ ਨੂੰ ਖੋਲ੍ਹਣਾ ਡੀਬੱਗਿੰਗ ਟੂਲਅਤੇ ਫਿਰ ਪੰਨਾ ਚੁਣਨਾ ਲਾਗ. 'ਤੇ ਕਲਿੱਕ ਕਰੋ ਲਾਗ.

ਤੁਹਾਨੂੰ ਹੁਣ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਆਕਸੀਜਨ ਮੋਡੀਊਲ ਲਈ ਲਾਗ. ਪੰਨੇ ਦੇ ਸਿਖਰ 'ਤੇ ਮੈਕਰੋ ਦੀ ਸੂਚੀ ਵਿੱਚ, ਤੁਸੀਂ 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 ਟੋਪੋਲੋਜੀ ਸਹਾਇਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਸਾਡੀ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਅਗਲੀਆਂ ਦੋ ਲਾਈਨਾਂ ਅਸਲ ਵਿੱਚ ਨੋਡ ns-3 ਆਬਜੈਕਟ ਬਣਾਉਣਗੀਆਂ ਜੋ ਸਿਮੂਲੇਸ਼ਨ ਵਿੱਚ ਕੰਪਿਊਟਰਾਂ ਨੂੰ ਦਰਸਾਉਣਗੀਆਂ।

NodeContainer nodes;
nodes.Create (2);

ਜਾਰੀ ਰੱਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਕਲਾਸ ਲਈ ਦਸਤਾਵੇਜ਼ ਲੱਭੀਏ ਨੋਡ ਕੰਟੇਨਰ. ਕਿਸੇ ਦਿੱਤੀ ਗਈ ਕਲਾਸ ਲਈ ਦਸਤਾਵੇਜ਼ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਹੈ ਟੈਬ ਰਾਹੀਂ ਇੱਕਸੁਰ ਪੰਨਿਆਂ 'ਤੇ ਆਕਸੀਜਨ. ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਡੌਕਸੀਜਨ ਖੁੱਲ੍ਹਾ ਹੈ, ਤਾਂ ਬਸ ਪੰਨੇ ਦੇ ਸਿਖਰ ਤੱਕ ਸਕ੍ਰੋਲ ਕਰੋ ਅਤੇ ਕਲਾਸਾਂ ਟੈਬ ਨੂੰ ਚੁਣੋ। ਤੁਹਾਨੂੰ ਟੈਬਾਂ ਦਾ ਇੱਕ ਨਵਾਂ ਸੈੱਟ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਸ ਵਿੱਚੋਂ ਇੱਕ ਕਲਾਸਾਂ ਦੀ ਸੂਚੀ ਹੈ। ਇਸ ਟੈਬ ਦੇ ਹੇਠਾਂ ਤੁਸੀਂ ਸਾਰੀਆਂ NS-3 ਕਲਾਸਾਂ ਦੀ ਸੂਚੀ ਵੇਖੋਗੇ। ਤੱਕ ਹੇਠਾਂ ਸਕ੍ਰੋਲ ਕਰੋ ns3::ਨੋਡ ਕੰਟੇਨਰ. ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਕਲਾਸ ਲੱਭਦੇ ਹੋ, ਤਾਂ ਕਲਾਸ ਲਈ ਦਸਤਾਵੇਜ਼ਾਂ 'ਤੇ ਜਾਣ ਲਈ ਇਸਨੂੰ ਚੁਣੋ।

ਜਿਵੇਂ ਕਿ ਸਾਨੂੰ ਯਾਦ ਹੈ, ਸਾਡੇ ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੋਡ ਹੈ। ਇਹ ਉਸ ਕੰਪਿਊਟਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਪ੍ਰੋਟੋਕੋਲ ਸਟੈਕ, ਐਪਲੀਕੇਸ਼ਨ, ਅਤੇ ਪੈਰੀਫਿਰਲ ਕਾਰਡ ਵਰਗੀਆਂ ਚੀਜ਼ਾਂ ਜੋੜਨ ਜਾ ਰਹੇ ਹਾਂ। ਟੋਪੋਲੋਜੀ ਸਹਾਇਕ ਨੋਡ ਕੰਟੇਨਰ ਕਿਸੇ ਵੀ ਵਸਤੂ ਨੂੰ ਬਣਾਉਣ, ਪ੍ਰਬੰਧਨ ਅਤੇ ਐਕਸੈਸ ਕਰਨ ਦਾ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਨੋਡ, ਜੋ ਅਸੀਂ ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਲਈ ਬਣਾਉਂਦੇ ਹਾਂ। ਉਪਰੋਕਤ ਪਹਿਲੀ ਲਾਈਨ ਸਿਰਫ਼ ਐਲਾਨ ਕਰਦੀ ਹੈ ਨੋਡ ਕੰਟੇਨਰ, ਜਿਸਨੂੰ ਅਸੀਂ ਨੋਡ ਕਹਿੰਦੇ ਹਾਂ। ਦੂਜੀ ਲਾਈਨ ਨੋਡ ਆਬਜੈਕਟ ਉੱਤੇ ਬਣਾਓ ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ ਅਤੇ ਕੰਟੇਨਰ ਨੂੰ ਦੋ ਨੋਡ ਬਣਾਉਣ ਲਈ ਕਹਿੰਦੀ ਹੈ। ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ ਆਕਸੀਜਨ, ਕੰਟੇਨਰ ns-3 ਸਿਸਟਮ ਨੂੰ ਦੋ ਆਬਜੈਕਟ ਬਣਾਉਣ ਲਈ ਬੇਨਤੀ ਕਰਦਾ ਹੈ ਨੋਡ ਅਤੇ ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਇਹਨਾਂ ਵਸਤੂਆਂ ਲਈ ਪੁਆਇੰਟਰ ਸਟੋਰ ਕਰਦਾ ਹੈ।

ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਬਣਾਏ ਗਏ ਨੋਡ ਅਜੇ ਕੁਝ ਨਹੀਂ ਕਰਦੇ ਹਨ। ਟੌਪੋਲੋਜੀ ਬਣਾਉਣ ਦਾ ਅਗਲਾ ਕਦਮ ਸਾਡੇ ਨੋਡਾਂ ਨੂੰ ਨੈੱਟਵਰਕ ਨਾਲ ਜੋੜ ਰਿਹਾ ਹੈ। ਨੈਟਵਰਕ ਦਾ ਸਭ ਤੋਂ ਸਰਲ ਰੂਪ ਜਿਸਦਾ ਅਸੀਂ ਸਮਰਥਨ ਕਰਦੇ ਹਾਂ ਦੋ ਨੋਡਾਂ ਵਿਚਕਾਰ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਕੁਨੈਕਸ਼ਨ ਹੈ। ਅਸੀਂ ਹੁਣ ਅਜਿਹਾ ਕੁਨੈਕਸ਼ਨ ਬਣਾਵਾਂਗੇ।

PointToPointHelper

ਅਸੀਂ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਕੁਨੈਕਸ਼ਨ ਬਣਾਉਂਦੇ ਹਾਂ, ਕੁਨੈਕਸ਼ਨ ਲਈ ਲੋੜੀਂਦੇ ਹੇਠਲੇ-ਪੱਧਰ ਦੇ ਕੰਮ ਨੂੰ ਕਰਨ ਲਈ ਇੱਕ ਟੌਪੋਲੋਜੀ ਸਹਾਇਕ ਵਸਤੂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। ਯਾਦ ਕਰੋ ਕਿ ਸਾਡੇ ਦੋ ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨ NetDevice и ਚੈਨਲ. ਅਸਲ ਸੰਸਾਰ ਵਿੱਚ, ਇਹ ਸ਼ਬਦ ਮੋਟੇ ਤੌਰ 'ਤੇ ਪੈਰੀਫਿਰਲ ਕਾਰਡਾਂ ਅਤੇ ਨੈੱਟਵਰਕ ਕੇਬਲਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ। ਆਮ ਤੌਰ 'ਤੇ, ਇਹ ਦੋਵੇਂ ਚੀਜ਼ਾਂ ਇਕ ਦੂਜੇ ਨਾਲ ਨੇੜਿਓਂ ਜੁੜੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਕੋਈ ਵੀ ਸਾਂਝਾ ਕਰਨ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰ ਸਕਦਾ, ਉਦਾਹਰਨ ਲਈ, ਡਿਵਾਈਸਾਂ ਈਥਰਨੈੱਟ ਇੱਕ ਵਾਇਰਲੈੱਸ ਚੈਨਲ ਉੱਤੇ. ਸਾਡੇ ਟੌਪੌਲੋਜੀ ਸਹਾਇਕ ਇਸ ਨਜ਼ਦੀਕੀ ਰਿਸ਼ਤੇ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹਨ ਅਤੇ ਇਸਲਈ ਤੁਸੀਂ ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਵਸਤੂ ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ PointToPointHelper ns-3 ਵਸਤੂਆਂ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਜੋੜਨ ਲਈ PointToPointNetDevice и PointToPointChannel. ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਅਗਲੀਆਂ ਤਿੰਨ ਲਾਈਨਾਂ:

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

ਪਹਿਲੀ ਲਾਈਨ,

PointToPointHelper pointToPoint;

ਸਟੈਕ ਉੱਤੇ ਇੱਕ ਵਸਤੂ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਬਣਾਉਂਦਾ ਹੈ PointToPointHelper. ਉੱਚ ਪੱਧਰੀ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਹੇਠਲੀ ਲਾਈਨ,

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

ਵਸਤੂ ਨੂੰ ਦੱਸਦਾ ਹੈ PointToPointHelper ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰੋ "5 Mbit/s" (ਪੰਜ ਮੈਗਾਬਿਟ ਪ੍ਰਤੀ ਸਕਿੰਟ)ਡਾਟਾ ਦਰ".

ਵਧੇਰੇ ਖਾਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਸਤਰ "ਡਾਟਾਰੇਟ" ਉਸ ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਕਹਿੰਦੇ ਹਾਂ PointToPointNetDevice. ਜੇ ਤੁਸੀਂ ਦੇਖਦੇ ਹੋ ਆਕਸੀਜਨ ਕਲਾਸ ਲਈ ns3::PointToPointNetDevice ਅਤੇ ਵਿਧੀ ਲਈ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ GetTypeId ਤੁਹਾਨੂੰ ਡਿਵਾਈਸ ਲਈ ਪਰਿਭਾਸ਼ਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਮਿਲੇਗੀ। ਉਹਨਾਂ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ਤਾ ਹੋਵੇਗੀ "ਡਾਟਾ ਦਰ" ਜ਼ਿਆਦਾਤਰ ਉਪਭੋਗਤਾ-ਦਿੱਖਣ ਵਾਲੇ ns-3 ਆਬਜੈਕਟਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀਆਂ ਸਮਾਨ ਸੂਚੀਆਂ ਹੁੰਦੀਆਂ ਹਨ। ਅਸੀਂ ਇਸ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਬਿਨਾਂ ਰੀਕੰਪਾਈਲੇਸ਼ਨ ਦੇ ਆਸਾਨੀ ਨਾਲ ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਲਈ ਕਰਦੇ ਹਾਂ, ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਦੇਖੋਗੇ।

ਦੇ ਵਰਗਾ "ਡਾਟਾ ਦਰ"PointToPointNetDevice ਵਿੱਚ, ਤੁਹਾਨੂੰ PointToPointChannel ਨਾਲ ਸੰਬੰਧਿਤ "ਦੇਰੀ" ਵਿਸ਼ੇਸ਼ਤਾ ਮਿਲੇਗੀ। ਅੰਤਮ ਲਾਈਨ

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

ਕਹਿੰਦਾ ਹੈ PointToPointHelper ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਲਿੰਕ ਲਈ ਪ੍ਰਸਾਰ ਦੇਰੀ ਮੁੱਲ ਵਜੋਂ "2 ms" (ਦੋ ਮਿਲੀਸਕਿੰਟ) ਮੁੱਲ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੋ ਇਹ ਬਾਅਦ ਵਿੱਚ ਬਣਾਉਂਦਾ ਹੈ।

ਨੈੱਟ ਡਿਵਾਇਸ ਕੰਟੇਨਰ

ਇਸ ਸਮੇਂ ਸਾਡੇ ਕੋਲ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਹੈ ਨੋਡ ਕੰਟੇਨਰ, ਜਿਸ ਵਿੱਚ ਦੋ ਨੋਡ ਹੁੰਦੇ ਹਨ। ਸਾਡੇ ਕੋਲ PointToPointHelper, ਜੋ ਕਿ ਵਸਤੂਆਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ PointToPointNetDevices ਅਤੇ PointToPointChannel ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਉਹਨਾਂ ਨੂੰ ਜੋੜਨਾ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਨੋਡ ਬਣਾਉਣ ਲਈ NodeContainer ਟੋਪੋਲੋਜੀ ਸਹਾਇਕ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ, ਅਸੀਂ ਪੁੱਛਾਂਗੇ PointToPointHelper ਸਾਡੇ ਡਿਵਾਈਸਾਂ ਦੀ ਰਚਨਾ, ਸੰਰਚਨਾ ਅਤੇ ਸਥਾਪਨਾ ਨਾਲ ਸੰਬੰਧਿਤ ਸਾਡੇ ਲਈ ਕੰਮ ਕਰੋ। ਸਾਨੂੰ ਸਾਰੀਆਂ ਬਣਾਈਆਂ ਵਸਤੂਆਂ ਦੀ ਸੂਚੀ ਦੀ ਲੋੜ ਹੈ NetDevice, ਇਸ ਲਈ ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ ਨੈੱਟ ਡਿਵਾਇਸ ਕੰਟੇਨਰ ਉਹਨਾਂ ਨੂੰ ਉਸੇ ਤਰ੍ਹਾਂ ਸਟੋਰ ਕਰਨ ਲਈ ਜਿਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਵਰਤਿਆ ਸੀ ਨੋਡ ਕੰਟੇਨਰ ਸਾਡੇ ਦੁਆਰਾ ਬਣਾਏ ਗਏ ਨੋਡਸ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ। ਕੋਡ ਦੀਆਂ ਅਗਲੀਆਂ ਦੋ ਲਾਈਨਾਂ,

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

ਡਿਵਾਈਸ ਅਤੇ ਚੈਨਲ ਸੈੱਟਅੱਪ ਨੂੰ ਪੂਰਾ ਕਰੋ। ਪਹਿਲੀ ਲਾਈਨ ਉੱਪਰ ਦੱਸੇ ਗਏ ਡਿਵਾਈਸ ਕੰਟੇਨਰ ਦੀ ਘੋਸ਼ਣਾ ਕਰਦੀ ਹੈ, ਅਤੇ ਦੂਜੀ ਮੁੱਖ ਕੰਮ ਕਰਦੀ ਹੈ। ਵਿਧੀ ਇੰਸਟਾਲ ਕਰੋ ਸਹੂਲਤ PointToPointHelper ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਨੋਡ ਕੰਟੇਨਰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ ਤੇ. ਅੰਦਰ ਨੈੱਟ ਡਿਵਾਇਸ ਕੰਟੇਨਰ ਵਿੱਚ ਸਥਿਤ ਹਰੇਕ ਨੋਡ ਲਈ ਨੋਡ ਕੰਟੇਨਰ ਬਣਾਇਆ ਗਿਆ ਹੈ (ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਸੰਚਾਰ ਲਈ ਉਹਨਾਂ ਵਿੱਚੋਂ ਬਿਲਕੁਲ ਦੋ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ) PointToPointNetDevice ਡਿਵਾਈਸ ਕੰਟੇਨਰ ਵਿੱਚ ਬਣਾਇਆ ਅਤੇ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। PointToPointChannel ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਦੋ ਇਸ ਨਾਲ ਜੁੜੇ ਹੋਏ ਹਨ PointToPointNetDevices. ਆਬਜੈਕਟ ਬਣਾਉਣ ਤੋਂ ਬਾਅਦ, ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ PointToPointHelper, ਬਣਾਈਆਂ ਗਈਆਂ ਵਸਤੂਆਂ ਵਿੱਚ ਸੰਬੰਧਿਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਇੱਕ ਕਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ pointToPoint.Install (ਨੋਡ) ਸਾਡੇ ਕੋਲ ਦੋ ਨੋਡ ਹੋਣਗੇ, ਹਰੇਕ ਵਿੱਚ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਨੈੱਟਵਰਕ ਡਿਵਾਈਸ ਸਥਾਪਿਤ ਹੋਵੇਗੀ ਅਤੇ ਉਹਨਾਂ ਵਿਚਕਾਰ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਲਿੰਕ ਹੋਵੇਗਾ। ਦੋਵੇਂ ਡਿਵਾਈਸਾਂ ਨੂੰ ਚੈਨਲ 'ਤੇ ਦੋ ਮਿਲੀਸਕਿੰਟ ਦੀ ਪ੍ਰਸਾਰਣ ਦੇਰੀ ਨਾਲ ਪੰਜ ਮੈਗਾਬਿਟ ਪ੍ਰਤੀ ਸਕਿੰਟ ਦੀ ਗਤੀ ਨਾਲ ਡਾਟਾ ਸੰਚਾਰਿਤ ਕਰਨ ਲਈ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਵੇਗਾ।

InternetStackHelper

ਸਾਡੇ ਕੋਲ ਹੁਣ ਨੋਡ ਅਤੇ ਡਿਵਾਈਸਾਂ ਦੀ ਸੰਰਚਨਾ ਕੀਤੀ ਗਈ ਹੈ, ਪਰ ਸਾਡੇ ਨੋਡਾਂ ਵਿੱਚ ਪ੍ਰੋਟੋਕੋਲ ਸਟੈਕ ਸਥਾਪਤ ਨਹੀਂ ਹਨ। ਕੋਡ ਦੀਆਂ ਅਗਲੀਆਂ ਦੋ ਲਾਈਨਾਂ ਇਸ ਦਾ ਧਿਆਨ ਰੱਖਣਗੀਆਂ।

InternetStackHelper stack;
stack.Install (nodes);

InternetStackHelper - ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਨੈਟਵਰਕ ਡਿਵਾਈਸਾਂ ਲਈ PointToPointHelper ਦੇ ਸਮਾਨ, ਇੰਟਰਨੈਟ ਸਟੈਕ ਲਈ ਇੱਕ ਟੋਪੋਲੋਜੀ ਸਹਾਇਕ ਹੈ। ਢੰਗ ਇੰਸਟਾਲ ਕਰੋ NodeContainer ਨੂੰ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਲੈਂਦਾ ਹੈ। ਜਦੋਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਹਰੇਕ ਕੰਟੇਨਰ ਨੋਡ 'ਤੇ ਇੰਟਰਨੈੱਟ ਸਟੈਕ (TCP, UDP, IP, ਆਦਿ) ਨੂੰ ਸਥਾਪਿਤ ਕਰੇਗਾ।

IPv4AddressHelper

ਫਿਰ ਸਾਨੂੰ ਆਪਣੀਆਂ ਡਿਵਾਈਸਾਂ ਨੂੰ IP ਐਡਰੈੱਸ ਨਾਲ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ IP ਐਡਰੈੱਸ ਵੰਡ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਇੱਕ ਟੋਪੋਲੋਜੀ ਸਹਾਇਕ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ। ਉਪਭੋਗਤਾ ਨੂੰ ਦਿਖਾਈ ਦੇਣ ਵਾਲਾ ਇਕੋ API ਅਸਲ ਪਤਾ ਵੰਡਣ ਵੇਲੇ ਵਰਤਣ ਲਈ ਅਧਾਰ IP ਐਡਰੈੱਸ ਅਤੇ ਨੈੱਟਮਾਸਕ ਨੂੰ ਸੈੱਟ ਕਰ ਰਿਹਾ ਹੈ (ਇਹ ਸਹਾਇਕ ਦੇ ਅੰਦਰ ਹੇਠਲੇ ਪੱਧਰ 'ਤੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)। ਸਾਡੀ ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਅਗਲੀਆਂ ਦੋ ਲਾਈਨਾਂ first.cc,

Ipv4AddressHelper address;
address.SetBase ("10.1.1.0", "255.255.255.0");

ਐਡਰੈੱਸ ਹੈਲਪਰ ਆਬਜੈਕਟ ਘੋਸ਼ਿਤ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਦੱਸੋ ਕਿ ਇਸਨੂੰ ਨੈੱਟਵਰਕ 10.1.1.0 ਤੋਂ IP ਐਡਰੈੱਸ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ 255.255.255.0 ਬਿੱਟਮਾਸਕ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਪੂਰਵ-ਨਿਰਧਾਰਤ ਤੌਰ 'ਤੇ, ਨਿਰਧਾਰਤ ਪਤੇ ਇੱਕ ਤੋਂ ਸ਼ੁਰੂ ਹੋ ਜਾਣਗੇ ਅਤੇ ਮੋਨੋਟੋਨਿਕ ਤੌਰ 'ਤੇ ਵਧਣਗੇ, ਇਸਲਈ ਇਸ ਅਧਾਰ ਤੋਂ ਨਿਰਧਾਰਤ ਪਹਿਲਾ ਪਤਾ 10.1.1.1, ਫਿਰ 10.1.1.2, ਆਦਿ ਹੋਵੇਗਾ। ਵਾਸਤਵ ਵਿੱਚ, ਇੱਕ ਨੀਵੇਂ ਪੱਧਰ 'ਤੇ, ns-3 ਸਿਸਟਮ ਸਾਰੇ ਨਿਰਧਾਰਤ IP ਪਤਿਆਂ ਨੂੰ ਯਾਦ ਰੱਖਦਾ ਹੈ ਅਤੇ ਇੱਕ ਘਾਤਕ ਗਲਤੀ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਗਲਤੀ ਨਾਲ ਅਜਿਹੀ ਸਥਿਤੀ ਬਣਾਉਂਦੇ ਹੋ ਜਿੱਥੇ ਇੱਕੋ ਪਤਾ ਦੋ ਵਾਰ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਤਰੀਕੇ ਨਾਲ, ਇਸ ਗਲਤੀ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੈ)।

ਕੋਡ ਦੀ ਹੇਠਲੀ ਲਾਈਨ,

Ipv4InterfaceContainer interfaces = address.Assign (devices);

ਅਸਲ ਪਤਾ ਅਸਾਈਨਮੈਂਟ ਕਰਦਾ ਹੈ। ns-3 ਵਿੱਚ ਅਸੀਂ ਇੱਕ IP ਐਡਰੈੱਸ ਅਤੇ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਡਿਵਾਈਸ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਕੁਨੈਕਸ਼ਨ ਸਥਾਪਤ ਕਰਦੇ ਹਾਂ IPv4 ਇੰਟਰਫੇਸ. ਜਿਵੇਂ ਕਿ ਸਾਨੂੰ ਕਈ ਵਾਰ ਬਾਅਦ ਵਿੱਚ ਵਰਤੋਂ ਲਈ ਸਹਾਇਕ ਦੁਆਰਾ ਬਣਾਏ ਨੈੱਟਵਰਕ ਡਿਵਾਈਸਾਂ ਦੀ ਸੂਚੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਸਾਨੂੰ ਕਈ ਵਾਰ ਵਸਤੂਆਂ ਦੀ ਸੂਚੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। IPv4 ਇੰਟਰਫੇਸ. IPv4 ਇੰਟਰਫੇਸ ਕੰਟੇਨਰ ਇਹ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਅਸੀਂ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਨੈੱਟਵਰਕ ਬਣਾਇਆ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਟੈਕ ਸਥਾਪਤ ਕੀਤੇ ਗਏ ਹਨ ਅਤੇ IP ਪਤੇ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਹਨ। ਹੁਣ ਸਾਨੂੰ ਟ੍ਰੈਫਿਕ ਪੈਦਾ ਕਰਨ ਲਈ ਹਰੇਕ ਨੋਡ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਲੋੜ ਹੈ।

4.2.7 ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ns-3 ਸਿਸਟਮ ਦਾ ਇੱਕ ਹੋਰ ਮੁੱਖ ਐਬਸਟਰੈਕਸ਼ਨ ਹੈ ਐਪਲੀਕੇਸ਼ਨ (ਐਪਲੀਕੇਸ਼ਨ)। ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਅਸੀਂ ਦੋ ਬੇਸ ਕਲਾਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਾਂ ਐਪਲੀਕੇਸ਼ਨ ns-3 ਨੂੰ ਬੁਲਾਇਆ ਗਿਆ UdpEchoServerApplication и UdpEchoClientApplication. ਜਿਵੇਂ ਕਿ ਪਿਛਲੇ ਕੇਸਾਂ ਵਿੱਚ, ਅਸੀਂ ਅਧਾਰ ਵਸਤੂਆਂ ਨੂੰ ਸੰਰਚਿਤ ਅਤੇ ਪ੍ਰਬੰਧਨ ਲਈ ਸਹਾਇਕ ਵਸਤੂਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇੱਥੇ ਅਸੀਂ ਵਰਤਦੇ ਹਾਂ UdpEchoServerHelper и UdpEchoClientHelpeਸਾਡੀ ਜ਼ਿੰਦਗੀ ਨੂੰ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਚੀਜ਼ਾਂ.

UdpEchoServerHelper

ਸਾਡੀ first.cc ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਦੀ ਵਰਤੋਂ ਸਾਡੇ ਦੁਆਰਾ ਪਹਿਲਾਂ ਬਣਾਏ ਗਏ ਨੋਡਾਂ ਵਿੱਚੋਂ ਇੱਕ 'ਤੇ UDP ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

UdpEchoServerHelper echoServer (9);

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

ਉਪਰੋਕਤ ਸਨਿੱਪਟ ਵਿੱਚ ਕੋਡ ਦੀ ਪਹਿਲੀ ਲਾਈਨ ਬਣਾਉਂਦੀ ਹੈ UdpEchoServerHelper. ਆਮ ਵਾਂਗ, ਇਹ ਆਪਣੇ ਆਪ ਵਿੱਚ ਕੋਈ ਐਪਲੀਕੇਸ਼ਨ ਨਹੀਂ ਹੈ, ਇਹ ਇੱਕ ਵਸਤੂ ਹੈ ਜੋ ਅਸਲ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰਦੀ ਹੈ। ਸਾਡੀਆਂ ਪਰੰਪਰਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਸਹਾਇਕ ਵਸਤੂ ਦੇ ਨਿਰਮਾਤਾ ਨੂੰ ਲੋੜੀਂਦੇ ਗੁਣਾਂ ਨੂੰ ਪਾਸ ਕਰਨਾ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਸਹਾਇਕ ਕੁਝ ਵੀ ਲਾਭਦਾਇਕ ਨਹੀਂ ਕਰ ਸਕਦਾ ਜਦੋਂ ਤੱਕ ਇਸਨੂੰ ਪੋਰਟ ਨੰਬਰ ਨਹੀਂ ਦਿੱਤਾ ਜਾਂਦਾ ਜਿਸ 'ਤੇ ਸਰਵਰ ਪੈਕੇਟਾਂ ਲਈ ਸੁਣੇਗਾ, ਇਹ ਨੰਬਰ ਗਾਹਕ ਨੂੰ ਵੀ ਜਾਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ ਸਹਾਇਕ ਨਿਰਮਾਤਾ ਨੂੰ ਪੋਰਟ ਨੰਬਰ ਪਾਸ ਕਰਦੇ ਹਾਂ। ਕੰਸਟਰਕਟਰ, ਬਦਲੇ ਵਿੱਚ, ਬਸ ਕਰਦਾ ਹੈ SetAttribute ਪਾਸ ਕੀਤੇ ਮੁੱਲ ਦੇ ਨਾਲ. ਬਾਅਦ ਵਿੱਚ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਪੋਰਟ ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਇੱਕ ਵੱਖਰਾ ਮੁੱਲ ਸੈੱਟ ਕਰਨ ਲਈ SetAttribute ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਹੋਰ ਕਈ ਸਹਾਇਕ ਵਸਤੂਆਂ ਵਾਂਗ, ਵਸਤੂ UdpEchoServerHelper ਇੱਕ ਢੰਗ ਹੈ ਇੰਸਟਾਲ ਕਰੋ. ਇਸ ਵਿਧੀ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਚਲਾਉਣਾ ਇੱਕ ਬੁਨਿਆਦੀ ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਹੋਸਟ ਨਾਲ ਜੋੜਦਾ ਹੈ। ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ ਵਿਧੀ ਇੰਸਟਾਲ ਕਰੋ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਨੋਡ ਕੰਟੇਨਰ ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਰੂਪ ਵਿੱਚ ਜਿਵੇਂ ਕਿ ਦੂਜਿਆਂ ਦੀ ਤਰ੍ਹਾਂ ਇੰਸਟਾਲ ਕਰੋ ਤਰੀਕੇ ਅਸੀਂ ਵੇਖੇ ਹਨ।

ਇੱਥੇ ਕੰਮ ਕਰਨ ਵਾਲਾ C++ ਪਰਿਵਰਤਨ ਵਿਧੀ ਦਾ ਨਤੀਜਾ ਲੈਂਦਾ ਹੈ node.Get(1) (ਜੋ ਨੋਡ ਆਬਜੈਕਟ ਲਈ ਇੱਕ ਸਮਾਰਟ ਪੁਆਇੰਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ - Ptr ) ਅਤੇ ਇਸਨੂੰ ਅਗਿਆਤ ਵਸਤੂ ਲਈ ਕੰਸਟਰਕਟਰ ਵਿੱਚ ਵਰਤਦਾ ਹੈ ਨੋਡ ਕੰਟੇਨਰਜੋ ਫਿਰ ਵਿਧੀ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇੰਸਟਾਲ ਕਰੋ. ਜੇਕਰ ਤੁਸੀਂ C++ ਕੋਡ ਵਿੱਚ ਇਹ ਨਿਰਧਾਰਿਤ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਸ ਵਿਧੀ ਦੇ ਦਸਤਖਤ ਨੂੰ ਕੰਪਾਇਲ ਅਤੇ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਅਪ੍ਰਤੱਖ ਰੂਪਾਂਤਰਣਾਂ ਵਿੱਚੋਂ ਦੇਖੋ।

ਹੁਣ ਅਸੀਂ ਇਹ ਦੇਖਦੇ ਹਾਂ echoServer.Install ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਬਾਰੇ UdpEchoServerApplication ਵਿੱਚ ਪਾਇਆ ਨੋਡ ਕੰਟੇਨਰਜਿਸ ਦੀ ਵਰਤੋਂ ਅਸੀਂ ਆਪਣੇ ਨੋਡਸ, ਇੰਡੈਕਸ 1 ਦੇ ਨਾਲ ਨੋਡ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕਰਦੇ ਹਾਂ। ਢੰਗ ਇੰਸਟਾਲ ਕਰੋ ਇੱਕ ਕੰਟੇਨਰ ਵਾਪਸ ਕਰੇਗਾ ਜਿਸ ਵਿੱਚ ਸਾਰੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਪੁਆਇੰਟਰ ਸ਼ਾਮਲ ਹਨ (ਇਸ ਕੇਸ ਵਿੱਚ ਇੱਕ, ਕਿਉਂਕਿ ਅਸੀਂ ਇੱਕ ਅਗਿਆਤ ਪਾਸ ਕੀਤਾ ਹੈ ਨੋਡ ਕੰਟੇਨਰ, ਇੱਕ ਨੋਡ ਰੱਖਦਾ ਹੈ) ਸਹਾਇਕ ਦੁਆਰਾ ਬਣਾਇਆ ਗਿਆ ਹੈ।

ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਇਹ ਦੱਸਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਟ੍ਰੈਫਿਕ ਕਦੋਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ "ਸ਼ੁਰੂ" ਅਤੇ ਇਸ ਤੋਂ ਇਲਾਵਾ ਇੱਕ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ ਜਦੋਂ ਇਸਨੂੰ ਬੰਦ ਕਰਨਾ ਹੈ "ਰੂਕੋ". ਅਸੀਂ ਦੋਵੇਂ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ। ਇਹ ਸਮਾਂ ਤਰੀਕਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੈੱਟ ਕੀਤੇ ਗਏ ਹਨ ਐਪਲੀਕੇਸ਼ਨ ਕੰਟੇਨਰ ਸ਼ੁਰੂ ਕਰੋ и ਰੂਕੋ. ਇਹ ਵਿਧੀਆਂ ਕਿਸਮ ਦੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀਆਂ ਹਨ ਟਾਈਮ. ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਅਸੀਂ C++ ਲੈਣ ਲਈ C++ ਪਰਿਵਰਤਨ ਦੇ ਇੱਕ ਸਪਸ਼ਟ ਕ੍ਰਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਡਬਲ 1.0 ਅਤੇ ਇਸਨੂੰ ਇੱਕ tns-3 ਟਾਈਮ ਆਬਜੈਕਟ ਵਿੱਚ ਬਦਲੋ ਜੋ ਸਕਿੰਟਾਂ ਵਿੱਚ ਬਦਲਣ ਲਈ ਸੈਕਿੰਡ ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਯਾਦ ਰੱਖੋ ਕਿ ਪਰਿਵਰਤਨ ਨਿਯਮਾਂ ਨੂੰ ਮਾਡਲ ਲੇਖਕ ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ C++ ਦੇ ਆਪਣੇ ਨਿਯਮ ਹਨ, ਇਸਲਈ ਤੁਸੀਂ ਹਮੇਸ਼ਾ ਉਹਨਾਂ ਪੈਰਾਮੀਟਰਾਂ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰ ਸਕਦੇ ਜਿਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਉਮੀਦ ਕੀਤੀ ਸੀ ਪਰਿਵਰਤਿਤ ਕੀਤੇ ਜਾ ਰਹੇ ਹਨ। ਦੋ ਲਾਈਨਾਂ

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

ਸਿਮੂਲੇਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਇੱਕ ਸਕਿੰਟ ਬਾਅਦ ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਚਾਲੂ (ਆਟੋਮੈਟਿਕ ਚਾਲੂ) ਕਰਨ ਅਤੇ ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਦਸ ਸਕਿੰਟਾਂ ਬਾਅਦ ਬੰਦ (ਬੰਦ) ਕਰਨ ਦਾ ਕਾਰਨ ਬਣੇਗਾ। ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਿ ਅਸੀਂ ਇੱਕ ਸਿਮੂਲੇਸ਼ਨ ਇਵੈਂਟ (ਐਪਲੀਕੇਸ਼ਨ ਸਟਾਪ ਇਵੈਂਟ) ਘੋਸ਼ਿਤ ਕੀਤਾ ਹੈ, ਜੋ ਕਿ ਦਸ ਸਕਿੰਟਾਂ ਵਿੱਚ ਚਲਾਇਆ ਜਾਵੇਗਾ, ਘੱਟੋ ਘੱਟ ਦਸ ਸਕਿੰਟਾਂ ਦਾ ਨੈਟਵਰਕ ਓਪਰੇਸ਼ਨ ਸਿਮੂਲੇਟ ਕੀਤਾ ਜਾਵੇਗਾ।

UdpEchoClientHelper

ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਈਕੋ ਲਗਭਗ ਸਰਵਰ ਦੇ ਸਮਾਨ ਤਰੀਕੇ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਇੱਕ ਅਧਾਰ ਵਸਤੂ ਹੈ UdpEchoClientApplication, ਜੋ ਕਿ ਨਿਯੰਤਰਿਤ ਹੈ
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. ਅਸੀਂ ਉਹਨਾਂ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਾਂ ਜੋ ਗੁਣਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ (ਸਹਾਇਕ ਦੇ ਅੰਦਰ). "ਰਿਮੋਟ ਐਡਰੈੱਸ" и "ਰਿਮੋਟਪੋਰਟ" ਸਹਾਇਕ ਨਿਰਮਾਤਾ ਨੂੰ ਲੋੜੀਂਦੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਸਾਡੇ ਸਮਝੌਤੇ ਦੇ ਅਨੁਸਾਰ।

ਆਓ ਯਾਦ ਰੱਖੀਏ ਕਿ ਅਸੀਂ ਵਰਤਿਆ IPv4 ਇੰਟਰਫੇਸ ਕੰਟੇਨਰ IP ਪਤਿਆਂ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਜੋ ਅਸੀਂ ਆਪਣੀਆਂ ਡਿਵਾਈਸਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਹੈ। ਇੰਟਰਫੇਸ ਕੰਟੇਨਰ ਵਿੱਚ ਨਲ ਇੰਟਰਫੇਸ ਨੋਡ ਕੰਟੇਨਰ ਵਿੱਚ ਨਲ ਨੋਡ ਦੇ IP ਐਡਰੈੱਸ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇਗਾ। ਇੰਟਰਫੇਸ ਕੰਟੇਨਰ ਵਿੱਚ ਪਹਿਲਾ ਇੰਟਰਫੇਸ ਨੋਡ ਕੰਟੇਨਰ ਵਿੱਚ ਪਹਿਲੇ ਨੋਡ ਦੇ IP ਐਡਰੈੱਸ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇਸ ਲਈ, ਕੋਡ ਦੀ ਪਹਿਲੀ ਲਾਈਨ (ਉਪਰੋਕਤ) ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਹਾਇਕ ਬਣਾਉਂਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਦੱਸਦੇ ਹਾਂ ਕਿ ਕਲਾਇੰਟ ਦਾ ਰਿਮੋਟ ਐਡਰੈੱਸ ਹੋਸਟ ਨੂੰ ਦਿੱਤਾ ਗਿਆ IP ਪਤਾ ਹੋਵੇਗਾ ਜਿੱਥੇ ਸਰਵਰ ਸਥਿਤ ਹੈ। ਅਸੀਂ ਇਹ ਵੀ ਕਹਿੰਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਪੋਰਟ ਨੌਂ 'ਤੇ ਭੇਜੇ ਜਾਣ ਵਾਲੇ ਪੈਕੇਟਾਂ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

"MaxPackets" ਵਿਸ਼ੇਸ਼ਤਾ ਕਲਾਇੰਟ ਨੂੰ ਦੱਸਦੀ ਹੈ ਕਿ ਅਸੀਂ ਸਿਮੂਲੇਸ਼ਨ ਦੌਰਾਨ ਵੱਧ ਤੋਂ ਵੱਧ ਪੈਕੇਟਾਂ ਦੀ ਕਿੰਨੀ ਗਿਣਤੀ ਭੇਜ ਸਕਦੇ ਹਾਂ। "ਇੰਟਰਵਲ" ਵਿਸ਼ੇਸ਼ਤਾ ਕਲਾਇੰਟ ਨੂੰ ਦੱਸਦੀ ਹੈ ਕਿ ਪੈਕੇਟਾਂ ਵਿਚਕਾਰ ਕਿੰਨਾ ਸਮਾਂ ਉਡੀਕ ਕਰਨੀ ਹੈ, ਅਤੇ "ਪੈਕੇਟਸਾਈਜ਼" ਵਿਸ਼ੇਸ਼ਤਾ ਕਲਾਇੰਟ ਨੂੰ ਦੱਸਦੀ ਹੈ ਕਿ ਪੈਕੇਟ ਦਾ ਪੇਲੋਡ ਕਿੰਨਾ ਵੱਡਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਸੁਮੇਲ ਨਾਲ ਅਸੀਂ ਕਲਾਇੰਟ ਨੂੰ ਇੱਕ ਸਿੰਗਲ 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 ਸਕਿੰਟ 'ਤੇ ਅਨੁਸੂਚਿਤ ਇਵੈਂਟ ਨੂੰ ਫਾਇਰ ਕਰੇਗਾ ਜੋ ਈਕੋ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਲਾਂਚ ਕਰੇਗਾ। ਦੁਬਾਰਾ ਫਿਰ, ਇਸ ਇਵੈਂਟ ਵਿੱਚ ਕਈ ਹੋਰ ਸਮਾਗਮਾਂ ਦੀ ਯੋਜਨਾ ਹੋ ਸਕਦੀ ਹੈ। ਈਕੋ ਕਲਾਇੰਟ ਵਿੱਚ ਸ਼ੁਰੂਆਤੀ ਇਵੈਂਟ ਲਾਗੂ ਕਰਨਾ ਸਰਵਰ ਨੂੰ ਇੱਕ ਪੈਕੇਟ ਭੇਜ ਕੇ ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਪੜਾਅ ਨੂੰ ਸ਼ੁਰੂ ਕਰੇਗਾ।

ਸਰਵਰ ਨੂੰ ਇੱਕ ਪੈਕੇਟ ਭੇਜਣ ਦਾ ਕੰਮ ਘਟਨਾਵਾਂ ਦੀ ਇੱਕ ਲੜੀ ਨੂੰ ਚਾਲੂ ਕਰੇਗਾ ਜੋ ਪਰਦੇ ਦੇ ਪਿੱਛੇ ਆਪਣੇ ਆਪ ਨਿਯਤ ਕੀਤਾ ਜਾਵੇਗਾ ਅਤੇ ਜੋ ਸਾਡੇ ਦੁਆਰਾ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਸਮੇਂ ਦੇ ਮਾਪਦੰਡਾਂ ਦੇ ਅਨੁਸਾਰ ਇੱਕ ਈਕੋ ਪੈਕੇਟ ਭੇਜਣ ਦੇ ਮਕੈਨਿਕ ਨੂੰ ਲਾਗੂ ਕਰੇਗਾ।

ਨਤੀਜੇ ਵਜੋਂ, ਕਿਉਂਕਿ ਅਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਪੈਕੇਟ ਭੇਜ ਰਹੇ ਹਾਂ (ਯਾਦ ਰੱਖੋ, ਗੁਣ ਮੈਕਸ ਪੈਕੇਟ ਇੱਕ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਸੀ), ਇਸ ਸਿੰਗਲ ਕਲਾਇੰਟ ਪਿੰਗ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤੀਆਂ ਘਟਨਾਵਾਂ ਦੀ ਲੜੀ ਖਤਮ ਹੋ ਜਾਵੇਗੀ ਅਤੇ ਸਿਮੂਲੇਸ਼ਨ ਸਟੈਂਡਬਾਏ ਮੋਡ ਵਿੱਚ ਚਲਾ ਜਾਵੇਗਾ। ਇੱਕ ਵਾਰ ਅਜਿਹਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਬਾਕੀ ਅਨੁਸੂਚਿਤ ਇਵੈਂਟ ਇਵੈਂਟ ਹੋਣਗੇ ਰੂਕੋ ਸਰਵਰ ਅਤੇ ਕਲਾਇੰਟ ਲਈ. ਜਦੋਂ ਇਹਨਾਂ ਇਵੈਂਟਾਂ ਨੂੰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਅੱਗੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਲਈ ਕੋਈ ਵੀ ਇਵੈਂਟ ਨਹੀਂ ਬਚੇਗਾ ਅਤੇ ਸਿਮੂਲੇਟਰ::ਚਲਾਓ ਕੰਟਰੋਲ ਵਾਪਸ ਕਰ ਦੇਵੇਗਾ। ਸਿਮੂਲੇਸ਼ਨ ਪੂਰਾ ਹੋ ਗਿਆ ਹੈ।

ਜੋ ਬਚਦਾ ਹੈ ਉਹ ਹੈ ਆਪਣੇ ਆਪ ਨੂੰ ਸਾਫ਼ ਕਰਨਾ. ਇਹ ਗਲੋਬਲ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਸਿਮੂਲੇਟਰ::ਨਸ਼ਟ ਕਰੋ. ਕਿਉਂਕਿ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ (ਜਾਂ ਨੀਵੇਂ-ਪੱਧਰ ਦੇ ns-3 ਕੋਡ) ਨੂੰ ਬੁਲਾਇਆ ਗਿਆ ਸੀ, ਜੋ ਕਿ ਇਸ ਤਰ੍ਹਾਂ ਵਿਵਸਥਿਤ ਕੀਤੇ ਗਏ ਹਨ ਤਾਂ ਜੋ ਸਾਰੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਨਸ਼ਟ ਕਰਨ ਲਈ ਸਿਮੂਲੇਟਰ ਵਿੱਚ ਹੁੱਕਾਂ ਪਾਈਆਂ ਜਾਣ। ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਵਸਤੂ ਨੂੰ ਖੁਦ ਟ੍ਰੈਕ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਸੀ - ਤੁਹਾਨੂੰ ਬੱਸ ਕਾਲ ਕਰਨੀ ਸੀ ਸਿਮੂਲੇਟਰ::ਨਸ਼ਟ ਕਰੋ ਅਤੇ ਬਾਹਰ ਜਾਓ. ns-3 ਸਿਸਟਮ ਤੁਹਾਡੇ ਲਈ ਇਹ ਸਖ਼ਤ ਕੰਮ ਕਰੇਗਾ। ਸਾਡੀ ਪਹਿਲੀ ns-3 ਸਕ੍ਰਿਪਟ ਦੀਆਂ ਬਾਕੀ ਲਾਈਨਾਂ, first.cc, ਬਸ ਇਹ ਕਰੋ:

Simulator::Destroy ();
return 0;
}

ਸਿਮੂਲੇਟਰ ਕਦੋਂ ਬੰਦ ਹੋਵੇਗਾ?

ns-3 ਇੱਕ ਡਿਸਕ੍ਰਿਟ ਈਵੈਂਟ (DE) ਸਿਮੂਲੇਟਰ ਹੈ। ਅਜਿਹੇ ਸਿਮੂਲੇਟਰ ਵਿੱਚ, ਹਰੇਕ ਘਟਨਾ ਇਸਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮੇਂ ਨਾਲ ਜੁੜੀ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਸਿਮੂਲੇਸ਼ਨ ਘਟਨਾਵਾਂ ਨੂੰ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਪ੍ਰੋਸੈਸ ਕਰਕੇ ਜਾਰੀ ਰਹਿੰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਸਿਮੂਲੇਸ਼ਨ ਅੱਗੇ ਵਧਦੀ ਹੈ। ਇਵੈਂਟਸ ਭਵਿੱਖ ਦੀਆਂ ਘਟਨਾਵਾਂ ਨੂੰ ਨਿਯਤ ਕਰਨ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ (ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਟਾਈਮਰ ਅਗਲੇ ਅੰਤਰਾਲ ਵਿੱਚ ਗਿਣਤੀ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਆਪਣੇ ਆਪ ਨੂੰ ਮੁੜ-ਤਹਿ ਕਰ ਸਕਦਾ ਹੈ)।

ਸ਼ੁਰੂਆਤੀ ਇਵੈਂਟ ਆਮ ਤੌਰ 'ਤੇ ਇਕਾਈ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਉਦਾਹਰਨ ਲਈ IPv6 ਨੈੱਟਵਰਕ 'ਤੇ ਸੇਵਾਵਾਂ ਦੀ ਖੋਜ, ਗੁਆਂਢੀ ਬੇਨਤੀਆਂ ਆਦਿ ਨੂੰ ਤਹਿ ਕਰੇਗਾ। ਐਪਲੀਕੇਸ਼ਨ ਪਹਿਲੇ ਪੈਕੇਟ ਭੇਜਣ ਦੇ ਇਵੈਂਟ ਨੂੰ ਤਹਿ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੀ. ਜਦੋਂ ਇੱਕ ਇਵੈਂਟ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ ਜ਼ੀਰੋ, ਇੱਕ, ਜਾਂ ਇੱਕ ਤੋਂ ਵੱਧ ਇਵੈਂਟਸ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ। ਜਿਵੇਂ-ਜਿਵੇਂ ਸਿਮੂਲੇਸ਼ਨ ਅੱਗੇ ਵਧਦਾ ਹੈ, ਘਟਨਾਵਾਂ ਵਾਪਰਦੀਆਂ ਹਨ, ਜਾਂ ਤਾਂ ਖ਼ਤਮ ਹੁੰਦੀਆਂ ਹਨ ਜਾਂ ਨਵੀਆਂ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਜੇਕਰ ਇਵੈਂਟ ਕਤਾਰ ਖਾਲੀ ਹੈ ਜਾਂ ਕੋਈ ਵਿਸ਼ੇਸ਼ ਇਵੈਂਟ ਖੋਜਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਸਿਮੂਲੇਸ਼ਨ ਆਪਣੇ ਆਪ ਬੰਦ ਹੋ ਜਾਵੇਗਾ ਰੂਕੋ. ਘਟਨਾ ਰੂਕੋ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ (ਸਟਾਪ ਟਾਈਮ)

ਇੱਕ ਆਮ ਮਾਮਲਾ ਹੈ ਜਿੱਥੇ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ ਰੋਕਣ ਲਈ ਬਿਲਕੁਲ ਜ਼ਰੂਰੀ ਹੈ: ਜਦੋਂ ਸਵੈ-ਸਥਾਈ ਘਟਨਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਸਵੈ-ਸਥਾਈ (ਜਾਂ ਦੁਹਰਾਉਣ ਵਾਲੀਆਂ) ਘਟਨਾਵਾਂ ਉਹ ਘਟਨਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਹਮੇਸ਼ਾਂ ਮੁੜ ਨਿਯਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਨਤੀਜੇ ਵਜੋਂ, ਉਹ ਹਮੇਸ਼ਾ ਇਵੈਂਟ ਕਤਾਰ ਨੂੰ ਖਾਲੀ ਨਹੀਂ ਰੱਖਦੇ. ਕਈ ਪ੍ਰੋਟੋਕੋਲ ਅਤੇ ਮੋਡੀਊਲ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਦੁਹਰਾਉਣ ਵਾਲੀਆਂ ਘਟਨਾਵਾਂ ਸ਼ਾਮਲ ਹਨ, ਉਦਾਹਰਨ ਲਈ:

• ਫਲੋਮੋਨੀਟਰ - ਗੁੰਮ ਹੋਏ ਪੈਕੇਟਾਂ ਦੀ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਜਾਂਚ;

• RIPng - ਰੂਟਿੰਗ ਟੇਬਲ ਅੱਪਡੇਟ ਦਾ ਸਮੇਂ-ਸਮੇਂ 'ਤੇ ਪ੍ਰਸਾਰਣ;

• ਆਦਿ।

ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ ਸਿਮੂਲੇਸ਼ਨ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਰੋਕਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜਦੋਂ ns-3 ਇਮੂਲੇਸ਼ਨ ਮੋਡ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਰੀਅਲਟਾਈਮ ਸਿਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਸਿਮੂਲੇਸ਼ਨ ਕਲਾਕ ਨੂੰ ਮਸ਼ੀਨ ਕਲਾਕ ਨਾਲ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

ਪਾਠ ਪੁਸਤਕ ਵਿੱਚ ਸਿਮੂਲੇਸ਼ਨ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਕਾਲ ਨਹੀਂ ਕਰਦੇ ਹਨ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਕਿਉਂਕਿ ਕਤਾਰਬੱਧ ਇਵੈਂਟਾਂ ਦੇ ਖਤਮ ਹੋਣ 'ਤੇ ਉਹ ਆਪਣੇ ਆਪ ਬੰਦ ਹੋ ਜਾਂਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਇਹ ਪ੍ਰੋਗਰਾਮ ਸਿਮੂਲੇਟਰ::ਸਟਾਪ ਕਾਲ ਨੂੰ ਵੀ ਸਵੀਕਾਰ ਕਰਨਗੇ। ਉਦਾਹਰਨ ਲਈ, ਪਹਿਲੇ ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਨਿਮਨਲਿਖਤ ਵਾਧੂ ਕਥਨ 11 ਸਕਿੰਟਾਂ 'ਤੇ ਇੱਕ ਸਪਸ਼ਟ ਸਟਾਪ ਨੂੰ ਤਹਿ ਕਰੇਗਾ:

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

ਉਪਰੋਕਤ ਅਸਲ ਵਿੱਚ ਇਸ ਪ੍ਰੋਗਰਾਮ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਨਹੀਂ ਬਦਲੇਗਾ, ਕਿਉਂਕਿ ਇਹ ਵਿਸ਼ੇਸ਼ ਸਿਮੂਲੇਸ਼ਨ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ 10 ਸਕਿੰਟਾਂ ਬਾਅਦ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਉਪਰੋਕਤ ਸਟੇਟਮੈਂਟ ਵਿੱਚ ਸਟਾਪ ਟਾਈਮ ਨੂੰ 11 ਸਕਿੰਟ ਤੋਂ 1 ਸਕਿੰਟ ਵਿੱਚ ਬਦਲਣਾ ਸੀ, ਤਾਂ ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਸਿਮੂਲੇਸ਼ਨ ਕਿਸੇ ਵੀ ਆਉਟਪੁੱਟ ਦੇ ਸਕਰੀਨ 'ਤੇ ਆਉਣ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕ ਜਾਂਦੀ ਹੈ (ਕਿਉਂਕਿ ਆਉਟਪੁੱਟ ਸਿਮੂਲੇਸ਼ਨ ਸਮੇਂ ਦੇ ਲਗਭਗ 2 ਸਕਿੰਟਾਂ ਬਾਅਦ ਹੁੰਦੀ ਹੈ)।

ਸਿਮੂਲੇਟਰ ਨੂੰ ਕਾਲ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ:: ਸਿਮੂਲੇਟਰ::ਰਨ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਰੁਕੋ; ਨਹੀਂ ਤਾਂ ਸਿਮੂਲੇਟਰ::ਰਨ ਕਦੇ ਵੀ ਸਟਾਪ ਨੂੰ ਚਲਾਉਣ ਲਈ ਮੁੱਖ ਪ੍ਰੋਗਰਾਮ 'ਤੇ ਨਿਯੰਤਰਣ ਵਾਪਸ ਨਹੀਂ ਕਰ ਸਕਦਾ!

4.2.9 ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਬਣਾਉਣਾ

ਅਸੀਂ ਤੁਹਾਡੀਆਂ ਸਧਾਰਨ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਮਾਮੂਲੀ ਬਣਾ ਦਿੱਤਾ ਹੈ। ਤੁਹਾਨੂੰ ਬੱਸ ਆਪਣੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸਕ੍ਰੈਚ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਪਾਉਣਾ ਹੈ ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਚਲਾਉਂਦੇ ਹੋ ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ ਹੀ ਬਣ ਜਾਵੇਗੀ ਵਾਫ. ਆਓ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ। ਸਿਖਰਲੇ ਪੱਧਰ ਦੀ ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਵਾਪਸ ਜਾਓ ਅਤੇ ਕਾਪੀ ਕਰੋ example/tutorial/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 ns-3 ਸਰੋਤ ਕੋਡ

ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਕੁਝ ns-3 ਸਹਾਇਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਲਈ ਹੈ, ਤੁਸੀਂ ਕੁਝ ਸਰੋਤ ਕੋਡ 'ਤੇ ਨਜ਼ਰ ਮਾਰ ਸਕਦੇ ਹੋ ਜੋ ਇਸ ਕਾਰਜਸ਼ੀਲਤਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਨਵੀਨਤਮ ਕੋਡ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ 'ਤੇ ਸਾਡੇ ਵੈਬ ਸਰਵਰ 'ਤੇ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ: https://gitlab.com/nsnam/ns-3-dev.git. ਉੱਥੇ ਤੁਸੀਂ ਸਾਡੇ ns-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

ਸਾਡੀਆਂ ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟਾਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹਨ ਉਦਾਹਰਣ. ਜੇਕਰ ਤੁਸੀਂ ਉਦਾਹਰਨਾਂ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸੂਚੀ ਦਿਖਾਈ ਦੇਵੇਗੀ। ਸਬ-ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਫਾਈਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਟਿਊਟੋਰਿਅਲ - first.cc. ਜੇਕਰ ਤੁਸੀਂ 'ਤੇ ਕਲਿੱਕ ਕਰੋ first.cc ਤੁਸੀਂ ਉਹ ਕੋਡ ਦੇਖੋਗੇ ਜੋ ਤੁਸੀਂ ਹੁਣੇ ਸਿੱਖਿਆ ਹੈ।

ਸਰੋਤ ਕੋਡ ਮੁੱਖ ਤੌਰ 'ਤੇ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਥਿਤ ਹੈ ਝਰੋਖੇ. ਤੁਸੀਂ ਡਾਇਰੈਕਟਰੀ ਨਾਮ 'ਤੇ ਕਲਿੱਕ ਕਰਕੇ ਜਾਂ ਡਾਇਰੈਕਟਰੀ ਨਾਮ ਦੇ ਸੱਜੇ ਪਾਸੇ ਫਾਈਲਾਂ ਦੇ ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਕੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਤੁਸੀਂ src ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ src ਸਬ-ਡਾਇਰੈਕਟਰੀਆਂ ਦੀ ਸੂਚੀ ਮਿਲੇਗੀ। ਜੇਕਰ ਤੁਸੀਂ ਫਿਰ ਕੋਰ ਸਬ-ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਫਾਈਲਾਂ ਦੀ ਸੂਚੀ ਮਿਲੇਗੀ। ਪਹਿਲੀ ਫਾਈਲ ਜੋ ਤੁਸੀਂ ਦੇਖੋਗੇ (ਇਸ ਗਾਈਡ ਨੂੰ ਲਿਖਣ ਦੇ ਸਮੇਂ) ਹੈ abort.h. ਜੇਕਰ ਤੁਸੀਂ ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਦੇ ਹੋ abort.h, ਤੁਹਾਨੂੰ ਲਈ ਸਰੋਤ ਫਾਈਲ ਵਿੱਚ ਭੇਜਿਆ ਜਾਵੇਗਾ abort.h, ਜਿਸ ਵਿੱਚ ਅਸਧਾਰਨ ਸਥਿਤੀਆਂ ਦਾ ਪਤਾ ਲੱਗਣ 'ਤੇ ਸਕ੍ਰਿਪਟਾਂ ਤੋਂ ਬਾਹਰ ਜਾਣ ਲਈ ਉਪਯੋਗੀ ਮੈਕਰੋ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਵਰਤੇ ਗਏ ਸਹਾਇਕਾਂ ਲਈ ਸਰੋਤ ਕੋਡ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ src/ਐਪਲੀਕੇਸ਼ਨ/ਸਹਾਇਕ. ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਕਿ ਕਿੱਥੇ ਹੈ ਅਤੇ ns-3 ਪ੍ਰੋਗਰਾਮਾਂ ਦੀ ਸ਼ੈਲੀ ਨੂੰ ਸਮਝਣ ਲਈ ਡਾਇਰੈਕਟਰੀ ਟ੍ਰੀ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਘੁੰਮਣ ਲਈ ਬੇਝਿਜਕ ਮਹਿਸੂਸ ਕਰੋ।

ਸਰੋਤ: www.habr.com