CPU used in an RP2 with _thread and timer

[cve2022]

Target platform is the Raspberry Pi Pico.

Is there a way to know what CPU is used from inside a method?

I want to have one thread running a realtime routine and the other running nonrealtime stuff (mostly user interface related).

The realtime part of the code should look like this (a bit more involved though :

from machine import Pin,Timer

led=Pin(25, Pin.OUT)
timer=Timer()

def realtime_task(timer):
    led.on()
    do_real_time_critical_stuff()
    do_not_as_critical_stuff_prepare_next_run()
    led.off()

timer.init(freq=200, mode=Timer.PERIODIC, callback=realtime_task)

I understood the Timer class in RP2 is software based, will an instance of it run in the same CPU as the thread?

I instantiate two timers, one per thread, will they run in their respective CPU and not be hindered by each other?

[rkompass]

On the RPi Pico you have up to 2 threads that run on the two cores in parallel. As soon as you start another thread with
_thread.start_new_thread(thread_func, (arg0)) this will employ the second core. Attempting to start yet another thread will raise an Error of too many threads. This is because your MP interpreter is the first thread, so to say, and there are only the two threads each on it's core.

Is there a way to know what CPU is used from inside a method?

Not with _thread . There is a rudimentary port of threading in micropython-lib which at the cost of overhead implements a Thread class with many more functions, perhaps also a core function. If not, you may extend it, as you see there how other functionality is implemented.
The timers are interrupt-based. I'm not an expert but I think that all timer callbacks run on the first core and currently it is not possible to pin ISRs to another core (I remember a recent discussion on that problem but don't find it).

[cve2022]

Hello @rkompass , thank you for your comment.

On the RPi Pico you have up to 2 threads that run on the two cores in parallel. As soon as you start another thread with _thread.start_new_thread(thread_func, (arg0)) this will employ the second core. Attempting to start yet another thread will raise an Error of too many threads. This is because your MP interpreter is the first thread, so to say, and there are only the two threads each on it's core.

OK, this makes sense and it is really helpful. So in my project architecture the non-realtime critical UI and other stuff would be in the second thread.

Is there a way to know what CPU is used from inside a method?

Not with _thread . There is a rudimentary port of threading in micropython-lib which at the cost of overhead implements a Thread class with many more functions, perhaps also a core function. If not, you may extend it, as you see there how other functionality is implemented.

I see _thread has a get_ident() method so it may do the trick, though it may not be actually necessary, considering what you wrote about ISRs and timers (below).

The timers are interrupt-based. I'm not an expert but I think that all timer callbacks run on the first core and currently it is not possible to pin ISRs to another core (I remember a recent discussion on that problem but don't find it).

I'd love looking at that discussion, if you or anyone could find the reference (I will look for it anyway).

This "limitation" may be OK for this project though, if I allocate the threads the aforementioned way.

I will have to experiment with _threading and timers a little (including some simulated heavy processing load) to see how they perform. Anyway the fact I may use the two cores is potentially better than just using the default case where the second core is just wasted.

FWIW I want to keep the jitter of the more realtime critical stuff as low as possible.

Any further comments are welcome.

[cve2022]

Hello @rkompass.

Is this the discussion you wrote about? #9121

[rkompass]

Yes and the links there.

[rkompass]

Is there a way to know what CPU is used from inside a method?

On RPi Pico you have a CPUID register (section 2.1.3.7 of the datasheet) at address: 0xd0000000 which you can read and get the core. Example (lock example with added cpuid query):

# test if thread lock also stops the main thread
# threads report cpuid

from machine import mem32
import _thread
from time import sleep, sleep_ms

def thread_entry():
    lock.acquire()
    cpuid = mem32[0xd0000000]
    print(f'new thread: my CPU id is {cpuid}')
    sleep(5)
    lock.release()

print("main thread: start")
lock = _thread.allocate_lock()
print("main thread: locked?", lock.locked())
cpuid = mem32[0xd0000000]
print(f'main thread: my CPU id is {cpuid}')
print("main thread: start other thread now")
_thread.start_new_thread(thread_entry, ())
sleep_ms(1)                     # without this sleep, all printouts start (in right order) after the 5 seconds wait of the second thread
print("main thread: try to aquire lock")
lock.acquire()

print("main thread: got it")
lock.release()

[cve2022]

@rkompass , thank you very much for walking the extra mile.

Have a great 2023.