UDT 最新源码分析（二） -- 开始与终止

最新推荐文章于 2022-04-05 21:48:22 发布
最新推荐文章于 2022-04-05 21:48:22 发布
阅读量1.6k 收藏 4
点赞数 1
分类专栏： 计算机网络 文章标签： UDT UDP 网络 源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongkai0214/article/details/86287514
版权

UDT 最新源码分析 -- 开始与终止

UDT 开始与终止

开始流程

UDT:: startup -> CUDT::startup -> CUDTUnited::startup

初始化UDT库，多次调用时，调用计数增加，但实际上仅仅初始化一次。对于windows下，还需要初始化网络库WSAStartup。建立 garbageCollect 线程，用于清理失效socket，并删除分发器。

int CUDTUnited::startup()
{
    CGuard gcinit(m_InitLock);   //获取初始锁

    if (m_iInstanceCount++ > 0)  //实例被初始化的计数器，仅初始化一次
        return 0;

    if (m_bGCStatus) //garbageCollect状态，保证线程不会被建立多个
        return true;

    m_bClosing = false; //CUDTUnited状态, 此状态下 garbageCollect内 while循环不退出

    pthread_mutex_init(&m_GCStopLock, NULL);
	pthread_cond_init(&m_GCStopCond, NULL);
	pthread_create(&m_GCThread, NULL, garbageCollect, this); //garbageCollect 线程创建

    m_bGCStatus = true;

    return 0;
}

再来看 garbageCollect：

void* CUDTUnited::garbageCollect(void* p)
{
   CUDTUnited* self = (CUDTUnited*)p; //获取CUDTUnited实例，类型转化
   CGuard gcguard(self->m_GCStopLock);//资源清理的锁

   while (!self->m_bClosing) //初始 m_bClosing = false，无限循环
   {
      //当UDT协议判断某一个UDT SOCKET的状态不正确时，会将其状态设置为BROKEN，并在这个函数中进行处理
      self->checkBrokenSockets();

      //睡眠等待，等待下一次可以清理出现BROKEN状态的UDT SOCKET。睡眠时间 timeout: 1s
      pthread_cond_timedwait(&self->m_GCStopCond, &self->m_GCStopLock, &timeout);
   }

   //remove all sockets and multiplexers. m_bClosing = true, 清理目前依旧残余的资源 
   CGuard::enterCS(self->m_ControlLock);
   
   //遍历 m_Sockets 中的 UDT socket，设置为关闭，存入 m_ClosedSockets map，下一步处理连接记录。
   //查找 Listener, 将 该socket 在Listener中的 m_pQueuedSockets 与 m_pAcceptSockets中记录删除
   for (map<UDTSOCKET, CUDTSocket*>::iterator i = self->m_Sockets.begin(); i != self->m_Sockets.end(); ++ i)
   {
      i->second->m_pUDT->m_bBroken = true; //将CUDT* 的状态设置为 BROKEN，后续进行处理
      i->second->m_pUDT->close(); //关闭
      i->second->m_Status = CLOSED;//设置状态为关闭
      i->second->m_TimeStamp = CTimer::getTime(); //调整最后一次操作 UDT socket 的时间
      self->m_ClosedSockets[i->first] = i->second;//将当前描述连接的CUDT*保存至 m_ClosedSockets

      // remove from listener's queue
      map<UDTSOCKET, CUDTSocket*>::iterator ls = self->m_Sockets.find(i->second->m_ListenSocket);
      if (ls == self->m_Sockets.end()) //如果没有找到Listener, m_ClosedSockets中继续查找
      {
         ls = self->m_ClosedSockets.find(i->second->m_ListenSocket);
         if (ls == self->m_ClosedSockets.end())	//如果没有找到，就不再处理
            continue;
      }

      CGuard::enterCS(ls->second->m_AcceptLock);//获取Listener中的锁
      ls->second->m_pQueuedSockets->erase(i->second->m_SocketID);//清理接收连接但还未接受的排队 UDT socket
      ls->second->m_pAcceptSockets->erase(i->second->m_SocketID);//清理已完成连接的队列中UDT socket
      CGuard::leaveCS(ls->second->m_AcceptLock);
   }
   self->m_Sockets.clear();//最后删除m_Sockets中的所有sockets

   //最后再次遍历待关闭的socket队列
   for (map<UDTSOCKET, CUDTSocket*>::iterator j = self->m_ClosedSockets.begin(); j != self->m_ClosedSockets.end(); ++ j)
   {
      j->second->m_TimeStamp = 0;//设置状态为 0
   }
   CGuard::leaveCS(self->m_ControlLock);

   while (true)
   {
       //之前只是将即将清理的UDT socket 状态设置为BROKEN，此时对BROKEN状态的socket进行清理
      self->checkBrokenSockets();

      CGuard::enterCS(self->m_ControlLock);
      bool empty = self->m_ClosedSockets.empty(); //判断待关闭socket是否已经全部清理
      CGuard::leaveCS(self->m_ControlLock);

      if (empty)//如果为empty，就可以直接退出
         break;

      CTimer::sleep();//不行的话，再歇一会，再次进行处理
   }

   return NULL;
}

上面代码中出现了两次 checkBrokenSockets，该方法用于清理处于BROKEN状态的 UDT socket。

  • 检查所有的 UDT socket
    • 如果不是处于broken状态，查找下一个，如果处于broken状态：
      • 如果 socket 处于 LISTENING 状态，须再等待3s，以防止有客户端正在连接
      • 如果 recvbuffer 存在数据，且 brokencount 计数器仍大于0，继续等待更长的时间
      • 否则：
        • 设置socket为CLOSED状态，更新 m_TimeStamp 为当前时间, 开启移除定时器。
        • 将当前socket加入待关闭 tbc vector, socket加入临时存储closed socket的 m_ClosedSockets map.
        • 查找 Listener, 从m_pQueuedSockets 和 m_pAcceptSockets 移除接收到的socket 连接 socket。
  • 对于移入临时存储待关闭的 m_ClosedSockets map，检查每个socket，
    • 如果 m_ullLingerExpiration > 0，表示在发送缓冲中存在数据时，GC设置了延迟关闭的时间
      • 如果发送缓冲不存在，或为空，或设置关闭时间已经超时：
        • 将m_ullLingerExpiration设置为0；设置UDT socket为关闭状态，在下一次GC中将被回收。更新关闭时间为当前时间。
    • 否则：
      • 如果标记关闭时间已经超过1s，且socket对应接收队列信息节点已经被删除，或者节点不存在list中
      • 将UDT socket加入tbr 移除队列
  • 遍历tbc，从 m_Sockets中删除。遍历tbr, 将这些超时的 socket 移除。
void CUDTUnited::checkBrokenSockets()
{
   CGuard cg(m_ControlLock);//获取GC锁

   // set of sockets To Be Closed and To Be Removed
   vector<UDTSOCKET> tbc; //收集处于Closed状态的 UDT SOCKET
   vector<UDTSOCKET> tbr; //收集处于Removed状态的 UDT SOCKET
	 
   for (map<UDTSOCKET, CUDTSocket*>::iterator i = m_Sockets.begin(); i != m_Sockets.end(); ++ i)
   {
      // check broken connection
      if (i->second->m_pUDT->m_bBroken) //如果处于BROKEN状态
      {
         if (i->second->m_Status == LISTENING) //如果是LISTENING UDT SOCKET
         {
            // for a listening socket, it should wait an extra 3 seconds in case a client is connecting
            if (CTimer::getTime() - i->second->m_TimeStamp < 3000000)
               continue;
         }
         else if ((i->second->m_pUDT->m_pRcvBuffer != NULL) && (i->second->m_pUDT->m_pRcvBuffer->getRcvDataSize() > 0) && (i->second->m_pUDT->m_iBrokenCounter -- > 0))
         {
            // if there is still data in the receiver buffer, wait longer
            continue;//如果缓冲区中依旧有数据，应该等待更长的时间
         }

         //close broken connections and start removal timer
         i->second->m_Status = CLOSED;	//将状态设置为CLOSED
         i->second->m_TimeStamp = CTimer::getTime(); //设置UDT SOCKET的关闭时间
         tbc.push_back(i->first);//将这个UDT SOCKET添加进Closed Array，稍后处理
         m_ClosedSockets[i->first] = i->second;//将这个UDT SOCKET添加进CLOSED UDT SOCKET MAP

         // remove from listener's queue
         map<UDTSOCKET, CUDTSocket*>::iterator ls = m_Sockets.find(i->second->m_ListenSocket);
         if (ls == m_Sockets.end())
         {
            ls = m_ClosedSockets.find(i->second->m_ListenSocket);
            if (ls == m_ClosedSockets.end())
               continue;
         }

         CGuard::enterCS(ls->second->m_AcceptLock);
         ls->second->m_pQueuedSockets->erase(i->second->m_SocketID);
         ls->second->m_pAcceptSockets->erase(i->second->m_SocketID);
         CGuard::leaveCS(ls->second->m_AcceptLock);
      }
   }

   for (map<UDTSOCKET, CUDTSocket*>::iterator j = m_ClosedSockets.begin(); j != m_ClosedSockets.end(); ++ j)
   {
      if (j->second->m_pUDT->m_ullLingerExpiration > 0) //如果还没有到等待关闭时间
      {
         // asynchronous close: 
         if ((NULL == j->second->m_pUDT->m_pSndBuffer) || (0 == j->second->m_pUDT->m_pSndBuffer->getCurrBufSize()) || (j->second->m_pUDT->m_ullLingerExpiration <= CTimer::getTime()))
         { //如果发送缓冲区为空，接收缓冲区为空或者等待关闭时间小于0，调整状态为CLOSED直接关闭
            j->second->m_pUDT->m_ullLingerExpiration = 0;
            j->second->m_pUDT->m_bClosing = true; //更新Closed状态，由下一次启动的GC线程回收
            j->second->m_TimeStamp = CTimer::getTime();//更新关闭的时间
         }
      }

      // timeout 1 second to destroy a socket AND it has been removed from RcvUList
      if ((CTimer::getTime() - j->second->m_TimeStamp > 1000000) && ((NULL == j->second->m_pUDT->m_pRNode) || !j->second->m_pUDT->m_pRNode->m_bOnList))
      {
         tbr.push_back(j->first);
      }
   }

   // move closed sockets to the ClosedSockets structure
   for (vector<UDTSOCKET>::iterator k = tbc.begin(); k != tbc.end(); ++ k)
      m_Sockets.erase(*k); 

   // remove those timeout sockets
   for (vector<UDTSOCKET>::iterator l = tbr.begin(); l != tbr.end(); ++ l)
      removeSocket(*l);
}

如果 m_ClosedSockets 中UDT socket 已经超过超过1s, 就会放入 tbr。遍历 tbr, 移除所有socket，更新相关资源。这里用到了removeSocket 方法。

  • 如果UDT socket 是一个 Listener，将所有收到的但未接受的socket 关闭，设置为 BROKEN 状态，等待移除。
  • 删除 m_PeerRec 中记录的连接。
  • 删除 UDT socket， 检查对应的复用器，计数器减一，如果已经为0， 则关闭channel，清理复用器内的资源。
void CUDTUnited::removeSocket(const UDTSOCKET u)
{
   map<UDTSOCKET, CUDTSocket*>::iterator i = m_ClosedSockets.find(u);

   // invalid socket ID
   if (i == m_ClosedSockets.end())
      return;

   // 由于是多个UDT实例共享一个资源复用器，销毁时要减少引用计数
   // decrease multiplexer reference count, and remove it if necessary
   const int mid = i->second->m_iMuxID;

   if (NULL != i->second->m_pQueuedSockets)
   {
      CGuard::enterCS(i->second->m_AcceptLock);

      // if it is a listener, close all un-accepted sockets in its queue and remove them later
      for (set<UDTSOCKET>::iterator q = i->second->m_pQueuedSockets->begin(); q != i->second->m_pQueuedSockets->end(); ++ q)
      {
         m_Sockets[*q]->m_pUDT->m_bBroken = true;		//1. 将CUDT*的状态设置为BROKEN
         m_Sockets[*q]->m_pUDT->close();				//2. 调用CUDT中的close()
         m_Sockets[*q]->m_TimeStamp = CTimer::getTime();//3. 更新UDT SOCKET的关闭时间
         m_Sockets[*q]->m_Status = CLOSED;				//4. 将UDT SOCKET设置为Closed
         m_ClosedSockets[*q] = m_Sockets[*q];			//5. 在Closed Array中添加当前UDT SOCKET，在GC线程中进行处理
         m_Sockets.erase(*q);							//6. 从全局的MAP中删除
      }

      CGuard::leaveCS(i->second->m_AcceptLock);
   }

   // remove from peer rec
   map<int64_t, set<UDTSOCKET> >::iterator j = m_PeerRec.find((i->second->m_PeerID << 30) + i->second->m_iISN);
   if (j != m_PeerRec.end())
   {
      j->second.erase(u);
      if (j->second.empty())
         m_PeerRec.erase(j);
   }

   // delete this one
   i->second->m_pUDT->close();
   delete i->second;
   m_ClosedSockets.erase(i);

   map<int, CMultiplexer>::iterator m;
   m = m_mMultiplexer.find(mid);
   if (m == m_mMultiplexer.end())//如果这个资源复用器不存在，直接返回
   {
      //something is wrong!!!
      return;
   }

   m->second.m_iRefCount --;//否则的话，减少这个资源复用器的引用计数
   if (0 == m->second.m_iRefCount)
   {
      m->second.m_pChannel->close(); //与UDP SOCKET关联的Channel直接关闭
      delete m->second.m_pSndQueue;  //清理资源复用器的资源
      delete m->second.m_pRcvQueue;
      delete m->second.m_pTimer;
      delete m->second.m_pChannel;
      m_mMultiplexer.erase(m);
   }
}

终止流程

  • UDT::cleanup -> CUDT::cleanup -> CUDTUnited::cleanup

终止流程与开始流程相反，在计数器清零以后才会真正退出，每次调用，计数减一。修改 m_bClosing 与 m_bGCStatus 状态，终止垃圾回收线程。

int CUDTUnited::cleanup()
{
   CGuard gcinit(m_InitLock);

   if (--m_iInstanceCount > 0) //计数器减一
      return 0;

   if (!m_bGCStatus) 
      return 0;

   m_bClosing = true;

   pthread_cond_signal(&m_GCStopCond);
   pthread_join(m_GCThread, NULL);
   pthread_mutex_destroy(&m_GCStopLock);
   pthread_cond_destroy(&m_GCStopCond);

   m_bGCStatus = false;

   return 0;
}

对UDT库的初始化与终止流程分析结束，在例程中，基本上都是显示调用这两个接口，但是在 appclient.cpp 中，通过构造函数与析构函数隐式完成。两种方式均可，可根据需要自选。

struct UDTUpDown{
   UDTUpDown()
   {
      // use this function to initialize the UDT library
      UDT::startup();
   }
   ~UDTUpDown()
   {
      // use this function to release the UDT library
      UDT::cleanup();
   }
};
老雍
关注
专栏目录
udt源码，纯C语言实现。
02-18
1、udt c语言实现，支持跨平台； 2、优势：适用于嵌入式设备，编译库比较小； 3、udt网络传输协议开源包，是基于UDP的可靠传输协议； 4、linux平台下具体适用方式如下： make # compile make clean # cleanup export LD_LIBRARY_PATH=./src/:$LD_LIBRARY_PATH # export the library path progs/server # start the server progs/client # start the client progs/sendfile # start the sendfile server progs/recvfile "file/to/get" "file/to/saveas" # receive the file
UDT-C，UDT库C语言版本
02-18
对于初学者，建议从UDT-C的官方文档或源代码中的示例程序开始学习，了解如何初始化UDT连接、设置参数、发送和接收数据，以及正确关闭连接。随着对UDT-C理解的深入，开发者可以将UDT集成到自己的应用中，实现高效的...
UDT协议解析及C/C++代码实现
chen1415886044的博客
04-05 6602
基于 UDP 的协议 (UDT) 是一种高性能数据传输协议。用于广域高速网络上的分布式数据密集型应用程序。 UDT 使用 UDP 传输具有自己的可靠性控制和拥塞控制机制的批量数据。 新协议可以以比 TCP 高得多的速度传输数据。 UDT 也是一个高度可配置的框架，可以适应各种拥塞控制算法。 为什么需要使用UDT？ UDT 的最初（和主要）目的是为广域网上的分布式数据密集型应用程序提供高性能传输接口，因为效率和公平原因，TCP 很少能很好地工作。它也可以用于 TCP 不适合的其他情况（例如，多媒体流、防火墙穿
UDT 源码分析
龙宇网的专栏
08-22 6177
 1.   介绍    随着网络带宽时延产品(BDP)的增加，通常的TCP协议开始变的低效。这是因为它的AIMD（additiveincrease multiplicativedecrease）算法彻底减少了TCP拥塞窗口，但不能快速的恢复可用带宽。理论上的流量分析表明TCP在BDP增加到很高的时候比较容易受包损失攻击。另外，继承自TCP拥塞控制的不公平的RTT也成为在分布式数据密集程
UDT源码剖析（六）：UDT::socket()过程代码注释
liuhongxian的专栏
09-19 4615
调用路线 UDT::socket()->CUDT::socket()->CUDTUnited::newSocket() 1 UDTSOCKET CUDT::socket(int af, int type, int) 2 { 3    // 如果垃圾收集没启动
UDT源码剖析（四）：UDT的GC线程相关过程代码注释
liuhongxian的专栏
09-19 4182
随着UDT::Startup()的启动，GC线程也随之运行了。 GC主要关注的就是UDTSocket的释放，下面我们来看看这个GC线程是怎么实现的。 查看源代码 打印帮助 1 #ifndef WIN32 2    void* CUDTUnited::garbageCollect
udt源码分析
weixin_34318326的博客
01-02 109
http://blog.csdn.net/liuhongxiangm/article/details/7997058#comments
barchart-udt-core-2.3.0-test-sources.jar
03-13
官方版本，亲测可用
barchart-udt-core-2.2.6-test-sources.jar
03-13
官方版本，亲测可用
barchart-udt-core-2.2.5-test-sources.jar
03-13
官方版本，亲测可用
UDT源码最新版
05-13
UDT源码
udt4 源码
10-23
udt4 源码
udt源码 udp可靠性传输
05-25
基于udp的可靠传输，可以很好的控制网络拥赛，是应用层的开源协议
udt UDT网络传输协议开源包，是基于UDP的可靠传输协议
10-22
UDT网络传输协议开源包，是基于UDP的可靠传输协议，UDP访TCP
UDTv4服务端和客户端通讯源码
11-27
本人开发的在用的UDTv4服务端和客户端通讯源码。本代码涉及较广，socket WEB网页请求、本地读取QQ号信息、本地读取网卡信息、数据存入本地文本（当数据库使用）、获取本地时间等
UDT源码剖析（一）：UDT自带例程sendfile注释
热门推荐
liuhongxian的专栏
09-19 1万+
#ifndef WIN32    #include    #include #else    #include    #include #endif #include #include #include #include using namespace std; #ifndef WIN32 void* sendfile(void*); #
UDT 最新源码分析（一） -- 编译与源码初探
老雍的博客
01-28 1914
UDT 最新源码分析（一）UDT 编译UDT 模块部分重要模块描述 UDT 编译 UDT的编译以及测试用例运行比较简单，基本上是可以直接运行的，但是也有几点需要注意的地方: VC工程较老，需要重定向解决方案到当前系统; 修改测试项目的最小类型检查为否; 如果使用静态库，需要修改部分代码； 将udt.h代码中 #ifdef UDT_EXPORTS #defi...
S7-300 PLC中UDT与STRUCT数据类型详解
STRUCT型数据与UDT类似，也是用于组合多种基本数据类型，但它遵循结构体的规则，更常见于其他编程语言中。在STEP7中，UDT和STRUCT的使用方法基本相同，但UDT在PLC编程中更为常见。 总结来说，UDT在S7-300编程中是...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值