BỘ GIÁO DỤC VÀ ĐÀO TẠO ĐẠI HỌC HUẾ TRƯỜNG ĐẠI HỌC KHOA HỌC VŨ THIÊN HƯƠNG TÌM HIỂU MỘT SỐ KỸ THUẬT KẾT HỢP ĐỊNH TUYẾN LỆCH HƯỚNG VÀ TRUYỀN LẠI CHÙM TRONG MẠNG CHUYỂN MẠCH CHÙM QUANG CHUYÊN NGÀNH: KHOA HỌC MÁY TÍNH MÃ SỐ: 60.48.01.01 LUẬN VĂN THẠC SĨ KHOA HỌC ĐỊNH HƯỚNG NGHIÊN CỨU NGƯỜI HƯỚNG DẪN KHOA HỌC TS ĐẶNG THANH CHƯƠNG Thừa Thiên Huế, 2016 LỜI CAM ĐOAN Tôi xin cam đoan Đây công trình nghiên cứu khoa học riêng Các số liệu, trích dẫn, kết thực nghiệm cài đặt trình bày luận văn trung thực có nguồn gốc rõ ràng Huế, tháng năm 2016 Học viên Vũ Thiên Hương Lời Cảm Ơn Hoàn thành luận văn này, xin chân thành cám ơn Thầy giáo TS Đặng Thanh Chương, Khoa Công nghệ thông tin - Đại học Khoa học Huế, tận tình hướng dẫn suốt trình thực đề tài Xin chân thành cảm ơn giúp đỡ mặt Ban Giám hiệu, Phòng Quản lý sau đại học, Khoa Công nghệ Thông tin - Trường Đại học Khoa học - Đại học Huế quý Thầy Cô tham gia giảng dạy suốt trình học tập Xin chân thành cám ơn Ban Giám hiệu, Quý Thầy Cô giáo Khoa Công nghệ thông tin - Trường Đại học Khoa học - Đại học Huế quan tâm, động viên tạo điều kiện để hoàn thành luận văn Cảm ơn tất bạn bè, đồng nghiệp người thân động viên, giúp đỡ hoàn thành luận văn Huế, tháng năm 2016 Học viên Vũ Thiên Hương KẾT LUẬN DANH MỤC TÀI LIỆU THAM KHẢO PHỤ LỤC…………………………………………………………………………… DANH MỤC CÁC BẢNG DANH MỤC CÁC HÌNH DANH MỤC CÁC CHỮ VIẾT TẮT ACK AHDR AON BCP BHP BLP BLR CBR CPDR DB DP DR DWDM FDL FTP GMPLS HDR IP JIT JET LAN LAUC LAUC-VF LHDR NACK NS NSF Acknowledged (Gói tin xác nhận) Adaptive Hybrid Deflection Routing (Định tuyến lệch hướng lai thích nghi) All-Optical Network (Mạng toàn quang) Burst Control Packet (Gói điều khiển chùm) Burst Header Packet (Gói tiêu đề chùm) Burst Loss Probability (Xác suất chùm) Burst Loss Rate (Tỉ lệ chùm) Constant Bit Rate (Tốc độ bit cố định) Combined Probability Deflected and Retransmission (Kết hợp xác suất lệch hướng truyền lại) Data Burst (Chùm liệu) Dropping Probability (Xác suất rơi chùm) Deflection Routing (Định tuyến lệch hướng) Density Wavelength Division Multiplexing (Ghép kênh phân chia bước sóng dày đặc) Fiber Delay Line (Đường trễ quang) File Transmission Protocol (Giao thức truyền tập tin) Generalized Multi-Protocol Label Switching (Chuyển mạch nhãn đa giao thức tổng quát) Hybrid Deflection Routing (Định tuyến lệch hướng lai) Internet Protocol (Giao thức Internet) Just In Time (Đặt trước tài nguyên tức thì) Just Enough Time (Đặt trước tài nguyên sau khoảng trễ) Local Area Network (Mạng cục bộ) Latest Available Unscheduled Channel (Kênh lập lịch khả dụng gần nhất) Latest Available Unscheduled Channel with void filling (Kênh lập lịch khả dụng gần với lấp đầy khoảng trống) Limited Hybrid Deflection Routing (Định tuyến lệch hướng lai dựa số hop) Not Acknowledged (Gói tin không xác nhận) Network Simulator (Bộ mô mạng) National Science Foundation OBS OCS OPS OTN PDR PRT PR QoS RWA SP TCP UDP WDM WR Optical Burst Switching (Mạng chuyển mạch chùm quang) Optical Circuit Switching (Mạng chuyển mạch kênh quang) Optical Packet Switching (Mạng chuyển mạch gói quang) Optical Transmission Network (Mạng truyền tải quang) Pure Deflection Routing (Thuần định tuyến lệch hướng) Pure Retransmission (Thuần truyền lại) Primary Route (Lộ trình chính) Quality of Service (Chất lượng dịch vụ) Routing and Wavelength Assignment (Định tuyến cấp phát bước sóng) Shortest Path (Đường ngắn nhất) Transmission Control Protocol (Giao thức điều khiển truyền tải) User Data Protocol (Giao thức gói người dùng) Wavelength Division Multiplexing (Kỹ thuật ghép kênh phân chia bước sóng) Wavelength Router (Bộ định tuyến bước sóng) MỞ ĐẦU  Lý chọn đề tài Hiện nay, dịch vụ Internet ngày phát triển rộng rãi yêu cầu băng thông ngày cao Kỹ thuật ghép kênh phân chia bước sóng Wavelength Division Multiplexing (WDM) đời nhằm mục đích đáp ứng yêu cầu Đây công nghệ quan trọng sử dụng mạng tương lai Có nhiều vấn đề cần phải giải mạng quang nhằm ngày hoàn thiện kiến trúc mạng Trong vấn đề đó, việc nghiên cứu mạng chuyển mạch chùm quang Optical Burst Switching (OBS) coi hướng hấp dẫn có ý nghĩa Bởi mạng chuyển mạch chùm quang OBS kết hợp ưu điểm công nghệ chuyển mạch trước đó: công nghệ chuyển mạch kênh quang chuyển mạch gói quang nhằm cố gắng loại bỏ nhược điểm công nghệ mạng WDM Hiện nay, OBS xem công nghệ hứa hẹn cho mạng Internet quang hệ sau Next Generation Network (NGN) [1] Với tốc độ giao tiếp nhu cầu sử dụng băng thông mạng ngày cao vấn đề đặt làm để tăng tốc độ truyền tin, lượng thông tin truyền tải nhanh mà không xảy tình trạng tắc nghẽn Vì vậy, tình trạng tắc nghẽn chùm xem vấn đề thách thức mạng chuyển mạch chùm quang OBS Sự tắc nghẽn chùm xuất hai chùm từ hai cổng vào khác cố gắng cổng thời điểm Nếu với mạng Internet Protocol (IP), vùng đệm Random Access Memory (RAM) sử dụng để lưu tạm thời gói tin IP có độ ưu tiên thấp sau truyền cổng tương ứng rảnh rỗi Tuy nhiên, công nghệ quang không cho phép tạo đệm quang tương tự chùm quang có độ ưu tiên thấp bị loại bỏ Các giải pháp cho việc xử lý tắc nghẽn mạng OBS là: sử dụng đệm Fiber Delay Line (FDL) để làm trễ chùm quang có độ ưu tiên thấp [1][11]; thực chuyển đổi bước sóng hai chùm quang liệu tranh chấp [1][11]; định tuyến chùm quang liệu có độ ưu tiên thấp đến cổng khác sau truyền theo đường truyền khác để đến đích Kỹ thuật xử lý tranh chấp thứ ba có tên gọi kỹ thuật định tuyến lệch hướng Định tuyến lệch hướng thường không ưu tiên mạng chuyển mạch gói điện tử khả lặp lại truyền gói không theo thứ tự Tuy nhiên cần thiết phải cài đặt kỹ thuật định tuyến lệch hướng mạng sợi quang chuyển mạch chùm, nơi mà khả đệm giới hạn Một vấn đề định tuyến lệch hướng chùm chuyển hướng đường dài để tới đích, dẫn tới làm tăng độ trễ giảm chất lượng tín hiệu Một số chế khác phải thực để ngăn chặn độ dài đường lệch hướng mức như: sử dụng đếm số nút qua (hop) cực đại hay xem xét đến khả truyền lại chùm Vì vậy, việc kết hợp phương pháp định tuyến lệch hướng với số phương pháp khác thực cần thiết nhằm tận dụng ưu điểm giải pháp Đây lý chọn đề tài luận văn với tên gọi “TÌM HIỂU MỘT SỐ KỸ THUẬT KẾT HỢP ĐỊNH TUYẾN LỆCH HƯỚNG VÀ TRUYỀN LẠI CHÙM TRONG MẠNG CHUYỂN MẠCH CHÙM QUANG”  Mục tiêu luận văn Mục tiêu Luận văn nghiên cứu số kỹ thuật kết hợp định tuyến lệch hướng truyền lại chùm toán giảm xác suất chùm nút lõi mạng OBS  Đối tượng nghiên cứu - Một số kỹ thuật kết hợp định tuyến lệch hướng truyền lại chùm mạng chuyển mạch chùm quang - Gói mô OBS0.9a tích hợp NS2  Phương pháp nghiên cứu Phương pháp mô (dựa phần mềm mô OBS-ns2)  Phạm vi nghiên cứu Một số kỹ thuật (giải pháp) kết hợp định tuyến lệch hướng với truyền lại chùm nút lõi mạng OBS  Ý nghĩa thực tiễn Trong mạng OBS, tắc nghẽn chùm giải vài phương pháp, chuyển đổi bước sóng, sử dụng vùng đệm liệu dựa đường trễ quang (FDL) định tuyến lệch hướng [1][2] Đối với phương pháp định tuyến lệch hướng, chùm bị tắc nghẽn gửi tới liên kết khác nút sau định tuyến qua tuyến khác để đến đích Định tuyến lệch hướng hướng giải tắc nghẽn thu hút nhiều quan tâm mạng OBS, không cần thêm chi phí thành phần vật lý sử dụng miền phổ quang sẵn có [1][11] Tuy nhiên, lưu lượng mạng tăng lên, định tuyến lệch hướng làm giảm hiệu suất tính ổn định mạng Định tuyến lệch hướng không hoàn toàn loại bỏ việc rơi chùm, đó, số phương pháp khác thường kết hợp với định tuyến lệch hướng để khắc phục nhược điểm Một phương pháp sử dụng kết hợp với định tuyến lệch hướng phương pháp truyền lại chùm (burst retransmission) [7], cho phép chùm bị rơi truyền lại lớp OBS Tuy nhiên, phương pháp gây nên độ trễ mở rộng (extra delay), cụ thể độ trễ truyền lại (retransmission delay) Luận văn nghiên cứu vấn đề việc kết hợp định tuyến lệch hướng Pure Deflection Routing (PDR) với truyền lại chùm Pure Retransmission (PRT)[5][6] Một số mô hình tập trung tìm hiểu Luận văn bao gồm: kết hợp lệch hướng truyền lại Hybrid Deflection Routing (HDR), hạn chế lệch hướng Limited Hybrid Deflection Routing (LHDR), mô hình lai thích nghi adaptive HDR Adaptive Hybrid Deflection Routing (AHDR)[4][8], kết hợp xác suất lệch hướng truyền lại Combined Probability Deflected and Retransmission (CPDR) [3] Việc đánh giá mô hình thực qua mô kết 10 tcl.resultf("%d", nh); return (TCL_OK); } else if (strcmp(argv[1], "nhops_dfl") == 0) { // add by sonhong, return hopcnt of dfl path int src = atoi(argv[2]); int imt = atoi(argv[3]); int dst = atoi(argv[4]); int nodes[256]; int res = lookup_dfl_path(src, imt, dst, nodes); tcl.resultf("%d", res); return (TCL_OK); }// Search a next hop that not come back to src else if (strcmp(argv[1], "lookup_prm") == 0) { // add by sonhong, return next dfl hop int nh; int res = lookup_flat_prm((char*)argv[2], (char*)argv[3], (char*)argv[4], nh); if (res == TCL_OK) tcl.resultf("%d", nh); return (TCL_OK); } else if (strcmp(argv[1], "nhops_prm") == 0) { // add by sonhong, return hopcnt of dfl path int src = atoi(argv[2]); int imt = atoi(argv[3]); int dst = atoi(argv[4]); int nodes[256]; int res = lookup_prm_path(src, imt, dst, nodes); tcl.resultf("%d", res); return (TCL_OK); } } return (TclObject::command(argc, argv)); } // add by sonhong /* * Lookup all intermediate nodes along the shortest path * Return, intermediate node number, or -1, failure */ int RouteLogic::lookup_path (int src, int dst, int *node) { char ssrc[8]; char sdst[8]; int nexthop; int nodenum = 1; sprintf(sdst, "%d", dst); node[0] = src; while ( src != dst ) { sprintf(ssrc, "%d", src); if( TCL_ERROR == lookup_flat(ssrc, sdst, nexthop) ) { printf("lookup flat routes error from %d to %d\n", src, dst); return -1; } // nexthop || nexthop >= 256 ) { //fprintf(stderr, "no next hop from %d to %d\n", src, dst); return -1; } node[nodenum++] = nexthop; src = nexthop; } return nodenum; } // add by sonhong // Lookup all intermediate nodes along the alternative shortest path int RouteLogic::lookup_alt_path (int src, int dst, int *node) { // only for dump if (src == dst) { node[0] = src; return 1; } // look up the shortest path nodes, node1 int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } // temporarily set costs INFINITY int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; } // re-compute the routes compute_routes(); //look up the alternative shortest path, return path int ret; ret = lookup_path( src, dst, node ); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; // re-compute the routes compute_routes(); return ret; } // add by sonhong int RouteLogic::lookup_flat_alt(char* asrc, char* adst, int& result) { Tcl& tcl = Tcl::instance(); int src = atoi(asrc) ; int dst = atoi(adst) ; if (route_ == 0) { // routes are computed only after the simulator is running // ($ns run) tcl.result("routes not yet computed"); return (TCL_ERROR); } if (src >= size_ || dst >= size_) { tcl.result("node out of range"); return (TCL_ERROR); } // temporarily set costs INFINITY int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; } // re-compute the routes compute_routes(); lookup_flat(asrc, adst, result); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; // re-compute the routes compute_routes(); return TCL_OK; } // add by sonhong /* Return next hop for deflected path: - Find the path between src-dst - Give links of this path INFINITY cost - Find path from imt to dst */ int RouteLogic::lookup_flat_dfl(char* asrc, char* aimt, char* adst, int& result){ Tcl& tcl = Tcl::instance(); int src = atoi(asrc) ; int dst = atoi(adst) ; int imt = atoi(aimt) ; if (route_ == 0) { // routes are computed only after the simulator is running // ($ns run) tcl.result("routes not yet computed"); return (TCL_ERROR); } if (src >= size_ || dst >= size_) { tcl.result("node out of range"); return (TCL_ERROR); } //temporarily set costs INFINITY int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; adj_[INDEX(ndst, nsrc, size_)].cost = INFINITY; if ( (nsrc - 1) != imt ) for (int j = 0; j < size_; j++){ adj_[INDEX(nsrc, j, size_)].cost = INFINITY; adj_[INDEX(j, nsrc, size_)].cost = INFINITY; } } // re-compute the routes compute_routes(); lookup_flat(aimt, adst, result); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; // re-compute the routes compute_routes(); return TCL_OK; return TCL_OK; } int RouteLogic::lookup_dfl_path(int src, int imt, int dst, int *node){ // only for dump if (src == dst) { node[0] = src; return 1; } // look up the shortest path nodes, node1 int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } // temporarily set costs INFINITY int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; adj_[INDEX(ndst, nsrc, size_)].cost = INFINITY; } // re-compute the routes compute_routes(); // look up the alternative shortest path, return path int ret; ret = lookup_path( imt, dst, node ); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; // re-compute the routes compute_routes(); return ret; } // add by sonhong /*Return next hop for primary path that not come back to the source node: - Find the path between src-dst - Give links of this path INFINITY cost - Find path from imt to dst */ int RouteLogic::lookup_flat_prm(char* asrc, char* aimt, char* adst, int& result){ Tcl& tcl = Tcl::instance(); int src = atoi(asrc) ; int dst = atoi(adst) ; int imt = atoi(aimt) ; if (route_ == 0) { // routes are computed only after the simulator is running // ($ns run) tcl.result("routes not yet computed"); return (TCL_ERROR); } if (src >= size_ || dst >= size_) { tcl.result("node out of range"); return (TCL_ERROR); } //temporarily set costs INFINITY int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; adj_[INDEX(ndst, nsrc, size_)].cost = INFINITY; for (int j = 0; j < size_; j++){ adj_[INDEX(nsrc, j, size_)].cost = INFINITY; adj_[INDEX(j, nsrc, size_)].cost = INFINITY; } } //re-compute the routes compute_routes(); lookup_flat(aimt, adst, result); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; /* * re-compute the routes */ compute_routes(); return TCL_OK; } int RouteLogic::lookup_prm_path(int src, int imt, int dst, int *node){ // only for dump if (src == dst) { node[0] = src; return 1; } // look up the shortest path nodes, node1 int node1_num; int node1[1024]; if( -1 == (node1_num = lookup_path( src, dst, node1 )) ) { printf("lookup the shortest path error from %d to %d\n", src, dst); return -1; } //temporarily set costs INFINITY int adj_size = size_ * size_; adj_entry* adj_org = new adj_entry[adj_size]; memcpy( (void *)adj_org, (void *)adj_, sizeof(adj_entry) * adj_size ); for (int i = 1; i < node1_num; i++) { int nsrc = node1[i - 1] + 1; int ndst = node1[i] + 1; adj_[INDEX(nsrc, ndst, size_)].cost = INFINITY; adj_[INDEX(ndst, nsrc, size_)].cost = INFINITY; } // re-compute the routes compute_routes(); // look up the alternative shortest path, return path int ret; ret = lookup_path( imt, dst, node ); // recover the adj_ memcpy( (void *)adj_, (void *)adj_org, sizeof(adj_entry) * adj_size ); delete[] adj_org; // re-compute the routes compute_routes(); return ret; }