SDN实验（九）——基于链路质量的最短路径转发算法

已于 2023-02-16 11:00:51 修改
阅读量2.4k 收藏 29
点赞数 4
分类专栏： SDN 文章标签： Ryu
于 2022-10-18 17:10:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41422448/article/details/127389619
版权

SDN实验（九）——基于链路质量的最短路径转发算法

一、原理

  关于时延探测原理和网络拓扑的发现原理，这里不再叙述，详细请参考：

二、拓扑结构

在这里插入图片描述

三、程序设计

1、获取链路拓扑

通过topology/api提供get方法，获取链路拓扑的switch和link的信息，并将switch作为节点，link作为边，默认初始边权为0，写入有向图中，具体代码如下：

    # 获取网络链路拓扑
    # 即将节点和边信息写入有向图中，默认的权重为0
    @set_ev_cls(events)
    def get_topo(self, ev):
        switch_list = get_switch(self.topology_api_app)
        topo_switches = []
        # 得到每个设备的id，并写入图中作为图的节点
        for switch in switch_list:
            topo_switches.append(switch.dp.id)
        self.G.add_nodes_from(topo_switches)
 
        link_list = get_link(self.topology_api_app)
        self.links_src_dst = []
        # 将得到的链路的信息作为边写入图中
        # 注意这里links_src_dst时列表里列表，即[[],[],[]]，不能是元组，因为元组不可更改，也就是后面无法更新权重信息
        for link in link_list:
            self.links_src_dst.append([link.src.dpid, link.dst.dpid, 0])
        self.G.add_weighted_edges_from(self.links_src_dst)
 
        for link in link_list:
            self.links_src_dst.append([link.dst.dpid, link.src.dpid, 0])
        self.G.add_weighted_edges_from(self.links_src_dst)

2、更新拓扑信息

这里的更新主要是利用实时的链路时延信息，将时延作为权重信息更新进入有向图中，具体代码如下：

    # 更新拓扑信息，主要更新有向图的边的权重
    # 即，程序获取链路的实时时延，当时延变化时，就将新的时延作为权重写入有向图中
    def update_topo(self):
        # [[1, 2, 0], [3, 2, 0], [2, 1, 0], [2, 3, 0], [2, 1, 0], [2, 3, 0], [1, 2, 0], [3, 2, 0]]
        # {'2-3-3': 0.000362396240234375, '2-2-1': 0.001207113265991211, '1-2-2': 0.0004553794860839844, '3-2-2': 0.00015854835510253906}
        # 将link_Delay的时延作为权重更新进links_src_dst列表中，然后更新入有向图
        for key in self.link_Delay:
            list = key.split('-')
            l = (int(list[0]), int(list[2]))
            for i in self.links_src_dst:
                if l == (i[0], i[1]):
                    i[2] = self.link_Delay[key]
 
        self.G.add_weighted_edges_from(self.links_src_dst)

3、获取输出端口

也就是利用有向图的边权计算源到目的权值和最小的路径，根据路径得到每一跳需要转发数据的端口，比如说控制器收到s1-s5发送的数据，获取最小权重和的路径是s1-s3-s5，此时需要将s1数据转发到s3中，这时的s1-s3的连接是s1的1端口连接的，所以out_port=1。具体代码如下：

    # 获取输出的端口，这里的输出端口是控制器指示数据转发时按照最短权重获得的输出端口进行数据转发
    def get_out_port(self, datapath, src, dst, in_port):
        global out_port
        dpid = datapath.id
 
        # 开始时，各个主机可能在图中不存在，因为开始ryu只获取了交换机的dpid，并不知道各主机的信息，
        # 所以需要将主机存入图中
        # 同时将记录主机和交换机之间的连接关系和端口
        if src not in self.G:
            self.G.add_node(src)
            self.G.add_weighted_edges_from([[dpid, src, 0]])
            self.G.add_weighted_edges_from([[src, dpid, 0]])
            src_dst = "%s-%s" % (dpid, src)
            self.id_port[src_dst] = in_port
 
        # 计算出基于最小权重的链路，按照这个转发链路进行数据的转发
        if dst in self.G:
            path = nx.shortest_path(self.G, src, dst, weight='weight')
            next_hop = path[path.index(dpid) + 1]
            for key in self.id_port:
                match_key = "%s-%s" % (dpid, next_hop)
                if key == match_key:
                    out_port = self.id_port[key]
                    # print('key_out_port:', out_port)
            print(path)
        else:
            out_port = datapath.ofproto.OFPP_FLOOD
        return out_port

4、处理packet_in消息

packet_in消息主要是控制器处理交换机的数据，本程序主要包括处理LLDP和主机的转发信息两种。具体代码和解释如下：

    # 处理由交换机到来的消息，如LLDP消息和数据转发的消息
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofp = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        dpid = datapath.id
        in_port = msg.match['in_port']
 
        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocols(ethernet.ethernet)[0]
 
        dst = eth.dst
        src = eth.src
 
        # try...except，由于packetin中存在LLDP消息和主机的数据转发消息，
        # 二者格式不一样，所以用try...except进行控制，分别处理两种消息；
        try:  # 处理到达的LLDP报文，从而获得LLDP时延
            src_dpid, src_outport = LLDPPacket.lldp_parse(msg.data)  # 获取两个相邻交换机的源交换机dpid和port_no(与目的交换机相连的端口)
            dst_dpid = msg.datapath.id  # 获取目的交换机（第二个），因为来到控制器的消息是由第二个（目的）交换机上传过来的
            if self.switches is None:
                self.switches = lookup_service_brick("switches")  # 获取交换机模块实例
 
            # 获得key（Port类实例）和data（PortData类实例）
            for port in self.switches.ports.keys():  # 开始获取对应交换机端口的发送时间戳
                if src_dpid == port.dpid and src_outport == port.port_no:  # 匹配key
                    port_data = self.switches.ports[port]  # 获取满足key条件的values值PortData实例，内部保存了发送LLDP报文时的timestamp信息
                    timestamp = port_data.timestamp
                    if timestamp:
                        delay = time.time() - timestamp
                        self._save_delay_data(src=src_dpid, dst=dst_dpid, src_port=src_outport, lldp_dealy=delay)
        except Exception as error:  # 处理到达的主机的转发消息
            out_port = self.get_out_port(datapath, src, dst, in_port)
            actions = [ofp_parser.OFPActionOutput(out_port)]
 
            # 这里如果使用add_flow()进行了流表的添加，那么程序中的实时更新拓扑的权重就无意义了，转发就会依据流表进行
            # 所以这里不使用add_flow()方法，而是采用hub的形式，也就是每次转发都会请求控制器进行实时计算链路质量
 
            # 如果执行的动作不是flood，那么此时应该依据流表项进行转发操作，所以需要添加流表到交换机
            # if out_port != ofp.OFPP_FLOOD:
            #     match = ofp_parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
            #     self.add_flow(datapath=datapath, priority=1, match=match, actions=actions)
 
            data = None
            if msg.buffer_id == ofp.OFP_NO_BUFFER:
                data = msg.data
            # 控制器指导执行的命令
            out = ofp_parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                          in_port=in_port, actions=actions, data=data)
            datapath.send_msg(out)

四、实验验证

1、启动Ryu控制器

ryu-manager quality_path_forward.py --observe-links

在这里插入图片描述

2、运行拓扑

sudo python3 quality_path_forward.py

在这里插入图片描述

3、ping验证

h1 ping h2

在这里插入图片描述
  可以发现主机之间的通信路径会根据时延信息变化，可以自行进行权重变化验证是否会根据时延不同切换链路。

五、Ryu源码

import time

from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER, CONFIG_DISPATCHER, HANDSHAKE_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.lib import hub
from ryu.ofproto import ofproto_v1_3
from ryu.topology.switches import LLDPPacket
from ryu.base.app_manager import lookup_service_brick
from ryu.lib.packet import packet
from ryu.lib.packet import ethernet

# 导入这些主要是为了让网络链路中产生LLDP数据包，只有产生了LLDP数据报，才能进行LLDP时延探测
from ryu.topology.api import get_switch, get_link, get_host
from ryu.topology import event, switches

# networkx用于存储链路信息，本程序存储为一个有向图
import networkx as nx

class DelayDetector(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION] 

    def __init__(self, *args, **kwargs):
        super(DelayDetector, self).__init__(*args, *kwargs)
        self.name = 'delay_detector'
        self.switches = lookup_service_brick('switches')
        # 初始化networkx的有向图
        self.G = nx.DiGraph()
        self.topology_api_app = self

        # 存储网络拓扑的交换机id
        self.dpidSwitch = {}
        # 存储echo往返时延
        self.echoDelay = {}
        # 存储LLDP时延
        self.src_dstDelay = {}
        # 存储链路的时延，即LLDP时延-echo的时延，计算出的每条链路的时延
        self.link_Delay = {}

        # 存储源-目的-权重(时延)的列表，用于向有向图写入边信息
        self.links_src_dst = []
        # 存储整个链路各个节点之间的连接信息，包括源端口，
        # 例如s1-s2，通过s1的2端口连接，存储的信息即为：{’1-2‘：2}
        self.id_port = {}

        # 实现协程，进行时延的周期探测
        self.detector_thread = hub.spawn(self.detector)

    # 每间隔三秒，进行如下操作：
    # 控制器向交换机发送一次echo报文，用以获取往返时延
    # echo时延知道后，计算各个链路的时延，即LLDP-echo时延
    # 根据各个链路的时延更新网络拓扑有向图的每条边的权重
    def detector(self):
        while True:
            self.send_echo_request()
            self.link_delay()
            self.update_topo()
            hub.sleep(3)

    """==========================usually=========================================="""
    def add_flow(self, datapath, priority, match, actions):
        ofp = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        command = ofp.OFPFC_ADD
        inst = [ofp_parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]
        req = ofp_parser.OFPFlowMod(datapath=datapath, command=command,
                                    priority=priority, match=match, instructions=inst)
        datapath.send_msg(req)

    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_features_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofp = datapath.ofproto
        ofp_parser = datapath.ofproto_parser

        # add table-miss
        match = ofp_parser.OFPMatch()
        actions = [ofp_parser.OFPActionOutput(ofp.OFPP_CONTROLLER, ofp.OFPCML_NO_BUFFER)]
        self.add_flow(datapath=datapath, priority=0, match=match, actions=actions)
    """=================================================================================="""

    """这个方法的作用是什么呢？存疑"""
    """=================================================================================="""
    @set_ev_cls(ofp_event.EventOFPStateChange, [MAIN_DISPATCHER, DEAD_DISPATCHER])
    def state_change_handler(self, ev):
        datapath = ev.datapath
        if ev.state == MAIN_DISPATCHER:
            if not datapath.id in self.dpidSwitch:
                self.dpidSwitch[datapath.id] = datapath
        elif ev.state == DEAD_DISPATCHER:
            if datapath.id in self.dpidSwitch:
                del self.dpidSwitch[datapath.id]

    events = [event.EventSwitchEnter, event.EventSwitchLeave,
              event.EventSwitchReconnected,
              event.EventPortAdd, event.EventPortDelete,
              event.EventPortModify,
              event.EventLinkAdd, event.EventLinkDelete]

    # 获取网络链路拓扑
    # 即将节点和边信息写入有向图中，默认的权重为0
    @set_ev_cls(events)
    def get_topo(self, ev):
        switch_list = get_switch(self.topology_api_app)
        topo_switches = []
        # 得到每个设备的id，并写入图中作为图的节点
        for switch in switch_list:
            topo_switches.append(switch.dp.id)
        self.G.add_nodes_from(topo_switches)

        link_list = get_link(self.topology_api_app)
        self.links_src_dst = []
        # 将得到的链路的信息作为边写入图中
        # 注意这里links_src_dst是列表里列表，即[[],[],[]]，不能是元组，因为元组不可更改，也就是后面无法更新权重信息
        for link in link_list:
            self.links_src_dst.append([link.src.dpid, link.dst.dpid, 0])
        self.G.add_weighted_edges_from(self.links_src_dst)

        for link in link_list:
            self.links_src_dst.append([link.dst.dpid, link.src.dpid, 0])
        self.G.add_weighted_edges_from(self.links_src_dst)

    # 更新拓扑信息，主要更新有向图的边的权重
    # 即，程序获取链路的实时时延，当时延变化时，就将新的时延作为权重写入有向图中
    def update_topo(self):
        # [[1, 2, 0], [3, 2, 0], [2, 1, 0], [2, 3, 0], [2, 1, 0], [2, 3, 0], [1, 2, 0], [3, 2, 0]]
        # {'2-3-3': 0.000362396240234375, '2-2-1': 0.001207113265991211, '1-2-2': 0.0004553794860839844, '3-2-2': 0.00015854835510253906}
        # 将link_Delay的时延作为权重更新进links_src_dst列表中，然后更新入有向图
        for key in self.link_Delay:
            list = key.split('-')
            l = (int(list[0]), int(list[2]))
            for i in self.links_src_dst:
                if l == (i[0], i[1]):
                    i[2] = self.link_Delay[key]

        self.G.add_weighted_edges_from(self.links_src_dst)

    # 获取输出的端口，这里的输出端口是控制器指示数据转发时按照最短权重获得的输出端口进行数据转发
    def get_out_port(self, datapath, src, dst, in_port):
        global out_port
        dpid = datapath.id

        # 开始时，各个主机可能在图中不存在，因为开始ryu只获取了交换机的dpid，并不知道各主机的信息，
        # 所以需要将主机存入图中
        # 同时将记录主机和交换机之间的连接关系和端口
        if src not in self.G:
            self.G.add_node(src)
            self.G.add_weighted_edges_from([[dpid, src, 0]])
            self.G.add_weighted_edges_from([[src, dpid, 0]])
            src_dst = "%s-%s" % (dpid, src)
            self.id_port[src_dst] = in_port

        # 计算出基于最小权重的链路，按照这个转发链路进行数据的转发
        if dst in self.G:
            path = nx.shortest_path(self.G, src, dst, weight='weight')
            next_hop = path[path.index(dpid) + 1]
            for key in self.id_port:
                match_key = "%s-%s" % (dpid, next_hop)
                if key == match_key:
                    out_port = self.id_port[key]
                    # print('key_out_port:', out_port)
            print(path)
        else:
            out_port = datapath.ofproto.OFPP_FLOOD
        return out_port

    # 由控制器向交换机发送echo报文，同时记录此时时间
    def send_echo_request(self):
        # 循环遍历交换机，逐一向存在的交换机发送echo探测报文
        for datapath in self.dpidSwitch.values():
            parser = datapath.ofproto_parser
            echo_req = parser.OFPEchoRequest(datapath, data=bytes("%.12f" % time.time(), encoding="utf8"))  # 获取当前时间

            datapath.send_msg(echo_req)
            # 每隔0.5秒向下一个交换机发送echo报文，防止回送报文同时到达控制器
            hub.sleep(0.5)

    # 交换机向控制器的echo请求回应报文，收到此报文时，控制器通过当前时间-时间戳，计算出往返时延
    @set_ev_cls(ofp_event.EventOFPEchoReply, [MAIN_DISPATCHER, CONFIG_DISPATCHER, HANDSHAKE_DISPATCHER])
    def echo_reply_handler(self, ev):
        now_timestamp = time.time()
        try:
            echo_delay = now_timestamp - eval(ev.msg.data)
            # 将交换机对应的echo时延写入字典保存起来
            self.echoDelay[ev.msg.datapath.id] = echo_delay
        except Exception as error:
            print("echo error:", error)
            return

    # 处理由交换机到来的消息，如LLDP消息和数据转发的消息
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofp = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        dpid = datapath.id
        in_port = msg.match['in_port']

        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocols(ethernet.ethernet)[0]

        dst = eth.dst
        src = eth.src

        # try...except，由于packetin中存在LLDP消息和主机的数据转发消息，
        # 二者格式不一样，所以用try...except进行控制，分别处理两种消息；
        try:  # 处理到达的LLDP报文，从而获得LLDP时延
            # 获取两个相邻交换机的源交换机dpid和port_no(与目的交换机相连的端口)
            src_dpid, src_outport = LLDPPacket.lldp_parse(msg.data)  
            dst_dpid = msg.datapath.id  # 获取目的交换机（第二个），因为来到控制器的消息是由第二个（目的）交换机上传过来的
            if self.switches is None:
                self.switches = lookup_service_brick("switches")  # 获取交换机模块实例

            # 获得key（Port类实例）和data（PortData类实例）
            for port in self.switches.ports.keys():  # 开始获取对应交换机端口的发送时间戳
                if src_dpid == port.dpid and src_outport == port.port_no:  # 匹配key
                    port_data = self.switches.ports[port]  # 获取满足key条件的values值PortData实例，内部保存了发送LLDP报文时的timestamp信息
                    timestamp = port_data.timestamp
                    if timestamp:
                        delay = time.time() - timestamp
                        self._save_delay_data(src=src_dpid, dst=dst_dpid, src_port=src_outport, lldp_dealy=delay)
        except Exception as error:  # 处理到达的主机的转发消息
            out_port = self.get_out_port(datapath, src, dst, in_port)
            actions = [ofp_parser.OFPActionOutput(out_port)]

            # 这里如果使用add_flow()进行了流表的添加，那么程序中的实时更新拓扑的权重就无意义了，转发就会依据流表进行
            # 所以这里不使用add_flow()方法，而是采用hub的形式，也就是每次转发都会请求控制器进行实时计算链路质量

            # 如果执行的动作不是flood，那么此时应该依据流表项进行转发操作，所以需要添加流表到交换机
            # if out_port != ofp.OFPP_FLOOD:
            #     match = ofp_parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
            #     self.add_flow(datapath=datapath, priority=1, match=match, actions=actions)

            data = None
            if msg.buffer_id == ofp.OFP_NO_BUFFER:
                data = msg.data
            # 控制器指导执行的命令
            out = ofp_parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                          in_port=in_port, actions=actions, data=data)
            datapath.send_msg(out)

    # 用于存储各个LLDP的时延
    # 同时记录拓扑中各个交换机之间的连接
    def _save_delay_data(self, src, dst, src_port, lldp_dealy):
        key = "%s-%s-%s" % (src, src_port, dst)
        src_dst = "%s-%s" % (src, dst)
        self.id_port[src_dst] = src_port
        # {'1-2': 2, '3-2': 2, '2-1': 2, '2-3': 3}
        self.src_dstDelay[key] = lldp_dealy

    # 计算链路的时延
    def link_delay(self):
        for key in self.src_dstDelay:
            list = key.split('-')
            t1 = 0
            t2 = 0
            for key_s in self.echoDelay:
                if key_s == int(list[0]):
                    t1 = self.echoDelay[key_s]
                if key_s == int(list[2]):
                    t2 = self.echoDelay[key_s]
            delay = self.src_dstDelay[key] - (t1 + t2) / 2
            # 由于误差及其他原因，可能出现时延为负值情况，如果为负值就不要进行时延的更新
            if delay >= 0:
                self.link_Delay[key] = self.src_dstDelay[key] - (t1 + t2) / 2
            else:
                continue
程序员小菜鸡_
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
关于Ryu基于跳数的最短路径转发运行报错的问题汇总
Mr_Wanderer的博客
06-29 1161
关于Ryu基于跳数的最短路径转发运行报错的问题汇总写在前面代码展示networkx.DiGraph.add_edge()函数参数数量报错Mininet连接控制器后，主机间ping不通再放一下我修改后的代码吧 写在前面 这篇文章是本人的第一篇投稿，万分紧张，希望一切顺利，有什么错误还请大家指正。 本文记录了一些我在运行李呈老师的Ryu基于跳数的最短路径转发代码时遇到的错误，以及如何解决的，希望能够给大家带来帮助。 代码展示 请勿直接粘贴此代码！！！有错误 from ryu.base import app_ma
3.1 流量监控+最短路径转发
小蒋的博客
10-05 478
3.1 流量监控+最短路径转发
ospf实验
bengbengbuhuitia的博客
11-17 51
ospf实验
SDN-Route:使用 RYU 控制器在 SDN 中实现 Dijkstra 最短路径
05-30
SDN-路由 使用 RYU 控制器在 SDN 中实现 Dijkstra 最短路径
SDN实验---Ryu的应用开发（三）基于跳数的最短路径转发原理
weixin_45236003的博客
03-30 689
掌握基于Ryu开发最短路径转发应用: 基于网络信息进行复杂网络算法实现。
【软件定义网络】实验一：SDN拓扑实践 & 实验二：Open vSwitch虚拟交换机实践
Yophan的博客
09-18 4399
实验难度：适中实验过程中遇到的困难与解决办法：刚开始安装虚拟机和配置实验环境的时候，也遇到了不少报错，比如java环境配置，python库安装，ryu插件的安装，基本都是自己通过网上的教程，反复地去尝试，一步一步排除错误。因为是第一次用虚拟机，所以刚开始对各种操作都比较生疏，但经过这一次实验，变得更加熟练。开始做实验的时候，发生了棘手的问题，一个是重启系统后虚拟机启动时候报错，为了解决这个错误，花费了不少时间，终于在一个偏僻的个人网站找到了解决方法；一个是重启虚拟机后所有图标和菜单栏都消失了。
ryu实例---基于跳数的最短路径转发
北风
05-18 5690
参考网上的一些知识，本篇内容主要介绍如何利用networkx实现最短路径转发，同时介绍ryu如何获取链路拓扑。 一、获取拓扑 对于ryu控制器而言，获取链路拓扑的主要模块在ryu/topology目录下面，下面主要介绍接下来用到的api.py和switches.py。 (1) api: api是ryu对开发者提供的获取链路信息的接口，api提供了get_switch(), get_link()方法，通过这两个接口，可以获取链路的交换机的信息和各个节点的链路信息，具体的代码如下。 def get_
一、SDN-计算机网络（1）
qq_55202378的博客
04-03 969
UDP检验和：UDP的检验和是把首部和数据部分一起都检验，而IP数据报的检验和只检验IP数据报的首部。在计算检验和之前，要在UDP数据报之前增加长度为12B的伪首部，伪首部只在计算检验和时临时添加到UDP数据报前面，并不是UDP真正的首部，且不会和数据一起发送。BGP协议使用AS号来防止路由环路，当某路由器收到路由时，会查看路由中的AS属性信息，若在AS属性列表中发现自身的AS号，则会丢弃该路由。首部长度不受MTU大小限制；在传输层中，TCP和UDP首部中的检验和字段，同时检验首部和数据是否出现差错。
dijkstra-SDN-Ryu：这就是我实现Dijkstra算法以在SDN上找到最短路径的方式
02-05
这就是我实现Dijkstra算法以在SDN上找到最短路径的方式。 我使用了三种拓扑和基于带宽的OSPF成本。 我将距离矩阵声明为常数。 也许当您第一次尝试使用控制器代码时，它会显示“键错误（0）”，请耐心等待代码花时间...
SDN环境下基于QLearning算法的业务划分路由选路机制
01-20
在软件定义网络环境下，提出一种以业务属性为依据、基于QLearning算法的路由选路机制，设计了链路发现、链路分类、强化学习训练及Q值表下发4个模块，根据网络的实施情况对不同属性的业务流分配不同的路径以保障用户...
一种基于SDN的移动自组织网络服务路径重建算法
01-19
针对基于SDN的移动自组织网络链路故障时的服务路径重建问题，提出一种服务路径分级重建方法，通过备份重建和计算重建相结合的过程提高了服务路径重建的时效性；同时，考虑服务路径重建可能引发的路径冲突问题，从...
论文研究-SDN中基于负载均衡的最优路径分配算法研究.pdf
07-22
针对传统网络控制与转发的紧耦合，其路径分配算法的全局性差、实时性不足，根据软件定义网络的集中控制，提出一种基于马尔可夫链负载均衡（Markov chain-load balancing，MC-LB）算法。该算法使用马尔可夫链的转移...
异构网络互联；路由与转发；SDN基本概念；拥塞控制
codefan※的博客
09-12 1808
一、网络层的功能（1）路由选择与分组转发（2）异构网络互联（3）拥塞控制网络层传输单位是二、网络层的设计思路向上只提供简单灵活的、无连接的、尽最大努力交付的数据报服务三、异构网络互联网络互联是指将两个以上的计算机网络，通过一定的方法，用一些中间设备相互连接起来，以构成更大的网络系统四、中继系统（1）物理层~：转发器，集线器（2）数据链路层~：网桥或交换机（4）网络层以上~：网关五、路由选择和分组转发六、软件定义网络SDN见讲义重点的图七、拥塞控制（1）
22、通用转发和SDN
单俞浩的博客
05-23 1462
一、网络层功能 1、转发：对于从某个端口来的分组转发到合适的输出端口，数据平面 2、路由：决定分组从源端口到目标端口的路径（路由选择算法）,控制平面 这种功能称之为 垂直集成 的方式，每个路由器即执行控制平面，又执行数据平面。控制平面：路由器上运行路由协议实体，自己查路由表，自己做路由通告寻找下一跳。然后交给IP协议实体，由IP协议实体对到来的分组进行转发：数据平面 3、数据平面和控制平面 IP转发：对于到来的分组按照路由表决定如何转发，数据平面 路由：决定路径、计算路由表，处于控制平面，是传统的转发方式
SDN网络中的转发数据和数据传输
lingshengxiyou的博客
12-16 1223
如果类比传统路由器，控制器中的转发设备数据可以类比CPU中的RIB和ARP Cache，而虚拟软件交换机中的转发设备数据，可以类比硬件交换芯片的转发表项，在CPU中存在单独的进程和交换芯片SDK来处理RIB和硬件交换芯片转发表之间的同步。控制器再同步最新的数据到数据面节点。使用RPC的方式，Agent没法很好的持久化保存转发数据，因为控制器和数据面agent是通过网络通信的，所以在一些数据消息丢失的情况下，Agent的状态比较难排查。数据库的数据，表示的是转发数据最新的状态，没有数据的历史状态。
ryu实例---ECMP的rr(轮询)算法实现
北风
05-15 3296
最近，做到一个实验，需要每隔一段时间，就改变数据的传输路径，如下图所示，主机之间的数据传输需要经过s1和s2两个交换机，交换机之间的链路有两条，实验是在这两条链路之间每隔10秒切换一次，也就是相当于ECMP的轮询算法（当然，若想以流为单位切换链路，比如说：上一个流经链路1下一条流经链路2，这种方式的轮询利用集线器的程序改变一下就可以实现）。 轮询，即各个流在多条路径之间轮询传输。 拓扑的端口对应关系： 接下来，重点说明程序如何写，不再赘述一些关于拓扑构建和轮询的一些概念。 一、程序 SDN架
基本中型网络的仿真（RYU+Mininet的SDN架构）-以校园为例
weixin_53284122的博客
02-25 8953
网络设计
【RYU】rest_router.py源码解析
谈论现实
07-29 367
RYU中rest_router.py源码解析
java毕设&课设-图书管理系统（完整的）.zip
最新发布
07-21
计算机毕业设计资源包含（项目部署视频+源码+LW+开题报告等等），所有项目经过助教老师跑通，有问题可以私信博主解决，可以免费帮部署。
基于贪心算法的节点映射策略和基于k最短路径的链路映射策略
06-05
基于贪心算法的节点映射策略和基于k最短路径的链路映射策略都是在SDN网络中常用的映射策略，下面对这两种映射策略进行简单介绍。 基于贪心算法的节点映射策略： 这种策略会优先选择当前可用资源最多的节点进行任务映射，以实现最大化的资源利用率。具体而言，节点映射策略会将任务逐个分配给可用资源最多的节点，直到所有任务都被映射。这种策略的优点是简单易实现，且能够充分利用网络资源，但缺点是可能会出现资源浪费和负载不均衡的问题。 基于k最短路径的链路映射策略： 这种策略会根据链路上的拥塞状况，选择链路上最短的前k条路径，进行链路映射。具体而言，链路映射策略会通过监控链路负载，选择前k条负载最小的路径，将任务映射到这些路径上。这种策略的优点是能够有效地解决链路拥塞问题，但缺点是需要实时监控链路负载，计算复杂度较高。 综上所述，基于贪心算法的节点映射策略和基于k最短路径的链路映射策略都有各自的优缺点。需要根据具体的应用场景和需求，选择合适的映射策略。同时，为了实现更好的映射效果，可以结合两种策略进行优化，如基于贪心算法的节点映射策略，结合链路负载信息，选择可用资源最多且链路负载最小的节点进行任务映射。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值