Bài tiểu luận môn học IP ứng dụng và bảo mật giới thiệu công cụ NS - Pdf 34

1. Giới thiệu về côngHỌ
cụCmô
phỏ
g mạngNGHỆ
NS.............................................................4
VIỆ
N nCÔNG
VIỄN THÔNG
1.1 TổKHOA
ng quan....................................................................................................4
HỌ
C
VIỆ
N
CÔNG
NGHỆ
THÔNG
QUAN HỆ QUỐC TẾ VÀ ĐÀO VIỄ
TẠONSAU
ĐẠI HỌC
HỆn..................................................................................6
QUỐC TẾ VÀ ĐÀO TẠO SAU ĐẠI HỌC
1.2. Bộ KHOA
định trìQUAN
nh sự kiệ
1.3. Các thành phần mạng.................................................................................8
1.4. Gói dữ liệu................................................................................................10
2. Giao tiếp với bộ thông dịch: Liên kết OTcl..........................................................11
2.1 Các khái niệm............................................................................................11
2.2 Tổng quan về mã lệnh...............................................................................12
2.3 Lớp Tcl.......................................................................................................12

Vũ Anh Tuấn [23-44]
3.2.4 Bộ định trình thời gian thực...............................................................18
Nguyễn Việt Thắng [45-66]
Đinh Hải Đăng [67-hết]
3.3 Các phương thức khác...............................................................................18
3.4. Lướt qua về các lệnh.................................................................................19
4. Các nút và chuyển gói............................................................................................20
4.1 Các cách thức của bộ mô phỏng: Tạo kiến trúc mạng..............................20
4.2 Các cách thức của nút: đặt cấu hình nút....................................................22
4.3 Cấu hình nút về mặt chức năng.................................................................23
4.3.1 Giao diện cấu hình nút........................................................................23
Hà Nội
4.4 Bộ phân lớp................................................................................................25
4.4.1 Bộ phân lớp địa chỉ.............................................................................27

TIỂ
NNMÔN
TIỂUULUẬ
LUẬ
MÔNHỌ
HỌCC

i

4.4.2 Bộ phân lớp đa hướng........................................................................27
4.4.3 Bộ phân lớp đa đường........................................................................28
4.4.4 Bộ phân lớp băm.................................................................................29
4.4.5 Bộ tạo bản sao.....................................................................................30
4.5 Module định tuyến và sự tổ chức bộ phân lớp..........................................31

9.5.2. Khởi động Agent...............................................................................56
9.5.3. Xử lý đầu vào ở bộ thu......................................................................57
9.5.4. Xử lý đáp ứng ở bên gửi....................................................................58
9.5.5. Các bộ định thời.................................................................................59
9.6. Tạo một agent mới....................................................................................59

ii

9.6.1. Ví dụ: Yêu cầu “ping” (Cấu trúc kế thừa)........................................59
9.6.2. Các phương thức recv() và timeout()................................................60
9.6.3. Liên kết agent “ping” với OTcl.........................................................61
9.6.4. Sử dụng agent nhờ OTcl....................................................................62
9.7. Agent API.................................................................................................62
9.8. Các đối tượng agent khác.........................................................................62
9.9. Các lệnh cơ bản.........................................................................................63
10. Các bộ định thời...................................................................................................63
10.1. Lớp cơ sở trong C++ TimerHandler......................................................63
10.1.1. Định nghĩa một bộ định thời mới....................................................64
10.1.2. Ví dụ: Bộ định thời truyền lại TCP.................................................65
10.2. Lớp định thời trong OTcl.......................................................................68
10.3. Một số lệnh cơ bản.................................................................................68
11. Header gói và các định dạng...............................................................................68
11.1. Header gói cho một giao thức cụ thể......................................................69
11.1.1. Thêm một kiểu header gói mới.......................................................71
11.1.2. Lựa chọn các header gói trong bộ mô phỏng .................................71
11.2. Các lớp gói..............................................................................................72
11.2.1. Lớp Packet.......................................................................................72
11.2.2. Lớp p_info.......................................................................................74
11.2.3. Lớp hdr_cmn...................................................................................74

thành phần mạng và các hành liên kết trong các thư viện của NS. Việc thiết lập một
mạng là ghép nối các đường dữ liệu giữa các đối tượng mạng bằng cách đặt con trỏ
của một đối tượng này tới địa chỉ của một đối tượng khác tương ứng. Khi muốn tạo
một đối tượng mạng mới, thì người dùng có thể tạo ra đối tượng đó bằng cách xây
dựng một đối tượng mới hoặc tổ hợp các đối tượng có sẵn trong các thư viện đối tượng
của NS và tạo ra các đường liên kết dữ liệu giữa chúng.
Một thành phần quan trọng của NS (bên cạnh các đối tượng mạng) là bộ định
trình sự kiện. Một sự kiện trong NS là một mã nhận dạng gói, mã này là duy nhất đối
với một gói, sự kiện được định thời và gắn với một con trỏ trỏ đến đối tượng sẽ xử lý
sự kiện đó. Trong NS, bộ định trình sự kiện giám sát toàn bộ thời gian mô phỏng, quản
lý và kích hoạt các sự kiện theo một hàng đợi. Khi một sự kiện được kích hoạt, bộ định
trình sẽ gọi tới thành phần đối tượng mạng xử lý tương ứng (thường cũng là đối tượng
Bài tiểu luận môn học IP-Ứng dụng và bảo mật

4

Giới thiệu công cụ NS
tạo ra sự kiện đó), cho phép đối tượng này thực hiện các tác vụ thích hợp lên gói gắn
với sự kiện. Các thành phần đối tượng mạng truyền thông với nhau bằng cách trao đổi
các gói. Về nguyên tắc, tất cả các thành phần mạng luôn cần phải có một khoảng thời
gian nhất định để xử lý gói (trễ). Trễ này được thể hiện thông qua việc sử dụng các bộ
định trình sự kiện: gửi đi một sự kiện gắn với gói và chờ sự kiện đó được kích hoạt trở
lại trước khi xử lý các gói tiếp theo. Ví dụ: một thành phần mạng mô phỏng một thiết
bị chuyển mạch gói với 20 ms trễ, nó sẽ gửi đi một sự kiện trễ 20 ms gắn với gói cần
phải chuyển mạch tới bộ định trình sự kiện, bộ định trình sau 20 ms sẽ đưa sự kiện đó
ra khỏi hàng đội và kích hoạt nó trở lại thành phần mạng chuyển mạch, thành phần
chuyển mạch sẽ thực hiện việc chuyển gói tương ứng tới đối tượng liên kết đầu ra của
nó.
Một ứng dụng nữa của bộ định trình sự kiện là tạo ra các bộ định thời. VD: giao

Giới thiệu công cụ NS

Hình 3: Mô hình kiến trúc của NS
Hình 3 chỉ ra kiến trúc chung của công cụ mô phỏng NS. Trong hình vẽ này,
người sử dụng thiết kế, triển khai các mô phỏng bằng các câu lệnh Tcl, sử dụng các đối
tượng mô phỏng từ thư viện Otcl, các bộ định trình sự kiện và phần lớn các đối tượng
mạng được xây dựng bằng C++, và các đối tượng này vẫn có thể được sử dụng như là
các đối tượng Otcl thông qua các liên kết. Toàn bộ các thành phần trong hình 3, kết
hợp lại tạo nên một bộ công cụ mô phỏng mạng NS, là một bộ thông dịch Tcl được mở
rộng hướng đối tượng và một tập các thư viện đối tượng mô phỏng mạng.
Các kết quả đạt được sau khi kết thúc quá trình mô phỏng, như trong hình vẽ 1,
là tập một hoặc nhiều file kết quả đầu ra dưới dạng văn bản text, chứa các dữ liệu mô
phỏng chi tiết. Các số liệu này có để được dùng để phân tích mô phỏng hoặc dùng làm
đầu vào cho các công cụ trình diễn mô phỏng mạng dạng đồ họa: Nam, Xgraph...
Nam (Network Animator) có dạng giao diện tương tự như một công cụ chơi
CD, cho phép hiển thị thông tin dạng đồ hoạc như: thông lượng, số gói bị loại bỏ trên
mỗi link ...
1.2. Bộ định trình sự kiện

Như đã đề cập đến ở phần trên, đối tượng sử dụng chính của các bộ định trình
sự kiện là các thành phần mạng, mô phỏng việc xử lý gói hoặc có sử dụng các bộ định
thời. Hình 4 mô tả các đối tượng mạng sử dụng bộ định trình sự kiện. Cần lưu ý rằng:
một đối tượng gửi đi một sự kiện nào đó cũng chính là đối tượng xử lý sự kiện đó tại
một thời điểm định sẵn và đường dữ liệu giữa các đối tượng khác với đường điều
khiển (đường sự kiện). Thực tế, việc đưa các gói từ một đối tượng mạng này đến một
đối tượng mạng khác được thực hiện bằng cách sử dụng hàm send(Packet *p)
{target_-> recv(p)} của đối tượng gửi và hàm recv(Packet *,
Handler * h =0) của đối tượng nhận.

câu lệnh OTcl nằm trong chuỗi string của sự kiện AtEvent sẽ được thực thi. Ví dụ:
set ns [new Simulator]
$ns use-scheduler Heap
$ns at 300 "finish_sim"
...
proc finish_sim{}{
...
}

Trong ví dụ trên, ta thấy rằng hàm at time "string" là hàm thành viên của đối
tượng Simulator, nhưng cần phải lưu ý rằng đối tượng Simulator chỉ đóng vai trò giao
Bài tiểu luận môn học IP-Ứng dụng và bảo mật

7

Giới thiệu công cụ NS
tiếp người sử dụng, nên thực ra nó sẽ gọi đến các hàm thành viên của các đối tượng
mạng hoặc các đối tượng định trình để thực sự thực hiện công việc đó.
1.3. Các thành phần mạng

Trong NS, hầu hết các thành phần mạng là các đối tượng phức hợp. Hình 5 chỉ
ra một phần của cây phân cấp theo lớp OTcl.

Hình 5: Một phần của cây phân cấp theo lớp
Gốc của cây phân cấp này là lớp TclObject. Lớ
p TclObject là lớp cơ sở
của mọi đối tượng trong thư viện OTcl (định trình sự kiện, thành phần mạng, định thời,
và các đối tượng khác). Lớp NsObject là lớp cơ sở của mọi đối tượng thành phần
mạng cơ bản xử lý gói, các thành phần này kết hợp với nhau tạo thành các đối tượng

Hình 7: Đường kết nối
Cần lưu ý rằng hàng đợi đầu ra của một nút, thực ra là một phần của đối tượng
Link đơn. Các gói khi ra khỏi một hàng đợi Queue, sẽ được chuyển tới đối tượng
Delay, đối tượng này mô phỏng trễ của link, còn các gói bị loại bỏ khỏi hàng đợi
được gửi tới đối tượng Null Agent và được hủy tại đó. Cuối cùng, đối tượng TTL
tính toán tham số Time To Live đối với mỗi gói nhận được và thay đổi giá trị
trường TTL của gói.
Theo dõi giám sát
Trong NS, các tác vụ mạng được theo dõi trên mỗi đường kết nối đơn. Nếu đối
tượng mô phỏng được chỉ thị theo dõi các tác vụ mạng ( sử dụng lệnh $ns traceall file hoặc $ns trace-nam file), thì sau đó các đường kết nối được tạo ra
sẽ được thêm vào các đối tượng theo dõi như trong hình vẽ 8. Người sử dụng có thể
tạo ra đối tượng theo dõi thuộc một dạng nào đó giữa nút nguồn và nút đích bằng lệnh
create-trace {type file src dst}.

Hình 8. Các đối tượng theo dõi được thêm vào.
Khi mỗi đối tượng theo dõi nhận được một gói, nó sẽ ghi các thông số liên quan
đến gói ra file theo dõi mà không ảnh hưởng đến thời gian mô phỏng, và chuyển các
gói này tới đối tượng mạng tiếp theo.
Giám sát hàng đợi
Về cơ bản, các đối tượng theo dõi được thiết kế để ghi lại thời gian đến của gói
dữ liệu . Mặc dù người dùng có đủ các thông tin từ file theo dõi, nhưng có thể họ vẫn
Bài tiểu luận môn học IP-Ứng dụng và bảo mật

9

Giới thiệu công cụ NS
quan tâm đến những gì xảy ra bên trong một hàng đợi nào đó. Ví dụ: một người dùng
quan tâm đến cách thức xử lý một hàng đợi RED chẳng hạn, anh ta có thể muốn đo sự

Giới thiệu công cụ NS

2. Giao tiếp với bộ thông dịch: Liên kết OTcl
NS là một công cụ mô phỏng hướng đối tượng, bao gồm bản thân NS là một
đối tượng được viết bằng C++ và một bộ thông dịch OTcl. NS hỗ trợ kiến trúc cây
phân cấp theo lớp trong C++ (cây phân cấp biên dịch) và kiến trúc cây phân cấp theo
lớp tương tự trong bộ thông dịch OTcl(cây phân cấp thông dịch). Hai cây phân cấp này
có quan hệ chặt chẽ với nhau. Từ góc nhìn của người dùng, tồn tại mối quan hệ 1-1
giữa một lớp trong cây phân cấp thông dịch và một lớp trong cây phân cấp biên dịch.
Gốc của cả hai cây phân cấp này là lớp TclObject. Người dùng sẽ tạo ra các đối tượng
mô phỏng thông qua bộ thông dịch, những đối tượng này, thuộc vào cây phân cấp
thông dịch, được khởi tạo trong bộ thông dịch và sẽ được ánh xạ sang một đối tượng
tương ứng trong cây phân cấp biên dịch.
Cây phân cấp thông dịch được tự động thiết lập thông qua các hàm được định
nghĩa trong lớp TclClass. Các đối tượng tạo bởi người dùng được ánh xạ thông qua các
hàm được định nghĩa trong lớp TclObject. Ngoài ra vẫn có các cây phân cấp khác
trong C++ và OTcl, đó là những cây thực sự không có quan hệ với nhau.
2.1 Các khái niệm

Trước hết ta tìm hiểu tại sao NS lại sử dụng hai ngôn ngữ C++ và OTcl. Đó là
bởi vì, trong quá trình thực hiện mô phỏng có hai việc khác nhau cần phải thực hiện:
Một mặt, việc mô phỏng chi tiết cề các giao thức đòi hỏi phải sử dụng một ngôn
ngữ lập trình hệ thống, nhằm xử lý hiệu quả với các dữ liệu dạng byte, các mào đầu
gói hay thực hiện các giải thuật tính toán trên một số lượng lớn dữ liệu. Đối với những
công việc như vậy thì tốc độ thực thi là rất quan trọng, còn thời gian thay đổi, nâng cấp
(quá trình chạy mô phỏng, tìm lỗi, sửa lỗi, biên dịch và chạy lại) sẽ ít quan trọng hơn.
Mặt khác, một phần lớn các công việc nghiên cứu mạng lại liên quan đến những
thay đổi nhỏ các tham số đầu vào, thay đổi cấu hình hay việc tìm hiểu nhanh chóng

giao tiếp với bộ thông dịch được đặt trong thư mục /tclcl và toàn bộ phần còn lại mã
mô phỏng được đặt trong thư mục NS-2.
Có một số lớp được định nghĩa trong thư mục /tclcl cho giao tiếp với bộ thông
dịch OTcl, chúng ta chỉ xem xét 6 lớp trong số đó được sử dụng trong NS:
- Lớp Tcl: chứa các hàm cho phép mã C++ truy nhập tới bộ thông dịch
- Lớp TclObject: là lớp cơ sở của tất cả các đối tượng mô phỏng
- Lớp TclClass: định nghĩa cây phân cấp thông dịch và các hàm cho phép
người dùng khởi tạo các đối tượng TclObject
- Lớp TclCommand: định nghĩa các câu lệnh thông dịch đơn giản
- Lớp EmbeddedTcl: định nghĩa các hàm để nạp các câu lệnh có sẵn ở múc
cao hơn, cho phép thiết lập câu hình mô phỏng dễ dàng hơn.
- Lớp InstVar: định nghĩa các hàm cho phép truy nhập tới các biến thành viên
C++.
2.3 Lớp Tcl

Lớp Tcl bao bọc toàn bộ instance thực sự của bộ thông dịch OTcl và đưa ra
các hàm giao tiếp với bộ thông dịch đó. Các hàm này cho phép thực hiện
- Lấy tham chiếu tới Tcl instance
- Gọi các hàm OTcl qua bộ thông dịch
- Nhận và trả lại kết quả cho bộ thông dịch
- Thông báo các tình huống lỗi và thoát
- Lưu tham chiếu và tìm các đối tượng TclObject
- Truy nhập trực tiếp tới bộ thông dịch
2.3.1 Lấy tham chiếu tới instance của lớp Tcl
Luôn tồn tại một instance duy nhất của lớp Tcl được khai báo như là một biến
thành viễn tĩnh, người lập trình có thể lấy được tham chiếu tới instance này qua câu
lệnh
Tcl& tcl = Tcl:instance()
2.3.2 Gọi các hàm OTcl
Có 4 hàm khác nhau để gọi một câu lệnh OTcl qua Tcl instance:

tclresult ra luồng stdout và thoát ra với mã lỗi bằng 1.
2.3.5 Các hàm băm trong bộ thông dịch
NS lưu tham chiếu của tất cả các đối tượng TclObject của cây biên dịch trong
một bảng băm. NS sử dụng tên của các đối tượng này để thêm vào, tìm kiếm hay xóa
tham chiếu của đối tượng trong bảng băm. Có 3 hàm để làm điều này
- tcl.enter (TclObject * o)
- tcl.lookup(char * s)
- tcl.remove(TclObject *o)
Các hàm trên được sử dụng trong nội tại các lớp TclObject và TclClass để quản
lý các đối tượng.
2.4 Lớp TclObject

TclObject là lớp cơ sở của phần lớn các lớp còn lại trong cây biên dịch và
thông dịch. Mỗi đối tượng thuộc lớp TclObject được tạo bởi người sử dụng thông
qua bộ thông dịch, và sẽ có một đối tượng ánh xạ tương ứng được tạo ra trong cây biên
dịch. Hai đối tượng này có quan hệ chặt chẽ với nhau. Lớp TclClass (được mô tả ở
phần sau) chứa các cơ chế cho phép thực hiện việc ánh xạ này.
2.4.1 Tạo và hủy đối tượng TclObject
Khi người dùng muốn khởi tạo hay xóa bỏ một đối tượng TclObject, hai hàm
new{} và delete{} sẽ được sử dụng để tạo và hủy các đối tượng này. Hai hàm
new{} và delete{} được sử dụng để tạo và hủy các đối tượng của tất cả các lớp
dẫn xuất từ lớp TclObject.
Tạo đối tượng TclObject: bằng cách dùng hàm new{}, người dùng sẽ tạo ra
một đối tượng TclObject thông dịch, bộ thông dịch thực hiện việc khởi tạo đối
tượng đó thông qua việc gọi hàm dựng init{} với các tham số nhận được từ người
dùng. Sau đó NS sẽ tự động tạo ra một đối tượng biên dịch tương ứng, đối tượng ánh
xạ này được tạo ra bởi hàm dựng của lớp TclObject cơ sở. Vì vậy để khởi tạo một đối
tượng TclObject, trước tiên cần phải gọi hàm dựng của lớp cha trước khi thực hiện các
khởi tạo đối tượng của lớp con. Hàm new{} trả về thẻ bài trỏ tới đối tượng được tạo
ra.

set
set
set
set
set

realvar 1.2e3
intvar 123
bwvar 1.5mb
timevar 1500m
boolvar true

2.4.3 Theo dõi giá trị biến
Ngoài cơ chế kết hợp biến, TclObject còn hỗ trợ theo dõi giá trị của cả biến C+
+ và Tcl. Một biến khi được tạo ra trong C++ hoặc trong Tcl đều có thể thiết lập việc
theo dõi giá trị của nó. Để theo dõi giá trị một biến ở mức Tcl, thì biến đó phải xuất
hiện trong Tcl, điều đó có nghĩa là nó phải là một biến Tcl thuần túy hoặc là một biến
kết hợp C++/Tcl. Ngoài ra, một đối tượng có biến thành viên được theo dõi giá trị
cũng có thể yêu cầu việc theo dõi sử dụng hàm trace{} của đối tượng
TclObject.Hàm trace{} có hai tham số đầu vào, tham số vào đầu tiên là tên của
biến, tham số tùy chọn thứ hai chỉ ra đối tượng chịu trách nhiệm theo dõi giá trị của
biến cần theo dõi, nếu đối tượng theo dõi này không được chỉ ra, thì đối tượng sở hữu
biến sẽ chịu trách nhiệm theo dõi giá trị của biến.
Để một đối tượng TclObject có thể theo dõi được giá trị biến, nó phải mở rộng
hàm C++ trace(), đây là một hàm ảo đã được định nghĩa trong lớp TclObject.
2.4.4 Hàm command: định nghĩa và cách gọi
Đối với mỗi đối tượng TclObject được tạo ra, NS thiết lập một hàm mẫu
cmd{}, đóng vai trò như một giao tiếp để thực hiện các hàm của đối tượng biên dịch
ánh xạ. Hàm cmd{} tự động gọi hàm command() của đối tượng biên dịch, và các
tham số đầu vào của hàm cmd{} cho hàm command().

}
} class_reno;

2.5.1 Kết hợp các biến thành viên tĩnh của lớp C++
Ở phần trước, chúng ta đã đề cập đến cách thức để nhìn thấy các biến thành
viên của các đối tượng trọng C++ trong môi trường OTcl, tuy nhiên cơ chế này lại
không thể áp dụng cho các biến thành viên tĩnh của các lớp C++. Đương nhiên là,
chúng ta vẫn có thể tạo ra một biến trong OTcl tương ứng với biến thành viên tĩnh của
mỗi đối tượng C++, tuy nhiên điều này lại hoàn toàn phá hỏng đi ý nghĩa của biến
thành viên tĩnh.
Chúng ta không thể giải quyết vấn đề kết hợp biến này theo các giải pháp tương
tự như việc kết hợp biến trong TclObject, bởi vì cơ chế kết hợp biến trong TclObject
dựa trên lớp InstVar mà lớp này trong TclCl lại đòi hỏi sự hiện diện của một đối tượng
TclObject cụ thể. Tuy nhiên, chúng ta có thể tạo ra một hàm thuộc lớp TclClass tương
ứng và thực hiện việc truy xuất tới biến thành viên tĩnh của lớp C++ thông qua hàm
này. Các bước để thực hiện việc này như sau có thể tham khảo trong tài liệu hướng dẫn
NS, trang 30.
2.6 Lớp TclCommand

Lớp TclCommand đưa ra cơ chế cho phép NS chuyển các câu lệnh đơn giản tới
bộ thông dịch, và các câu lênh này có thể được thực hiện bởi bộ thông dịch trong môi
trường chung.
Có hai hàm: ns-random và ns-version thường được sử dụng trong môi
trường chung, cả hai hàm này được khởi tạo bởi hàm init_misc(void), và hàm
init_misc được gọi bởi hàm Tcl_AppInit(void) trong quá trình NS được nạp
vào bộ nhớ.
Lớp VersionCommand, định nghĩa hàm ns-version, hàm này không có
tham số đầu vào, và trả về phiên bản NS hiện thời dạng chuỗi.
Lớp RandomCommand, định nghĩa hàm ns-random, không tham số đầu vào,
trả về một giá trị nguyên ngẫu nhiên nằm trong khoảng [0, 231-1].

Lớp InstVar định nghĩa các hàm và đưa ra các cơ chế để kết hợp một biến
C++ trong đối tượng biên dịch với một biến OTcl xác định trong đối tượng thông dịch
tương ứng. Việc kết hợp này cho phép giá trị của biến có thể được thay đổi trong cả
hai môi trường: thông dịch và biên dịch ở mọi thời điểm.
Có
năm
lớp
biến:
InstVarReal,
InstVarTime,
InstVarBandwidth, InstVarInt và InstVarBool, được sử dụng để kết
hợp 5 kiểu biến: thực, nguyên, thời gian, logic và băng thông tương ứng.

3. Lớp Simlator
Tất cả bộ mô phỏng được mô tả bởi lớp Tcl của bộ mô phỏng. Nó cung cấp một
tập các giao diện cho việc đặt cấu hình mô phỏng và lựa chọn kiểu của bộ định trình
sự kiện sử dụng để điều khiển việc mô phỏng. Một kịch bản mô phỏng nói chung bắt
đầu bởi việc tạo ra một lớp cụ thể và gọi các phương thức khác nhau để tạo các nút,
các cấu trúc liên kết mạng và cấu hình các khía cạnh khác của sự mô phỏng.
3.1 Khởi tạo bộ mô phỏng

Khi một đối tượng mô phỏng được tạo ra trong tcl, thủ tục khởi tạo được thực
hiện theo các thao tác:
- Khởi tạo định dạng gói (gọi hàm create_packetformat)
- Tạo bộ định trình (mặc định là bộ định trình lịch)
- Tạo một "tác tử rỗng"(null agent - nơi để hủy gói trong ở các ví trí khác
nhau)
Sự khởi tạo định dạng gói thiết lập các trường dư với các gói được sử dụng
trong suốt quá trình mô phỏng. Bộ định trình thực hiện mô phỏng theo cách điều khiển

Việc thực hiện từng phần các sự kiện hoặc các công việc được ưu tiên sẽ không
được hỗ trợ.
Một sự kiện nói chung gồm có "thời gian đốt cháy" (firing time) và một hàm
trình xử lý. Định nghĩa thật sự của một sự kiện như sau:
class Event {
public:
Event* next_; /* event list */
Handler* handler_; /* handler to call when event ready */
double time_; /* time at which event is ready */
int uid_; /* unique ID */
Event() : time_(0), uid_(0) {}
};
/*
* The base class for all event handlers. When an event’s scheduled
* time arrives, it is passed to handle which must consume it.
* i.e., if it needs to be freed it, it must be freed by the handler.
*/
class Handler {
public:
virtual void handle(Event* event);
};

Hai kiểu của đối tượng được dẫn xuất từ lớp sự kiện gốc: gói và "đang lúc sự
kiện" (at-event). Một at-event là việc thực hiện thủ tục tcl được định trình diễn ra tại
một thời điểm nhất định. Điều này thường xuyên được sử dụng trong kịch bản mô
phỏng. Một ví dụ đơn giản về việc sử dụng chúng như sau:
...
set ns_ [new Simulator]
$ns_ use-scheduler Heap
$ns_ at 300.5 "$self complete_sim"

3.2.4 Bộ định trình thời gian thực
Bộ định trình thời gian thực cố gắng đồng bộ sự thi hành của các sự kiện với
thời gian thực. Nó thực thi như là một lớp con của bộ định trình danh sách. Khả năng
về thời gian thực trong ns là đang được phát triển, những đã được sử dụng đưa ra một
ns mô phỏng mạng trong kiến trúc thế giới thực được thực nghiệm với kiến trúc mạng
đơn giản, lưu lượng chéo, ... Nó chỉ hoạt động với tốc độ dữ liệu lưu lượng mạng
chậm, như một bộ mô phỏng cần phải có thể theo được với tốc độ đến của gói trong
thế giới thực, và sự đồng bộ này hiện tại là không có hiệu lực.
3.3 Các phương thức khác

Các lớp của bộ mô phỏng cung cấp một lượng các phương pháp sử dụng thiết
lập sự mô phỏng. Nói chung chúng được chia thành 3 loại:
Các phương pháp tạo, quản lý kiến trúc và quản lý các liên kết, các phương
pháp thực hiện việc theo vết, và trình giúp đỡ thực hiện chức năng xử lý với bộ định
trình. Theo đây là danh sách các phương pháp không có liên quan đến kiến trúc mạng
của bộ mô phỏng:
Simulator instproc now ;# return scheduler’s notion of current time
Simulator instproc at args ;# schedule execution of code at specified
time
Simulator
Simulator
Simulator
Simulator
buffers
Simulator
object
Simulator
packet format

instproc cancel args ;# cancel event

Synopsis:
ns <otclfile> <arg> <arg>..

Mô tả: Lệnh cơ bản để chay một kịch bản mô phỏng trong ns. Bộ mô phỏng ns
gọi thông qua bộ thông dịch ns, một sự mở rộng của lệnh vanilla otclsh. Sự mô phỏng
được định nghĩa bởi một kịch bản Otcl (tệp tin). Vài ví dụ về kịch bản Otcl có thể thấy
trong thư mục ns/tcl/ex
Dưới đây là danh sách chung nhất các lệnh của bộ mô phỏng được sử dụng
trong mô phỏng
scripts:
set ns_ [new Simulator]
lệnh này tạo ra một đối tượng cụ thể của bộ mô phỏng.
set now [$ns_ now]
Bộ đị nh trình giữ vết thời gian mô phỏng. nó trả về thông báo của bộ
đị nh trình về thời gian hiện tại.
$ns_ halt
dừng lại và tạm dừng bộ đị nh trình.
This stops or pauses the scheduler.
$ns_ run
Chạy bộ đị nh trình This starts the scheduler.
$ns_ at <time> <event>
Đị nh trình một sự kiện <event> (thông thường là một đoạn mã) được
thực hiện ở một thời gian nào đó.
e.g $ns_ at $opt(stop) "puts ¨NS EXITING..¨ ; $ns_ halt"
or, $ns_ at 10.0 "$ftp start"
$ns_ cancel <event>
Bỏ qua sự kiện, sự kiện được loại ra khỏi danh sách bộ đị nh trình của
những sự kiện sẵn sàng hoạt động.
$ns_ create-trace <type> <file> <src> <dst> <optional arg: op>
tạo một đối tượng giám sát kiểu <type> giữa đối tượng <src> và <dst>

19

Giới thiệu công cụ NS
$ns_ create_packetformat
Thiết lập đị nh dạng gói tin của bộ mô phỏng.

4. Các nút và chuyển gói
Chương này mô tả một khía cánh của việc tạo kiến trúc mạng trong ns như là
tạo các nút. Chương tiếp theo sẽ mô tả khía cạnh thứ hai của việc tạo kiến trúc mạng
như là kết nối các nút thành các liên kết. Chương này ko mô tả chi tiết tổ chức bên
trong của một nút (cho dù một vài lược đồ được đưa ra), hoặc là tương tác giữa một
nút và module định tuyến của nó.
Nhắc lại rằng mỗi mô phỏng yêu cầu lớp của bộ mô phỏng cụ thể để điều khiển
và thao tác mô phỏng này. Lớp này cung cấp các thủ tục cụ thể để tạo và quản lý kiến
trúc mạng và lưu trữ bên trong các tham chiếu tới mỗi phần tử của kiến trúc mạng.
Chúng ta bắt đầu mô tả các thủ tục trong lớp Bộ mô phỏng (phần 4.1) sau đó mô tả các
thủ tục cụ thể trong lớp Node (phần 4.2) để truy cập và thao tác trên nút riêng biệt.
Chúng ta kết thúc với các mô tả chi tiết của Bộ phân lớp (phần 4.4) từ đó các đối
tượng nút phức hợp hơn được hình thành.
4.1 Các cách thức của bộ mô phỏng: Tạo kiến trúc mạng

Nguyên tố cơ bản có được một nút là:
set ns [new Simulator]
$ns node

Thủ tục cụ thể node dựng nên một nút từ các đối tượng phân lớp đơn giản hơn.
Bản thân Node là một lớp đứng độc lập trong OTcl. Hơn nữa, hầu hết các thành phần
của nút là trong đối tượng Tcl. Cấu trúc điển hình của một nút được chỉ ra trong hình

rằng phần địa chỉ là địa chỉ đa hướng hay địa chỉ đơn hướng. Nếu bit đó là 0, địa chỉ
đại diện là đại chỉ đơn hướng, ngược lại là địa chỉ đa hướng. Nó ngụ ý rằng, theo mặc
định, mô phỏng đa hưởng được giới hạn trong 128 nút.

Bài tiểu luận môn học IP-Ứng dụng và bảo mật

21

Giới thiệu công cụ NS

Hình 4.2 Cấu trúc bên trong của nút đa hướng
4.2 Các cách thức của nút: đặt cấu hình nút

Các thủ tục để cấu hình mỗi nút riêng biệt có thể được chia thành:
- Các chức năng điều khiển
- Quản lý số địa chỉ và số cổng, các chức năng định tuyến đơn hướng
- Quản lý tác tử
- Thêm lân cận
Chúng ta mô tả các chức năng như sau:

Các chức năng điều khiển:
$node entry trả về điểm đầu vào cho nút, đây là phần tử đầu tiên sẽ xử lý các
gói đến trong nút này.
Biến số cụ thể của Node, entry_, lưu tham chiếu phần tử này. Với nút đơn
hướng, đây là bộ phân lớp địa chỉ nhằm vào bit cao của địa chỉ đích. Biến số
classifier_ chứa tham chiếu tới bộ phân lớp này. Tuy nhiên, với các nút đa hướng,
điểm vào là biến switch_ nhằm vào bit đầu tiên để quyết hoặc là chuyển gói tới bộ
phân lớp đơn hướng hoặc là bộ phân lớp đa hướng cho phù hợp.
$node_reset sẽ xác lập lại toàn bộ tác tử của nút.

danh sách từ các tuyến đã cài đặt trong bộ phân lớp đa đường. Nếu đầu vào của tuyến
trong bộ phân lớp không trỏ đến bộ phân lớp đa đường, thường lệ chỉ là xóa đầu vào từ
classifier_ và cài đặt nullagent vào chỗ đó.
Định tuyến động chi tiết cũng sử dụng 2 phương thức cộng thêm vào: thủ tục cụ
thể init-routing{} thiết lập biến số multiPath_ sẽ tương đương với biến số lớp cùng tên,
nó cũng cộng một tham chiếu tới đối tượng bộ điều khiển tuyến của nút trong biến số
này, rtObject_. Thủ tục rtObject{} trả về xử lý cho đối tượng tuyến của nút,
Cuối cùng, thủ tục intf-changed{} là được gọi lên bởi mã động trên mạng nếu
một liên kết rơi vào nút thay đổi trạng thái.
Quản lý tác tử
Một tác tử đã cho, thủ tục attach{} sẽ cộng thêm tác tử đó vào danh sách
agents_, gán số cổng của tác tử và đặt địa chỉ nguồn, đặt đích của tác tử cho nó và
cộng vào một con trỏ tới bộ giải ghép cổng của nút (dmux_) cho tác tử tại khe tương
ứng trong bộ phân lớp dmux_.
Ngược lại, detach{} sẽ xóa tác tử từ agent_, và chỉ đến đích của tác tử và đầu
vào nút dmux_ bằng nullagent.
Theo dõi nút lân cận (tracking Neighbors) Mỗi một nút giữ một danh sách các
nút lân cận nó trong biến neighbor_. Thủ tục add-neighbor{} cộng thêm một nút lân
cận vào danh sách. Thủ tục neighbors{} trả về danh sách này.
4.3 Cấu hình nút về mặt chức năng

4.3.1 Giao diện cấu hình nút
Giao diện cấu hình nút gồm có 2 phần. Phần thứ nhất giải quyết cấu hình nút,
phần thứ 2 thực sự tạo ra nút theo kiểu cụ thể. Cấu hình nút gồm có định nghĩa các đặc
tính khác nhau của nút trước khi tạo ra chúng, có thể gồm có kiểu cấu trúc đánh địa chỉ
trong việc mô phỏng, định nghĩa các thành phần mạng cho các nút di đông, bật hoặc
tắt các lựa chọn theo dõi ở mức tác tử, bộ định tuyến hoặc MAC, lựa chọn kiểu các thủ
tục định tuyến thay đổi cho các nút không dây hoặc định nghĩa mô hình năng lượng
của chúng. Toàn bộ API cấu hình nút như sau:
OPTION_TYPE AVAILABLE OPTION_VALUES

Giá trị mặc định cho tất cả lựa chọn trên là rỗng trừ kiểu đánh địa chỉ,
-addressingType có giá trị mặc định là kiểu phẳng, lựa chọn -reset có thể được lựa
chọn để thiết lập lại toàn bộ tham số cấu hình nút mang giá trị mặc định của chúng.
Cấu hình nút cho nút không dây, di động chạy AODV như là giao thức định
tuyến adhoc trong cấu trúc mạng phân cấp được chỉ ra dưới đây, chúng ta quyết định
bật theo dõi chỉ ở mức tác tử và mức bộ định tuyến. Hơn nữa chúng ta giả sử rằng sơ
đồ kiến trúc mạng đã được tạo ra với lệnh "set topo [new Topography]". Lệnh cấu
hình nút như sau:
$ns_ node-config -addressingType hierarchical
-adhocRouting AODV
-llType LL
-macType Mac/802_11
-ifqType Queue/DropTail/PriQueue
-ifqLen 50
-antType Antenna/OmniAntenna
-propType Propagation/TwoRayGround
-phyType Phy/WirelessPhy
-topoInstance $topo
-channelType Channel/WirelessChannel
-agentTrace ON
-routerTrace ON
-macTrace OFF
-movementTrace OFF

Chú ý rằng lệnh cấu hình có thể ngắt thành những dòng riêng biệt như:
$ns_ node-config -addressingType hier
$ns_ node-config -macTrace ON

Các lựa chọn cần phải thay đổi chỉ thay đổi khi được gọi đến, ví dụ sau khi cấu
hình cho các nút di động AODV như trên, chúng ta có thể cấu hình cho các nút trạm

giản hơn trong ns.
Chúng ta bắt đầu mô tả lớp cơ sở trong phần này. Đoạn tiếp theo sẽ mô tả bộ
phân lớp địa chỉ (4.4.1), bộ phân lớp đa hướng (4.4.2), bộ phân lớp đa đường (4.4.3)
và cuối cùng bộ tái tạo (bản sao)(4.4.5)
Bộ phân lớp cung cấp cách đối xử với một gói tin dựa vào vài điều kiện logic
và lấy tham chiếu tới đối tượng mô phỏng khác dựa trên kết quả tính toán. Mỗi bộ
phân lớp gồm có một bảng các đối tượng mô phỏng được đánh chỉ mục bằng số khe
(slot number). Công việc của một bộ phân lớp là xác định số khe kết hợp với gói tin
nhận được và chuyển gói tin này tới đối tượng được tham chiếu bởi khe liên quan. Lớp
Classifier cung cấp một lớp cơ sở từ đó các bộ phân lớp khác được dẫn xuất từ lớp
này.
class Classifier : public NsObject {
public:
~Classifier();
void recv(Packet*, Handler* h = 0);
protected:
Classifier();
void install(int slot, NsObject*);
void clear(int slot);
virtual int command(int argc, const char*const* argv);
virtual int classify(Packet *const) = 0;
void alloc(int);
NsObject** slot_; /* table that maps slot number to a NsObject */
int nslot_;
int maxslot_;
};

Phương thức classify() là hoàn toàn ảo, chỉ định lớp Classifier được sử dụng
như một lớp gốc, phương thức alloc() cấp phát động không gian đủ cho bảng chứa số
cụ thể của các khe. Phương thức install() và clear() thêm vào hoặc xóa bỏ các đối

Nhờ tải bản gốc

Tài liệu, ebook tham khảo khác

Bài tiểu luận môn học IP ứng dụng và bảo mật giới thiệu công cụ NS - Pdf 34

Tài liệu, ebook tham khảo khác

Học thêm