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

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

5 ਸੈਟਿੰਗਾਂ
5.1 ਲੌਗਿੰਗ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
5.1.1 ਲੌਗਿੰਗ ਸੰਖੇਪ ਜਾਣਕਾਰੀ
5.1.2 ਲੌਗਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ
5.1.3 ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਲੌਗਿੰਗ ਜੋੜਨਾ
5.2 ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
5.2.1 ਪੂਰਵ-ਨਿਰਧਾਰਤ ਵਿਸ਼ੇਸ਼ਤਾ ਮੁੱਲਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਾ
5.2.2 ਤੁਹਾਡੀਆਂ ਖੁਦ ਦੀਆਂ ਕਮਾਂਡਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨਾ
5.3 ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
5.3.1 ASCII ਟਰੇਸਿੰਗ
ASCII ਟਰੇਸ ਪਾਰਸ ਕਰ ਰਿਹਾ ਹੈ
5.3.2 PCAP ਟਰੇਸ

ਅਧਿਆਇ 5

ਵਿਵਸਥਾ

5.1 ਲੌਗਿੰਗ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਦੇਖ ਕੇ ns-3 ਲੌਗਿੰਗ ਮੋਡੀਊਲ ਨੂੰ ਸੰਖੇਪ ਵਿੱਚ ਦੇਖਿਆ ਹੈ first.cc. ਇਸ ਅਧਿਆਇ ਵਿੱਚ, ਅਸੀਂ ਲੌਗਿੰਗ ਸਬ-ਸਿਸਟਮ ਲਈ ਸੰਭਾਵਿਤ ਵਰਤੋਂ 'ਤੇ ਇੱਕ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰਾਂਗੇ।

5.1.1 ਲੌਗਿੰਗ ਸੰਖੇਪ ਜਾਣਕਾਰੀ

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

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

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

ਵਰਤਮਾਨ ਵਿੱਚ, ਸਿਸਟਮ ਜਾਣਕਾਰੀ ਸਮੱਗਰੀ ਦੇ ਵਧਦੇ ਕ੍ਰਮ ਵਿੱਚ ਲਾਗ ਸੁਨੇਹਿਆਂ ਦੇ ਸੱਤ ਪੱਧਰਾਂ (ਕਿਸਮਾਂ) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।

• LOG_ERROR - ਲਾਗਿੰਗ ਗਲਤੀ ਸੁਨੇਹੇ (ਸਬੰਧਤ ਮੈਕਰੋ: NS_LOG_ERROR);
• LOG_WARN - ਲੌਗ ਚੇਤਾਵਨੀ ਸੰਦੇਸ਼ (ਸਬੰਧਤ ਮੈਕਰੋ: NS_LOG_WARN);
• LOG_DEBUG - ਮੁਕਾਬਲਤਨ ਦੁਰਲੱਭ ਵਿਸ਼ੇਸ਼ ਡੀਬੱਗ ਸੁਨੇਹਿਆਂ ਨੂੰ ਲੌਗ ਕਰੋ (ਸਬੰਧਤ ਮੈਕਰੋ: NS_LOG_DEBUG);
• LOG_INFO - ਪ੍ਰੋਗਰਾਮ ਦੀ ਪ੍ਰਗਤੀ ਬਾਰੇ ਜਾਣਕਾਰੀ ਸੰਦੇਸ਼ਾਂ ਦੀ ਰਜਿਸਟ੍ਰੇਸ਼ਨ (ਸਬੰਧਤ ਮੈਕਰੋ: NS_LOG_INFO);
• LOG_FUNCTION - ਹਰੇਕ ਫੰਕਸ਼ਨ ਦਾ ਵਰਣਨ ਕਰਨ ਵਾਲੇ ਲੌਗ ਸੁਨੇਹੇ (ਦੋ ਸੰਬੰਧਿਤ ਮੈਕਰੋ: NS_LOG_FUNCTION, ਮੈਂਬਰ ਫੰਕਸ਼ਨਾਂ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ NS_LOG_FUNCTION_NOARGS, ਸਥਿਰ ਫੰਕਸ਼ਨਾਂ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ);
• LOG_LOGIC - ਇੱਕ ਫੰਕਸ਼ਨ (ਸਬੰਧਤ ਮੈਕਰੋ: NS_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_ਸੰਬੰਧੀ ਸੰਦੇਸ਼ ਵੀ ਸ਼ਾਮਲ ਹੋਣਗੇ। LOG_WARN ਅਤੇ NS_LOG_ERROR।

ਅਸੀਂ ਬਿਨਾਂ ਸ਼ਰਤ ਲੌਗਿੰਗ ਮੈਕਰੋ ਵੀ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ ਜੋ ਹਮੇਸ਼ਾ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦਾ ਹੈ, ਲੌਗਿੰਗ ਪੱਧਰ ਜਾਂ ਚੋਣ ਹਿੱਸੇ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ।

• NS_LOG_UNCOND - ਸੰਬੰਧਿਤ ਸੁਨੇਹੇ ਦੀ ਬਿਨਾਂ ਸ਼ਰਤ ਲੌਗਿੰਗ (ਕੋਈ ਸੰਬੰਧਿਤ ਲੌਗਿੰਗ ਪੱਧਰ ਨਹੀਂ)।

ਹਰੇਕ ਪੱਧਰ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਜਾਂ ਸੰਚਤ ਤੌਰ 'ਤੇ ਪੁੱਛਗਿੱਛ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਲੌਗਿੰਗ ਨੂੰ sh ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ NS_LOG ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਜਾਂ ਸਿਸਟਮ ਫੰਕਸ਼ਨ ਕਾਲ ਨੂੰ ਲੌਗ ਕਰਕੇ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਜਿਵੇਂ ਕਿ ਪਹਿਲਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਲੌਗਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਡੌਕਸੀਜਨ ਦਸਤਾਵੇਜ਼ ਹਨ ਅਤੇ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਤੋਂ ਨਹੀਂ ਹੈ ਤਾਂ ਇਸਦੀ ਸਮੀਖਿਆ ਕਰਨ ਦਾ ਹੁਣ ਵਧੀਆ ਸਮਾਂ ਹੈ।

ਹੁਣ ਜਦੋਂ ਤੁਸੀਂ ਡੌਕੂਮੈਂਟੇਸ਼ਨ ਨੂੰ ਬਹੁਤ ਵਿਸਥਾਰ ਨਾਲ ਪੜ੍ਹ ਲਿਆ ਹੈ, ਆਓ ਉਸ ਗਿਆਨ ਦੀ ਵਰਤੋਂ ਉਦਾਹਰਣ ਸਕ੍ਰਿਪਟ ਤੋਂ ਕੁਝ ਦਿਲਚਸਪ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕਰੀਏ। scratch/myfirst.ccਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੰਪਾਇਲ ਕਰ ਚੁੱਕੇ ਹੋ।

5.1.2 ਲੌਗਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ

ਚਲੋ ਕੁਝ ਹੋਰ ਲੌਗਸ ਨੂੰ ਚਲਾਉਣ ਲਈ NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੀਏ, ਪਰ ਪਹਿਲਾਂ, ਸਿਰਫ਼ ਆਪਣੀ ਬੇਅਰਿੰਗ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਪਿਛਲੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਓ ਜਿਵੇਂ ਤੁਸੀਂ ਪਹਿਲਾਂ ਕੀਤਾ ਸੀ,

$ ./waf --run scratch/myfirst

ਤੁਹਾਨੂੰ ਪਹਿਲੇ ns-3 ਉਦਾਹਰਨ ਪ੍ਰੋਗਰਾਮ ਤੋਂ ਜਾਣੂ ਆਉਟਪੁੱਟ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ

$ 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.413s)
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ "ਭੇਜੇ" ਅਤੇ "ਪ੍ਰਾਪਤ" ਸੁਨੇਹੇ ਜੋ ਤੁਸੀਂ ਉੱਪਰ ਦੇਖਦੇ ਹੋ ਅਸਲ ਵਿੱਚ ਇਸ ਤੋਂ ਲੌਗ ਕੀਤੇ ਸੁਨੇਹੇ ਹਨ UdpEchoClientApplication и UdpEchoServerApplication. ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਇਸਦੇ ਲੌਗਿੰਗ ਪੱਧਰ ਨੂੰ ਸੈੱਟ ਕਰਕੇ ਵਾਧੂ ਜਾਣਕਾਰੀ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੇ ਹਾਂ।

ਹੁਣ ਤੋਂ, ਮੈਂ ਇਹ ਮੰਨਣ ਜਾ ਰਿਹਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ sh-like ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ ਜੋ "variable=value" ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ csh-ਵਰਗੇ ਸ਼ੈੱਲ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਮੇਰੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਉਹਨਾਂ ਸ਼ੈੱਲਾਂ ਦੁਆਰਾ ਲੋੜੀਂਦੇ "setenv ਵੇਰੀਏਬਲ ਮੁੱਲ" ਸੰਟੈਕਸ ਵਿੱਚ ਬਦਲਣਾ ਪਵੇਗਾ।

ਵਰਤਮਾਨ ਵਿੱਚ, UDP ਈਕੋ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਦੀ ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਦਾ ਜਵਾਬ ਦਿੰਦੀ ਹੈ scratch/myfirst.cc,

LogComponentEnable("UdpEchoClientApplication", LOG_LEVEL_INFO);

ਇਹ ਲੌਗਿੰਗ ਪੱਧਰ LOG_LEVEL_INFO ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਲੌਗਿੰਗ ਪੱਧਰ ਫਲੈਗ ਪਾਸ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਉਸ ਪੱਧਰ ਅਤੇ ਸਾਰੇ ਹੇਠਲੇ ਪੱਧਰਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦੇ ਹਾਂ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਸੀਂ NS_LOG_INFO, NS_LOG_DEBUG, NS_LOG_WARN ਅਤੇ NS_LOG_ERROR ਨੂੰ ਸਮਰੱਥ ਬਣਾਇਆ ਹੈ। ਅਸੀਂ NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਸੈਟ ਕਰਕੇ, ਲੌਗਿੰਗ ਪੱਧਰ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸਕ੍ਰਿਪਟ ਤਬਦੀਲੀਆਂ ਅਤੇ ਰੀਕੰਪਾਈਲੇਸ਼ਨ ਤੋਂ ਬਿਨਾਂ ਹੋਰ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ:

$ export NS_LOG=UdpEchoClientApplication=level_all

ਇਸ ਲਈ ਅਸੀਂ sh ਸ਼ੈੱਲ ਵੇਰੀਏਬਲ NS_LOG ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਹੈ,

UdpEchoClientApplication=level_all

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

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.404s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

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

ਤੁਸੀਂ ਹੁਣ ਫੰਕਸ਼ਨ ਕਾਲਾਂ ਦਾ ਇੱਕ ਲੌਗ ਦੇਖ ਸਕਦੇ ਹੋ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਦੁਆਰਾ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ। ਜੇ ਤੁਸੀਂ ਧਿਆਨ ਨਾਲ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਲਾਈਨ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਕੌਲਨ ਵੇਖੋਗੇ UdpEchoClientApplication ਅਤੇ ਵਿਧੀ ਦਾ ਨਾਮ, ਜਿੱਥੇ ਤੁਸੀਂ C++ ਸਕੋਪ ਆਪਰੇਟਰ (: :) ਨੂੰ ਦੇਖਣ ਦੀ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹੋ। ਇਹ ਜਾਣਬੁੱਝ ਕੇ ਹੈ।

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

ਹਾਲਾਂਕਿ, ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਅਸਲ ਵਿੱਚ ਲੌਗ ਸੁਨੇਹੇ ਨੂੰ ਕਿਹੜੀ ਵਿਧੀ ਤਿਆਰ ਕਰ ਰਹੀ ਹੈ। ਜੇ ਤੁਸੀਂ ਉਪਰੋਕਤ ਟੈਕਸਟ ਨੂੰ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਹੈਰਾਨ ਹੋ ਸਕਦੇ ਹੋ ਕਿ ਲਾਈਨ ਕਿੱਥੇ ਹੈ "Received 1024 bytes from 10.1.1.2" ਤੁਸੀਂ ਪੱਧਰ ਨਿਰਧਾਰਤ ਕਰਕੇ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹੋ prefix_func NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਲਈ। ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਅਜ਼ਮਾਓ:

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func'

ਨੋਟ ਕਰੋ ਕਿ ਹਵਾਲਾ ਚਿੰਨ੍ਹ ਜ਼ਰੂਰੀ ਹਨ ਕਿਉਂਕਿ ਵਰਟੀਕਲ ਬਾਰ ਜੋ ਅਸੀਂ OR ਓਪਰੇਸ਼ਨ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਦੇ ਹਾਂ ਉਹ ਵੀ ਇੱਕ ਯੂਨਿਕਸ ਪਾਈਪ ਕਨੈਕਟਰ ਹੈ। ਹੁਣ ਜੇਕਰ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਲੌਗਿੰਗ ਸਿਸਟਮ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਦਿੱਤੇ ਗਏ ਲੌਗ ਵਿੱਚ ਹਰੇਕ ਸੰਦੇਸ਼ ਕੰਪੋਨੈਂਟ ਨਾਮ ਦੇ ਨਾਲ ਅਗੇਤਰ ਹੈ।

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.417s)
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
UdpEchoClientApplication:HandleRead(0x6241e0, 0x624a20)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()

ਹੁਣ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ UDP ਈਕੋ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਆਉਣ ਵਾਲੇ ਸਾਰੇ ਸੁਨੇਹੇ ਇਸ ਤਰ੍ਹਾਂ ਪਛਾਣੇ ਗਏ ਹਨ। ਸੁਨੇਹਾ"Received 1024 bytes from 10.1.1.2" ਹੁਣ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਈਕੋ ਕਲਾਇੰਟ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਆਉਣ ਵਜੋਂ ਪਛਾਣਿਆ ਗਿਆ ਹੈ। ਬਾਕੀ ਬਚਿਆ ਸੁਨੇਹਾ UDP ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਆਉਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਸੀਂ NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਵਿੱਚ ਭਾਗਾਂ ਦੀ ਇੱਕ ਕੋਲੋਨ-ਵੱਖ ਕੀਤੀ ਸੂਚੀ ਦਾਖਲ ਕਰਕੇ ਇਸ ਕੰਪੋਨੈਂਟ ਨੂੰ ਸਮਰੱਥ ਕਰ ਸਕਦੇ ਹਾਂ।

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func:
               UdpEchoServerApplication=level_all|prefix_func'

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

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.406s)
UdpEchoServerApplication:UdpEchoServer()
UdpEchoClientApplication:UdpEchoClient()
UdpEchoClientApplication:SetDataSize(1024)
UdpEchoServerApplication:StartApplication()
UdpEchoClientApplication:StartApplication()
UdpEchoClientApplication:ScheduleTransmit()
UdpEchoClientApplication:Send()
UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
UdpEchoServerApplication:HandleRead(): Echoing packet
UdpEchoClientApplication:HandleRead(0x624920, 0x625160)
UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
UdpEchoServerApplication:StopApplication()
UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

ਇਹ ਕਈ ਵਾਰ ਸਿਮੂਲੇਸ਼ਨ ਸਮਾਂ ਦੇਖਣ ਦੇ ਯੋਗ ਹੋਣਾ ਵੀ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਿਸ 'ਤੇ ਲੌਗ ਸੁਨੇਹਾ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ। ਤੁਸੀਂ OR ਬਿੱਟ ਜੋੜ ਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ prefix_time:

$ export 'NS_LOG=UdpEchoClientApplication=level_all|prefix_func|prefix_time: UdpEchoServerApplication=level_all|prefix_func|prefix_time'

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

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)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਕੰਸਟਰਕਟਰ ਲਈ UdpEchoServer ਸਿਮੂਲੇਸ਼ਨ 0 ਸਕਿੰਟ ਦੌਰਾਨ ਕਾਲ ਕੀਤੀ ਗਈ ਸੀ। ਇਹ ਅਸਲ ਵਿੱਚ ਸਿਮੂਲੇਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਵਾਪਰਦਾ ਹੈ, ਪਰ ਸਮਾਂ ਜ਼ੀਰੋ ਸਕਿੰਟਾਂ ਵਜੋਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ। ਕੰਸਟਰਕਟਰ ਸੰਦੇਸ਼ ਲਈ ਵੀ ਇਹੀ ਸੱਚ ਹੈ UdpEchoClient.

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)
0s UdpEchoServerApplication:UdpEchoServer()
0s UdpEchoClientApplication:UdpEchoClient()
0s UdpEchoClientApplication:SetDataSize(1024)
1s UdpEchoServerApplication:StartApplication()
2s UdpEchoClientApplication:StartApplication()
2s UdpEchoClientApplication:ScheduleTransmit()
2s UdpEchoClientApplication:Send()
2s UdpEchoClientApplication:Send(): Sent 1024 bytes to 10.1.1.2
2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1
2.00369s UdpEchoServerApplication:HandleRead(): Echoing packet
2.00737s UdpEchoClientApplication:HandleRead(0x624290, 0x624ad0)
2.00737s UdpEchoClientApplication:HandleRead(): Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
10s UdpEchoClientApplication:StopApplication()
UdpEchoClientApplication:DoDispose()
UdpEchoServerApplication:DoDispose()
UdpEchoClientApplication:~UdpEchoClient()
UdpEchoServerApplication:~UdpEchoServer()

ਯਾਦ ਕਰੋ ਕਿ ਸਕ੍ਰਿਪਟ scratch/first.cc ਸਿਮੂਲੇਸ਼ਨ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਇੱਕ ਸਕਿੰਟ ਪਹਿਲਾਂ ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਸ਼ੁਰੂ ਕੀਤੀ। ਹੁਣ ਤੁਸੀਂ ਇਹ ਤਰੀਕਾ ਦੇਖ ਸਕਦੇ ਹੋ ਅਰੰਭ ਕਰੋ ਸਰਵਰ ਨੂੰ ਅਸਲ ਵਿੱਚ ਪਹਿਲੇ ਸਕਿੰਟ ਵਿੱਚ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ ਇਹ ਵੀ ਨੋਟ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਈਕੋ ਕਲਾਇੰਟ ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਦੂਜੇ ਸਕਿੰਟ ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਪੁੱਛਿਆ ਹੈ।

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

ਇਸ ਸਿਮੂਲੇਸ਼ਨ ਵਿੱਚ, ਤੁਹਾਡੇ ਧਿਆਨ ਤੋਂ ਬਿਨਾਂ ਬਹੁਤ ਕੁਝ ਵਾਪਰਦਾ ਹੈ। ਪਰ ਤੁਸੀਂ ਸਿਸਟਮ ਵਿੱਚ ਸਾਰੇ ਲੌਗਿੰਗ ਭਾਗਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਕੇ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਹੁਤ ਆਸਾਨੀ ਨਾਲ ਟਰੈਕ ਕਰ ਸਕਦੇ ਹੋ। NS_LOG ਵੇਰੀਏਬਲ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ,

$ export 'NS_LOG=*=level_all|prefix_func|prefix_time'

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

$ ./waf --run scratch/myfirst > log.out 2>&1

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

5.1.3 ਤੁਹਾਡੇ ਕੋਡ ਵਿੱਚ ਲੌਗਿੰਗ ਜੋੜਨਾ

ਤੁਸੀਂ ਮਲਟੀਪਲ ਮੈਕਰੋਜ਼ ਤੋਂ ਲੌਗ ਕੰਪੋਨੈਂਟ ਨੂੰ ਕਾਲ ਕਰਕੇ ਆਪਣੇ ਸਿਮੂਲੇਸ਼ਨ ਵਿੱਚ ਨਵੀਆਂ ਐਂਟਰੀਆਂ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ। ਚਲੋ ਇਸਨੂੰ ਇੱਕ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕਰੀਏ myfirst.cc, ਜੋ ਸਾਡੇ ਕੋਲ "ਕਲੀਨ" ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹੈ। ਯਾਦ ਕਰੋ ਕਿ ਅਸੀਂ ਇਸ ਦ੍ਰਿਸ਼ ਵਿੱਚ ਇੱਕ ਲੌਗਿੰਗ ਕੰਪੋਨੈਂਟ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ:

NS_LOG_COMPONENT_DEFINE ("FirstScriptExample");

ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਤੁਸੀਂ NS_LOG ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਵੱਖ-ਵੱਖ ਪੱਧਰਾਂ 'ਤੇ ਸੈੱਟ ਕਰਕੇ ਇਸ ਕੰਪੋਨੈਂਟ ਤੋਂ ਸਾਰੇ ਸੁਨੇਹਿਆਂ ਦੀ ਲਾਗਿੰਗ ਨੂੰ ਯੋਗ ਕਰ ਸਕਦੇ ਹੋ। ਚਲੋ ਅੱਗੇ ਵਧੀਏ ਅਤੇ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੁਝ ਐਂਟਰੀਆਂ ਸ਼ਾਮਲ ਕਰੀਏ। ਲੌਗ ਵਿੱਚ ਜਾਣਕਾਰੀ ਪੱਧਰ ਦੇ ਸੁਨੇਹੇ ਜੋੜਨ ਲਈ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਮੈਕਰੋ NS_LOG_INFO ਹੈ। ਚਲੋ ਇੱਕ ਸੁਨੇਹਾ ਜੋੜਦੇ ਹਾਂ (ਨੋਡ ਬਣਾਉਣਾ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ) ਜੋ ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਸਕ੍ਰਿਪਟ "ਟੌਪੋਲੋਜੀ ਬਣਾਉਣਾ" ਪੜਾਅ ਵਿੱਚ ਹੈ। ਇਹ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਸਨਿੱਪਟ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ,
ਖੋਲੋ scratch/myfirst.cc ਆਪਣੇ ਮਨਪਸੰਦ ਸੰਪਾਦਕ ਵਿੱਚ ਅਤੇ ਲਾਈਨ ਜੋੜੋ,
NS_LOG_INFO ("Creating Topology");
ਲਾਈਨਾਂ ਤੋਂ ਪਹਿਲਾਂ,

NodeContainer nodes;
nodes.Create (2);

ਹੁਣ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੰਪਾਇਲ ਕਰੋ waf, ਅਤੇ ਲਾਗਿੰਗ ਸਟ੍ਰੀਮ ਨੂੰ ਅਸਮਰੱਥ ਕਰਨ ਲਈ NS_LOG ਵੇਰੀਏਬਲ ਨੂੰ ਸਾਫ਼ ਕਰੋ ਜੋ ਅਸੀਂ ਪਹਿਲਾਂ ਯੋਗ ਕੀਤਾ ਸੀ:

$ ./waf
$ export NS_LOG=
Теперь, если вы запустите скрипт,
$ ./waf --run scratch/myfirst

ਤੁਸੀਂ ਨਵਾਂ ਸੁਨੇਹਾ ਨਹੀਂ ਦੇਖ ਸਕੋਗੇ ਕਿਉਂਕਿ ਸੰਬੰਧਿਤ ਲੌਗਿੰਗ ਕੰਪੋਨੈਂਟ (FirstScriptExample) ਯੋਗ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। ਆਪਣਾ ਸੁਨੇਹਾ ਦੇਖਣ ਲਈ ਤੁਹਾਨੂੰ ਲੌਗਿੰਗ ਕੰਪੋਨੈਂਟ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਪਹਿਲੀ ਸਕ੍ਰਿਪਟ ਉਦਾਹਰਨ NS_LOG_INFO ਤੋਂ ਘੱਟ ਨਾ ਹੋਣ ਵਾਲੇ ਪੱਧਰ ਦੇ ਨਾਲ। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ ਇਸ ਖਾਸ ਲੌਗਿੰਗ ਪੱਧਰ ਨੂੰ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਯੋਗ ਕਰ ਸਕਦੇ ਹੋ,

$ export NS_LOG=FirstScriptExample=info

ਜੇਕਰ ਤੁਸੀਂ ਹੁਣੇ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਨਵਾਂ ਸੁਨੇਹਾ ਵੇਖੋਂਗੇ "ਟੌਪੋਲੋਜੀ ਬਣਾਉਣਾ",

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.404s)
Creating Topology
Sent 1024 bytes to 10.1.1.2
Received 1024 bytes from 10.1.1.1
Received 1024 bytes from 10.1.1.2

5.2 ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

5.2.1 ਪੂਰਵ-ਨਿਰਧਾਰਤ ਵਿਸ਼ੇਸ਼ਤਾ ਮੁੱਲਾਂ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਨਾ

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

ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦਾ ਪਹਿਲਾ ਕਦਮ ਇੱਕ ਕਮਾਂਡ ਲਾਈਨ ਪਾਰਸਰ ਘੋਸ਼ਿਤ ਕਰਨਾ ਹੈ। ਇਹ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ (ਤੁਹਾਡੇ ਮੁੱਖ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ), ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਵਿੱਚ,

int
main (int argc, char *argv[])
{
...
CommandLine cmd;
cmd.Parse (argc, argv);
...
}

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

$ ./waf --run "scratch/myfirst --PrintHelp"

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

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.413s)
TcpL4Protocol:TcpStateMachine()
CommandLine:HandleArgument(): Handle arg name=PrintHelp value=
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.

ਹੁਣ ਵਿਕਲਪ ਨੂੰ ਵੇਖਦੇ ਹਾਂ -ਪ੍ਰਿੰਟ ਗੁਣ. ਪਹਿਲੀ.cc ਸਕ੍ਰਿਪਟ ਦਾ ਅਧਿਐਨ ਕਰਦੇ ਸਮੇਂ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ns-3 ਗੁਣ ਪ੍ਰਣਾਲੀ ਦਾ ਜ਼ਿਕਰ ਕਰ ਚੁੱਕੇ ਹਾਂ। ਅਸੀਂ ਕੋਡ ਦੀਆਂ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਵੇਖੀਆਂ ਹਨ,

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

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

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

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

--ns3::PointToPointNetDevice::DataRate=[32768bps]:
The default data rate for point to point links

ਇਹ ਡਿਫੌਲਟ ਮੁੱਲ ਹੈ ਜੋ ਸਿਸਟਮ ਦੁਆਰਾ ਆਬਜੈਕਟ ਬਣਾਉਣ ਵੇਲੇ ਵਰਤਿਆ ਜਾਵੇਗਾ PointToPointNetDevice. ਅਸੀਂ ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਡਿਫੌਲਟ ਮੁੱਲ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰਾਂਗੇ ਗੁਣ в PointToPointHelper ਉੱਚਾ ਆਉ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਡਿਵਾਈਸਾਂ ਅਤੇ ਚੈਨਲਾਂ ਲਈ ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰੀਏ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਕਾਲਾਂ ਨੂੰ ਮਿਟਾ ਦੇਵਾਂਗੇ SetDeviceAttribute и SetChannelAttribute ਤੱਕ myfirst.cc, ਜੋ ਸਾਡੇ ਕੋਲ ਇੱਕ ਸਾਫ਼ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਹੈ।

ਤੁਹਾਡੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਹੁਣ ਸਿਰਫ਼ ਘੋਸ਼ਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ PointToPointHelper ਅਤੇ ਕੋਈ ਵੀ ਇੰਸਟਾਲੇਸ਼ਨ ਓਪਰੇਸ਼ਨ ਨਾ ਕਰੋ ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿੱਤੀ ਉਦਾਹਰਣ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ,

...
NodeContainer nodes;
nodes.Create (2);
PointToPointHelper pointToPoint;
NetDeviceContainer devices;
devices = pointToPoint.Install (nodes);
...

ਅੱਗੇ ਵਧੋ ਅਤੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਸਕ੍ਰਿਪਟ ਬਣਾਓ ਵਾਫ (./waff) ਅਤੇ ਆਓ ਵਾਪਸ ਚੱਲੀਏ ਅਤੇ UDP ਈਕੋ ਸਰਵਰ ਐਪਲੀਕੇਸ਼ਨ ਤੋਂ ਕੁਝ ਐਂਟਰੀ ਸ਼ਾਮਲ ਕਰੀਏ ਅਤੇ ਸਮਾਂ ਅਗੇਤਰ ਸ਼ਾਮਲ ਕਰੀਏ।

$ export 'NS_LOG=UdpEchoServerApplication=level_all|prefix_time'

ਜੇ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਚਲਾਉਂਦੇ ਹੋ ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੀ ਆਉਟਪੁੱਟ ਦੇਖਣੀ ਚਾਹੀਦੀ ਹੈ:

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.405s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

ਯਾਦ ਕਰੋ ਕਿ ਪਿਛਲੀ ਵਾਰ ਜਦੋਂ ਅਸੀਂ ਸਿਮੂਲੇਸ਼ਨ ਸਮੇਂ ਨੂੰ ਦੇਖਿਆ ਸੀ, ਜਿਸ ਪਲ ਈਕੋ ਸਰਵਰ ਦੁਆਰਾ ਪੈਕੇਟ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਇਹ 2,00369 ਸਕਿੰਟ ਸੀ।

2.00369s UdpEchoServerApplication:HandleRead(): Received 1024 bytes from 10.1.1.1

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

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

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

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

ਸਾਨੂੰ ਪਤਾ ਲੱਗੇਗਾ ਕਿ ਚੈਨਲ ਦੇਰੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਸੈੱਟ ਕੀਤੀ ਗਈ ਹੈ:

--ns3::PointToPointChannel::Delay=[0ns]:
Transmission delay through the channel

ਅਸੀਂ ਫਿਰ, ਕਮਾਂਡ ਲਾਈਨ ਸਿਸਟਮ ਰਾਹੀਂ, ਇਹਨਾਂ ਦੋਨਾਂ ਮੂਲ ਮੁੱਲਾਂ ਨੂੰ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ।

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

ਇਸ ਸਥਿਤੀ ਵਿੱਚ ਅਸੀਂ ਉਸ ਸਮੇਂ ਨੂੰ ਮੁੜ ਬਹਾਲ ਕਰਦੇ ਹਾਂ ਜਦੋਂ ਅਸੀਂ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਡੇਟਾ ਰੇਟ ਅਤੇ ਦੇਰੀ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਸੀ:

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.417s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.00369s Received 1024 bytes from 10.1.1.1
2.00369s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

ਨੋਟ ਕਰੋ ਕਿ ਪੈਕੇਟ ਸਰਵਰ ਦੁਆਰਾ 2,00369 ਸਕਿੰਟਾਂ ਬਾਅਦ ਦੁਬਾਰਾ ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ। ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਵਰਤੇ ਗਏ ਕਿਸੇ ਵੀ ਗੁਣ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ। ਖਾਸ ਤੌਰ 'ਤੇ, ਅਸੀਂ ਮੈਕਸਪੈਕੇਟ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਗੈਰ-ਇਕ ਮੁੱਲਾਂ ਲਈ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹਾਂ UdpEchoClient.

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

$ ./waf --run "scratch/myfirst
--ns3::PointToPointNetDevice::DataRate=5Mbps
--ns3::PointToPointChannel::Delay=2ms
--ns3::UdpEchoClient::MaxPackets=2"

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

$ ./waf --run "scratch/myfirst --PrintHelp"
myfirst [Program Arguments] [General Arguments]
General Arguments:
--PrintGlobals: Print the list of globals.
--PrintGroups: Print the list of groups.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintTypeIds: Print all TypeIds.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintHelp: Print this help message.

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

./waf --run "scratch/myfirst --PrintGroup=PointToPoint"
TypeIds in group PointToPoint:
ns3::PointToPointChannel
ns3::PointToPointNetDevice
ns3::PointToPointRemoteChannel
ns3::PppHeader

ਇੱਥੇ ਤੁਸੀਂ ਐਟਰੀਬਿਊਟ ਲੁੱਕਅੱਪ ਲਈ ਉਪਲਬਧ TypeId ਨਾਮ ਲੱਭ ਸਕਦੇ ਹੋ, ਉਦਾਹਰਨ ਲਈ ਵਿੱਚ
--PrintAttributes = ns3 :: PointToPointChannelਜਿਵੇਂ ਉੱਪਰ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

ਗੁਣਾਂ ਬਾਰੇ ਜਾਣਨ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ Doxygen ns-3 ਦੁਆਰਾ ਹੈ। ਇੱਕ ਪੰਨਾ ਹੈ ਜੋ ਸਿਮੂਲੇਟਰ ਵਿੱਚ ਰਜਿਸਟਰ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ.

5.2.2 ਤੁਹਾਡੀਆਂ ਖੁਦ ਦੀਆਂ ਕਮਾਂਡਾਂ ਨੂੰ ਕੈਪਚਰ ਕਰਨਾ

ਤੁਸੀਂ ਕਮਾਂਡ ਲਾਈਨ ਸਿਸਟਮ ਰਾਹੀਂ ਆਪਣੇ ਖੁਦ ਦੇ ਹੁੱਕ ਵੀ ਜੋੜ ਸਕਦੇ ਹੋ। ਇਹ ਕਮਾਂਡ ਲਾਈਨ ਪਾਰਸਰ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਹੁਤ ਅਸਾਨੀ ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਮੁੱਲ ਜੋੜੋ.
ਆਉ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਪੈਕੇਜਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਰੀਏ। ਆਉ ਇੱਕ ਲੋਕਲ ਵੇਰੀਏਬਲ ਜੋੜੀਏ ਜਿਸਨੂੰ ਕਹਿੰਦੇ ਹਾਂ nਪੈਕੇਟ ਇੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਮੁੱਖ. ਅਸੀਂ ਇਸਨੂੰ ਸਾਡੇ ਪਿਛਲੇ ਡਿਫੌਲਟ ਵਿਵਹਾਰ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ ਇੱਕ 'ਤੇ ਸੈੱਟ ਕਰਾਂਗੇ। ਕਮਾਂਡ ਲਾਈਨ ਪਾਰਸਰ ਨੂੰ ਇਸ ਮੁੱਲ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ, ਸਾਨੂੰ ਪਾਰਸਰ ਵਿੱਚ ਇਸ ਮੁੱਲ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਸੀਂ ਇੱਕ ਕਾਲ ਜੋੜ ਕੇ ਅਜਿਹਾ ਕਰਦੇ ਹਾਂ ਮੁੱਲ ਜੋੜੋ. ਜਾਓ ਅਤੇ ਸਕ੍ਰਿਪਟ ਬਦਲੋ scratch/myfirst.cc ਇਸ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਲਈ,

int
main (int argc, char *argv[])
{
uint32_t nPackets = 1;
CommandLine cmd;
cmd.AddValue("nPackets", "Number of packets to echo", nPackets);
cmd.Parse (argc, argv);
...

ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਉਸ ਬਿੰਦੂ ਤੱਕ ਹੇਠਾਂ ਸਕ੍ਰੋਲ ਕਰੋ ਜਿੱਥੇ ਅਸੀਂ MaxPackets ਗੁਣ ਸੈੱਟ ਕਰਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਬਦਲਦੇ ਹਾਂ ਤਾਂ ਕਿ ਇਹ ਸਥਿਰ 1 ਦੀ ਬਜਾਏ nPackets ਵੇਰੀਏਬਲ 'ਤੇ ਸੈੱਟ ਹੋਵੇ, ਜਿਵੇਂ ਕਿ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।

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

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

$ ./waf --run "scratch/myfirst --PrintHelp"
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.403s)
--PrintHelp: Print this help message.
--PrintGroups: Print the list of groups.
--PrintTypeIds: Print all TypeIds.
--PrintGroup=[group]: Print all TypeIds of group.
--PrintAttributes=[typeid]: Print all attributes of typeid.
--PrintGlobals: Print the list of globals.
User Arguments:
--nPackets: Number of packets to echo

ਜੇਕਰ ਤੁਸੀਂ ਪ੍ਰਸਾਰਿਤ ਪੈਕੇਟਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟ - -nPackets ਸੈੱਟ ਕਰਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ।

$ ./waf --run "scratch/myfirst --nPackets=2"

ਹੁਣ ਤੁਹਾਨੂੰ ਹੁਣ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ

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.404s)
0s UdpEchoServerApplication:UdpEchoServer()
1s UdpEchoServerApplication:StartApplication()
Sent 1024 bytes to 10.1.1.2
2.25732s Received 1024 bytes from 10.1.1.1
2.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
Sent 1024 bytes to 10.1.1.2
3.25732s Received 1024 bytes from 10.1.1.1
3.25732s Echoing packet
Received 1024 bytes from 10.1.1.2
10s UdpEchoServerApplication:StopApplication()
UdpEchoServerApplication:DoDispose()
UdpEchoServerApplication:~UdpEchoServer()

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

5.3 ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰਨਾ

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

#include <iostream>
...
int main ()
{
...
std::cout << "The value of x is " << x << std::endl;
...
}

ਤੁਸੀਂ ਆਪਣੇ ਹੱਲ ਵਿੱਚ ਥੋੜਾ ਜਿਹਾ ਢਾਂਚਾ ਜੋੜਨ ਲਈ ਇੱਕ ਲੌਗਿੰਗ ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ। ਇਸ ਪਹੁੰਚ ਦੇ ਕਾਰਨ ਬਹੁਤ ਸਾਰੀਆਂ ਜਾਣੀਆਂ-ਪਛਾਣੀਆਂ ਸਮੱਸਿਆਵਾਂ ਹਨ, ਅਤੇ ਇਸਲਈ ਅਸੀਂ ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਆਮ ਘਟਨਾ ਟਰੇਸਿੰਗ ਉਪ-ਸਿਸਟਮ ਪ੍ਰਦਾਨ ਕੀਤਾ ਹੈ।

NS-3 ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਦੇ ਮੁੱਖ ਟੀਚੇ ਹਨ:

• ਬੁਨਿਆਦੀ ਕਾਰਜਾਂ ਲਈ, ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ ਪ੍ਰਸਿੱਧ ਸਰੋਤਾਂ ਲਈ ਇੱਕ ਮਿਆਰੀ ਟਰੇਸ ਬਣਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ ਅਤੇ ਟਰੇਸ ਪੈਦਾ ਕਰਨ ਵਾਲੀਆਂ ਵਸਤੂਆਂ ਦੀ ਚੋਣ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ;

• ਇੰਟਰਮੀਡੀਏਟ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਸਿਮੂਲੇਟਰ ਕੋਰ ਨੂੰ ਸੋਧੇ ਬਿਨਾਂ, ਤਿਆਰ ਕੀਤੇ ਆਉਟਪੁੱਟ ਫਾਰਮੈਟ ਨੂੰ ਬਦਲਣ ਜਾਂ ਨਵੇਂ ਟਰੇਸ ਸਰੋਤਾਂ ਨੂੰ ਸੰਮਿਲਿਤ ਕਰਨ ਲਈ ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਨੂੰ ਵਧਾਉਣ ਦੇ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ;

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

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

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

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

ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ, ਅਸੀਂ ਕੁਝ ਪੂਰਵ-ਪ੍ਰਭਾਸ਼ਿਤ ਸਰੋਤਾਂ ਅਤੇ ਸਿੰਕਾਂ ਵਿੱਚੋਂ ਲੰਘਾਂਗੇ ਅਤੇ ਦਿਖਾਵਾਂਗੇ ਕਿ ਉਹਨਾਂ ਨੂੰ ਉਪਭੋਗਤਾ ਦੇ ਹਿੱਸੇ 'ਤੇ ਘੱਟ ਤੋਂ ਘੱਟ ਮਿਹਨਤ ਨਾਲ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਉੱਨਤ ਟਰੇਸ ਸੰਰਚਨਾ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਈ ns-3 ਮੈਨੁਅਲ ਜਾਂ ਕਿਵੇਂ-ਕਰਨ ਸੈਕਸ਼ਨ ਵੇਖੋ, ਜਿਸ ਵਿੱਚ ਟਰੇਸ ਨੇਮਸਪੇਸ ਦਾ ਵਿਸਤਾਰ ਕਰਨਾ ਅਤੇ ਨਵੇਂ ਟਰੇਸ ਸਰੋਤ ਬਣਾਉਣਾ ਸ਼ਾਮਲ ਹੈ।

5.3.1 ASCII ਟਰੇਸਿੰਗ

ns-3 ਸਹਾਇਕ ਕਾਰਜਕੁਸ਼ਲਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਸਧਾਰਨ ਪੈਕੇਟ ਟਰੇਸ ਸਥਾਪਤ ਕਰਨ ਵੇਲੇ ਵੇਰਵਿਆਂ ਵਿੱਚ ਤੁਹਾਡੀ ਮਦਦ ਕਰਨ ਲਈ ਇੱਕ ਘੱਟ-ਪੱਧਰੀ ਟਰੇਸਿੰਗ ਸਿਸਟਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਮਰੱਥ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ASCII ਫਾਈਲਾਂ ਵਿੱਚ ਆਉਟਪੁੱਟ ਵੇਖੋਗੇ। ns-2 ਆਉਟਪੁੱਟ ਤੋਂ ਜਾਣੂ ਲੋਕਾਂ ਲਈ, ਇਸ ਕਿਸਮ ਦਾ ਟਰੇਸ ਸਮਾਨ ਹੈ out.tr, ਜੋ ਬਹੁਤ ਸਾਰੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਚਲੋ ਕਾਰੋਬਾਰ 'ਤੇ ਉਤਰੀਏ ਅਤੇ ਸਾਡੀ scratch/myfirst.cc ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਕੁਝ ASCII ਟਰੇਸਿੰਗ ਨਤੀਜੇ ਸ਼ਾਮਲ ਕਰੀਏ। ਕਾਲ ਤੋਂ ਠੀਕ ਪਹਿਲਾਂ Simulator :: Run (), ਕੋਡ ਦੀਆਂ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਜੋੜੋ:
AsciiTraceHelper ascii;

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

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

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

ns-2 ਤੋਂ ਜਾਣੂ ਲੋਕਾਂ ਲਈ, ਟਰੈਕ ਕੀਤੀਆਂ ਘਟਨਾਵਾਂ ਜਾਣੇ-ਪਛਾਣੇ ਟਰੇਸਪੁਆਇੰਟਾਂ ਦੇ ਬਰਾਬਰ ਹਨ ਜੋ ਘਟਨਾਵਾਂ "+", "-", "d" ਅਤੇ "r" ਨੂੰ ਲੌਗ ਕਰਦੇ ਹਨ।
ਹੁਣ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਤੋਂ ਚਲਾ ਸਕਦੇ ਹੋ:

$ ./waf --run scratch/myfirst

ਪਹਿਲਾਂ ਦੀ ਤਰ੍ਹਾਂ ਕਈ ਵਾਰ, ਤੁਸੀਂ Waf ਤੋਂ ਕਈ ਸੁਨੇਹੇ ਦੇਖੋਗੇ, ਅਤੇ ਫਿਰ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਕੁਝ ਸੰਦੇਸ਼ਾਂ ਦੇ ਨਾਲ "'ਬਿਲਡ' ਸਫਲਤਾਪੂਰਵਕ ਪੂਰਾ ਹੋਇਆ"।

ਜਦੋਂ ਚੱਲਦਾ ਹੈ, ਪ੍ਰੋਗਰਾਮ ਨਾਮ ਦੀ ਇੱਕ ਫਾਈਲ ਬਣਾਏਗਾ myfirst.tr. ਕੰਮ ਦੇ ਸੁਭਾਅ ਦੇ ਕਾਰਨ ਵਾਫ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਫਾਇਲ ਸਥਾਨਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਉੱਚ-ਪੱਧਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਬਣਾਈ ਜਾਂਦੀ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਉਸ ਮਾਰਗ ਨੂੰ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿੱਥੇ ਟਰੇਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ Waf ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ --cwd. ਅਸੀਂ ਅਜਿਹਾ ਨਹੀਂ ਕੀਤਾ ਹੈ, ਇਸਲਈ ਤੁਹਾਡੇ ਮਨਪਸੰਦ ਸੰਪਾਦਕ ਵਿੱਚ ASCII ਟਰੇਸ ਫਾਈਲ myfirst.tr ਨੂੰ ਦੇਖਣ ਲਈ, ਸਾਨੂੰ ਆਪਣੀ ਰਿਪੋਜ਼ਟਰੀ ਦੀ ਉੱਚ-ਪੱਧਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਨੈਵੀਗੇਟ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ।

ASCII ਟਰੇਸ ਪਾਰਸ ਕਰ ਰਿਹਾ ਹੈ

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

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

+: ਡਿਵਾਈਸ ਕਤਾਰ 'ਤੇ ਇੱਕ ਕਤਾਰਬੰਦੀ ਕਾਰਵਾਈ ਹੋਈ;
-: ਡਿਵਾਈਸ ਕਤਾਰ ਵਿੱਚ ਇੱਕ ਤੱਤ ਪ੍ਰਾਪਤੀ ਕਾਰਵਾਈ ਹੋਈ;
d: ਪੈਕੇਟ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਸੀ, ਆਮ ਤੌਰ 'ਤੇ ਕਿਉਂਕਿ ਕਤਾਰ ਭਰੀ ਹੋਈ ਸੀ;
r: ਪੈਕੇਟ ਇੱਕ ਨੈੱਟਵਰਕ ਡਿਵਾਈਸ ਦੁਆਰਾ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ।

ਆਉ ਟਰੇਸ ਫਾਈਲ ਵਿੱਚ ਪਹਿਲੀ ਲਾਈਨ ਤੇ ਇੱਕ ਡੂੰਘਾਈ ਨਾਲ ਵਿਚਾਰ ਕਰੀਏ. ਮੈਂ ਇਸਨੂੰ ਭਾਗਾਂ ਵਿੱਚ ਵੰਡਾਂਗਾ (ਸਪਸ਼ਟਤਾ ਲਈ ਇੰਡੈਂਟੇਸ਼ਨ ਦੇ ਨਾਲ) ਅਤੇ ਖੱਬੇ ਪਾਸੇ ਲਾਈਨ ਨੰਬਰ:

0 +
1 2
2 /NodeList/0/DeviceList/0/$ns3::PointToPointNetDevice/TxQueue/Enqueue
3 ns3::PppHeader (
4   Point-to-Point Protocol: IP (0x0021))
6   ns3::Ipv4Header (
7     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
8     length: 1052 10.1.1.1 > 10.1.1.2)
9     ns3::UdpHeader (
10      length: 1032 49153 > 9)
11      Payload (size=1024)

ਇਸ ਵਿਸਤ੍ਰਿਤ ਟਰੇਸ ਘਟਨਾ (ਲਾਈਨ 0) ਦਾ ਪਹਿਲਾ ਭਾਗ ਓਪਰੇਸ਼ਨ ਹੈ। ਸਾਡੇ ਕੋਲ ਇੱਥੇ ਇੱਕ + ਚਿੰਨ੍ਹ ਹੈ, ਜੋ ਪ੍ਰਸਾਰਣ ਲਈ ਕਤਾਰ ਦੇ ਸੰਚਾਲਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਦੂਜਾ ਭਾਗ (ਲਾਈਨ 1) ਸਿਮੂਲੇਸ਼ਨ ਸਮਾਂ ਹੈ, ਸਕਿੰਟਾਂ ਵਿੱਚ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਤੁਹਾਨੂੰ ਯਾਦ ਹੋਵੇਗਾ ਕਿ ਅਸੀਂ ਕੀ ਪੁੱਛਿਆ ਸੀ UdpEchoClientApplication ਦੋ ਸਕਿੰਟਾਂ ਵਿੱਚ ਪੈਕੇਟ ਭੇਜਣਾ ਸ਼ੁਰੂ ਕਰੋ। ਇੱਥੇ ਅਸੀਂ ਪੁਸ਼ਟੀ ਦੇਖਦੇ ਹਾਂ ਕਿ ਇਹ ਅਸਲ ਵਿੱਚ ਹੋ ਰਿਹਾ ਹੈ।

ਟਰੇਸ ਉਦਾਹਰਨ ਦਾ ਅਗਲਾ ਭਾਗ (ਲਾਈਨ 2 ਤੋਂ) ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਟਰੇਸ ਸਰੋਤ ਨੇ ਇਸ ਘਟਨਾ ਨੂੰ ਬਣਾਇਆ ਹੈ (ਨੇਮਸਪੇਸ ਟਰੇਸ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ)। ਤੁਸੀਂ ਟਰੇਸ ਨੇਮਸਪੇਸ ਬਾਰੇ ਸੋਚ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਫਾਈਲ ਸਿਸਟਮ ਨੇਮਸਪੇਸ ਕਰਦੇ ਹੋ। ਨਾਮ-ਸਥਾਨ ਦਾ ਮੂਲ ਹੈ ਨੋਡਲਿਸਟ. ਇਹ ਮੁੱਖ NS-3 ਕੋਡ ਵਿੱਚ ਪ੍ਰਬੰਧਿਤ ਕੰਟੇਨਰ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਉਹ ਸਾਰੇ ਨੋਡ ਹਨ ਜੋ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਬਣਾਏ ਗਏ ਹਨ। ਜਿਵੇਂ ਕਿ ਇੱਕ ਫਾਈਲ ਸਿਸਟਮ ਦੇ ਰੂਟ ਵਿੱਚ ਡਾਇਰੈਕਟਰੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ, ਨੋਡਲਿਸਟ ਸਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੇ ਨੋਡ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ ਲਾਈਨ /NodeList/0 ਨੋਡਲਿਸਟ ਵਿੱਚ ਨਲ ਨੋਡ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਜਿਸਨੂੰ ਅਸੀਂ ਆਮ ਤੌਰ 'ਤੇ "ਨੋਡ 0" ਦੇ ਰੂਪ ਵਿੱਚ ਸੋਚਦੇ ਹਾਂ। ਹਰੇਕ ਨੋਡ ਵਿੱਚ ਜੰਤਰਾਂ ਦੀ ਸੂਚੀ ਹੁੰਦੀ ਹੈ ਜੋ ਇੰਸਟਾਲ ਕੀਤੇ ਗਏ ਹਨ। ਇਹ ਸੂਚੀ ਨੇਮਸਪੇਸ ਵਿੱਚ ਅੱਗੇ ਸਥਿਤ ਹੈ। ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇਹ ਟਰੇਸ ਘਟਨਾ ਆਈ ਡਿਵਾਈਸਲਿਸਟ/0, ਜੋ ਕਿ ਨੋਡ ਵਿੱਚ ਸਥਾਪਿਤ ਨਲ ਡਿਵਾਈਸ ਹੈ।

ਅਗਲੀ ਸਬਸਟਰਿੰਗ, $ ns3 :: PointToPointNetDevice, ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਡਿਵਾਈਸ ਜ਼ੀਰੋ ਸਥਿਤੀ 'ਤੇ ਹੈ: ਨੋਡ ਜ਼ੀਰੋ ਦੀ ਡਿਵਾਈਸ ਸੂਚੀ। ਯਾਦ ਕਰੋ ਕਿ ਲਾਈਨ 0 ਵਿੱਚ ਪਾਏ ਗਏ + ਓਪਰੇਸ਼ਨ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਡਿਵਾਈਸ ਦੀ ਟ੍ਰਾਂਸਮਿਟ ਕਤਾਰ ਵਿੱਚ ਇੱਕ ਤੱਤ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਹ "ਟਰੈਕ ਮਾਰਗ" ਦੇ ਆਖਰੀ ਭਾਗਾਂ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਤ ਹੁੰਦਾ ਹੈ: TxQueue/Enqueue.

ਟਰੇਸ ਵਿੱਚ ਬਾਕੀ ਭਾਗ ਕਾਫ਼ੀ ਅਨੁਭਵੀ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ. ਲਾਈਨਾਂ 3-4 ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਪੈਕੇਟ ਨੂੰ ਇੱਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ। ਲਾਈਨਾਂ 5-7 ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਪੈਕੇਟ ਵਿੱਚ ਇੱਕ IP4 ਸੰਸਕਰਣ ਹੈਡਰ ਹੈ ਅਤੇ IP ਐਡਰੈੱਸ ਵਿੱਚ ਉਤਪੰਨ ਹੋਇਆ ਹੈ 10.1.1.1 ਅਤੇ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ 10.1.1.2. ਲਾਈਨਾਂ 8-9 ਦਿਖਾਉਂਦੀਆਂ ਹਨ ਕਿ ਇਸ ਪੈਕੇਟ ਵਿੱਚ ਇੱਕ UDP ਸਿਰਲੇਖ ਹੈ ਅਤੇ ਅੰਤ ਵਿੱਚ ਲਾਈਨ 10 ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਪੇਲੋਡ ਸੰਭਾਵਿਤ 1024 ਬਾਈਟਸ ਹੈ।

ਟਰੇਸ ਫਾਈਲ ਵਿੱਚ ਅਗਲੀ ਲਾਈਨ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਉਹੀ ਪੈਕੇਟ ਉਸੇ ਨੋਡ 'ਤੇ ਟ੍ਰਾਂਸਮਿਸ਼ਨ ਕਤਾਰ ਤੋਂ ਖਿੱਚਿਆ ਗਿਆ ਸੀ।

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

0 r
1 2.25732
2 /NodeList/1/DeviceList/0/$ns3::PointToPointNetDevice/MacRx
3   ns3::Ipv4Header (
4     tos 0x0 ttl 64 id 0 protocol 17 offset 0 flags [none]
5     length: 1052 10.1.1.1 > 10.1.1.2)
6     ns3::UdpHeader (
7       length: 1032 49153 > 9)
8       Payload (size=1024)

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

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

5.3.2 PCAP ਟਰੇਸ

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

pcap ਟਰੇਸਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣਾ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

pointToPoint.EnablePcapAll ("myfirst");

ਕੋਡ ਦੀ ਇਸ ਲਾਈਨ ਨੂੰ ASCII ਟਰੇਸ ਕੋਡ ਤੋਂ ਬਾਅਦ ਪੇਸਟ ਕਰੋ ਜੋ ਅਸੀਂ ਹੁਣੇ ਸ਼ਾਮਲ ਕੀਤਾ ਹੈ scratch/myfirst.cc. ਨੋਟ ਕਰੋ ਕਿ ਅਸੀਂ ਸਿਰਫ਼ "myfirst" ਸਟ੍ਰਿੰਗ ਪਾਸ ਕੀਤੀ ਹੈ, "myfirst.pcap" ਜਾਂ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਕੋਈ ਚੀਜ਼ ਨਹੀਂ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਪੈਰਾਮੀਟਰ ਇੱਕ ਅਗੇਤਰ ਹੈ, ਪੂਰਾ ਫਾਈਲ ਨਾਂ ਨਹੀਂ। ਸਿਮੂਲੇਸ਼ਨ ਦੇ ਦੌਰਾਨ, ਸਹਾਇਕ ਅਸਲ ਵਿੱਚ ਹਰੇਕ ਪੁਆਇੰਟ-ਟੂ-ਪੁਆਇੰਟ ਡਿਵਾਈਸ ਲਈ ਇੱਕ ਟਰੇਸ ਫਾਈਲ ਬਣਾਏਗਾ. ਫਾਇਲ ਨਾਂ ਅਗੇਤਰ, ਨੋਡ ਨੰਬਰ, ਡਿਵਾਈਸ ਨੰਬਰ, ਅਤੇ ਪਿਛੇਤਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਏ ਜਾਣਗੇ ".pcap".

ਸਾਡੀ ਉਦਾਹਰਨ ਸਕ੍ਰਿਪਟ ਲਈ, ਅਸੀਂ "ਨਾਮ ਦੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਦੇਖਾਂਗੇmyfirst-0-0.pcap"ਅਤੇ"myfirst-1-0.pcap", ਜੋ ਕਿ ਕ੍ਰਮਵਾਰ ਨੋਡ 0-ਡਿਵਾਈਸ 0 ਅਤੇ ਨੋਡ 1-ਡਿਵਾਈਸ 0 ਲਈ pcap ਟਰੇਸ ਹਨ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ pcap ਟਰੇਸਿੰਗ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ ਕੋਡ ਦੀ ਲਾਈਨ ਜੋੜ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਨੂੰ ਆਮ ਤਰੀਕੇ ਨਾਲ ਚਲਾ ਸਕਦੇ ਹੋ:

$ ./waf --run scratch/myfirst

ਜੇਕਰ ਤੁਸੀਂ ਆਪਣੀ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਦੀ ਸਿਖਰ-ਪੱਧਰੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਤਿੰਨ ਫਾਈਲਾਂ ਦੇਖਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ: ਇੱਕ ASCII ਟਰੇਸ ਫਾਈਲ myfirst.tr, ਜਿਸਦਾ ਅਸੀਂ ਪਹਿਲਾਂ ਅਧਿਐਨ ਕੀਤਾ ਸੀ, ਫਾਈਲਾਂ myfirst-0-0.pcap и myfirst-1-0.pcap - ਨਵੀਆਂ pcap ਫਾਈਲਾਂ ਜੋ ਅਸੀਂ ਹੁਣੇ ਤਿਆਰ ਕੀਤੀਆਂ ਹਨ।

tcpdump ਨਾਲ ਆਉਟਪੁੱਟ ਪੜ੍ਹਨਾ

ਹੁਣ ਲਈ, pcap ਫਾਈਲਾਂ ਨੂੰ ਦੇਖਣ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ tcpdump ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ।

$ tcpdump -nn -tt -r myfirst-0-0.pcap
reading from file myfirst-0-0.pcap, link-type PPP (PPP)
2.000000 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.514648 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024
tcpdump -nn -tt -r myfirst-1-0.pcap
reading from file myfirst-1-0.pcap, link-type PPP (PPP)
2.257324 IP 10.1.1.1.49153 > 10.1.1.2.9: UDP, length 1024
2.257324 IP 10.1.1.2.9 > 10.1.1.1.49153: UDP, length 1024

ਡੰਪ ਵਿਚ myfirst-0-0.pcap (ਕਲਾਇੰਟ ਡਿਵਾਈਸ) ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਈਕੋ ਪੈਕੇਟ ਸਿਮੂਲੇਸ਼ਨ ਦੇ 2 ਸਕਿੰਟਾਂ ਬਾਅਦ ਭੇਜਿਆ ਗਿਆ ਹੈ। ਜੇ ਤੁਸੀਂ ਦੂਜੇ ਡੰਪ ਨੂੰ ਦੇਖਦੇ ਹੋ (myfirst-1-0.pcap), ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਪੈਕੇਟ 2,257324 ਸਕਿੰਟਾਂ 'ਤੇ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ। ਤੁਸੀਂ ਦੂਜੇ ਡੰਪ ਵਿੱਚ ਦੇਖੋਗੇ ਕਿ ਪੈਕੇਟ 2.257324 ਸਕਿੰਟਾਂ ਵਿੱਚ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਅਤੇ ਅੰਤ ਵਿੱਚ ਇਹ ਕਿ ਪੈਕਟ ਗਾਹਕ ਦੁਆਰਾ 2.514648 ਸਕਿੰਟਾਂ ਵਿੱਚ ਪਹਿਲੇ ਡੰਪ ਵਿੱਚ ਵਾਪਸ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਸੀ।

ਵਾਇਰਸ਼ਾਰਕ ਨਾਲ ਆਉਟਪੁੱਟ ਪੜ੍ਹਨਾ

ਜੇ ਤੁਸੀਂ ਜਾਣੂ ਨਹੀਂ ਹੋ ਵਰਅਰਹਾਰਕ, ਇੱਕ ਵੈਬਸਾਈਟ ਹੈ ਜਿੱਥੋਂ ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ: http://www.wireshark.org/. ਵਰਅਰਹਾਰਕ ਇੱਕ GUI ਹੈ ਜੋ ਇਹਨਾਂ ਟਰੇਸ ਫਾਈਲਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਵਾਇਰਸ਼ਾਰਕ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਟਰੇਸ ਫਾਈਲਾਂ ਨੂੰ ਖੋਲ੍ਹ ਸਕਦੇ ਹੋ ਅਤੇ ਸਮੱਗਰੀ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ ਜਿਵੇਂ ਤੁਸੀਂ ਇੱਕ ਪੈਕੇਟ ਸਨਿਫਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਕੇਟਾਂ ਨੂੰ ਕੈਪਚਰ ਕੀਤਾ ਹੈ।

ਸਰੋਤ: www.habr.com