How to implement blocking without interactive_ioc()

[aswyatt]

Apologies for my NOOB question - I'm not familiar with cothreads or asyncio. Basically I want to run my IOC in the background (via ssh with nohup), which cannot be done with a python shell running. I understand the logic is to use run_forever() or WaitForQuit(), but not sure of how to do it exactly. I would like to create a PV (call it "QUIT" because why not) that can be used to quit the program - how do I implement this. I initially created my ioc on Windows, so was using asyncio, but am porting to Linux - I'd be grateful for examples of both asyncio and cothread implementations. Obviously I can also kill the process to quite the IOC. Thnx

[AlexanderWells-diamond]

We have some simple example programs of both cothread and asyncio, available in the docs/examples directory. Those should show the basic syntax differences between the two. I'm not sure how softioc.interactive_ioc() interacts with nohup, so you may need to do as you say and use alternative functions.

To quit the IOC, the answer changes based on whether you use asyncio or cothread. In both cases you'll want to create your "QUIT" PV, and set an on_update function (and perhaps always_update=True). For cothread I think its as simple as calling the Quit() function. For asyncio I think you'll need to set up an Event and wait for it to be set from the main thread, and signal it from the update function. There's probably other threading constructs that could also be used here.

[aswyatt]

I already have a working IOC, but using softioc.interactive_ioc(), but I want to implement without this. I understand the concept of how to do it, but I don't know the exact syntax / function etc. An explicit example would go a long way to help (e.g. how do I modify the example codes given).

[AlexanderWells-diamond]

This code shows how to do it with cothread :

# Import the basic framework components.
from softioc import softioc, builder
import cothread

# Set the record prefix
builder.SetDeviceName("MY-DEVICE-PREFIX")

def quit_update_func(value):
    cothread.Quit()

# Create some records
ao = builder.aOut('QUIT', always_update=True,
                  on_update=quit_update_func)

# Boilerplate get the IOC started
builder.LoadDatabase()
softioc.iocInit()


cothread.WaitForQuit()

The main thread will call WaitForQuit(), which does what it says on the tin and will stick around forever. When the QUIT PV receives an updated value (any value), it'll call the Quit() method. This signals the main thread to terminate, which brings down all the child threads too.

The asyncio version would be to replace the WaitForQuit() and Quit() calls with a threading.Event object, and have the main thread call .wait() and the update method call .set(). (And of course the other syntax changes required for asyncio, as seen in the example file)

[aswyatt]

Thanks for the example and very quick reply - much appreciated. Because I was developing on Windows (due to the hardware I was using), I had to use asyncio and haven't used cothread, and so wasn't sure how to use cothread (which turns out to be really simple). I probably need both Windows and Linux compatability and don't want to mantain two codebases, hence eering towards asyncio.

I'm still not understanding the asyncio methodology - I really have no experience using these cothread modules and am getting lost in the documentation, and how softioc integrates with it. I was able to adapt the example for my needs, apart from this specific issue. The asyncio example contains two additional lines - generating the dispatcher (I don't really know what that is) and the run_coroutine_threadsafe() instead of Spawn() command (plus the extra "decorations"). I'm not sure where the threading.Event object is / how to access it within the example code and how to use the .wait() / .set() commands. If you could provide a similar example is you did with cothread, that would be perfect.

[AlexanderWells-diamond]

Here's the same thing with asyncio:

# Import the basic framework components.
from softioc import softioc, builder, asyncio_dispatcher
import threading

# Create an asyncio dispatcher, the event loop is now running
dispatcher = asyncio_dispatcher.AsyncioDispatcher()

quit_event = threading.Event()

# Set the record prefix
builder.SetDeviceName("MY-DEVICE-PREFIX")

def quit_update_func(value):
    quit_event.set()


# Create some records
ao = builder.aOut('QUIT', always_update=True,
                  on_update=quit_update_func)

# Boilerplate get the IOC started
builder.LoadDatabase()
softioc.iocInit(dispatcher)


quit_event.wait()

The Dispatcher that is created is what handles the asyncio event loop in the background. Its the thing that manages updating the PVs whenever anything happens. The main thread doesn't do any of that work.
The Event object is from the Python standard threading module.