server_common/a8
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add xtimer

Browse Source
This commit is contained in:
aozhiwei 2019-04-13 14:01:21 +08:00
parent 3619cd46f9
commit 4ce247a7a3
2 changed files with 412 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

352
a8/xtimer.cc Normal file
View File

@ -0,0 +1,352 @@
#include <a8/a8.h>
#include <a8/xtimer.h>
#define CONFIG_BASE_SMALL 0
#define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)
#define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)
#define TVN_SIZE (1 << TVN_BITS)
#define TVR_SIZE (1 << TVR_BITS)
#define TVN_MASK (TVN_SIZE - 1)
#define TVR_MASK (TVR_SIZE - 1)
#define INDEX(N) ((base->timer_tick >> (TVR_BITS + (N) * TVN_BITS)) & TVN_MASK)
struct xtvec {
struct list_head vec[TVN_SIZE];
};
struct xtvec_root {
struct list_head vec[TVR_SIZE];
};
struct xtvec_base {
struct xtimer_list *running_timer;
long long timer_tick;
list_head free_timer;
int free_timer_num;
struct xtvec_root tv1;
struct xtvec tv2;
struct xtvec tv3;
struct xtvec tv4;
struct xtvec tv5;
};
struct xtimer_list {
struct list_head entry;
struct list_head attach_entry;
int timer_type; // 0:deadline 1: repeattimer 2:fixedtimer outher:deadline
long long expires;
int expire_time;
int fixed_timer_execute_times;
struct xtvec_base *base;
a8::XTimerFunc timer_func;
a8::XTimerAfterFunc timer_after_func;
a8::XParams param;
};
static void InternalAddXTimer(struct xtvec_base *base, struct xtimer_list *timer)
{
long long expires = timer->expires;
long long idx = expires - base->timer_tick;
struct list_head *vec;
if (idx < 0) {
vec = base->tv1.vec + (base->timer_tick & TVR_MASK);
}else if (idx < TVR_SIZE) {
int i = expires & TVR_MASK;
vec = base->tv1.vec + i;
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
int i = (expires >> TVR_BITS) & TVN_MASK;
vec = base->tv2.vec + i;
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
vec = base->tv4.vec + i;
} else {
int i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
vec = base->tv5.vec + i;
}
list_add_tail(&timer->entry, vec);
}
static int Cascade(struct xtvec_base *base, struct xtvec *tv, int index)
{
/* cascade all the timers from tv up one level */
struct xtimer_list *timer, *tmp;
struct list_head tv_list;
// 将tv数组中以index为下标的定时器队列取出，准备搬移
list_replace_init(tv->vec + index, &tv_list);
// 根据超时时间，将队列中的定时器重新排队。定时器往上一级时间轮排队的过程就 // 在这里发生。
list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
InternalAddXTimer(base, timer);
}
return index;
}
static inline int DetachTimer(struct xtimer_list *timer)
{
if (!list_empty(&timer->entry)) {
list_del_init(&timer->entry);
}
return 1;
}
static inline void InitTimerList(xtvec_base* base, xtimer_list* timer, int timer_type,
long long expires, int expire_time, a8::XParams& param,
a8::XTimerFunc timer_func, a8::XTimerAfterFunc timer_after_func)
{
INIT_LIST_HEAD(&timer->entry);
INIT_LIST_HEAD(&timer->attach_entry);
timer->timer_type = timer_type;
timer->expires = expires;
timer->expire_time = expire_time;
timer->fixed_timer_execute_times = 0;
timer->base = base;
timer->timer_func = timer_func;
timer->timer_after_func = timer_after_func;
timer->param = param;
}
namespace a8
{
XTimer::XTimer()
{
base_ = new xtvec_base();
base_->running_timer = nullptr;
base_->timer_tick = get_tick_count_func_(context_);
INIT_LIST_HEAD(&base_->free_timer);
base_->free_timer_num = 0;
for (int j = 0; j < TVN_SIZE; j++) {
INIT_LIST_HEAD(base_->tv5.vec + j);
INIT_LIST_HEAD(base_->tv4.vec + j);
INIT_LIST_HEAD(base_->tv3.vec + j);
INIT_LIST_HEAD(base_->tv2.vec + j);
}
for (int j = 0; j < TVR_SIZE; j++) {
INIT_LIST_HEAD(base_->tv1.vec + j);
}
}
XTimer::~XTimer()
{
Clear();
delete base_;
base_ = nullptr;
}
void XTimer::Init(XGetTickCountFunc func, void* context, int gc_time, int cache_timer_num)
{
get_tick_count_func_ = func;
context_ = context_;
gc_time_ = gc_time;
cache_timer_num_ = cache_timer_num;
AddRepeatTimer(gc_time_,
a8::XParams().SetSender(this),
&XTimer::GC_XTimerFunc);
}
void XTimer::Update()
{
if (get_tick_count_func_(context_) >= base_->timer_tick) {
UpdateTimer();
}
}
xtimer_list* XTimer::AddDeadLineTimer(int expire_time, a8::XParams param, a8::XTimerFunc timer_func,
a8::XTimerAfterFunc timer_after_func)
{
xtimer_list *timer = NewTimerList();
InitTimerList(base_,
timer,
0,
get_tick_count_func_(context_) + expire_time,
expire_time,
param,
timer_func,
timer_after_func);
ModifyTimer(timer, expire_time);
return timer;
}
xtimer_list* XTimer::AddDeadLineTimerAndAttach(int expire_time, a8::XParams param, a8::XTimerFunc timer_func,
list_head* attach_list, a8::XTimerAfterFunc timer_after_func)
{
xtimer_list* timer = AddDeadLineTimer(expire_time, param, timer_func, timer_after_func);
list_add_tail(&timer->attach_entry, attach_list);
return timer;
}
xtimer_list* XTimer::AddRepeatTimer(int expire_time, a8::XParams param, a8::XTimerFunc timer_func)
{
xtimer_list *timer = NewTimerList();
InitTimerList(base_,
timer,
1,
get_tick_count_func_(context_) + expire_time,
expire_time,
param,
timer_func,
nullptr);
ModifyTimer(timer, expire_time);
return timer;
}
void XTimer::ModifyTimer(xtimer_list* timer, int expire_time)
{
DetachTimer(timer);
timer->expire_time = expire_time;
if (timer->timer_type == 2) {
long long tick = get_tick_count_func_(context_);
long long today_passed_seconds = time(nullptr) - a8::GetDaySeconds(time(nullptr), 0);
timer->expires = (tick - today_passed_seconds * 1000) + expire_time;
if (timer->fixed_timer_execute_times > 0) {
if (timer->expires <= tick) { //已过期
timer->expires += 1000 * 3600 * 24;
}
}
}else {
timer->expires = get_tick_count_func_(context_) + expire_time;
}
InternalAddXTimer(base_, timer);
}
void XTimer::DeleteTimer(xtimer_list* timer)
{
if (timer->timer_after_func) {
timer->timer_after_func(timer->param);
}
DetachTimer(timer);
if (!list_empty(&timer->attach_entry)) {
list_del_init(&timer->attach_entry);
}
AddToFreeList(timer);
}
xtimer_list* XTimer::GetTimerByAttach(list_head* attach_entry)
{
if (attach_entry) {
xtimer_list* timer = list_entry(attach_entry, struct xtimer_list, attach_entry);
return timer;
} else {
return nullptr;
}
}
void XTimer::UpdateTimer()
{
struct xtvec_base *base = base_;
while (get_tick_count_func_(context_) >= base->timer_tick) {
struct list_head work_list;
struct list_head *head = &work_list;
int index = base->timer_tick & TVR_MASK;
if (!index &&
(!Cascade(base, &base->tv2, INDEX(0))) &&
(!Cascade(base, &base->tv3, INDEX(1))) &&
!Cascade(base, &base->tv4, INDEX(2))) {
Cascade(base, &base->tv5, INDEX(3));
}
++base->timer_tick;
list_replace_init(base->tv1.vec + index, &work_list);
while (!list_empty(head)) {
struct xtimer_list *timer;
timer = list_first_entry(head, struct xtimer_list,entry);
base->running_timer = timer;
if (timer->timer_func) {
timer->timer_func(timer->param);
}
if (timer->timer_after_func) {
timer->timer_after_func(timer->param);
}
switch (timer->timer_type) {
case 1:
case 2: //循环类定时 fixed timer也是循环定时器
{
if (timer->timer_type == 2) {
timer->fixed_timer_execute_times++;
}
ModifyTimer(timer, timer->expire_time);
}
break;
default: //deadline timer
{
DetachTimer(timer);
if (!list_empty(&timer->attach_entry)) {
list_del_init(&timer->attach_entry);
}
AddToFreeList(timer);
}
break;
}
}
}
base->running_timer = nullptr;
}
xtimer_list* XTimer::NewTimerList()
{
if (!list_empty(&base_->free_timer)) {
xtimer_list* timer = list_first_entry(&base_->free_timer, struct xtimer_list,entry);
list_del_init(&timer->entry);
base_->free_timer_num--;
return timer;
} else {
return new xtimer_list();
}
}
void XTimer::AddToFreeList(xtimer_list* timer)
{
list_add_tail(&timer->entry, &base_->free_timer);
base_->free_timer_num++;
}
void XTimer::Clear()
{
auto free_timers =
[] (list_head* head)
{
while (!list_empty(head)) {
struct xtimer_list *timer;
timer = list_first_entry(head, struct xtimer_list,entry);
DetachTimer(timer);
if (!list_empty(&timer->attach_entry)) {
list_del_init(&timer->attach_entry);
}
delete timer;
}
};
for (int j = 0; j < TVN_SIZE; j++) {
free_timers(base_->tv5.vec + j);
free_timers(base_->tv4.vec + j);
free_timers(base_->tv3.vec + j);
free_timers(base_->tv2.vec + j);
}
for (int j = 0; j < TVR_SIZE; j++) {
free_timers(base_->tv1.vec + j);
}
free_timers(&base_->free_timer);
}
void XTimer::GC_XTimerFunc(const a8::XParams& param)
{
XTimer* timer = (XTimer*)param.sender.GetUserData();
int i = 0;
while (!list_empty(&timer->base_->free_timer) &&
timer->base_->free_timer_num > timer->cache_timer_num_ && i < 1000) {
xtimer_list* timer1 = list_first_entry(&timer->base_->free_timer, struct xtimer_list, entry);
list_del_init(&timer1->entry);
delete timer1;
timer->base_->free_timer_num--;
i++;
}
}
}

60
a8/xtimer.h Normal file
View File

@ -0,0 +1,60 @@
/*
* 仿照linux2.6内核定时器实现
*/
#ifndef A8_XTIMER_H
#define A8_XTIMER_H
struct xtimer_list;
struct xtvec_base;
namespace a8
{
typedef void (*XTimerFunc)(const a8::XParams& param);
typedef void (*XTimerAfterFunc)(const a8::XParams& param);
typedef long long (*XGetTickCountFunc)(void*);
class XTimer
{
private:
XTimer();
~XTimer();
public:
void Init(XGetTickCountFunc func, void* context, int gc_time, int cache_timer_num);
void Update();
//添加截止时间定时器(一次性定时器)
xtimer_list* AddDeadLineTimer(int expire_time, a8::XParams param, a8::XTimerFunc timer_func,
a8::XTimerAfterFunc timer_after_func = nullptr);
xtimer_list* AddDeadLineTimerAndAttach(int expire_time, a8::XParams,
a8::XTimerFunc timer_func,
list_head* attach_list,
a8::XTimerAfterFunc timer_after_func = nullptr);
//添加重复执行定时器(周期性定时器)
xtimer_list* AddRepeatTimer(int expire_time, a8::XParams param, a8::XTimerFunc timer_func);
//修改定时器参数
void ModifyTimer(xtimer_list* timer, int expire_time);
//删除定时器
void DeleteTimer(xtimer_list* timer);
//通过关联的list_head获取定时器对象
xtimer_list* GetTimerByAttach(list_head* attach_entry);
private:
void UpdateTimer();
xtimer_list* NewTimerList();
void AddToFreeList(xtimer_list* timer);
void Clear();
static void GC_XTimerFunc(const a8::XParams& param);
private:
xtvec_base* base_ = nullptr;
XGetTickCountFunc get_tick_count_func_ = nullptr;
void* context_ = nullptr;
int gc_time_ = 10;
int cache_timer_num_ = 100;
};
}
#endif