创建
This commit is contained in:
sc committed
commit
da43152a7e
3380 files changed
+1128754
No files matched your search
@@ -0,0 +1,15 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = []
|
||||
if GetDepend("RT_USING_SMP"):
|
||||
src += Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
group = DefineGroup('DeviceDrivers', src, depend = [''], CPPPATH = CPPPATH)
|
||||
|
||||
list = os.listdir(cwd)
|
||||
for item in list:
|
||||
if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
|
||||
group = group + SConscript(os.path.join(item, 'SConscript'))
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,374 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/9/12 zhujiale the first version
|
||||
* 2024/10/24 Shell added non-blocking IPI calling method;
|
||||
* fixup data racing
|
||||
*/
|
||||
|
||||
#include "smp_call.h"
|
||||
|
||||
#define DBG_TAG "SMP"
|
||||
#define DBG_LVL DBG_INFO
|
||||
#include <rtdbg.h>
|
||||
|
||||
static struct smp_data
|
||||
{
|
||||
/* call request data to each cores */
|
||||
struct rt_smp_call_req call_req_cores[RT_CPUS_NR];
|
||||
|
||||
/* call queue of this core */
|
||||
rt_ll_slist_t call_queue;
|
||||
} _smp_data_cores[RT_CPUS_NR];
|
||||
|
||||
#define _CALL_REQ_USAGE_FREED 0
|
||||
#define _CALL_REQ_USAGE_BUSY 1
|
||||
static void _call_req_take(struct rt_smp_call_req *req)
|
||||
{
|
||||
rt_base_t exp;
|
||||
do
|
||||
{
|
||||
exp = _CALL_REQ_USAGE_FREED;
|
||||
}
|
||||
while (!rt_atomic_compare_exchange_strong(&req->event.typed.usage_tracer, &exp, _CALL_REQ_USAGE_BUSY));
|
||||
}
|
||||
|
||||
static void _call_req_release(struct rt_smp_call_req *req)
|
||||
{
|
||||
rt_atomic_store(&req->event.typed.usage_tracer, _CALL_REQ_USAGE_FREED);
|
||||
}
|
||||
|
||||
void rt_smp_request_wait_freed(struct rt_smp_call_req *req)
|
||||
{
|
||||
rt_base_t usage_tracer;
|
||||
|
||||
RT_DEBUG_IN_THREAD_CONTEXT;
|
||||
|
||||
usage_tracer = rt_atomic_load(&req->event.typed.usage_tracer);
|
||||
while (usage_tracer != _CALL_REQ_USAGE_FREED)
|
||||
{
|
||||
rt_thread_yield();
|
||||
usage_tracer = rt_atomic_load(&req->event.typed.usage_tracer);
|
||||
}
|
||||
}
|
||||
|
||||
static void _mask_out_cpu(struct rt_smp_event *event, int oncpu)
|
||||
{
|
||||
rt_base_t new_mask, old_mask;
|
||||
rt_atomic_t *maskp = event->typed.calling_cpu_mask;
|
||||
do
|
||||
{
|
||||
old_mask = rt_atomic_load(maskp);
|
||||
new_mask = old_mask & ~(1ul << oncpu);
|
||||
} while (!rt_atomic_compare_exchange_strong(maskp, &old_mask, new_mask));
|
||||
}
|
||||
|
||||
static void _do_glob_request(struct rt_smp_call_req *req_global,
|
||||
struct rt_smp_call_req *req_local)
|
||||
{
|
||||
struct rt_smp_event *event;
|
||||
|
||||
/* release the global request data */
|
||||
rt_memcpy(req_local, req_global, sizeof(struct rt_smp_call_req));
|
||||
rt_hw_spin_unlock(&req_global->freed_lock);
|
||||
|
||||
event = &req_local->event;
|
||||
RT_ASSERT(!!event->func);
|
||||
event->func(event->data);
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
static void _do_request(struct rt_smp_call_req *req)
|
||||
{
|
||||
struct rt_smp_event *event;
|
||||
|
||||
event = &req->event;
|
||||
RT_ASSERT(!!event->func);
|
||||
event->func(event->data);
|
||||
|
||||
_call_req_release(req);
|
||||
return ;
|
||||
}
|
||||
|
||||
static rt_err_t _smp_call_handler(struct rt_smp_call_req *req, int oncpu)
|
||||
{
|
||||
switch (req->event.event_id)
|
||||
{
|
||||
case SMP_CALL_EVENT_GLOB_SYNC:
|
||||
{
|
||||
struct rt_smp_call_req req_local;
|
||||
_do_glob_request(req, &req_local);
|
||||
_mask_out_cpu(&req_local.event, oncpu);
|
||||
break;
|
||||
}
|
||||
case SMP_CALL_EVENT_GLOB_ASYNC:
|
||||
{
|
||||
struct rt_smp_call_req req_local;
|
||||
_do_glob_request(req, &req_local);
|
||||
break;
|
||||
}
|
||||
case SMP_CALL_EVENT_REQUEST:
|
||||
{
|
||||
_do_request(req);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
LOG_E("error event id\n");
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void rt_smp_call_ipi_handler(int vector, void *param)
|
||||
{
|
||||
int oncpu = rt_hw_cpu_id();
|
||||
struct rt_smp_call_req *request;
|
||||
|
||||
RT_ASSERT(rt_interrupt_get_nest());
|
||||
|
||||
while (1)
|
||||
{
|
||||
rt_ll_slist_t *node = rt_ll_slist_dequeue(&_smp_data_cores[oncpu].call_queue);
|
||||
if (node)
|
||||
{
|
||||
request = rt_list_entry(node, struct rt_smp_call_req, slist_node);
|
||||
|
||||
_smp_call_handler(request, oncpu);
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void _smp_call_remote_request(int callcpu, rt_smp_call_cb_t func,
|
||||
void *data, rt_uint8_t flags,
|
||||
struct rt_smp_call_req *call_req)
|
||||
{
|
||||
rt_base_t cpu_mask = 1ul << callcpu;
|
||||
|
||||
_call_req_take(call_req);
|
||||
|
||||
rt_ll_slist_enqueue(&_smp_data_cores[callcpu].call_queue, &call_req->slist_node);
|
||||
|
||||
rt_hw_ipi_send(RT_SMP_CALL_IPI, cpu_mask);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief SMP call request with user provided @call_req. Compare to
|
||||
* rt_smp_call_func* family, you can call it in ISR or IRQ-masked
|
||||
* environment.
|
||||
*
|
||||
* @param callcpu the logical core id of the target
|
||||
* @param flags control flags of your request
|
||||
* @param call_req the pre-initialized request data
|
||||
* @return rt_err_t RT_EOK on succeed, otherwise the errno to failure
|
||||
*/
|
||||
rt_err_t rt_smp_call_request(int callcpu, rt_uint8_t flags, struct rt_smp_call_req *call_req)
|
||||
{
|
||||
rt_ubase_t clvl;
|
||||
int oncpu;
|
||||
|
||||
if (rt_atomic_load(&call_req->event.typed.usage_tracer) ==
|
||||
_CALL_REQ_USAGE_BUSY)
|
||||
{
|
||||
return -RT_EBUSY;
|
||||
}
|
||||
|
||||
if (flags & SMP_CALL_WAIT_ALL)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
clvl = rt_enter_critical();
|
||||
oncpu = rt_hw_cpu_id();
|
||||
|
||||
if (oncpu == callcpu && !(flags & SMP_CALL_NO_LOCAL))
|
||||
{
|
||||
rt_ubase_t level;
|
||||
|
||||
/* handle IPI on irq-masked environment */
|
||||
level = rt_hw_local_irq_disable();
|
||||
call_req->event.func(call_req->event.data);
|
||||
rt_hw_local_irq_enable(level);
|
||||
}
|
||||
else if (callcpu < RT_CPUS_NR)
|
||||
{
|
||||
_smp_call_remote_request(callcpu, call_req->event.func, call_req->event.data, flags, call_req);
|
||||
}
|
||||
|
||||
rt_exit_critical_safe(clvl);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void rt_smp_call_req_init(struct rt_smp_call_req *call_req,
|
||||
rt_smp_call_cb_t func, void *data)
|
||||
{
|
||||
call_req->event.typed.usage_tracer = 0;
|
||||
call_req->event.data = data;
|
||||
call_req->event.func = func;
|
||||
call_req->event.event_id = SMP_CALL_EVENT_REQUEST;
|
||||
}
|
||||
|
||||
static void _smp_call_func_cond(int oncpu, rt_ubase_t cpu_mask,
|
||||
rt_smp_call_cb_t func, void *data,
|
||||
rt_uint8_t flags, rt_smp_cond_t cond)
|
||||
{
|
||||
rt_ubase_t tmp_mask;
|
||||
rt_bool_t sync_call = RT_FALSE;
|
||||
rt_ubase_t oncpu_mask = 1 << oncpu;
|
||||
rt_atomic_t calling_cpu_mask, *maskp;
|
||||
int tmp_id = 0, rcpu_cnt = 0, event_id, call_local;
|
||||
|
||||
if (!(flags & SMP_CALL_NO_LOCAL) && (oncpu_mask & cpu_mask))
|
||||
{
|
||||
call_local = RT_TRUE;
|
||||
cpu_mask = cpu_mask & (~oncpu_mask);
|
||||
}
|
||||
else
|
||||
{
|
||||
call_local = RT_FALSE;
|
||||
}
|
||||
|
||||
if (cpu_mask)
|
||||
{
|
||||
tmp_mask = cpu_mask;
|
||||
|
||||
if (flags & SMP_CALL_WAIT_ALL)
|
||||
{
|
||||
sync_call = RT_TRUE;
|
||||
maskp = &calling_cpu_mask;
|
||||
event_id = SMP_CALL_EVENT_GLOB_SYNC;
|
||||
rt_atomic_store(maskp, cpu_mask);
|
||||
}
|
||||
else
|
||||
{
|
||||
event_id = SMP_CALL_EVENT_GLOB_ASYNC;
|
||||
maskp = RT_NULL;
|
||||
}
|
||||
|
||||
while (tmp_mask)
|
||||
{
|
||||
struct rt_smp_call_req *call_req;
|
||||
struct rt_smp_event *event;
|
||||
int lz_bit = __rt_ffsl(tmp_mask);
|
||||
|
||||
tmp_id = lz_bit - 1;
|
||||
tmp_mask &= ~(1ul << tmp_id);
|
||||
|
||||
if (cond && !cond(tmp_id, data))
|
||||
{
|
||||
cpu_mask &= ~(1ul << tmp_id);
|
||||
continue;
|
||||
}
|
||||
|
||||
/* need to wait one more */
|
||||
rcpu_cnt++;
|
||||
|
||||
call_req = &_smp_data_cores[oncpu].call_req_cores[tmp_id];
|
||||
|
||||
/* very careful here, spinning wait on previous occupation */
|
||||
rt_hw_spin_lock(&call_req->freed_lock);
|
||||
|
||||
event = &call_req->event;
|
||||
event->event_id = event_id;
|
||||
event->func = func;
|
||||
event->data = data;
|
||||
event->typed.calling_cpu_mask = maskp;
|
||||
|
||||
rt_ll_slist_enqueue(&_smp_data_cores[tmp_id].call_queue, &call_req->slist_node);
|
||||
}
|
||||
|
||||
if (cpu_mask)
|
||||
{
|
||||
RT_ASSERT(rcpu_cnt);
|
||||
|
||||
rt_hw_ipi_send(RT_SMP_CALL_IPI, cpu_mask);
|
||||
}
|
||||
}
|
||||
|
||||
if (call_local && (!cond || cond(tmp_id, data)))
|
||||
{
|
||||
rt_ubase_t level;
|
||||
|
||||
/* callback on local with sims ISR */
|
||||
level = rt_hw_local_irq_disable();
|
||||
func(data);
|
||||
rt_hw_local_irq_enable(level);
|
||||
}
|
||||
|
||||
if (sync_call && rcpu_cnt)
|
||||
{
|
||||
while (rt_atomic_load(maskp) & cpu_mask)
|
||||
;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief call function on specified CPU ,
|
||||
*
|
||||
* @param cpu_mask cpu mask for call
|
||||
* @param func the function pointer
|
||||
* @param data the data pointer
|
||||
* @param flag call flag if you set SMP_CALL_WAIT_ALL
|
||||
* then it will wait all cpu call finish and return
|
||||
* else it will call function on specified CPU and return immediately
|
||||
* @param cond the condition function pointer,if you set it then it will call function only when cond return true
|
||||
*/
|
||||
void rt_smp_call_func_cond(rt_ubase_t cpu_mask, rt_smp_call_cb_t func, void *data, rt_uint8_t flag, rt_smp_cond_t cond)
|
||||
{
|
||||
int oncpu;
|
||||
rt_ubase_t clvl;
|
||||
|
||||
RT_ASSERT(!rt_hw_interrupt_is_disabled());
|
||||
|
||||
clvl = rt_enter_critical();
|
||||
oncpu = rt_hw_cpu_id();
|
||||
|
||||
if (cpu_mask <= RT_ALL_CPU)
|
||||
{
|
||||
_smp_call_func_cond(oncpu, cpu_mask, func, data, flag, cond);
|
||||
}
|
||||
|
||||
rt_exit_critical_safe(clvl);
|
||||
}
|
||||
|
||||
void rt_smp_call_each_cpu(rt_smp_call_cb_t func, void *data, rt_uint8_t flag)
|
||||
{
|
||||
rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, RT_NULL);
|
||||
}
|
||||
|
||||
void rt_smp_call_each_cpu_cond(rt_smp_call_cb_t func, void *data, rt_uint8_t flag, rt_smp_cond_t cond_func)
|
||||
{
|
||||
rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, cond_func);
|
||||
}
|
||||
|
||||
void rt_smp_call_cpu_mask(rt_ubase_t cpu_mask, rt_smp_call_cb_t func, void *data, rt_uint8_t flag)
|
||||
{
|
||||
rt_smp_call_func_cond(cpu_mask, func, data, flag, RT_NULL);
|
||||
}
|
||||
|
||||
void rt_smp_call_cpu_mask_cond(rt_ubase_t cpu_mask, rt_smp_call_cb_t func, void *data, rt_uint8_t flag, rt_smp_cond_t cond_func)
|
||||
{
|
||||
rt_smp_call_func_cond(cpu_mask, func, data, flag, cond_func);
|
||||
}
|
||||
|
||||
void rt_smp_call_init(void)
|
||||
{
|
||||
rt_memset(&_smp_data_cores, 0, sizeof(_smp_data_cores));
|
||||
|
||||
for (int i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
for (int j = 0; j < RT_CPUS_NR; j++)
|
||||
{
|
||||
rt_hw_spin_lock_init(&_smp_data_cores[i].call_req_cores[j].freed_lock);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/9/12 zhujiale the first version
|
||||
* 2024/10/24 Shell added non-blocking IPI calling method
|
||||
*/
|
||||
|
||||
#ifndef __SMP_IPI_H__
|
||||
#define __SMP_IPI_H__
|
||||
#include <rtthread.h>
|
||||
|
||||
#ifdef RT_USING_SMP
|
||||
|
||||
/* callback of smp call */
|
||||
typedef void (*rt_smp_call_cb_t)(void *data);
|
||||
typedef rt_bool_t (*rt_smp_cond_t)(int cpu, void *info);
|
||||
|
||||
#define SMP_CALL_EVENT_GLOB_ASYNC 0x1
|
||||
#define SMP_CALL_EVENT_GLOB_SYNC 0x2
|
||||
#define SMP_CALL_EVENT_REQUEST 0x4
|
||||
|
||||
#define SMP_CALL_WAIT_ALL (1ul << 0)
|
||||
#define SMP_CALL_NO_LOCAL (1ul << 1)
|
||||
#define SMP_CALL_SIGNAL (1ul << 2)
|
||||
|
||||
#define RT_ALL_CPU ((1 << RT_CPUS_NR) - 1)
|
||||
struct rt_smp_event
|
||||
{
|
||||
int event_id;
|
||||
void *data;
|
||||
rt_smp_call_cb_t func;
|
||||
|
||||
union
|
||||
{
|
||||
rt_atomic_t *calling_cpu_mask;
|
||||
rt_atomic_t usage_tracer;
|
||||
} typed;
|
||||
};
|
||||
|
||||
struct rt_smp_call_req
|
||||
{
|
||||
/* handle the busy status synchronization */
|
||||
rt_hw_spinlock_t freed_lock;
|
||||
struct rt_smp_event event;
|
||||
rt_ll_slist_t slist_node;
|
||||
};
|
||||
|
||||
void rt_smp_call_ipi_handler(int vector, void *param);
|
||||
void rt_smp_call_each_cpu(rt_smp_call_cb_t func, void *data, rt_uint8_t flags);
|
||||
void rt_smp_call_each_cpu_cond(rt_smp_call_cb_t func, void *data, rt_uint8_t flag, rt_smp_cond_t cond_func);
|
||||
void rt_smp_call_cpu_mask(rt_ubase_t cpu_mask, rt_smp_call_cb_t func, void *data, rt_uint8_t flags);
|
||||
void rt_smp_call_cpu_mask_cond(rt_ubase_t cpu_mask, rt_smp_call_cb_t func, void *data, rt_uint8_t flag, rt_smp_cond_t cond_func);
|
||||
void rt_smp_call_init(void);
|
||||
|
||||
rt_err_t rt_smp_call_request(int callcpu, rt_uint8_t flags, struct rt_smp_call_req *call_req);
|
||||
void rt_smp_call_req_init(struct rt_smp_call_req *call_req,
|
||||
rt_smp_call_cb_t func, void *data);
|
||||
void rt_smp_request_wait_freed(struct rt_smp_call_req *req);
|
||||
|
||||
#define rt_smp_for_each_cpu(_iter) for (_iter = 0; (_iter) < RT_CPUS_NR; (_iter)++)
|
||||
rt_inline size_t rt_smp_get_next_remote(size_t iter, size_t cpuid)
|
||||
{
|
||||
iter++;
|
||||
return iter == cpuid ? iter + 1 : iter;
|
||||
}
|
||||
#define rt_smp_for_each_remote_cpu(_iter, _cpuid) for (_iter = rt_smp_get_next_remote(-1, _cpuid); (_iter) < RT_CPUS_NR; _iter=rt_smp_get_next_remote(_iter, _cpuid))
|
||||
|
||||
#endif // RT_USING_SMP
|
||||
|
||||
#endif // __SMP_IPI_H__
|
||||
@@ -0,0 +1,8 @@
|
||||
menu "SMP-Call Test"
|
||||
|
||||
config RT_UTEST_SMP_CALL_FUNC
|
||||
bool "SMP-Call Smoke Test"
|
||||
default n
|
||||
depends on RT_USING_SMP
|
||||
|
||||
endmenu
|
||||
@@ -0,0 +1,13 @@
|
||||
Import('rtconfig')
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = []
|
||||
CPPPATH = [cwd]
|
||||
|
||||
if GetDepend(['RT_UTEST_SMP_CALL_FUNC']):
|
||||
src += Glob('smp*.c')
|
||||
|
||||
group = DefineGroup('utestcases', src, depend = ['RT_USING_UTESTCASES'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,90 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/9/12 zhujiale the first version
|
||||
* 2024/10/28 Shell Added more assertions
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
#include <utest.h>
|
||||
#include <utest_assert.h>
|
||||
#include <smp_call.h>
|
||||
|
||||
#define TEST_COUNT 10000
|
||||
|
||||
static int pass_count = 0;
|
||||
static RT_DEFINE_SPINLOCK(_test_data_lock);
|
||||
|
||||
static void _test_smp_cb(void *data)
|
||||
{
|
||||
int *maskp;
|
||||
int oncpu;
|
||||
|
||||
if (!rt_hw_interrupt_is_disabled())
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
rt_spin_lock(&_test_data_lock);
|
||||
|
||||
oncpu = rt_hw_cpu_id();
|
||||
maskp = (int *)data;
|
||||
*maskp &= ~(1 << oncpu);
|
||||
|
||||
rt_spin_unlock(&_test_data_lock);
|
||||
}
|
||||
|
||||
static void _blocking_call(void)
|
||||
{
|
||||
volatile int cpu_mask;
|
||||
rt_ubase_t tested_cpus = 0;
|
||||
|
||||
for (int i = 0; i < TEST_COUNT; i++)
|
||||
{
|
||||
cpu_mask = rand() % RT_ALL_CPU;
|
||||
tested_cpus |= cpu_mask;
|
||||
rt_smp_call_cpu_mask(cpu_mask, _test_smp_cb, (void *)&cpu_mask, SMP_CALL_WAIT_ALL);
|
||||
|
||||
if (!cpu_mask)
|
||||
{
|
||||
pass_count++;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* TARG.001, MP.001 */
|
||||
uassert_true(0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
LOG_D("pass_count %d", pass_count);
|
||||
|
||||
/* TARG.001 */
|
||||
uassert_true(pass_count == TEST_COUNT);
|
||||
|
||||
/* TOP.001, TOP.002 */
|
||||
uassert_true(tested_cpus == RT_ALL_CPU);
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
pass_count = 0;
|
||||
srand(rt_tick_get());
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void _testcase(void)
|
||||
{
|
||||
UTEST_UNIT_RUN(_blocking_call);
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(_testcase, "components.drivers.smp_call.smoke_001", utest_tc_init, utest_tc_cleanup, 10);
|
||||
@@ -0,0 +1,132 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/10/28 Shell Added smp.smoke
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
#include <utest.h>
|
||||
#include <utest_assert.h>
|
||||
#include <smp_call.h>
|
||||
|
||||
#define PERCPU_TEST_COUNT 10000
|
||||
#define NEWLINE_ON 80
|
||||
|
||||
static struct rt_semaphore _utestd_exited;
|
||||
static rt_thread_t _utestd[RT_CPUS_NR];
|
||||
static rt_atomic_t _entry_counts[RT_CPUS_NR];
|
||||
|
||||
static void _logging_progress(void)
|
||||
{
|
||||
static rt_atomic_t counts;
|
||||
rt_ubase_t old;
|
||||
|
||||
rt_kputs("#");
|
||||
old = rt_atomic_add(&counts, 1);
|
||||
if (old % NEWLINE_ON == 0)
|
||||
{
|
||||
rt_kputs("\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void _test_smp_cb(void *param)
|
||||
{
|
||||
rt_ubase_t req_cpuid = (rt_ubase_t)param;
|
||||
|
||||
if (!rt_hw_interrupt_is_disabled())
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
_logging_progress();
|
||||
rt_atomic_add(&_entry_counts[req_cpuid], 1);
|
||||
}
|
||||
|
||||
static void _utestd_entry(void *oncpu_param)
|
||||
{
|
||||
rt_ubase_t oncpu = (rt_ubase_t)oncpu_param;
|
||||
volatile int cpu_mask;
|
||||
volatile int popcount = 0;
|
||||
rt_ubase_t tested_cpus = 0;
|
||||
|
||||
if (rt_hw_cpu_id() != oncpu)
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < PERCPU_TEST_COUNT; i++)
|
||||
{
|
||||
cpu_mask = rand() % RT_ALL_CPU;
|
||||
tested_cpus |= cpu_mask;
|
||||
|
||||
rt_smp_call_cpu_mask(cpu_mask, _test_smp_cb, oncpu_param, SMP_CALL_WAIT_ALL);
|
||||
popcount += __builtin_popcount(cpu_mask);
|
||||
}
|
||||
|
||||
LOG_D("popcount %d, _entry_counts[%d] %d", popcount, oncpu, _entry_counts[oncpu]);
|
||||
|
||||
/* TARG.001 */
|
||||
uassert_true(popcount == rt_atomic_load(&_entry_counts[oncpu]));
|
||||
|
||||
/* TOP.001, TOP.002 */
|
||||
uassert_true(tested_cpus == RT_ALL_CPU);
|
||||
|
||||
rt_sem_release(&_utestd_exited);
|
||||
}
|
||||
|
||||
static void _blocking_mtsafe_call(void)
|
||||
{
|
||||
rt_err_t error;
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
error = rt_thread_startup(_utestd[i]);
|
||||
|
||||
/* SYNC.001, SYNC.002, SYNC.003 */
|
||||
uassert_true(!error);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_sem_take(&_utestd_exited, RT_WAITING_FOREVER);
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_atomic_store(&_entry_counts[i], 0);
|
||||
_utestd[i] = rt_thread_create("utestd", _utestd_entry, (void *)i,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY,
|
||||
20);
|
||||
rt_thread_control(_utestd[i], RT_THREAD_CTRL_BIND_CPU, (void *)i);
|
||||
|
||||
/* SYNC.001, SYNC.002, SYNC.003 */
|
||||
uassert_true(_utestd[i] != RT_NULL);
|
||||
}
|
||||
|
||||
rt_sem_init(&_utestd_exited, "utestd", 0, RT_IPC_FLAG_PRIO);
|
||||
srand(rt_tick_get());
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
rt_sem_detach(&_utestd_exited);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void _testcase(void)
|
||||
{
|
||||
UTEST_UNIT_RUN(_blocking_mtsafe_call);
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(_testcase, "components.drivers.smp_call.smoke_002", utest_tc_init, utest_tc_cleanup, 10);
|
||||
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/10/28 Shell Added smp.smoke
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
#include <utest.h>
|
||||
#include <utest_assert.h>
|
||||
#include <smp_call.h>
|
||||
|
||||
#define PERCPU_TEST_COUNT 10000
|
||||
#define NEWLINE_ON 80
|
||||
|
||||
static struct rt_semaphore _utestd_exited;
|
||||
static rt_thread_t _utestd[RT_CPUS_NR];
|
||||
static rt_atomic_t _entry_counts[RT_CPUS_NR];
|
||||
|
||||
static void _logging_progress(void)
|
||||
{
|
||||
static rt_atomic_t counts;
|
||||
rt_ubase_t old;
|
||||
|
||||
rt_kputs("#");
|
||||
old = rt_atomic_add(&counts, 1);
|
||||
if (old % NEWLINE_ON == 0)
|
||||
{
|
||||
rt_kputs("\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void _test_smp_cb(void *param)
|
||||
{
|
||||
rt_ubase_t req_cpuid = (rt_ubase_t)param;
|
||||
|
||||
if (!rt_hw_interrupt_is_disabled())
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
_logging_progress();
|
||||
rt_atomic_add(&_entry_counts[req_cpuid], 1);
|
||||
}
|
||||
|
||||
static void _utestd_entry(void *oncpu_param)
|
||||
{
|
||||
rt_ubase_t oncpu = (rt_ubase_t)oncpu_param;
|
||||
volatile int cpu_mask;
|
||||
volatile int popcount = 0;
|
||||
rt_thread_t curthr = rt_thread_self();
|
||||
|
||||
if (rt_hw_cpu_id() != oncpu)
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < PERCPU_TEST_COUNT; i++)
|
||||
{
|
||||
cpu_mask = rand() % RT_ALL_CPU;
|
||||
|
||||
rt_smp_call_cpu_mask(cpu_mask, _test_smp_cb, oncpu_param, 0);
|
||||
popcount += __builtin_popcount(cpu_mask);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_thread_control(curthr, RT_THREAD_CTRL_BIND_CPU, (void *)i);
|
||||
}
|
||||
|
||||
LOG_D("popcount %d, _entry_counts[%d] %d", popcount, oncpu, _entry_counts[oncpu]);
|
||||
|
||||
/* MP.002 */
|
||||
uassert_true(popcount == rt_atomic_load(&_entry_counts[oncpu]));
|
||||
|
||||
rt_sem_release(&_utestd_exited);
|
||||
}
|
||||
|
||||
static void _async_call(void)
|
||||
{
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_thread_startup(_utestd[i]);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_sem_take(&_utestd_exited, RT_WAITING_FOREVER);
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_atomic_store(&_entry_counts[i], 0);
|
||||
_utestd[i] = rt_thread_create("utestd", _utestd_entry, (void *)i,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY,
|
||||
20);
|
||||
rt_thread_control(_utestd[i], RT_THREAD_CTRL_BIND_CPU, (void *)i);
|
||||
|
||||
/* SYNC.001, SYNC.002, SYNC.003 */
|
||||
uassert_true(_utestd[i] != RT_NULL);
|
||||
}
|
||||
|
||||
rt_sem_init(&_utestd_exited, "utestd", 0, RT_IPC_FLAG_PRIO);
|
||||
srand(rt_tick_get());
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
rt_sem_detach(&_utestd_exited);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void _testcase(void)
|
||||
{
|
||||
UTEST_UNIT_RUN(_async_call);
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(_testcase, "components.drivers.smp_call.smoke_003", utest_tc_init, utest_tc_cleanup, 10);
|
||||
@@ -0,0 +1,210 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2024 RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2024/10/28 Shell Added smp.smoke
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
#include <utest.h>
|
||||
#include <utest_assert.h>
|
||||
#include <smp_call.h>
|
||||
|
||||
#define PERCPU_TEST_COUNT 10000
|
||||
#define NEWLINE_ON 80
|
||||
#define MAX_RETRIES (RT_TICK_PER_SECOND)
|
||||
|
||||
static struct rt_semaphore _utestd_exited;
|
||||
static rt_thread_t _utestd[RT_CPUS_NR];
|
||||
static rt_atomic_t _entry_counts[RT_CPUS_NR];
|
||||
static struct rt_smp_call_req _callreq_data[RT_CPUS_NR][RT_CPUS_NR];
|
||||
static rt_ubase_t _masks_data[RT_CPUS_NR];
|
||||
static RT_DEFINE_SPINLOCK(_test_data_lock);
|
||||
|
||||
static void _logging_progress(char id)
|
||||
{
|
||||
static rt_atomic_t counts;
|
||||
rt_ubase_t old;
|
||||
|
||||
rt_kprintf("%c", id);
|
||||
old = rt_atomic_add(&counts, 1);
|
||||
if (old % NEWLINE_ON == 0)
|
||||
{
|
||||
rt_kputs("\n");
|
||||
}
|
||||
}
|
||||
|
||||
static void _reentr_isr_cb(void *param)
|
||||
{
|
||||
rt_ubase_t *maskp;
|
||||
int oncpu;
|
||||
|
||||
if (!rt_hw_interrupt_is_disabled())
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
rt_spin_lock(&_test_data_lock);
|
||||
|
||||
oncpu = rt_hw_cpu_id();
|
||||
maskp = (rt_ubase_t *)param;
|
||||
*maskp |= (1 << oncpu);
|
||||
|
||||
rt_spin_unlock(&_test_data_lock);
|
||||
|
||||
_logging_progress('0' + (maskp - _masks_data));
|
||||
}
|
||||
|
||||
static void _test_smp_call_isr(void *param)
|
||||
{
|
||||
rt_err_t error;
|
||||
rt_ubase_t iter, oncpu = (rt_ubase_t)param;
|
||||
struct rt_smp_call_req *callreqp = _callreq_data[oncpu];
|
||||
|
||||
if (rt_hw_cpu_id() != oncpu)
|
||||
{
|
||||
/* SYNC.004 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
if (!rt_hw_interrupt_is_disabled())
|
||||
{
|
||||
/* SYNC.004, PRIV.001 */
|
||||
uassert_true(0);
|
||||
}
|
||||
|
||||
rt_smp_for_each_remote_cpu(iter, oncpu)
|
||||
{
|
||||
error = rt_smp_call_request(iter, SMP_CALL_NO_LOCAL, &callreqp[iter]);
|
||||
if (error)
|
||||
{
|
||||
/* SYNC.002 */
|
||||
uassert_false(error);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static rt_ubase_t _wait_for_update(rt_ubase_t *maskp, rt_ubase_t exp, int cpuid, rt_thread_t curthr)
|
||||
{
|
||||
rt_ubase_t level, current_mask;
|
||||
|
||||
for (size_t i = cpuid; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_thread_control(curthr, RT_THREAD_CTRL_BIND_CPU, (void *)(i % RT_CPUS_NR));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < MAX_RETRIES; i++)
|
||||
{
|
||||
level = rt_spin_lock_irqsave(&_test_data_lock);
|
||||
current_mask = *maskp;
|
||||
rt_spin_unlock_irqrestore(&_test_data_lock, level);
|
||||
|
||||
if (current_mask == exp)
|
||||
{
|
||||
break;
|
||||
}
|
||||
rt_thread_delay(1);
|
||||
}
|
||||
|
||||
return current_mask;
|
||||
}
|
||||
static void _utestd_entry(void *oncpu_param)
|
||||
{
|
||||
rt_thread_t curthr = rt_thread_self();
|
||||
rt_ubase_t oncpu = (rt_ubase_t)oncpu_param;
|
||||
rt_ubase_t worker_id = (oncpu + 1) % RT_CPUS_NR;
|
||||
int cpu_mask = 1ul << worker_id;
|
||||
rt_ubase_t req_cpus_mask = ~cpu_mask & RT_ALL_CPU;
|
||||
rt_ubase_t *mask_data = &_masks_data[worker_id];
|
||||
rt_ubase_t current_mask;
|
||||
rt_ubase_t level;
|
||||
|
||||
for (size_t i = 0; i < PERCPU_TEST_COUNT; i++)
|
||||
{
|
||||
rt_smp_call_cpu_mask(cpu_mask, _test_smp_call_isr, (void *)worker_id, 0);
|
||||
|
||||
current_mask = _wait_for_update(mask_data, req_cpus_mask, worker_id, curthr);
|
||||
if (current_mask != req_cpus_mask)
|
||||
{
|
||||
LOG_I("current mask 0x%x, last fetch 0x%x", *mask_data, current_mask);
|
||||
|
||||
/* MP.002, TARG.001 */
|
||||
uassert_true(0);
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_ubase_t iter;
|
||||
level = rt_spin_lock_irqsave(&_test_data_lock);
|
||||
*mask_data = 0;
|
||||
rt_spin_unlock_irqrestore(&_test_data_lock, level);
|
||||
|
||||
rt_smp_for_each_remote_cpu(iter, worker_id)
|
||||
{
|
||||
rt_smp_request_wait_freed(&_callreq_data[worker_id][iter]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
rt_sem_release(&_utestd_exited);
|
||||
}
|
||||
|
||||
static void _test_reentr_isr_main(void)
|
||||
{
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_thread_startup(_utestd[i]);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
rt_sem_take(&_utestd_exited, RT_WAITING_FOREVER);
|
||||
}
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_init(void)
|
||||
{
|
||||
size_t iter_x, iter_y;
|
||||
rt_smp_for_each_cpu(iter_x)
|
||||
{
|
||||
rt_smp_for_each_cpu(iter_y)
|
||||
{
|
||||
rt_smp_call_req_init(&_callreq_data[iter_x][iter_y],
|
||||
_reentr_isr_cb, &_masks_data[iter_x]);
|
||||
}
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < RT_CPUS_NR; i++)
|
||||
{
|
||||
_masks_data[i] = 0;
|
||||
rt_atomic_store(&_entry_counts[i], 0);
|
||||
_utestd[i] = rt_thread_create("utestd", _utestd_entry, (void *)i,
|
||||
UTEST_THR_STACK_SIZE, UTEST_THR_PRIORITY + 1,
|
||||
20);
|
||||
rt_thread_control(_utestd[i], RT_THREAD_CTRL_BIND_CPU, (void *)i);
|
||||
uassert_true(_utestd[i] != RT_NULL);
|
||||
}
|
||||
|
||||
rt_sem_init(&_utestd_exited, "utestd", 0, RT_IPC_FLAG_PRIO);
|
||||
srand(rt_tick_get());
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t utest_tc_cleanup(void)
|
||||
{
|
||||
rt_sem_detach(&_utestd_exited);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void _testcase(void)
|
||||
{
|
||||
UTEST_UNIT_RUN(_test_reentr_isr_main);
|
||||
}
|
||||
|
||||
UTEST_TC_EXPORT(_testcase, "components.drivers.smp_call.smoke_004", utest_tc_init, utest_tc_cleanup, 10);
|
||||
Reference in new issue
Block a user