🥇NS-3 ನೆಟ್‌ವರ್ಕ್ ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ಟ್ಯುಟೋರಿಯಲ್. ಅಧ್ಯಾಯ 3

ಅಧ್ಯಾಯ 1,2

3 ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ
3.1 ಅವಲೋಕನ
3.2 ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು
3.2.1 ns-3 ಬಿಡುಗಡೆಯನ್ನು ಮೂಲ ಆರ್ಕೈವ್ ಆಗಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
3.3 Git ಬಳಸಿಕೊಂಡು ns-3 ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು
3.3.1 ಬೇಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ns-3 ಅನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
3.4 ಅಸೆಂಬ್ಲಿ ಎನ್ಎಸ್-3
3.4.1 build.py ಜೊತೆಗೆ ಕಟ್ಟಡ
3.4.2 ಬೇಕ್ನೊಂದಿಗೆ ಕಟ್ಟಡ
3.4.3 ವಾಫ್ನೊಂದಿಗೆ ನಿರ್ಮಿಸಿ
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++ ಅಥವಾ ಪೈಥಾನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

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++ ಕಂಪೈಲರ್, ಪೈಥಾನ್, ಮೂಲ ಕೋಡ್ ಸಂಪಾದಕ (ಉದಾಹರಣೆಗೆ, ವಿಮ್, ಎಮ್ಯಾಕ್ಸ್ ಅಥವಾ ಎಕ್ಲಿಪ್ಸ್) ಮತ್ತು, ಅಭಿವೃದ್ಧಿ ರೆಪೊಸಿಟರಿಗಳನ್ನು ಬಳಸಿದರೆ, Git ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳು. ಹೆಚ್ಚಿನ ಮೊದಲ-ಬಾರಿ ಬಳಕೆದಾರರು ತಮ್ಮ ಕಾನ್ಫಿಗರೇಶನ್ ಕೆಲವು ns-3 ಸುಧಾರಿತ ವೈಶಿಷ್ಟ್ಯಗಳು ಕಾಣೆಯಾಗಿದೆ ಎಂದು ವರದಿ ಮಾಡಿದರೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ಪೂರ್ಣ ಸ್ಥಾಪನೆಯನ್ನು ಬಯಸುವವರಿಗೆ, ಯೋಜನೆಯು ಸಾಕಷ್ಟು ಉಪಯುಕ್ತ ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳೊಂದಿಗೆ ಪುಟಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ವಿಕಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಅಂತಹ ಒಂದು ಪುಟವು ಅನುಸ್ಥಾಪನಾ ಪುಟವಾಗಿದೆ, ವಿವಿಧ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳೊಂದಿಗೆ, ಇಲ್ಲಿ ಲಭ್ಯವಿದೆ: https://www.nsnam.org/wiki/Installation.

ಈ ವಿಕಿಯ ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳ ವಿಭಾಗವು ಸಾಮಾನ್ಯ ns-3 ಆಯ್ಕೆಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಯಾವ ಪ್ಯಾಕೇಜುಗಳ ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ ಮತ್ತು Linux ಅಥವಾ macOS ನ ಸಾಮಾನ್ಯ ಫ್ಲೇವರ್‌ಗಳಲ್ಲಿ ಅವುಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಬಳಸುವ ಆಜ್ಞೆಗಳನ್ನು ಸಹ ಒದಗಿಸುತ್ತದೆ.

ns-3 ವಿಕಿ ಪುಟ ಅಥವಾ ಮುಖ್ಯ ವೆಬ್‌ಸೈಟ್ ಅನ್ನು ಅನ್ವೇಷಿಸಲು ನೀವು ಈ ಅವಕಾಶದ ಲಾಭವನ್ನು ಪಡೆಯಬಹುದು: https://www.nsnam.org, ಏಕೆಂದರೆ ಅಲ್ಲಿ ಸಾಕಷ್ಟು ಮಾಹಿತಿ ಇದೆ. ns-3 (ns-3.29) ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯಿಂದ ಪ್ರಾರಂಭಿಸಿ, ns-3 ಅನ್ನು ಚಲಾಯಿಸಲು ಈ ಕೆಳಗಿನ ಉಪಕರಣಗಳು ಅಗತ್ಯವಿದೆ:

ಟೂಲ್ ಪ್ಯಾಕೇಜ್/ಆವೃತ್ತಿ

ಸಿ++ ಕಂಪೈಲರ್
ಕ್ಲಾಂಗ್++ ಅಥವಾ g++ (g++ ಆವೃತ್ತಿ 4.9 ಅಥವಾ ಹೆಚ್ಚಿನದು)
ಪೈಥಾನ್
python2 ಆವೃತ್ತಿ >= 2.7.10, ಅಥವಾ python3 ಆವೃತ್ತಿ >=3.4
ಹೋಗಿ
ಯಾವುದೇ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ (GitLab.com ನಲ್ಲಿ ns-3 ಅನ್ನು ಪ್ರವೇಶಿಸಲು)
ಟಾರ್
ಯಾವುದೇ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ (ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲು ns‑3 ಬಿಡುಗಡೆಗಾಗಿ)
ಬಂಜಿಪ್2
ಯಾವುದೇ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ (ns‑3 ಬಿಡುಗಡೆಯನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲು)

ಪೈಥಾನ್‌ನ ಡೀಫಾಲ್ಟ್ ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು, ಟೈಪ್ ಮಾಡಿ python -V. g++ ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು, ಟೈಪ್ ಮಾಡಿ g++ -v. ಯಾವುದೇ ಪರಿಕರಗಳು ಕಾಣೆಯಾಗಿದ್ದರೆ ಅಥವಾ ತುಂಬಾ ಹಳೆಯದಾಗಿದ್ದರೆ, ದಯವಿಟ್ಟು ns-3 ವಿಕಿ ಪುಟದಲ್ಲಿನ ಅನುಸ್ಥಾಪನಾ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ನೋಡಿ.

ಇಂದಿನಿಂದ, ಓದುಗರು Linux, MacOS, ಅಥವಾ Linux ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತಿದ್ದಾರೆ ಮತ್ತು ಕನಿಷ್ಠ ಮೇಲಿನ ಪರಿಕರಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.

3.2.1 ns-3 ಬಿಡುಗಡೆಯನ್ನು ಮೂಲ ಆರ್ಕೈವ್ ಆಗಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ns-3 ನ ಇತ್ತೀಚಿನ ಬಿಡುಗಡೆ ಮತ್ತು ಪ್ಯಾಕೇಜ್ ಆವೃತ್ತಿಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಪ್ರಯೋಗಿಸಲು ಬಯಸುವ ಹೊಸ ಬಳಕೆದಾರರಿಗೆ ಇದು ಕ್ರಮವಾಗಿದೆ. ns-3 ಬಿಡುಗಡೆಗಳನ್ನು ಸಂಕುಚಿತ ಮೂಲ ಆರ್ಕೈವ್‌ಗಳಾಗಿ ಪ್ರಕಟಿಸಲಾಗುತ್ತದೆ, ಇದನ್ನು ಕೆಲವೊಮ್ಮೆ ಕರೆಯಲಾಗುತ್ತದೆ ಟಾರ್ಬಾಲ್. ಟಾರ್ಬಾಲ್ ವಿಶೇಷ ಸಾಫ್ಟ್‌ವೇರ್ ಆರ್ಕೈವ್ ಸ್ವರೂಪವಾಗಿದೆ, ಇದರಲ್ಲಿ ಹಲವಾರು ಫೈಲ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ. ಆರ್ಕೈವ್ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಂಕುಚಿತಗೊಳಿಸಲಾಗುತ್ತದೆ. ns-3 ಮೂಲಕ ಬೂಟ್ ಪ್ರಕ್ರಿಯೆ ಟಾರ್ಬಾಲ್ ಸರಳವಾಗಿದೆ, ನೀವು ಬಿಡುಗಡೆಯನ್ನು ಆರಿಸಬೇಕಾಗುತ್ತದೆ, ಅದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಿ.

ನೀವು ಬಳಕೆದಾರರಾಗಿ, ಸ್ಥಳೀಯ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ns-3 ಅನ್ನು ನಿರ್ಮಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಭಾವಿಸೋಣ ಕಾರ್ಯಕ್ಷೇತ್ರ. ಕೆಳಗಿನವುಗಳನ್ನು Linux ಕನ್ಸೋಲ್‌ಗೆ ನಮೂದಿಸುವ ಮೂಲಕ ನೀವು ಬಿಡುಗಡೆಯ ಕೆಲಸದ ನಕಲನ್ನು ಪಡೆಯಬಹುದು (ಸಹಜವಾಗಿ ಸೂಕ್ತವಾದ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಗಳನ್ನು ಬದಲಿಸಿ)

$ 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 Git ಬಳಸಿಕೊಂಡು 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-ಅಲಿನೋನ್ ಹೆಚ್ಚುವರಿ ರೆಪೊಸಿಟರಿಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ ಎನ್ಎಸ್-3, ತಯಾರಿಸಲು, ಪೈಬಿಂಡ್ಜೆನ್ и ನೇತಾನಿಮ್.

ಹೇಳಿಕೆಯನ್ನು
ಕ್ಲೀನ್ ಉಬುಂಟು 16.04 ಹೊಂದಿರುವ ಯಂತ್ರದಲ್ಲಿ, ನಾನು ಇದಕ್ಕೆ ಆಜ್ಞೆಯನ್ನು ಬದಲಾಯಿಸಬೇಕಾಗಿದೆ: $ sudo python3 download.py -n ns-3.29 (ಇನ್ನು ಮುಂದೆ ಅನುವಾದಕರ ಟಿಪ್ಪಣಿಗಳು).

3.3.1 ಬೇಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ns-3 ಅನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಮೇಲಿನ ಎರಡು ವಿಧಾನಗಳು (ಮೂಲ ಆರ್ಕೈವ್ ಅಥವಾ ರೆಪೊಸಿಟರಿ ns-3-ಅಲಿನೋನ್ Git ಮೂಲಕ) ಬಹು ಆಡ್ಆನ್‌ಗಳೊಂದಿಗೆ ಸರಳವಾದ ns-3 ಸ್ಥಾಪನೆಯನ್ನು ಪಡೆಯಲು ಉಪಯುಕ್ತವಾಗಿದೆ(ಪೈಬಿಂಡ್ಜೆನ್ ಪೈಥಾನ್ ಬೈಂಡಿಂಗ್‌ಗಳನ್ನು ರಚಿಸಲು ಮತ್ತು ನೇತಾನಿಮ್ ನೆಟ್ವರ್ಕ್ ಅನಿಮೇಷನ್ಗಾಗಿ). ns-3-ಅಲಿನೋನ್‌ನಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಒದಗಿಸಲಾದ ಮೂರನೇ ರೆಪೊಸಿಟರಿಯನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ತಯಾರಿಸಲು.

ತಯಾರಿಸಲು ns-3 ಯೋಜನೆಗಾಗಿ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾದ ಬಹು ರೆಪೊಸಿಟರಿಗಳಿಂದ ಸಾಫ್ಟ್‌ವೇರ್‌ನ ಸಂಘಟಿತ ಕಟ್ಟಡಕ್ಕಾಗಿ ಒಂದು ಸಾಧನವಾಗಿದೆ. ತಯಾರಿಸಲು ns-3 ನ ಅಭಿವೃದ್ಧಿ ಆವೃತ್ತಿಗಳನ್ನು ಪಡೆಯಲು, ಹಾಗೆಯೇ ಪರಿಸರದಂತಹ ns-3 ವಿತರಣೆಯ ಮೂಲ ಆವೃತ್ತಿಯ ವಿಸ್ತರಣೆಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ಮಿಸಲು ಬಳಸಬಹುದು ನೇರ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್, CradleNetwork ಸಿಮ್ಯುಲೇಶನ್ ತೊಟ್ಟಿಲು, ಹೊಸ ಪೈಥಾನ್ ಬೈಂಡಿಂಗ್‌ಗಳು ಮತ್ತು ವಿವಿಧ ns-3 "ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು" ರಚಿಸುವ ಸಾಮರ್ಥ್ಯ.

ಹೇಳಿಕೆಯನ್ನು
CradleNetwork ಸಿಮ್ಯುಲೇಶನ್ ಕ್ರೇಡಲ್ ಒಂದು ಫ್ರೇಮ್ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ನೆಟ್‌ವರ್ಕ್ ಸಿಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ನಿಜವಾದ 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 ವಿತರಣೆಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ಮಿಸಲು ಈ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬಳಸುವುದು ಮುಂದಿನ ಹಂತವಾಗಿದೆ. ಹಲವಾರು ಗ್ರಾಹಕೀಕರಣ ಗುರಿಗಳು ಲಭ್ಯವಿದೆ:

ಎನ್ಎಸ್-3.29ಬಿಡುಗಡೆಗೆ ಅನುಗುಣವಾದ ಮಾಡ್ಯೂಲ್; ಇದು ಟಾರ್‌ಬಾಲ್‌ನಲ್ಲಿನ ಬಿಡುಗಡೆಯಂತೆಯೇ ಘಟಕಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ;
ns-3-dev: ಇದೇ ಮಾಡ್ಯೂಲ್, ಆದರೆ ಅಭಿವೃದ್ಧಿ ವೃಕ್ಷದಿಂದ ಕೋಡ್ ಅನ್ನು ಬಳಸುವುದು;
ಎನ್ಎಸ್-ಅಲಿನೋನ್-3.29: ಕ್ಲಿಕ್ ರೂಟಿಂಗ್ ಮತ್ತು ನೆಟ್‌ವರ್ಕ್ ಸಿಮ್ಯುಲೇಶನ್ ಕ್ರೇಡಲ್, ns-3 ಗಾಗಿ ಓಪನ್‌ಫ್ಲೋ ಮುಂತಾದ ಇತರ ಹೆಚ್ಚುವರಿ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಮಾಡ್ಯೂಲ್.
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 ಪರಿಸರ ವೇರಿಯಬಲ್), ಉದಾಹರಣೆಗೆ ಕೆಳಗಿನಂತೆ (Linux bash shell ಗೆ ಉದಾಹರಣೆ). "ಬೇಕ್" ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ನಂತರ ಈ ಕೆಳಗಿನ ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ಹೊಂದಿಸಿ:

$ 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-ಅಲಿನೋನ್ (ಹೆಚ್ಚುವರಿ ಪ್ಯಾಕೇಜುಗಳೊಂದಿಗೆ) ಸಂಪೂರ್ಣ ನಿರ್ಮಾಣಕ್ಕೆ ಸಾಮಾನ್ಯವಾಗಿ ಇದು ಅಗತ್ಯವಾಗಿರುತ್ತದೆ.

ನಿಮ್ಮ ಕೆಲಸದ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ ಮತ್ತು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನಮೂದಿಸಿ:

$ ./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 ...

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಮರ್ಕ್ಯುರಿಯಲ್, ಸಿವಿಎಸ್, ಜಿಟ್ ಮತ್ತು ಬಜಾರ್‌ನಂತಹ ಅಪ್‌ಲೋಡ್ ಪರಿಕರಗಳು ಈ ಹಂತದಲ್ಲಿ ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಅವುಗಳು ಕೋಡ್ ಪಡೆಯಲು ನಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಈ ಹಂತದಲ್ಲಿ, ಕಾಣೆಯಾದ ಪರಿಕರಗಳನ್ನು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ಸ್ಥಾಪಿಸಿ (ನೀವು ಹೇಗೆ ತಿಳಿದಿದ್ದರೆ) ಅಥವಾ ಸಹಾಯಕ್ಕಾಗಿ ನಿಮ್ಮ ಸಿಸ್ಟಮ್ ನಿರ್ವಾಹಕರನ್ನು ಸಂಪರ್ಕಿಸಿ.

ಮುಂದೆ, ಸಾಫ್ಟ್‌ವೇರ್ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ:

$ ./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 ಅಸೆಂಬ್ಲಿ ಎನ್ಎಸ್-3

ns-3 ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವಂತೆ, ns-3 ಅನ್ನು ನಿರ್ಮಿಸಲು ಹಲವಾರು ಮಾರ್ಗಗಳಿವೆ. ನಾವು ಒತ್ತಿಹೇಳಲು ಬಯಸುವ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ns-3 ಎಂಬ ಬಿಲ್ಡ್ ಟೂಲ್ ಅನ್ನು ಬಳಸಿ ನಿರ್ಮಿಸಲಾಗಿದೆ Wafಕೆಳಗೆ ವಿವರಿಸಲಾಗಿದೆ. ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ಕೆಲಸ ಮಾಡುತ್ತಾರೆ Waf, ಆದರೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ನಿರ್ಮಾಣಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಅಥವಾ ಸಂಘಟಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡಲು ಕೆಲವು ಸೂಕ್ತ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿವೆ. ಆದ್ದರಿಂದ ದಯವಿಟ್ಟು, ನೀವು ಓದುವ ಮೊದಲು Waf, ನೋಡೋಣ ಬಿಲ್ಡ್.ಪೈ ಮತ್ತು ಜೊತೆ ಜೋಡಣೆ ತಯಾರಿಸಲು.

3.4.1 build.py ಜೊತೆಗೆ ಕಟ್ಟಡ

ಎಚ್ಚರಿಕೆ ಈ ನಿರ್ಮಾಣ ಹಂತವು ಮೇಲೆ ವಿವರಿಸಿದಂತೆ ಪಡೆದ ಮೂಲ ಆರ್ಕೈವ್ ಆವೃತ್ತಿಯಿಂದ ಮಾತ್ರ ಲಭ್ಯವಿದೆ; ಮತ್ತು ಜಿಟ್ ಅಥವಾ ಬೇಕ್ ಮೂಲಕ ಡೌನ್‌ಲೋಡ್ ಮಾಡಲಾಗಿಲ್ಲ.

ಬಿಡುಗಡೆ ಆರ್ಕೈವ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಟಾರ್ಬಾಲ್, ಇನ್ ns-3-ಅಲಿನೋನ್ ಘಟಕಗಳನ್ನು ಸುಲಭವಾಗಿ ಜೋಡಿಸಲು ಸೂಕ್ತವಾದ ಸ್ಕ್ರಿಪ್ಟ್ ಇದೆ. ಇದನ್ನು build.py ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಈ ಪ್ರೋಗ್ರಾಂ ನಿಮಗಾಗಿ ಯೋಜನೆಯನ್ನು ಅತ್ಯಂತ ಉಪಯುಕ್ತ ರೀತಿಯಲ್ಲಿ ಹೊಂದಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ns-3 ನೊಂದಿಗೆ ಹೆಚ್ಚು ಸುಧಾರಿತ ಸೆಟಪ್ ಮತ್ತು ಕೆಲಸವು ಸಾಮಾನ್ಯವಾಗಿ ns-3 ನ ಸ್ವಂತ ನಿರ್ಮಾಣ ವ್ಯವಸ್ಥೆ, Waf ಅನ್ನು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಇದನ್ನು ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನಂತರ ಪರಿಚಯಿಸಲಾಗುವುದು.

ಬಳಸಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ್ದರೆ ಟಾರ್ಬಾಲ್, ನಂತರ ನಿಮ್ಮ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ~/ಕಾರ್ಯಸ್ಥಳ ಒಂದು ರೀತಿಯ ಹೆಸರಿನ ಡೈರೆಕ್ಟರಿ ಎನ್ಎಸ್-ಅಲಿನೋನ್-3.29. ಕೆಳಗಿನವುಗಳನ್ನು ನಮೂದಿಸಿ:

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

ಕರೆದಾಗ ಬಿಲ್ಡ್.ಪೈ ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ಬಳಸಲಾದ ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ನಾವು ಕಮಾಂಡ್ ಲೈನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಬಳಸಿದ್ದೇವೆ, ಇವುಗಳನ್ನು ns-3 ನಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿರ್ಮಿಸಲಾಗಿಲ್ಲ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸಹ ನಿರ್ಮಿಸುತ್ತದೆ. ನಂತರ, ನೀವು ಬಯಸಿದರೆ, ನೀವು ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳಿಲ್ಲದೆ ns-3 ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು ಅಥವಾ ನಿಮ್ಮ ಕೆಲಸಕ್ಕೆ ಅಗತ್ಯವಿಲ್ಲದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹೊರಗಿಡಬಹುದು.

ನೀವು ಲೋಡ್ ಮಾಡಿದ ವಿವಿಧ ಭಾಗಗಳನ್ನು ನಿರ್ಮಿಸುವುದರಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಪ್ರದರ್ಶಿಸಲಾದ ಬಹಳಷ್ಟು ಕಂಪೈಲರ್ ಔಟ್‌ಪುಟ್ ಸಂದೇಶಗಳನ್ನು ನೀವು ನೋಡುತ್ತೀರಿ. ಮೊದಲು ಸ್ಕ್ರಿಪ್ಟ್ ಆನಿಮೇಟರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ನೇತಾನಿಮ್, ನಂತರ ಬೈಂಡಿಂಗ್ ಜನರೇಟರ್ ಪೈಬಿಂಡ್ಜೆನ್ ಮತ್ತು ಅಂತಿಮವಾಗಿ 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 ವಾಫ್ನೊಂದಿಗೆ ನಿರ್ಮಿಸಿ

ಈ ಹಂತದವರೆಗೆ, ns-3 ಅನ್ನು ನಿರ್ಮಿಸಲು ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿದ್ದೇವೆ ಬಿಲ್ಡ್.ಪೈ, ಅಥವಾ ಉಪಕರಣ ತಯಾರಿಸಲು. ಈ ಉಪಕರಣಗಳು ns-3 ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಗ್ರಂಥಾಲಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಉಪಯುಕ್ತವಾಗಿವೆ. ವಾಸ್ತವವಾಗಿ, ನಿರ್ಮಿಸಲು ಅವರು ಬಿಲ್ಡ್ ಟೂಲ್ ಅನ್ನು ಚಲಾಯಿಸುತ್ತಾರೆ Waf ಡೈರೆಕ್ಟರಿ ns-3 ರಿಂದ. Waf ns-3 ಮೂಲ ಕೋಡ್‌ನೊಂದಿಗೆ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಮತ್ತು ಜೋಡಿಸಲು ನೇರವಾಗಿ ns‑3 ಅನ್ನು ಬಳಸುತ್ತಾರೆ Waf. ಆದ್ದರಿಂದ, ಮುಂದುವರಿಯಲು, ದಯವಿಟ್ಟು ನೀವು ಮೂಲತಃ ರಚಿಸಿದ ns-3 ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಿ.

ಈ ಸಮಯದಲ್ಲಿ ಇದು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಸ್ವಲ್ಪ ಹಿಮ್ಮೆಟ್ಟಿಸಲು ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್ ಕಾನ್ಫಿಗರೇಶನ್ಗೆ ಹೇಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಬೇಕೆಂದು ನೋಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ. ಕೋಡ್‌ನ ಆಪ್ಟಿಮೈಸ್ಡ್ ಆವೃತ್ತಿಯನ್ನು ರಚಿಸುವುದು ಬಹುಶಃ ನೀವು ಮಾಡಬಹುದಾದ ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾದ ಕಾನ್ಫಿಗರೇಶನ್ ಬದಲಾವಣೆಯಾಗಿದೆ. ಡೀಫಾಲ್ಟ್ ಆಗಿ, ಡೀಬಗ್ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಮಿಸಲು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ನೀವು ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೀರಿ. ಆಪ್ಟಿಮೈಸ್ಡ್ ಬಿಲ್ಡ್ ಅನ್ನು ರಚಿಸಲು ಯೋಜನೆಯನ್ನು ನೋಡೋಣ. ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಆಪ್ಟಿಮೈಸ್ಡ್ ಬಿಲ್ಡ್‌ಗಳನ್ನು ಮಾಡಬೇಕೆಂದು Waf ಗೆ ವಿವರಿಸಲು, ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಬೇಕಾಗುತ್ತದೆ:

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

ಇದು ಲಾಂಚ್ ಆಗುತ್ತದೆ Waf ಸ್ಥಳೀಯ ಡೈರೆಕ್ಟರಿಯ ಹೊರಗೆ (ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕಾಗಿ). ಮೊದಲ ಆಜ್ಞೆಯು ಹಿಂದಿನ ನಿರ್ಮಾಣದಿಂದ ಸ್ವಚ್ಛಗೊಳಿಸುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಇದು ಉತ್ತಮ ಅಭ್ಯಾಸವಾಗಿದೆ (ಕೆಳಗಿನ ಬಿಲ್ಡ್ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಸಹ ನೋಡಿ); ಇದು ಹಿಂದೆ ರಚಿಸಲಾದ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿರುವ ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಅಳಿಸುತ್ತದೆ ನಿರ್ಮಿಸಲು/. ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಮರುಸಂರಚಿಸಿದಾಗ ಮತ್ತು ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ವಿವಿಧ ಅವಲಂಬನೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿದಾಗ, ನೀವು ಈ ಕೆಳಗಿನ ರೀತಿಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡಬೇಕು:

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 ಹೊಂದಿಸಿ". ಇದನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ಆದ್ದರಿಂದ ಈ ವೈಶಿಷ್ಟ್ಯವು "ಸಕ್ರಿಯಗೊಳಿಸಲಾಗಿಲ್ಲ" ಎಂದು ಗೋಚರಿಸುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ಸಕ್ರಿಯಗೊಳಿಸಿದ ಆಯ್ಕೆಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು, ಬಳಸಿ Waf ನಿಯತಾಂಕದೊಂದಿಗೆ --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

ಮೇಲಿನ ಸನ್ನಿವೇಶ ಬಿಲ್ಡ್.ಪೈ ವಾದಗಳನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ --enable-examples и --enable-tests, ಆದರೆ ಇತರ ಆಯ್ಕೆಗಳು Waf ಇದು ನೇರವಾಗಿ ಬೆಂಬಲಿಸುವುದಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಇದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ:

$ ./build.py --disable-python

ಪ್ರತಿಕ್ರಿಯೆ ಈ ರೀತಿ ಇರುತ್ತದೆ:

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

ಆದಾಗ್ಯೂ, ವಿಶೇಷ ಆಪರೇಟರ್ - - ಮೂಲಕ ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸಲು ಬಳಸಬಹುದು ವೇಫ್ಆದ್ದರಿಂದ ಮೇಲಿನ ಆಜ್ಞೆಯ ಬದಲಿಗೆ ಕೆಳಗಿನ ಆಜ್ಞೆಯು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

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

ಏಕೆಂದರೆ ಇದು ಮುಖ್ಯ ಆಜ್ಞೆಯನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ ./waf ಕಾನ್ಫಿಗರ್ --disable-python. ಕುರಿತು ಇನ್ನೂ ಕೆಲವು ಪರಿಚಯಾತ್ಮಕ ಸಲಹೆಗಳು ಇಲ್ಲಿವೆ Waf.

ನಿರ್ಮಾಣ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಸಾಮಾನ್ಯ Linux ಮತ್ತು MacOS ವಿತರಣೆಗಳಲ್ಲಿ ಬಿಡುಗಡೆಯ ಸಮಯದಲ್ಲಿ ಲಭ್ಯವಿರುವ ಇತ್ತೀಚಿನ C++ ಕಂಪೈಲರ್‌ಗಳಲ್ಲಿ ns-3 ಬಿಡುಗಡೆಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಕಾಲಾನಂತರದಲ್ಲಿ, ಹೊಸ ಕಂಪೈಲರ್‌ಗಳೊಂದಿಗೆ ಹೊಸ ವಿತರಣೆಗಳು ಬಿಡುಗಡೆಯಾಗುತ್ತವೆ ಮತ್ತು ಈ ಹೊಸ ಕಂಪೈಲರ್‌ಗಳು ಎಚ್ಚರಿಕೆಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ನಿಷ್ಠುರವಾಗಿರುತ್ತವೆ. ns-3 ಎಲ್ಲಾ ಎಚ್ಚರಿಕೆಗಳನ್ನು ದೋಷಗಳಾಗಿ ಪರಿಗಣಿಸಲು ಅದರ ನಿರ್ಮಾಣವನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಕೆಲವೊಮ್ಮೆ ನೀವು ಹೊಸ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಹಳೆಯ ಆವೃತ್ತಿಯನ್ನು ಚಲಾಯಿಸುತ್ತಿದ್ದರೆ, ಕಂಪೈಲರ್ ಎಚ್ಚರಿಕೆಯು ನಿರ್ಮಾಣವನ್ನು ನಿಲ್ಲಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ಫೆಡೋರಾ 3.28 ಗಾಗಿ ಈ ಹಿಂದೆ ns‑28 ಬಿಡುಗಡೆಯಿತ್ತು, ಇದು ಹೊಸ ಪ್ರಮುಖ ಆವೃತ್ತಿಯನ್ನು ಒಳಗೊಂಡಿತ್ತು. gcc (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 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಬಿಡುಗಡೆಗಳಲ್ಲಿ, in Waf ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಒಂದು ಆಯ್ಕೆ ಲಭ್ಯವಿದೆ. ಇದು g++ ಮತ್ತು clang++ ನಲ್ಲಿ "-Werror" ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಹೊಂದಿಸುವುದನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಇದು "--disable-werror" ಆಯ್ಕೆಯಾಗಿದೆ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಸಮಯದಲ್ಲಿ ಅನ್ವಯಿಸಬೇಕು:

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

ಕಾನ್ಫಿಗರ್ ಮಾಡಿ ಅಥವಾ ಜೋಡಿಸಿ

ಕೆಲವು ಆಜ್ಞೆಗಳು Waf ಸಂರಚನಾ ಹಂತದಲ್ಲಿ ಮಾತ್ರ ಅರ್ಥವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು ಕೆಲವು ನಿರ್ಮಾಣ ಹಂತದಲ್ಲಿ ಮಾತ್ರ ಮಾನ್ಯವಾಗಿರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ns-3 ಎಮ್ಯುಲೇಶನ್ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ನೀವು ಬಿಟ್ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬಹುದು ಮೊಕದ್ದಮೆ ಹೂಡಿದೆ ಬಳಸಿ ಸುಡೊ, ಮೇಲೆ ವಿವರಿಸಿದಂತೆ. ಇದು ಸಂರಚನಾ ಹಂತದ ಆಜ್ಞೆಗಳನ್ನು ಅತಿಕ್ರಮಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಂರಚನೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು, ಇದು ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳನ್ನು ಸಹ ಒಳಗೊಂಡಿದೆ.

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

ನೀವು ಇದನ್ನು ಮಾಡಿದರೆ Waf ಪ್ರಾರಂಭಿಸಲಿದೆ ಸುಡೊಅನುಮತಿಗಳೊಂದಿಗೆ ರನ್ ಮಾಡಲು ಎಮ್ಯುಲೇಶನ್ ಕೋಡ್ ಸಾಕೆಟ್ ರಚನೆ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬೇರು. ದಿ Waf ಸಂರಚನಾ ಮತ್ತು ನಿರ್ಮಾಣ ಹಂತಗಳಿಗೆ ಹಲವು ಇತರ ಆಯ್ಕೆಗಳು ಲಭ್ಯವಿದೆ. ನಿಮ್ಮ ಆಯ್ಕೆಗಳನ್ನು ಅನ್ವೇಷಿಸಲು, ನಮೂದಿಸಿ:

$ ./waf --help

ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಕೆಲವು ಪರೀಕ್ಷೆ ಸಂಬಂಧಿತ ಆಯ್ಕೆಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.

ಅಸೆಂಬ್ಲಿ ಪ್ರೊಫೈಲ್‌ಗಳು

ನೀವು ಹೇಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಾವು ಈಗಾಗಲೇ ನೋಡಿದ್ದೇವೆ Waf ಅಸೆಂಬ್ಲಿಗಳಿಗಾಗಿ ಡಿಬಗ್ и ಹೊಂದುವಂತೆ:

$ ./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;)

ಡೀಫಾಲ್ಟ್, Waf ಬಿಲ್ಡ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಕಲಾಕೃತಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ಸ್ಥಳಗಳು. ಆಯ್ಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಬೇರೆ ಔಟ್‌ಪುಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು - -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
...

ಪ್ರತಿ ಬಾರಿಯೂ ಇತ್ತೀಚಿನ ಅಸೆಂಬ್ಲಿಯನ್ನು ಪುನಃ ಬರೆಯದೆಯೇ ಬಹು ಅಸೆಂಬ್ಲಿಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ನೀವು ಇನ್ನೊಂದು ಪ್ರೊಫೈಲ್‌ಗೆ ಬದಲಾಯಿಸಿದಾಗ, Waf ಎಲ್ಲವನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಮರುಸಂಕಲಿಸದೆ ಅದನ್ನು ಮಾತ್ರ ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ.

ನೀವು ಈ ರೀತಿಯಲ್ಲಿ ಬಿಲ್ಡ್ ಪ್ರೊಫೈಲ್‌ಗಳನ್ನು ಬದಲಾಯಿಸಿದಾಗ, ಪ್ರತಿ ಬಾರಿಯೂ ಅದೇ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳನ್ನು ನೀಡಲು ನೀವು ಜಾಗರೂಕರಾಗಿರಬೇಕು. ಹಲವಾರು ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ತಪ್ಪುಗಳನ್ನು ತಪ್ಪಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ:

$ 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

ಸಂಕಲನಕಾರರು ಮತ್ತು ಧ್ವಜಗಳು

ಮೇಲಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ Waf ns-3 ಅನ್ನು ನಿರ್ಮಿಸಲು GCC ನಿಂದ C++ ಕಂಪೈಲರ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ( g ++) ಆದಾಗ್ಯೂ, ನೀವು ಬಳಸುವ ಒಂದನ್ನು ನೀವು ಬದಲಾಯಿಸಬಹುದು Waf C++ ಕಂಪೈಲರ್, CXX ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಮೂಲಕ. ಉದಾಹರಣೆಗೆ, C++ ಕಂಪೈಲರ್ ಅನ್ನು ಬಳಸಲು ಕ್ಲಾಂಗ್, ಕ್ಲಾಂಗ್++,

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

ಅದೇ ರೀತಿಯಲ್ಲಿ ನೀವು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು Waf ಬಳಸಿ ವಿತರಿಸಿದ ಸಂಕಲನವನ್ನು ಬಳಸಲು 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/include. ಸೂಪರ್ಯೂಸರ್ ಹಕ್ಕುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಡೀಫಾಲ್ಟ್ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಒಂದು ವಿಶಿಷ್ಟವಾದ ಆಜ್ಞೆಯು ಇರುತ್ತದೆ sudo ./waf ಸ್ಥಾಪನೆ. ಪ್ರಾರಂಭಿಸಿದಾಗ, Waf ಮೊದಲು ಬಿಲ್ಡ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಹಂಚಿದ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಲು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ, ನಂತರ ಸ್ಥಳೀಯ ಪರಿಸರದಲ್ಲಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಲೈಬ್ರರಿಗಳ ಹಾದಿಯಲ್ಲಿ ಲೈಬ್ರರಿಗಳನ್ನು ಹುಡುಕುತ್ತದೆ. ಹಾಗಾಗಿ ಲೈಬ್ರರಿಗಳನ್ನು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸುವಾಗ, ಸರಿಯಾದ ಲೈಬ್ರರಿಗಳನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವುದು ಉತ್ತಮ ಅಭ್ಯಾಸ. ಕಾನ್ಫಿಗರೇಶನ್ ಸಮಯದಲ್ಲಿ ಆಯ್ಕೆಯನ್ನು ರವಾನಿಸುವ ಮೂಲಕ ಬಳಕೆದಾರರು ಬೇರೆ ಪೂರ್ವಪ್ರತ್ಯಯದೊಂದಿಗೆ ಸ್ಥಾಪಿಸಲು ಆಯ್ಕೆ ಮಾಡಬಹುದು --prefix, ಉದಾಹರಣೆಗೆ:

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

ನಂತರ, ನಿರ್ಮಾಣದ ನಂತರ, ಬಳಕೆದಾರರು ಅನುಸ್ಥಾಪನಾ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸುತ್ತಾರೆ ./waf, ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ /ಆಯ್ಕೆ/ಸ್ಥಳೀಯ.

ತಂಡದ ./waf clean ಅನುಸ್ಥಾಪನೆಯು ಬಳಸಿದರೆ ಯೋಜನೆಯನ್ನು ಮರುಸಂರಚಿಸುವ ಮೊದಲು ಬಳಸಬೇಕು Waf ಬೇರೆ ಪೂರ್ವಪ್ರತ್ಯಯದ ಅಡಿಯಲ್ಲಿ.

ಹೀಗಾಗಿ, ns-3 ಅನ್ನು ಬಳಸಲು ಕರೆ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ ./waf install. ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರಿಗೆ ಈ ಆಜ್ಞೆಯ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ಏಕೆಂದರೆ Waf ಬಿಲ್ಡ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ಪ್ರಸ್ತುತ ಲೈಬ್ರರಿಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಬಳಕೆದಾರರು ತಮ್ಮ ಚಟುವಟಿಕೆಗಳು ns-3 ಡೈರೆಕ್ಟರಿಯ ಹೊರಗಿನ ಪ್ರೋಗ್ರಾಂಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿದ್ದರೆ ಇದು ಉಪಯುಕ್ತವಾಗಬಹುದು.

ವಾಫ್ ಸಿಂಗಲ್

ns-3 ಮೂಲ ಮರದ ಮೇಲಿನ ಹಂತದಲ್ಲಿ, ಕೇವಲ ಒಂದು Waf ಸ್ಕ್ರಿಪ್ಟ್ ಇದೆ. ಒಮ್ಮೆ ನೀವು ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿದರೆ, ನೀವು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಕಳೆಯುತ್ತೀರಿ scratch/ ಅಥವಾ ಆಳವಾಗಿsrc/... ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ ಓಡಬೇಕು Waf. ನೀವು ಎಲ್ಲಿದ್ದೀರಿ ಎಂದು ನೀವು ನೆನಪಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಓಡಬಹುದು Waf ಕೆಳಗಿನಂತೆ:

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

ಆದರೆ ಇದು ಬೇಸರದ ಮತ್ತು ದೋಷ ಪೀಡಿತವಾಗಿರುತ್ತದೆ, ಆದ್ದರಿಂದ ಉತ್ತಮ ಪರಿಹಾರಗಳಿವೆ. ಪಠ್ಯ ಸಂಪಾದಕವನ್ನು ಬಳಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ಮಾರ್ಗವಾಗಿದೆ ಎಮ್ಯಾಕ್ಸ್ ಅಥವಾ ವಿಮ್, ಇದರಲ್ಲಿ ಎರಡು ಟರ್ಮಿನಲ್ ಸೆಷನ್‌ಗಳನ್ನು ತೆರೆಯಲಾಗುತ್ತದೆ, ಒಂದನ್ನು 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

ಈ ಪರೀಕ್ಷೆಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ನಡೆಸಲಾಗುತ್ತದೆ Waf. ಅಂತಿಮವಾಗಿ ನೀವು ಹೇಳುವ ಸಂದೇಶವನ್ನು ನೋಡಬೇಕು:

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

ವಾಲ್‌ಗ್ರೈಂಡ್ ಕ್ರ್ಯಾಶ್‌ಗಳು, ಕ್ರ್ಯಾಶ್‌ಗಳು ಅಥವಾ ದೋಷಗಳನ್ನು ಗುರುತಿಸಲು ಇದು ಪ್ರಮುಖ ಸಂದೇಶವಾಗಿದೆ, ಇದು ಕೋಡ್‌ನೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಅಥವಾ ಪರಿಕರಗಳು ಮತ್ತು ಕೋಡ್ ನಡುವಿನ ಅಸಾಮರಸ್ಯತೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ನೀವು ಅಂತಿಮ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸಹ ನೋಡುತ್ತೀರಿ Waf ಮತ್ತು ಪ್ರತಿ ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸುತ್ತಿರುವ ಪರೀಕ್ಷಕ, ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

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: ..." ಸಾಲುಗಳ ಕ್ರಮವು ವಿಭಿನ್ನವಾಗಿರಬಹುದು ಎಂಬುದನ್ನು ಗಮನಿಸಿ, ಇದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಮುಖ್ಯವಾದ ವಿಷಯವೆಂದರೆ ವರದಿಯ ಕೊನೆಯಲ್ಲಿ ಸಾರಾಂಶದ ಸಾಲು ಎಲ್ಲಾ ಪರೀಕ್ಷೆಗಳು ಉತ್ತೀರ್ಣವಾಗಿದೆ ಎಂದು ತೋರಿಸುತ್ತದೆ; ಯಾವುದೇ ಪರೀಕ್ಷೆಗಳು ವಿಫಲವಾಗಿಲ್ಲ ಅಥವಾ ಕ್ರ್ಯಾಶ್ ಆಗಿಲ್ಲ.) ಮತ್ತು Wafಮತ್ತು test.py ಯಂತ್ರದ ಲಭ್ಯವಿರುವ ಪ್ರೊಸೆಸರ್ ಕೋರ್‌ಗಳಾದ್ಯಂತ ಕೆಲಸವನ್ನು ಸಮಾನಾಂತರಗೊಳಿಸುತ್ತದೆ.

3.6 ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು

ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ನಿಯಂತ್ರಣದಲ್ಲಿ ನಡೆಸುತ್ತೇವೆ Waf. ಹಂಚಿದ ಲೈಬ್ರರಿ ಮಾರ್ಗಗಳನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಲೈಬ್ರರಿಗಳು ಲಭ್ಯವಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು, ಸರಳವಾಗಿ ಬಳಸಿ Waf ನಿಯತಾಂಕದೊಂದಿಗೆ - -run. ಸರ್ವತ್ರ ಪ್ರೋಗ್ರಾಂನ ns-3 ಸಮಾನವನ್ನು ರನ್ ಮಾಡೋಣ ಹಲೋ ವರ್ಲ್ಡ್ಕೆಳಗಿನವುಗಳನ್ನು ಟೈಪ್ ಮಾಡುವ ಮೂಲಕ:

$ ./waf --run hello-simulator

ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸರಿಯಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆಯೇ ಎಂದು ವಾಫ್ ಮೊದಲು ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿದ್ದರೆ ನಿರ್ಮಿಸುತ್ತದೆ. ನಂತರ Waf ಕೆಳಗಿನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

Hello Simulator

ಅಭಿನಂದನೆಗಳು! ನೀವು ಈಗ ns-3 ಬಳಕೆದಾರರಾಗಿದ್ದೀರಿ!

ನಾನು ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡದಿದ್ದರೆ ನಾನು ಏನು ಮಾಡಬೇಕು?

ನೀವು ಸಂದೇಶಗಳನ್ನು ನೋಡಿದರೆ Wafನಿರ್ಮಾಣವು ಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ, ಆದರೆ ನೀವು ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡುವುದಿಲ್ಲ "ಹಲೋ ಸಿಮ್ಯುಲೇಟರ್", ನಂತರ [ಬಿಲ್ಡ್-ವಿತ್-ವೇಫ್] ವಿಭಾಗದಲ್ಲಿ ನಿಮ್ಮ ಬಿಲ್ಡ್ ಮೋಡ್ ಅನ್ನು ನೀವು ಬದಲಾಯಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ ಹೊಂದುವಂತೆ, ಆದರೆ ಮೋಡ್‌ಗೆ ಹಿಂತಿರುಗುವುದು ತಪ್ಪಿಹೋಗಿದೆ ಡಿಬಗ್. ಈ ಟ್ಯುಟೋರಿಯಲ್‌ನಲ್ಲಿ ಬಳಸಲಾದ ಎಲ್ಲಾ ಕನ್ಸೋಲ್ ಔಟ್‌ಪುಟ್ ವಿಶೇಷ ns-3 ಘಟಕವನ್ನು ಬಳಸುತ್ತದೆ ಅದು ಲಾಗಿಂಗ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಕನ್ಸೋಲ್‌ಗೆ ಕಸ್ಟಮ್ ಸಂದೇಶಗಳನ್ನು ಮುದ್ರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಆಪ್ಟಿಮೈಸ್ಡ್ ಕೋಡ್ ಕಂಪೈಲ್ ಮಾಡಿದಾಗ ಈ ಘಟಕದಿಂದ ಔಟ್‌ಪುಟ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿಷ್ಕ್ರಿಯಗೊಳ್ಳುತ್ತದೆ - ಇದು "ಆಪ್ಟಿಮೈಸ್ಡ್" ಆಗಿದೆ. ನೀವು "ಹಲೋ ಸಿಮ್ಯುಲೇಟರ್" ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡದಿದ್ದರೆ, ಈ ಕೆಳಗಿನವುಗಳನ್ನು ನಮೂದಿಸಿ:

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

ಕಾನ್ಫಿಗರ್ ಮಾಡಲು Waf ಉದಾಹರಣೆಗಳು ಮತ್ತು ಪರೀಕ್ಷೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ns-3 ಕಾರ್ಯಕ್ರಮಗಳ ಡೀಬಗ್ ಆವೃತ್ತಿಗಳನ್ನು ನಿರ್ಮಿಸಲು. ನಂತರ ನೀವು ಟೈಪ್ ಮಾಡುವ ಮೂಲಕ ಕೋಡ್‌ನ ಪ್ರಸ್ತುತ ಡೀಬಗ್ ಆವೃತ್ತಿಯನ್ನು ಮರುನಿರ್ಮಾಣ ಮಾಡಬೇಕು

$ ./waf

ಈಗ ನೀವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ ಹಲೋ-ಸಿಮ್ಯುಲೇಟರ್, ನೀವು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶವನ್ನು ನೋಡಬೇಕು.

3.6.1 ಕಮಾಂಡ್ ಲೈನ್ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು

ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ns-3 ಪ್ರೋಗ್ರಾಂಗೆ ರವಾನಿಸಲು, ಈ ಕೆಳಗಿನ ಮಾದರಿಯನ್ನು ಬಳಸಿ:

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

ಬದಲಾಯಿಸಿ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರಿಗೆ ಮತ್ತು ವಾದಗಳಿಗೆ. ವಾದ - -command-template ಗೆ Waf ಮೂಲಭೂತವಾಗಿ ನಿಜವಾದ ಕಮಾಂಡ್ ಲೈನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಒಂದು ಪಾಕವಿಧಾನವಾಗಿದೆ Waf ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ನಿರ್ಮಾಣವು ಪೂರ್ಣಗೊಂಡಿದೆಯೇ ಎಂದು Waf ಪರಿಶೀಲಿಸುತ್ತದೆ, ಹಂಚಿದ ಲೈಬ್ರರಿ ಮಾರ್ಗಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ನಂತರ ಒದಗಿಸಿದ ಕಮಾಂಡ್ ಲೈನ್ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದದನ್ನು ಕರೆಯಲು %s ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್‌ಗೆ ಪ್ರೋಗ್ರಾಂ ಹೆಸರನ್ನು ಬದಲಿಸುತ್ತದೆ. ಈ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸಂಕೀರ್ಣವಾಗಿದೆ ಎಂದು ನೀವು ಕಂಡುಕೊಂಡರೆ, ns-3 ಪ್ರೋಗ್ರಾಂ ಮತ್ತು ಅದರ ವಾದಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಸರಳವಾದ ಆವೃತ್ತಿಯು ಏಕ ಉಲ್ಲೇಖಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಲ್ಪಟ್ಟಿದೆ:

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

ಮತ್ತೊಂದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತ ಉದಾಹರಣೆಯೆಂದರೆ ಪರೀಕ್ಷಾ ಸೂಟ್‌ಗಳನ್ನು ಆಯ್ದವಾಗಿ ಚಾಲನೆ ಮಾಡುವುದು. mytest ಎಂಬ ಪರೀಕ್ಷಾ ಸೂಟ್ ಇದೆ ಎಂದು ಭಾವಿಸೋಣ (ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ). ಮೇಲೆ ನಾವು ./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 ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು (ಉದಾಹರಣೆಗೆ, ಜಿಡಿಬಿ) ಅಥವಾ ಮೆಮೊರಿ ಪರೀಕ್ಷಾ ಸಾಧನ (ಉದಾಹರಣೆಗೆ, ವಾಲ್ಗ್ರಿಂಡ್), ಇದೇ ರೂಪವನ್ನು ಬಳಸಿ - -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 ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿ

ವಾಫ್ ಅನ್ನು ns-3 ಮರದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಅದರ ಸ್ಥಳದಿಂದ ಪ್ರಾರಂಭಿಸಬೇಕು. ಈ ಫೋಲ್ಡರ್ ಔಟ್‌ಪುಟ್ ಫೈಲ್‌ಗಳನ್ನು ಬರೆಯುವ ಕೆಲಸದ ಡೈರೆಕ್ಟರಿಯಾಗುತ್ತದೆ. ಆದರೆ ನೀವು ಈ ಫೈಲ್‌ಗಳನ್ನು ns-3 ಮೂಲ ಮರದ ಹೊರಗೆ ಇರಿಸಲು ಬಯಸಿದರೆ ಏನು ಮಾಡಬೇಕು? ವಾದವನ್ನು ಬಳಸಿ - -cwd:

$ ./waf --cwd=...

ನಿಮ್ಮ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಫೈಲ್‌ಗಳನ್ನು ಪಡೆಯಲು ನಿಮಗೆ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕೆಳಗಿನ ಪರೋಕ್ಷ ಕ್ರಿಯೆಯು ಸಹಾಯ ಮಾಡುತ್ತದೆ:

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

ಆಜ್ಞೆಯ ಹಿಂದಿನ ಆವೃತ್ತಿಯ ಈ ಅಲಂಕಾರವು ಪ್ರಸ್ತುತ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸಂರಕ್ಷಿಸುತ್ತದೆ, ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗುತ್ತದೆ Wafತದನಂತರ ಸೂಚನೆ ನೀಡುತ್ತದೆ Waf ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಉಳಿಸಿದ ಪ್ರಸ್ತುತ ಕಾರ್ಯ ಡೈರೆಕ್ಟರಿಗೆ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಬದಲಾಯಿಸಲು. ನಾವು ತಂಡವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತೇವೆ - -cwd ಸಂಪೂರ್ಣತೆಗಾಗಿ, ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ಕೇವಲ ಉನ್ನತ ಮಟ್ಟದ ಡೈರೆಕ್ಟರಿಯಿಂದ Waf ಅನ್ನು ರನ್ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಅಲ್ಲಿ ಔಟ್‌ಪುಟ್ ಫೈಲ್‌ಗಳನ್ನು ರಚಿಸುತ್ತಾರೆ.

ಮುಂದುವರಿದಿದೆ: ಅಧ್ಯಾಯ 4

ಮೂಲ: www.habr.com

ns-3 ನೆಟ್ವರ್ಕ್ ಸಿಮ್ಯುಲೇಟರ್ ಟ್ಯುಟೋರಿಯಲ್. ಅಧ್ಯಾಯ 3