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

最新推荐文章于 2021-05-01 16:32:29 发布
最新推荐文章于 2021-05-01 16:32:29 发布
阅读量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 源码分析
龙宇网的专栏
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 4183
随着UDT::Startup()的启动，GC线程也随之运行了。 GC主要关注的就是UDTSocket的释放，下面我们来看看这个GC线程是怎么实现的。 查看源代码 打印帮助 1 #ifndef WIN32 2    void* CUDTUnited::garbageCollect
udt源码分析
weixin_34318326的博客
01-02 111
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源码剖析（一）：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源码最新版
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 最新源码分析（一） -- 编译与源码初探
老雍的博客
01-28 1914
UDT 最新源码分析（一）UDT 编译UDT 模块部分重要模块描述 UDT 编译 UDT的编译以及测试用例运行比较简单，基本上是可以直接运行的，但是也有几点需要注意的地方: VC工程较老，需要重定向解决方案到当前系统; 修改测试项目的最小类型检查为否; 如果使用静态库，需要修改部分代码； 将udt.h代码中 #ifdef UDT_EXPORTS #defi...
udt源码整理
jinyuttt的专栏
05-01 734
UDT是基于UDP的数据传输协议。UDT是开源软件，主要目的是针对“TCP在高带宽长距离网络上的传输性能差”的问题，尽可能全面支持BDP网络上的海量数据传输。UDT是建立与UDP之上的面向双向的应用层协议，引入了新的拥塞控制算法和数据可靠性控制机制。它不仅可以支持可靠的数据流传输（STREAM 类型TCP）和部分可靠的数据报（DGRAM类似网络上发广播消息）传输，也可以应用在点对点技术，防火墙穿透，多媒体数据传输等领域。 我下载了udt4源码，另外添加了c#的绑定。 项目地址：https://githu
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、付费专栏及课程。

余额充值