Can't run subkernels

shareefj

Hi there,

First time trying some of the new ARTIQ-8 features and am looking for help debugging. I'm trying to replicate the simple examples shown in the documentation but can't even do that.

I have a master/satellite setup with an SMA DIO on the satellite that I'm trying to toggle a TTL output on. The following simple experiment works:

class Test(EnvExperiment):
    def build(self):
        self.core = self.get_device("core")
        self.ttl = self.get_device("ttl0")

    @kernel
    def run(self):
        self.core.reset()
        for _ in range(10):
            self.ttl.pulse(100 * ms)
            delay(100 * ms)

whereas the same setup within a subkernel fails:

class Test(EnvExperiment):
    def build(self):
        self.core = self.get_device("core")
        self.ttl = self.get_device("ttl0")

    @kernel
    def run(self):
        self.core.reset()
        delay(10*ms)
        self.pulse_ttl()


    @subkernel(destination=1)
    def pulse_ttl(self) -> TNone:
        for _ in range(100):
            self.ttl.pulse(100 * ms)
            delay(100 * ms)

The satellite UART output seems to suggest something is running but I don't get any TTL output:

[   672.718310s]  INFO(ksupport::kernel::core1): kernel starting
[   672.724102s]  INFO(ksupport::kernel::core1): kernel finished
[   672.729676s]  INFO(satman::subkernel): subkernel 2 finished, with exception: false

Also, the satellite seems to not respond to any other RTIO events after running the subkernels. I know the documentation states this to be the case for a running subkernel, but shouldn't I be able to run standard non-subkernel experiments once it has finished? I seem to need to reset the board each time.

spaqin

I believe that the problem is that the subkernel scheduled the RTIO events, and then it finished. And on subkernel finish, control should be (in theory, but looking at your second problem seems not?) returned to the DRTIO master. With the initial delay too, that could just miss the first pulse. Try adding a loop, so the kernel won't finish so early.

Will look into the second issue.

shareefj

Hi, can you provide an example of what you're suggesting? I can't work out what you mean. Are you suggesting that the subkernel returns control to the DRTIO master before the first pulse has been issued?

spaqin

Are you suggesting that the subkernel returns control to the DRTIO master before the first pulse has been issued?

Yes, that would seem to be the case. RTIO events are scheduled by the kernel, but control is returned before the first pulse. The timing in the logs also does suggest that.

~~A simple loop with while i < 50000 (or other large number) and i += 1 in the body, while not elegant, would let you see if you get any TTL pulses during the subkernel execution.~~

You can just use self.core.wait_until_mu(now_mu()) to wait for the completion of the RTIO events.

spaqin

Sorry for coming back so late.

Generally speaking, you may need to run self.core.reset() in the beginning of the subkernel on first run. Due to non-deterministic time it may take to start a subkernel, it would be challenging to synchronize signals between the main kernel and subkernels, and normal DRTIO would still be a better choice. Although now that you mention it, I believe it should be still possible; I'll verify the behavior further.

You should also call subkernel_await(self.pulse_ttl) to catch any potential exceptions (as mentioned in the manual).

I tried it with two Kaslis, SoC (M) and 1.1 (S), adjusted the code a bit, using LEDs for a visual indicator, for a quick test, but it should behave just like TTL. The LED pulse call from main kernel after the subkernel returns also works.

from artiq.experiment import *

class Test(EnvExperiment):
    def build(self):
        self.core = self.get_device("core")
        self.led = self.get_device("led2")
        self.led4 = self.get_device("led4")

    @kernel
    def run(self):
        self.core.reset()
        delay(20*ms)
        self.pulse_ttl()
        subkernel_await(self.pulse_ttl)
        # advance RTIO timer by how long subkernel takes to run + overhead
        delay(20.5*s)
        self.led4.pulse(1000*ms)

    @subkernel(destination=1)
    def pulse_ttl(self) -> TNone:
        self.core.reset()
        for _ in range(100):
            self.led.pulse(100 * ms)
            delay(100 * ms)
        # wait until all scheduled events are finished before exiting subkernel
        self.core.wait_until_mu(now_mu())

shareefj

Thanks. I'll give that a go and get back to you. I was planning on picking this up again this week or next.

spaqin

I would also now recommend updating to newer version of ARTIQ. RTIO timestamp is now passed to the subkernel and self.core.reset() shouldn't be necessary. A delay (below 100ms) may be needed to account for the time it takes to start up the subkernel.