live555 运行调度机制

最新推荐文章于 2024-08-27 16:22:56 发布
最新推荐文章于 2024-08-27 16:22:56 发布
阅读量855 收藏 2
点赞数 1
分类专栏： Audio&Video 文章标签： live555
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dongkun152/article/details/106569945
版权

live555 运行调度机制

在运行live555时，整体的简单结构是这样的：

TaskScheduler* scheduler = BasicTaskScheduler::createNew();
创建server
创建mediasession
创建submediasession
添加submediasession到mediasession
添加mediasession到server
env->taskScheduler().doEventLoop();

运行调度相关的类

TaskScheduler <-----BasicTaskScheduler0 <------BasicTaskScheduler
DelayQueueEntry<----DelayQueue
DelayQueueEntry<----AlarmHandler

调度相关类关系图

超时队列

超时队列的组织

maxSchedulerGranularity默认为10ms，这里主要关注scheduleDelayedTask()函数它向DelayQueue fDelayQueue中添加Alarm_handler。

BasicTaskScheduler* BasicTaskScheduler::createNew(unsigned maxSchedulerGranularity) {
	return new BasicTaskScheduler(maxSchedulerGranularity);
}

BasicTaskScheduler::BasicTaskScheduler(unsigned maxSchedulerGranularity)
  : fMaxSchedulerGranularity(maxSchedulerGranularity), fMaxNumSockets(0)
#if defined(__WIN32__) || defined(_WIN32)
  , fDummySocketNum(-1)
#endif
{
  FD_ZERO(&fReadSet);
  FD_ZERO(&fWriteSet);
  FD_ZERO(&fExceptionSet);

  if (maxSchedulerGranularity > 0) schedulerTickTask(); // ensures that we handle events frequently
}
void BasicTaskScheduler::schedulerTickTask() {
  scheduleDelayedTask(fMaxSchedulerGranularity, schedulerTickTask, this);
}

超时队列的组织利用的时linux 2.4内核定时器队列的管理方式。队列中保存的超时时间是该节点的超时时间与前一个节点的超时间的差值，该节点的实际的超时时间是从该节点起到head节点的超时值的和。查询到期时，只需要判断第一个节点是否到期，到期就把该节点移除；插入时，将节点的超时值与从head开始的节点超时值的和比较找到合适的位置插入。
在这里插入图片描述
如上图，1号节点的超时时间为2，2号为2+6，3号为2+6+10，4号为2+6+10+20

TaskToken BasicTaskScheduler0::scheduleDelayedTask(int64_t microseconds,
						 TaskFunc* proc,
						 void* clientData) {
  if (microseconds < 0) microseconds = 0;
  DelayInterval timeToDelay((long)(microseconds/1000000), (long)(microseconds%1000000));
  AlarmHandler* alarmHandler = new AlarmHandler(proc, clientData, timeToDelay);
  fDelayQueue.addEntry(alarmHandler);

  return (void*)(alarmHandler->token());
}

void DelayQueue::addEntry(DelayQueueEntry* newEntry) {
  synchronize(); //同步动作用来防止没有及时执行timeout节点

  DelayQueueEntry* cur = head();
  while (newEntry->fDeltaTimeRemaining >= cur->fDeltaTimeRemaining) {
    newEntry->fDeltaTimeRemaining -= cur->fDeltaTimeRemaining;
    cur = cur->fNext;
  }

  cur->fDeltaTimeRemaining -= newEntry->fDeltaTimeRemaining;

  // Add "newEntry" to the queue, just before "cur":
  newEntry->fNext = cur;
  newEntry->fPrev = cur->fPrev;
  cur->fPrev = newEntry->fPrev->fNext = newEntry;
}

在创建TaskScheduler是就向延迟队列中加入一个alarmhandler，它的超时动作是添加另一个与自己一模一样的handler。

运行

env->taskScheduler().doEventLoop() 函数

void BasicTaskScheduler0::doEventLoop(char volatile* watchVariable) {
  // Repeatedly loop, handling readble sockets and timed events:
  while (1) {
    if (watchVariable != NULL && *watchVariable != 0) break;
    SingleStep();
  }
}

在SingleStep() 中在select()后做三件事情：

  • 处理加入的HandlerDescriptor，每个HandlerDescriptor跟socket fd相关
  • 处理事件触发
  • 处理延迟队列
void BasicTaskScheduler::SingleStep(unsigned maxDelayTime) {
  fd_set readSet = fReadSet; // make a copy for this select() call
  fd_set writeSet = fWriteSet; // ditto
  fd_set exceptionSet = fExceptionSet; // ditto

  DelayInterval const& timeToDelay = fDelayQueue.timeToNextAlarm();
  struct timeval tv_timeToDelay;
  tv_timeToDelay.tv_sec = timeToDelay.seconds();
  tv_timeToDelay.tv_usec = timeToDelay.useconds();
  // Very large "tv_sec" values cause select() to fail.
  // Don't make it any larger than 1 million seconds (11.5 days)
  const long MAX_TV_SEC = MILLION;
  if (tv_timeToDelay.tv_sec > MAX_TV_SEC) {
    tv_timeToDelay.tv_sec = MAX_TV_SEC;
  }
  // Also check our "maxDelayTime" parameter (if it's > 0):
  if (maxDelayTime > 0 &&
      (tv_timeToDelay.tv_sec > (long)maxDelayTime/MILLION ||
       (tv_timeToDelay.tv_sec == (long)maxDelayTime/MILLION &&
	tv_timeToDelay.tv_usec > (long)maxDelayTime%MILLION))) {
    tv_timeToDelay.tv_sec = maxDelayTime/MILLION;
    tv_timeToDelay.tv_usec = maxDelayTime%MILLION;
  }

//select 超时时间设置为延迟队列的最近超时时间
  int selectResult = select(fMaxNumSockets, &readSet, &writeSet, &exceptionSet, &tv_timeToDelay);
  if (selectResult < 0) { //出错
#if defined(__WIN32__) || defined(_WIN32)
    int err = WSAGetLastError();
    // For some unknown reason, select() in Windoze sometimes fails with WSAEINVAL if
    // it was called with no entries set in "readSet".  If this happens, ignore it:
    if (err == WSAEINVAL && readSet.fd_count == 0) {
      err = EINTR;
      // To stop this from happening again, create a dummy socket:
      if (fDummySocketNum >= 0) closeSocket(fDummySocketNum);
      fDummySocketNum = socket(AF_INET, SOCK_DGRAM, 0);
      FD_SET((unsigned)fDummySocketNum, &fReadSet);
    }
    if (err != EINTR) {
#else
    if (errno != EINTR && errno != EAGAIN) {
#endif
	// Unexpected error - treat this as fatal:
#if !defined(_WIN32_WCE)
	perror("BasicTaskScheduler::SingleStep(): select() fails");
	// Because this failure is often "Bad file descriptor" - which is caused by an invalid socket number (i.e., a socket number
	// that had already been closed) being used in "select()" - we print out the sockets that were being used in "select()",
	// to assist in debugging:
	fprintf(stderr, "socket numbers used in the select() call:");
	for (int i = 0; i < 10000; ++i) {
	  if (FD_ISSET(i, &fReadSet) || FD_ISSET(i, &fWriteSet) || FD_ISSET(i, &fExceptionSet)) {
	    fprintf(stderr, " %d(", i);
	    if (FD_ISSET(i, &fReadSet)) fprintf(stderr, "r");
	    if (FD_ISSET(i, &fWriteSet)) fprintf(stderr, "w");
	    if (FD_ISSET(i, &fExceptionSet)) fprintf(stderr, "e");
	    fprintf(stderr, ")");
	  }
	}
	fprintf(stderr, "\n");
#endif
	internalError();
      }
  }

  // Call the handler function for one readable socket:
  HandlerIterator iter(*fHandlers);
  HandlerDescriptor* handler;
  // To ensure forward progress through the handlers, begin past the last
  // socket number that we handled:
  if (fLastHandledSocketNum >= 0) {
    while ((handler = iter.next()) != NULL) {
    //找到刚处理的handler，如果有则退出
      if (handler->socketNum == fLastHandledSocketNum) break;
    }
    if (handler == NULL) {
      fLastHandledSocketNum = -1;
      iter.reset(); // start from the beginning instead
    }
  }
  //从已经处理过的handler之后进行查找进行处理
  while ((handler = iter.next()) != NULL) {
    int sock = handler->socketNum; // alias
    int resultConditionSet = 0;
    if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;
    if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;
    if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;
    if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {
      fLastHandledSocketNum = sock;
          // Note: we set "fLastHandledSocketNum" before calling the handler,
          // in case the handler calls "doEventLoop()" reentrantly.
      (*handler->handlerProc)(handler->clientData, resultConditionSet);
      break;
    }
  }
  //如果没有处理过handler，则从头进行处理
  if (handler == NULL && fLastHandledSocketNum >= 0) {
    // We didn't call a handler, but we didn't get to check all of them,
    // so try again from the beginning:
    iter.reset();
    while ((handler = iter.next()) != NULL) {
      int sock = handler->socketNum; // alias
      int resultConditionSet = 0;
      if (FD_ISSET(sock, &readSet) && FD_ISSET(sock, &fReadSet)/*sanity check*/) resultConditionSet |= SOCKET_READABLE;
      if (FD_ISSET(sock, &writeSet) && FD_ISSET(sock, &fWriteSet)/*sanity check*/) resultConditionSet |= SOCKET_WRITABLE;
      if (FD_ISSET(sock, &exceptionSet) && FD_ISSET(sock, &fExceptionSet)/*sanity check*/) resultConditionSet |= SOCKET_EXCEPTION;
      if ((resultConditionSet&handler->conditionSet) != 0 && handler->handlerProc != NULL) {
	fLastHandledSocketNum = sock;
	    // Note: we set "fLastHandledSocketNum" before calling the handler,
            // in case the handler calls "doEventLoop()" reentrantly.
	(*handler->handlerProc)(handler->clientData, resultConditionSet);
	break;
      }
    }
    if (handler == NULL) fLastHandledSocketNum = -1;//because we didn't call a handler
  }

  // Also handle any newly-triggered event (Note that we do this *after* calling a socket handler, 处理新触发的事件
  // in case the triggered event handler modifies The set of readable sockets.)
  if (fTriggersAwaitingHandling != 0) {
    if (fTriggersAwaitingHandling == fLastUsedTriggerMask) {
      // Common-case optimization for a single event trigger:
      fTriggersAwaitingHandling &=~ fLastUsedTriggerMask;
      if (fTriggeredEventHandlers[fLastUsedTriggerNum] != NULL) {
	(*fTriggeredEventHandlers[fLastUsedTriggerNum])(fTriggeredEventClientDatas[fLastUsedTriggerNum]);
      }
    } else {
      // Look for an event trigger that needs handling (making sure that we make forward progress through all possible triggers):
      unsigned i = fLastUsedTriggerNum;
      EventTriggerId mask = fLastUsedTriggerMask;

      do {
	i = (i+1)%MAX_NUM_EVENT_TRIGGERS;
	mask >>= 1;
	if (mask == 0) mask = 0x80000000;

	if ((fTriggersAwaitingHandling&mask) != 0) {
	  fTriggersAwaitingHandling &=~ mask;
	  if (fTriggeredEventHandlers[i] != NULL) {
	    (*fTriggeredEventHandlers[i])(fTriggeredEventClientDatas[i]);
	  }

	  fLastUsedTriggerMask = mask;
	  fLastUsedTriggerNum = i;
	  break;
	}
      } while (i != fLastUsedTriggerNum);
    }
  }

  // Also handle any delayed event that may have come due.
  //最后检测延迟队列
  fDelayQueue.handleAlarm();
}

在singlestep()的最后检测延迟队列，在创建TaskScheduler是加入的alarmHandler保证延迟队列中一直会有一个10ms超时事件的handler存在，使得select()的超时事件最大是10ms，也就是说至少10ms检测并执行一次singlestep的动作。

HandlerSet

在 BasicTaskScheduler0 与handler处理相关的元素：

 // To implement background reads:
  HandlerSet* fHandlers; 管理HandlerDescriptor链表
  int fLastHandledSocketNum;

参照上文调度类关系图，handlerSet中管理handlerdescriptor双向链表，HandlerDescriptor元素有socket号，和此handler需要检测的fd变动条件：读，写，异常。handlerProc是回调函数。
在这里插入图片描述

事件触发

在 BasicTaskScheduler0 中与事件触发相关的元素

// To implement event triggers:
  EventTriggerId volatile fTriggersAwaitingHandling; // implemented as a 32-bit bitmap
  EventTriggerId fLastUsedTriggerMask; // implemented as a 32-bit bitmap
  TaskFunc* fTriggeredEventHandlers[MAX_NUM_EVENT_TRIGGERS]; 事件回调函数
  void* fTriggeredEventClientDatas[MAX_NUM_EVENT_TRIGGERS]; 响应回调函数的数据
  unsigned fLastUsedTriggerNum; // in the range [0,MAX_NUM_EVENT_TRIGGERS)

32个事件，用mask来管理到来的事件。

LUCKY-LIVING
关注
专栏目录
硬刚live555源码(二) -- BasicTaskScheduler
asanpyx的专栏
03-15 429
live555源代码分析
live555任务调度学习
码夫的专栏
03-21 1251
 live555任务调度学习
live555编译运行笔记
最新发布
learnframework的博客
08-27 1003
学习rtsp协议实战时候，一般需要有一个rstp的服务进行测试和验证，这个rtsp服务器最好是大家可以手写一个，但是这样可能比较耗费时间，初学者建议可以先拿开源的rtsp服务进行验证抓包学习流程等。​ 一个为流媒体提供解决方案的跨平台的C++开源项目，它实现了对标准流媒体传输是一个为流媒体提供解决方案的跨平台的C++开源项目，它实现了对标准流媒体传输协议如RTP/RTCP、RTSP、SIP等的支持。
TaskScheduler任务调度器抽象基类——Live555源码阅读(一)任务调度相关类
teleger的博客
11-02 768
TaskScheduler任务调度器抽象基类 TaskScheduler是一个抽象基类，其定义在live555sourcecontrol\UsageEnvironment\include\UsageEnvironment.hh文件中。 TaskScheduler声明了很多纯虚接口，其实现一般在class BasicTaskScheduler0中。这里简要介绍一下。 TaskScheduler
后台运行服务
wzq756984的博客
10-18 754
我的系统是ubuntu16.04的版本， 要在系统上运行live555程序，但是当运行后如果关闭窗口或者ctrl+c就会停止，所以改成了后台运行。 具体如下： nohup ./live555MediaServer &gt;&gt;liev.log 2&gt;&amp;1 &amp; nohup可以用于多种场景下。...
3 live555源码分析（三）——live555 任务调度
qq_36383272的博客
10-25 1319
一、TaskScheduler TaskScheduler类是任务调度的基础抽象类，live555将任务分为三种类型，分别是延迟任务、事件任务和后台IO任务，在这个类中定义了三种任务的调度函数。 TaskScheduler类跟UsageEnvironment定义在相同的文件中UsageEnvironment/include/UsageEnvironment.h： class TaskScheduler { public: virtual ~TaskScheduler(); virtual Task
live555源码学习笔记之TaskScheduler
weixin_33872566的博客
08-13 170
今天抽空研究了下live555的任务实现： TaskScheduler分为三种任务：socket handler,event handler,delay task。这三种任务的特点是，前两个加入执行队列后会一直存在，而delay task在执行完一次后会立即弃掉。 socket handler保存在队列BasicTaskScheduler0::HandlerSet* fHandlers中;ev...
live555学习笔记
08-02
Live555是一个开源的流媒体服务器框架，它使用C++编写，并且广泛应用于RTSP（实时流协议）服务器的...在深入了解Live555内部机制的基础上，开发者可以更有效地进行错误处理、任务调度优化，以及协议支持扩展等工作。
Live555 学习笔记
02-07
- `UsageEnvironment`代表了Live555的运行环境，提供了一整套错误处理机制，包括错误记录和错误报告等功能。几乎所有Live555的组件都需要与`UsageEnvironment`交互以便进行错误处理。 - `BasicUsageEnvironment`则...
live555流媒体服务器
10-28
通过在Visual Studio 2010中编译和运行Live555，我们可以深入理解其实现机制，并进一步定制和优化流媒体服务。在实际应用中，myLive555项目可能是编译好的服务器实例，包含了运行所需的所有文件，只需按照说明部署和...
live555类关系&结构图&博客
08-03
在live555的类关系中，`BasicUsageEnvironment`是基础的运行时环境类，负责事件调度和错误处理。`TaskScheduler`则是任务调度器，用于安排定时任务。`Groupsock`类是网络通信的核心，实现了多路复用和解复用功能。`...
FFmpeg入门详解之95：live555使用整理
福优学苑@音视频+流媒体
10-20 776
live555使用整理live555使用、学习及遇到的问题的整理。
Live555-基类研究二
BIGBurning
02-09 2111
TaskSecheduler类是一个任务调度器，它是整个Live555的任务调度中心，程序在任何时刻的任何动作，均由该类完成。其核心函数是SingleStep。Live555的任务主要分为Delayed Event、Socket Event以及Trigger Event。其类层次结构如下图所示:   从类图中可以看到，其类层次结构和第二节中的UsageEnvironment类极其相
live555 源码分析（四：TaskScheduler分析（上））
酱油师兄的博客
02-22 780
本来想一篇写完，结果发现这个关联了好多东西，还是分开写吧，这一篇算预热，下一篇更精彩。
live555 源码分析（五：TaskScheduler分析（下））
酱油师兄的博客
02-24 811
这个是最后一个live555的类了，但也是最难的，所以要好好的分析分析。
二、Live555 基础类
IT Zk
01-14 491
二  基础类  讲几个重要的基础类：  BasicUsageEnvironment 和 UsageEnvironment 中的类都是用于整个系统的基础功能类．比 如 UsageEnvironment 代表了整个系统运行的环境，它提供了错误记录和错误报告的功能， 无论哪一个类要输出错误，就需要保存 UsageEnvironment 的指针．而 TaskScheduler 则提供了任务调度功能
live555--消息循环
evsqiezi
09-21 950
TaskScheduler用于事件调度。类的框架如下： 消息循环如下： void BasicTaskScheduler0::doEventLoop(char* watchVariable) { // Repeatedly loop, handling readble sockets and timed events: while (1) { if (watchVari
live555MediaServer几个构造过程详解
CodeHeng的专栏
02-08 1541
菜鸟初看live555，故做下笔记 MediaServer的主函数，代码没多少，但是前面的几个构造过程可谓是完成了大部分的工作啊 #include #include "DynamicRTSPServer.hh" #include "version.hh" int main(int argc, char** argv) { // Begin by setting up our usage
Live555关键类详解：生命期管理与调度机制
特别是**TaskScheduler**，它是整个程序运行的核心组件，负责任务的调度和执行，是系统运行的“发动机”。 2. **TaskScheduler**：作为全局单例存在，它被存储在**UsageEnvironment**中。所有其他类都需要引用它来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值