smp

zhuzhuzhus · Rbb666 · commit 8ce405f739c1 · 2024-09-24T09:56:30.000+08:00
diff --git a/components/smp/SConscript b/components/smp/SConscript
@@ -5,6 +5,6 @@ src = []
 if GetDepend("RT_USING_SMP"):
     src += Glob('*.c')
 CPPPATH = [cwd]
-group = DefineGroup('mprotect', src, depend = [''], CPPPATH = CPPPATH)
+group = DefineGroup('smp', src, depend = [''], CPPPATH = CPPPATH)
 
 Return('group')
diff --git a/components/smp/smp.c b/components/smp/smp.c
@@ -14,15 +14,15 @@
 #define DBG_LVL DBG_INFO
 #include <rtdbg.h>
 
-struct smp_call global_work[RT_CPUS_NR];
-rt_atomic_t wait;
-rt_err_t smp_call_handler(struct smp_event *event)
+struct rt_smp_call rt_smp_work[RT_CPUS_NR];
+rt_atomic_t        rt_smp_wait;
+rt_err_t           smp_call_handler(struct rt_smp_event *event)
 {
-    switch(event->event_id)
+    switch (event->event_id)
     {
     case SMP_CALL_EVENT_FUNC:
         event->func(event->data);
-        rt_atomic_add(&wait,1);
+        rt_atomic_add(&rt_smp_wait, 1);
         break;
     default:
         LOG_E("error event id\n");
@@ -34,20 +34,20 @@ void rt_smp_call_ipi_handler(int vector, void *param)
 {
     int err;
     int cur_cpu = rt_hw_cpu_id();
-    rt_spin_lock(&global_work[cur_cpu].lock);
-    if(global_work[cur_cpu].event.event_id)
+    rt_spin_lock(&rt_smp_work[cur_cpu].lock);
+    
+    if (rt_smp_work[cur_cpu].event.event_id)
     {
-        err = smp_call_handler(&global_work[cur_cpu].event);
-        if(err)
+        err = smp_call_handler(&rt_smp_work[cur_cpu].event);
+        if (err)
         {
             LOG_E("Have no event\n");
-            rt_memset(&global_work[cur_cpu].event,0,sizeof(struct smp_event));
-            rt_spin_unlock(&global_work[cur_cpu].lock);
+            rt_memset(&rt_smp_work[cur_cpu].event, 0, sizeof(struct rt_smp_event));
+            rt_spin_unlock(&rt_smp_work[cur_cpu].lock);
         }
-        rt_memset(&global_work[cur_cpu].event,0,sizeof(struct smp_event));
+        rt_memset(&rt_smp_work[cur_cpu].event, 0, sizeof(struct rt_smp_event));
     }
-    rt_spin_unlock(&global_work[cur_cpu].lock);
-
+    rt_spin_unlock(&rt_smp_work[cur_cpu].lock);
 }
 
 /**
@@ -61,85 +61,85 @@ void rt_smp_call_ipi_handler(int vector, void *param)
  *             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(int cpu_mask, smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond)
+void rt_smp_call_func_cond(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond)
 {
     RT_DEBUG_NOT_IN_INTERRUPT;
-    struct smp_event event;
-    rt_bool_t need_call = RT_TRUE,need_wait = RT_FALSE;
-    int cur_cpu = rt_hw_cpu_id();
-    int cpuid = 1 << cur_cpu;
-    int tmp_id = 0,cpu_nr = 0;
-    int tmp_mask;
+    struct rt_smp_event event;
+    rt_bool_t           need_call = RT_TRUE, need_wait = RT_FALSE;
+    int                 cur_cpu = rt_hw_cpu_id();
+    int                 cpuid   = 1 << cur_cpu;
+    int                 tmp_id = 0, cpu_nr = 0;
+    int                 tmp_mask;
 
-    if(flag == SMP_CALL_WAIT_ALL)
+    if (flag == SMP_CALL_WAIT_ALL)
     {
         need_wait = RT_TRUE;
-        rt_atomic_store(&wait,0);
+        rt_atomic_store(&rt_smp_wait, 0);
     }
 
-    if(cpuid & cpu_mask)
+    if (cpuid & cpu_mask)
     {
         func(data);
         cpu_mask = cpu_mask & (~cpuid);
     }
 
-    if(!cpu_mask)
+    if (!cpu_mask)
         need_call = RT_FALSE;
 
     tmp_mask = cpu_mask;
-    if(need_call)
+    if (need_call)
     {
-        while(tmp_mask)
+        while (tmp_mask)
         {
-            if((tmp_mask & 1) && (tmp_id < RT_CPUS_NR))
+            if ((tmp_mask & 1) && (tmp_id < RT_CPUS_NR))
             {
-                if(cond && !cond(tmp_id,data))
+                if (cond && !cond(tmp_id, data))
                     continue;
                 cpu_nr++;
                 event.event_id = SMP_CALL_EVENT_FUNC;
-                event.func = func;
-                event.data = data;
+                event.func     = func;
+                event.data     = data;
                 event.cpu_mask = cpu_mask;
-                rt_spin_lock(&global_work[tmp_id].lock);
-                global_work[tmp_id].event = event;
-                rt_spin_unlock(&global_work[tmp_id].lock);
+                rt_spin_lock(&rt_smp_work[tmp_id].lock);
+                rt_smp_work[tmp_id].event = event;
+                rt_spin_unlock(&rt_smp_work[tmp_id].lock);
             }
             tmp_id++;
             tmp_mask = tmp_mask >> 1;
         }
         rt_hw_ipi_send(RT_FUNC_IPI, cpu_mask);
     }
 
-    if(need_wait)
+    if (need_wait)
     {
-        while(rt_atomic_load(&wait) != cpu_nr);
+        while (rt_atomic_load(&rt_smp_wait) != cpu_nr);
     }
 }
 
-void rt_call_each_cpu(smp_call_func_back func, void *data,rt_uint8_t flag)
+void rt_smp_call_each_cpu(smp_call_func_back func, void *data, rt_uint8_t flag)
 {
-    rt_smp_call_func_cond(RT_ALL_CPU,func,data,flag,RT_NULL);
+    rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, RT_NULL);
 }
 
-void rt_call_each_cpu_cond(smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func)
+void rt_smp_call_each_cpu_cond(smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond_func)
 {
-    rt_smp_call_func_cond(RT_ALL_CPU,func,data,flag,cond_func);
+    rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, cond_func);
 }
-void rt_call_any_cpu(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag)
+void rt_smp_call_any_cpu(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag)
 {
-    rt_smp_call_func_cond(cpu_mask,func,data,flag,RT_NULL);
+    rt_smp_call_func_cond(cpu_mask, func, data, flag, RT_NULL);
 }
 
-void rt_call_any_cpu_cond(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func)
+void rt_smp_call_any_cpu_cond(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond_func)
 {
-    rt_smp_call_func_cond(cpu_mask,func,data,flag,cond_func);
+    rt_smp_call_func_cond(cpu_mask, func, data, flag, cond_func);
 }
 
-void smp_init(void)
+void rt_smp_init(void)
 {
-    for(int i = 0; i < RT_CPUS_NR; i++)
+    for (int i = 0; i < RT_CPUS_NR; i++)
     {
-        rt_memset(&global_work[i],0,sizeof(struct smp_call));
-        rt_spin_lock_init(&global_work[i].lock);
+        rt_memset(&rt_smp_work[i], 0, sizeof(struct rt_smp_call));
+        rt_spin_lock_init(&rt_smp_work[i].lock);
     }
 }
diff --git a/components/smp/smp.h b/components/smp/smp.h
@@ -10,25 +10,25 @@ typedef rt_bool_t (*smp_cond)(int cpu, void *info);
 #define SMP_CALL_NO_WAIT (1 << 1)
 
 #define RT_ALL_CPU ((1 << RT_CPUS_NR) - 1)
-struct smp_event
+struct rt_smp_event
 {
     int cpu_mask;
     int event_id;
     void *data;
     smp_call_func_back func;
 };
-struct smp_call
+struct rt_smp_call
 {
     struct rt_spinlock lock;
-    struct smp_event event;
+    struct rt_smp_event event;
 };
 
 
 void rt_smp_call_ipi_handler(int vector, void *param);
-void rt_call_each_cpu(smp_call_func_back func, void *data,rt_uint8_t flag);
-void rt_call_each_cpu_cond(smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func);
-void rt_call_any_cpu(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag);
-void rt_call_any_cpu_cond(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func);
-void smp_init(void);
+void rt_smp_call_each_cpu(smp_call_func_back func, void *data,rt_uint8_t flag);
+void rt_smp_call_each_cpu_cond(smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func);
+void rt_smp_call_any_cpu(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag);
+void rt_smp_call_any_cpu_cond(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func);
+void rt_smp_init(void);
 
 #endif
diff --git a/examples/utest/testcases/smp/smp.c b/examples/utest/testcases/smp/smp.c
@@ -26,7 +26,7 @@ void test1()
         cpu_mask = rand() % 0xf;
         if (cpu_mask == 0)
             pass--;
-        rt_call_any_cpu(cpu_mask,test_call, &cpu_mask, SMP_CALL_WAIT_ALL);
+        rt_smp_call_any_cpu(cpu_mask,test_call, &cpu_mask, SMP_CALL_WAIT_ALL);
         if (i % 20 == 0)
             rt_kprintf("#");
     }
@@ -46,11 +46,11 @@ void test_call2(void *data)
 void test2(void)
 {
     int data = 0;
-    rt_call_each_cpu(test_call2, &data, SMP_CALL_WAIT_ALL);
+    rt_smp_call_each_cpu(test_call2, &data, SMP_CALL_WAIT_ALL);
     uassert_true(data == RT_CPUS_NR);
     rt_thread_mdelay(10);
     data = 0;
-    rt_call_each_cpu(test_call2, &data, SMP_CALL_NO_WAIT);
+    rt_smp_call_each_cpu(test_call2, &data, SMP_CALL_NO_WAIT);
     uassert_true(data != RT_CPUS_NR);
 }
 
diff --git a/libcpu/aarch64/common/setup.c b/libcpu/aarch64/common/setup.c
@@ -302,7 +302,7 @@ void rt_hw_common_setup(void)
     rt_thread_idle_sethook(rt_hw_idle_wfi);
 
 #ifdef RT_USING_SMP
-    smp_init();
+    rt_smp_init();
     /* Install the IPI handle */
     rt_hw_ipi_handler_install(RT_SCHEDULE_IPI, rt_scheduler_ipi_handler);
     rt_hw_ipi_handler_install(RT_STOP_IPI, rt_scheduler_ipi_handler);

Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,15 @@`
`14`	`14`	`#define DBG_LVL DBG_INFO`
`15`	`15`	`#include <rtdbg.h>`
`16`	`16`
`17`		`-struct smp_call global_work[RT_CPUS_NR];`
`18`		`-rt_atomic_t wait;`
`19`		`-rt_err_t smp_call_handler(struct smp_event *event)`
	`17`	`+struct rt_smp_call rt_smp_work[RT_CPUS_NR];`
	`18`	`+rt_atomic_t rt_smp_wait;`
	`19`	`+rt_err_t smp_call_handler(struct rt_smp_event *event)`
`20`	`20`	`{`
`21`		`- switch(event->event_id)`
	`21`	`+ switch (event->event_id)`
`22`	`22`	`{`
`23`	`23`	`case SMP_CALL_EVENT_FUNC:`
`24`	`24`	`event->func(event->data);`
`25`		`- rt_atomic_add(&wait,1);`
	`25`	`+ rt_atomic_add(&rt_smp_wait, 1);`
`26`	`26`	`break;`
`27`	`27`	`default:`
`28`	`28`	`LOG_E("error event id\n");`
`@@ -34,20 +34,20 @@ void rt_smp_call_ipi_handler(int vector, void *param)`
`34`	`34`	`{`
`35`	`35`	`int err;`
`36`	`36`	`int cur_cpu = rt_hw_cpu_id();`
`37`		`- rt_spin_lock(&global_work[cur_cpu].lock);`
`38`		`- if(global_work[cur_cpu].event.event_id)`
	`37`	`+ rt_spin_lock(&rt_smp_work[cur_cpu].lock);`
	`38`	`+`
	`39`	`+ if (rt_smp_work[cur_cpu].event.event_id)`
`39`	`40`	`{`
`40`		`- err = smp_call_handler(&global_work[cur_cpu].event);`
`41`		`- if(err)`
	`41`	`+ err = smp_call_handler(&rt_smp_work[cur_cpu].event);`
	`42`	`+ if (err)`
`42`	`43`	`{`
`43`	`44`	`LOG_E("Have no event\n");`
`44`		`- rt_memset(&global_work[cur_cpu].event,0,sizeof(struct smp_event));`
`45`		`- rt_spin_unlock(&global_work[cur_cpu].lock);`
	`45`	`+ rt_memset(&rt_smp_work[cur_cpu].event, 0, sizeof(struct rt_smp_event));`
	`46`	`+ rt_spin_unlock(&rt_smp_work[cur_cpu].lock);`
`46`	`47`	`}`
`47`		`- rt_memset(&global_work[cur_cpu].event,0,sizeof(struct smp_event));`
	`48`	`+ rt_memset(&rt_smp_work[cur_cpu].event, 0, sizeof(struct rt_smp_event));`
`48`	`49`	`}`
`49`		`- rt_spin_unlock(&global_work[cur_cpu].lock);`
`50`		`-`
	`50`	`+ rt_spin_unlock(&rt_smp_work[cur_cpu].lock);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/**`
`@@ -61,85 +61,85 @@ void rt_smp_call_ipi_handler(int vector, void *param)`
`61`	`61`	`* else it will call function on specified CPU and return immediately`
`62`	`62`	`* @param cond the condition function pointer,if you set it then it will call function only when cond return true`
`63`	`63`	`*/`
`64`		`-void rt_smp_call_func_cond(int cpu_mask, smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond)`
	`64`	`+void rt_smp_call_func_cond(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond)`
`65`	`65`	`{`
`66`	`66`	`RT_DEBUG_NOT_IN_INTERRUPT;`
`67`		`- struct smp_event event;`
`68`		`- rt_bool_t need_call = RT_TRUE,need_wait = RT_FALSE;`
`69`		`- int cur_cpu = rt_hw_cpu_id();`
`70`		`- int cpuid = 1 << cur_cpu;`
`71`		`- int tmp_id = 0,cpu_nr = 0;`
`72`		`- int tmp_mask;`
	`67`	`+ struct rt_smp_event event;`
	`68`	`+ rt_bool_t need_call = RT_TRUE, need_wait = RT_FALSE;`
	`69`	`+ int cur_cpu = rt_hw_cpu_id();`
	`70`	`+ int cpuid = 1 << cur_cpu;`
	`71`	`+ int tmp_id = 0, cpu_nr = 0;`
	`72`	`+ int tmp_mask;`
`73`	`73`
`74`		`- if(flag == SMP_CALL_WAIT_ALL)`
	`74`	`+ if (flag == SMP_CALL_WAIT_ALL)`
`75`	`75`	`{`
`76`	`76`	`need_wait = RT_TRUE;`
`77`		`- rt_atomic_store(&wait,0);`
	`77`	`+ rt_atomic_store(&rt_smp_wait, 0);`
`78`	`78`	`}`
`79`	`79`
`80`		`- if(cpuid & cpu_mask)`
	`80`	`+ if (cpuid & cpu_mask)`
`81`	`81`	`{`
`82`	`82`	`func(data);`
`83`	`83`	`cpu_mask = cpu_mask & (~cpuid);`
`84`	`84`	`}`
`85`	`85`
`86`		`- if(!cpu_mask)`
	`86`	`+ if (!cpu_mask)`
`87`	`87`	`need_call = RT_FALSE;`
`88`	`88`
`89`	`89`	`tmp_mask = cpu_mask;`
`90`		`- if(need_call)`
	`90`	`+ if (need_call)`
`91`	`91`	`{`
`92`		`- while(tmp_mask)`
	`92`	`+ while (tmp_mask)`
`93`	`93`	`{`
`94`		`- if((tmp_mask & 1) && (tmp_id < RT_CPUS_NR))`
	`94`	`+ if ((tmp_mask & 1) && (tmp_id < RT_CPUS_NR))`
`95`	`95`	`{`
`96`		`- if(cond && !cond(tmp_id,data))`
	`96`	`+ if (cond && !cond(tmp_id, data))`
`97`	`97`	`continue;`
`98`	`98`	`cpu_nr++;`
`99`	`99`	`event.event_id = SMP_CALL_EVENT_FUNC;`
`100`		`- event.func = func;`
`101`		`- event.data = data;`
	`100`	`+ event.func = func;`
	`101`	`+ event.data = data;`
`102`	`102`	`event.cpu_mask = cpu_mask;`
`103`		`- rt_spin_lock(&global_work[tmp_id].lock);`
`104`		`- global_work[tmp_id].event = event;`
`105`		`- rt_spin_unlock(&global_work[tmp_id].lock);`
	`103`	`+ rt_spin_lock(&rt_smp_work[tmp_id].lock);`
	`104`	`+ rt_smp_work[tmp_id].event = event;`
	`105`	`+ rt_spin_unlock(&rt_smp_work[tmp_id].lock);`
`106`	`106`	`}`
`107`	`107`	`tmp_id++;`
`108`	`108`	`tmp_mask = tmp_mask >> 1;`
`109`	`109`	`}`
`110`	`110`	`rt_hw_ipi_send(RT_FUNC_IPI, cpu_mask);`
`111`	`111`	`}`
`112`	`112`
`113`		`- if(need_wait)`
	`113`	`+ if (need_wait)`
`114`	`114`	`{`
`115`		`- while(rt_atomic_load(&wait) != cpu_nr);`
	`115`	`+ while (rt_atomic_load(&rt_smp_wait) != cpu_nr);`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`
`119`		`-void rt_call_each_cpu(smp_call_func_back func, void *data,rt_uint8_t flag)`
	`119`	`+void rt_smp_call_each_cpu(smp_call_func_back func, void *data, rt_uint8_t flag)`
`120`	`120`	`{`
`121`		`- rt_smp_call_func_cond(RT_ALL_CPU,func,data,flag,RT_NULL);`
	`121`	`+ rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, RT_NULL);`
`122`	`122`	`}`
`123`	`123`
`124`		`-void rt_call_each_cpu_cond(smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func)`
	`124`	`+void rt_smp_call_each_cpu_cond(smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond_func)`
`125`	`125`	`{`
`126`		`- rt_smp_call_func_cond(RT_ALL_CPU,func,data,flag,cond_func);`
	`126`	`+ rt_smp_call_func_cond(RT_ALL_CPU, func, data, flag, cond_func);`
`127`	`127`	`}`
`128`		`-void rt_call_any_cpu(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag)`
	`128`	`+void rt_smp_call_any_cpu(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag)`
`129`	`129`	`{`
`130`		`- rt_smp_call_func_cond(cpu_mask,func,data,flag,RT_NULL);`
	`130`	`+ rt_smp_call_func_cond(cpu_mask, func, data, flag, RT_NULL);`
`131`	`131`	`}`
`132`	`132`
`133`		`-void rt_call_any_cpu_cond(int cpu_mask,smp_call_func_back func, void *data,rt_uint8_t flag,smp_cond cond_func)`
	`133`	`+void rt_smp_call_any_cpu_cond(int cpu_mask, smp_call_func_back func, void *data, rt_uint8_t flag, smp_cond cond_func)`
`134`	`134`	`{`
`135`		`- rt_smp_call_func_cond(cpu_mask,func,data,flag,cond_func);`
	`135`	`+ rt_smp_call_func_cond(cpu_mask, func, data, flag, cond_func);`
`136`	`136`	`}`
`137`	`137`
`138`		`-void smp_init(void)`
	`138`	`+void rt_smp_init(void)`
`139`	`139`	`{`
`140`		`- for(int i = 0; i < RT_CPUS_NR; i++)`
	`140`	`+ for (int i = 0; i < RT_CPUS_NR; i++)`
`141`	`141`	`{`
`142`		`- rt_memset(&global_work[i],0,sizeof(struct smp_call));`
`143`		`- rt_spin_lock_init(&global_work[i].lock);`
	`142`	`+ rt_memset(&rt_smp_work[i], 0, sizeof(struct rt_smp_call));`
	`143`	`+ rt_spin_lock_init(&rt_smp_work[i].lock);`
`144`	`144`	`}`
`145`	`145`	`}`