标签：延迟 保留 修改 schedule fine 设备 period llb 讲解
SmartOS是一个完全由新生命团队设计的嵌入式操作系统，主要应用于智能家居、物联网、工业自动化控制等领域。
ARM Cortex-M系列微处理器几乎全都做成单核心，对于业务逻辑较复杂的物联网就显得难以使用，因此SmartOS设计了两个多任务调度系统：
1，多线程调度，重量级，逼近PC操作系统多线程用法。使用上需要特别小心，要合理分配每一个线程的栈空间大小，任务越多越容易出问题
2，大循环，轻量级。每个任务注册一个函数指针，然后由主线程轮询各个任务函数，轮流执行
本文主要讲解第二种，轻量级多任务调度系统。
TaskScheduler是任务调度中心，Task表示单个任务。
SmartOS启动后会进入C/C++标准的main函数，在这里需要初始化各个模块，各个模块在初始化的时候，通过Sys.AddTask向系统注册任务函数。
一切就绪以后，在main最后一行，使用Sys.Start()进入大循环，开始调度。
Sys.Start实际上调用TaskScheduler.Start，从后面代码可以看出，这个Start内部有一个死循环。
每一个任务都需要指定4大参数：函数指针、回调参数、开始时间、调度周期。
调度中心将会维护并计算每一个任务的“下一次调度”时间。
显然，每一个任务函数获得CPU时间开始执行的时候，其它所有任务都没有机会执行。
原则上，当然是每个任务都尽量不要占用太长的时间。但是随着智能设备越来越复杂，应用系统也日渐复杂，为了满足需求，开发人员很希望在一个任务里面完成一系列连贯动作，获得跟PC上一样的体验，让任务假设自己独占CPU。
常规的大循环调度根本无法满足以上要求。
我们在这个基础上做了一点点改进，允许某个任务在休眠等待的时候，分出时间去调度其它函数。
例如，A、B、C多个任务正在工作。
其中A是主要业务逻辑，B是以太网驱动，定时询问网卡要数据。
A里面有一个功能，需要向服务器发送一个指令，然后等待响应。
如果这个时候A阻塞CPU，它永远也拿不到响应数据，即使响应数据已经到来！
因为CPU被A独占了，B没有机会去问网卡要数据，也就不能把数据交给A。
我们把A的等待做一点点调整，A在调用Sys.Sleep等待一定时间的时候，调度中心不要浪费了这点时间，安排去调度其它任务，那么B就有机会执行，网络响应数据上冒到A业务附近的函数，最终被A获取，达到业务需求。
头文件
#ifndef __Task_H__ #define __Task_H__ #include "Sys.h" #include "List.h" class TaskScheduler; // 任务 class Task { private: TaskScheduler* _Scheduler; friend class TaskScheduler; Task(TaskScheduler* scheduler); public: uint ID; // 编号 Action Callback; // 回调 void* Param; // 参数 long Period; // 周期us ulong NextTime; // 下一次执行时间 uint Times; // 执行次数 uint CpuTime; // 总耗费时间 uint SleepTime; // 当前睡眠时间 uint Cost; // 平均执行时间 bool Enable; // 是否启用 byte Reversed[3];// 保留，避免对齐问题 //~Task(); void ShowStatus(); // 显示状态 }; // 任务调度器 class TaskScheduler { private: FixedArray<Task, 32> _Tasks; uint _gid; // 总编号 friend class Task; public: string Name; // 系统名称 int Count; // 任务个数 Task* Current; // 正在执行的任务 bool Running; // 是否正在运行 byte Reversed[3];// 保留，避免对齐问题 TaskScheduler(string name = NULL); ~TaskScheduler(); // 创建任务，返回任务编号。dueTime首次调度时间us，period调度间隔us，-1表示仅处理一次 uint Add(Action func, void* param, ulong dueTime = 0, long period = 0); void Remove(uint taskid); void Start(); void Stop(); // 执行一次循环。指定最大可用时间 void Execute(uint usMax); static void ShowStatus(void* param); // 显示状态 Task* operator[](int taskid); }; #endif
源代码
#include "Task.h" /* */ Task::Task(TaskScheduler* scheduler) { _Scheduler = scheduler; Times = 0; CpuTime = 0; SleepTime = 0; Cost = 0; Enable = true; } /*Task::~Task() { if(ID) _Scheduler->Remove(ID); }*/ // 显示状态 void Task::ShowStatus() { debug_printf("Task::Status 任务 %d [%d] 执行 %dus 平均 %dus\r\n", ID, Times, CpuTime, Cost); } TaskScheduler::TaskScheduler(string name) { Name = name; _gid = 1; Running = false; Current = NULL; Count = 0; } TaskScheduler::~TaskScheduler() { Current = NULL; _Tasks.DeleteAll().Clear(); } // 创建任务，返回任务编号。dueTime首次调度时间us，period调度间隔us，-1表示仅处理一次 uint TaskScheduler::Add(Action func, void* param, ulong dueTime, long period) { Task* task = new Task(this); task->ID = _gid++; task->Callback = func; task->Param = param; task->Period = period; task->NextTime = Time.Current() + dueTime; Count++; _Tasks.Add(task); #if DEBUG // 输出长整型%ld，无符号长整型%llu //debug_printf("%s添加任务%d 0x%08x FirstTime=%lluus Period=%ldus\r\n", Name, task->ID, func, dueTime, period); if(period >= 1000) { uint dt = dueTime / 1000; int pd = period > 0 ? period / 1000 : period; debug_printf("%s::添加任务%d 0x%08x FirstTime=%ums Period=%dms\r\n", Name, task->ID, func, dt, pd); } else debug_printf("%s::添加任务%d 0x%08x FirstTime=%uus Period=%dus\r\n", Name, task->ID, func, (uint)dueTime, (int)period); #endif return task->ID; } void TaskScheduler::Remove(uint taskid) { int i = -1; while(_Tasks.MoveNext(i)) { Task* task = _Tasks[i]; if(task->ID == taskid) { _Tasks.RemoveAt(i); debug_printf("%s::删除任务%d 0x%08x\r\n", Name, task->ID, task->Callback); // 首先清零ID，避免delete的时候再次删除 task->ID = 0; delete task; break; } } } void TaskScheduler::Start() { if(Running) return; #if DEBUG //Add(ShowTime, NULL, 2000000, 2000000); Add(ShowStatus, this, 10000000, 30000000); #endif debug_printf("%s::准备就绪 开始循环处理%d个任务！\r\n\r\n", Name, Count); Running = true; while(Running) { Execute(0xFFFFFFFF); } debug_printf("%s停止调度，共有%d个任务！\r\n", Name, Count); } void TaskScheduler::Stop() { debug_printf("%s停止！\r\n", Name); Running = false; } // 执行一次循环。指定最大可用时间 void TaskScheduler::Execute(uint usMax) { ulong now = Time.Current() - Sys.StartTime; // 当前时间。减去系统启动时间，避免修改系统时间后导致调度停摆 ulong min = UInt64_Max; // 最小时间，这个时间就会有任务到来 ulong end = Time.Current() + usMax; // 需要跳过当前正在执行任务的调度 //Task* _cur = Current; int i = -1; while(_Tasks.MoveNext(i)) { Task* task = _Tasks[i]; //if(task && task != _cur && task->Enable && task->NextTime <= now) if(task && task->Enable && task->NextTime <= now) { // 不能通过累加的方式计算下一次时间，因为可能系统时间被调整 task->NextTime = now + task->Period; if(task->NextTime < min) min = task->NextTime; ulong now2 = Time.Current(); task->SleepTime = 0; Current = task; task->Callback(task->Param); Current = NULL; // 累加任务执行次数和时间 task->Times++; int cost = (int)(Time.Current() - now2); if(cost < 0) cost = -cost; //if(cost > 0) { task->CpuTime += cost - task->SleepTime; task->Cost = task->CpuTime / task->Times; } #if DEBUG if(cost > 500000) debug_printf("Task::Execute 任务 %d [%d] 执行时间过长 %dus 睡眠 %dus\r\n", task->ID, task->Times, cost, task->SleepTime); #endif // 如果只是一次性任务，在这里清理 if(task->Period < 0) Remove(task->ID); } // 如果已经超出最大可用时间，则退出 if(!usMax || Time.Current() > end) return; } // 如果有最小时间，睡一会吧 now = Time.Current(); // 当前时间 if(min != UInt64_Max && min > now) { min -= now; #if DEBUG //debug_printf("TaskScheduler::Execute 等待下一次任务调度 %uus\r\n", (uint)min); #endif //// 最大只允许睡眠1秒，避免Sys.Delay出现设计错误，同时也更人性化 //if(min > 1000000) min = 1000000; //Sys.Delay(min); Time.Sleep(min); } } // 显示状态 void TaskScheduler::ShowStatus(void* param) { TaskScheduler* ts = (TaskScheduler*)param; int i = -1; while(ts->_Tasks.MoveNext(i)) { Task* task = ts->_Tasks[i]; if(task) task->ShowStatus(); } } Task* TaskScheduler::operator[](int taskid) { int i = -1; while(_Tasks.MoveNext(i)) { Task* task = _Tasks[i]; if(task && task->ID == taskid) return task; } return NULL; }
外部注册函数
// 任务 #include "Task.h" // 任务类 TaskScheduler* _Scheduler; // 创建任务，返回任务编号。priority优先级，dueTime首次调度时间us，period调度间隔us，-1表示仅处理一次 uint TSys::AddTask(Action func, void* param, ulong dueTime, long period) { // 屏蔽中断，否则可能有线程冲突 SmartIRQ irq; if(!_Scheduler) _Scheduler = new TaskScheduler("系统"); return _Scheduler->Add(func, param, dueTime, period); } void TSys::RemoveTask(uint taskid) { assert_ptr(_Scheduler); _Scheduler->Remove(taskid); } void TSys::SetTask(uint taskid, bool enable) { Task* task = (*_Scheduler)[taskid]; if(task) task->Enable = enable; } void TSys::Start() { if(!_Scheduler) _Scheduler = new TaskScheduler("系统"); #if DEBUG //AddTask(ShowTime, NULL, 2000000, 2000000); #endif if(OnStart) OnStart(); else _Scheduler->Start(); } void TSys::StartInternal() { _Scheduler->Start(); } void TSys::Stop() { _Scheduler->Stop(); } void TimeSleep(uint us) { // 在这段时间里面，去处理一下别的任务 if(_Scheduler && (!us || us >= 1000)) { // 记录当前正在执行任务 Task* task = _Scheduler->Current; ulong start = Time.Current(); // 1ms一般不够调度新任务，留给硬件等待 ulong end = start + us - 1000; // 如果休眠时间足够长，允许多次调度其它任务 int cost = 0; while(true) { ulong start2 = Time.Current(); _Scheduler->Execute(us); ulong now = Time.Current(); cost += (int)(now - start2); // us=0 表示释放一下CPU if(!us) return; if(now >= end) break; } if(task) { _Scheduler->Current = task; task->SleepTime += cost; } cost = (int)(Time.Current() - start); if(cost > 0) return; us -= cost; } if(us) Time.Sleep(us); } void TSys::Sleep(uint ms) { // 优先使用线程级睡眠 if(OnSleep) OnSleep(ms); else { #if DEBUG if(ms > 1000) debug_printf("Sys::Sleep 设计错误，睡眠%dms太长，超过1000ms建议使用多线程Thread！", ms); #endif TimeSleep(ms * 1000); } } void TSys::Delay(uint us) { // 如果延迟微秒数太大，则使用线程级睡眠 if(OnSleep && us >= 2000) OnSleep((us + 500) / 1000); else { #if DEBUG if(us > 1000000) debug_printf("Sys::Sleep 设计错误，睡眠%dus太长，超过1000ms建议使用多线程Thread！", us); #endif TimeSleep(us); } }
标签：延迟 保留 修改 schedule fine 设备 period llb 讲解
原文地址：http://www.cnblogs.com/nnhy/p/smartos_task.html
