通向码农的道路(enet开源翻译计划 一)

原创 2015年07月10日 23:50:01

QQ 324186207群 enet交流技术,主要是为了研究tcp内部运行机制,欢迎大家加入探讨,小弟水平有限,翻译难免有误。。

Features:

    ENet evolved specifically as a UDP networking layer for the multiplayer first person shooter Cube.
ENet 最初衷设计为了第一人称射击类游戏。为什么需要udp (参考,unix网络编程,如果不是为了进行多播,不要使用udp,我们应该使用tcp,让厂商来关注性能 )因为无法容忍延迟。(参考tcp v1)


目前我们游戏来看卡牌塔防类,根本不需要udp  就算有高延迟玩家有什么不能接受的, 看看梦幻细雨,有时候一回合延迟高达10秒??  最终我们失去了tcp的重新分组,快速恢复算法,快速重传,延迟确认机制 ,坚持定时器........ 

因为看到腾讯的 t3 面试问题 如何提网络吞吐量?enet 正是如何回答这个问题的最佳方案,我想enet 正是学习tcp最佳路程,如果只是看内核tcp源码学习,难免会有点不自量力。 

1.
     
enet_host_create( &address, 4095200 );  // num of clients, num of channels, incoming bandwidth, outgoing bandwidth。


 channels  这个设计目前我理解的为了进行负载均衡, 比如 client    -》 zoneconnect     -》 zoneserver   
如果此时  client zoneconnect  1 num   ,
zoneconnect  zoneserver   2  num ,     1 num  之间通信发生了拥塞,此时通过拥塞控制,减少发包频率,如果 2  num 也在发包呢?  然而此时的 1  num 已经发生了拥塞 ,那么我们的所需要发送的数据包,只有异步等待 1 num发送  为了解决这个问题的延迟,并减少对数据包的限制,使用多通道独立的进行发送,因此此时一个通道的数据包传送状态不会影响其他通道的包传送 。
 如果默认为0 则是禁止开启流量控制,和拥塞控制。(参考 tcpv2 内核源码)


    To combat this latency and reduce the ordering restrictions on packets, ENet provides multiple channels of communication over a given connection. Each channel is independently sequenced, and so the delivery status of a packet in one channel will not stall the delivery of other packets in another channel.

 
ENetHost *

enet_host_create (const ENetAddress * address, size_t peerCount, size_t channelLimit, enet_uint32 incomingBandwidth,enet_uint32 outgoingBandwidth)

{

    ENetHost * host; //服务器本端 一个全局变量存储数据

    ENetPeer * currentPeer;//当前客户端就是一个peer 

//ENET_PROTOCOL_MAXIMUM_PEER_ID

//

    if( peerCount > ENET_PROTOCOL_MAXIMUM_PEER_ID ) 

      return NULL;


    host = (ENetHost *) enet_malloc (sizeof (ENetHost));

    if (host == NULL)

      return NULL;

    memset(host, 0sizeof (ENetHost));


    host ->peers = (ENetPeer *) enet_malloc (peerCount * sizeof (ENetPeer));

    if (host ->peers == NULL)

    {

       enet_free (host);


       return NULL;

    }

    memset (host ->peers0, peerCount * sizeof (ENetPeer));


    host ->socket = enet_socket_create (ENET_SOCKET_TYPE_DATAGRAM);

    if (host ->socket == ENET_SOCKET_NULL || (address != NULL && enet_socket_bind (host ->socket, address) < 0))

    {

       if (host ->socket != ENET_SOCKET_NULL)

         enet_socket_destroy (host ->socket);


       enet_free (host ->peers);

       enet_free (host);


       return NULL;

    }


    enet_socket_set_option (host ->socketENET_SOCKOPT_NONBLOCK1); //设置非阻塞

    enet_socket_set_option (host ->socketENET_SOCKOPT_BROADCAST1);//设置广播 

    enet_socket_set_option (host ->socketENET_SOCKOPT_RCVBUFENET_HOST_RECEIVE_BUFFER_SIZE); //设置socket 接受缓冲区

    enet_socket_set_option (host ->socketENET_SOCKOPT_SNDBUFENET_HOST_SEND_BUFFER_SIZE);//设置socket发送缓冲区


    if (address != NULL && enet_socket_get_address (host ->socket, & host -> address) < 0 // 绑定socket  设置地址

      host -> address = * address;


    if (! channelLimit || channelLimit > ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT)

      channelLimit = ENET_PROTOCOL_MAXIMUM_CHANNEL_COUNT;

    else

    if (channelLimit < ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT)

      channelLimit = ENET_PROTOCOL_MINIMUM_CHANNEL_COUNT;


    host ->randomSeed = (enet_uint32) (size_t) host;

    host ->randomSeed += enet_host_random_seed ();

    host ->randomSeed = (host ->randomSeed << 16) | (host ->randomSeed >> 16);

    host ->channelLimit = channelLimit;

    host ->incomingBandwidth = incomingBandwidth;

    host ->outgoingBandwidth = outgoingBandwidth;

    host ->bandwidthThrottleEpoch = 0;

    host ->recalculateBandwidthLimits = 0;

    host ->mtu = ENET_HOST_DEFAULT_MTU//通信最大包限制, 本身自带分包发送。

    host ->peerCount = peerCount;

    host ->commandCount = 0;

    host ->bufferCount = 0;

    host ->checksum = NULL;

    host ->receivedAddress.host = ENET_HOST_ANY;

    host ->receivedAddress.port = 0;

    host ->receivedData = NULL;

    host ->receivedDataLength = 0;

     

    host ->totalSentData = 0;

    host ->totalSentPackets = 0;

    host ->totalReceivedData = 0;

    host ->totalReceivedPackets = 0;


    host ->connectedPeers = 0;

    host ->bandwidthLimitedPeers = 0;

    host ->duplicatePeers = ENET_PROTOCOL_MAXIMUM_PEER_ID;

    host ->maximumPacketSize = ENET_HOST_DEFAULT_MAXIMUM_PACKET_SIZE;

    host ->maximumWaitingData = ENET_HOST_DEFAULT_MAXIMUM_WAITING_DATA;


    host ->compressor.context = NULL// 这里开启压缩包算法

    host ->compressor.compress = NULL;

    host ->compressor.decompress = NULL;

    host ->compressor.destroy = NULL;


    host ->intercept = NULL;


    enet_list_clear (& host ->dispatchQueue); //双向链表 每次必须clear 使得双指针指向头节点


    for (currentPeer = host ->peers;

         currentPeer < & host ->peers [host -> peerCount];

         ++ currentPeer)

    {

       currentPeer ->host = host;

       currentPeer ->incomingPeerID = currentPeer - host ->peers;

       currentPeer ->outgoingSessionID = currentPeer ->incomingSessionID = 0xFF;

       currentPeer ->data = NULL;


       enet_list_clear (& currentPeer ->acknowledgements);

       enet_list_clear (& currentPeer ->sentReliableCommands);

       enet_list_clear (& currentPeer ->sentUnreliableCommands);

       enet_list_clear (& currentPeer ->outgoingReliableCommands);

       enet_list_clear (& currentPeer ->outgoingUnreliableCommands);

       enet_list_clear (& currentPeer ->dispatchedCommands);


       enet_peer_reset (currentPeer);

    }


    return host;

}

2.

 
 /** Forcefully disconnects a peer.

    @param peer peer to forcefully disconnect

    @remarks The foreign host represented by the peer is not notified of the disconnection and will timeout

    on its connection to the local host.

*/

void

enet_peer_reset (ENetPeer * peer)

{

    enet_peer_on_disconnect (peer);

        

    peer -> outgoingPeerID = ENET_PROTOCOL_MAXIMUM_PEER_ID;

    peer -> connectID = 0;


    peer -> state = ENET_PEER_STATE_DISCONNECTED;


    peer -> incomingBandwidth = 0;

    peer -> outgoingBandwidth = 0;

    peer -> incomingBandwidthThrottleEpoch = 0;

    peer -> outgoingBandwidthThrottleEpoch = 0;

    peer -> incomingDataTotal = 0;

    peer -> outgoingDataTotal = 0;

    peer -> lastSendTime = 0;

    peer -> lastReceiveTime = 0;

    peer -> nextTimeout = 0;   客户端下次超时时间

    peer -> earliestTimeout = 0;  最早的超时时间

    peer -> packetLossEpoch = 0;

    peer -> packetsSent = 0;

    peer -> packetsLost = 0;

    peer -> packetLoss = 0;

    peer -> packetLossVariance = 0;

    peer -> packetThrottle = ENET_PEER_DEFAULT_PACKET_THROTTLE;

    peer -> packetThrottleLimit = ENET_PEER_PACKET_THROTTLE_SCALE;

    peer -> packetThrottleCounter = 0;

    peer -> packetThrottleEpoch = 0;

    peer -> packetThrottleAcceleration = ENET_PEER_PACKET_THROTTLE_ACCELERATION;

    peer -> packetThrottleDeceleration = ENET_PEER_PACKET_THROTTLE_DECELERATION;

    peer -> packetThrottleInterval = ENET_PEER_PACKET_THROTTLE_INTERVAL;

    peer -> pingInterval = ENET_PEER_PING_INTERVAL;    心跳检测时间

    peer -> timeoutLimit = ENET_PEER_TIMEOUT_LIMIT;    

    peer -> timeoutMinimum = ENET_PEER_TIMEOUT_MINIMUM;    

    peer -> timeoutMaximum = ENET_PEER_TIMEOUT_MAXIMUM;  最大超时时间  如果没有收到对端的ack确认,会一直重传,至道最大超时,并且踢掉玩家

    peer -> lastRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;   

    peer -> lowestRoundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;

    peer -> lastRoundTripTimeVariance = 0;

    peer -> highestRoundTripTimeVariance = 0;

    peer -> roundTripTime = ENET_PEER_DEFAULT_ROUND_TRIP_TIME;  客户端和服务器通信往返时间设置,用于判断是否超时

    peer -> roundTripTimeVariance = 0;

    peer -> mtu = peer -> host -> mtu;

    peer -> reliableDataInTransit = 0;

    peer -> outgoingReliableSequenceNumber = 0;

    peer -> windowSize = ENET_PROTOCOL_MAXIMUM_WINDOW_SIZE; 滑动窗口大小

    peer -> incomingUnsequencedGroup = 0;

    peer -> outgoingUnsequencedGroup = 0;

    peer -> eventData = 0;

    peer -> totalWaitingData = 0;


    memset (peer -> unsequencedWindow0sizeof (peer -> unsequencedWindow));

    

    enet_peer_reset_queues (peer);

}


3.

void

enet_peer_reset_queues (ENetPeer * peer)

{

    ENetChannel * channel;


    if (peer -> needsDispatch

    {

       enet_list_remove (& peer -> dispatchList); 收到收到的数据包都会加入到调度队列


       peer -> needsDispatch = 0;

    }


    while (! enet_list_empty (& peer -> acknowledgements))  对端确认协议

      enet_free (enet_list_remove (enet_list_begin (& peer -> acknowledgements)));


    enet_peer_reset_outgoing_commands (& peer -> sentReliableCommands); 可靠数据包协议 (每次发送send包后,需要存储到这个双向链表,目的在于存储,用于超时重传,只有收到ack确认,才会删除)

    enet_peer_reset_outgoing_commands (& peer -> sentUnreliableCommands); 不可靠数据包协议

    enet_peer_reset_outgoing_commands (& peer -> outgoingReliableCommands);   送数据所有都会优先加入到 进来的可靠数据包协议 然后send后,又会加入到peer -> sentReliableCommands  如果检测超时,又会从新回到peer -> outgoingReliableCommands

    enet_peer_reset_outgoing_commands (& peer -> outgoingUnreliableCommands);

    enet_peer_reset_incoming_commands (& peer -> dispatchedCommands); 调度协议


    if (peer -> channels != NULL && peer -> channelCount > 0初始化通道

    {

        for (channel = peer -> channels;

             channel < & peer -> channels [peer -> channelCount];

             ++ channel)

        {

            enet_peer_reset_incoming_commands (& channel -> incomingReliableCommands);

            enet_peer_reset_incoming_commands (& channel -> incomingUnreliableCommands);

        }


        enet_free (peer -> channels);

    }


    peer -> channels = NULL;

    peer -> channelCount = 0;

} 


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

通向码农的道路(服务器架构设计(一))

单生产者,单消费者

/*单个生产者和单个消费者*/ #include #include #include #include #include #include #define B...

(TCP-over-UDP library)基于UDP协议之上实现通用、可靠、高效的TCP协议

随着互联网应用广泛推广,出现了越来越多的网络应用,其中基于p2p思想的各种网络技术的产品也越来越多的出现在我们的视野当中。从最早闻名的Napster到现在的Bittorrent、eMule、skype...

通向码农的道路(enet开源翻译计划 二)

http://enet.bespin.org  解析enet 双向链表(无placement new) enet本身就已经局限了4095 在线人数   如果有10000人同时在线,enet使用list...

几种UDP网络库的整理Raknet,UDT,ENet,lidgren-network-gen3

UDT库 https://sourceforge.net/projects/udt/?source=directory     C#包装:https://github.com/dump247/udt...

可靠的UDP编程(ENET库)

可靠的UDP编程(ENET库) 大家都知道UDP这个东西太不可靠了,存在着乱序,丢包,包重复等缺点,但它的速度快,包有界等优点,但在实际编程中要自己处理乱序啊之类的问题会发疯的。...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)