Ngon Ngu Otcl Trong Ns2

Cơ sở mạng thông tin – K4X

MỤC LỤC

Phần I ................................................................................................................................................ 4 Chương trình mô phỏng mạng .......................................................................................................... 4 Network Simulator (NS-2) ............................................................................................................... 4

1/ :Tại sao phải cần chương trình mô phỏng mạng : ............................................................... 4 2.Phần mềm mô phỏng mạng Network Simulator : (NS) ....................................................... 5 2.1. Tổng quan về NS : ............................................................................................................. 5 2.2. Làm việc với NS : .............................................................................................................. 8 Ngôn ngữ Otcl : ....................................................................................................................... 8 Khái niệm tổng quan : .............................................................................................................. 9 Lớp Tcl ...................................................................................................................................... 9 Yêu cầu các thủ tục OTcl .......................................................................................................... 9 Truyền kết quả tới/từ trình thông dịch .................................................................................... 10 Lớp TclObject ......................................................................................................................... 10 Tạo và xoá đối tượng TclObject ............................................................................................. 10 Liên kết biến ........................................................................................................................... 11 Các phương thức command: định nghĩa và gọi ...................................................................... 11 2.3 Các mô phỏng cơ sở ......................................................................................................... 12 2.3.1 Lớp mô phỏng (class Simulator) ................................................................................... 12 2.3.2 Node và truyền tải gói tin (packet forwarding) ............................................................. 13 2.3.3 Các liên kết : ................................................................................................................. 19 2.3.4 Quản lý queue và lập lịch gói ........................................................................................ 21

Phần II.Công cụ hình ảnh hoá mô phỏng : NAM ........................................................................... 31 1.Giới thiệu chung về NAM : ................................................................................................ 31 1.1. Tổng quan ........................................................................................................................ 31 1.2.Các lựa chọn dòng lệnh của NAM: .................................................................................. 33 1.3. Giao diện người sử dụng: ................................................................................................ 33 1.3. Các câu lệnh bàn phím: ................................................................................................... 35 1.4. Tạo ra các hoạt động bên ngoài từ Nam : ........................................................................ 35 1.5. Network Layout: .............................................................................................................. 36 1.6. Các đối tượng hoạt động: ................................................................................................. 36 2. NAM TRACE ................................................................................................................... 37 2.1.Định dạng Nam Trace: ...................................................................................................... 37 2.2. Các sự kiện khởi tạo: ....................................................................................................... 38 2.3. Nodes: .............................................................................................................................. 39 2.4. Links : ............................................................................................................................. 39 2.5. Queues: ............................................................................................................................ 40 2.6. Các gói tin: (Packets) ....................................................................................................... 40 2.7. Đánh dấu Node : .............................................................................................................. 41 2.8. Tìm vết Agent: (Agent Tracing ) ..................................................................................... 41 2.9. Tìm vết biến (Variable Tracing): ...................................................................................... 41

Phần III : Các bài toán mô phỏng ................................................................................................... 42 1. Mô phỏng các gói tin UDP/TCP ...................................................................................... 42 1.1 UDP Agent ........................................................................................................................ 42

Cyber Pro !!! :)) 1


1.2. TCP Agents ...................................................................................................................... 43 2.Unicast Routing .................................................................................................................. 50 2.1 The Interface to the Simulation Operator (The API) ........................................................ 50 2.2 Các cơ chế cấu hình khác cho Specialised Routing .......................................................... 52 2.3 Các tham số cấu hình đặc tả giao thức ............................................................................. 52 2.4 Đặc tính và kiến trúc của Routing .................................................................................... 53 2.5 Protocol Internals .............................................................................................................. 57 2.6 Các đối tượng Unicast routing ......................................................................................... 58 2.7 Tỏng quan các lệnh ........................................................................................................... 58 3.Multicast Routing ............................................................................................................... 59 3.1 Multicast API .................................................................................................................... 59 3.2 Internals of Multicast Routing .......................................................................................... 62

Bảng tra cứu định dạng File Nam trace: ......................................................................................... 68

Lời mở đầu

Cyber Pro !!! :)) 2


Trong những năm gần đây mạng máy tính phát triển ngày càng mạnh mẽ tạo

nên một bước ngoặt quan trọng trong công nghệ thông tin. Mạng máy tính ngày

nay có mặt trong rất nhiều các hoạt động trong đời sống. Các công nghệ, các kỹ

thuật phục vụ cho môi trường mạng đã được xây dựng nhiều, và đang còn được

tiếp tục phát triển, cải tiến.

Muốn có một mạng thật để thử nghiệm các công nghệ mới thì thật tốn kém,

không phải cá nhân, tổ chức nào cũng có thể đáp ứng được.Hơn nữa các mạng cục

bộ này không những phải đảm bảo các tính năng của một mạng thông thường mà

còn phải thực hiện được những bài toán thử nghiệm cũng như giúp cho sinh viên

thấy được tính khả thi của chúng đối với các bài toán mới.Cách tốt nhất để giải

quyết những yêu cầu đặt ra đó là dùng một môi trường mạng ảo để xây dựng và thử

nghiệm các công nghệ mới. Giả lập mạng (network simulator) ra đời với mục đích

đó,trong đó tiêu biểu là chương trình NS, có thể dùng để thực hiện các kịch bản

mạng như áp dụng các mô hình UDP/TCP, các bài toán routing vào các tôpô thích

hợp.

Do đó đề tài thực tập tốt nghiệp của chúng em là : “Nghiên cứu chương trình

mô phỏng mạng NS và các công cụ hỗ trợ, và cơ sở để áp dụng các bài toán ứng

dụng trên NS để đánh giá tính khả thi và tối ưu của chúng trên mạng”.

Chúng em xin chân thành cảm ơn thầy giáo TS.Đặng Văn Chuyết, TS

Nguyễn Linh Giang và thầy Tạ Hải Tùng đã tận tình hướng dẫn chúng em định

hướng, thực hiện đề tài này .

Cyber Pro !!! :)) 3


Phần IChương trình mô phỏng mạng

Network Simulator (NS-2)

1/ :Tại sao phải cần chương trình mô phỏng mạng :Tốc độ phát triển của Internet đang phát triển rất nhanh , sự ra đời của các giao thức mới

và các thuật toán để phục vụ các đòi hỏi về bảo mật ,truyền thông đa phương tiện, mạng di động ,các chính sách quản lý và sự hõ trợ của chất lượng dịch vụ (QoS) . Lý thuyết và ước lượng của các công cụ này đòi hỏi phải trả lời rất nhiều các câu hỏi .

Bỏ qua những giá trị của chúng , các mô phỏng thông dụng, các thí điểm qui mô lớn và các các đánh giá thí nghiệm qui mô nhỏ đều có mặt hạn chế của nó .Bởi vì sử dụng các mã thực(real code) nên các cuộc thí nghiệm thực hiện trong các khu thí điểm hay các phòng thí nghiệm tự động nắm bắt các nội dung ,chi tiết quan trọng có khi đã bị bỏ qua trong khi mô phỏng . Tuy nhiên để xây dựng các khu thí điểm hay các phòng thí nghiệm quả thật rất tốn kém , tái cơ cấu và phân bổ chúng rất khó . Chúng cũng không được linh động lắm .Hơn nữa , việc mô phỏng một vài hiện tượng của hoạt động mạng như nhiễu sóng vô tuyến có thể rất khó khăn , phức tạp trong việc so sánh hay ước lượng các mô hình giao thức .

Thiết kế giao thức bằng mô phỏng thường bắt đầu với các mô phỏng các chi tiết riêng lẻ của giao thức của một nhà nghiên cứu độc lập thông qua các Topology cỡ nhỏ và các giả định đơn giản thường là ở dạng tĩnh . Các chi phí ban đầu cao đã ngăn cản một nhóm độc lập có được các điều kiện cần thiết để tạo ra một môi trường mô phỏng mạng hoàn thiện .Chính khó khăn này là nguyên nhân dẫn đến các mô phỏng được xây dựng bởi các nhóm khác nhau không có được chất lượng như mong muốn .

Công trình nghiên cứu về thí điểm mạng ảo ( Virtual Internerwork Testbed _ VINT) đã cung cấp các công cụ mô phỏng tiên tiến cho các nhà nghiên cứu mạng sử dụng để thiết kế và triển khai các giao thức Internet trên diện rộng . Công cụ tiêu biểu của VINT là : NS ( Network Simulator ).

VINT cung cấp các điều kiện thực hành tiên tiến giúp mở rộng điều kiện cho các nhà nghiên cứu trong việc ước lượng các giao thức :

1. Tính trừu tượng : Sự thay đổi trong việc mô phỏng dạng hạt cho phép các một mô phỏng đơn có thể điều chỉnh khớp các chi tiết và các mô phỏng ở mức cao . Các nhà nghiên cứu nghiên cứu giao thức mạng tại nhiều mức . Trải rộng từ các phần riêng biệt của một giao thức độc lập đến sự tập hợp của các luồng đa dữ liệu và sự tương tác giữa các giao thức với nhau . Các cơ chế trừu tượng hoá trong NS cho phép các nhà nghiên cứu kiểm tra được các giao thức mà không cần có sự thay đổi trong mô phỏng và công nhận kết sự trừu tượng hoá thông qua việc so sánh nhiều chi tiết và trừu tượng hoá các kết quả .

2. Tính mô phỏng : Hầu hết những thí nghiệm mô phỏng đều bị giới hạn trong một thế giới mô phỏng nên chỉ có sự xuất hiện của các giao thức và các thuật toán trong chương trình mô phỏng . Trái ngược với điều này , sự mô phỏng ở đây cho phép chạy chương trình mô phỏng có sự tương tác giữa các nốt mạng với nhau .

3. Thực hiện các kịch bản : Việc kiểm tra các giao thức dưới các điều kiện mạng thích hợp là vấn đề then chốt để giành được kết quả tốt . Chương trình sẽ tự động tạo ra các mẫu lưu thông phức tạp , các Topology và các sự kiện động có thể giúp tạo ra các kịch bản .

Cyber Pro !!! :)) 4


4. Tính trực quan : Các nhà nghiên cứu cần các công cụ có thể giúp họ hiểu được các hoạt động phức tạp trong mạng . Tính trực quan sử dụng công cụ có hoạt ảnh : Nam cung cấp một sự thể hiện động cho phép các nhà nghiên cứu phát triển tốt hơn khả năng trực giác đối với các giao thức và giúp cho việc dò sửa lỗi trong các giao thức

5. Khả năng mở rộng : Chương trình mô phỏng phải dễ mở rộng nếu nó cần thiết phải thêm vào các tác vụ cần thiết .

2.Phần mềm mô phỏng mạng Network Simulator : (NS)

2.1. Tổng quan về NS :NS là hệ thống mô phỏng mạng, đặc biệt là các giao thức điều khiển hoạt động của mạng,

phát triển tại đại học Berkeley và viện công nghệ thông tin ISI (Information Science Institute), có khả năng mô phỏng nhiều kiểu mạng IP khác nhau. Nó mô phỏng việc thực hiện các giao thức mạng như TCP, UDP, các nguồn dữ liệu FTP, Telnet, Web, CBR và VBR, có cơ chế quản lí hàng đợi router như DropTail, RED và CBR, với các giải thuật chọn đường như Dijkstra… ns cũng bổ xung phần multicasting với một số giao thức tầng MAC để hỗ trợ việc mô phỏng mạng LAN. Phiên bản hiện nay của ns (ver 2) được viết bằng C++ và Otcl (Otcl: là mở rộng của ngôn ngữ Tcl có thêm phần hướng đối tượng, tương tự như C và C++). Dưới góc độ người dùng, một hệ thống mô phỏng có sơ đồ như sau:

Sơ đồ 1: Mô hình ns đơn giản

Từ mô hình có thể thấy, ns sử dụng ngôn ngữ Otcl với thư viện bao gồm các đối tượng Event Scheduler, các đối tượng Network Component, và các module Plumbing giúp cho việc cài đặt mạng. Nói cách khác, để sử dụng ns, ta phải lập trình trên ngôn ngữ Otcl. Để cài đặt và chạy chương trình mô phỏng mạng bằng ns, ta phải viết script trên ngôn ngữ Otcl, lập lịch cho các sự kiện, thiết lập cấu hình mạng (topo mạng) bằng cách sử dụng các đối tượng Network Component, triệu gọi các hàm thư viện, báo cho các nguồn dữ liệu biết khi nào thì bắt đầu và kết thúc việc truyền gói tin trên mạng. Khi muốn tạo một đối tượng mạng mới, có thể viết mới một đối tượng hoặc bằng cách liên kết các đối tượng mạng đã có sẵn trong thư viện. Việc gắn kết đối tượng tạo nên đối tượng mới chính là điểm mạnh của ns.

Một bộ phận quan trọng khác của ns bên cạnh network object là event scheduler. Một sự kiện trong ns là một ID của gói tin được lên lịch và một con trỏ trỏ tới đối tượng xử lí sự kiện đó. Một event scheduler theo dõi lịch của tất cả các sự kiện và triệu gọi đối tượng thực hiện sự kiện đó vào thời điểm thích hợp. Các đối tượng trong mạng trao đổi thông tin với nhau bằng cách gửi

Cyber Pro !!! :)) 5


và nhận các gói tin. Với mỗi gói tin, các đối tượng đều phải mất một khoảng thời gian để xử lí gói tin (độ trễ), các đối tựơng tạo độ trễ bằng cách sử dụng event scheduler. Một dạng thể hiện khác của event scheduler là timer. Ví dụ TCP cần timer để theo dõi việc truyền gói tin nhằm phục vụ cho việc truyền lại trong trường hợp mất gói tin (gói tin gửi lại vẫn có cùng số hiệu với gói tin trước nhưng sẽ khác ở ns packet ID). Timer đo thời gian gắn với gói tin và thực hiện hành động liên quan tới gói tin khi đến thời điểm thích hợp, và không mô phỏng độ trễ.

ns sử dụng cả ngôn ngữ C++ và ngôn ngữ Otcl. Ns hỗ trợ cấu trúc lớp kiểu phân cấp trong C++ (được gọi là cấu trúc lớp biên dịch), và một cấu trúc lớp tương tự trong ngôn ngữ Otcl (gọi là cấu trúc lớp thông dịch). Hai cấu trúc lớp phân cấp này có quan hệ chặt chẽ với nhau, dưới góc độ người sử dụng (không phải người lập trình phát triển ns), có tương ứng 1-1 giữa lớp trong cấu trúc lớp biên dịch và lớp trong cấu trúc lớp thông dịch Sơ đồ sau là ví dụ về sự phân cấp trong C++ và Otcl.

Sơ đồ 2: Tương ứng C++ và OtclLý do để ns sử dụng hai ngôn ngữ lập trình là do hệ mô phỏng phải thực hiện hai dạng

yêu cầu xử lý khác nhau. Một mặt, việc mô phỏng chi tiết các giao thức đòi hỏi một ngôn ngữ lập trình hệ thống có khả năng thao tác hiệu quả với các byte, packet header, và thực hiện những giải thuật với tập dữ liệu lớn. Với những công việc dạng này, tốc độ của thực hiện khi chạy rất quan trọng, và thời gian xử lý quay vòng (chạy mô phỏng, tìm lỗi, gỡ lỗi, dịch lại, chạy lại) kém quan trọng hơn. Mặt khác, khi nghiên cứu mạng, rất cần nhanh chóng thay đổi tham số hay cấu hình, hoặc đưa ra nhiều kịch bản hoạt động khác nhau. Trong những trường hợp như vậy, thời gian quay vòng (thay đổi mô hình và chạy lại) quan trọng hơn thời gian cấu hình ban đầu và thời gian chạy. ns thoả mãn cả hai yêu cầu này với C++ và Otcl. C++ chạy nhanh nhưng lại chậm khi cần có thay đổi, rất phù hợp cho việc triển khai chi tiết các giao thức. Otcl chạy chậm hơn nhiều, song lại có khả năng thay đổi rất nhanh (và có tính tương tác tốt), có thể thoả mãn tốt nhu cầu cấu hình hệ thống mô phỏng. ns sử dụng tclcl (tcl – c linkage) như một lớp keo gắn kết các đối tượng và biến trong hai ngôn ngữ.Mỗi ngôn ngữ được sử dụng với mục đích riêng. Otcl có thể được sử dụng:- Trong việc cấu hình, cài đặt và các công việc thực hiện “một lần”- Chỉnh sửa các đối tượng C++ đã có sẵnVà sử dụng C++ cho:- Khi làm các công việc đòi hỏi xử lý từng gói tin của luồng dữ liệu- Khi phải thay đổi các hành vi của các lớp C++ đã tồn tạiCó thể hình dung tổ chức của ns qua sơ đồ sau:

Cyber Pro !!! :)) 6


Sơ đồ 3: Kiến trúc của nsSơ đồ Kiến trúc của ns thể hiện kiến trúc ns, nói chung có thể coi người dùng như đang

đứng ở góc dưới bên trái, thiết kế và chạy hệ mô phỏng bằng ngôn ngữ Tcl và sử dụng các đối tượng Otcl trong thư viện. Event Scheduler và hầu hết các đối tượng Network Component đều được viết bằng C++, và có thể triệu gọi từ Otcl thông qua giao tiếp tclcl, cả hệ thống kết hợp lại thành ns.

Sơ đồ Mô hình ns đơn giản cũng chỉ ra , khi kết thúc quá trình mô phỏng, ns có thể sinh ra một hay nhiều text file chứa số liệu chi tiết phục vụ cho việc phân tích quá trình mô phỏng, hoặc cũng có thể là đầu vào cho hệ mô phỏng bằng đồ hoạ (Network Animator : NAM).

Hình dươi đây sẽ mô tả sự hoạt động của NS thông cua 3 mức , như chúng ta thấy có mức khung cảnh, mức Script và cuối cùng là ngôn ngữ C++ Tất cả những công việc của NS đều thông cua các Script của NS để gọi các hàm của C++ ở mức dưới cùng.

Sơ đồ 4 : Sự hoạt động của NS

Cyber Pro !!! :)) 7


2.2. Làm việc với NS :2.2.1. Download và cài đặt :

Ta có thể cài NS bằng các gói riêng biệt (Tcl/Tk , Otcl … ) hoặc cũng có thể dùng một gói bao gồm tất cả các gói riêng biệt “All-in-One” . Ở đây chúng em sử dụng gói “All-in-one” để cài đặt bản 2.27 (Ns-allinone2.27) _ bản mới nhất hiện nay . Bản này đựơc chúng em cài đặt và chạy trên Linux RedHat 8.0 chạy ổn định . Các File có trong NS 2.27 :

- Tkrelease 8.3.2- Otclrelease 1.0a8- TclCL release 1.0b13- Tcl release 8.3.2- Ns release 2.26- Nam release 1.9- Xgraph version 12- CWebversion 3.4g- SGB version 1.0- Gt-itm gt-itm and sgb2ns 1.1- Zlib version 1.1.4

Để cài đặt trên LINUX , ta phải COPY bản nén của NS (ns-allinone-2.27.tar.gz ) trên LINUX và giải nén bằng công cụ của LINUX . Sau đó ta mở Terminal của LINUX , chuyển đến thư mục có chứa File ns-allinone2.27 đã bung nén . Nếu dùng giao diện KDE ta có thể mở cửa sổ Terminal ngay trên thanh công cụ của cửa sổ Window (Window -> Terminal ) . Sau đó gõ lệnh sh install để chạy Script Install của NS . Sau khi đã Install xong ta Copy các Flie trong thư mục Bin của NS vào thư mục Bin của Root hoặc User tuỳ cấp độ sử dụng . Như vậy là ta đã có thể sử dụng chương trình mô phỏng mạng NS .Ta còn có thể chạy được NS trên Window nhờ vào một chương trình giả lập môi trường LINUX trên hệ điều hành Windows gọi là : Cygwin . Để chạy NAM ta còn phải cài đặt thêm Xfree86Server . Tuy nhiên vì điều kiện chưa Down được Xfree86 cho nên chúng em chưa thử nghiệm được NAM trên môi trường Windows , nhưng đã có thể cài đặt và chạy được NS trên Window .

2.2.2 Lập trình bằng Otcl trong NS :

Ngôn ngữ Otcl :

ns là một chương trình mô phỏng hướng đối tượng, viết bởi C++, sử dụng một trình thông dịch OTcl như một bộ giao tiếp trực tiếp với người dùng. Chương trình thông dịch hỗ trợ một lớp phân cấp trong C++ (gọi là phân cấp biên dịch) và một lớp phân cấp tương ứng trong trình thông dịch Otcl (gọi là phân cấp thông dịch). Có sự tương ứng một một giữa một lớp trong phân cấp thông dịch và một lớp trong phân cấp biên dịch. Lớp gốc của phân cấp này là lớp TclObject.

Người dùng tạo ra các đối tượng giả lập mới thông qua trình biên dịch, những đối tượng này được thể hiện trong trình thông dịch, và được phản xạ tỉ mỉ, bởi một đối tượng tương ứng trong phân cấp biên dịch. Phân cấp lớp thông dịch được tự động đưa vào thông qua các phương thức định nghĩa trong lớp TclObject.

Cyber Pro !!! :)) 8


Khái niệm tổng quan :

Tại sao dùng 2 ngôn ngữ ? ns dùng hai ngôn ngữ bởi vì bộ mô phỏng có hai việc khác nhau cần thực hiện

- Một mặt, các mô phỏng chi tiết của giao thức yêu cầu một ngôn ngữ lập trình hệ thống mà hoạt động có hiệu quả tới các byte, packet header, các thuật toán chạy trên các bộ dữ liệu lớn. Với những tác vụ này, tốc độ chạy thực (runtime speed) là quan trọng, còn thời gian thay đổi (chạy giả lập, sửa lỗi, biên dịch lại, chạy lại) là không quan trọng.

- Mặt khác, phần lớn mạng nghiên cứu, bao gồm các thông số, cấu hình khác nhau, hoặc thăm dò nhanh một số hoạt cảnh. Trong những trường hợp này, thời gian tương tác (chạy lại, thay đổi chế độ) là quan trọng hơn còn cấu hình chạy một lần, thời gian chạy thực không quan trọng bằng.

ns kết hợp tất cả các yêu cầu này với hai ngôn ngữ C++ và OTcl. C++ nhanh khi chạy, nhưng chậm khi thay đổi, phù hợp với việc xử lý chi tiết giao thức. OTcl chạy chậm nhưng thay đổi nhanh, là lý tưởng cho cấu hình giả lập. ns thông qua (tclcl) cung cấp “keo” để tạo các đối tượng và các biến xuất hiện trên cả hai ngôn ngữ.

• OTcl dùng để :o Cấu hình, setup và “one-time” stuffo Làm các công việc mà có thể sử dụng các đối tượng C++ có sẵn.

• C++ dùng cho:o Làm những công việc yêu cầu phải xử lý các gói tin trong luồng.o Nếu đang cần phải thay đổi cách ứng xử của một lớp c++, sẵn có trong những

cách mà không biết trước.

Lớp Tcl

Lớp Tcl đóng gói thể hiện thực (actual instance) của trình thông dịch OTcl và cung cấp các phương thức để truy cập và giao tiếp với các trình thông dịch này.

Một instance của lớp được mô tả trong ~/tclcl/tcl.cc như một biến thành phần tĩnh. Lập trình viên phải đặt một tham chiếu đến instance này để truy cập tới các phương thức khác. Khai báo:

Tcl & tcl = Tcl::instance();

Yêu cầu các thủ tục OTcl

Có 4 công cụ khác nhau để yêu cầu một lệnh OTcl thông qua instance Tcl. Chúng khác nhau cơ bản về các thông số. Mỗi hàm truyền một xâu tới trình thông dịch sau đó định giá xâu đó trong ngữ cảnh toàn cục. Các phương thức sẽ trả về nơi gọi nếu trình thông dịch trả về TCL_OK. Ngược lại, nếu trình thông dịch trả vể TCL_ERROR, các phương thức đó sẽ gọi tkerror{}. Người dùng có thể chèn thêm các phương thức này để có thông báo lỗi một cách chính xác hơn.

- Tcl.eval(char *s) yêu cầu Tcl_GlobalEval() chạy s thông qua trình thông dịch- Tcl.evalc(const char* s) bảo vệ tham số s. Nó copy s vào bộ đệm trong, nó sau đó yêu cầu

hàm eval(char *s) trên bộ đệm trong.- Tcl.eval() giả định rằng lệnh đó đã được lưu trong đệm trong bp_ của lớp, nó trực tiếp yêu

cầu Tcl.eval( char* bp_ ). Một handle tới chính bộ đệm thông qua phương thức tcl.buffer(void).

- Tcl.evalf(const char* s, ...) gần tương đương Printf(3). Nó sử dụng vsprintf(3) nội tại để tạo xâu vào.

Cyber Pro !!! :)) 9


Truyền kết quả tới/từ trình thông dịch

Khi trình thông dịch yêu cầu một phương thức C++, nó tiếp nhận kết quả trả lại trong biến thành phần private, tcl_->result. Hai phương thức có khả năng để đặt biến này:

- Tcl.result(const char* s) truyền xâu kết quả s lại trình thông dịch.- Tcl.resultf(const char* fmt, ...)- varargs(3) biến đổi trên để định dạng kết quả sử dụng vsprintf(3), truyền xâu kết quả

tới trình thông dịch.if (strcmp(argv[1], "now") = = 0) {tcl.resultf("%.17g", clock());return TCL_OK;}tcl.result("Invalid operation specified");return TCL_ERROR;

Khi một phương thức C++ yêu cầu một lệnh OTcl, trình thông dịch trả về kết quả trong tcl_->result. tcl.result(void) phải được dùng để nhận kết quả. Chú ý rằng, kết quả là một xâu, nó phải được chuyển tới một định dạng bên trong tương ứng với kiểu của kết quả.

tcl.evalc("Simulator set NumberInterfaces_");char* ni = tcl.result();if (atoi(ni) != 1)tcl.evalc("Simulator set NumberInterfaces_ 1");

Lớp TclObject

Lớp TclObject là lớp cơ sở cho hầu hết các lớp khác trong phân cấp thông dịch và biên dịch. Mỗi đối tượng trong lớp TclObject được tạo ra bởi người dùng từ trong trình thông dịch. Một đối tượng bóng tương đương được tạo ra trong phân cấp biên dịch. Hai đối tượng này liên kết mật thiết với nhau. Ví dụ cấu hình của một TclObject , một tác tử SRM (lớp Agent/SRM/Adaptive)

set srm [new Agent/SRM/Adaptive]$srm set packetSize_ 1024$srm traffic-source $s0

Với quy ước trong ns, lớp Agent/SRM/Adaptor là lớp con của Agent/SRM, là lớp con của lớp Agent, là lớp con của lớp TclObject. Phân cấp lớp biên dịch tương ứng là ASRMAgent, thừa kế từ Agent, thừa kế từ TclObject tương ứng.

Tạo và xoá đối tượng TclObject

a,Tạo đối tượng TclObject: Bằng cách dùng new{}, trình thông dịch sẽ chạy hàm khởi tạo cho đối tượng đó, init{},

truyền cho nó các tham số cung cấp bởi người dùng. Đối tượng bóng của nó được tạo ra bởi hàm thiết lập lớp cơ sở TclObject. Do đó hàm khởi tạo cho đối tượng TclObject mới đầu tiên phải gọi hàm khởi tạo của lớp cha. new{} trả về một handle tới đối tượng này.

Trình tự các hành động sau được thực hiện bởi trình thông dịch là một phần của việc khởi tạo đối tượng TclObject mới.

- Lấy một handle của đối tượng mới từ không gian tên của TclObject. - Gọi hàm khởi tạo cho đối tượng mới và các hàm khởi tạo của các đối tượng lớp trên.

Hàm khởi tạo của đối tượng gốc TclObject sẽ tạo đối tượng bóng và thực hiện các khởi tạo cho nó.

Cyber Pro !!! :)) 10


- Sau khi đối tượng bóng được tạo xong, hàm create_shadow(void) sẽ:o Thêm đối tượng mới vào bảng băm của TclObjectso Gắn cmd{} thành một thủ tục instance của đối tượng thông dịch mới. Thủ tục instance

này gọi phương thức command() của đối tượng biên dịch.Các kỹ thuật tạo bóng ở trên chỉ được thực hiện khi người dùng tạo đối tượng TclObject

thông qua trình thông dịch.

b,Xoá đối tượng TclObject: Hành động xoá delete sẽ huỷ đối tượng thông dịch và đối tượng bóng của nó. Giống như hàm thiết lập, hàm huỷ đối tượng phải gọi hàm huỷ cho lớp cha một cách tường minh như các lệnh cuối của hàm huỷ. Hàm huỷ TclObject sẽ yêu cầu thủ tục thể hiện delete-shadow, tiếp đó yêu cầu phương thức tương ứng trong trình biên dịch để huỷ đối tượng bóng. Trình thông dịch tự nó sẽ huỷ đối tượng thông dịch.

Liên kết biến

Thông thường, việc truy xuất biến biên dịch hay biến thông dịch chỉ giới hạn trong mã biên dịch hay mã thông dịch. Tuy nhiên ns có cơ chế cho phép liên kết giữa biến biên dịch và biến thông dịch, sự thay đổi của biến này sẽ được phản ánh vào biến liên kết với nó.

Việc liên kết được thực hiện thông qua hàm khởi tạo của đối tượng biên dịch. ns hỗ trợ 5 kiểu dữ liệu khác nhau, biến giá trị băng thông, biến thời gian, nguyên, thực và biến logic.

Các phương thức command: định nghĩa và gọi

Mỗi TclObject được tạo, ns thiết lập một thủ tục instance, cmd{}, cho phép thực thi các hàm thông qua các đối tượng biên dịch, cmd{} tự động gọi thủ tục command{} của đối tượng biên dịch và truyền các tham số cần thiết.

Người dùng yêu cầu phương thức cmd{} theo một trong hai cách: gọi tường minh hoặc không tường minh. Với cách tường minh, người dùng gọi thủ tục cmd{} và truyền tham số đầu tiên là hành động cần thực hiện. Với cách không tường minh, nếu có một thủ tục instance có tên giống như hành động cần thực hiện thì người dùng chỉ việc gọi thủ tục instance đó.Lớp TclClass

Lớp biên dịch này (TclClass) là một lớp trừu tượng. Các lớp kế thừa từ lớp này cung cấp hai chức năng: khởi tạo cây lớp thông dịch ánh xạ của cây lớp biên dịch và cung cấp các phương thức để tạo các TclObject mới. Mỗi lớp kế thừa được liên kết với một lớp biên dịch trong cây lớp biên dịch.Lớp TclCommand

Lớp này chỉ cung cấp các kỹ thuật cho ns để xuất các lệnh đơn giản tới trình thông dịch, mà sau đó được chạy trong phạm vi toàn cục bởi trình thông dịch.Lớp InstVar

Lớp này định nghĩa các phương thức và các kỹ thuật để liên kết một biến thành viên C++ trong đối tượng bóng với một biến instance trong đối tượng thông dịch tương ứng. Giá trị của biến có thể truy xuất bởi mã biên dịch hay mã thông dịch tại bất kỳ thời điểm nào.

Có 5 lớp tương ứng với 5 loại biến của Ns: lớp InstVarReal, lớp InstVarTime, InstVarBandwidth, lớp InstVarInt, lớp InstVarBool, tương ứng liên kết với biến thực, thời gian, băng thông, số nguyên, và biến logic.



2.3 Các mô phỏng cơ sở

2.3.1 Lớp mô phỏng (class Simulator)Hệ thống mô phỏng được thực hiện bởi lớp Tcl Simulator. Lớp này cung cấp các giao tiếp

cho phép cấu hình quá trình mô phỏng và lựa chọn loại lịch sự kiện (event scheduler). Các script mô phỏng thường bắt đầu bằng việc tạo một instance của lớp Simulator. Tiếp theo nó gọi các hàm để tạo các nút mạng, cấu hình topo và các thuộc tính khác của mạng. Trong ns version 2 có một lớp thừa kế từ lớp Simulator gọi là OldSim nhằm cung cấp khả năng tuơng thích ngược với ns version 1

2.3.1.1 Khởi tạo mô phỏng

Khi một đối tượng giả lập mới được tạo trong tcl, thủ tục khởi tạo thực hiện các hành động sau:

• Khởi tạo định dạng gói • Tạo một bộ lập lịch • Tạo một “null agent”

Khởi tạo định dạng gói thiét lập các trường offset trong các gói sử dụng bởi toàn bộ trình mô phỏng. Bộ lập lịch (scheduler) chạy theo kiểu điều khiển sự kiện.Null agent được tạo ra với lời gọi sau:

set nullAgent_ [new Agent/Null]NullAgent thường được dùng để làm sink cho các gói muốn loại hay làm đích các gói

không nhận dạng được chuyển tới.

2.3.1.2 Các bộ lập lịch và các sự kiện.

Trình mô phỏng hoạt động theo kiểu hướng sự kiện. Có bốn bộ lập lịch, mỗi bộ sử dụng các cấu trúc dữ liệu khác nhau: danh sách liên kết đơn linked-list, heap, calendar queue (ngầm định) và kiểu một đặc biệt được gọi là “real time”. Bộ lập lịch thực hiện chọn sự kiện tiếp theo gần nhất, hoàn thành nó và sau đó xử lý sự kiện tiếp theo. Đơn vị sử dụng cho lập lịch là giây. Hiện tại, trình mô phỏng chạy đơn tuyến , chỉ một sự kiện được chạy ở một thời điểm. Nếu có nhiều hơn một sự kiện được lập lịch để chạy đồng thời thì việc chạy chúng được thực hiện trên cơ sở sự kiện nào được lập lịch trước sẽ được chạy trước. Các sự kiện mô phỏng không bao giờ được sắp xếp lại bởi bộ lập lịch. Một sự kiện thường bao gồm một “firing time” và một hàm quản lý (handler function).

Hai kiểu đối tượng được thừa kế từ lớp cơ sở Event là packets và “at-events”. Một at-event là một thủ tục được lập lịch chạy ở một thời điểm xác định. Đó là một chuỗi được sử dụng trong các script mô phỏng.

Bộ lập lịch kiểu danh sách (List Scheduler): sử dụng một cấu trúc danh sách liên kết đơn. Danh sách này tổ chức theo trật tự thời gian, theo đó việc chèn và xoá sự kiện yêu cầu phải quét danh sách để tìm điểm vào thích hợp. Khi chọn sự kiện tiếp theo để chạy cần cắt điểm đầu của danh sách khỏi danh sách. Cách thực hiện này đảm bảo thực hiện các sự kiện trong dãy FIFO của dòng các sự kiện.



Bộ lập lịch kiểu vun đống (heap scheduler): thực hiện lập lịch theo cấu trúc vun đống. Cấu trúc này cao cấp hơn so với cấu trúc danh sách cho một số lượng lớn các sự kiện, thời gian chèn và xoá n sự kiện là O(log n).

Bộ lập lịch kiểu (calendar queue): sử dụng cấu trúc dữ liệu giống lịch năm để bàn, ở đó các sự kiện cùng tháng/ngày của nhiều năm có thể được ghi cùng một ngày.

Bộ lập lịch thời gian thực: đồng bộ việc thực hiện các sự kiện với thời gian thực. Nó hiện tại vẫn được đang phát triển.

2.3.2 Node và truyền tải gói tin (packet forwarding)

2.3.2.1 Các cơ sở node (Node basics)

Cơ sở nguyên thuỷ để tạo node là: set ns [new Simulator]$ns node

Thủ tục instance node xây dựng một node bên ngoài các đối tượng phân lớp đơn giản. Node tự bản thân nó là một lớp đơn chuẩn trong OTcl. Mặc dù vậy hầu hết các bộ phận của node đều là các TclObject. Cấu trúc tiêu biểu của một node (unicast) như sau:

Hình 1: Cấu trúc unicast node trong nsCấu trúc đơn giản này bao gồm 2 TclObject: một phân lớp địa chỉ (classifier_) và một

phân lớp cổng (dmux_). Chức năng của các phân lớp này là để phân loại các gói tin đến chính xác các agent hoặc liên kết ra.Hầu hết các node chứa ít nhất các bộ phận sau:

• Một địa chỉ hoặc id_, tự động tăng đều thêm 1 (bắt đầu từ 0) trong không gian tên mô phỏng mỗi khi một node được tạo ra.

• Danh sách các node lân cận (neighbor_).• Một danh sách các agent(agent_).• Bộ định kiểu node (nodetype_)• Một module rounting

Ngầm định, các node trong ns được xây dựng để mô phỏng unicast. Để có khả năng mô phỏng multicast, trình mô phỏng phải được tạo với tuỳ chọn “multicast on”. Ví dụ :



set ns [new Simulator –multicast on]Khi một trình mô phỏng sử dụng rounting multicast, bit cao nhất trong địa chỉ cho biết địa

chỉ đó là địa chỉ multicast hay địa chỉ unicast. Nếu bit này là 0 thì địa chỉ là unicast, ngược lại địa chỉ đó là multicast.Cấu trúc trong của một node multicast.

Hình 2: Cấu trúc multicast node trong ns

2.3.2.2 Các phương thức node: cấu hình node

Thủ tục để cấu hình mỗi node được phân lớp trong • Các hàm điều khiển• Quản lý số hiệu cổng và địa chỉ, chức năng unicast routing• Quản lý agent• Thêm các hàng xóm

Các hàm điều khiển• $node entry trả về điểm vào cho mỗi node. Đây là phần tử đầu tiên sẽ quản lý các gói tin

đến node. Biến instance node, entry_, lưu tham chiếu phần tử này. Với node unicast, đấy là phân lớp (classfier_) địa chỉ mà nhìn ở các bit cao trong địa chỉ đích. Biến instance classfier_ chứa tham chiếu tới phân lớp này. Tuy nhiên, với các node multicast, điểm vào là switch_ nó nhìn ở bít đầu tiên để chỉ ra nó sẽ truyền gói tới phân lớp unicast, hay phân lớp multicast tương ứng.

• $node reset sẽ reset tất cả các tác tử tại node.

Quản lý số hiệu cổng và địa chỉ Thủ tục $node id trả về số hiệu node. Số này tự động tăng và gắn tới mỗi node lúc khởi

tạo bởi phương thức lớp Simulator, $ns node. Lớp Simulator cũng lưu một mảng biến instance, node_, được đánh số bởi node id, và chứa một tham chiếu tới node với id đó.

Thủ tục $node agent (port) trả về handle của agent tại port xác định. Nếu không có agent nào tại số hiệu cổng chỉ định sẵn sàng, thủ tục trả về một xâu rỗng.

Thủ tục alloc-port trả về số hiệu cổng tiếp theo có thể được sử dụng. Nó dùng một biến instance, np_, để đánh dấu số hiệu cổng chưa được xác định.



Thủ tục add-route và add-routes, dùng bởi unicast routing để thêm các đường đi vào classifier_. Cú pháp được dùng là:

$node add-route <destination id> <TclObject> . $node add-routes <destination id> <TclObjects> được dùng để thêm nhiều router tới

cùng một đích.Ngược lại với thủ tục add-routes{} là delete-routes{}.

Quản lý agentVới một <agent>, thủ tục attach{} sẽ thêm agent vào danh sách của agents_ của nó, gắn

số hiệu cổng với agent và đặt địa nguồn cho nó, đặt đích của agent ở entry{} của nó, thêm một con trỏ tới bộ giải tích hợp cổng tại node (dmux_) vào agent tại slot tương ứng trong phân lớp dmux_

Ngược lại, detach{} sẽ xoá tác tử từ danh sách agents_, và bỏ điểm đích của agent, điểm vào trong dumx_ của node vào nullagent.

Xác định các node lân cậnMỗi node giữ một danh sách các node gần nó trong biến instance, neighbor_. Thủ tục add-

neighbor{} thêm một node hàng xóm vào danh sách. Thủ tục neighbors{} trả về danh sách này.

2.3.2.3 Giao diện cấu hình node

Simulator::node-config{} điều tiết tính linh hoạt và cấu trúc module của các node khác nhau định nghĩa trong cùng lớp Node cơ sở.

Giao diện cấu hình node bao gồm hai phần. Phần đầu làm việc với cấu hình node, phần hai tạo node với kiểu được định sẵn.

Cấu hình node về bản chất là định nghĩa các đặc tính khác nhau của node trước khi tạo chúng. Chúng có thể gồm kiểu của cấu trúc địa chỉ sử dụng trong mô phỏng, định nghĩa các bộ phận của mạng cho mobilenode, bật hoặc tắt tuỳ chọn dấu ở các mức Agent/Router/MAC, chọn kiểu của giao thức router cho các node không dây hoặc hạn chế chế độ hoạt động.

2.3.2.4 Phân lớp ( Classifier )

Chức năng của một node khi nó nhận một gói là kiểm tra các trường của gói, thường là địa chỉ đích, và có thể là địa chỉ nguồn. Nó có thể ánh xạ giá trị tới một đối tượng giao diện ra đó là nơi nhận tiếp theo của gói này.

Trong ns công việc này được thực hiện bởi đối tượng classifier đơn.Mỗi đối tượng classifier sẽ được đặt tại một vị trí xác định để kiểm tra việc truyền tải gói tin khi vận chuyển qua node. Một node trong ns dùng nhiều kiểu đối tượng classifier khác nhau của phân lớp cho các mục đích khác nhau.

Phân lớp địa chỉPhân lớp địa chỉ trợ giúp chuyển gói unicast. Nó áp đặt một phép dịch bit và thực hiện

gắn mặt nạ tới địa chỉ đích của gói để tạo một số hiệu slot. Số hiệu slot này được trả về từ phương thức classify().

Phân lớp Multicast.



Phân lớp multicast phân lớp các gói theo cả (nhóm) địa chỉ đích và nguồn. Nó duy trì một bảng ánh xạ cặp nguồn/nhóm tói các số hiệu slot. Khi một gói đến chứa một cặp nguồn/nhóm chưa xác định tới phân lớp, nó yêu cầu một thủ tục OTcl là Node::new-group{} để thêm một điểm vào trong bảng của nó.

Phân lớp đa đường (MultiPath)Đối tượng này được tạo ra để trợ giúp truyền trên nhiều đường có chi phí (cost) bằng

nhau, ở đây node sẽ có nhiều đường chi phí bằng nhau tới cùng một đích, và dùng tất cả chúng đồng thời. Đối tượng này không kiểm soát bất kỳ một trường nào trong gói. Với mỗi gói thành công, nó đơn giản trả về trường slot tiếp trong chế độ làm tròn robin.

Phân lớp bămĐối tượng này được dùng để phân lớp một gói như các thành phần của một luồng. Đúng

như tên của nó chỉ ra, phân lớp băm sử dụng bảng băm để gắn các gói với các luồng. Các gói có thể được gắn tới các luồng dựa vào định danh luông (flow ID), địa chỉ đích, địa chỉ nguồn/đích, hoặc sự kết hợp địa chỉ nguồn /đích cộng với định danh luồng.

Phân lớp băm được tạo ra với một tham số nguyên chỉ định kích thước khởi tạo của bảng băm. Kích thước hiện tại của bảng băm có thể thay đổi với phương thức resize. Khi đã tạo, một biến instance shift_ và mask_ được khởi tạo với giá trị NodeShift và NodeMask hiện tại tương ứng của trình mô phỏng. Những giá trị này nhận được từ đối tượng AddrParams khi một phân lớp băm được khởi tạo. Phân lớp băm sẽ thất bại nếu cấu trúc AddrParams không được khởi tạo.

Phân lớp băm nhận các gói, phân lớp theo các điều kiện luồng của chúng, và nhận các phân lớp slot chỉ định node tiếp theo có thể nhận gói đó.

ReplicatorReplicator khác với các phân lớp khác, nó không dùng chức năng phân lớp. Nó đơn giản

chỉ dùng các phân lớp như một bảng có n slot, nó sử dụng phương thức resv() để tạo n bản copy của gói rồi phát tới n đối tượng được tham chiếu trong bảng.

Để hỗ trợ truyền gói multicast, một phân lớp nhận một gói multicast từ nguồn S cho nhóm G tính một hàm băm h(S,G) cho một số hiệu slot trong bảng đối tượng phân lớp.

2.3.2.5 Module routing và tổ chức phân lớp

Node trong ns thực sự là một tập các phân lớp. Node đơn giản nhất chứa chỉ một phân lớp địa chỉ và một phân lớp cổng. Khi muốn mở rộng chức năng một node, nhiều phân lớp được thêm vào node cơ sở.

Phương thức để quản lý trường hợp này là thông qua lớp thừa kế. Ví dụ, nếu một node muốn trợ giúp phân lớp routing, một cách đơn giản là thừa kế một node Node/Hier từ node cơ sở và chèn các phương thức đặt phân lớp để chèn các phân cấp. Phương thức này hoạt động tốt khi các khối chức năng mới là độc lập và không bị “xáo trộn”(arbitrarily) tuỳ ý. Ví dụ cả kiến trúc routing và adhoc routing dùng tập phân cấp của của chúng. Thừa kế yêu cầu có Node/Hier hỗ trợ trước, và Node/Mobile sau. Sẽ có vấn đề khi muốn node adhoc routing hỗ trợ hierarchical routing. Trong trường hợp này, phải sử dụng đa thừa kế để giải quyết, nhưng nó trở nên không khả thi khi số khối chức năng tăng lên.

Phương thức duy nhất để giải quyết vấn đề này là phép hợp đối tượng. Node cơ sở cần định nghĩa một tập các giao diện cho các phân lớp truy nhập và tổ chức. Những giao diện này có thể là:



• Cho phép các module routing đơn thực thi các phân lớp của chúng để chèn các phân lớp của chúng vào node.

• Cho phép các khối tính toán đường đưa các thông tin định tuyến tới các phân lớp trong tất cả các module routing cần thông tin này.

• Cung cấp một điểm đơn quản lý các module routing đã tồn tại.Ngoài ra, nên định nghĩa một giao diện đồng nhất cho các module routing để nối tới các

giao diện node, cũng như cung cấp một hướng tiếp cận để mở rộng chức năng node.

Module routingMỗi module routing trong ns bao gồm 3 khối chức năng:

• Routing agent chuyển đổi gói routing với các hàng xóm.• Route logic sử dụng thông tin thu lượm bởi routing agent để thực hiện tính toán đường

thực.• Các phân lớp nằm trong node. Chúng dùng bảng routing đã được tính để thực hiện chuyển

gói.Khi tính toán một giao thức routing mới, không cần thực hiện tất cả các khối đó.Khi một giao thức routing mới gộp nhiều hơn một khối chức năng, đặc biệt khi nó chứa

phân cấp của chính nó, nó muốn có một đối tượng khác, mà gọi là routing module, quản lý tất cả các khối chức năng đó và giao tiếp với node để tổ chức các phân lớp của nó.

Hình sau mô tả mối liên quan chức năng giữa các đối tượng này:

Hình 3: Mudule routingCác module routing có thể có quan hệ trực tiếp với các khối tính toán đường, route logic

và/hoặc routing agent. Mặc dù vậy, khối tính toán đường có thể không được cài trực tiếp các đường của chúng thông qua module routing, bởi vì có thể tồn tại các module khác chú tâm tìm các đường mới.

Một module routing bao gồm 3 chức năng lớn:• Khởi tạo các liên kết của nó tới một node thông qua register{}, và loại bỏ liên kết qua

unregister{}. Thường trong register{}, một module routing (1) nói cho node biết liệu nó có muốn biết các cập nhật đường và gắn kết các agent vận chuyển.



(2) tạo các phân lớp của nó và cài chúng trong node. Trong unregister{} một module routing thực hiện công việc ngược lại: xoá các phân lớp và bỏ các kết nối của nó tới bộ cập nhật đường của node.

• Nếu module routing muốn biết các cập nhật đường, node sẽ thông tin cho module thông qua RtModule::add-route{dst,target} và RtModule::delete-route{dst, nullagent}

• Nếu module routing muốn thức hiện gắn kết và huỷ bỏ gắn kết các agent vận chuyển trong node, node sẽ thông tin cho module thông qua: RtModule::attach{agent, port} và RtModule::detach{agent, nullagent}

Giao diện node Để liên kết với các giao diện của module routing, node cung cấp các giao diện tương ứng:

* Để biết module nào đăng ký khi khởi tạo, lớp Node giữ một danh sách các module như một biến lớp. Giá trị ngầm định của danh sách này chứa chỉ module routing cơ sở. Lớp Node cung cấp hai proc sau để xử lý danh sách module này:

Node::enable-module{[name]} Nếu module RtModule/[name] tồn tại, proc này đặt [name] vào danh sách module.

Node::disable-module{[name]} Nếu [name] là trong danh sách module, xoá nó khỏi danh sách đó.

Khi một node được tạo, có thể dùng các thủ tục sau để liệt kê các module đã đăng ký, hoặc nhận một thẻ của module có tên chỉ định:

• Node::list-modules{}• Node::get-module{[name]}

* Để cho các module routing muốn cập nhật routing, một đối tưọng node cung cấp các hàm:• Node::rouite-notify{module} Thêm module vào danh sách cập nhật module.• Node::unreg-route-notify{module} xoá module khỏi danh sách cập nhật routing.

Các thủ tục sau cung cấp các móc nối trên liên kết của các agent vận chuyển:• Node::port-notify{module} Thêm module vào danh sách thông báo kết nối agent.• Node::unreg-port-notify{module} Xoá module từ danh sách liên kết agent.

* Node cung cấp các thủ tục sau để xử lý phân cấp địa chỉ và cổng của nó:Node::insert-entry{module, clsfr, hook} chèn phân lớp clsfr vào điểm vào của node. Nó

cũng liên kết phân lớp mới với module do đó nếu phân lớp này bị loại sau đó, module sẽ bị huỷ bỏ đăng ký. Nếu hook được chỉ ra là một số, phân cấp đã tồn tại sẽ được chèn vào slot hook của phân lớp mới.

Node::install-entry{module, clsfr, hook} khác với Node::insert-entry ở chỗ nó xoá phân lớp đã tồn tại ở điểm vào của node, bỏ đăng ký mọi module routing tương ứng, cài đặt phân lớp mới tại điểm vào. Nếu hook được cung cấp, phân lớp cũ được nối vào chuỗi phân lớp, nó sẽ nối chuỗi này vào slot hook của phân lớp mới. Như trên, nếu hook bằng target, clsfr sẽ được đánh dấu như một đối tượng được thừa kế từ Connector thay cho một phân lớp.

Node::install-demux{demux, port} đặt phân cấp demux được cung cấp như một giải đa hợp ngầm định. Nếu port được cung cấp nó đặt bộ giải đa hợp sẵn có vào slot port của node mới. Chú ý, trong trường hợp này, không xoá bộ giải đa hợp đã tồn tại.



2.3.3 Các liên kết : Các liên kết đơn

Phần này sẽ mô tả cách tạo các liên kết để kết nối các node và hoàn thiện topology của mạng trong giới hạn mô tả các liên kết điểm-điểm đơn giản. Cũng như node được cấu tạo từ các phân lớp, một liên kết đơn được xây dựng từ một chuỗi các bộ kết nối (connector).

Lớp Link là một lớp trong OTcl, cung cấp một vài primitive (hàm nguyên thuỷ) đơn giản. Lớp SimpleLink cung cấp khả năng để kết nối hai node bằng liên kết điểm-điểm. ns cung cấp thủ tục simplex-link{} để xây dựng các liên kết đơn hướng từ một node tới một node khác. Cú pháp mô tả như sau:

set ns [new Simulator]$ns simplex-link (node0)( node1)(bandwidth)(delay)(queue_type)

Lệnh này tạo một liên kết từ node0 tới node1 với băng thông bandwidth và độ trễ delay. Liên kết này dùng một queue các kiểu queue_type.

Cấu trúc của một liên kết đơn giản:

Hình 4: Cấu trúc Link trong ns

• head_ là điểm vào của liên kết, nó chỉ tới đối tượng đầu tiên của liên kết.• queue_tham chiếu tới hàng đợi chính các phần tử của liên kết. • link_ tham chiếu tới phần tử thực sự làm mô hình cho liên kết này, về đặc tính trễ và

băng thông của liên kết.• ttl_tham chiếu tới phần tử xử lý thời gian sống của mỗi gói• drophead_ tham chiếu tới một đối tượng là đầu của hàng đợi các thành phần bị bỏ qua bởi

xử lý liên kết.• enqT_ tham chiếu tới phân tử đánh dấu các gói đang vào queue_• deqT_ tham chiếu tới phần tử đánh dấu các gói đang rời khỏi queue_• drpT_ tham chiếu tơi phần tử đánh dấu các gói đã bị bỏ từ queue_• rcvT_ tham chiếu tới phần tử đánh dấu các gói đã nhận được bởi node tiếp theo.

Thủ tục duplex-link{} xây dựng một liên kết hai hướng từ hai liên kết đơn giản.

2.3.3.1 Các thủ tục xây dựng các liên kết và các liên kết đơn

Link procedures: lớp Link được thực thi hoàn toàn trong Otcl. Lớp OTcl SimpleLink dùng lớp C++ LinkDelay để mô phỏng độ trễ trong phân phát các gói tin. Các thủ tục trong lớp Link là:

• head{} trả về handle của head_.



• queue{} trả về handle của queue_.• link{} trả về handle cho phần tử trễ, link_.• up{} đặt liên kết trạng thái là “up” trong dynamics_ element.• down{} ngược của up{}.• up?{} trả về trạng thái liên kết. Trạng thái là g “up” hay “down”; là “up” nếu

liên kết động được cho phép• all-connectors{} áp đặt mọi hành động chỉ định lên mọi connector trên liên kết.• cost{} đặt giá cho liên kết • cost?{} trả về giá của liên kết.

SimpleLink Procedures: Lớp (Otcl) SimpleLink thực hiện một liên kết điểm-điểm đơn giản với một độ trễ và một queue_ tương ứng. Nó được yêu cầu từ lớp (Otcl cơ sở) Link như sau:

Class SimpleLink -superclass LinkSimpleLink instproc init { src dst bw delay q { lltype "DelayLink" } } {$self next $src $dst$self instvar link_ queue_ head_ toNode_ ttl_...set queue_ $qset link_ [new Delay/Link]$link_ set bandwidth_ $bw$link_ set delay_ $delay$queue_ target $link_$link_ target [$toNode_ entry]...set ttl_ [new TTLChecker]$ttl_ target [$link_ target]$link_ target $ttl_}

2.3.3.2 Các bộ kết nối (connector)Các connector không giống các phân lớp (classifier), nó chỉ tạo dữ liệu cho một bên nhận;

hoặc là gói dữ liệu được chuyển cho hàng xóm target_, hoặc là huỷ (gửi đến drop-target_)Một connector sẽ nhận một gói, thực hiện vài chức năng, và phát gói đó tới hàng xóm của

nó, hoặc loại bỏ gói. Có nhiều loại connector trong ns, mỗi loại thực hiện một chức năng khác nhau:

• Networkinterface : dán nhãn các gói với định danh giao diện đến - nó được dùng bởi các giao thức định tuyến multicast

• DynaLink : đối tượng mà gate traffic phụ thuộc vào link là up hay down• DelayLink : đối tượng mà mô hình hoá tính chất độ trễ và băng thông của liên kết• Queues : kiểu output buffer gắn vào link trong một “real” router trong một mạng• TTLChecker : giảm ttl của mỗi gói tin khi nó được nhận.

2.3.3.3 Phân cấp đối tượngLớp cơ sở dùng đẻ mô tả liên kết gọi là Link.



SimpleLink Object : dùng để thể hiện một liên kết đơn hướng . Không có biến trạng thái hay tham số cấu hình gắn với đối tượng này.DelayLink Object : xác định tổng thời gian yêu cầu cho một packet băng qua một link. Nó được xác định bởi size/bw + delay với size là kích thước gói tin, bw là bandwidth của link và delay là độ trễ khi truyền của link.

2.3.4 Quản lý queue và lập lịch góiQueue biểu diễn các vị trí là nơi mà có thể lưu các gói hay drop. Packet scheduling đề cập

tới các quyết định phục vụ hay là drop gói tin. Hiện tại có các kiểu drop-detail queueing (FIFO), quản lí bộ đệm RED, CBQ và một vài loại Fair Queueing như Fair Queueing (FQ), Stochastic Fair Queueing (SFQ) hay Deficit Round-Robin (DRR).

2.3.4.1 Lớp Queue C++Lớp queue được thừa kế từ lớp cơ sở Connector. Nó cung cấp một lớp cơ sở được dùng

bởi các các lớp queue, như hàm gọi ngược để thực hiện khối hoá. Enque và deque là các hàm ảo thuần tuý, cho thấy lớp Queue được sử dụng như lớp cơ sở,

đặc biệt các queue được thừa kế từ Queue và thực hiện hai chức này nếu cần thiết. Các queue thường không chồng hàm recv bởi vì nó yêu cầu các enque, deque đặc biệt.

Lớp Queue không chứa trạng thái trong. Thường chúng là các đối tượng theo dõi đặc biệt. Thành phần qlim_ được xây dựng để điều khiển giới hạn trên của queue, nhưng nó không được tự đặt bởi lớp Queue; nó phải được dùng bởi các lớp queue con, nếu chúng cần giá trị này. Thành phần bocked_ là một biến logic, xác định liệu queue có khả năng để gửi một gói ngay lập tức tới hàng xóm của nó hay không. Khi một queue bị block, nó có thể enqueue các gói nhưng nó không thể gửi chúng.

2.3.4.2 Queue BlockingMột queue có thể bị block hoặc unblock bất kỳ lúc nào. Thường một queue bị block khi

một packet đi qua giữa nó và hàng xóm của nó. Một blocked queue sẽ còn bị block nếu như downstream link vẫn bận và queue đang có ít nhất một packet được gửi. Một queue chỉ được unblock khi hàm resume của nó được gọi, thông thưòng đó là khi không có packet nào vào queue.

Khi một đối tượng Queue được tạo, nó sẽ bao gồm một đối tượng QueueHandler (qh_) được khởi tạo để chứa một tham chiếu tới đối tượng Queue mới. Khi một Queue nhận một packet, nó gọi phiên bản lớp con của hàm enque với packet đó. Nếu queue không bị block nó sẽ gửi packet và gọi hàm deque chỉ định để kết thúc packet được truyền, block queue và gửi packet tới hàng xóm.

2.3.4.3 Lớp PacketQueueLớp Queue có thể thực hiện quản lý bộ đệm và lập lịch nhưng không thực hiện các công

việc mức thấp trên một queue xác định. Lớp PacketQueue duy trì một linked-list của các packet, và thường được dùng bởi các

chiến lược điều độ riêng biệt và quản lý bộ đệm một cách kỷ luật để giữ trật tự các packet. Chiến lược điều độ riêng biệt hoặc quản lý bộ đệm có thể sử dụng một vài đối tượng PacketQueue. Lớp PacketQueue duy trì số lượng hiện tại các packet được lưu trong queue, nó được phương thức length() trả về. Hàm enque đặt packet chỉ định ở cuối queue và cập nhật biến thành phần len_. Hàm deque trả về packet ở đỉnh queue và xoá nó khỏi queue, hoặc trả về NULL nếu queue rỗng. Hàm lookup trả về packet thứ r từ đỉnh queue, hoặc NULL nếu không có. Hàm remove xoá gói ở



địa chỉ đã cho trong queue. Nó sẽ khiến chương trình kết thúc bất thường nếu gói đó không tồn tại.

2.3.4.4 Các loại đối tượng queue.

Một đối tượng queue là một lớp thông thường của đối tượng có khả năng giữ và đánh dấu hoặc bỏ qua các packet khi chúng đi qua topology được mô phỏng.

Các tham số cấu hình được dùng cho đối tưọng queue là:• Limit_ kích thước queue trong các packet.• Blocked_ ngầm định là false, nó là true nếu queue bị block. • unblock_on_resume_ đặt ngầm định là true, chỉ ra một queue nên tự unblock ở thời

điểm gói cuối cùng đã gửi xong.

2.3.5 Các trễ và các liên kết

Các trễ thể hiện thời gian mỗi gói qua một liên kết. Một dạng cụ thể của đối tượng này (“dynamic link”) cũng hiển thị khả năng hỏng của một liên kết. Tổng thời gian yêu cầu cho một gói vượt qua một liên kết được định nghĩa theo: s/b+d trong đó s là kích thước gói, b là tốc độ của liên kết (bits/s), d là trễ liên kết (s). Sự thực hiện các trễ liên kết được gắn chặt chẽ với thủ tục khối hoá queue.

Đối tượng này trợ giúp một insproc-like, $object dynamic, để đặt các biến của nó, dynamic_. Biến này xác định liệu liên kết có là liên kết động hay không.

Với các liên kết không động, phương thức này thực hiện bởi việc nhận một gói p và lập lịch hai sự kiện. Giả sử hai sự kiện này gọi là E1 và E2, và sự kiện E1 được lập lịch xảy ra sau E2. E1 được lập lịch để xảy ra khi có packet gửi tới node với độ trễ để hoàn tất việc gửi packet hiện tại. E1 thường gắn với đối tượng Queue, do đó nó sẽ được unblock. E2 thể hiện sự kiện packet được chuyển đến nút lân cận tiếp theo. Sự kiện E2 xảy ra một số giây sau E1 là trễ liên kết.

Khi liên kết là động, và nhận một packet p, thì nó sẽ lập lịch cho E1 để có thể unblock queue tại thời điểm thích hợp. Tuy nhiên, E2 được lập lịch chỉ khi p là gói duy nhất hiện đang được truyền. Nếu không, phải có ít nhất một gói đang được truyền trên liên kết mà phải được nhận trước p tại E2. Do đó gói p được giữ trong Transit queue , itq_. Khi gói ngay trước p được node lân cận nhận, đối tương DelayLink sẽ lập lịch một sự kiện cho chính nó để tác động tới E2. Tại thời điểm thích hợp, phương thức handle() của nó sẽ trực tiếp gửi p đến đích của nó. Phương thức nội tại schedule_next() sẽ điều độ các sự kiện cho các gói khi truyền tại thời điểm thích hợp.

II.3.6 Agent:Agent là các điểm cuối (endpoint) nơi các gói của tầng mạng được tạo ra hoặc sử dụng,

agent còn được dùng để cài đặt các giao thức của các tầng khác nhau. Lớp Agent có một phần được cài đặt bằng OTcl và một phần được cài đặt bằng C++.

2.3.6.1 Trạng thái agentLớp Agent C++ chứa đầy đủ các trạng thái nội tại để gắn với các trường khác nhau của

các gói tin mô phỏng được gửi đi. Bao gồm:• addr_ Địa chỉ của node (địa chỉ nguồn trong các gói dữ liệu)• dst_ Địa chỉ đích mà gói sẽ được gửi tới



• size_ packet kích thước (bytes), thường đặt trong header của gói.• type_ type kiểu gói (trong header gói)• fid_ định danh luồng • prio_ the trường mức ưu tiên IP • flags_ packet các cờ • defttl_ default giá trị thời gian sống ngầm định IP ttl

Các giá trị này có thể được thay đổi trong các lớp dẫn xuất của Agent, tuy nhiên không phải tất cả chúng đều cần thiết trong một agent cụ thể nào đó.

2.3.6.2 Các phương thức của agent.Lớp agent hỗ trợ việc sinh và nhận gói. Các hàm thành phần sau được thực hiện bởi lớp

Agent trong C++, và các lớp dẫn xuất thường không override các phương thức này.• Packet* allocpkt() cấp phát một gói mới và gán các trường của nó.• Packet* allocpkt(int) cấp phát gói mới với một tải dữ liệu n byte và gán các trường của nó

Các hàm thành viên sau của lớp Agent thường được override bởi lớp dẫn xuất:• void timeout(timeout number) lớp con chỉ định phương thức timeout• void recv(Packet*, Handler*) agent nhận receiving nhận đường dẫn.

2.3.6.3 Các Agent giao thức:Trong ns có cung cấp các agent sau: (tên trong OTcl)

TCP a “Tahoe” TCP sender (cwnd = 1 on any loss)TCP/Reno a “Reno” TCP sender (with fast recovery)TCP/Newreno a modified Reno TCP sender (changes fast recovery)TCP/Sack1 a SACK TCP senderTCP/Fack a “forward” SACK sender TCPTCP/FullTcp a more full-functioned TCP with 2-way trafficTCP/Vegas a “Vegas” TCP senderTCP/Vegas/RBP a Vegas TCP with “rate based pacing”TCP/Vegas/RBP a Reno TCP with “rate based pacing”TCP/Asym an experimental Tahoe TCP for asymmetric linksTCP/Reno/Asym an experimental Reno TCP for asymmetric linksTCP/Newreno/Asym an experimental Newreno TCP for asymmetric linksTCPSink a Reno or Tahoe TCP receiver (not used for FullTcp)TCPSink/DelAck a TCP delayed-ACK receiverTCPSink/Asym an experimental TCP sink for asymmetric linksTCPSink/Sack1 a SACK TCP receiverTCPSink/Sack1/DelAck a delayed-ACK SACK TCP receiverUDP a basic UDP agentRTP an RTP sender and receiverRTCP an RTCP sender and receiverLossMonitor a packet sink which checks for lossesIVS/Source an IVS sourceIVS/Receiver an IVS receiverCtrMcast/Encap a “centralised multicast” encapsulatorCtrMcast/Decap a “centralised multicast” de-encapsulatorMessage a protocol to carry textual messages



Message/Prune processes multicast routing prune messagesSRM an SRM agent with non-adaptive timersSRM/Adaptive an SRM agent with adaptive timersTap interfaces the simulator to a live networkNull a degenerate agent which discards packetsrtProto/DV distance-vector routing protocol agent

2.3.6.4 Các ví dụ: các Agent TCP, TCPSINK

Lớp TCP biểu diễn một TCP sender đơn giản. Nó gửi dữ liệu tới một agent TCPSink và xử lý các tín hiệu báo nhận (acknowledgments) của nó. Nó có một đối tượng riêng biệt được kết hợp với nó mà biểu diễn yêu cầu của một ứng dụng.

Tạo một agentĐoạn mã OTcl sau đây tạo ra một agent TCP và cấu hình nó:

set tcp [new Agent/TCP] ; # tạo agent gửi$tcp set fid_ 2 ; # thiết lập ID luồng tầng IPset sink [new Agent/TCPSink] ; # tạo agent nhận$ns attach-agent $n0 $tcp ; # đặt sender lên nút $n0$ns attach-agent $n3 $sink ; # đặt receiver lên nút $n3$ns connect $tcp $sink ; # thiết lập kết nối TCPset ftp [new Application/FTP] ; # tạo một ứng dụng nguồn FTP $ftp attach-agent $tcp ; # kết hợp FTP với TCP sender $ns at 1.2 "$ftp start" ; # sắp xếp để FTP bắt đầu vào thời điểm 1.2 giây

Bắt đầu một agent

Agent TcpAgent trong ví dụ được bắt đầu khi nguồn sinh FTP của nó nhận lệnh start ở thời điểm 1.2 giây. Thao tác start là một thủ tục instance được định nghĩa trong lớp Application/FTP. Nó được định nghĩa trong ~ns/tcl/lib/ns-source.tcl như sau:

Application/FTP instproc start {} {[$self agent] send -1

}Trong trường hợp này, agent tham chiếu đến agent TCP đơn giản của chúng ta và send –1

tương tự như gửi một file lớn tùy ý.Lời gọi đến send cuối cùng dẫn đến việc TCP sender tạo ra các gói.

Xử lý đầu vào tại nơi nhậnNhiều TCP agent có thể được sử dụng cùng với lớp TCPSink. Lớp này định nghĩa các

phương thức recv() và ack(). Phương thức recv() chèn lên phương thức Agent::recv() (chỉ đơn thuần là hủy bỏ gói nhận

được). Nó cập nhật trạng thái bên trong với số thứ tự của gói nhận được (và do đó yêu cầu biến off_tcp_ được khởi tạo đúng). Sau đó, nó tạo ra một tín hiệu báo nhận (acknowledgment) cho gói nhận được.

Phương thức ack() cho phép truy nhập đầy đủ tới các trường header của gói bao gồm sự truy nhạp riêng biệt tới TCP header, IP header, Flags header và các header chung. Lời gọi tới send() dẫn ra phương thức Connector::send().



Xử lý các phản hồi tại nơi gửiMột khi phía bên kia của TCP đơn giản nhận được dữ liệu và tạo ra một ACK, nơi gửi

thường phải xử lý ACK. Trong agent TcpAgent, điều này được làm như sau:/** main reception path - should only see acks, otherwise the* network connections are misconfigured*/void TcpAgent::recv(Packet *pkt, Handler*){

hdr_tcp *tcph = (hdr_tcp*)pkt->access(off_tcp_);hdr_ip* iph = (hdr_ip*)pkt->access(off_ip_);...if (((hdr_flags*)pkt->access(off_flags_))->ecn_)

quench(1);if (tcph->seqno() > last_ack_) {

newack(pkt);opencwnd();

} else if (tcph->seqno() == last_ack_) {if (++dupacks_ == NUMDUPACKS) {

...}

}Packet::free(pkt);send(0, 0, maxburst_);

}Đoạn mã này được thực thi khi một gói ACK tới nơi gửi. Trong trường hợp này, một khi

thông tin trong ACK được xử lý (bởi newack), gói này không còn được cần nữa và được trả về cho bộ cấp phát bộ nhớ gói (packet memory allocator). Hơn nữa, việc nhận ACK chỉ ra khả năng gửi dữ liệu thêm, vì vậy phương thức TcpSimpleAgent::send()được gọi để cố gắng gửi thêm dữ liệu nếu cửa sổ TCP cho phép.

Cài đặt các TimerNhư sẽ được trình bày trong chương tiếp theo, các lớp timer cụ thể phải được kế thừa từ

lớp cơ sở trừu tượng TimerHandler được định nghĩa trong ~ns/timer-handler. Các instance của những lớp con này sau đó có thể được sử dụng như những timer của các agent khác nhau. Các agent có thể muốn override phương thức Agent::timeout() (phương thức này không làm gì cả). Trong trường hợp Tahoe TCP agent, hai timer được sử dụng: một timer gửi trễ delsnd_timer_ và một timer phát lại rtx_timer_.

2.3.6.5 Tạo một Agent mới

Để tạo một agent mới, phải làm những việc sau đây:1. Quyết định cấu trúc kế thừa của nó, và tạo ra các định nghĩa lớp phù hợp.

2. Định nghĩa các phương thức recv() và timeout().

3. Định nghĩa những lớp timer cần thiết nào đó.



4. Định nghĩa các hàm liên kết OTcl.

5. Viết mã OTcl cần thiết để truy nhập agent (Phần 10.6.4).

2.3.7 Timer: Các bộ định thời được cài đặt cả trong C++ và trong OTcl. Nó thường được dùng trong các agent.

Trong C++, dùng lớp cơ sở TimerHandler để xử lý thời gian. Trong OTcl cũng có một lớp định thời đơn giản Timer để thao tác với các bộ định thời.

Ở đây ta quan tâm một số thao tác xử lý thời gian sau:$timer sched <delay> Dừng một sự kiện nào đó mà có thể đã được lập lịch và lập

lịch lại sự kiện sau thời gian <delay>.$timer resched <delay> Tương tự lệnh trên. Có thêm các API của C++$timer cancel Dừng các sự kiện đã được lập lịch.$timer distroy giống cancel$timer exprire gọi cho một time-out. Tuy nhiên thủ tục time-out phải được

định nghĩa trong các lớp con.

2.3.8 Định dạng và header của gói tin (packet)Các đôi tượng trong lớp Packet là các đơn vị cơ sở cho việc trao đổi dữ liệu giữa các đối

tượng trong hệ thống mô phỏng. Các giao thức mới có thể định nghĩa các header của riêng mình hoặc có thể mở rộng header có sẵn với bằng việc thêm vào các trường mới.

Các loại header mới được khai báo vào trong hệ mô phỏng bằng cách định nghĩa một cấu trúc dữ liệu C++ với các trường cần thiết, định nghĩa một lớp tĩnh để cung cấp khả năng liên kết với OTcl, sau đó thay đổi một số đoạn mã khởi tạo của hệ mô phỏng để chỉ ra địa chỉ lệch của header mới so với các header khác trong packet.

Khi hệ mô phỏng được khởi tạo thông qua OTcl, người dùng có thể lựa chọn sử dụng một tập con của các loại packet có sẵn, điều này giúp tiết kiệm bộ nhớ trong quá trình mô phỏng. Mặc định hầu hết các loại packet đều được kích hoạt. Việc quản lý xem loại packet nào đang được kích hoạt trong quá trình mô phỏng được quản lý bởi một đối tượng quản lý các header của packet. Đối tượng này cung cấp một phương thức OTcl cho phép chỉ ra header nào được sử dụng trong quá trình mô phỏng. Việc sử dụng một trường trong header không được kích hoạt sẽ dẫn đến lỗi nghiêm trọng (fatal) thoát chương trình.

2.3.8.1 Thêm một kiểu header mớiGiả sử muốn thêm một kiểu header gói mới gọi là newhdr, thực hiện các bước sau:

• Tạo một cấu trúc mới định nghĩa các trường dữ liệu thô (raw field - dữ liệu tạo nên dữ liệu mới), định nghĩa offset_ và các phương thức truy cập.

• Định nghĩa các hàm thành phần cho các trường cần thiết.• Tạo ra một lớp tĩnh để cung cấp khả năng liên kết với OTcl, thực hiện bind_offset() trong

hàm khởi tạo của của nó.• Soạn thảo ~ns/tcl/lib/ns-packet.tcl để cho phép khuôn dạng gói mới.

2.3.8.2 Lựa chọn các header gói gộp vào trong chương trình giả lậpNgầm định, ns gộp tất cả các header của tất cả các giao thức có trong ns vào mỗi packet

trong chương trình giả lập. Việc này dẫn đến dung lượng mỗi packet tăng thêm khoảng 1.9 KB!



Nếu chỉ gộp các header của các giao thức thông thường như IP, TCP thì dung lượng tăng thêm chỉ khoảng 100 byte. Do đó chỉ nên gộp các kiểu header cần dùng.

Để gộp chỉ các header mong muốn khi thực hiện giả lập, trước hết loại bỏ các kiểu header đã được gôp trước khi khởi tạo trình giả lập. Sau đó gộp tập các header chỉ định như sau (ví dụ IP và TCP):

remove-all-packet-headersadd-packet-header IP TCP......set ns [new Simulator]

2.3.8.3 Các lớp liên quan đến packetCó 4 lớp C++ để xử lý các packet và các header là: Packet, p_info, PacketHeader và

PacketHeaderManager. Lớp Packet mô tả các kiểu gói trong giả lập. Lớp packet_info giữ tất cả các dạng text cho các tên gói. Lớp PacketHeader là lớp cơ sở cho mọi header. Lớp PacketHeaderManager là một lớp được dùng để tập hợp và quản lý các header.

2.3.9 Mạng LANĐặc tính của mạng LAN khác với các liên kết điểm-điểm. Một mạng bao gồm nhiều liên

kết điểm - điểm không thể hiện được các thuộc tính chia sẻ và tương tranh của LAN. Để mô phỏng những thuộc tính này, cần tạo ra một kiểu node mới, LanNode. Các cấu hình và giao diện cho LanNode được thực hiện như sau:

2.3.9.1 Cấu hình TclGiao diện để tạo và cấu hình một LAN hơi khác so với các liên kết điểm-điểm. Ở mức

đỉnh, lớp OTcl Simulator cung cấp một phương thức mới gọi là make-lan. Các tham số cho phương thức này giống phương thức duplex-link, ngoại trừ rằng make-lan chỉ chấp nhận một danh sách các node như một tham số đơn thay vì 2 tham số như trong duplex-link.

Simulator instproc make-lan {nodes bw delay lltype ifqtype mactype chantype}Các tuỳ chọn để tạo Lan chỉ ra kiểu của tầng liên kết (LL), hàng đợi, tầng MAC (Mac), và

tầng vật lý (Channel). Ví dụ tạo ra một mạng LAN (ethernet) CSMA/CD như sau:$ns make-lan "$n1 $n2" $bw $delay LL Queue/DropTail Mac/Csma/CdCâu lệnh trên tạo ra một LAN với kiểu cơ bản cho tầng liên kết, hàng đợi DropTail, và

CSMA/CD cho tầng MAC.

2.3.9.2 Các thành phần của LANLanLink chứa các chức năng của 3 tầng thấp nhất trong stack mạng: Link Layer (LL),

Medium Access Control Layer (MAC), Physical Layer (PHY).Hình sau, mô phỏng stack mạng mở rộng tạo giả lập của mạng LAN trong ns.



Hình 5: Giả lập mạng LAN trong ns

Một packet đi xuống lần lượt qua tầng liên kết (Queue và LL), tầng MAC (Mac) và tầng vật lý (Channel đến Classifier/Mac). Tiếp theo packet sẽ đi ngược trở lên qua tầng Mac và LL.

Tại đáy của stack, tầng vật lý bao gồm hai đối tượng Channel và Classifier/Mac. Đối tượng Channel mô phỏng chia sẻ đường truyền và các kỹ thuật truy cập đường truyền của bên gửi. Tại phía nhận, Classifier/Mac chịu trách nhiệm chuyển và (có thể) lặp các packet tới các đối tượng MAC nhận.

Tuỳ thuộc vào kiểu của tầng vật lý, tầng MAC phải chứa một tập nhất định các chức năng như, cảm nhận sóng mang (carrier sense), phát hiện xung đột, tránh xung đột,... Vì các chức năng này ảnh hưởng tới cả bên gửi và bên nhận nên chúng được thực hiện trong một đối tượng Mac. Với bên gửi, đối tượng Mac phải sử một giao thức truy cập đường truyền nhất định trước khi truyền packet lên channel. Với bên nhận, tầng MAC chịu trách nhiệm chuyển packet tới tầng link.

Lớp ChannelLớp Channel mô phỏng giao truyền các packet của tầng vật lý. Lớp Channel cơ bản cung

cấp khả năng mô phỏng xung đột trên đường truyền. Nó cho phép tầng MAC thực hiện cảm nhận sóng mang, xung đột, tắc nghẽn. Nếu có nhiều cuộc truyền xảy ra đồng thời, channel sẽ bật cờ xung đột. Bằng việc kiểm tra cờ này, đối tượng MAC có thể thực hiện phát hiện xung đột và xử lý nó.

Đối tượng Channel chỉ đặt tín hiệu busy của nó trong khoảng thời gian được yêu cầu bởi đối tượng MAC. Nó cũng lập lịch các gói để phân phát tới các đối tượng MAC đích sau thời gian truyền cộng với trễ truyền lan.

Lớp MacClassifierLớp MacClassifier kết thừa lớp Classifier để cài đặt kỹ thuật broadcast đơn giản. Nó thay

đổi phương thức recv() như sau: vì việc lập lại các gói thường tốn kém, nên thường một gói unicst sẽ được phân loại bởi địa chỉ đích MAC macDA_ và chuyển trực tiếp tới đối tượng MAC với địa chỉ này. Nếu địa chỉ của đối tượng đích không tìm thấy hoặc nếu địa chỉ đích MAC là broadcast BCAST_ADDR, gói sẽ được nhân bản và gửi tới mọi MAC trên LAN trừ MAC nguồn.

Lớp MAC



Đối tượng Mac mô phỏng các giao thức truy cập đường truyền cần thiết trong các môi trường chia sẻ đường truyền như là mạng không dây, LANs, do việc truyền và gửi luôn đi kèm với nhau trong hầu hết các loại tầng MAC nên đối tượng MAC được cài đặt cả 2 khả năng này.

Tại bên gửi, đối tượng Mac làm nhiệm vụ thêm header MAC và truyền packet lên channel. Tại phía nhận đối tượng Mac nhận không đồng bộ các gói từ classifier của tầng vật lý. Sau khi xử lý giao thức MAC, nó chuyển gói dữ liệu tới tầng link.

Lớp LL (tầng link)Đối tượng LL mô phỏng các giao thức liên kết dữ liệu. Nhiều giao thức có thể thực hiện

trong lớp này như là phân đoạn (fragmentation) packet, tái hợp (reassembly) packet, giao thức liên kết tin cậy.

Một chức năng khác của tầng link là đặt các địa chỉ đích MAC trong header MAC của packet. Công việc này hiện tại yêu cầu 2 vấn đề tách biệt: tìm kiếm địa chỉ IP của nút theo (next-hop-node) và tìm địa chỉ MAC ứng với địa chỉ này. Để đơn giản, ánh xạ ngầm định giữa các địa chỉ MAC và IP là tương ứng 1-1.

Lớp LanRouterNgầm định chỉ có một đối tượng LanRouter cho mỗi LAN. Nó được tao ra khi một

LanNode mới được khởi tạo. Với mỗi node trên LAN, đối tượng LL có một con trỏ tới LanRouter, do đó nó có khả năng để tìm trạm tiếp cho packet được truyền trên LAN.

Packet* LL::sendto(Packet* p, Handler* h){int nh = (lanrouter_) ? lanrouter_->next_hop(p) : -1;. . .}

2.3.9.3 Routing trong LAN.

Khi tạo một LAN trong ns, một nút ảo LAN (“virtual LAN node”) LanNode được tạo ra. LanNode chứa các đối tượng chia sẻ trong LAN: Channel, Classifier/Mac và LanRouter. Với mỗi nút trong LAN, một đối tượng LanIface được tạo ra. LanIface chứa mọi đối tượng dành riêng cho mỗi nút: Queue, LL, Mac, v.v... LanNode chỉ có ý nghĩa cho giải thuật chọn đường, nó có rất ít điểm chung với nút bình thường. Một trong những điểm chung đó là 2 loại nút này chia sẻ cùng một không gian id nút (Node ID-space). Nếu chọn đường phân cấp (hierarchical routing) được sử dụng, LanNode cũng được gán một địa chỉ phân cấp như mọi nút khác. Đối với vấn đề chọn đường (tĩnh) của NS, LanNode được coi như một nút nối vào tất cả các nút khác trong LAN. Liên kết nối giữa LanNode và các nút của LAN cũng là “ảo” (VLink), giá mặc định cho một liên kết như vậy là ½, do đó, giá cho việc truyền từ một nút này đến một nút khác trong LAN được tính là 1.

2.3.10 Cấu trúc địa chỉ hoá trong nsKhông gian địa chỉ có thể xem như một trường liên tục các n bit, ở đó n có thể là khác

nhau tuỳ mỗi yêu cầu của việc mô phỏng. Giá trị ngầm định của n là 16. Giá trị cực đại của n có thể đặt tới 32.

Không gian địa chỉ gồm 2 phần node-id và port-id. Các bít cao được gán làm địa chỉ nút, id_, các bít thấp hơn còn lại được được gán cho port-id hoặc định danh cho agent gắn với node. Trong các bít cao, có một bít được dùng cho multicast. Không gian địa chỉ bao gồm 32 bít, và



không gian port-id (định danh cổng) bao gồm 32 bít. 32 bít địa chỉ cao dành cho node-id, MSB cho multicast và 32 bít địa chỉ thấp cho port-id. Ngoài ra không gian địa chỉ cũng có thể đặt trong định dạng phân cấp, bao gồm nhiều mức của phân cấp địa chỉ.

2.3.10.1 Định dạng địa chỉ ngầm địnhĐịnh dạng ngầm định cung cấp 32 bit thấp cho port-id, 1 bít cao cho multicast và 32 bít

còn lại cho cho node-id.Thủ tục để đặt định dạng địa chỉ trong chế độ ngầm định được gọi trong khi khởi tạo

chương trình giả lập như sau:set ns [new Simulator]

Nó cũng có thể được gọi tường minh như sau:$ns set-address-format def

2.3.10.2 Định dạng địa chỉ phân cấpCó hai lựa chọn cho việc đặt một địa chỉ tới định dạng phân cấp, ngầm định và chỉ định.

Đặt phân cấp ngầm địnhnode-id trong phân cấp ngầm định bao gồm 3 mức với các bít (10 11 11) trong 3 mức

đó.Cấu hình phân cấp có thể yêu cầu như sau:$ns set-address-format hierarchicalNó đặt:* 32 bít cho port-id,

* 32 bít cho node-id gán trong 3 mức của phân cấp – các bít (10 11 11) cho 3 mức đó – hoặc (9 11 11) nếu kích hoạt multicast

Đặt phân cấp xác địnhLựa chọn thứ hai cho phép một địa chỉ phân cấp, được đặt với các số xác định của các

mức với số các bít gán cho mỗi mức. API cho nó có thể như sau:$ns set-address-format hierarchical <#n hierarchy levels><bits for level1><bits for level2> ...<bits for nthlevel>Ví dụ một cấu hình như sau: $ns set-address-format hierarchical 2 8 15Trong đó có 2 mức phân cấp được chỉ định và gán 8 bít cho mức một và 15 bít cho mức 2.

2.3.10.3 Định dạng địa chỉ node mở rộngTrong trường hợp yêu cầu nhiều bít hơn cho không gian địa chỉ, API mở rộng địa chỉ có

thể như sau:$ns set-address-format expandedSự mở rộng không gian địa chỉ này tới 30 bít, cung cấp 22 bít cao cho node-id và 8 bít

thấp cho port-id. Lệnh này đã lỗi thời vì không gian địa chỉ hiện nay là 32 bít địa chỉ cho node-id và 32 bít địa chỉ cho port-id.

2.3.10.4 Mở rộng trường port-idNó được dùng khi muốn mở rộng port-id trong sự kiện có yêu cầu gắn với một số lượng

lớn các tác nhân ( agent ) tới các node này. Nó có thể dùng trong sự liên kết với lệnh set-addres-format (vơi các tuỳ chọn khác nhau), đã giải thích ở trên.

Dạng rút gọn của lệnh này có dạng như sau:expend-port-field-bits<#bits for portid#>



expend-port-field-bits kiểm tra và đưa ra lỗi như sau nếu yêu cầu kích thước cổng không thể điều tiết (số lượng các bít rỗi là không đủ để đáp ứng) hoặc nếu kích thước cổng là nhỏ hơn hoặc bằng kích thước cổng đã tồn tại.

2.3.10.5 Lỗi khi đặt định dạng địa chỉCác lỗi trả về cho cả set-address-format và expend-port-field-bits nguyên thuỷ trong các

trường hợp sau:• Nếu số các bít chỉ định là nhỏ hơn 0.• Nếu vị trí bít xung đột (số kề nhau của các bít trống được yêu cầu là không tìm thấy)• Nếu tổng số các bít yêu cầu là vượt quá MAXADDRSIZE_• Nếu expend-port-field-bits đòi số bít nhỏ hơn hoặc bằng số bít của kích thước cồng đã tồn

tại.• Nếu số mức phân cấp không tương ứng với số các bít số các bít chỉ định (cho mỗi level).

Phần II.Công cụ hình ảnh hoá mô phỏng : NAM

1.Giới thiệu chung về NAM :

1.1. Tổng quanNam là một công cụ mô phỏng hoạt động dựa trên Tcl/Tk dành cho việc quan sát một

cách trực quan các vết mô phỏng và vết dữ liệu(Tracedata packet) gói tin trong thực tế. Nguyên lý thiết kế nam đã tạo ra một bộ mô phỏng chuyển động có khả năng đọc các tập dữ liệu chuyển động lớn và có thể mở rộng vừa đủ vì vậy nó có thể được sử dụng trong các tình huống mạng trực quan khác nhau. Nam được thiết kế để đọc các câu lệnh sự kiện đơn giản từ một File Trace lớn. Để thực hiện đối với dữ liệu hoạt động lớn cần phải thiết lập một lượng nhỏ thông tin được lưu giữ trong bộ nhớ. Các câu lệnh sự kiện được giữ trong file và đọc lại từ File đó bất cứ khi nào thấy cần thiết.

Bước đầu tiên sử dụng Nam là tạo ra File vết. File vết chứa thông tin về Topology : Nodes, links, cũng như các vết gói. Thường thì các File vết được tạo ra bởi ns. Đối với Ns, người sử dụng có thể tạo các cấu hình Topology, đưa ra các thông tin, và các vết gói sử dụng các sự kiện vết trong ns. Tuy nhiên, bất kì ứng dụng nào cũng có thể tạo ra một File vết của nam.

Trong khi các File vết được tạo ra, nó có thể được hoạt động bởi nam. Khi khởi động Nam sẽ đọc File vết, tạo Topology, hiện cửa sổ, đưa ra nếu cần và dừng lại tại thời điểm 0. Thông qua giao diện người sử dụng, Nam cung cấp điều khiển thông qua nhiều yếu tố của sự hoạt động.

Nó thực hiện lại các sự kiện từ một File vết của nam (nam Trace File ) . File này có thể sẽ rất lớn khi thời gian mô phỏng dài hoặc các sự kiện xảy ra mạnh . Để chạy nam ta làm như sau :

– $nam nam_trace_file.nam– In ns-2 script:

Proc finish{} {……

exec nam nam_trace_file.nam &



exit

.Vẽ hình sử dụng Xgraph : Dựa trên các File đầu ra .Nó vẽ dựa trên các điểm dữ liệu thống kê đồng bộ

Chạy Xgraph :– $xgraph out0.tr, out1.tr –geometry 800x400– In ns-2 script:Proc finish{} {……exec xgraph out0.tr, out1.tr out2.tr –geometry800x400 &exit}



1.2.Các lựa chọn dòng lệnh của NAM:

Các lựa chọn dòng lệnh:-g : Định dạnh hình học của cửa sổ khởi động-t : Chỉ định Nam sử dụng tkgraph, và định dạng đầu vào file nam cho tkgraph

-i : [ Thông tin cho lựa chọn này có khi không đúng] Chỉ ra tỉ lệ (thực tế) triệu giây đối với tỉ lệ cập nhật màn hình.

-N : Chỉ ra tên ứng dụng của ví dụ nam. Tên ứng dụng này có lẽ sau đó được sử dụng trong đồng bộ cùng cấp

-c : Kích thước lớn nhất của bộ nhớ cache được sử dụng để lưu trữ các đối tượng active khi thực hiện hoạt động ngược lại

-f : Tên của các File khởi động được load khi khởi động. Trong file này, người dùng có thể định nghĩa các chức năng sẽ được gọi trong ?

-a : Tạo các ví dụ riêng biệt của Nam-p : In ra định dạng File vết của Nam-S : Cho phép đồng bộ hoạt động X vì vậy dễ dàng hơn cho việc tìm lỗi đồ hoạ. Đối với hệ

thống UNIX chỉ chạy X<tracefile> là tên của File chứa dữ liệu vết được hoạt động. Nếu <tracefile> không thể đọc, nam sẽ cố gắng mở <tracefile>

1.3. Giao diện người sử dụng:Khi bắt đầu khởi động lên, việc đầu tiên Nam làm là khởi động cửa sổ đơn. Bạn có nhiều hoạt

động chạy trong cùng một ví dụ Nam. Trên cungd của tất cả các cửa sổ của Nam là một Menu Bar. Đối với cửa sổ đơn của Nam có các Menu “File” và “Help”. Dưới “File” có một câu lệnh New để tạo một ns topology sử dụng nam editor(Đang làm chức năng này), một cây lệnh Open cho phép bạn mở các File vết đang tồn tại, một câu lệnh WinList mở ra một cửa sổ liệt kê tên của tất cả các File vết đang có, và một câu lệnh Quit để thoát khỏi Nam. Thư mục “Help” chứa các màn hình giúp đỡ và một câu lệnh hiện lên Version và thông tin bản quyền .

“View” menu có 4 nút :• New view : Tạo một view mới của cùng một hoạt động. Người dùng có thể

cuộn hay Zoom trên new view. Tất cả các view sẽ được hoạt động một cách đồng bộ.

• Show monitor checkbox : Nếu được chọn, sẽ hiện lên một bảng tại nửa dưới của cửa sổ, ở đó các màn hình sẽ được hiển thị

• Show autolayout checkbox : Nếu được chọn, sẽ hiện lên một bảng ở nửa dưới của cửa sổ, chứa các hộp input và một nút cho việc tự động đưa ra các điều chỉnh. Hộp này sẽ không được kích hoạt khi sử dụng các liên kết layout.



• Show annotation checkbox : Nếu được chọn, sẽ hiện lên một hộp danh sách tại nửa dưới của cửa sổ, sẽ được sử dụng để liệt kê các chú thích trong qúa trình tăng thời gian.

Dưới Menu Bar, có một bar điều khiển chứa 6 nút, một nhãn, và một thanh cuộn nhỏ. Chúng có thể được nhấn vào theo bất cứ thứ tự nào.

• ( << ) – Rewind : Khi được nhấn, hoạt động sẽ quay lại tỉ lệ 25 lần tỉ lệ cập nhật màn hình hiện thời.

• ( < ) – Backward play : Khi được nhấn, hoạt động sẽ quay lại với thời gian giảm.

• ( Hình vuông ) – Stop : Khi được nhấn, hoạt động sẽ dừng lại.• ( > ) – Forward play : Khi được nhấn, hoạt động sẽ chuyển đến trước với thời

gian tăng.• ( >> ) – Fast Forward : Khi được nhấn, thời gian hoạt động sẽ chuyển đến tốc

độ 25 lần tốc độ cập nhật màn hình hiện thời.• (Biểu tượng chữ V ) : Đóng cửa sổ hoạt động hiện thời.

Nhãn thời gian: Thể hiện thời gian hoạt động hiện thời ( ví dụ : Thời gian mộ phỏng như trong File vết) Rate Slider : Điều khiển tỉ lệ cập nhật màn hình. Tỉ lệ hiện thời được hiển thị trong nhãn trên con trượt (Slider).

Dưới thanh điều khiển đầu tiên, có Màn hiển thị chính, nó chứa một thanh công cụ và ô quan sát chính với hai thanh cuộn . Tất cả new view được tạo ra bởi menu “Views/New view” sẽ có 3 công cụ này. Thanh công cụ chứa 2 nút Zoom. Nút với mũi tên chỉ lên là phóng to, nút có mũi tên xuống là thu nhỏ. Hai thanh cuộn được sử dụng để mở rộng màn hiển thị hoạt động.Nhấn chuột trái lên bất kì đối tượng nào trong khung nhìn chính sẽ hiện ra cửa sổ thông tin. Đối với các đối tượng là gói tin và tác tử (agent), có một nút “monitor” trên cửa sổ hiển thị. Nhấn vào đó ta sẽ thấy hiện ra khung màn hình (nếu nó không có ở đó), và thêm vào một màn hình tới đối tượng. Đối với các đối tượng là Link, sẽ có một nút “Graph” . Nhấn vào nút đó sẽ có một cửa sổ hiển thị, ở đó người sử dụng có thể lựa chọn giữa vẽ một hình với sự sử dụng băng thông hay vẽ một link mất hình của một simplex edge của Duplex Link.“Views/ Show monitors” : Tất cả màn hình sẽ được thiết lập. Một màn hình nhìn nhu một nút lớn trong khung. Chỉ các gói tin và Agent hiện thời mới có các màn hìnhMột màn hình gói tin thể hiện : Kích thước, id, và thời gian gửi. Khi gói tin đến được đích, màn hình vẫn ở đó, nhưng sẽ thông báo rằng gói tin ẩn_invisible. Một màn hình Agent thể hiện tên của Agent và khi có bất kì biến vết nào liên quan đến agent này, chúng cũng được thể hiện luôn lúc đó.

Thanh trượt thời gian : Nhìn giống như một cái thước kẻ, với một con trượt TIME (tag TIME) thả dọc theo thước. Khi ta nhìn thấy con trượt TIME, hoạt động hiện thời sẽ được thể hiện trong nhãn thời gian trong thanh điều khiển(control bar) ở trên. Cạnh bên trái của thanh trượt thể hiện thời gian sự kiện sớm nhất trong file vết và cạnh phải thể hiện thời gian trễ nhất. Nhấn chuột trái lên thước( không phải con trượt) có cùng ảnh hưởng như Rewind và Fast Forward, phụ thuộc vị trí ấn chuột.Khung Automatic Layout có khi là hiện hoặc ẩn. Nếu là hiện, nó sẽ ở dưới thanh trượt thời gian. Nó có 3 hộp Input và một nút relayout. Khi người dùng ấn Enter trong hộp Input, hay ấn vào nút Relayout , số các tương tác sẽ được thực hiện.



Dưới cùng là Hộp danh sách thông báo, ở đó các thông báo được hiển thị. Thông báo là một cặp (time,string), mô tả một sự kiện xảy ra tại một thời điểm. Nháy đúp vào một thông báo trong hộp danh sách sẽ đưa Nam đến thời gian khi mà thông báo được ghi lại. Khi con trỏ ở trong hộp danh sách, nháy chuột phải ta sẽ có ba lựa chọn: Add, Delete, Info để thêm, xoá và hiển thị thông báo.

1.3. Các câu lệnh bàn phím:

1. <return> - Typing a <return> will pause nam if it’s not already paused. If nam is paused, <return> will step the animation one simulated clock tick. (If your keyboard autorepeats, holding down <return> is a goodway to slow-step through the animation.)

2. ’p’ or ’P’ - Pause but not step if paused.3. ’c’ or ’C’ - Continue after a pause.4. ’b’ or ’B’ - Decrease animation time for one screen update interval.5. ’r’ or ’R’ - Rewind.6. ’f’ or ’F’ - Fast Forward.7. ’n’ or ’N’ - Jump to time of next event in the tracefile.8. ’x’ or ’X’ - Undo the last rate change.9. ’u’ or ’U’ - Undo the last time slider drag.10. ’>’ or ‘.’ Increase the granularity (speed up) by 5%.11. ’<’ or ’,’ Decrease the granularity (slow down) by 5%.12. <space bar> - Toggle the pause state of nam.13. ’q’, ’Q’ or <control-c> - Quit.

1.4. Tạo ra các hoạt động bên ngoài từ Nam :Các hoạt động của Nam có thể được ghi và chuyển sang file Gifs hay chuyển động MPEG.Để ghi lại các khung và hoạt động, khởi động Nam với File vết và thiết lập ở chỗ bạn muốn

nó bắt đầu và thêm các thông số khác (bước tỉ lệ, kích cỡ, …). Chọn “Record Animation” từ File Menu để bắt đầu ghi các khung. Mỗi bước hoạt động được ghi trong một cửa sổ thả X (X-Window) gọi là “nam%d.xwd” ở đó %d là số khung. Các File này có thể sau đó được ghép lại trong file chuyển động GIFs hay MPEGs với các các công cụ xử lý thích hợp.

Dưới đây là một đoạn Script chuyển các File này thành một File chuyển động định dạng Gif:

Chú ý xwdtoppm, ppmtogif, và gifmerge không phải của Ns.



1.5. Network Layout:Trong Nam, Một topology được nhận dạng bởi sự chuyển đổi của các đối tượng Node. Nhưng để thể hiện topology trong một cách có thể hiểu được, chúng ta cần phải có kĩ thuật layout. Hiện nay Nam cung cấp 3 phương pháp Layout :

• Người sử dụng nhận dạng layout bởi các hướng của Link. Một hướng kết nối là một góc giữa cạnh và đường nằm ngang, trong khoảng [0;2Π]. Trong quá trình Layout, nam sẽ tôn trọng hướng của Link . Thông thường, nó sẽ lựa chọn một Node tham chiếu, sau đó thay thế các Node khác sử dụng các hướng và độ dài Link. Độ dài Link được quyết định bởi trễ của Link và độ lớn các Node kết nối. Cách này tốt đối với các Topology vừa và nhỏ.

• Sử dụng đối với các Topology ngẫu nhiên, chúng ta có lẽ muốn Layout một cách tự động. Một thuật toán layout đồ hoạ tự động được áp dụng và thực hiện. Ý tưởng chủ đạo của thuật toán là mô hình đồ hoạ như các quả bóng (Nodes) kết nối bởi lò xo (Links). Các quả bóng sẽ đẩy các quả khác, trong khi lò xo nối chúng lại với nhau. Hệ thống này sẽ hội tụ sau khi các quả bóng tương tác với nhau. Trong thực tế, sau một số lượng nhỏ các tương tác (hàng chục, hàng trăm), hầu hết các hình vừa và nhỏ sẽ hội tụ tới một cấu trúc toàn diện. Các hình lớn hơn có thể tạo một kết nối tự động Layout và thực hiện sắp xếp sao cho thu được một Layout có thể chấp nhận được.

o Có 3 thông số của quá trình Layout tự động : Ca hằng số lực hấp dẫn, nó điều khiển lực lò xo giữa các quả bóng. Cr hằng số lực đàn hồi, điều khiển sự đàn hồi giữa các quả bóng. Số lượng các tương tác là khoảng thời gian chạy thủ tục AutomaticLayout

o Đối với Topology nhỏ khoảng 10 Nodé, thông số mặc định (20 – 30 tương tác) sẽ cho một thủ tục layout tốt. Nhưng với topology lớn hơn, cẩn thận với các tham số.

• Có một cặp toạ độ x,y dành cho Layout. Chúng sẽ được sử dụng để hiển thị một topology wireles trong đó các link không phải vĩnh cửu. Sử dụng cách này, các sự kiện Nodes được đưa các toạ độ x và y chỉ ra nơi các Nodes nên được đặt trong một hệ toạ độ Đề-Các.

1.6. Các đối tượng hoạt động:Nam hoạt động sử dụng việc xây dựng các khối được định nghĩa dưới đây:

1. Node : Các Node được tạo nên từ sự kiện vết “n” trong một File vết. Nó thể hiện một nguồn, host, router. Nam sẽ bỏ qua bất kí một Node nào trùng lặp, Một Node có ba hình dạng (tròn ,vuông và lục giác), nhưng mỗi lần được tạo nó không thể thay đổi hình dạn. Các Nodes có thể thay đổi màu trong suốt quá trình hoạt động.

2. Link : Các Links được tạo giữa các Node từ Topology mạng. Các links trong Nam có hay links đơn. Vết sự kiện “l” tạo 2 link đơn và thiết lập các thông số cần thiết trên chúng. Vì vậy đối với quan sát của nguời dùng thì tất cả các Link đều là Duplex. Links có thể đổi màu trong suốt quá trình hoạt động.

3. Queue : Các Queue cần được xây dựng trong nam giữa các Node. Một queue nam được liên kết với chỉ một đường của duplex link. Các Queue được trực quan như khi sắp xếp các gói tin. Các gói tin được sắp xếp trên suốt đường truyền, một góc giữa đường truyền và đường nằm ngang có thể được nhận dạng trong sự kiện vết Queue



4. Packet : Các gói tin được trực quan hoá như một khối với một mũi tên. Hướng của mũi tên chỉ chiều của gói tin di chuyển.Các gói tin được sắp xếp trong hàng đợi được thể hiện như các hình vuông nhỏ.Một gói tin có thể bị Drop từ một hàn đợi hay một Link. Các gói tin đã bị Drop thể hiện như dòng các hình vuông rơi xuống và biến mất cuối mành hình. Không may là các thiết kế của Nam đối với các gói tin bị Drop không thể hiện trong khi hoạt động quay lui.

5. Agent : Các Agents được sử dụng để phân biệt các giao thức từ Node. Chúng luôn liên kết với các nodes. Một Agent có một tên làm định dạng duy nhất cho nó. Nó thể hiện như một hình vuông với tên ở trong và được vẽ cạnh node mà nó liên kết tới.

2. NAM TRACE Về File vết (File trace) chúng ta đã giới thiệu qua ở trên, bây giờ chúng ta sẽ đi sâu vào

tìm hiểu file vết của NAM (Nam Trace)

2.1.Định dạng Nam Trace:Lớp Trace trong C++ đã sử dụng trong việc tìm vết của NS nay được sử dụng cho việc tìm vết của Nam. Phương thức Trace::format() định nghĩa định dạng nam sử ụng trong các File vết của nam được sử dụng cho sự hiển thị của các mô phỏng Ns. Nếu macro NAM_TRACE được định nghĩa (mặc định được định nghĩa trong trace.h), thì các mã sau đó sẽ được thực hiện trong phần hàm Trace::format

if (namChan_ != 0)sprintf(nwrk_,"%c -t "TIME_FORMAT" -s %d -d %d -p %s -e %d -c %d-i %d -a %d -x %s.%s %s.%s %d %s %s",tt,Scheduler::instance().clock(),s,d,name,th->size(),iph->flowid(),th->uid(),iph->flowid(),src_nodeaddr,src_portaddr,dst_nodeaddr,dst_portaddr,seqno,flags,sname);

Mỗi File Nam trace có một định dạng cơ bản. Mỗi dòng là một sự kiện Nam. Kí tự đầu tiên trên dòng định nghĩa kiểu sự kiện và được theo sau bởi vài cờ được thiết lập lựa chọn trên sự kiện đó. Mỗi sự kiện được kết thúc bằng một dòng kí tự mới.

<event-type> -t <time> <more flags>...



Dựa trên các kiểu sự kiện có các kiểu cờ khác nhau theo cờ thời gian.Có 2 đoạn trên File đó, Các sự kiện cấu hình khởi tạo tĩnh và các sự kiện động. Tất cả sự kiện với –t* trong chúng là các sự kiện cấu hình và nên là bắt đầu của File. Một điều chú ý rằng Nam có thể được dẫn file trace từ một dòng cho phép sử dụng các ứng dụng thời gian thực. (Xem Using Stream with Realtime Applications)

2.2. Các sự kiện khởi tạo:Phần đầu của File vết chứa các thông tin khởi tạo. Tất cả các sự kiện khởi tạo đều bắt

đầu bằng cờ -t* . Điều này nói cho Nam biết rằng sự kiện này cần phân tích trước khi bất cứ một hành động nào xảy ra.

Version : Định nghĩa Nam version khi hiển thị File Trace:V -t <time> -v <version> -a <attr>

Thường chỉ có một chuỗi Version trong Tracefile được đưa ra, và nó thường là dòng đầu tiên của File. Ví dụ : V -t * -v 1.0a5 -a 0Cờ -v 1.0a5 nói Nam biết rằng đó là Script yêu cầu Version của Nam > 1.0a5.

Wireless : Nếu bạn muốn sử dụng Node Wireless trong Nam bạn cần khởi tạo sự kiện wireless.W -t * -x 600 -y 600

Cho chúng ta biết được kích thước của layout đối với Wireless thực sự. –x : chiều rộng ; -y : chiều cao.Phân lớp : Thông tin địa chỉ phân lớp được định nghĩa bởi :A -t <time> -n <levels> -o <address-space size> -c <mcastshift> -a <mcastmask> -h <nth level> -m <mask in nth level> -s <shift in nth level>

Vết này cho chúng ta nội dung của các lớp, nếu địa chỉ phân lớp được sử dụng trong mô phỏng .

- Cờ -n <levels> chỉ ra tổng số các tầng phân lớp, 1 đối với địa chỉ flat, 2 đối với địa chỉ phân lớp lớp 2.

- Cờ -o <address-space size> cho biết tổng số bits được sử dụng đối với địa chỉ flat.- Cờ -h <nth level> chỉ ra mức của phân lớp địa chỉ.- Cờ -m <mask> và -s <shift> chỉ ra mặt nạ địa chỉ và bit dịch chuyển của lớp trong

phân lớp địa chỉ.Ví dụ :

A -t * -n 3 -p 0 -o 0xffffffff -c 31 -a 1A -t * -h 1 -m 1023 -s 22A -t * -h 2 -m 2047 -s 11A -t * -h 3 -m 2047 -s 0

Hộp nhập bảng màu (Color Table Entry) : Ta có thể xây dựng các hộp nhập bảng màu sử dụng:

c -t <time> -i <color id> -n <color name>Nam cho phép liên quan một một giữa màu và số nguyên. Đây là điều hết sức hữu ích

trong các gói tin màu. Dòng id của một gói tin được sử dụng với màu của gói tin tương ứng



với bảng màu. Chú ý rằng tên màu nên là một trong các tên trong cơ sở dữ liệu màu X11(user/X11/lib/rgb.txt)

2.3. Nodes:Vết của Nam định nghĩa trạng thái Node :n -t <time> -a <src-addr> -s <src-id> -S <state> -v <shape> -c <color> -i <l-color> -o <color>

- “n” định nghĩa trạng thái Node- Cờ “-t” chỉ thời gian và “-a” , “-s” chỉ địa chỉ và id của Node- “-S” cho biết trạng thái truyền của Node. Các giá trị truyền trạng thái tốt là:

+ UP, DOWN chỉ ra lỗi và phục hồi Node+ COLOR chỉ ra sự thay đổi màu của Node. Nếu COLOR được đưa ra, -c

<color> cho ta biết giá trị màu mới. Cũng như vậy -o <color> cho ta tìm lại vết có thể phục hồi màu cũ của Node

+ DLABEL thêm nhãn vào Node. Nếu DLABEL được đưa ra, -l <old-label> -L <new-label> chỉ nhãn cũ và nhãn mới. Shape cho ta hình dạng của Node. Màu của Node có thể nhận dạng thông qua cờ -i

- “v” là hình dạng của Node. Các giá trị có thể là:+ Tròn+ Hộp+ Lục giác

Ví dụ:n -t * -a 4 -s 4 -S UP -v circle -c tan -i tanĐịnh nghĩa một Node với địa chỉ và Id là 4 hình dạng tròn , màu là nâu vàng(tan)

và nhãn của i là màu nâu vàng

2.4. Links :Nam trace đối với các trạng thái link được cho bởi :l -t <time> -s <src> -d <dst> -S <state> -c <color> -o orientation -r <bw> -D <delay>Ở đó,<state> và <color> chỉ cùng một trạng thái(và cùng một định dạng) như mô tả ở trên trong phần các vết trạng thái Node. Cờ -o cho ta các hướng của Link. Các giá trị có thể là :_

+ up+ down+ right+ left+ up-right+ down-right+ up-left+ down-left+ angle between 0 and 2pi

Cờ -r và –D cho ta băng thông (Mb) và độ trễ (ms) .Ví dụ: l -t * -s 0 -d 1 -S UP -r 1500000 -D 0.01 -c black -o right



2.5. Queues:Các trạng thái Queue của vết nam :

q -t <time> -s <src> -d <dst> -a <attr>Queue được hiển thị trong Nam như một đường thẳng với các gói (các hình vuông nhỏ) được đóng gói. Trong các sự kiện vết Queue, cờ -a chỉ ra hướng của đường Queue (góc giữa đường Queue và đường nằm ngang, theo chiều kim đồng hồ.)Ví dụ : Dòng chỉ một queue phát triển theo chiều dọc tăng lên với màn hình (0.5 có nghĩa là một góc so với đường nằm ngang là pi/2)

q -t * -s 0 -d 1 -a 0.5

2.6. Các gói tin: (Packets)Khi một dòng một tả một gói tin, sự kiện có thể là +(tăng) ; -(giảm); r(nhận); d(bỏ) ;

h(bước).<type> -t <time> -e <extent> -s <source id> -d <destination id> -c <conv> -i <id>Trong đó, Type là một trong các kiểu sau:

+ h Hop : Gói tin bắt đầu được truyền trên Link từ nguồn tới đích và qua next hop+ r receive : Gói tin đã kết thúc truyền và bắt đầu được nhận tại đích+ d Drop : Gói tin đã bị bỏ từ hàng đợi hay Link từ nguồn tới đích. Drop ở đây có nghĩa

là không phân biệt giữa Drop trên Queue hay Drop trên Link. Điều này được quyết định bởi Drop time

+ Enter queue : Gói tin đã vào hàng đợi từ nguồn tới đích+ Leave queue : Gói tin đã ra khỏi hàng đợi từ nguồn tới đích.

Các cờ khác và các ý nghĩa :+ -t <time> là thời gian sự kiện hoạt động+ -s<source id> Node khởi tạo.+ -d<destination id> Node đích+ -p<pkt-type> là tên mô tả của kiểu gói tin quan sát được+ -e<extent> là kichs thước của gói tin (bytes)+ -c<conv> là conversation id và flow-id của phiên đó+ -i<id> là id của gói tin trong conversation + -a<attr> là thuộc tính gói tin, được sử dụng như màu của id+ -x<src-na.pa><dst-sa.na><seq><flags><sname> được chuyển từ File vết của Ns và

nó cho Node nguồn, đích và các địa chỉ cổng, sequence number, các cờ và các kiểu thông điệp.

Ví dụ: -x {0.1 -2147483648.0 -1 ----- SRM_SESS} Cho biết một thông điệp SRM đựơc gửi từ node 0 (port 1)



Các cờ thêm vào cho vài giao thức:+ -P <packet type> cho ta một chuỗi ASCII chỉ rõ một dấu phẩy phân biệt danh sách

các kiểu gói tin. Dưới đây là một vài giá trị :o TCP Một gói tin TCP.o ACK Tạo ACK.o NACK Tạo một bỏ ACK.o SRM Gói tin dữ liệu SRM.

+ -n <sequence number> Cho ta thứ tự của gói tin

2.7. Đánh dấu Node :Đánh dấu Node được tô màu ở tâm các Node hình tròn, hình hộp hay các hình lục giác. Chúng được tạo bởi :m -t <time> -n <mark name> -s <node> -c <color> -h <shape> -o <color>và được xoá bởi : m -t <time> -n <mark name> -s <node> -XChú ý là mỗi lần tạo, một Node đã đánh dấu không thể thay đổi hình dạng của nó. Một vết Nam thể hiện đánh dấu Node là :m -t 4 -s 0 -n m1 -c blue -h circlechỉ ra node 0 đuợc đánh dấu với hình tròn xanh tại thời điểm 1.4ms. Tên của dấu là m1.

2.8. Tìm vết Agent: (Agent Tracing )Các sự kiện vết Agent được dùng để hiển thị trạng thái giao thức. Chúng luôn được liên

kết với các Nodes. Một sự kiện Agent có một tên, với một định danh duy nhất cho agent. Một Agent được thể hiện như một hình vuông với tên trong đó, và một đường Link giữa nó và Node.Các sự kiện Agent được xây dựng sử dụng các định dạng sau đây:

a -t <time> -n <agent name> -s <src>Bởi vì trong ns , các Agent có lẽ được đính vào trong Node, một Agent có lẽ được xoá trong Nam với câu lệnh:

a -t <time> -n <agent name> -s <src> -XVí dụ, Dòng dưới tạo mọt agent tên là srm(50 nối với Node 5 tại thời điểm 0

a -t 0.00000000000000000 -s 5 -n srm(5)

2.9. Tìm vết biến (Variable Tracing):Để hiển thị các biến trạng thái lien quan tới các agent protocol, chúng ta sử dụng các sự kiện vết. Hiện tại chúng ta cho phép một đặc tính hiển thị một biến đơn giản, …, một biến với một biến đơn. Chú ý rằng biến đơn giản được coi như chuỗi (không kể khoảng trống). Mọi đặc tính được yêu cầu liên quan tới Agent. Sau đó, nó có thể thêm hay thay đổi bất cứ khi nào sau khi agent của nó được tạo ra. Dòng vết tạo một đặc tính :f -t <time> -s <src> -a <agentname> -T <type> -n <varname> -v <value> -o <prev value>

Cờ <Type> là :+ v đôí với biến đơn giản+ l đối với danh sách+ s đối với bộ dừng thời gian+ u thời gian khởi tạo bộ đếm thời gian



+ d bỏ bộ đếm thời gian.Ví dụ:f -t 0.00000000000000000 -s 1 -n C1_ -a srm(1) -v 2.25000 -T v

Các đặc tính xoá được sử dụng:f -t <time> -a <agent name> -n <var name> -o <prev value> -X

Phần III : Các bài toán mô phỏng

1. Mô phỏng các gói tin UDP/TCP

1.1 UDP AgentUDP agent được thực hiện trong file udp.{cc, h}. Một UDP agent cho phép dữ liệu trong

một kích cỡ biến thiên lấy từ một ứng dụng và phân đoạn dữ liệu đó nếu cần.Các gói tin UDP cũng chứa một số tuần tự tăng và một nhãn thời gian RTP mặc dù các gói tin UDP thực tế không chứa chúng, số tuần tự này không tự làm các overhead giả lập và dễ dùng đối với sự phân tích file trace hay giả lập các ứng dụng dựa trên UDP.Kích cỡ phân đoạn tối đa mặc định (MSS) cho các UDP agent là 1000 byte:

Agent/UDP set packetSize_ 1000 ; # max segment size

Các ứng dụng có thể truy cập các UDP agent thông qua hàm sendmsg() trong C++ hay phương thức sendmsg trong OTcl,

Sau đây là ví dụ cách thức một UDP agent có thể đwocj sử dụng trong một chương trình, ở đây bộ khởi tạo lưu lượng CBR khởi tạo tại thời gian 1.0,khi đó bắt đầu gọi định kỳ hàm UDP agent sendmsg().

set ns [new Simulator]set n0 [$ns node]set n1 [$ns node]$ns duplex-link $n0 $n1 5Mb 2ms DropTailset udp0 [new Agent/UDP]$ns attach-agent $n0 $udp0set cbr0 [new Application/Traffic/CBR]$cbr0 attach-agent $udp0$udp0 set packetSize_ 536 ;# set MSS to 536 bytesset null0 [new Agent/Null]$ns attach-agent $n1 $null0$ns connect $udp0 $null0$ns at 1.0 "$cbr0 start"

1.1.2 Giải thích các lệnh: Các lệnh sau dùng để cài đặt các UDP agent trong kịch bản giả lập:

set udp0 [new Agent/UDP] : #Tạo một UDP agent.$ns_ attach-agent <node> <agent> : #Gắn <agent> vào <node>.



$traffic-gen attach-agent <agent> : #Đây là một phương thức lớp Application/Traffic/<traffictype> được kết nối bộ khởi tạo lưu lượng tới <agent>.

Ví dụ :nếu ta muốn thiết lập một luồng lưu lượng CBR cho udp agent, udp1, ta sẽ dùng lệnh

set cbr1 [new Application/Traffic/CBR]$cbr1 attach-agent $udp1$ns_ connect <src-agent> <dst-agent> : Lệnh này sẽ thiết lập một kết nối đầu cuối giữa hai agent (ở lớp transport ).$udp set packetSize_ <pktsize>$udp set dst_addr_ <address>$udp set dst_port_ <portnum>$udp set class_ <class-type>$udp set ttl_ <time-to-live>.....

1.2. TCP AgentsCó hai loại TCP agent chính là agent một chiều và hai chiều.Tác tử một chiều được chia

nhỏ hơn thành các tập hợp bên gửi TCP (tuân theo các công nghệ điều khiển lỗi và chống tắc nghẽn khác nhau) và bên nhận (“sinks”).Các tác tử hai chiều đối xứng trong cảm nhận, mô tả cả bên gửi và bên nhận.

Các agent gửi TCP một chiều hiện được hỗ trợ là :

Agent/TCP - a “tahoe” TCP sender

Agent/TCP/Reno - a “Reno” TCP sender

Agent/TCP/Newreno - Reno with a modification

Agent/TCP/Sack1 - TCP with selective repeat (follows RFC2018)

Agent/TCP/Vegas - TCP Vegas

Agent/TCP/Fack - Reno TCP with “forward acknowledgment”The one-way TCP receiving agents currently supported are:

Agent/TCPSink - TCP sink with one ACK per packet

Agent/TCPSink/DelAck - TCP sink with configurable delay per ACK

Agent/TCPSink/Sack1 - selective ACK sink (follows RFC2018)

Agent/TCPSink/Sack1/DelAck - Sack1 with DelAck

Bên gửi thử nghiệm hai chiều hiện hỗ trợ chỉ một dạng Reno của TCP: Agent/TCP/FullTcpSau đây gồm ba phần: Phần I là nhìn tổng quan và các ví dụ cấu hình TCP cơ bản send/sinkagents (sink không cần cấu hình). Phần hai mô tả bên trong của tác tử gửi , và phần cuối là mô tả mở rộng các loại agent khác.

1.2.1. TCP Sender một chiềuBộ giả lập hỗ trợ nhiều phiên bản của một bộ gửi TCP.Các đối tượng này cố gắng bám sát

cách điều khiển lỗi và tắc nghẽn TCP,nhưng không được như sự thực thi TCP trong thực



tế.Chúng không bao gồm quảng bá cửa sổ động, chúng thực hiện số phân đoạn và tính toán số ACK trong đơn vị gói tn, không có kết nối SYN/FIN và không có sự chuyển dũ liệu .1.2.1.1 TCP Sender cơ bản (Tahoe TCP)

Tác tử TCP “Tahoe” Agent/TCP thực hiện điều khiển tắc nghẽn và ước lượng thời gian quay vòng - round-trip-time tương tự như phiên bản TCP với 4.3BSD “Tahoe” UN’X của UC Berkeley.Cửa sổ tắc nghẽn được tăng bởi một gói tin cho mỗi ACK mới nhận được trong khi khởi động chậm(khi cwnd_<ssthresh_) hay khi chống tắc nghẽn(khi cwnd_>=ssthresh_)

Responses to Congestion : Tahoe TCP cho rằng môt gói tin bị mất (do tắc nghẽn) khi thực hiện NUMDUPACKS (định nghĩa trong file tcp.h,) sao lại các gói tin ACK, hay khi bộ đếm truyền lại hết hiệu lực.Nói cách khác, Tahoe TCP tác động trở lại bởi thiết lập ssthresh_ tới một nửa kích cỡ của sổ hiện tại(nhỏ nhất của cwnd_ và window_) hay 2, cái nào lớn hơn.Nó sẽ khởi tạo giá trị cwnd_trở về giá trị của windowInit_. Đây là nguyên nhân điển hình làm cho TCP bật slow-start.

Round-Trip Time Estimation hay RTO Timeout Selection: Bốn biến được dùng để ước lượng thời gian quay vòng và thiết lập bộ đếm truyền lại: rtt_, srtt_, rttvar_, tcpTick_, và backoff_. TCP khởi tạo rttvar_ là 3/tcpTick_ và backoff_ là 1.Khi bộ đếm truyền lại được thiết lập, thời gian timeout của nó đựoc thiết lập tới thời gian hiện tại cộng thêm max(bt(a+4v+1),64) giây, với b là giá trị của backoff_ hiện tại, t là giá trị của tcpTick_, a là giá rị của srtt_và v là giá trị của rttvar_.Cácmẫu thử thời gian quay vòng RTT Round-trip time với các ACK mới được tính toán với sự khác nhau của thời gian hiện hành và trường “time echo” trong gói tin ACK.Khi mẫu thử đầu tiên được tạo ra, giá trị của nó được dùng là giá trị khởi tạo của srtt_. Một nửa của mẫu thử đầu tiên được dùng như giá trị khởi tạo của rttvar_. Với các mẫu thử tuần tự tiếp theo, giá trị được cập nhất như sau:

Srtt= samplesrtt ×+×8

1

8

7

Rttvar= srttsamplertt −×+×4

1var

4

3

1.2.1.2 Cấu hình Chạy một bộ giả lập TCP cần phải tạo ra và cấu hình agent, gắn với một nguồn dữ liệu cấp ứng dụng (một bộ khởi tạo lưu lượng ), và khởi động chúng.1.2.1.3 Cấu hình đơn giảnTạo Agent

set ns [new Simulator] ; # preamble initializationset node1 [$ns node] ; #agent to reside on this nodeset node2 [$ns node] ; #agent to reside on this nodeset tcp1 [$ns create-connection TCP $node1 TCPSink $node2 42]$tcp set window_ 50 ; # configure the TCP agentset ftp1 [new Application/FTP]$ftp1 attach-agent $tcp1$ns at 0.0 "$ftp start"

Ví dụ này giải thích dùng bộ giả lập xây dựng chức năng tạo kết nối, node nguồn, agent tác vụ được tạo ra và ID luồng được dùng trên kết nối.Chức năng này được thực hiện bằng cách



tạo hai agent, thiết lập trường ID luồng flow ID trong các agent, gắn nguồn và các agent đích tới các node tương ứng, sau đó hoàn thành kết nối (thiết lập nguồn và các cổng, địa chỉ đích thích hợp).Giá trị trả về của hàm này là tên của agent nguồn được tạo ra.

TCP Data Source : là TCP agent không tạo ra bất cứ dữ liệu ứng dụng nào trên bản thân nó, thay vào đó người sử dụng có thể kết nối các module sinh lưu lượng tới TCP agent để tạo ra dữ liệu.Hai ứng dụng thường được dùng cho TCP: FTP và Telnet. FTP minh họa truyền một lượng lớn dữ liệu và telnet chọn ngẫu nhiên kích cỡ truyền của nó từ tcplib (file tcplib-telnet.cc).

1.2.1.4 Các tham số cấu hình khác Ngoài các tham số window_ được liệt kê ở trên, TCP agent hỗ trợ các biến cấu hình,, mỗi

biến được mô tả trong mục nhỏ là một biến lớp và biến instance.Việc thay đổi biến lớp làm thay đổi giá trị mặc định đối với tất cả các agent được tạo ra tuần tự.Việc hay đổi biến instance của agent đặc biệt chỉ ảnh hưởng giá trị đwocj dùng bởi agent đó.Ví dụ:

Agent/TCP set window_ 100 ; # Changes the class variable$tcp set window_ 2.0 ; # Changes window_ for the $tcp object onlyTham số mặc định của mỗi TCP agent là:Agent/TCP set window_ 20 ; # max bound on window sizeAgent/TCP set windowInit_ 1 ; # initial/reset value of cwndAgent/TCP set windowOption_ 1 ; # cong avoid algorithm (1: standard)Agent/TCP set windowConstant_ 4 ; # used only when windowOption != 1Agent/TCP set windowThresh_ 0.002 ; # used in computing averaged windowAgent/TCP set overhead_ 0 ; # !=0 adds random time between sendsAgent/TCP set ecn_ 0 ; # TCP should react to ecn bitAgent/TCP set packetSize_ 1000 ; # packet size used by sender (bytes)Agent/TCP set bugFix_ true ; # see explanationAgent/TCP set slow_start_restart_ true ; # see explanationAgent/TCP set tcpTick_ 0.1 ; # timer granulatiry in sec (.1 is NONSTANDARD)Agent/TCP set maxrto_ 64 ; # bound on RTO (seconds)Agent/TCP set dupacks_ 0 ; # duplicate ACK counterAgent/TCP set ack_ 0 ; # highest ACK receivedAgent/TCP set cwnd_ 0 ; # congestion window (packets)Agent/TCP set awnd_ 0 ; # averaged cwnd (experimental)Agent/TCP set ssthresh_ 0 ; # slow-stat threshold (packets)Agent/TCP set rtt_ 0 ; # rtt sampleAgent/TCP set srtt_ 0 ; # smoothed (averaged) rttAgent/TCP set rttvar_ 0 ; # mean deviation of rtt samplesAgent/TCP set backoff_ 0 ; # current RTO backoff factorAgent/TCP set maxseq_ 0 ; # max (packet) seq number sent

Với nhiều bộ giả lập, một số ccác tham số cấu hình được yêu cầu thay đổi, thường là : window_ và packetSize_. Window_ ràng buộc window TCP ,và đwocj coi như đóng vai trò của cửa sổ được quảng bá bên nhận trong thế giới TCP thực(mặc dù nó vẫn cố định).Kích cỡ gói tin mang chức năng giống như kích cỡ MMS trong thế giới TCP thực.Thay đổi các tham số này có



thể có một ảnh hưởng sâu sắc tới cách thực hiện của TCP.Tổng quát, các TCP với kích cỡ gói tin, cửa sổ lớn hơn và thời gian quay vòng nhỏ hơn (một kết quả của tô pô và tắc nghẽn) sẽ làm linh họat hơn trong việc giành được băng thông mạng.

1.2.1.5 One-Way TCP Sender khácReno TCP Reno TCP agent ương tự như Tahoe TCP agent, ngoại trừ nó bao gồm fast

recovery,với của sổ tắc nghẽn hiện tại được tăng lên bởi số các bản sao ACK mà TCP sender nhận được trwocs khi nhận một ACK mới.Một ACK mới tức là ACK với giá trị cao hơn so với giá trị cao nhất trước đó.Thêm vào đó, Reno TCP agent không quay về slow-start trong quá trình truyền lại nhanh.Hơn nữa, nó giảm tập hợp cửa sổ tắc nghẽn xuống một nửa và khởi tạo lại ssthresh_ khớp với giá trị này.

Newreno TCP Được dựa trên Reno TCP agent, nhưng thay đổi hoạt động khi nhận các ACK mới, để thoát trạng thái phục hồi nhanh - fast recovery,bên gửi phảib nhận một ACK với số sequence cao nhất gửi đi.Như vậy, các “partial ACK” mới (chúng được xem như các ACK mới nhưng không phải là một ACK với dữ liệu tồn tại) không làm giảm cửa sổ (và có thể đưa đến một sự trì hoãn, đặc tính của Reno).

Sack TCP thực hiện lặp lại có chọn lọc, dựa trên các ACK được cung cấp bởi bên nhận.Fack TCP Thực hiện các “forward ACK” TCP, là sự biến đổi của Sack TCP .

1.2.2 TCP Receivers (sinks)Bên gửi TCP đwocj mô tả trên miêu tả bên gửi dữ liệu một chiều, chúng phải tương

đương với một đối tượng “TCP sink”1.2.2.1 TCP Sink cơ bản

Đối tượng TCP sink (Agent/TCPSink) có trách nhiệm gửi trả về các ACK tới đối tượng nguồn TCP tương đương.Nó tạo ra một ACK với mỗi gói tin nhận được.Kích cỡ các ACK có thể được cấu hình Việc tạo và cấu hình đối tượng TCP sink thường được thực hiện tự động bởi một thư viện gọi.Các tham số cấu hình

Agent/TCPSink set packetSize_ 401.2.2.2 Delayed-ACK TCP SinkMột đối tượng delayed-ACK sink (Agent/Agent/TCPSink/DelAck) có thể dùng để mô phỏng một TCP receiver mà các ACK nhận ít hơn một lần trên một gói tin.Đói tượng này chứa một biến ràng buộc interval_ là số giây đợi giữa các ACK.Delayed ACK sink thực hiện một chế độ ACK linh hoạt nhờ đó chỉ các ACK hợp lệ là bị trễ.Các gói tin không hợp lệ ngay lập tức sẽ sinh ra ACK

Tham số cấu hìnhAgent/TCPSink/DelAck set interval_ 100ms

1.2.2.3 Sack TCP SinkSelective-acknowledgment TCP sink (Agent/TCPSink/Sack1) thực hiện mô hình sinh

SACK sau định nghĩa SACK trong chuẩn RFC 2018.Đối tượng này bao gồm biến ràng buộc maxSackBlocks_ là số lượng cực đại các khối thông tin trong một ACK có thể dùng rong việc nắm giữ thông tin SACK.Giá trị mặc định của biến này là 3, phù hợp với mong muốn dùng SACK với RTTM (RFC 2018, section 3). Delayed và selective ACKs cùng được thực hiện bởi một đối tượng loại Agent/TCPSink/Sack1/DelAck.



Tham số cấu hình:Agent/TCPSink set maxSackBlocks_ 3

1.2.3 Các TCP Agent hai chiều (FullTcp)Đối tượng Agent/TCP/FullTcp được thêm vào bộ TCP agent đwocj hôx trợ cho việc mô

phỏng và vẫn đang phát triển.Có sự khác nhau giữa các agent này nhưng dùng cung một cơ chế.Chúng khác nhau ở các điểm sau:

- Các kết nối có thể được thiết lập và ngắt - town down (Các gói tin SYN/FIN được trao đổi)

- Hỗ trợ truyền dữ liệu hai chiều- Các số tuần tự - sequence number trong các byte đúng hơn là các gói tinSự sinh ra các gói tin SYN (và các ACK của chúng) có thể có thể có độ quan trọng tới hạn

trong việc cố gắng đạt tới mô hình thực tế khi dùng nhiều sự truyền dữ liệu rất ngắnPhiên bản này của TCP hiện được mặc định gửi dữ liệu trên các phân đoạn thứ ba của một bắt tay 3 lần đầu tiên, có thể hơi khác so với mô hình TCP thực tế.Một kết nối TCP điển hình được thực iện với việc kích hoạt một opener gửi một SYN, opener thụ động tương ứng với một SYN+ACK, opener chủ đông tướng ứng với một ACK, và sau một thời gian sau việc gửi phân đoạn đầu tiên với dữ liệu (tương ứng với viết ứng dụng đầu tiên ).Do đó phiên bản này của TCP gửi dữ liệu sớm hơn so với loại điển hình thực hiện.TCP này có thể được cấu hình để gửi dữ liệu trên phân đoạn SYN khởi tạo.Tương lai FullTCP có thể bao gồm viẹc diều chỉnh để gửi phân đoạn dữ liệu đầu tiên sau đó, và có thể thực hiện chức năng T/TCP Hiện tại FullTCP chỉ thực hiện với điều khiển tắc nghẽn Reno, và cuối cùng nó có thể có một dải đầy đủ của các thuật toán điều khiển tắcnghẽn(như Tahoe, SACK, Vegas, etc.).1.2.3.1 Cấu hình cơ bản

Chạy một mô phỏng Full TCP đòi hỏi tạo và cấu hình agent, gắn vào một nguồn dữ liệu cấp ứng dụng(một traffic generator), và khởi tạo agent cũng như traffic generator.Tạo Agent

# set up connection (do not use "create-connection" method because# we need a handle on the sink object)set src [new Agent/TCP/FullTcp] ; # create agentset sink [new Agent/TCP/FullTcp] ; # create agent$ns_ attach-agent $node_(s1) $src ; # bind src to node$ns_ attach-agent $node_(k1) $sink ; # bind sink to node$src set fid_ 0 ; # set flow ID field$sink set fid_ 0 ; # set flow ID field$ns_ connect $src $sink ; # active connection src to sink

# set up TCP-level connections$sink listen ; # will figure out who its peer is$src set window_ 100;

Việc tạo ra FullTcp agent tương tự như các agent khác, nhưng sink được tạo ra tại trạng thái listening bởi phương thức listen.Do bên nhận được yêu cầu phù hợp với cuộc gọi, việc tạo kết nối cuộc gọi ở trên có thể sẽ không được dùng.



Agent/TCP/FullTcp set segsperack_ 1 ; # segs received before generating ACKAgent/TCP/FullTcp set segsize_ 536 ; # segment size (MSS size for bulk xfers)Agent/TCP/FullTcp set tcprexmtthresh_ 3 ; # dupACKs thresh to trigger fast rexmtAgent/TCP/FullTcp set iss_ 0 ; # initial send sequence numberAgent/TCP/FullTcp set nodelay_ false ; # disable sender-side Nagle algorithmAgent/TCP/FullTcp set data_on_syn_ false ; # send data on initial SYN?Agent/TCP/FullTcp set dupseg_fix_ true ; # avoid fast rxt due to dup segs+acksAgent/TCP/FullTcp set dupack_reset_ false ; # reset dupACK ctr on !0 len data segs

containing dup ACKsAgent/TCP/FullTcp set interval_ 0.1 ; # as in TCP above, (100ms is non-std)

1.2.3.2 BayFullTcpMột sự thực hiện khác của TCP hai chiều được gọi là BayFullTcp. Sự khác nhau cơ bản

giữa BayFullTcp và FullTcp như sau:_

- BayTcp hỗ trợ mô hình ứng dụng client-server trong khi FullTcp không giả định về lớp ứng dụng của nó..

- Giao diện ứng dụng tcp khác nhau- FullTcp hỗ trợ ack cục bộ (BayTcp thì không).- FullTcp hỗ trợ các dạng khác của tcp (tahoe, reno etc) còn baytcp thì không- Sự thực hiện của cả hai khác nhau tập các API .

1.2.4 Kiến trúc bên trongTCP agent cơ bản (class Agent/TCP) được xây dựng như một tập các chu trình gửi gói

tin, xử lý ACK, quản lý việc gửi cửa sổ và nắm bắt thời gian timeout..Tổng quát, mỗi chu trình có thể đuợc xác định bởi một chức năng cùng tên trong lớp xuất phát..

The TCP header: TCP header đwocj định nghĩa trong cấu trúc hdr_tcp trong file ~ns/tcp.h. Agent cơ bản chỉ dùng các tập con của các trường sauts_ /* current time packet was sent from source */ts_echo_ /* for ACKs: timestamp field from packet associated with this ACK */seqno_ /* sequence number for this data segment or ACK (Note: overloading!) */reason_ /* set by sender when (re)transmitting to trace reason for send */

Các hàm gửi dữ liệu: tổng quan,TCP không bao giờ thục sự gử dữ liệu, nó chỉ thiết lập kích cỡ các gói tin.

+ send_much(force, reason, maxburst) Hàm này cố gắng gửi nhiều gói tin đến mức cửa sổ truyền hiện hành cho phép.Nó cũng giữ việc theo dõi bao nhiêu gói tin đã được gửi đi, và giới hạn là maxburst.

+ output(seqno, reason) gửi một gói tin với số tuần tự và cấp nhật biến số tuần tự gửi đi cực đại (maxseq_) để nắm bắt số tuần tự nếu nó quá lớn.Hàm này cũng chỉ định các trường khác nhau trong TCP header (sequence number, timestamp, reason for transmission). Hàm này cũng thiết lập một bộ đếm truyền lại nếu bên nào đó đang chờ đợi

Các chức năng quản lý của sổ:



- window().Nó trả về tối thiểu của cửa sổ tắc nghẽn và biến wnd_, mô tả cửa sổ quảng bá của bên nhận.

- opencwnd() - Chức năng này mở của sổ tắc nghẽn được gọi khi một ACK mới đến.Trong chế độ slow-start,hàm này hiếm khi gia tăng cwnd_ bởi mỗi ACK được nhậnKhi tránh tắc nghẽn, cấu hình chuẩn gia tăng cwnd_ bởi số nghịch đảo của nó.Cửa sổ khác tăng lựa chọn được hỗ trợ trong khi tránh tắc nghẽn.

- closecwnd(int how) –Hàm này giảm cửa sổ tắc nghẽn, có thẻ được gọi bằng nhiều cách: Khi thực hiện truyền lại nhanh fast retransmit, dựa vào bộ đếm hết hiệu lực hay khia báo tắc nghẽn.(bit ECN được thiết lập ).Đối số của nó cho biết cách của sổ tắc nghẽn đượcgiảm.Giá trị 0 được dùng để truyền lại timeout và truyền nhanh trong Tahoe TCP.Đó là nguyên nhân điển hình TCP thiết lập slow-start và giảm ssthresh_ xuống một nửa cửa sổ hiện tại.Giá trị 1 được dùng bởi Reno TCP cho quá trình phục hồi nhanh -fast recovery (ngăn ngừa việc trở về slow-start).Giá trị 2 được dùng để giảm cửa sổ dựa vào ECN indication. Nó sẽ thiết lập lại cửa sổ tắc nghẽn về giá trị khởi tạo(Thường gây ra slow-start),nhưng không làm thay đổi ssthresh_.

Các hàm xử lý ACK+ recv() – Hàm này là đường tiếp nhận chính các ACK.Chú ý rằng chỉ một chiều của

luồng dữ liệu được dùng, chức năng này chỉ được gọi với các gói tin ACK thuần(không có dữ liệu).Hàm này chứa các nhãn thời gian từ ACK trong ts_peer_, và kiểm tra sự có mặt của bit ECN (giảm cửa sổ gửi nếu cần).Nếu ACK là một ACK mới,nó gọi newack(), và iểm tra nếu là bản sao của ACK trước.Nếu đúng, nó sẽ truyền lại nhanh bằng cách đóng cửa sổ, thiết lập lại bộ đếm truyền lại và gửi lại gói tin bằng cách gọi hàm send_.

+ newack() – Hàm này xử lý một ACK mới(chứa một số ACK cao hơn so với trước), hàm này thiết lập bộ đếm truyền lại mới bằng việc gọi lại newtimer(), cập nhật ước lượng RTT bằng cách gọi rtt_update, và cập nhật biến ACK cuối cùng và cao nhất.Các hàm quản lý bộ đếm truyền lại:Các hàm này có hai mục đích:ước lượng thời gian quay vòng và thiết lập bộ đếm truyền lại.. rtt_init – hàm này khởi tạo srtt_ và rtt_ về 0, thiết lập rttvar_ về 3/tcptick_

+ rtt_timeout – Hàm này đưa ra giá trị timeout , có thể được dùng để lập kế hoạch cho bộ đếm truyền lại tiếp theo.Nó sẽ tính toán dựa vào ước lượng hiện tại về cách thức và sai số của thời gian quay vòng

+ rtt_update – Hàm này tạo một đối số đo lường RTT và tính trung bình khi chạy và wocs lượng sai số .

+ reset_rtx_timer – Hàm này được gọi trong quá trình truyền lại nhanh hay trong quá trình timeout.Nó thiết lập một bộ đếm truyền lại bằng việc gọi set_rtx_timer và nếu được gọi khi timeout cũng gọi rtt_backoff.

+ rtt_backoff – Hàm này backs off bộ đếm truyền lại + newtimer – Hàm này chỉ được gọi khi một ACK mới đến.

1.2.5 Tracing TCP DynamicsCách thực hiện của TCP thuờng được tiến hành bằng cách xây dựng một khe sequence

number-vs-time .Điển hình một trace được thực hiện bởi việc kích hoạt tracing trên một link trên đó các gói tin TCP sẽ qua.Hai phương thức trace được hỗ trợ : Một mặc định dùng cho tracing các TCP agent và một mở rộng cho các FullTCP.

31.6 One-Way Trace TCP Trace Dynamics



Các gói tin TCP đựoc tạo ra bởi một trong các TCP agent một chiều và có đích là một TCP sink agent có một traced link sẽ tạo ra một file trace có dạng:

+ 0.94176 2 3 tcp 1000 ------ 0 0.0 3.0 25 40+ 0.94276 2 3 tcp 1000 ------ 0 0.0 3.0 26 41d 0.94276 2 3 tcp 1000 ------ 0 0.0 3.0 26 41+ 0.95072 2 0 ack 40 ------ 0 3.0 0.0 14 29- 0.95072 2 0 ack 40 ------ 0 3.0 0.0 14 29- 0.95176 2 3 tcp 1000 ------ 0 0.0 3.0 21 36+ 0.95176 2 3 tcp 1000 ------ 0 0.0 3.0 27 42

1.2.6. Tổng quan về các lệnhSau đây là danh sách các lệnh được dùng để thiết lập, vận hành luồng TCP cho mô phỏng

set tcp0 [new Agent/TCP]: Tạo một instance của TCP agent. Có nhiều loại TCP-sender và TCP-receiver ( sink) agent đwocj thực hiện trên NS. Các TCP-sender có thể là: Agent/TCP, Agent/TCP/Reno,Agent/TCP/Newreno, Agent/TCP/Sack1, Agent/TCP/Vegas, Agent/TCP/Fack.Các TCP-receiver hiện nay có thể là : Agent/TCPSink, Agent/TCPSink/DelAck, Agent/TCPSink/Sack1,Agent/TCPSink/Sack1/DelAck.Có TCP hai chiều được gọi là Agent/TCP/FullTcp. Các tham số cấu hình cho luồng TCP được thiết lập như sau:$tcp set window_ <wnd-size> :

Sau đây là thết lập kết nối TCP đơn giản:set tcp [new Agent/TCP] ; # create tcp agent$ns_ attach-agent $node_(s1) $tcp ; # bind src to node$tcp set fid_ 0 ; # set flow ID fieldset ftp [new Application/FTP] ; # create ftp traffic$ftp attach-agent $tcp ; # bind ftp traffic to tcp agentset sink [new Agent/TCPSink] ; # create tcpsink agent$ns_ attach-agent $node_(k1) $sink ; # bind sink to node$sink set fid_ 0 ; # set flow ID field$ns_ connect $ftp $sink ; # active connection src to sink$ns_ at $start-time "$ftp start" ; # start ftp flow

2.Unicast Routing

2.1 The Interface to the Simulation Operator (The API)Kịch bản giả lập cấp độ người sử dụng đòi hỏi một lệnh để đặc tả đinh tuyến unicast hay

các giao thức cho mô phỏng.Một kế hoạch định tuyến chính là một cơ chế tổng quan trong đó NS sẽ tính toán các đường đi trong bộ mô phỏng.Có 4 cơ chế routing trong NS :Static, Session, Dynamic và Manual. Ngược lại, một giao thức định tuyến là một sự thực hiện của một thuật toán đặc biệt.Thông thường Static và Session routing dùng thuật toán Dijkstra để tìm đường đi ngắn nhất;Còn cơ chế dynamic routing dùng thuật toán Bellman-Ford phân tán.trong NS, thường không có sự khác biệt rõ ràng giữa cơ chế và thuật toán cho static và session routing, thường quy về giao thức.

- rtproto{}: là phương thức trong lớp: class Simulator đặc tả giao thức unicast routing dược dùng trong mô phỏng.Nó có nhiều tham số: đầu tiên là ID của giao thức routing, tiếp theo là



tham số đặc tả các node sẽ chạy trong instance của giao thức này.Mặc định là chạy cùng một giao thức routing trong tất cả các node trong tô pô mạng.Ví dụ về lệnh rtproto{} như sau:

$ns rtproto Static ;# Enable static route strategy for the simulation$ns rtproto Session ;# Enable session routing for this simulation$ns rtproto DV $n1 $n2 $n3 ;# Run DV agents on nodes $n1, $n2, and $n3$ns rtproto LS $n1 $n2 ;# Run link state routing on specified nodes

Nếu NS không thực hiện rtproto{}, nó sẽ thực hiện chạy Static routing trên tất cả các node.

Nhiều dòng rtproto{} cho cùng hay các giao thức routing khác nhau có thể xảy ra trong một kịch bản mô phỏng.Tuy nhiên một mô phỏng không thể dùng cả hai cơ chế routing tập trung như static hay session routing và các giao thức định tuyến động được mô tả hóa như DV.Trong dynamic routing, mỗi node có thể được chạy nhiều hơn một giao thức routing, khi đó nhiều hơn một giao thức sẽ có một đường định tuyến tới cùng một đích.Do đó, mỗi giao thức sẽ thêm vào một gía trị tham chiếu tới mõi đường định tuyến.Đây là các giá trị không âm trong dải 0. . . 255.Các giá tri thấp hơn sẽ được ưu tiên hơn.Khi các agent giao thức định tuyến có nhiều hơn một đưwngf đi tới cùng đích, đường được chọn sẽ được cài đặt vào bảng forwarding table của node.Ta gọi đường định tuyến có cost thấp nhất là “candidate” route.Nếu có nhiều candidate route từ cùng một hay nhiều giao thức khác nhau, một trong các đường của agent đó sẽ được chọn ngẫu nhiên.

Preference Assignment and Control: Mỗi agent giao thức chứa một mảng các ưu tiên định tuyến rtpref_. Đó là một thành phần trên mỗi đích, được đánh chỉ mục bởi node.Giá trị ưu tiên mặc định đươc dùng bởi mỗi giao thức xuất phát từ một biến lớp preference_ cho mỗi giao thức, mặc định là :Agent/rtProto set preference_ 200 ; # global default preferenceAgent/rtProto/Direct3 set preference_ 100Agent/rtProto/DV set preference_ 120

Một kịch bản mô phỏng có thể điều khiển định tuyến bằng cách biến đổi sự ưu tiên của đường định tuyến qua một trong 3 cách :

+ Biến đổi độ ưu tiên cho mỗi đường đi qua một protocol agent riêng biệt.+ Biến đổi độ ưu tiên mọi đường đi được học bởi agent,+ Biến đổi các biến lớp cho agent trước khi agent được tạo ra.

Link Cost Assignment and Control: Trong các giao thức định tuyến đươc thực hiện hiện tại,, metric của một đường đi tới đích của một node là cost để tìm thấy đích đó từ node.Có thể thay đổi cost của các link. Thủ tục instance cost{} được gọi giống như

$ns cost < node1> <node2> <cost> : Thiết lập giá của đường link từ node 1 tới node 2$ns cost $n1 $n2 10 ;# set cost of link from $n1 to $n2 to 10$ns cost $n2 $n1 5 ; # set cost of link in reverse direction to 5[$ns link $n1 $n2] cost? ; # query cost of link from $n1 to $n2[$ns link $n2 $n1] cost? ; # query cost of link in reverse direction

Chú ý rằng thủ tục thiết lập cost chỉ theo một hướng, tương tự , thủ tục cost?{} trả về giá trị cost của một liên kết vô hướng, có giá trị mặc định là 1.



2.2 Các cơ chế cấu hình khác cho Specialised RoutingCó thể chèn độ ưu tiên và các cơ chế cost để có hai loại cấu hình định tuyến: Định tuyến

không đối xứng và định tuyến đa hướng - multipath routing.Asymmetric Routing: Định tuyến không đối xứng xảy ra khi một đường dẫn từ node n1

tới node n2 khác đường đi từ node n2 đến node n1. Sau đây là ví dụ đơn giản cùng với cấu hình:

MultiPath Routing: Mỗi node có thể được cấu hình cục bộ để dùng nhiều đường đi riêng biệt . Biến instance multiPath_ xác định node đó sẽ dùng nhiều đường đi tới đích nào đó hay không.Mỗi node khởi tạo biến instance của nó từ một viến lớp cùng tên.Nếu có nhiều đường trỏ đến một đích được kích hoạt, mà tất cả chúng được học từ cùng một giao thức thì node có thể dùng tất cả các đường khác nhau đó đồng thời.Cấu hình điển hình như sau:

Node set multiPath_ 1 ; # All new nodes in the simulation use multiPaths where applicable

Cách khác:set n1 [$ns Node] ; # only enable $n1 to use multiPaths where applicable$n1 set multiPath_ 1

Hiện nay, chỉ có DV routing có thể hỗ trợ định tuyến đa hướng.

2.3 Các tham số cấu hình đặc tả giao thứcStatic Routing: Cơ chế tính toán định tuyến tĩnh là cơ chế mặc dịnh trong NS.Cơ chế này

dùng thuật toán tìm đường ngắn nhất Dijkstra’s all-pairs SPF algorithm.Thuật toán tính toán đường đi chạy chính xác một lần trước khi khởi tạo mô phỏng.Các đường đi được tính toán dùng ma trận gần kề và các cost của link trong tô pô mạng., (chú ý rằng định tuyến tĩnh là tĩnh trong việc phán đoán và được tính một lần khi bộ mô phỏng bắt đầu, trái với phiên làm việc và DV routing cho phép các đường đi thay đổi giữa quá trình mô phỏng.Nói cách khác static routing là Manual routing khi các đường đi không được tính toán nhưng thay vào đó được thiết lập (manually) bởi người sử dụng)

Session Routing Cơ chế static routing mô tả sớm hơn chỉ tính toán đường đi cho tô pô mạng một lần trong suốt quá trình mô phỏng, nếu định tuyến tĩnh được dùng và tô pô mạng thay đổi trong quá trình mô phỏng thì một số nguồn và đích có thể không được xác định trong một thời gian ngắn.Cơ chế Session routing hầu như giống hệt static routing, trong việc chạy thuật toán Dijkstra all-pairs SPF trước khi chạy mô phỏng, dùng ma trận kề bên và cost của link trong tô pô mạng.Tuy nhiên, nó cũng chạy cùng giao thức đó để tính toán lại đường đi mõi khi tô pô mạng thay đổi trong lúc mô phỏng.Nói cách khác, việc tính toán lại đường đi và khôi phục lại được thực hiện tức thời và không bị lệch cấu hình như static routing.Session routing cung cấp sự thay đổi định tuyến ngay lập tức và hoàn chỉnh với tô pô động.Nếu tô pô luôn luôn được kết nối, đó là các kết nối điểm- điểm tại bất cứ lúc nào trong quá trình mô



phỏng.Tuy nhiên người sử dụng nên biết rằng sự tính toán lại đường đi ngay lập tức sẽ không ngăn chặn các tác động tạm thời có nguyên nhân như sắp xếp lại các gói tin, đặc biệt là thời gian ngắn xung quanh sự thay đổi tô pô.

DV Routing: DV routing là sự thực hiện của thuật toán Distributed Bellman-Ford (Distance Vector) routing trong NS.Nó gửi các cập nhật định tuyến định kỳ sau khoảng thời gian advertInterval.Biến này là biến class trong lớp Agent/rtProto/DV. Nó có giá trị mặc định là 2 giây.Thêm vào đó để câp nhật định kỳ, mỗi agent cũng phải gửi các cập nhật nhanh triggered update;Chúng thực hiện điều này khi các bảng forwarding table trong node thay đổi, xảy ra dựa vào sự thay đổi tôpô hay vì một agent tại một node nhận một cập nhật định tuyến, và tính toán lại, thiết lập lại node mới.Mỗi agent sử dụng cơ chế split horizon với poisoned reverse để quảng bá các đường định tuyến của nó tới các node đồng đẳng gần kề.“Split horizon” là cơ chế trong đó agent không quảng bá đường định tuyến ra ngoài giao diện mà nó đến.Trong cơ chế “Split horizon with poisoned reverse”, agent sẽ quảng bá đường định tuyến ra ngoài giao diện đó với metric tới hạn.Mỗi DV agent dùng một giá trị ưu tiên mặc định là preference_ = 120.Giá trị này được xác định bằng một biến lớp cùng tên.Mỗi agent dùng biến lớp INFINITY (thiết lập là 32) để xác định sự hợp lệ của đường định tuyến..

Manual Routing: Manual routing không phải là một giao thức tính toán đưòng đi, chỉ đơn giản là một cách cho người sử dụng cấu hình bảng routing table bằng tay, chỉ cần đánh lệnh “route” trên workstation.

Để dùng manual routing, kích hoạt nó với rtproto, sau đó thiết lập mỗi node một bảng routing table với lệnh add-route-to-adj-node .Ví dụ:

$ns rtproto Manualset n1 [$ns node]set n2 [$ns node]$ns duplex-link $n1 $n2 10Mb 100ms DropTail$n1 add-route-to-adj-node -default $n2$n2 add-route-to-adj-node -default $n1

2.4 Đặc tính và kiến trúc của RoutingSau đây là mô tả về các giao diện giữa unicast routing và network dynamics, cũng như

giữa unicast và multicast routing.2.4.1 Các lớp:

Có 4 lớp chính:RouteLogic,rtObject,rtPeer, và lớp cơ sở Agent/rtProto cho tất cả các giao thức.Thêm vào đó, cấu trúc routing mở rộng thêm các lớp Simulator, Link, Node và Classifier.

Lớp RouteLogic: Lớp này đinh nghĩa hai phương thức cấu hình unicast routing,và một phương thức để truy vấn nó cho thông tin định tuyến.Nó cũng định nghĩa một thủ tục instance có thể dùng được khi tôpô là động._

• Thủ tục instance register{} được gọi bởi Simulator::rtproto{}.Nó đặt giao thức và một danh sách các node như các đối số, và xây dựng một biến instance,



rtprotos_, là một mảng, chỉ mục mảng này là tên của giao thức, và giá trị là danh sách các node sẽ chạy giao thức này.

• Configure{} đọc biến instance rtprotos_ , và với mỗi thành phần trong mảng, gọi các phương pháp giao thức định tuyến để thực hiện khởi tạo thích hợp.Nó được gọi bởi bộ mô phỏng chạy thủ tục.

Với mỗi giao thức (rt-proto) được đánh chỉ mục trong mảng rtprotos_ , chu trình này gọi Agent/rtProto/<rt-proto>init-all rtprotos_(<rt-proto>).

Nếu không có thành phần nào trong rtprotos_, chu trình gọi Static routing, như Agent/rtProto/Static init-all.Thủ tục instance lookup{} tạo hai số node.nodeId1 và nodeId2 làm các đối số.Nó trả về ID của các node hàng xóm mà nodeId1 dùng để tìm nodeId2 .

Thủ tục được dùng bởi thủ tục tính toán định tuyến tĩnh để truy vấn các đường định tuyến đã được tính và xác định các đường định tuyến tại mỗi node Nó cũng được dùng bởi các giao thức routing multicast để thực hiện kiểm tra RPF thích hợp.Chú ý rằng thủ tục này overload một instproc-like cùng tên.Thủ tục truy vấn các thực thể rtObject thích hợp nếu chúng tồn tại., nói cách khác, thủ tục gọi instproc-like để đạt được các thông tin liên quan.

Lớp rtObject được dùng trong sự mô phỏng dùng định tuyến động.Mỗi node có một rtObject tương ứng với chúng, hoạt động như một điều phối viên cho các giao thức được thực hiện tại một node.Với node nào đó, rtObject ở node đó theo dõi mỗi giao thức chạy trên node đó.Nó tính toán và thiết lập đường đi đói với mỗi đích đến qua mỗi một giao thức.Khi sự kiện thay đổi bảng routing, hay thay đổi tôpô xảy ra, rtObject sẽ cảnh báo các giao thức để có hành động thích hợp..

Lớp định nghĩa thủ tục init-all{};Thủ tục này tạo một danh sách các node như các đối số, và tạo một rtObject tại mỗi một node trong danh sách đối số của nó.Tiếp theo nó sẽ gọi các đường định tuyến compute-route của nó .Việc chấp nhận rằng constructor đối với mỗi một đối tượng mới sẽ thuyết minh giao thức định tuyến “Direct” tại mỗi một trong các node này.Giao thức định tuyến này chịu trách nhiệm tính toán đường đi tới các hàng xóm gần kề.Khi compute-routes{} được chạy bởi thủ tục init-all{} Các đường định tuyến trực tiếp này sẽ được thiết lập trong node bởi các đối tượng định tuyến thích hợp..

Các thủ tục instance khác trong lớp này là :+ init{} Là constructor thiết lập các con trỏ pointer từ bant thân tới node, trong biến

instance node_ của nó,và từ node tới bản thân, thông qua thủ tục instance Node init-routing{} và biến instance Node rtObject_.Sau đó nó sẽ khởi tạo một mảng nextHop_, rtpref_, metric_, rtVia_. Chỉ mục của mỗi bảng này là handle của node đích.nextHop_ chứa link sẽ được sử dụng để tìm đích đén tương ứng, rtpref_ và metric_ là mức ưu tiên và metric cho đường định tuyến được càiđặt trên node;rtVia_ là tên của agent mà đường định tuyến của nó được cài đặt trên node.

Constructor cũng tạo ra một instance của giao thức định tuyến trực tiếp, và gọi compute-routes{} cho giao thức đó.

+ add-proto{} tạo một instance của giao thức, chứa một tham chiếu tới nó trong mảng các giao thức, rtProtos_. Chỉ mục của mảng là tên của giao thức .Nó cũng gắn đối tưọng giao thức vào node, và trả về handle của đối tượng giao thức.



+ lookup{} tạo một handle node đích, và trả về ID của node hàng xóm được dùng để tìm kiếm đích. Nếu nhièu đường có thể được dùng, nó sẽ trả về danh sách các node hàng xóm sẽ được dùng.Nếu node không có đường nào đến đích thì thủ tục trả về giá trị -1.

+ compute-routes{} là thủ tục cơ bản của lớp này, nó kiểm tra lần đầu để thấy nếu giao thức nào ở node tính toán đường đi.Nếu có, nó sẽ xác định đường đi tốt nhất cho mỗi đích đến giữa các giao thức.Nếu một vài đường đi thay đổi, thủ tục sẽ báo tin giao thức của số thay đổi đó trong trường hợp các giao thức này muốn gửi một cập nhật mới.Cuối cùng nó cũng thông báo cho một số các giao thức multicast rằng các bảng định tuyến unicast mới đã được tính toán.Chu trình kiểm tra biến instance của agent, rtsChanged_ để nhận ra nếu một vài đường định tuyến trong giao thức đó có sự thay đổi so với lần kiểm tra cuối cùng.Nó dùng các mảng biến instance của giao thức,nextHop_,rtpref_,và metric_ để tính toán các mảng của nó. rtObject sẽ được thiết lập hay thay đổi một vài đường định tuyến khi sự thay đổi được tìm thấy.Nếu ột số đưwngf định tuyến tại node thay đổi,rtObject sẽ gọi các thủ tục instance của agent giao thức,send-updates{} với số lượng thay đổi là các đối số, nó sẽ gọi các đối tượng định tuyến multicast nếu chúng tồn tại.

Bước tiếp theo của chu trình được dùng để truy vấn rtObject cho các thông tin trạng thái đa dạng.+ dump-routes{} coi file mô tả output như một đối số và viết bảng routing table tại node

đó.+ rtProto?{} coi một giao thức route như đối số, và trả về một handle tới instance của

giao thức đang chạy trên node.+ nextHop?{} nắm bắt handle node đích, và trả về link dã được sử dụng để tìm đến đích.

Tương tự, rtpref?{} và metric?{} nắm bắt handle node đích như đối số và trả về độ ưu tiên và metric của đường đi tới đích được cài trên node.

Lớp rtPeer: là một lớp bao chứa được dùng bởi các agent giao thức.Mỗi đối tượng chứa địa chỉ của agent tương đương, và độ ưu tiên, metric đối với mỗi đường đi được quảng bá bởi agent đồng đẳng đó.Một agent giao thức sẽ chứa một đói tượng tương ứng.Lớp lưu giữ biến instance addr_, và các mảng biến instance , metric_ và rtpref_; Chỉ mục bảng là các handle của node đích..

Các thủ tục instance lớp : metric{} và preference{}, xác định một đích đến và giá trị, thiết lập biến mảng tương ứng.Các thủ tục metric?{} và preference?{}, xác định một đích đến và trả về giá trị hiện hành cho đích đó.Thủ tục instance addr?{} trả về địa chỉ của agent đồng đẳng.

Lớp Agent/rtProto Lớp này là lớp cơ sở từ đó bắt nguồn tất cả các agent giao thức định tuyến Mỗi agent giao thức phải định nghĩa procedureinit-all{} để khởi tạo giao thức hoàn chỉnh, và các thủ tục instance init{},compute-routes{}, và send-updates{}. Thêm vàođó, nếu tô pô là động và giao thức hỗ trợ tính toán đường đi tác động lại sự thay đổi tô pô, sau đó giao thức định nghĩa thủ tục compute-all{}, và thủ tục instance intf-changed{}.

+ Thủ tục init-all{} là thủ tục khởi tạo toàn cục cho lớp, nó có thể được đưa ra một danh sách các node như các đối số.Đây là danh sách các node chạy giao thức routing này.Tuy nhiên, các giao thức routing trọng tâm như static và session routing sẽ sửa chữa đối số này, mô tả các giao thức routing động như DV sẽ dùng danh sách tham số này để khởi tạo các agent giao thức tại mỗi node.

Chú ý rằng các lớp bắt nguồn từ OTcl không thừa kế các thủ tục định nghĩa trong lớp cơ sở.Do đó mọi lớp giao thức được bắt nguồn phải định nghĩa các thủ tục của nó một cách rõ ràng.



+ Thủ tục instance init{} là cơ sở cho các agent giao thức được tạo ra,Constructor lớp cơ sở khởi tạo độ ưu tiên mặc định cho các đối tượng trong lớp này, ID các giao diện trên các node và trạng thái hiện tại của chúng.Các giao diện được đáh chỉ mục bởi handle hàng xóm và chứa trong mảng biến instance, ifs_; Mảng biến instance trạng thái tương ứng là ifstat_.Các giao thức định tuyến trọng tâm hóa như static và session routing không tạo các agent riêng biệt trên các node, và do đó không truy cập thủ tục instance nào.

+ Thủ tục instance compute-routes{} tính toán đường đi thực sự đối với giao thức.Sự tính toán dựa trên các đường định tuyến học bởi giao thức và sự biến đổi từ giao thức tới giao thức.Chu trình này đựoc gọi bởi rtObject khi tô pô thay đổi, và cũng được gọi khi node nhận một cập nhật.

Nếu chu trình tính toán đường đi mới, rtObject::compute-routes{} cần để được triệu gọi để tính toán lại và cài đặt đường định tuyến mới tại node.Sự triệu gọi thực sự của rtObject được thực hiện bởi thủ tục gọi chu trình này lần đầu tiên.

+ Thủ tục instance send-updates{} được gọi bởi rtObject khi các bảng routing thay đổi.và cập nhật mới đưwcj gửi đi các node.

Thủ tục này cũng có thể được gọi khi không có sự thay đổi nào về đường định tuyến nhưng tô pô gắn liền với node thay đổi trạng thái.Số lượng thay đổi đwocj dùng để xác định danh sách các node đồng đẳng mà thông tin cập nhật phải được gửi.

Các mở rộng khác cho Simulator, Node, Link, and Classifier— Ta đã xét các phương thức rtproto{} và cost{} trong lớp Simulator .Một phương thức khác dùng trong đó là get-routelogic{}; Thủ tục này trả về instance của routelogic trong mô phỏng.Phương thức đưwcj dùng bởi lớp Simulator, unicast và multicast routing.—Lớp Node chứa các thủ tục instance thêm vào này để hỗ trợ dynamic unicast routing: init-routing{},add-routes{}, delete-routes{}, và rtObject?{}.

+ Thủ tục instance init-routing{} được gọi bởi rtObject tại node.Nó chứa một con trỏ tới rtObject, trong biến instance của nó: rtObject_, cho sự vận động hay thu hồi sau đó.Nó cũng kiểm tra biến lớp của nó để thấy nếu dùng multiPath routing, và thiết lập một biến instance tới tác động này..Nếu multiPath routing có thể được dùng, mảng biến instance routes_ chứa một lượng các đường dẫn đươc cài trên mỗi một đích đến.Đây chỉ là mảng trong unicast routing được đánh chỉ mục bởi ID của node,hơn là node handle.

+ Thủ tục instance rtObject?{} trả về rtObject handle cho node đó.+ Thủ tục instance add-routes{} tạo một node id, và một danh sách các link.Nó sẽ

thêm vào danh sách các link như các đường định tuyến để tìm đến đích được xác nhận bởi node id.Sự thực hiện của multiPath routing được xác định bởi một Classifier/multiPath riêng biệt.Với một số đích đến có ID d, nếu node này có nhiều đường tới d, và classifier chính trỏ tới multipath classifier này thay cho link để tìm đường tới đích.Mỗi multiple path được xác nhận bởi các giao diện được dùng để cài đặt trong multipath classifier.Multipath classifier sẽ dùng mỗi một link cài trên nó để chuyển tiếp thành công các gói tin tới nó.

+ Thủ tục instance delete-routes{} nắm một node id,một danh sách các giao diện và một ullAgent. Nó sẽ xóa mỗi giao diện trong danh sách, nếu cổng vào trước đó không dùng một multipath classifier,sau đó chỉ có một đường định tuyến, và cổng vào đường đi được thiết lập để trỏ tới nullAgent

2.4.2 Interface to Network Dynamics and Multicast



Sự hồi đáp của việc thay đổi tô pô đwocj xét theohaichủ đề: Các hoạt động xảy ra bởi các agent cục bộ tại mỗi node và các hoạt động bởi toàn thể giao thứcCác giao thức routing chi tiết như DV thực thi đòi hỏi các hoạt động được thực hiện bởi các agent giao thức cục bộ tại node đang xét..Hoạt dộng tại các node cục bộ Sau đây là một số thay đổi trong tô pô, các mô hình mạng động sẽ được gọi đầu tiên.

rtObject::intf-changed{} : Ở mỗi một node ảnh hưởng, với mỗi một giao thức định tuyến unicast được thực hiện taị node đó, rtObject::intf-changed{} sẽ gọi thủ tục instance của giao thức cục bộ, intf-changed{}, theo sau bởi thủ tục compute-routes{} của giao thức .sau khi mỗi giao thức được tính các đường định tuyến của nó rtObject::intf-changed{} sẽ gọi compute-routes{} để có thể cài các đường định tuyến mới.Nếu các đường định tuyến mới đã được thiết lập, rtObject::compute-routes{} sẽ gọi send-updates{} chomoix giao thức được thực hiện trên node.Thủ tục cũng thiết lập cờ đối tượng định tuyến multicast của đwngf định tuyến thay đổi trên node, xác định số lượng thay đổi đã được thực hiện.

rtObject::flag-multicast{} sẽ thông báo đối tượng định tuyến multicast để tạo hành động thích hợp.Một ngoại lệ cho giao diện giữa unicast và multicast là sự tương tác giữa multicast cơ chế dày đặc động - dynamic dense mode và định tuyến unicast chi tiết - detailed unicast routing. Sự thực hiện DM động trong NS coi node hàng xóm sẽ gửi cập nhật ngầm khi nào đường định tuyến thay đổi.mà không gửi bản cập nhất thật sự.Sau đó nó dùng thông tin để tính toán quan hệ cha-con thích hợp cho multicast spanning trees.Vì thế, detailed unicast routing sẽ gọi rtObject_ flag-multicast 1 khi nào nó nhận một cập nhật định tuyến , thậm chí khi cập nhật không biểu hiện trong bảng routing table của nó.

Hoạt động toàn cục : Mỗi lần hoạt động chi tiết tại các node ảnh hưởng được hoàn thành, các mô hình mạng động sẽ báo hiệu RouteLogic instance (RouteLogic::notify{}) của các sự thay đổi tới tô pô.Thủ tục này sẽ gọi thủ tục compute-all{} đối với mỗi giao thức được cài tại các node.Các giao thức định tuyến tập trung như session routing dùng tín hiệu này để tính toán lại các đường định tuýến tới tô pô.Cuối cùng thủ tục RouteLogic::notify{} sẽ báo hiệu một vài instance của centralized multicast sẽ được thực hiện tại node đó.

2.5 Protocol InternalsDirect Routing: Giao thức này ghi lại trạng thái của liên kết gắn liền và duy trì các

đường định tuyến ngay lập tức tới các hàng xóm gần kề.Với các gikhác, nó duy trì các mảng biến instance nextHop_, rtpref_, và metric_, được đánh chỉ mục bởi handle của mỗi đích đến có thể trong tô pôThủ tục instance compute-routes{} tính toán đường đi dựa trên trạng thái hiện thời của link, và trạng thái trước đó của link gắn với nó.Không có thủ tục hay thủ tục instance khác được định nghĩa trong giao thức này.

Static Routing Thủ tục compute-routes{} trong lớp RouteLogic đầu tiên tạo ra ma trận gần kề, và sauđó gọi các phương thức C++, compute_routes() của đối tượng.Cuối cùng, thủ tục khôi phục lại kết quả tính toán định tuyến tại mỗi node trong tô pô..

Session Routing: Lớp định nghĩa thủ tục init-all{}để tính toán dường đi khi khởi tạo mô phỏng.Nó cũng định nghĩa thủ tục compute-all{} để tính toán các đường đi khi tô pô thay đôi.Mỗi thủ tục này sẽ gọi trực tiếp compute-routes{}.



DV Routing: Trong một cơ chế định tuyến động, các node gửi và nhận các thông điệp, và tính toán đường đi trong tô pô dựa trên trao đổi thông điệp.Thủ tục init-all{} tạo một danh sách node làm tham số, mặc định là danh sách node trong tô pô.Tại mỗi một node thủ tục khởi tạo lớp rtObject và các agent lớp Agent/rtProto/DV .Nó xác định các DV đồng đẳng với mỗi agent DV được tạo ra. Và tạo các đối tượng rtPeer liên quan..Constructor cho agent DV khởi tạo một số các biến instance, mỗi agent chứa một mảng được đánh chỉ mục bởi handle của node đích, của độ ưu tiên, metric, giao diện (hay link) tới next hop, và các node ở xa, với đường đi tốt nhất cho mỗi đích đến được tính toán bởi các agent .agent tạo ra các biến instance và lập lịch gửi cập nhật đầu tiên trong 0.5 giây đầu tiên khi khởi động mô phỏng..

Mỗi agent chứa danh sách các đồng đẳng được chỉ ra bởi handle của node dồng đẳng.Mỗi peer là một cấu trúc đồng đẳng riêng biệt nắm giữ địa chỉ của agent đồng đẳng, metric và độ ưu tiên của đường đi tới đích được quảng bá bởi agent đó.Cấu trúc peer được khởi tạo bởi thủ tục add-peer{} được gọi bởi init-all{}.

Chu trình send-periodic-update{} gọi send-updates{} để gửi cập nhật thực tế, nó đặt lại lịch gửi bản cập nhật tiếp theo sau khi advertInterval để chống lại sự đồng bộ có thể.ảnh hưởng send-updates{} sẽ gửi các bản cập nhật tới tập các peer đã chọn, nếu mọt vài đường thay dổi hay không cạp nhật định kỳ, thủ tục sẽ gửi cập nhật tới tất cả các peer.Nói cách khác, néu vài link được lấy lại, thủ tục sẽ gửi cạp nhật tới peer sát đó chỉ gắn với link.send-updates{} Dùng thủ tục send-to-peer{} để gửi các câph nhật thực tế, thủ tục này sẽ đóng gói các cập nhật, dùng cơ chế split-horizon and poison reverse .Nó gọi instproc-like, send-update{}để gửi cập nhật.Cập nhật thực tế được chứa trong biến lớp msg_ được đánh chỉ mục bởi số nguyên không giảm.instproc-like chỉ gửi msg_ tới peer ở xa. Điều này loại trừ sự cần phải chuyển đổi từ xâu OTcl xang dạng định dạng khác.Khi một peer nhận một cập nhật, đầu tiên nó sẽ kiểm tra nếu cập nhật có khác trước không.Agent sẽ tính toán đường định tuyến mới nếu bản cập nhật có thông tin mới

2.6 Các đối tượng Unicast routing Routelogic và rtObject là hai đối tượng quan trọng đối với unicast routing trong NS.

Routelogic,về cơ bản sẽ mô tả bảng routing được tạo ra và duy trì với mọi mô phỏng unicast. rtObject là đối tượng mà mọi node có trong định tuyến unicast độn, có một instance.Chú ý rằng không có instance của dối tượng này nếu Session routing được chạy như một detailed routing protocol khong được mô phỏng trong trường hợp này.

2.7 Tỏng quan các lệnhSau đây là danh sách các lệnh về unicast routing được dùng trong kịch bản mô phỏng:

$ns_ rtproto <routing-proto> <args>

Với <routing-proto> định nghĩa loại giao thức routing như Static, Manual, Session , DV.Các đối số args có thể định nghĩa danh sách các node mà giao thức routing chạyCác phương thức bên trong:

$ns_ compute-routes: Tính toán thông tin next_hop cho tất cả các node dùng kết nối tô pô.Thông tin next_hop này sau đó được sử dụng để tính các node classifier hay các bảng routing . compute-routes triệu gọi calls compute-flat-routes hay compute-hier-routes dựa vào loại địa chỉ được dùng trong mô phỏng.



$ns_ get-routelogic : Trả về một handle tới đối tượng RouteLogic object (the routing table),nếu một đối tượng được tạo ra.Nói cách khác một đối tượng bảng routing sẽ được tạo ra

$ns_ dump-routelogic-nh : Kết xuất ra thông tin nexthop trong bảng routing table..$ns_ dump-routelogic-distance Kết xuất ra thông tin khoảng cách trong bảng routing.$node add-route <dst> <Target>: Đây là một phương thức dùng để thêm vào các đầu

vào routing (thông tin nexthop) trong bảng routing table của node. Nexthop tới <dst> từ một node là đối tượng <target> và thông tin này sẽ được thêm vào classifier. của node

$routelogic lookup <srcid> <destid>: Trả về ID của node là nexthop từ node với ID nguồn tới ID đích.

$routelogic dump <nodeid>: Kết xuất các bảng routing table của tất cả các node với ID nhỏ hơn nodeid.Các node id được gán cho các node tăng dần bắt đầu từ 0 theo thứ tự tạo ra.rtobject dump-routes <fileID> Kết xuất bảng routing table ra kênh ngoài được xác định theo fileID. fileID phải là một file handle trả vè bởi lệnh Tcl open và phải được mở khi hoạt động..

$rtobject rtProto? <proto> Trả về một handle để routing protocol agent specified by proto if it exists at that node. Returns an empty string otherwise.

$rtobject nextHop? <destID> Trả về ID của node mà next hop tới đích đặc đặc tả bởi node id, <destID>.

$rtobject rtpref? destID : Trả về độ ưu tiên của đường định tuyến tới node đích được cho bởi destid.

$rtobject metric? destID: Trả về metric cho đường định tuyến tới destid.

3.Multicast Routing

3.1 Multicast APIMulticast forwarding yêu cầu sự cải tiến các node và link trong tô pô.Do đó, người sử

dụng phải định rõ các yêu cầu multicast tới lớp Simulator trước khi tạo ra tô pô>Sau đây là một trong hai cách:

set ns [new Simulator -multicast on]hayset ns [new Simulator]$ns multicast

Khi các mở rộng multicast được kích hoạt, các node sẽ được tạo ra với các classifiers và các replicators thêm vào cho multicast forwarding, và các link chứa các thành phần để gán nhãn giao diện vào cho các gói tin vào một node.

Một cơ chế multicast routing là cơ chế trong đó cây phân tán multicast đwocj tính toán trong mô phỏng .NS hỗ trợ 3 cơ chế tính toán định tuyến multicast :centralised, dense mode(DM) hay shared tree mode(ST).

Phương thức mrtproto{} trong lớp Simulator đặc tả cơ chế tính toán định tuyến cho centralised multicast routing, hay giao thức định tuyến mô tả chi tiết đưowcj dùngSau đây là ví dụ khai báo hợp lệ cho multicast routing trong ns:

set cmc [$ns mrtproto CtrMcast] ; # specify centralized multicast for all nodes;# cmc is the handle for multicast protocol object

$ns mrtproto DM ; # specify dense mode multicast for all nodes$ns mrtproto ST ; # specify shared tree mode to run on all nodes



Trong ví dụ trên CtrMcast trả về một handle có thể đưqợc dùng dể thêm cấu hình của centralised multicast routing.Các giao thức routing khác sẽ trả về chuỗi Null.Tất cả các node trong tô pô sẽ chạy instance cả cùng một giao thức.Các giao thức định tuyến multicast có thể chạy trên một node, nhưng trong trường hợp này người dùng phải định rõ giao thức nào sẽ đi vào giao diện.Khi đó mrtproto-iifs{} được dùng.

Các địa chỉ mới, không dùng được định vị qua thủ tục allocaddr{}.Các agent dùng thủ tục instance join-group{} và leave-group{}, trong lớp Node để nhập và rời các nhóm multicast.Các thủ tục này có hia tham số bắt buộc, đầu tiên là các ID của agent tương ứng và tham số thứ hai xác định địa chỉ nhóm.Sau đây là một ví dụ cấu hình multicast

set ns [new Simulator -multicast on] ; # enable multicast routingset group [Node allocaddr] ; # allocate a multicast addressset node0 [$ns node] ; # create multicast capable nodesset node1 [$ns node]$ns duplex-link $node0 $node1 1.5Mb 10ms DropTailset mproto DM ; # configure multicast protocolset mrthandle [$ns mrtproto $mproto] ; # all nodes will contain multicast

protocol agentsset udp [new Agent/UDP] ; # create a source agent at node 0$ns attach-agent $node0 $udpset src [new Application/Traffic/CBR]$src attach-agent $udp$udp set dst_addr_ $group$udp set dst_port_ 0set rcvr [new Agent/LossMonitor] ; # create a receiver agent at node 1$ns attach-agent $node1 $rcvr$ns at 0.3 "$node1 join-group $rcvr $group" ; # join the group at simulation time 0.3 (sec)

3.1.1 Cấu hình giám sát Multicast NS hỗ trợ một module giám sát multicast có thể ghi vết các hoạt động gói tin do người

dùng định nghĩa.Module tính toán số lượng gói tin đi qua định kỳ và instance ra kết quả ra các file đặc tả.

attach{} kích hoạt một module giám sát để instance kết quả ra filetrace-topo{} ghép module giám sát vào các link filter{} cho phép tính toán các packet header, trường trong header và giá trị của trường đó.

Gọi filter{} lặp lại vớikết quả trong phép AND ở điều kiện lọcprint-trace{} Thông báo module giám sát để bắt đầu kết xuất dữ liệu. ptype() là một

mảng toàn cục với tên loại gói tin(xem trong đầu ra của trace-all{}) và ánh xạ tới giá trị tương ứng.Một cáu hình đơn giản để lọc các gói tin CBR trong nhóm như sau:

set mcastmonitor [new McastMonitor]set chan [open cbr.tr w] ; # open trace file$mmonitor attach $chan1 ; # attach trace file to McastMoniotor object



$mcastmonitor set period_ 0.02 ; # default 0.03 (sec)$mmonitor trace-topo ; # trace entire topology$mmonitor filter Common ptype_ $ptype(cbr) ; # filter on ptype_ in Common header$mmonitor filter IP dst_ $group ; # AND filter on dst_ address in IP header$mmonitor print-trace ; # begin dumping periodic traces to specified files

Sau đây là một ví dụ đàu ra minh họa định dạng file (time, count):0.16 00.17999999999999999 00.19999999999999998 00.21999999999999997 60.23999999999999996 110.25999999999999995 120.27999999999999997 12

3.1.2 Cấu hình đặc tả giao thức Centralized Multicast: centralized multicast là một cơ chế thực hiện rải rác của multicast

tương tự như PIM-SM .Một cây chia sẻ gốc - rooted shared tree Rendezvous Point (RP) đwocj xây dựng cho nhóm multicast.Việc gửi thực sự cũng như việc kết hợp thông điệp ,… để thiết lập trạng thái tại các node là không được mô phỏng.Một agent tính toán tập trung được dùng để tính toán cây forwarding và thiết lập trạng thái multicast forwarding,< S, G> ở các node liên quan khi những receiver mới gia nhập nhóm.Các gói tin dữ liệu từ sender tới nhóm là unicast đối với RP.Chú ý rằng các gói tin dữ liệu từ người gửi là unicast đối với RP thậm chí khi không có receiver đối với nhóm.

Phương thức kích hoạt centralised multicast routing trong mô phỏng là:

set mproto CtrMcast ; # set multicast protocolset mrthandle [$ns mrtproto $mproto]

Thủ tục lệnh mrtproto{} trả về một handle tới đối tượng multicast protocol .Handle này có thể được dùng để điều khiển RP và boot-strap-router (BSR),chuyển đổi các loại tree-types cho một nhóm, từ các cây chia sẻ cho đến các cây đặc tả nguồn và tính toán lại đường định tuyến multicast

$mrthandle set_c_rp $node0 $node1 ; # set the RPs$mrthandle set_c_bsr $node0:0 $node1:1 ; # set the BSR, specified as list of

node:priority$mrthandle get_c_rp $node0 $group ; # get the current RP ???$mrthandle get_c_bsr $node0 ; # get the current BSR$mrthandle switch-treetype $group ; # to source specific or shared tree$mrthandle compute-mroutes ; # recompute routes. usually invoked

automatically as neededChú ý rằng khi nào mạng thay đổi hay unicast routing thay đổi,compute-mroutes{} có thể

được gọi để tính toán lại multicast routes. Tính năng tính toán lại ngay lập tức của các thuật toán tập trung có thể dẫn đến kết quả ngay trong hời gian định kỳ ngắn.

Dense Mode: giao thức Dense Mode (DM.tcl) là một sự thực thi của giao thức dense–mode–like .Dựa vào giá trị của biến lớp DM CacheMissMode nó có thể chạy trong một hay hai



chế độNếu CacheMissMode được thiết lập là pimdm (mặc định ), PIM-DM giống như luật forwarding sẽ được dùng.Như một lựa chọn, CacheMissMode cóthể được thiết lập là dvmrp (dựa vào DVMRP]). Sự khác nhau chính gữa hai phương thức là DVMRP duy trì quan hệ cha-con giữa các node để giảm số link khi các gói tin dữ liệu được quảng bá.Sự thực thi trên liên kết point-to-point như LAN và thích hợp với sự linh động của mạng (Các link up và down).Một vài node nhận dữ liệu cho một nhóm cụ thể không có các downstream receiver,gửi một prune upstream. Một prune message gây ra upstream node để khởi tạo trạng thái prune ở node đó.Trạng thái prune ngăn chặn node dó gửi dữ liệu xuôi xuống cho nhóm đó tới node đã gửi thông điệp prune ban đầu trong khi trạng thái đang hoạt động.Trong khoảng thời gian mà trạng thái prune được kích hoạt, được cấu hình thông qua biến lớp DM, PruneTimeout.

Một cấu hình DM điển hình như sau:DM set PruneTimeout 0.3 ; # default 0.5 (sec)DM set CacheMissMode dvmrp ; # default pimdm$ns mrtproto DM

Shared Tree Mode Là chế độ đơn giản ST.tcl, là một phiên bản của giao thức multicast câychia sẻ - shared–tree multicast protocol. Mảng biến lớp RP_ được đánh chỉ mục bởi nhóm xác định trong đó node là RP đối với nhóm.Ví dụ:

ST set RP_($group) $node0$ns mrtproto ST

Khi mô phỏng multicast được khởi tạo, giao thức được tạo ra và cài đặt dóng gói các đối tượng tại node có các multicast sender, mở gói các đối tượng tại các RP và kết nối chúng.Để tham gia một nhóm, một node gửi một thông điệp graft tới RP của nhóm.Để rời khỏi nhóm, nó gửi mộtthông điệp prune message. Giao thức hiện nay không hỗ trợ sư thay đổi động và các LAN.

Bi-directional Shared Tree Mode BST.tcl là một phiên bản của bi–directional shared tree protocol. Khi ở chế độ cây chia sẻ, các RP phải được cấu hình bằng cách dùng mảng lớp RP_.Giao thức hiện nay không hỗ trợ sư thay đổi động và các LAN

3.2 Internals of Multicast Routing3.2.1 The classes

Các lớp chính trong sự thực thi là lớp mrtObject và McastProtocol. Đây là các phần mở rộng dựa trên các lớp cơ sở: Simulator, Node, Classifier, ... Các giao thức đặc tả cũng dùng cấu trúc dữ liệu thêm vào cho các tác vụ đặc biệt, như các cơ chế bộ đếm thời gian bởi chế độ detailed dense mode, các agent đóng gói /mở gói cho multicast tập trung,…;

mrtObject class Đây là một đối tượng mrtObject (aka Arbiter) trên mỗi node có khả năng multicast .Đối tượng này hỗ trợ khả năng một node chạy các giao thức định tuýen multicast bằng cách giữ một mảng các giao thức multicast được đánh chỉ mục bởi các giao diện đi vào. Do đó, néu có nhiều giao thức multicast trên một node, mỗi giao diện sẽ được làm chủ bởi chỉ một giao thức .Khi đó đối tượng này hỗ trợ khả năng một node chạy nhiều giao thức định tuyến multicast .Node dùng một trọng taì để thực hiện hoạt động giao thức, cũng vậy đối với một instance giao thức đặc tả tại node đó, hay tất cả các instance giao thức tại ndoe đó.



addproto{instance, [iiflist]} thêm handle cho instance giao thức tới mảng giao thức của nó. Tham số lựa chon thứ hai là danh sách giao diện đi vào được điều khiển bởi giao thức .Nếu tham số này là danh sách rỗng thì giao thức sẽ được cho rằng chạy trên tất cả các giao diện.(chỉ một giao thức ).

getType{protocol} Trả về handle ới instance giao thức kích hoạt tại node đó Chức năng này thường được dùng để định vị sự tương đương tại các node khác.Một xâu rỗng sẽ được trả về nếu giao thức không được tìm ra.

all-mprotos{op, args} Chu trình bên trong để thực hiện “op” với “args” trên tất cả các instance giao thức kích hoạt tại node đó.

start{} stop{} Khởi tạo và dừng sự thực hiện của tất cả các giao thức notify{dummy} : Được gọi khi tô pô thay đổi.Đối số dummy hiện không được dùng.dump-mroutes{file-handle, [grp], [src]} Kết xuất các đường định tuyến multicast tới

file-handle.join-group{G, S} Đánh dấu tất cả các instance giao thức gia nhập < S, G>leave-group{G, S} Đánh dấu tất cả các instance giao thức loại bỏ < S, G>upcall{code, s, g, iif} Đánh dấu bởi node trên lỗi forwarding errors trong

classifier;chu trình này bật các tín hiệu instance giao thức làm chủ gao diện vào (iif) bởi việc triệu gọi chức năng handle thích hợp .

drop{rep, s, g, iif} Được gọi khi các gói tin mất.Có thể kích hoạt trạng thái prune trên giao diện

Thêm vào đó, lớp mrtObject hỗ trợ khái niệm các nhóm nỗi tiếng- well known groups,.. .,Các nhóm này không yêu cầu hỗ trợ giao thức rõ ràng.Hai nhóm tiêu biểu là ALL_ROUTERS và ALL_PIM_ROUTERS được định nghĩa trước trong NS.

Lớp mrtObject định nghĩa hai thủ tục lớp để thiết lập và lấy thông tin về các nhóm này, - registerWellKnownGroups{name} Đặt tên cho địa chỉ nhóm nổi tiếng - getWellKnownGroup{name} Trả về địa chỉ được đánh cho nhóm nổi tiếng,hay

tên .Nếu tên không được đăng ký như nhóm nổi tiếng - well known group, thì nó sẽ trả về địa chỉ ALL_ROUTERS.

McastProtocol class: Đây là lớp cơ bản cho sự thực hiện tất cả các giao thức multicast .Nó chứa các hàm multicast cơ bản:start{}, stop{} Thiết lập trạng thái status_ của instance giao thức getStatus{} Trả về trạng thái thực hiện instance giao thức này.getType{} Trả về loại của giao thức được thực hiện. bửi instance này..upcall{code args} Được triệu gọi khi các tín hiệu node classifier signals có lỗi, dựa vào cache-miss hay wrong-iif cho các gói tin đến.Chu trình này gọi protocol specific handle, handle-<code>{} với các tham số cho tín hiệu handle Multicast thực thi trong NS cho rằng dùng duplex links, nếu có một link đơn giản từ node 1 tới node 2,sẽ phải có một link ngược lại từ node 2 tới node 1 Có thẻ nói rằng với link nào nhận được gói tin, bộ mô phỏng multicast sẽ cấu hình link với một nhãn giao diện ở cuối mỗi link, với các nhãn gói tin là đơn nhất.Dó đó “incoming interface” được quy cho nhãn này và là một số >=0.Nhãn giao diện vào có thể là -1 trong trường hợp đặc biệt gói tin được gửi bởi một chi nhánh cục bộ tới agent node.

Ngược lại, một “outgoing interface” được quy cho một object handler, thường là một phần đầu của một link được cài tại một replicator.



3.2.2 Mở rông cho các lớp khác trong NSTa đã biết đầu vào của node đối với node multicast là switch_. Nó được xem ở bit cao

nhất để quyết định nếu đích là gói tin multicast hay unicast .Các gói tin multicast được forward tới một multicast classifier là nơi lưu giữ danh sách các replicator;Có một replicator trên một <source, group> tuple. Các replicator sao chép gói tin đến và forward tới tất cả các outgoing interface.

Class Node: Node hỗ trợ cho multicast theo hai cách chính : Nó đáp ứng như một tiêu điểm để truy cập các giao thức multicast, trong các vùng dánh địa chỉ, quản lý và điều khiển, và thứ hai là nó cung cấp điều khiển và truy cập các giao diện trên các link gắn với node đó.

expandaddr{},allocaddr{} Các thủ tục lớp cho việc quản lý địa chỉexpandaddr{} Hiện nay không dùng nữa allocaddr{} Định vị địa chỉ multicast tiếp theo có thể. start-mcast{},stop-mcast{} Khởi động và dừng multicast routing tại node đó .notify-mcast{} notify-mcast{} Ra tín hiệu cho mrtObject tại node đó để tính toán lại đường định tuyến multicast sau khi tô pô thay đổi hay đường unicast cập nhật từ hàng xóm.getArbiter{} Trả về một handle trỏ tới mrtObject thực hiện tại node đó..dump-routes{file-handle} Truy xuất các bảng multicast forwarding table tại node đó new-group{s g iif code} Khi một gói tin dũ liệu multicast được nhận, và multicast classifier không thể tìm thấy slot tương ứng với gói dữ liệu đó.Nó gọi Node nstproc new-group{} để thiét lập một cỏng vào thích hợp.join-group{a g} Một agent tại node gia nhập một nhóm , gọi “node join-group <agent> <group>”. Node phát tín hiệu mrtObject để gia nhập nhóm và thêm nó vào danh sách của các agent tại nhóm này.Sau đó nó thêm agent tới tất cả các replicator trong nhóm.leave-group{a g} Node instproc leave-group đảo nghịch quá trình được mô tả trước đó, vô hiệu hóa các outgoing interface để các receiver agent cho tất cả các replicator của nhóm, xóa các receiver agent từ danh sách cục bộ Agents_ ;Sau đó nó gọi trọng tài leave-group{} của instance.add-mfc{s g iif oiflist} Node instproc add-mfc thêm một đầu vào multicast forwarding cache cho nhóm đặc biệt <source, group, iif> Cơ chế là:

+ Tạo một replicator mới (nếu không có cái nào tồn tại ),+ Cập nhật mảng biến instance replicator_ tại node.+ Thêm tất cả các outgoing interface và local agent vào replicator thích hợp,+ Gọi add-rep{} của multicast classifier để tạo ra một khe slot cho replicator trong

multicast classifier.

del-mfc{s g oiflist} vô hiệu mỗi oif trong oiflist từ replicator với <s, g>

Danh sách các thành phần có thẻ sử dụng được tại node để điều khiển giao diện của nó được liệt kê dưới đây:add-iif{ifid link},add-oif{link if} Triệu gọi trong suốt qúa trình tạo link để chuẩn bị cho node về nhãn giao diện vào và các đối tượng giao diện ra..get-all-oifs{} Trả về tất cả oifs cho node này.



get-all-iifs{} Trả về tất cả các iifs cho node nàyiif2link{ifid} Trả về các đối tượng link được đặt nhãn với nhãn của giao diện .link2iif{link} Trả về nhãn giao diện đi vào cho link.oif2link{oif} Trả về đối tượng link tương ứng với outgoing interface.link2oif{link} Trả về outgoing interface cho link .rpf-nbr{src} Trả về một handle tới node hàng xóm mà next hop của nó là src.getReps{s g} Trả về một handle trỏ tới replicator so sánh với <s,g>, các tham số có thể là wildcard getReps-raw{s g} Như trên, nhưng trả về danh sách cặp <key, handle> clearReps{s g} Xóa tất cả các replicator cùng với <s,g>

Class Link and SimpleLink: Lớp này cung cấp các phương thức kiểm tra loại link, và nhãn nó được thêm vào trên gói tin cục bộ đi qua.Có một phương thức them vào đối tương giao diện trên link được gọi là if-label?{}

Class NetworkInterface Đây là một connector đơn giản được đặt trên link, nó thêm vào ID nhãn của nó vào mỗi gói tin đi qua.ID của gói tin được dùng bởi node đích gắn trên link đó để nhận ra link nào gói tin đang tìm đến. ID của nhãn được cấu hình bởi Link constructor.Đối tượng này là một đối tương bên trong, và không được thiết kế để vận hành bởi kịch bản mô phỏng cấ độ người dùng.Đối tượng này chỉ hỗ trợ hai phương thức:

+ label{ifid} gán ifid mà đối tượng này thêm vào cho mỗi gói tin+ label{} Trả về nhãn mà đối tượng này thêm vào mỗi gói tin..

Biến lớp toàn cục, ifacenum_,chỉ rõ số ifid có thể tiếp theo.

Class Multicast Classifier Classifier/Multicast duy trì một multicast forwarding cache. Có một multicast classifier trên mỗi node.Node chứa một tham chiếu tới classifier này trong biến instance multiclassifier_.Khi classifier này nhận một gói tin, nó sẽ kiẻm tra thông tin <source, group> trong packet headers,và giao diện mà gói tin xuất phát (incoming interface hay iif);Thực hiện kiểm tra trong MFC và nhận diện slot được dùng để forward gói tin đó.Khe slot sẽ chỉ tới một replicator thích hợp.

Tuy nhiên, nếu classifier không có đầu vào cho nhóm <source, group> này hay iif cho đầu vào khác, nó sẽ gọi thủ tục upcall new-group{} cho classifier,với một trong hai mã code để nhận ra vấn đề:_

+ cache-miss xác đinh rằng classifier không tìm thấy một đầu vào <source, group> nào+ wrong-iif chỉ ra rằng classifier tìm thấy đầu vào <source,group> nhưng không so sánh

được giao diện với gói tin này.

Class Replicator Khi một replicator nhận mọt gói tin , nó sao chép tới tất cả các khe slot của nó, mỗi slot trỏ tới một outgoing interface đói với mỗi < source, group> Nếu không slot nào được tìm thấy, C++ replicator gọi thủ tục instance lớp drop{} để thúc đẩy hoạt động giao thức nhanh

Các thủ tục instance để điều khiển các thành phần của mỗi slot:+ insert{oif} Chèn một outgoing interface mới vào slot tiếp theo+ disable{oif} Vô hiệu con trỏ slot tới oif.+ enable{oif} kích hoạt con trỏ slot tới oif.+ is-active{} Trả về true nếu replicator coits nhát một slot dược kích hoạt.+ exists{oif} Trả về true nếu con trỏ slot trỏ tới oif được kích hoạt.+ change-iface{source, group, oldiif, newiif} Sửa chữa đầu vào iif cho replicator.



3.2.3 Protocol InternalsCentralized Multicast

CtrMcast là thừa kế của McastProtocol. Một agent CtrMcast cần đwocj tạo ra chomoix node.Có một agent CtrMcastComp trung tâm để tính toán và cài đặt các đường định tuyến multicast cho toàn thể tô pô.Mỗi agent CtrMcast agent xử lý các lệnh chức năng, và gửi lại agent CtrMcastComp để tính lại đường đi thích hợp

+ join-group{} Đăng ký thành viên mới với agent CtrMCastComp và gọi agent đó tính toán lại đường đi cho mỗi thành viên

+ leave-group{} Là đảo ngược của join-group{}.+ handle-cache-miss{} Được gọi khi không cổng forwarding thích hợp được tìm thấy

với nguồn gói tin nào đó.Trong trường hợp centralized multicast,nguồn mới bắt đầu gửi các gói tin dữ liệu.Do đó, agent CtrMcast đăng ký với nguồn mới với agent CtrMcastComp.Nếu có các thành viên trong nhóm đó, tính toán cây multicast mới.Nếu nhóm là chế độ RPT (cây chia sẻ - shared tree) , thì :

1. Tạo một agent đóng gói ở nguồn;2. Tạo một agent mở gói tương ứng ở RP3. Hai agent được kết nối bởi unicast;4. Cổng vào <S,G> trỏ outgoing interface của nó tới agent đóng gói

CtrMcastComp là một agent tính toán đường định tuyến multicast tập trung+ reset-mroutes{} Khởi động lại tất cả các đầu vào multicast forwarding + compute-mroutes{} Tính toán tất cả các đầu vào multicast forwarding + compute-tree{source, group} tính toán một cây multicast cho một nguồn để tìm tất cả

các receiver trong một nhóm đặc biệt+compute-branch{source, group, member} Được thực hiện khi một receiver gia nhập một

nhóm multicast .Nó cũng có thể được gọi bởi compute-tree{} khi bản thân nó tính lại cây multicast .Thuật toán khởi tạo tại receiver,tìm kiếm đệ quy liên tiếp các nexthop, cho tới khi tìm thấynguồn hay RP, hoặc tìm thấy một node lầ một phần của cây multicast liên quan.Trong suốt quá trình, nhều replicator mới và một outgoing interface sẽ được cài đặt.

+ prune-branch{source, group, member} tương tự như compute-branch{} ngoại trừ outgoing interface là disabled;Nếu danh sách outgoing interface là rỗng tại mode này nó sẽ đi dọc cây multicast , pruning tại các node trung gian cho tới khi tìm thấy một node có một danh sách outgoing interface không rỗng Dense Mode

+ join-group{group} Gửi các thông điệp graft nếu <S,G> không chứa các slot outgoing kích hoạt nào, (ví dụ no downstream receiver).Nếu nexthop hướng tới nguồn là một LAN, tăng bộ đếm của receiver cho nhóm đối với LAN.

+ leave-group{group} Giảm bộ đếm LAN.+handle-cache-miss{srcID group iface} Dựa vào giá trị cuả CacheMissMode gọi hoặc là

handle-cache-miss-pimdm hay handle-cache-miss-dvmrp.+ handle-cache-miss-pimdm{srcID group iface} Nếu gói tin được nhận trên iif đúng(từ

node mà nexthop chỉ tới nguồn), thì đưa gói tin ra tất cả oifs ngoại trừ oif mà trỏ về next–hop–neighbor và oifs là các LAN với node đó không được forward.Nói cách khác, nếu giao diện sai thì gửi một prune trở lại .



+ handle-cache-miss-dvmrp{srcID group iface}truyền các gói tin ra chỉ ở các node là nexthop trỏ tới nguồn (parent).

+ drop{replicator source group iface} Gửi một thông điệp prune trở lại hop trước đó.+ recv-prune{from source group iface} Khởi động lại bộ đếm prune nếu giao diện bị

prune trước đó.Nói cách khác, nó sẽ khởi động bộ đếm prune timer và sẽ disables interface; xa hơn,nếu danh sách outgoing interface rỗng, nó sẽ truyền thông điệp prune .

+ recv-graft{from source group iface} Hủy bỏ một số bộ đếm prune timer,kích hoạt lại giao diện đã bị prune.Nếu danh sách giao diện trước đó rỗng, nó sẽ forward graft lên đường truyền.

+ handle-wrong-iif{srcID group iface} Được gọi khi multicast classifier mất gói tin vì đến sai giao diện

+ invoked new-group{}. Chu trình này bị gọi bởi mrtObject instproc new-group{}.Khi gọi, nó gửi một thông điệp prune trở về nguồn

3.2.4 The internal variablesClass mrtObjectprotocols_ :Một mảng của các handlecủa instance giao thức kích hoạt tại node mà giao thức hoạt động, được đánh dấu bởi giao diện vào- incoming interface.mask-wkgroups : Biến lớp, định nghĩa mask được dùng để nhận dạng các nhóm nổi tiếng - well known groups.wkgroups : Biến mảng lớp, mảng của các địa chỉ nhóm nổi tiếng, xác định bởi tên nhóm. wkgroups(Allocd): là một biến đặc biệt định vị nhóm nổi tiếng được định vị cao nhất..McastProtocolstatus_ có giá trị là “up” hay “down”, để biểu thị trạng thái thực hiện của protocol instance.type_ chứa loại (tên lớp) của giao thức được thực hiện bởi instance này như DM, hay ST.SimulatormultiSim_ là 1 nếu mô phỏng multicast và 0 nếu khácMrtHandle_ Nắm giữ handle tới đối tượng mô phỏng multicast tập trung hóa.Nodeswitch_ Là handle cho classifier đwocj đặt ở bit cao nhất của địa chỉ đích trong gói tin để xác định khi nào là gói tin multicast (bit=1 ) hay gói tin unicast (bit = 0).multiclassifier_ Là handle trỏ tới classifier để thực hiện so sánh <s,g,iif>replicator_ Mảng được đánh chỉ mục bởi <s,g> của các handle là bản sao của một gói tin multicast trên link yêu cầu.Agents_ Mảng được dánh chỉ mục bởi nhóm multicast của danh sách các agent tại node cục bộ nghe hấy groupoutLink_ Cached list của outgoing interfaces tại node nàyinLink_ Cached list của incoming interfaces tại node này.Link và SimpleLinkiif_ Là thao tác cho đối tượng NetworkInterface được đặt trên linkhead_ Đối tượng đầu tiên trên link, một no-op connector.Tuy nhiên đói tượng này chứa biến instance, link_, được trỏ tới đối tượng container Link .NetworkInterfaceifacenum_ Biến lớp , nắm giữ số giao diện có thể được tiếp theo



Bảng tra cứu định dạng File Nam trace:

# : comment – this line is ignoredT : Dummy event to be used in time synchronization

-t <time> timen : node

-t <time> time-s <int> node id-v <shape> shape (circle, box, hexagon)-c <color> color-z <double> size of node-a <int> address-x <double> x location-y <double> y location-i <color> label color-b <string> label-l <string> label-o <color> previous color-S <string> state (UP, DOWN, COLOR)-L <string> previous label-p <string> label location-P <string> previous label location-i <color> inside label color-I <color> previous inside label color-e <color> label color-E <color> previous label color-u <string> x velocity-U <string> x velocity-V <string> y velocity-T <double> node stop time-w <flag> wireless node

l : link-t <time> time-s <int> source id-d <int> destination id

-r <double> transmission rate-D <double> delay-h <double> length-O <orientation> orientation-b <string> label-c <color> color-o <color> previous color-S <string> state (UP, DOWN)-l <string l> label-L <string> previous label-e <color> label color-E <color> previous label color

+ : enqueue packet-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> packet color attribute id-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type

- : dequeue packet-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type



h : hop-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type-R <double> wireless broadcast radius-D <double> wireless broadcast duration

r : receive-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type-R <double> wireless broadcast radius-D <double> wireless broadcast duration

d : drop line-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type

E : session enqueue-t <time> time-s <int> source id

-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type

D : session dequeue-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type

P : session drop-t <time> time-s <int> source id-d <int> destination id-e <int> extent-a <int> attribute-i <int> id-l <int> energy-c <string> conversation-x <comment> comment-p <string> packet type-k <string> packet type

a : agent-t <time> time-s <int> source id-d <int> destination id-x <flag> remove agent-n <string> agent name

f : feature-t <time> time-s <int> source id-d <int> destination id-x <flag> remove feature-T <char> type-n <string> name-a <string> agent



-v <string> value-o <string> previous value

G : group-t <time> time-n <string> name-i <int> node id-a <int> group id-x <flag> remove from group

L : lan link-t <time> time-s <int> source id-d <int> destination id-o <orientation> orientation-O <orientation> orientation

m : mark node-t <time> time-n <string> name-s <int> node id-c <string> color-h <string> shape (circle, square, hexagon)-X <flag> remove mark

R : routing event-t <time> time-s <int> source id-d <int> destination id-g <int> multicast group-p <packet source> packet source id or *-n <flag> negative cache-x <flag> this route timed out-T <double> timeout-m <string> mode (iif or oif)

v : execute tcl expression-t <time> time-e <tcl expression> tcl script

V : set trace file version-t <time> time

-v <string> time-a <int> time

N : use nam graphW : wireless range

-t <time> time-x <int> X-y <int> Y

g : energy status – for future use-t <time> time

A : hierarchical address space configuration – initilization only

-t <time> time-n <int> hierarchy-p <int> port shift-o <hex> port mask-c <int> mulitcast shift-a <int> multicast mask-h <int> hierarchy-m <int> node shift-s <int> node mask

c : color table configuration – initialization only

-t <time> time-i <int> id-n <string> color

q : create packet queue – initialization only-t <time> time-s <int> source id-d <int> destination id-a <orientation> orientaion

X : layout lan-t <time> time-n <string> name-r <double> rate-D <double> delay-o <orientation> orientation-O <orientation> orientation




Documents

Ngon Ngu Otcl Trong Ns2