Skip to content

[components][ktime]support period ktime timeout and multiple ktimer_hrtimer #8972

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
BernardXiong merged 9 commits into from
Jun 23, 2024
Merged

[components][ktime]support period ktime timeout and multiple ktimer_hrtimer #8972

Show file tree
Hide file tree
Changes from 8 commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
b379510
support period time
zmshahaha May 21, 2024
f764256
enable multiple ktimer
zmshahaha May 21, 2024
afe3267
mv set delay_cnt to hrtimer_start
zmshahaha May 22, 2024
21a4079
add ktime debug info
zmshahaha May 23, 2024
c2a50de
change current_irq_begin to local var
zmshahaha May 29, 2024
8aeaa2b
fix bug: setting current timer and setting timeout in driver aren't a…
zmshahaha May 30, 2024
51044cd
Merge branch 'master' into ktime
zmshahaha May 30, 2024
e62817e
create->init
zmshahaha Jun 4, 2024
64b6c21
refactoring ktime
zmshahaha Jun 6, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 0 additions & 1 deletion components/drivers/include/drivers/pic.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -98,7 +98,6 @@ struct rt_pic_isr
#ifdef RT_USING_PIC_STATISTICS
struct rt_pic_irq_statistics
{
rt_ubase_t current_irq_begin[RT_CPUS_NR];
rt_ubase_t max_irq_time_ns;
rt_ubase_t min_irq_time_ns;
rt_ubase_t sum_irq_time_ns;
Expand Down
10 changes: 5 additions & 5 deletions components/drivers/ktime/inc/ktime.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,10 +22,11 @@

struct rt_ktime_hrtimer
{
struct rt_object parent; /**< inherit from rt_object */
rt_list_t row;
rt_uint8_t flag; /**< compatible to tick timer's flag */
char name[RT_NAME_MAX];
rt_list_t node;
void *parameter;
unsigned long init_cnt;
unsigned long delay_cnt;
unsigned long timeout_cnt;
rt_err_t error;
struct rt_completion completion;
Expand Down Expand Up @@ -124,11 +125,10 @@ rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt, void (*timeout)(void *pa

void rt_ktime_hrtimer_init(rt_ktime_hrtimer_t timer,
const char *name,
unsigned long cnt,
rt_uint8_t flag,
void (*timeout)(void *parameter),
void *parameter);
rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer);
rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer, unsigned long cnt);
rt_err_t rt_ktime_hrtimer_stop(rt_ktime_hrtimer_t timer);
rt_err_t rt_ktime_hrtimer_control(rt_ktime_hrtimer_t timer, int cmd, void *arg);
rt_err_t rt_ktime_hrtimer_detach(rt_ktime_hrtimer_t timer);
Expand Down
193 changes: 106 additions & 87 deletions components/drivers/ktime/src/hrtimer.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -13,6 +13,10 @@
#include <rthw.h>
#include <rtthread.h>

#define DBG_SECTION_NAME "drv.ktime"
#define DBG_LEVEL DBG_INFO
#include <rtdbg.h>

#include "ktime.h"

#ifdef ARCH_CPU_64BIT
Expand All @@ -22,7 +26,7 @@
#endif

static rt_list_t _timer_list = RT_LIST_OBJECT_INIT(_timer_list);
static rt_ktime_hrtimer_t _nowtimer = RT_NULL;
static rt_ktime_hrtimer_t _current_timer = RT_NULL;
static RT_DEFINE_SPINLOCK(_spinlock);

rt_weak rt_uint64_t rt_ktime_hrtimer_getres(void)
Expand All @@ -48,6 +52,8 @@ static void _hrtimer_timeout(void *parameter)
_outcb(parameter);
}

static struct rt_timer _sh_rtimer;

rt_weak rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt, void (*timeout)(void *param), void *param)
{
static rt_timer_t timer = RT_NULL;
Expand All @@ -71,7 +77,8 @@ rt_weak rt_err_t rt_ktime_hrtimer_settimeout(unsigned long cnt, void (*timeout)(

if (timer == RT_NULL)
{
timer = rt_timer_create("shrtimer", _hrtimer_timeout, param, cnt, RT_TIMER_FLAG_ONE_SHOT);
timer = &_sh_rtimer;
rt_timer_init(timer, "shrtimer", _hrtimer_timeout, param, cnt, RT_TIMER_FLAG_ONE_SHOT);
}
else
{
Expand Down Expand Up @@ -111,119 +118,132 @@ static void _sleep_timeout(void *parameter)
rt_completion_done(&timer->completion);
}

static void _set_next_timeout_n_unlock(rt_base_t level);
static void _timeout_callback(void *parameter)
static void _insert_timer_to_list_locked(rt_ktime_hrtimer_t timer)
{
rt_ktime_hrtimer_t timer;
timer = (rt_ktime_hrtimer_t)parameter;
rt_base_t level;
rt_ktime_hrtimer_t iter;

level = rt_spin_lock_irqsave(&_spinlock);
_nowtimer = RT_NULL;
rt_list_remove(&(timer->row));
/* change status of timer */
timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;

if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
rt_list_for_each_entry(iter, &_timer_list, node)
Comment thread
zmshahaha marked this conversation as resolved.
{
timer->timeout_func(timer->parameter);
if (iter->timeout_cnt > timer->timeout_cnt)
{
break;
}
}
rt_list_insert_before(&iter->node, &(timer->node));

timer->flag |= RT_TIMER_FLAG_ACTIVATED;
}

static void _exec_timeout_locked(rt_ktime_hrtimer_t timer)
{
rt_list_remove(&(timer->node));

if (timer->flag & RT_TIMER_FLAG_PERIODIC)
{
timer->timeout_cnt = timer->delay_cnt + rt_ktime_cputimer_getcnt();
_insert_timer_to_list_locked(timer);
}

_set_next_timeout_n_unlock(level);
if ((timer->flag & RT_TIMER_FLAG_ACTIVATED) && timer->timeout_func)
{
timer->timeout_func(timer->parameter);
}
}

static void _set_next_timeout_n_unlock(rt_base_t level)
static void _timeout_callback(void *parameter);
static void _set_next_timeout_locked(void)
{
rt_ktime_hrtimer_t t;
rt_ubase_t timeout_hrtimer_cnt;

if (&_timer_list != _timer_list.prev)
{
t = rt_list_entry((&_timer_list)->next, struct rt_ktime_hrtimer, row);
if (_nowtimer != RT_NULL)
t = rt_list_entry(_timer_list.next, struct rt_ktime_hrtimer, node);
if (_current_timer != t)
{
if (t != _nowtimer && t->timeout_cnt < _nowtimer->timeout_cnt)
_current_timer = t;
timeout_hrtimer_cnt = _cnt_convert(_current_timer->timeout_cnt);
if (timeout_hrtimer_cnt > 0)
{
_nowtimer = t;
rt_spin_unlock_irqrestore(&_spinlock, level);
rt_ktime_hrtimer_settimeout(_cnt_convert(t->timeout_cnt), _timeout_callback, t);
rt_ktime_hrtimer_settimeout(timeout_hrtimer_cnt, _timeout_callback, _current_timer);
}
else
{
rt_spin_unlock_irqrestore(&_spinlock, level);
_exec_timeout_locked(_current_timer);
_set_next_timeout_locked();
}
}
else
{
_nowtimer = t;
rt_spin_unlock_irqrestore(&_spinlock, level);
rt_ktime_hrtimer_settimeout(_cnt_convert(t->timeout_cnt), _timeout_callback, t);
}
}
else
{
_nowtimer = RT_NULL;
rt_spin_unlock_irqrestore(&_spinlock, level);
_current_timer = RT_NULL;

/* clear hrtimer timeout */
rt_ktime_hrtimer_settimeout(0, RT_NULL, RT_NULL);
}
}

static void _timeout_callback(void *parameter)
{
rt_ktime_hrtimer_t timer;
timer = (rt_ktime_hrtimer_t)parameter;
rt_base_t level;

LOG_D("Expected wake-up in CPU time: %lu, actual wake-up in CPU time %lu", timer->timeout_cnt, rt_ktime_cputimer_getcnt());

level = rt_spin_lock_irqsave(&_spinlock);

_exec_timeout_locked(timer);
_set_next_timeout_locked();

rt_spin_unlock_irqrestore(&_spinlock, level);
}

void rt_ktime_hrtimer_init(rt_ktime_hrtimer_t timer,
const char *name,
unsigned long cnt,
rt_uint8_t flag,
void (*timeout)(void *parameter),
void *parameter)
{
/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(timeout != RT_NULL);
RT_ASSERT(cnt < (_HRTIMER_MAX_CNT / 2));

/* set flag */
timer->parent.flag = flag;
rt_memset(timer, 0, sizeof(struct rt_ktime_hrtimer));

timer->flag = flag;
rt_strncpy(timer->name, name, RT_NAME_MAX - 1);

/* set deactivated */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer->timeout_func = timeout;
timer->parameter = parameter;
timer->timeout_cnt = cnt + rt_ktime_cputimer_getcnt();
timer->init_cnt = cnt;
timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer->timeout_func = timeout;
timer->parameter = parameter;

rt_list_init(&(timer->row));
rt_list_init(&(timer->node));
rt_completion_init(&timer->completion);
}

rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer)
rt_err_t rt_ktime_hrtimer_start(rt_ktime_hrtimer_t timer, unsigned long delay_cnt)
{
rt_list_t *timer_list;
rt_base_t level;

/* parameter check */
RT_ASSERT(timer != RT_NULL);
RT_ASSERT(delay_cnt < (_HRTIMER_MAX_CNT / 2));

timer->delay_cnt = delay_cnt;
timer->timeout_cnt = timer->delay_cnt + rt_ktime_cputimer_getcnt();

level = rt_spin_lock_irqsave(&_spinlock);
rt_list_remove(&timer->row); /* remove timer from list */
/* change status of timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer_list = &_timer_list;
for (; timer_list != _timer_list.prev; timer_list = timer_list->next)
{
rt_ktime_hrtimer_t t;
rt_list_t *p = timer_list->next;

t = rt_list_entry(p, struct rt_ktime_hrtimer, row);
rt_list_remove(&timer->node);
_insert_timer_to_list_locked(timer);
_set_next_timeout_locked();

if ((t->timeout_cnt - timer->timeout_cnt) == 0)
{
continue;
}
else if ((t->timeout_cnt - timer->timeout_cnt) < (_HRTIMER_MAX_CNT / 2))
{
break;
}
}
rt_list_insert_after(timer_list, &(timer->row));
timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;

_set_next_timeout_n_unlock(level);
rt_spin_unlock_irqrestore(&_spinlock, level);

return RT_EOK;
}
Expand All @@ -235,16 +255,18 @@ rt_err_t rt_ktime_hrtimer_stop(rt_ktime_hrtimer_t timer)
RT_ASSERT(timer != RT_NULL); /* timer check */

level = rt_spin_lock_irqsave(&_spinlock);
if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))
if (!(timer->flag & RT_TIMER_FLAG_ACTIVATED))
{
rt_spin_unlock_irqrestore(&_spinlock, level);
return -RT_ERROR;
}
_nowtimer = RT_NULL;
rt_list_remove(&timer->row);
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED; /* change status */
_current_timer = RT_NULL;
rt_list_remove(&timer->node);
timer->flag &= ~RT_TIMER_FLAG_ACTIVATED; /* change status */

_set_next_timeout_locked();

_set_next_timeout_n_unlock(level);
rt_spin_unlock_irqrestore(&_spinlock, level);

return RT_EOK;
}
Expand All @@ -259,26 +281,27 @@ rt_err_t rt_ktime_hrtimer_control(rt_ktime_hrtimer_t timer, int cmd, void *arg)
level = rt_spin_lock_irqsave(&_spinlock);
switch (cmd)
{

case RT_TIMER_CTRL_GET_TIME:
*(unsigned long *)arg = timer->init_cnt;
*(unsigned long *)arg = timer->delay_cnt;
break;

case RT_TIMER_CTRL_SET_TIME:
RT_ASSERT((*(unsigned long *)arg) < (_HRTIMER_MAX_CNT / 2));
timer->init_cnt = *(unsigned long *)arg;
timer->timeout_cnt = *(unsigned long *)arg + rt_ktime_cputimer_getcnt();
timer->delay_cnt = *(unsigned long *)arg;
timer->timeout_cnt = *(unsigned long *)arg + rt_ktime_cputimer_getcnt();
break;

case RT_TIMER_CTRL_SET_ONESHOT:
timer->parent.flag &= ~RT_TIMER_FLAG_PERIODIC;
timer->flag &= ~RT_TIMER_FLAG_PERIODIC;
break;

case RT_TIMER_CTRL_SET_PERIODIC:
timer->parent.flag |= RT_TIMER_FLAG_PERIODIC;
timer->flag |= RT_TIMER_FLAG_PERIODIC;
break;

case RT_TIMER_CTRL_GET_STATE:
if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
if (timer->flag & RT_TIMER_FLAG_ACTIVATED)
{
/*timer is start and run*/
*(rt_uint32_t *)arg = RT_TIMER_FLAG_ACTIVATED;
Expand Down Expand Up @@ -330,27 +353,25 @@ rt_err_t rt_ktime_hrtimer_detach(rt_ktime_hrtimer_t timer)
level = rt_spin_lock_irqsave(&_spinlock);

/* stop timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
timer->flag &= ~RT_TIMER_FLAG_ACTIVATED;
/* when interrupted */
if (timer->error == -RT_EINTR || timer->error == RT_EINTR)
{
_nowtimer = RT_NULL;
rt_list_remove(&timer->row);
_set_next_timeout_n_unlock(level);
}
else
{
rt_spin_unlock_irqrestore(&_spinlock, level);
_current_timer = RT_NULL;
rt_list_remove(&timer->node);
_set_next_timeout_locked();
}

rt_spin_unlock_irqrestore(&_spinlock, level);

return RT_EOK;
}

/************************** delay ***************************/

void rt_ktime_hrtimer_delay_init(struct rt_ktime_hrtimer *timer)
{
rt_ktime_hrtimer_init(timer, "hrtimer_sleep", 0, RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER,
rt_ktime_hrtimer_init(timer, "hrtimer_sleep", RT_TIMER_FLAG_ONE_SHOT | RT_TIMER_FLAG_HARD_TIMER,
_sleep_timeout, timer);
}

Expand All @@ -366,15 +387,13 @@ rt_err_t rt_ktime_hrtimer_sleep(struct rt_ktime_hrtimer *timer, unsigned long cn
if (cnt == 0)
return -RT_EINVAL;

timer->timeout_cnt = cnt + rt_ktime_cputimer_getcnt();
timer->init_cnt = cnt;
rt_ktime_hrtimer_start(timer, cnt); /* reset the timeout of thread timer and start it */

rt_ktime_hrtimer_start(timer); /* reset the timeout of thread timer and start it */
err = rt_completion_wait_flags(&(timer->completion), RT_WAITING_FOREVER,
RT_INTERRUPTIBLE);
rt_ktime_hrtimer_keep_errno(timer, err);

return RT_EOK;
return err;
}

rt_err_t rt_ktime_hrtimer_ndelay(struct rt_ktime_hrtimer *timer, unsigned long ns)
Expand Down
Loading