libs/rt-thread
libs
/
rt-thread
4
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[pthread][libc] move 'clock_time' to libc

This commit is contained in:
Meco Man 2021-02-12 01:30:41 +08:00
parent f0805a7973
commit 291fe36139
7 changed files with 228 additions and 253 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
components/libc/compilers/common/sys/time.h
View File

@ -10,6 +10,7 @@
#ifndef _SYS_TIME_H_
#define _SYS_TIME_H_
#include <rtconfig.h>
#include <time.h>
#ifdef __cplusplus
@ -53,6 +54,38 @@ time_t timegm(struct tm * const t);
int gettimeofday(struct timeval *tv, struct timezone *tz);
int settimeofday(const struct timeval *tv, const struct timezone *tz);
#ifdef RT_USING_PTHREADS
/* posix clock and timer */
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 1
#endif
#define CLOCK_CPUTIME_ID 2
#ifndef CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 4
#endif
int clock_getres (clockid_t clockid, struct timespec *res);
int clock_gettime (clockid_t clockid, struct timespec *tp);
int clock_settime (clockid_t clockid, const struct timespec *tp);
#endif /*RT_USING_PTHREADS*/
#ifdef __cplusplus
}
#endif

163
components/libc/compilers/common/time.c
View File

@ -14,6 +14,9 @@
* 2021-02-11 Meco Man fix bug #3183 - align days[] and months[] to 4 bytes
* add difftime()
* 2021-02-12 Meco Man add errno
* 2012-12-08 Bernard <clock_time.c> fix the issue of _timevalue.tv_usec initialization,
* which found by Rob <rdent@iinet.net.au>
* 2021-02-12 Meco Man move all of the functions located in <clock_time.c> to this file
*/
#include <sys/time.h>
@ -26,7 +29,7 @@
#define SPD 24*60*60
/* days per month -- nonleap! */
const short __spm[13] =
static const short __spm[13] =
{
0,
(31),
@ -97,12 +100,14 @@ struct tm *gmtime_r(const time_t *timep, struct tm *r)
r->tm_isdst = 0;
return r;
}
RTM_EXPORT(gmtime_r);
struct tm* gmtime(const time_t* t)
{
static struct tm tmp;
return gmtime_r(t, &tmp);
}
RTM_EXPORT(gmtime);
/*TODO: timezone */
struct tm* localtime_r(const time_t* t, struct tm* r)
@ -114,18 +119,21 @@ struct tm* localtime_r(const time_t* t, struct tm* r)
local_tz = *t + utc_plus * 3600;
return gmtime_r(&local_tz, r);
}
RTM_EXPORT(localtime_r);
struct tm* localtime(const time_t* t)
{
static struct tm tmp;
return localtime_r(t, &tmp);
}
RTM_EXPORT(localtime);
/* TODO: timezone */
time_t mktime(struct tm * const t)
{
return timegm(t);
}
RTM_EXPORT(mktime);
char* asctime_r(const struct tm *t, char *buf)
{
@ -147,28 +155,33 @@ char* asctime_r(const struct tm *t, char *buf)
buf[24] = '\n';
return buf;
}
RTM_EXPORT(asctime_r);
char* asctime(const struct tm *timeptr)
{
static char buf[25];
return asctime_r(timeptr, buf);
}
RTM_EXPORT(asctime);
char *ctime_r (const time_t * tim_p, char * result)
{
struct tm tm;
return asctime_r (localtime_r (tim_p, &tm), result);
}
RTM_EXPORT(ctime_r);
char* ctime(const time_t *tim_p)
{
return asctime (localtime (tim_p));
}
RTM_EXPORT(ctime);
double difftime (time_t tim1, time_t tim2)
{
return (double)(tim1 - tim2);
}
RTM_EXPORT(difftime);
/**
* Returns the current time.
@ -216,11 +229,13 @@ RT_WEAK time_t time(time_t *t)
return time_now;
}
RTM_EXPORT(time);
RT_WEAK clock_t clock(void)
{
return rt_tick_get();
}
RTM_EXPORT(clock);
int stime(const time_t *t)
{
@ -246,6 +261,7 @@ int stime(const time_t *t)
return -1;
#endif /* RT_USING_RTC */
}
RTM_EXPORT(stime);
time_t timegm(struct tm * const t)
{
@ -320,6 +336,7 @@ time_t timegm(struct tm * const t)
i = 60;
return ((day + t->tm_hour) * i + t->tm_min) * i + t->tm_sec;
}
RTM_EXPORT(timegm);
/* TODO: timezone */
int gettimeofday(struct timeval *tv, struct timezone *tz)
@ -338,6 +355,7 @@ int gettimeofday(struct timeval *tv, struct timezone *tz)
return -1;
}
}
RTM_EXPORT(gettimeofday);
/* TODO: timezone */
int settimeofday(const struct timeval *tv, const struct timezone *tz)
@ -352,3 +370,146 @@ int settimeofday(const struct timeval *tv, const struct timezone *tz)
return -1;
}
}
RTM_EXPORT(settimeofday);
#ifdef RT_USING_PTHREADS
static struct timeval _timevalue;
static int clock_time_system_init()
{
time_t time;
rt_tick_t tick;
rt_device_t device;
time = 0;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
}
/* get tick */
tick = rt_tick_get();
_timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
return 0;
}
INIT_COMPONENT_EXPORT(clock_time_system_init);
int clock_getres(clockid_t clockid, struct timespec *res)
{
int ret = 0;
if (res == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
switch (clockid)
{
case CLOCK_REALTIME:
res->tv_sec = 0;
res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND;
break;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
res->tv_sec = 0;
res->tv_nsec = clock_cpu_getres();
break;
#endif
default:
ret = -1;
rt_set_errno(EINVAL);
break;
}
return ret;
}
RTM_EXPORT(clock_getres);
int clock_gettime(clockid_t clockid, struct timespec *tp)
{
int ret = 0;
if (tp == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
switch (clockid)
{
case CLOCK_REALTIME:
{
/* get tick */
int tick = rt_tick_get();
tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
}
break;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
{
float unit = 0;
long long cpu_tick;
unit = clock_cpu_getres();
cpu_tick = clock_cpu_gettime();
tp->tv_sec = ((int)(cpu_tick * unit)) / NANOSECOND_PER_SECOND;
tp->tv_nsec = ((int)(cpu_tick * unit)) % NANOSECOND_PER_SECOND;
}
break;
#endif
default:
rt_set_errno(EINVAL);
ret = -1;
}
return ret;
}
RTM_EXPORT(clock_gettime);
int clock_settime(clockid_t clockid, const struct timespec *tp)
{
int second;
rt_tick_t tick;
rt_device_t device;
if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL))
{
rt_set_errno(EINVAL);
return -1;
}
/* get second */
second = tp->tv_sec;
/* get tick */
tick = rt_tick_get();
/* update timevalue */
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1;
/* update for RTC device */
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* set realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second);
}
else
return -1;
return 0;
}
RTM_EXPORT(clock_settime);
#endif /*RT_USING_PTHREADS*/

0
components/libc/time/posix_sleep.c → components/libc/pthreads/posix_sleep.c
View File

33
components/libc/pthreads/pthread.c
View File

@ -13,6 +13,7 @@
#include <rthw.h>
#include <pthread.h>
#include <sched.h>
#include <sys/time.h>
#include "pthread_internal.h"
RT_DEFINE_SPINLOCK(pth_lock);
@ -688,3 +689,35 @@ int pthread_cancel(pthread_t thread)
}
RTM_EXPORT(pthread_cancel);
int clock_time_to_tick(const struct timespec *time)
{
int tick;
int nsecond, second;
struct timespec tp;
RT_ASSERT(time != RT_NULL);
tick = RT_WAITING_FOREVER;
if (time != NULL)
{
/* get current tp */
clock_gettime(CLOCK_REALTIME, &tp);
if ((time->tv_nsec - tp.tv_nsec) < 0)
{
nsecond = NANOSECOND_PER_SECOND - (tp.tv_nsec - time->tv_nsec);
second = time->tv_sec - tp.tv_sec - 1;
}
else
{
nsecond = time->tv_nsec - tp.tv_nsec;
second = time->tv_sec - tp.tv_sec;
}
tick = second * RT_TICK_PER_SECOND + nsecond * RT_TICK_PER_SECOND / NANOSECOND_PER_SECOND;
if (tick < 0) tick = 0;
}
return tick;
}
RTM_EXPORT(clock_time_to_tick);

12
components/libc/time/SConscript
View File

@ -1,12 +0,0 @@
# RT-Thread building script for component
from building import *
cwd = GetCurrentDir()
src = Glob('*.c') + Glob('*.cpp')
CPPPATH = [cwd]
group = DefineGroup('libc', src,
depend = ['RT_USING_PTHREADS'], CPPPATH = CPPPATH)
Return('group')

188
components/libc/time/clock_time.c
View File

@ -1,188 +0,0 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2012-12-08 Bernard fix the issue of _timevalue.tv_usec initialization,
* which found by Rob <rdent@iinet.net.au>
*/
#include <rtthread.h>
#include <pthread.h>
#include "clock_time.h"
static struct timeval _timevalue;
int clock_time_system_init()
{
time_t time;
rt_tick_t tick;
rt_device_t device;
time = 0;
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* get realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_TIME, &time);
}
/* get tick */
tick = rt_tick_get();
_timevalue.tv_usec = (tick%RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = time - tick/RT_TICK_PER_SECOND - 1;
return 0;
}
INIT_COMPONENT_EXPORT(clock_time_system_init);
int clock_time_to_tick(const struct timespec *time)
{
int tick;
int nsecond, second;
struct timespec tp;
RT_ASSERT(time != RT_NULL);
tick = RT_WAITING_FOREVER;
if (time != NULL)
{
/* get current tp */
clock_gettime(CLOCK_REALTIME, &tp);
if ((time->tv_nsec - tp.tv_nsec) < 0)
{
nsecond = NANOSECOND_PER_SECOND - (tp.tv_nsec - time->tv_nsec);
second = time->tv_sec - tp.tv_sec - 1;
}
else
{
nsecond = time->tv_nsec - tp.tv_nsec;
second = time->tv_sec - tp.tv_sec;
}
tick = second * RT_TICK_PER_SECOND + nsecond * RT_TICK_PER_SECOND / NANOSECOND_PER_SECOND;
if (tick < 0) tick = 0;
}
return tick;
}
RTM_EXPORT(clock_time_to_tick);
int clock_getres(clockid_t clockid, struct timespec *res)
{
int ret = 0;
if (res == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
switch (clockid)
{
case CLOCK_REALTIME:
res->tv_sec = 0;
res->tv_nsec = NANOSECOND_PER_SECOND/RT_TICK_PER_SECOND;
break;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
res->tv_sec = 0;
res->tv_nsec = clock_cpu_getres();
break;
#endif
default:
ret = -1;
rt_set_errno(EINVAL);
break;
}
return ret;
}
RTM_EXPORT(clock_getres);
int clock_gettime(clockid_t clockid, struct timespec *tp)
{
int ret = 0;
if (tp == RT_NULL)
{
rt_set_errno(EINVAL);
return -1;
}
switch (clockid)
{
case CLOCK_REALTIME:
{
/* get tick */
int tick = rt_tick_get();
tp->tv_sec = _timevalue.tv_sec + tick / RT_TICK_PER_SECOND;
tp->tv_nsec = (_timevalue.tv_usec + (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK) * 1000;
}
break;
#ifdef RT_USING_CPUTIME
case CLOCK_CPUTIME_ID:
{
float unit = 0;
long long cpu_tick;
unit = clock_cpu_getres();
cpu_tick = clock_cpu_gettime();
tp->tv_sec = ((int)(cpu_tick * unit)) / NANOSECOND_PER_SECOND;
tp->tv_nsec = ((int)(cpu_tick * unit)) % NANOSECOND_PER_SECOND;
}
break;
#endif
default:
rt_set_errno(EINVAL);
ret = -1;
}
return ret;
}
RTM_EXPORT(clock_gettime);
int clock_settime(clockid_t clockid, const struct timespec *tp)
{
int second;
rt_tick_t tick;
rt_device_t device;
if ((clockid != CLOCK_REALTIME) || (tp == RT_NULL))
{
rt_set_errno(EINVAL);
return -1;
}
/* get second */
second = tp->tv_sec;
/* get tick */
tick = rt_tick_get();
/* update timevalue */
_timevalue.tv_usec = MICROSECOND_PER_SECOND - (tick % RT_TICK_PER_SECOND) * MICROSECOND_PER_TICK;
_timevalue.tv_sec = second - tick/RT_TICK_PER_SECOND - 1;
/* update for RTC device */
device = rt_device_find("rtc");
if (device != RT_NULL)
{
/* set realtime seconds */
rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_TIME, &second);
}
else
return -1;
return 0;
}
RTM_EXPORT(clock_settime);

52
components/libc/time/clock_time.h
View File

@ -1,52 +0,0 @@
/*
* Copyright (c) 2006-2018, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017-12-31 Bernard the first version
*/
#ifndef CLOCK_TIME_H__
#define CLOCK_TIME_H__
#ifdef __cplusplus
extern "C" {
#endif
/* posix clock and timer */
#define MILLISECOND_PER_SECOND 1000UL
#define MICROSECOND_PER_SECOND 1000000UL
#define NANOSECOND_PER_SECOND 1000000000UL
#define MILLISECOND_PER_TICK (MILLISECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define MICROSECOND_PER_TICK (MICROSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#define NANOSECOND_PER_TICK (NANOSECOND_PER_SECOND / RT_TICK_PER_SECOND)
#ifndef CLOCK_REALTIME
#define CLOCK_REALTIME 1
#endif
#define CLOCK_CPUTIME_ID 2
#ifndef CLOCK_PROCESS_CPUTIME_ID
#define CLOCK_PROCESS_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_THREAD_CPUTIME_ID
#define CLOCK_THREAD_CPUTIME_ID CLOCK_CPUTIME_ID
#endif
#ifndef CLOCK_MONOTONIC
#define CLOCK_MONOTONIC 4
#endif
int clock_getres (clockid_t clockid, struct timespec *res);
int clock_gettime (clockid_t clockid, struct timespec *tp);
int clock_settime (clockid_t clockid, const struct timespec *tp);
#ifdef __cplusplus
}
#endif
#endif