using second core to run blocking code

[GM-Script-Writer-62850]

So if i have uasyncio running on one core, how can i use _thread to run say urequest or read a sensor and await it's completion and get the return value

IIRC there would be a issue running urequest on core 1 of a PICO W assuming wifi was setup on core 0, but not every NIC has that limitation

i know there will be some complications where i may need to have another process wait for core 1 to be freed up

[peterhinch]

See this doc. The idea is to use the 2nd core so that the main uasyncio program can have a task which pauses on a blocking function without blocking the rest of the application. The blocking function runs on the second core.

[peterhinch]

The link I supplied uses the Message object to achieve synchronisation and to return the function's result. Message uses the official ThreadSafeFlag. I suggest you try the example script to get a grasp of how it works.

The doc explains why globals are unsafe.

[GM-Script-Writer-62850]

I'm probably wording it wrong

import uasyncio
ThreadSafeFlag=uasyncio.ThreadSafeFlag
#from primitives import ESwitch, WaitAny, Delay_ms
from threadsafe import Message
from time import sleep
import _thread


async def unblock(func, *args, **kwargs):
	def wrap(func, message, args, kwargs):
		message.set(func(*args, **kwargs))  # Run the blocking function.
	msg = Message()
	_thread.start_new_thread(wrap, (func, msg, args, kwargs))
	return await msg

async def taskA():
	await unblock(sleep,2)

async def task1():
	await unblock(sleep,2)

async def main():
	uasyncio.create_task(taskA())
	uasyncio.create_task(task1()) # this will error as my only other core is busy, this needs to wait for it finish
	await uasyncio.sleep(5)

uasyncio.run(main())

i was asking if there is a built in way to check if _thread is busy so the task waits for it to be available (for my use i do not see this getting longer than 1 task waiting)

• Note that i only have 2 cores as i am using a pico (a 3ed core would be so nice to have...)

[rkompass]

i was asking if there is a built in way to check if _thread is busy so the task waits for it to be available

Not in _thread. This would be part of threading which uses _thread for its function.
Iirc threading wraps the task to be executed roughly like this:

thr_state = 1
try:
    task_to_be_executed()
    thr_state = 0
except:
    thr_state = -1

.. of course much more elaborate, with an extra class, using locks etc.
This way you may query thr_state to see in what condition the thread is and possibly decide to cancel/restart it.

[GM-Script-Writer-62850]

Is it possible to have core 1 use _thread to run a process on core 0? lets say i have uasyncio running on core 1 for some good reason and core 0 does not really have any work (well just running the network chip) how would i give work for core 0 to do?

[rkompass]

I strongly suppose not, i.e. this is not possible. There is no RTOS in the background (speaking of RP2040) and as MP starts running on this core (0) it certainly will never give up usage of it. The control of the threads itself surely runs on core 0, not only the network. I suppose, on core 1 if a thread starts there, just the parser/compiler/bytecode interpreter - complex is made to run in parallel on this core. This is from my logical thinking alone, though. If some insider expert tells us that that is not true I would be eager to learn.

[peterhinch]

As @rkompass says, you can't do that. If you have multiple blocking functions there are two options: use a target that supports multiple threads or have a task which waits for them in sequence - i.e. run them sequentially rather than concurrently:

async def taskA():
	await unblock(sleep,2)
	await unblock(sleep,2)

[GM-Script-Writer-62850]

i think i figured out how to do what i wanted, though this version is only good for a dual core cpu

unblock_thread_lock=uasyncio.Lock()
async def unblock(func, *args, **kwargs):#https://github.com/peterhinch/micropython-async/blob/master/v3/docs/THREADING.md#4-taming-blocking-functions
	def wrap(func, message, args, kwargs):
		message.set(func(*args, **kwargs))  # Run the blocking function.
	msg = Message()
	await unblock_thread_lock.aquire()
	_thread.start_new_thread(wrap, (func, msg, args, kwargs))
	msg=await msg
	unblock_thread_lock.release()
	return msg

unblock can be used by as many different task as needed

[peterhinch]

You can do the same thing in the application code, while preserving the generality of unblock. Create a Lock and use it to guard each call to unblock. Either approach will work.