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

ਅਧਿਆਇ 1,2

3 ਸ਼ੁਰੂ ਕਰਨਾ
3.1 ਸੰਖੇਪ ਜਾਣਕਾਰੀ
3.2 ਪੂਰਵ-ਸ਼ਰਤਾਂ
3.2.1 ਸਰੋਤ ਪੁਰਾਲੇਖ ਵਜੋਂ ns-3 ਰੀਲੀਜ਼ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ
3.3 ਗਿੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ns-3 ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ
3.3.1 ਬੇਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ns-3 ਨੂੰ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
3.4 ਅਸੈਂਬਲੀ ns-3
3.4.1 build.py ਨਾਲ ਬਿਲਡਿੰਗ
3.4.2 ਬੇਕ ਨਾਲ ਬਿਲਡਿੰਗ
3.4.3 Waf ਨਾਲ ਬਣਾਓ
3.5 ਟੈਸਟਿੰਗ ns-3
3.6 ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣਾ
3.6.1 ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਸ
3.6.2 ਡੀਬੱਗਿੰਗ
3.6.3 ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ

ਅਧਿਆਇ 3

ਸ਼ੁਰੂ ਕਰਨਾ

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

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

ns-3 ਸਿਮੂਲੇਟਰ ਸਹਿਯੋਗੀ ਸੌਫਟਵੇਅਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਇੱਕ ਪ੍ਰਣਾਲੀ ਵਜੋਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਅਸੈਂਬਲੀ ਦੇ ਦੌਰਾਨ, ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਕੋਡ ਨੂੰ ਇਹਨਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ. C++ ਜਾਂ Python ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਨੂੰ ਕਸਟਮ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

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

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

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

ਜ਼ਿਆਦਾਤਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ns-3 ਅਧਿਕਾਰ ਰੂਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਇੱਕ ਗੈਰ-ਅਧਿਕਾਰਤ ਉਪਭੋਗਤਾ ਖਾਤੇ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

3.2 ਪੂਰਵ-ਸ਼ਰਤਾਂ

ਉਪਲਬਧ ns-3 ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਪੂਰੇ ਸੈੱਟ ਵਿੱਚ ਤੀਜੀ-ਧਿਰ ਲਾਇਬ੍ਰੇਰੀਆਂ 'ਤੇ ਬਹੁਤ ਸਾਰੀਆਂ ਨਿਰਭਰਤਾਵਾਂ ਹਨ, ਪਰ ਜ਼ਿਆਦਾਤਰ ਹਿੱਸੇ ਲਈ ns-3 ਨੂੰ ਕਈ ਆਮ (ਅਕਸਰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਥਾਪਤ) ਭਾਗਾਂ ਲਈ ਸਮਰਥਨ ਨਾਲ ਬਣਾਇਆ ਅਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ: ਇੱਕ C++ ਕੰਪਾਈਲਰ, ਪਾਈਥਨ, ਇੱਕ ਸਰੋਤ ਕੋਡ ਸੰਪਾਦਕ (ਉਦਾਹਰਨ ਲਈ, vim, emacs ਜ eclipse) ਅਤੇ, ਜੇਕਰ ਵਿਕਾਸ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ Git ਸੰਸਕਰਣ ਕੰਟਰੋਲ ਸਿਸਟਮ। ਬਹੁਤੇ ਪਹਿਲੀ ਵਾਰ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਚਿੰਤਾ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੋਵੇਗੀ ਜੇਕਰ ਉਹਨਾਂ ਦੀ ਸੰਰਚਨਾ ਵਿੱਚ ਕੁਝ ns-3 ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਗੁੰਮ ਹੋਣ ਦੀ ਰਿਪੋਰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ ਉਹਨਾਂ ਲਈ ਜੋ ਪੂਰੀ ਸਥਾਪਨਾ ਚਾਹੁੰਦੇ ਹਨ, ਪ੍ਰੋਜੈਕਟ ਇੱਕ ਵਿਕੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਉਪਯੋਗੀ ਸੁਝਾਅ ਅਤੇ ਜੁਗਤਾਂ ਵਾਲੇ ਪੰਨੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਅਜਿਹਾ ਹੀ ਇੱਕ ਪੰਨਾ ਇੰਸਟਾਲੇਸ਼ਨ ਪੰਨਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਸਿਸਟਮਾਂ ਲਈ ਇੰਸਟਾਲੇਸ਼ਨ ਹਦਾਇਤਾਂ ਹਨ, ਇੱਥੇ ਉਪਲਬਧ ਹਨ: https://www.nsnam.org/wiki/Installation.

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

ਤੁਸੀਂ ns-3 ਵਿਕੀ ਪੰਨੇ ਜਾਂ ਮੁੱਖ ਵੈੱਬਸਾਈਟ ਦੀ ਪੜਚੋਲ ਕਰਨ ਲਈ ਇਸ ਮੌਕੇ ਦਾ ਫਾਇਦਾ ਉਠਾ ਸਕਦੇ ਹੋ: https://www.nsnam.org, ਕਿਉਂਕਿ ਉੱਥੇ ਬਹੁਤ ਸਾਰੀ ਜਾਣਕਾਰੀ ਹੈ। ns-3 (ns-3.29) ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ns-3 ਨੂੰ ਚਲਾਉਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਟੂਲਸ ਦੀ ਲੋੜ ਹੈ:

ਟੂਲ ਪੈਕੇਜ/ਵਰਜਨ

• C++ ਕੰਪਾਈਲਰ
  clang++ ਜਾਂ g++ (g++ ਸੰਸਕਰਣ 4.9 ਜਾਂ ਉੱਚਾ)
• ਪਾਈਥਨ
  python2 ਸੰਸਕਰਣ >= 2.7.10, ਜਾਂ python3 ਸੰਸਕਰਣ >=3.4
• ਗਿੱਟ
  ਕੋਈ ਵੀ ਨਵੀਨਤਮ ਸੰਸਕਰਣ (GitLab.com 'ਤੇ ns-3 ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ)
• ਟਾਰ
  ਕੋਈ ਵੀ ਨਵੀਨਤਮ ਸੰਸਕਰਣ (ਐਨਐਸ-3 ਰੀਲੀਜ਼ ਨੂੰ ਅਨਪੈਕ ਕਰਨ ਲਈ)
• bunzip2
  ਕੋਈ ਵੀ ਨਵੀਨਤਮ ਸੰਸਕਰਣ (NS-3 ਰੀਲੀਜ਼ ਨੂੰ ਅਨਪੈਕ ਕਰਨ ਲਈ)

ਪਾਈਥਨ ਦੇ ਡਿਫਾਲਟ ਸੰਸਕਰਣ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਟਾਈਪ ਕਰੋ python -V. g++ ਸੰਸਕਰਣ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਟਾਈਪ ਕਰੋ g++ -v. ਜੇਕਰ ਕੋਈ ਟੂਲ ਗੁੰਮ ਹੈ ਜਾਂ ਬਹੁਤ ਪੁਰਾਣਾ ਹੈ, ਤਾਂ ਕਿਰਪਾ ਕਰਕੇ ns-3 ਵਿਕੀ ਪੰਨੇ 'ਤੇ ਇੰਸਟਾਲੇਸ਼ਨ ਗਾਈਡ ਵੇਖੋ।

ਹੁਣ ਤੋਂ, ਅਸੀਂ ਮੰਨਦੇ ਹਾਂ ਕਿ ਪਾਠਕ ਲੀਨਕਸ, ਮੈਕੋਸ, ਜਾਂ ਲੀਨਕਸ ਈਮੂਲੇਟਰ ਚਲਾ ਰਿਹਾ ਹੈ, ਅਤੇ ਘੱਟੋ-ਘੱਟ ਉਪਰੋਕਤ ਟੂਲ ਹਨ।

3.2.1 ਸਰੋਤ ਪੁਰਾਲੇਖ ਵਜੋਂ ns-3 ਰੀਲੀਜ਼ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ

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

ਚਲੋ ਮੰਨ ਲਓ ਕਿ ਤੁਸੀਂ, ਇੱਕ ਉਪਭੋਗਤਾ ਦੇ ਤੌਰ ਤੇ, ਇੱਕ ਸਥਾਨਕ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ns-3 ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸ ਨੂੰ ਕਹਿੰਦੇ ਹਨ ਵਰਕਸਪੇਸ. ਤੁਸੀਂ ਲੀਨਕਸ ਕੰਸੋਲ ਵਿੱਚ ਹੇਠਾਂ ਦਰਜ ਕਰਕੇ ਰੀਲੀਜ਼ ਦੀ ਕਾਰਜਸ਼ੀਲ ਕਾਪੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ (ਉਚਿਤ ਸੰਸਕਰਣ ਨੰਬਰਾਂ ਨੂੰ ਬਦਲ ਕੇ, ਬੇਸ਼ਕ)

$ cd 
$ mkdir workspace 
$ cd workspace 
$ wget https://www.nsnam.org/release/ns-allinone-3.29.tar.bz2 
$ tar xjf ns-allinone-3.29.tar.bz2 

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

ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋਏ ਤੁਹਾਨੂੰ ns-allinone-3.29 ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਲੈ ਜਾਵੇਗਾ, ਉੱਥੇ ਤੁਹਾਨੂੰ ਕਈ ਫਾਈਲਾਂ ਅਤੇ ਡਾਇਰੈਕਟਰੀਆਂ ਦੇਖਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ।

$ cd ns-allinone-3.29
$ ls
bake constants.py ns-3.29 README
build.py netanim-3.108 pybindgen-0.17.0.post58+ngcf00cc0 util.py

ਤੁਸੀਂ ਹੁਣ ns-3 ਬੇਸ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਹੋ ਅਤੇ ਬਿਲਡਿੰਗ ns-3 ਦੇ ਸੈਕਸ਼ਨ 'ਤੇ ਜਾ ਸਕਦੇ ਹੋ।

3.3 ਗਿੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ns-3 ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨਾ

ns-3 ਕੋਡ GitLab.com 'ਤੇ Git ਰਿਪੋਜ਼ਟਰੀਆਂ ਵਿੱਚ ਉਪਲਬਧ ਹੈ https://gitlab.com/nsnam/. ਸਮੂਹ nsnam ਇੱਕ ਓਪਨ ਸੋਰਸ ਪ੍ਰੋਜੈਕਟ ਦੁਆਰਾ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਵੱਖ-ਵੱਖ ਰਿਪੋਜ਼ਟਰੀਆਂ ਨੂੰ ਇਕੱਠਾ ਕਰਦਾ ਹੈ।

Git ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਵਾਤਾਵਰਣ ਨੂੰ ਫੋਰਕ ਜਾਂ ਕਲੋਨ ਕਰਨਾ ਹੈ ns-3-ਐਲਿਨੋਨ. ਇਹ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਜੋ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੇ ਜਾਣ ਵਾਲੇ ns-3 ਉਪ-ਸਿਸਟਮਾਂ ਦੀ ਲੋਡਿੰਗ ਅਤੇ ਅਸੈਂਬਲੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ Git ਲਈ ਨਵੇਂ ਹੋ, ਤਾਂ ਸ਼ਬਦ "ਕਾਂਟਾ" ਅਤੇ "ਕਲੋਨ" ਤੁਹਾਡੇ ਲਈ ਅਣਜਾਣ ਹੋ ਸਕਦੇ ਹਨ; ਜੇਕਰ ਅਜਿਹਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ GitLab.com 'ਤੇ ਸਥਿਤ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਕਲੋਨ ਕਰੋ (ਆਪਣੀ ਖੁਦ ਦੀ ਕਾਪੀ ਬਣਾਓ):

$ cd 
$ mkdir workspace 
$ cd workspace 
$ git clone https://gitlab.com/nsnam/ns-3-allinone.git 
$ cd ns-3-allinone 

ਇਸ ਪੜਾਅ 'ਤੇ, ਤੁਹਾਡੀ ਡਾਇਰੈਕਟਰੀ ਦਾ ਦ੍ਰਿਸ਼ ns-3-ਐਲਿਨੋਨ ਉੱਪਰ ਵਰਣਿਤ ਰੀਲੀਜ਼ ਆਰਕਾਈਵ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਥੋੜ੍ਹਾ ਵੱਖਰਾ ਹੈ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ:

$ ls
build.py constants.py download.py README util.py

ਕਿਰਪਾ ਕਰਕੇ ਨੋਟ ਕਰੋ ਕਿ ਇੱਕ ਸਕ੍ਰਿਪਟ ਹੈ download.py, ਜੋ ਕਿ ns-3 ਅਤੇ ਨਾਲ ਵਾਲੇ ਸਰੋਤ ਕੋਡ ਨੂੰ ਵੀ ਐਕਸਟਰੈਕਟ ਕਰੇਗਾ। ਇੱਥੇ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਵਿਕਲਪ ਹੈ: ਜਾਂ ਤਾਂ ਨਵੀਨਤਮ ns-3 ਵਿਕਾਸ ਸਨੈਪਸ਼ਾਟ ਡਾਊਨਲੋਡ ਕਰੋ:

$ python download.py

ਜਾਂ ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ns-3 ਰੀਲੀਜ਼ ਨੂੰ ਤਰਜੀਹ ਦਿਓ -n ਰਿਲੀਜ਼ ਨੰਬਰ ਦਰਸਾਉਣ ਲਈ:

$ python download.py -n ns-3.29

ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਇਸ ਕਦਮ ਦੇ ਬਾਅਦ ns-3-ਐਲਿਨੋਨ ਵਾਧੂ ਰਿਪੋਜ਼ਟਰੀਆਂ ਡਾਊਨਲੋਡ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ ns-3, ਸੇਕ, pybindgen и ਨੇਤਨੀਮ.

ਟਿੱਪਣੀ
ਸਾਫ਼ Ubuntu16.04 ਵਾਲੀ ਮਸ਼ੀਨ 'ਤੇ, ਮੈਨੂੰ ਇਸ ਲਈ ਕਮਾਂਡ ਬਦਲਣ ਦੀ ਲੋੜ ਸੀ: $ sudo python3 download.py -n ns-3.29 (ਇਸ ਤੋਂ ਬਾਅਦ ਅਨੁਵਾਦਕ ਦੇ ਨੋਟ)।

3.3.1 ਬੇਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ns-3 ਨੂੰ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

ਉਪਰੋਕਤ ਦੋ ਵਿਧੀਆਂ (ਸਰੋਤ ਆਰਕਾਈਵ ਜਾਂ ਰਿਪੋਜ਼ਟਰੀ ns-3-ਐਲਿਨੋਨ ਗਿੱਟ ਰਾਹੀਂ) ਮਲਟੀਪਲ ਐਡ-ਆਨਾਂ ਨਾਲ ਸਰਲ NS-3 ਇੰਸਟਾਲੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹਨ (pybindgen ਪਾਈਥਨ ਬਾਈਡਿੰਗ ਬਣਾਉਣ ਲਈ ਅਤੇ ਨੇਤਨੀਮ ਨੈੱਟਵਰਕ ਐਨੀਮੇਸ਼ਨ ਲਈ). ns-3-allinone ਵਿੱਚ ਮੂਲ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੀ ਤੀਜੀ ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਸੇਕ.

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

ਟਿੱਪਣੀ
CradleNetwork Simulation Cradle ਇੱਕ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਨੈੱਟਵਰਕ ਸਿਮੂਲੇਟਰ ਦੇ ਅੰਦਰ ਅਸਲ TCP/IP ਨੈੱਟਵਰਕ ਸਟੈਕ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

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

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

ਤੁਸੀਂ ਨਵੀਨਤਮ ਕਾਪੀ ਵੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ ਸੇਕਆਪਣੇ ਲੀਨਕਸ ਕੰਸੋਲ ਵਿੱਚ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦਾਖਲ ਕਰਕੇ (ਇਹ ਮੰਨ ਕੇ ਕਿ ਤੁਸੀਂ Git ਇੰਸਟਾਲ ਕੀਤਾ ਹੈ):

$ cd 
$ mkdir workspace 
$ cd workspace 
$ git clone https://gitlab.com/nsnam/bake.git

ਜਦੋਂ ਤੁਸੀਂ git ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖਿਆਂ ਵਰਗਾ ਕੁਝ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:

Cloning into 'bake'...
remote: Enumerating objects: 2086, done. 
remote: Counting objects: 100% (2086/2086), done. 
remote: Compressing objects: 100% (649/649), done. 
remote: Total 2086 (delta 1404), reused 2078 (delta 1399) 
Receiving objects: 100% (2086/2086), 2.68 MiB | 3.82 MiB/s, done. 
Resolving deltas: 100% (1404/1404), done.

ਕਮਾਂਡ ਪੂਰਾ ਹੋਣ ਤੋਂ ਬਾਅਦ ਕਲੋਨ ਤੁਹਾਡੇ ਕੋਲ ਨਾਮ ਦੀ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਸੇਕ, ਜਿਸ ਦੀ ਸਮੱਗਰੀ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣੀ ਚਾਹੀਦੀ ਹੈ:

$ cd bake
$ ls
bake bakeconf.xml bake.py doc examples generate-binary.py test TODO

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

1. ns-3.29: ਰੀਲੀਜ਼ ਦੇ ਅਨੁਸਾਰੀ ਮੋਡੀਊਲ; ਇਹ ਟਾਰਬਾਲ ਵਿੱਚ ਰੀਲੀਜ਼ ਦੇ ਸਮਾਨ ਭਾਗਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੇਗਾ;

2. ns-3-dev: ਇੱਕ ਸਮਾਨ ਮੋਡੀਊਲ, ਪਰ ਡਿਵੈਲਪਮੈਂਟ ਟ੍ਰੀ ਤੋਂ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ;

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

4. ns-3-ਐਲਿਨੋਨ: ਮੋਡੀਊਲ ਦੇ ਰੀਲੀਜ਼ ਸੰਸਕਰਣ ਦੇ ਸਮਾਨ ਇੱਕ ਵਿਚ ਸਾਰੇ, ਪਰ ਵਿਕਾਸ ਕੋਡ ਲਈ.

ਟਿੱਪਣੀ
ਕਲਿਕ ਕਰੋ — ਰਾਊਟਰ ਬਣਾਉਣ ਲਈ ਮਾਡਿਊਲਰ ਸਾਫਟਵੇਅਰ ਆਰਕੀਟੈਕਚਰ।

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

ਮੌਜੂਦਾ ਵਿਕਾਸ ਸਨੈਪਸ਼ਾਟ (ਗੈਰ-ਰਿਲੀਜ਼) ns-3 ਇੱਥੇ ਲੱਭਿਆ ਜਾ ਸਕਦਾ ਹੈ:https://gitlab.com/nsnam/ns-3-dev.git.

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

ਤੁਸੀਂ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਸੂਚੀ ਨੂੰ ਬ੍ਰਾਊਜ਼ ਕਰਕੇ, ਜਾਂ ns-3 ਰੀਲੀਜ਼ ਵੈੱਬ ਪੇਜ 'ਤੇ ਜਾ ਕੇ ਕੋਡ ਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਲੱਭ ਸਕਦੇ ਹੋ:https://www.nsnam.org/releases/ ਅਤੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਲਿੰਕ 'ਤੇ ਕਲਿੱਕ ਕਰਨਾ। ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ ਅਸੀਂ ns-3.29 ਦੇ ਨਾਲ ਜਾਰੀ ਰੱਖਾਂਗੇ।

ਹੁਣ, ਸਾਨੂੰ ਲੋੜੀਂਦੇ ns-3 ਭਾਗਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਪਕਾਉਣਾ. ਆਓ ਕੰਮ ਬਾਰੇ ਕੁਝ ਸ਼ੁਰੂਆਤੀ ਸ਼ਬਦ ਕਹੀਏ ਪਕਾਉਣਾ.

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

$ export BAKE_HOME=`pwd` 
$ export PATH=$PATH:$BAKE_HOME:$BAKE_HOME/build/bin 
$ export PYTHONPATH=$PYTHONPATH:$BAKE_HOME:$BAKE_HOME/build/lib

ਇਹ ਪ੍ਰੋਗਰਾਮ ਰੱਖੇਗਾ bake.py ਸ਼ੈੱਲ ਮਾਰਗ 'ਤੇ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਹੋਰ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਇਸ ਦੁਆਰਾ ਬਣਾਏ ਗਏ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਲੱਭਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ ਸੇਕ. ਕੁਝ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸੇਕ, ਉੱਪਰ ਦੱਸੇ PATH ਅਤੇ PYTHONPATH ਸੈਟਿੰਗ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਪਰ ns-3-allinone (ਵਾਧੂ ਪੈਕੇਜਾਂ ਦੇ ਨਾਲ) ਦੀ ਇੱਕ ਪੂਰੀ ਬਿਲਡ ਆਮ ਤੌਰ 'ਤੇ ਇਸਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਆਪਣੀ ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਓ ਅਤੇ ਕੰਸੋਲ ਵਿੱਚ ਹੇਠਾਂ ਦਰਜ ਕਰੋ:

$ ./bake.py configure -e ns-3.29

ਅੱਗੇ ਅਸੀਂ ਪੁੱਛਾਂਗੇ ਪਕਾਉਣਾ ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਸਾਡੇ ਕੋਲ ਵੱਖ-ਵੱਖ ਭਾਗਾਂ ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਟੂਲ ਹਨ। ਡਾਇਲ:

$ ./bake.py check

ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੇ ਵਰਗਾ ਕੁਝ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:

> Python - OK 
> GNU C++ compiler - OK 
> Mercurial - OK 
> Git - OK 
> Tar tool - OK 
> Unzip tool - OK 
> Make - OK 
> cMake - OK 
> patch tool - OK 
> Path searched for tools: /usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin ...

ਖਾਸ ਤੌਰ 'ਤੇ, ਅਪਲੋਡ ਟੂਲ ਜਿਵੇਂ ਕਿ Mercurial, CVS, Git ਅਤੇ ਬਾਜ਼ਾਰ ਇਸ ਪੜਾਅ ਵਿੱਚ ਜ਼ਰੂਰੀ ਹਨ ਕਿਉਂਕਿ ਉਹ ਸਾਨੂੰ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ। ਇਸ ਮੌਕੇ 'ਤੇ, ਗੁੰਮ ਹੋਏ ਟੂਲ ਨੂੰ ਆਪਣੇ ਸਿਸਟਮ ਲਈ ਆਮ ਤਰੀਕੇ ਨਾਲ ਸਥਾਪਿਤ ਕਰੋ (ਜੇ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਕਿਵੇਂ) ਜਾਂ ਮਦਦ ਲਈ ਆਪਣੇ ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਨਾਲ ਸੰਪਰਕ ਕਰੋ।

ਅੱਗੇ, ਸੌਫਟਵੇਅਰ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ:

$ ./bake.py download

ਨਤੀਜਾ ਕੁਝ ਅਜਿਹਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

>> Searching for system dependency setuptools - OK 
>> Searching for system dependency libgoocanvas2 - OK 
>> Searching for system dependency gi-cairo - OK 
>> Searching for system dependency pygobject - OK 
>> Searching for system dependency pygraphviz - OK 
>> Searching for system dependency python-dev - OK 
>> Searching for system dependency qt - OK 
>> Searching for system dependency g++ - OK 
>> Downloading pybindgen-0.19.0.post4+ng823d8b2 (target directory:pybindgen) - OK 
>> Downloading netanim-3.108 - OK 
>> Downloading ns-3.29 - OK

ਇਸ ਦਾ ਮਤਲਬ ਹੋਵੇਗਾ ਕਿ ਤਿੰਨ ਸਰੋਤ ਡਾਊਨਲੋਡ ਕੀਤੇ ਗਏ ਹਨ। ਹੁਣ ਸਰੋਤ ਡਾਇਰੈਕਟਰੀ 'ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ ls; ਤੁਹਾਨੂੰ ਇਹ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:

$ cd source 
$ ls
netanim-3.108 ns-3.29 pybindgen

ਹੁਣ ਤੁਸੀਂ ns-3 ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਬਣਾਉਣ ਲਈ ਤਿਆਰ ਹੋ।

3.4 ਅਸੈਂਬਲੀ ns-3

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

3.4.1 build.py ਨਾਲ ਬਿਲਡਿੰਗ

ਸਾਵਧਾਨ ਇਹ ਬਿਲਡ ਸਟੈਪ ਸਿਰਫ ਸਰੋਤ ਪੁਰਾਲੇਖ ਸੰਸਕਰਣ ਤੋਂ ਉਪਲਬਧ ਹੈ ਜਿਵੇਂ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ; ਅਤੇ ਗਿੱਟ ਜਾਂ ਬੇਕ ਦੁਆਰਾ ਡਾਊਨਲੋਡ ਨਹੀਂ ਕੀਤਾ ਗਿਆ।

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

ਜੇਕਰ ਤੁਸੀਂ ਵਰਤ ਕੇ ਡਾਊਨਲੋਡ ਕੀਤਾ ਹੈ ਟਾਰਬਾਲ, ਫਿਰ ਤੁਹਾਡੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ~/ਵਰਕਸਪੇਸ ਇੱਕ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਕੁਝ ਅਜਿਹਾ ਹੈ ns-allinone-3.29. ਹੇਠ ਲਿਖੇ ਦਰਜ ਕਰੋ:

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

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

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

Waf: Leaving directory '/path/to/workspace/ns-allinone-3.29/ns-3.29/build'
'build' finished successfully (6m25.032s) 

Modules built:
antenna                aodv                     applications
bridge                 buildings                config-store
core                   csma                     csma-layout
dsdv                   dsr                      energy 
fd-net-device          flow-monitor             internet
internet-apps          lr-wpan                  lte
mesh                   mobility                 mpi
netanim (no Python)    network                  nix-vector-routing 
olsr                   point-to-point           point-to-point-layout 
propagation            sixlowpan                spectrum 
stats                  tap-bridge               test (no Python) 
topology-read          traffic-control          uan 
virtual-net-device     visualizer               wave 
wifi                   wimax 

Modules not built (see ns-3 tutorial for explanation):
brite                  click                    openflow 
Leaving directory ./ns-3.29

ਸੂਚੀ ਦੀਆਂ ਆਖਰੀ ਤਿੰਨ ਲਾਈਨਾਂ ਵਿੱਚ ਅਸੀਂ ਉਹਨਾਂ ਮੈਡਿਊਲਾਂ ਬਾਰੇ ਇੱਕ ਸੁਨੇਹਾ ਦੇਖਦੇ ਹਾਂ ਜੋ ਨਹੀਂ ਬਣਾਏ ਗਏ ਸਨ:

Modules not built (see ns-3 tutorial for explanation):
brite                     click

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

3.4.2 ਬੇਕ ਨਾਲ ਬਿਲਡਿੰਗ

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

$ ./bake.py build

ਅਤੇ ਤੁਹਾਨੂੰ ਕੁਝ ਅਜਿਹਾ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ:

>> Building pybindgen-0.19.0.post4+ng823d8b2 - OK 
>> Building netanim-3.108 - OK 
>> Building ns-3.29 - OK

ਟੂਲਟਿਪ: ਤੁਸੀਂ "bake.py deploy" 'ਤੇ ਕਾਲ ਕਰਕੇ ਇੱਕੋ ਸਮੇਂ 'ਤੇ ਡਾਊਨਲੋਡ ਅਤੇ ਬਿਲਡ ਸਟੈਪਸ ਦੋਵੇਂ ਕਰ ਸਕਦੇ ਹੋ।

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

>> Building castxml - Problem 
> Problem: Optional dependency, module "castxml" failed
This may reduce the functionality of the final build.
However, bake will continue since "castxml" is not an essential dependency.
For more information call bake with -v or -vvv, for full verbose mode.

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

ਜੇਕਰ ਇਹ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਤੁਹਾਨੂੰ ਗੁੰਮ ਨਿਰਭਰਤਾ ਬਾਰੇ ਇੱਕ ਸੰਕੇਤ ਦੇਵੇਗੀ:

$ ./bake.py show

ਪੈਕੇਜਾਂ ਦੀਆਂ ਵੱਖ-ਵੱਖ ਨਿਰਭਰਤਾਵਾਂ ਜੋ ਤੁਸੀਂ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹੋ, ਸੂਚੀਬੱਧ ਕੀਤਾ ਜਾਵੇਗਾ।

3.4.3 Waf ਨਾਲ ਬਣਾਓ

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

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

$ ./waf clean 
$ ./waf configure --build-profile=optimized --enable-examples --enable-tests

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

Setting top to      : /home/ns3user/workspace/bake/source/ns-3-dev
Setting out to      : /home/ns3user/workspace/bake/source/ns-3-dev/build
Checking for 'gcc' (C compiler)        : /usr/bin/gcc 
Checking for cc version                : 7.3.0 
Checking for 'g++' (C++ compiler)      : /usr/bin/g++ 
Checking for compilation flag -march=native support : ok 
Checking for compilation flag -Wl,--soname=foo support : ok 
Checking for compilation flag -std=c++11 support       : ok 
Checking boost includes   : headers not found, please ,!provide a --boost-includes argument (see help) 
Checking boost includes   : headers not found, please ,!provide a --boost-includes argument (see help) 
Checking for program 'python'            : /usr/bin/python 
Checking for python version >= 2.3       : 2.7.15 python-config                                                                     : /usr/bin/python-config
Asking python-config for pyembed '--cflags --libs --ldflags' flags : yes
Testing pyembed configuration                                      : yes
Asking python-config for pyext '--cflags --libs --ldflags' flags   : yes
Testing pyext configuration                                        : yes

Checking for compilation flag -fvisibility=hidden support          : ok 
Checking for compilation flag -Wno-array-bounds support            : ok 
Checking for pybindgen location          : ../pybindgen ,!(guessed) 
Checking for python module 'pybindgen'   : 0.19.0. ,!post4+g823d8b2 
Checking for pybindgen version           : 0.19.0. ,!post4+g823d8b2 
Checking for code snippet                : yes 
Checking for types uint64_t and unsigned long equivalence : no 
Checking for code snippet                                 : no 
Checking for types uint64_t and unsigned long long equivalence     : yes 
Checking for the apidefs that can be used for Python bindings                       : gcc-LP64 
Checking for internal GCC cxxabi         : complete 
Checking for python module 'pygccxml'    : not found 
Checking for click location              : not found 
Checking for program 'pkg-config'        : /usr/bin/pkg- ,!config 
Checking for 'gtk+-3.0'                  : not found 
Checking for 'libxml-2.0'                : yes 
checking for uint128_t                   : not found 
checking for __uint128_t                 : yes 
Checking high precision implementation   : 128-bit integer ,!(default) 
Checking for header stdint.h             : yes 
Checking for header inttypes.h           : yes 
Checking for header sys/inttypes.h       : not found 
Checking for header sys/types.h          : yes 
Checking for header sys/stat.h           : yes 
Checking for header dirent.h             : yes 
Checking for header stdlib.h             : yes 
Checking for header signal.h             : yes 
Checking for header pthread.h            : yes 
Checking for header stdint.h             : yes 
Checking for header inttypes.h           : yes 
Checking for header sys/inttypes.h       : not found
Checking for library rt                  : yes 
Checking for header sys/ioctl.h          : yes 
Checking for header net/if.h             : yes 
Checking for header net/ethernet.h       : yes 
Checking for header linux/if_tun.h       : yes 
Checking for header netpacket/packet.h   : yes 
Checking for NSC location                : not found 
Checking for 'sqlite3'                   : not found 
Checking for header linux/if_tun.h       : yes 
Checking for python module 'gi'          : 3.26.1 
Checking for python module 'gi.repository.GObject'      : ok 
Checking for python module 'cairo'                      : ok 
Checking for python module 'pygraphviz'                 : 1.4rc1 
Checking for python module 'gi.repository.Gtk'          : ok 
Checking for python module 'gi.repository.Gdk'          : ok 
Checking for python module 'gi.repository.Pango'        : ok 
Checking for python module 'gi.repository.GooCanvas'    : ok 
Checking for program 'sudo'                             : /usr/bin/sudo 
Checking for program 'valgrind'                         : not found 
Checking for 'gsl' : not found python-config            : not found 
Checking for compilation flag -fstrict-aliasing support : ok 
Checking for compilation flag -fstrict-aliasing support : ok 
Checking for compilation flag -Wstrict-aliasing support : ok 
Checking for compilation flag -Wstrict-aliasing support : ok 
Checking for program 'doxygen'                          : /usr/bin/doxygen
---- Summary of optional ns-3 features:
Build profile : optimized
Build directory : 
BRITE Integration : not enabled (BRITE not enabled (see option --with- ,!brite)) 
DES Metrics event collection : not enabled (defaults to disabled) 
Emulation FdNetDevice        : enabled 
Examples                     : enabled 
File descriptor NetDevice    : enabled 
GNU Scientific Library (GSL) : not enabled (GSL not found) 
Gcrypt library               : not enabled
(libgcrypt not found: you can use ,!libgcrypt-config to find its location.) GtkConfigStore               : not enabled (library 'gtk+-3.0 >= 3.0' not fou   nd)
MPI Support                  : not enabled (option --enable-mpi not selected)
ns-3 Click Integration       : not enabled (nsclick not enabled (see option --with- ,!nsclick))
ns-3 OpenFlow Integration   : not enabled (Required boost libraries not found) 
Network Simulation Cradle    : not enabled (NSC not found (see option --with-nsc))
PlanetLab FdNetDevice         : not enabled (PlanetLab operating system not detected ,!(see option --force-planetlab)) PyViz visualizer : enabled 
Python API Scanning Support   : not enabled (Missing 'pygccxml' Python module)
Python Bindings : enabled 
Real Time Simulator           : enabled 
SQlite stats data output      : not enabled (library 'sqlite3' not found)
Tap Bridge                    : enabled 
Tap FdNetDevice               : enabled
Tests                         : enabled 
Threading Primitives          : enabled 
Use sudo to set suid bit   : not enabled (option --enable-sudo not selected)
XmlIo                         : enabled
'configure' finished successfully (6.387s)

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

ਚਲੋ ਹੁਣ ਵਾਪਸ ਚੱਲੀਏ ਅਤੇ ਡੀਬੱਗ ਬਿਲਡ ਵਿੱਚ ਉਦਾਹਰਨਾਂ ਅਤੇ ਟੈਸਟਾਂ ਵਾਲੇ ਵਾਪਿਸ ਸਵਿਚ ਕਰੀਏ।

$ ./waf clean 
$ ./waf configure --build-profile=debug --enable-examples --enable-tests

ਬਿਲਡ ਸਿਸਟਮ ਹੁਣ ਸੈੱਟਅੱਪ ਹੋ ਗਿਆ ਹੈ ਅਤੇ ਤੁਸੀਂ ਸਿਰਫ਼ ਟਾਈਪ ਕਰਕੇ ns-3 ਪ੍ਰੋਗਰਾਮਾਂ ਦੇ ਡੀਬੱਗ ਵਰਜਨ ਬਣਾ ਸਕਦੇ ਹੋ:

$ ./waf

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

ਇਹ ਵੇਖਣ ਲਈ ਕਿ ਇੱਕ ਦਿੱਤੇ ਪ੍ਰੋਜੈਕਟ ਸੰਰਚਨਾ ਲਈ ਕਿਹੜਾ ਪ੍ਰੋਫਾਈਲ ਕਿਰਿਆਸ਼ੀਲ ਹੈ, ਇੱਕ ਕਮਾਂਡ ਹੈ:

$ ./waf --check-profile 
Waf: Entering directory `/path/to/ns-3-allinone/ns-3.29/build' 
Build profile: debug

ਉਪਰੋਕਤ ਦ੍ਰਿਸ਼ build.py ਦਲੀਲਾਂ ਦਾ ਸਮਰਥਨ ਵੀ ਕਰਦਾ ਹੈ --enable-examples и --enable-tests, ਪਰ ਹੋਰ ਵਿਕਲਪ ਵਾਫ ਇਹ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ:

$ ./build.py --disable-python

ਪ੍ਰਤੀਕਰਮ ਇਸ ਤਰ੍ਹਾਂ ਹੋਵੇਗਾ:

build.py: error: no such option: --disable-python

ਹਾਲਾਂਕਿ, ਵਿਸ਼ੇਸ਼ ਆਪਰੇਟਰ - - ਦੁਆਰਾ ਵਾਧੂ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪਾਸ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ wafਇਸ ਲਈ ਉਪਰੋਕਤ ਦੀ ਬਜਾਏ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਕੰਮ ਕਰੇਗੀ:

$ ./build.py -- --disable-python

ਕਿਉਂਕਿ ਇਹ ਮੁੱਖ ਕਮਾਂਡ ਤਿਆਰ ਕਰਦਾ ਹੈ ./waf configure --disable-python. ਇੱਥੇ ਬਾਰੇ ਕੁਝ ਹੋਰ ਸ਼ੁਰੂਆਤੀ ਸੁਝਾਅ ਹਨ ਵਾਫ.

ਬਿਲਡ ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣਾ

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

ਉਦਾਹਰਨ ਲਈ, ਪਹਿਲਾਂ ਫੇਡੋਰਾ 3.28 ਲਈ ns‑28 ਜਾਰੀ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਮੁੱਖ ਸੰਸਕਰਣ ਸ਼ਾਮਲ ਸੀ। ਜੀਸੀਸੀ (gcc-8). ਫੇਡੋਰਾ 3.28 ਦੇ ਅਧੀਨ ਰੀਲੀਜ਼ ns-28 ਜਾਂ ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਨੂੰ ਬਣਾਉਣਾ, Gtk2+ ਦੇ ਨਾਲ, ਹੇਠ ਲਿਖੀ ਗਲਤੀ ਆਵੇਗੀ:

/usr/include/gtk-2.0/gtk/gtkfilechooserbutton.h:59:8: error: unnecessary parentheses ,!in declaration of ‘__gtk_reserved1’ [-Werror=parentheses] void (*__gtk_reserved1);

ns‑3.28.1 ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਰੀਲੀਜ਼ਾਂ ਵਿੱਚ, ਵਿੱਚ ਵਾਫ ਇਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਇੱਕ ਵਿਕਲਪ ਉਪਲਬਧ ਹੈ। ਇਹ g++ ਅਤੇ clang++ ਵਿੱਚ "-Werror" ਫਲੈਗ ਸੈੱਟ ਕਰਨ ਨੂੰ ਅਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ "--disable-werror" ਵਿਕਲਪ ਹੈ ਅਤੇ ਸੰਰਚਨਾ ਦੌਰਾਨ ਲਾਗੂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ:

$ ./waf configure --disable-werror --enable-examples --enable-tests

ਕੌਂਫਿਗਰ ਕਰੋ ਜਾਂ ਇਕੱਠੇ ਕਰੋ

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

$ ./waf configure --enable-sudo --enable-examples --enable-tests

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

$ ./waf --help

ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਅਸੀਂ ਟੈਸਟਿੰਗ ਸੰਬੰਧੀ ਕੁਝ ਵਿਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।

ਅਸੈਂਬਲੀ ਪ੍ਰੋਫਾਈਲਾਂ

ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਦੇਖ ਚੁੱਕੇ ਹਾਂ ਕਿ ਤੁਸੀਂ ਕਿਵੇਂ ਸੰਰਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਵਾਫ ਅਸੈਂਬਲੀਆਂ ਲਈ ਡੀਬੱਗ и ਅਨੁਕੂਲ:

$ ./waf --build-profile=debug

ਇੱਕ ਇੰਟਰਮੀਡੀਏਟ ਅਸੈਂਬਲੀ ਪ੍ਰੋਫਾਈਲ ਵੀ ਹੈ, ਰੀਲਿਜ਼. ਵਿਕਲਪ -d ਦਾ ਸਮਾਨਾਰਥੀ ਹੈ --build-profile. ਬਿਲਡ ਪ੍ਰੋਫਾਈਲ ਲੌਗਿੰਗ, ਦਾਅਵੇ, ਅਤੇ ਕੰਪਾਈਲਰ ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਸਵਿੱਚਾਂ ਦੀ ਵਰਤੋਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ:

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

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਕੋਡ ਹੈ ਜੋ ਸਿਰਫ ਕੁਝ ਬਿਲਡ ਪ੍ਰੋਫਾਈਲਾਂ ਵਿੱਚ ਚੱਲਣਾ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਕੋਡ ਰੈਪਰ ਮੈਕਰੋ ਦੀ ਵਰਤੋਂ ਕਰੋ:

NS_BUILD_DEBUG (std::cout << "Part of an output line..." << std::flush; timer.Start ,!()); DoLongInvolvedComputation ();
NS_BUILD_DEBUG (timer.Stop (); std::cout << "Done: " << timer << std::endl;)

ਡਿਫੌਲਟ, ਵਾਫ ਬਿਲਡ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਕਲਾਕ੍ਰਿਤੀਆਂ ਨੂੰ ਸਥਾਨ ਦਿੰਦਾ ਹੈ। ਤੁਸੀਂ ਵਿਕਲਪ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵੱਖਰੀ ਆਉਟਪੁੱਟ ਡਾਇਰੈਕਟਰੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ - -out, ਉਦਾਹਰਨ ਲਈ:

$ ./waf configure --out=my-build-dir

ਇਸ ਨੂੰ ਬਿਲਡ ਪ੍ਰੋਫਾਈਲਾਂ ਦੇ ਨਾਲ ਜੋੜ ਕੇ, ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਵੱਖ-ਵੱਖ ਸੰਕਲਨ ਵਿਕਲਪਾਂ ਵਿਚਕਾਰ ਸਵਿਚ ਕਰ ਸਕਦੇ ਹੋ:

$ ./waf configure --build-profile=debug --out=build/debug
$ ./waf build
... 
$ ./waf configure --build-profile=optimized --out=build/optimized 
$ ./waf build
...

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

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

$ export NS3CONFIG="--enable-examples --enable-tests" 
$ export NS3DEBUG="--build-profile=debug --out=build/debug"
$ export NS3OPT=="--build-profile=optimized --out=build/optimized" 

$ ./waf configure $NS3CONFIG $NS3DEBUG
$ ./waf build 
... 
$ ./waf configure $NS3CONFIG $NS3OPT
$ ./waf build

ਕੰਪਾਈਲਰ ਅਤੇ ਫਲੈਗ

ਉਪਰੋਕਤ ਉਦਾਹਰਣਾਂ ਵਿੱਚ ਵਾਫ ns-3 ਬਣਾਉਣ ਲਈ GCC ਤੋਂ C++ ਕੰਪਾਈਲਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ( g ++). ਹਾਲਾਂਕਿ, ਤੁਸੀਂ ਉਸ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ ਵਾਫ C++ ਕੰਪਾਈਲਰ, CXX ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਕੇ। ਉਦਾਹਰਨ ਲਈ, C++ ਕੰਪਾਈਲਰ Clang, clang++ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ,

$ CXX="clang++" ./waf configure 
$ ./waf build 

ਇਸੇ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਸੰਰਚਿਤ ਕਰ ਸਕਦੇ ਹੋ ਵਾਫ ਵਰਤ ਕੇ ਵੰਡਿਆ ਸੰਕਲਨ ਵਰਤਣ ਲਈ distcc:

$ CXX="distcc g++" ./waf configure 
$ ./waf build

distcc ਅਤੇ ਡਿਸਟ੍ਰੀਬਿਊਟਡ ਕੰਪਾਈਲੇਸ਼ਨ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਦਸਤਾਵੇਜ਼ੀ ਭਾਗ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਪੰਨੇ 'ਤੇ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ। ns-3 ਦੀ ਸੰਰਚਨਾ ਕਰਦੇ ਸਮੇਂ ਕੰਪਾਈਲਰ ਫਲੈਗ ਜੋੜਨ ਲਈ, CXXFLAGS_EXTRA ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਸੈਟਿੰਗ

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

ਜੇਕਰ ਉਪਭੋਗਤਾ ਬਿਲਡ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਬਾਹਰ ਇੰਸਟਾਲ ਕਰਨਾ ਪਸੰਦ ਕਰਦੇ ਹਨ, ਤਾਂ ਉਹ ਕਮਾਂਡ ਚਲਾ ਸਕਦੇ ਹਨ ./waf ਇੰਸਟਾਲ ਕਰੋ. ਇੰਸਟਾਲੇਸ਼ਨ ਲਈ ਡਿਫਾਲਟ ਅਗੇਤਰ ਹੈ / usr / localਇਸੇ ਕਰਕੇ ./waf ਇੰਸਟਾਲ ਕਰੋ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਸਥਾਪਿਤ ਕਰੇਗਾ / usr / local / bin, ਵਿੱਚ ਲਾਇਬ੍ਰੇਰੀਆਂ / usr / local / lib ਅਤੇ ਹੈਡਰ ਫਾਈਲਾਂ ਵਿੱਚ /usr/local/ਸ਼ਾਮਲ. ਸੁਪਰਯੂਜ਼ਰ ਅਧਿਕਾਰਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਡਿਫੌਲਟ ਪ੍ਰੀਫਿਕਸ ਨਾਲ ਸੈੱਟ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਆਮ ਕਮਾਂਡ ਹੋਵੇਗੀ sudo ./waf ਇੰਸਟਾਲ ਕਰੋ. ਲਾਂਚ ਕੀਤੇ ਜਾਣ 'ਤੇ, Waf ਪਹਿਲਾਂ ਬਿਲਡ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਾਂਝੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਚੋਣ ਕਰੇਗਾ, ਫਿਰ ਸਥਾਨਕ ਵਾਤਾਵਰਣ ਵਿੱਚ ਸੰਰਚਿਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਮਾਰਗ ਦੇ ਨਾਲ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਖੋਜ ਕਰੇਗਾ। ਇਸ ਲਈ ਜਦੋਂ ਕਿਸੇ ਸਿਸਟਮ 'ਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਜਾਂਚ ਕਰਨਾ ਚੰਗਾ ਅਭਿਆਸ ਹੈ ਕਿ ਸਹੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ। ਉਪਭੋਗਤਾ ਸੰਰਚਨਾ ਦੇ ਦੌਰਾਨ ਵਿਕਲਪ ਨੂੰ ਪਾਸ ਕਰਕੇ ਇੱਕ ਵੱਖਰੇ ਪ੍ਰੀਫਿਕਸ ਨਾਲ ਇੰਸਟਾਲ ਕਰਨ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹਨ --prefix, ਉਦਾਹਰਨ ਲਈ:

./waf configure --prefix=/opt/local

ਜੇਕਰ ਬਾਅਦ ਵਿੱਚ, ਬਿਲਡ ਤੋਂ ਬਾਅਦ, ਉਪਭੋਗਤਾ ਇੰਸਟਾਲੇਸ਼ਨ ਕਮਾਂਡ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦਾ ਹੈ ./waf, ਅਗੇਤਰ ਵਰਤਿਆ ਜਾਵੇਗਾ /opt/local.

ਦੀ ਟੀਮ ./waf clean ਜੇਕਰ ਇੰਸਟਾਲੇਸ਼ਨ ਵਰਤਦੀ ਹੈ ਤਾਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਮੁੜ ਸੰਰਚਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਵਾਫ ਇੱਕ ਵੱਖਰੇ ਅਗੇਤਰ ਦੇ ਅਧੀਨ.

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

Waf ਸਿੰਗਲ

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

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

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

$ export NS3DIR="$PWD" 
$ function waff { cd $NS3DIR && ./waf $* ; } 

$ cd scratch 
$ waff build

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

3.5 ਟੈਸਟਿੰਗ ns-3

ਤੁਸੀਂ ਸਕ੍ਰਿਪਟ ਚਲਾ ਕੇ ns-3 ਡਿਸਟਰੀਬਿਊਸ਼ਨ ਦੇ ਯੂਨਿਟ ਟੈਸਟ ਚਲਾ ਸਕਦੇ ਹੋ ./test.py:

$ ./test.py

ਇਹ ਪ੍ਰੀਖਿਆਵਾਂ ਦੇ ਸਮਾਨਾਂਤਰ ਚਲਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ ਵਾਫ. ਅੰਤ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇੱਕ ਸੁਨੇਹਾ ਵੇਖਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਕਿਹਾ ਗਿਆ ਹੈ:

92 of 92 tests passed (92 passed, 0 failed, 0 crashed, 0 valgrind errors)

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

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

Waf: Entering directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build' 
Waf: Leaving directory `/path/to/workspace/ns-3-allinone/ns-3-dev/build' 
'build' finished successfully (1.799s) 

Modules built:
aodv           applications          bridge
click          config-store          core
csma           csma-layout           dsdv
emu            energy                flow-monitor
internet       lte                   mesh
mobility       mpi                   netanim
network        nix-vector-routing    ns3tcp
ns3wifi        olsr                  openflow
point-to-point point-to-point-layout propagation
spectrum       stats                 tap-bridge
template       test                  tools
topology-read  uan                   virtual-net-device
visualizer     wifi                  wimax

PASS: TestSuite ns3-wifi-interference
PASS: TestSuite histogram 

...

PASS: TestSuite object
PASS: TestSuite random-number-generators
92 of 92 tests passed (92 passed, 0 failed, 0 crashed, 0 valgrind errors)

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

3.6 ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣਾ

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

$ ./waf --run hello-simulator

Waf ਪਹਿਲਾਂ ਇਹ ਜਾਂਚ ਕਰੇਗਾ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਹੀ ਢੰਗ ਨਾਲ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਜੇਕਰ ਲੋੜ ਹੋਵੇ ਤਾਂ ਉਸ ਨੂੰ ਬਣਾਓ। ਫਿਰ ਵਾਫ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਚਲਾਏਗਾ ਜੋ ਹੇਠਾਂ ਦਿੱਤੀ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦਾ ਹੈ।

Hello Simulator

ਵਧਾਈਆਂ! ਤੁਸੀਂ ਹੁਣ ਇੱਕ ns-3 ਉਪਭੋਗਤਾ ਹੋ!

ਮੈਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਮੈਂ ਨਤੀਜੇ ਨਹੀਂ ਦੇਖਦਾ?

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

$ ./waf configure --build-profile=debug --enable-examples --enable-tests

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

$ ./waf

ਹੁਣ ਜੇਕਰ ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ ਹੈਲੋ-ਸਿਮੂਲੇਟਰ, ਤੁਹਾਨੂੰ ਉਮੀਦ ਕੀਤੀ ਨਤੀਜਾ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ।

3.6.1 ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਸ

ns-3 ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਮਾਂਡ ਲਾਈਨ ਆਰਗੂਮੈਂਟਸ ਪਾਸ ਕਰਨ ਲਈ, ਹੇਠ ਦਿੱਤੇ ਪੈਟਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ:

$ ./waf --run <ns3-program> --command-template="%s <args>"

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

$ ./waf --run '<ns3-program> --arg1=value1 --arg2=value2 ...'

ਇੱਕ ਹੋਰ ਖਾਸ ਤੌਰ 'ਤੇ ਉਪਯੋਗੀ ਉਦਾਹਰਨ ਚੋਣ ਸੂਟ ਚਲਾ ਰਹੀ ਹੈ। ਮੰਨ ਲਓ ਕਿ ਇੱਥੇ ਇੱਕ ਟੈਸਟ ਸੂਟ ਹੈ ਜਿਸ ਨੂੰ ਮਾਈਟੈਸਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਅਸਲ ਵਿੱਚ ਅਜਿਹਾ ਨਹੀਂ ਹੈ)। ਉੱਪਰ ਅਸੀਂ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਕਈ ਟੈਸਟਾਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ./test.py ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਜੋ ਵਾਰ-ਵਾਰ ਟੈਸਟ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ। ਟੈਸਟ ਦੌੜਾਕ. ਕਾਲ ਕਰੋ ਟੈਸਟ ਦੌੜਾਕ ਸਿੱਧਾ ਇੱਕ ਟੈਸਟ ਚਲਾਉਣ ਲਈ:

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

ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਦਲੀਲਾਂ ਦਿੱਤੀਆਂ ਜਾਣਗੀਆਂ ਟੈਸਟ ਦੌੜਾਕ. ਕਿਉਂਕਿ mytest ਮੌਜੂਦ ਨਹੀਂ ਹੈ, ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਤਿਆਰ ਕੀਤਾ ਜਾਵੇਗਾ। ਉਪਲਬਧ ਟੈਸਟ-ਰਨਰ ਵਿਕਲਪਾਂ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ, ਦਾਖਲ ਕਰੋ:

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

3.6.2 ਡੀਬੱਗਿੰਗ

ns-3 ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਕਿਸੇ ਹੋਰ ਸਹੂਲਤ ਦੇ ਅਧੀਨ ਚਲਾਉਣ ਲਈ, ਜਿਵੇਂ ਕਿ ਡੀਬੱਗਰ (ਉਦਾਹਰਨ ਲਈ, ਜੀਡੀਬੀ) ਜਾਂ ਮੈਮੋਰੀ ਟੈਸਟ ਟੂਲ (ਉਦਾਹਰਨ ਲਈ, valgrind), ਸਮਾਨ ਰੂਪ ਦੀ ਵਰਤੋਂ ਕਰੋ - -command-template = "…". ਉਦਾਹਰਨ ਲਈ, ਡੀਬਗਰ ਵਿੱਚ ਚਲਾਉਣ ਲਈ ਜੀਡੀਬੀ ਆਰਗੂਮੈਂਟਸ ਦੇ ਨਾਲ ਤੁਹਾਡਾ ਹੈਲੋ-ਸਿਮੂਲੇਟਰ ns-3 ਪ੍ਰੋਗਰਾਮ:

$ ./waf --run=hello-simulator --command-template="gdb %s --args <args>"

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

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

3.6.3 ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ

Waf ਨੂੰ ns-3 ਰੁੱਖ ਦੇ ਸਿਖਰ 'ਤੇ ਇਸ ਦੇ ਸਥਾਨ ਤੋਂ ਲਾਂਚ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਫੋਲਡਰ ਵਰਕਿੰਗ ਡਾਇਰੈਕਟਰੀ ਬਣ ਜਾਂਦਾ ਹੈ ਜਿੱਥੇ ਆਉਟਪੁੱਟ ਫਾਈਲਾਂ ਲਿਖੀਆਂ ਜਾਣਗੀਆਂ. ਪਰ ਜੇ ਤੁਸੀਂ ਇਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ns-3 ਸਰੋਤ ਟ੍ਰੀ ਤੋਂ ਬਾਹਰ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਕੀ ਹੋਵੇਗਾ? ਦਲੀਲ ਦੀ ਵਰਤੋਂ ਕਰੋ - -cwd:

$ ./waf --cwd=...

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

$ function waff {
CWD="$PWD" 
cd $NS3DIR >/dev/null 
./waf --cwd="$CWD" $*
cd - >/dev/null 
}

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

ਜਾਰੀ: ਅਧਿਆਇ 4

ਸਰੋਤ: www.habr.com