wangchdo opened a new pull request, #17573:
URL: https://github.com/apache/nuttx/pull/17573
## Summary
This change introduces high-resolution timer (hrtimer) support as a fully
independent and optional module to support scheduler, without altering the
existing scheduler behavior.
The hrtimer implementation is strictly isolated from the current scheduling
logic:
1. All hrtimer-related code is guarded by CONFIG_HRTIMER.
2. When CONFIG_HRTIMER is disabled, the scheduler continues to rely on the
existing tick-based or tickless mechanisms with no functional or behavioral
changes.
No existing scheduler data structures or timing paths are modified
unconditionally.
**From an integration perspective, hrtimer is used only as an alternative
time source for driving scheduler events. The core scheduling logic
(nxsched_process_tick(), nxsched_tick_expiration(), etc.) remains unchanged and
is reused as-is.**
To further reduce risk:
1. The scheduler hrtimer is initialized lazily and does not affect system
startup.
2. The module does not replace or bypass existing timer infrastructure
unless explicitly enabled via configuration.
3. Failure or imperfection in the hrtimer path is confined to the hrtimer
module itself and cannot impact legacy scheduling paths.
**This design allows hrtimer to be developed, reviewed, and evolved
incrementally, while ensuring that existing NuttX scheduling behavior remains
stable and unaffected unless the feature is explicitly enabled.**
## Impact
Add hrtimer support to nuttx scheduelr, without altering the existing
scheduler behavior.
## Testing
**Test 1 passed (integrated in ostest):**
**- test implementation:**
```
/****************************************************************************
* apps/testing/ostest/hrtimer.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <nuttx/hrtimer.h>
#include <stdio.h>
#include <sched.h>
#include "ostest.h"
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
#define NSEC_PER_500MS (500 * NSEC_PER_MSEC)
/* Set a 1ms margin to allow hrtimertest to pass in QEMU.
*
* QEMU is a virtual platform, and its timer resolution and scheduling
* latency may be less precise than on real hardware. Using a larger
* margin ensures that tests do not fail due to timing inaccuracies.
*
* On real hardware (verified on the a2g-tc397-5v-tft board), this
* margin can be reduced to less than 5 ns because timers are precise
* and deterministic.
*/
#define NSEC_MARGIN (NSEC_PER_MSEC)
/* Simple assertion macro for HRTimer test cases */
#define HRTIMER_TEST(expr, value) \
do \
{ \
ret = (expr); \
if (ret != (value)) \
{ \
printf("ERROR: HRTimer test failed, line=%d ret=%d\n", \
__LINE__, ret); \
ASSERT(false); \
} \
} \
while (0)
/****************************************************************************
* Private Types
****************************************************************************/
/* Structure for HRTimer test tracking */
struct hrtimer_test_s
{
hrtimer_t timer; /* HRTimer instance */
uint64_t previous; /* Previous timestamp in nanoseconds */
uint32_t count; /* Number of timer expirations */
uint32_t period; /* Expected period between expirations */
bool active; /* True while the test is still running */
};
/****************************************************************************
* Private Functions
****************************************************************************/
/****************************************************************************
* Name: hrtimer_test_init
*
* Description:
* Initialize a hrtimer_test_s structure for a new test.
*
* Input Parameters:
* test_hrtimer - Pointer to the test structure to initialize
* period - Expected timer period in nanoseconds
*
* Returned Value:
* None
*
****************************************************************************/
static void hrtimer_test_init(FAR struct hrtimer_test_s *test_hrtimer,
uint32_t period)
{
test_hrtimer->previous = 0;
test_hrtimer->count = 0;
test_hrtimer->active = true;
test_hrtimer->period = period;
}
/****************************************************************************
* Name: test_hrtimer_callback
*
* Description:
* HRTimer callback function for test.
*
* - Verifies the timer interval is exactly 500ms (nanosecond precision)
* - Stops the test after 15 expirations
* - Re-arms the timer in absolute mode
*
* Input Parameters:
* hrtimer - Pointer to the expired HRTimer instance
*
* Returned Value:
* Timer period in nanoseconds (NSEC_PER_500MS)
*
****************************************************************************/
static uint32_t test_hrtimer_callback(FAR hrtimer_t *hrtimer)
{
struct timespec ts;
uint32_t diff;
uint64_t now;
int ret;
FAR struct hrtimer_test_s *test =
(FAR struct hrtimer_test_s *)hrtimer;
/* Increment expiration count */
test->count++;
/* Get current system time */
clock_systime_timespec(&ts);
now = clock_time2nsec(&ts);
/* Skip comparison for first two invocations */
if (test->count > 2)
{
/* Verify the timer interval is exactly
* 500ms with nsec resolution
*/
diff = (uint32_t)(now - test->previous);
HRTIMER_TEST(NSEC_PER_500MS < diff + NSEC_MARGIN, true);
HRTIMER_TEST(NSEC_PER_500MS > diff - NSEC_MARGIN, true);
}
test->previous = now;
/* Stop the test after 15 expirations */
if (test->count >= 15)
{
ret = hrtimer_cancel(hrtimer);
HRTIMER_TEST(ret, 0);
test->active = false;
}
return test->period;
}
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: hrtimer_test
*
* Description:
* Entry point for high-resolution timer functional test.
*
* - Initializes a HRTimer
* - Starts it with a 500ms relative timeout
* - Verifies subsequent expirations occur at 500ms intervals
*
* Input Parameters:
* None
*
* Returned Value:
* None
*
****************************************************************************/
void hrtimer_test(void)
{
int ret;
struct hrtimer_test_s test_hrtimer_500ms;
/* Initialize test structure */
hrtimer_test_init(&test_hrtimer_500ms, NSEC_PER_500MS);
/* Initialize the high-resolution timer */
hrtimer_init(&test_hrtimer_500ms.timer,
test_hrtimer_callback,
NULL);
/* Start the timer with 500ms relative timeout */
ret = hrtimer_start(&test_hrtimer_500ms.timer,
test_hrtimer_500ms.period,
HRTIMER_MODE_REL);
HRTIMER_TEST(ret, OK);
/* Wait until the test completes */
while (test_hrtimer_500ms.active)
{
usleep(500 * USEC_PER_MSEC);
}
}
```
**test log on rv-virt:smp64:**
```
NuttShell (NSH)
nsh>
nsh> uname -a
NuttX 0.0.0 6847a0cc95-dirty Dec 20 2025 12:26:39 risc-v rv-virt
nsh> ostest
(...)
user_main: hrtimer test
End of test memory usage:
VARIABLE BEFORE AFTER
======== ======== ========
arena 1fbdec0 1fbdec0
ordblks 9 9
mxordblk 1f73880 1f73880
uordblks 109b0 ff18
fordblks 1fad510 1fadfa8
Final memory usage:
VARIABLE BEFORE AFTER
======== ======== ========
arena 1fbdec0 1fbdec0
ordblks 1 9
mxordblk 1fb2cf8 1f73880
uordblks b1c8 ff18
fordblks 1fb2cf8 1fadfa8
user_main: Exiting
ostest_main: Exiting with status 0
```
**test 2 passed (provided by @Fix-Point )**
**test implementation**
```
/****************************************************************************
* apps/examples/hello/hello_main.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <unistd.h>
#include <nuttx/hrtimer.h>
#define HRTIMER_TEST_THREAD_NR (1)
#define HRTIMER_TEST_NR (1000000)
/****************************************************************************
* Public Functions
****************************************************************************/
static int volatile tcount = 0;
static volatile uint32_t next = 0;
static uint32_t test_callback(FAR struct hrtimer_s *hrtimer)
{
tcount++;
up_ndelay(hrtimer->expired % (10 * NSEC_PER_USEC));
return 0;
}
static uint32_t test_callback_background(FAR struct hrtimer_s *hrtimer)
{
up_ndelay(hrtimer->expired % NSEC_PER_USEC);
return 0;
}
static void test1(int tid)
{
hrtimer_t timer;
int count = 0;
irqstate_t flags;
spinlock_t lock;
if (tid == 0)
{
hrtimer_init(&timer, test_callback, NULL);
}
else
{
hrtimer_init(&timer, test_callback_background, NULL);
}
while (count++ < HRTIMER_TEST_NR)
{
int ret;
if (tid == 0)
{
uint64_t delay = rand() % (10 * NSEC_PER_MSEC);
/* Simulate the periodical hrtimer.. */
flags = spin_lock_irqsave(&lock);
/* Use as periodical timer */
ret = hrtimer_cancel(&timer);
ret = hrtimer_start(&timer, 1000, HRTIMER_MODE_REL);
spin_unlock_irqrestore(&lock, flags);
up_ndelay(NSEC_PER_MSEC);
flags = spin_lock_irqsave(&lock);
ret = hrtimer_cancel_sync(&timer);
ret = hrtimer_start(&timer, 1000, HRTIMER_MODE_REL);
spin_unlock_irqrestore(&lock, flags);
up_ndelay(NSEC_PER_MSEC);
hrtimer_cancel_sync(&timer); // stucked here????
printf("???\n");
}
else
{
/* Simulate the background hrtimer.. */
uint64_t delay = rand() % (10 * NSEC_PER_MSEC);
ret = hrtimer_cancel(&timer);
ret = hrtimer_start(&timer, delay, HRTIMER_MODE_REL);
}
UNUSED(ret);
}
}
static void* test_thread(void *arg)
{
while (1)
{
test1((int)arg);
}
return NULL;
}
/****************************************************************************
* hello_main
****************************************************************************/
int main(int argc, FAR char *argv[])
{
unsigned int thread_id;
pthread_attr_t attr;
pthread_t pthreads[HRTIMER_TEST_THREAD_NR];
printf("hrtimer_test start...\n");
ASSERT(pthread_attr_init(&attr) == 0);
/* Create wdog test thread */
for (thread_id = 0; thread_id < HRTIMER_TEST_THREAD_NR; thread_id++)
{
ASSERT(pthread_create(&pthreads[thread_id], &attr,
test_thread, (void *)thread_id) == 0);
}
for (thread_id = 0; thread_id < HRTIMER_TEST_THREAD_NR; thread_id++)
{
pthread_join(pthreads[thread_id], NULL);
}
ASSERT(pthread_attr_destroy(&attr) == 0);
printf("hrtimer_test end...\n");
return 0;
}
```
**test passed log on rv-virt:smp64**
```
nsh> uname -a
NuttX 0.0.0 6847a0cc95-dirty Dec 20 2025 12:26:39 risc-v rv-virt
nsh>
nsh> hello
???
???
???
(...)
```
**test 3 passed (provided by @Fix-Point )**
**test implementation**
```
/****************************************************************************
* apps/examples/hello/hello_main.c
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <nuttx/hrtimer.h>
#define HRTIMER_TEST_THREAD_NR (CONFIG_SMP_NCPUS * 8)
/****************************************************************************
* Public Functions
****************************************************************************/
static uint32_t test_callback(FAR struct hrtimer_s *hrtimer)
{
printf("test callback ...\n");
return 0;
}
static void* test_thread(void *arg)
{
irqstate_t flags;
hrtimer_t timer;
spinlock_t lock = SP_UNLOCKED;
hrtimer_init(&timer, test_callback, NULL);
while (1)
{
uint64_t delay = rand() % NSEC_PER_MSEC;
int ret;
/* Simulate the usage of driver->wait_dog. */
flags = spin_lock_irqsave(&lock);
/* The driver lock acquired */
/* First try, failed. Because hrtimer_start can not ensure the timer
being started. */
ret = hrtimer_cancel(&timer);
// ret = hrtimer_start(&timer, 10 * NSEC_PER_USEC, HRTIMER_MODE_REL);
/* May fail */
/* This try-loop start should be OK. But it failed again.
* Besides, we can not sleep or spin in the critical sections.
*/
while (hrtimer_start(&timer, 10 * NSEC_PER_USEC, HRTIMER_MODE_REL) !=
OK);
ret = OK;
/* Second try, Success, but we can not sleep or spin in the critical
section. */
// ret = hrtimer_cancel_sync(&timer); /* Sleep in critical sections */
// ret = hrtimer_start(&timer, delay, HRTIMER_MODE_REL);
spin_unlock_irqrestore(&lock, flags);
if (ret != OK)
{
printf("hrtimer_start failed\n");
}
up_ndelay(delay);
}
return NULL;
}
/****************************************************************************
* hello_main
****************************************************************************/
int main(int argc, FAR char *argv[])
{
unsigned int thread_id;
pthread_attr_t attr;
pthread_t pthreads[HRTIMER_TEST_THREAD_NR];
printf("hrtimer_test start...\n");
ASSERT(pthread_attr_init(&attr) == 0);
/* Create wdog test thread */
for (thread_id = 0; thread_id < HRTIMER_TEST_THREAD_NR; thread_id++)
{
ASSERT(pthread_create(&pthreads[thread_id], &attr,
test_thread, NULL) == 0);
}
for (thread_id = 0; thread_id < HRTIMER_TEST_THREAD_NR; thread_id++)
{
pthread_join(pthreads[thread_id], NULL);
}
ASSERT(pthread_attr_destroy(&attr) == 0);
printf("hrtimer_test end...\n");
return 0;
}
```
**test passed log on rv-virt:smp64**
```
NuttShell (NSH)
nsh>
nsh>
nsh> uname -a
NuttX 0.0.0 6847a0cc95-dirty Dec 20 2025 12:33:59 risc-v rv-virt
nsh> hello
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
test callback ...
(....)
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
