Running independent kernels with DRTIO?

kjh-m

We have two Sinara systems, which have been running standalone on separate scientific experiments. However, now I’m contemplating on using both for the same experiment.

I would need to have one system running a particular kernel more or less constantly, save for some RPC-interrupts. Other system would be used more interactively, with experiments being submitted by a user.

So, my question is: is it possible to use Artiq DRTIO functionality for this purpose? Can both RTIO cores have kernels running independent of each other, e.g. in separate pipelines in one Artiq master? I suppose I could run both systems stand-alone, but using DRTIO would give me synchronization between be RTIO cores.

BR
Kalle

sb10q

This is not implemented (i.e. you will have to run two separate standalone systems) but technically doable. If you would like to sponsor this development, please email us (sales@m-l**s.hk).

kjh-m

Ok, thank you for the clarification! I'll run the systems stand-alone in this case.

Is it possible to run masters for multiple stand-alone systems on a same computer (by e.g. simply changing the TCP ports each master uses)?

sb10q

kjh-m Is it possible to run masters for multiple stand-alone systems on a same computer (by e.g. simply changing the TCP ports each master uses)?

Yes. But you don't need to do that; a single master can have several core devices.

kjh-m

Ok, great!

So do I just define both core devices in the same device_db.py -file? Can you provide a bare-bones example of such configuration?

sb10q

kjh-m So do I just define both core devices in the same device_db.py -file?

Yes, with different names, and then you select one or the other by name in the experiment either:

with self.setattr_device("my_core") followed by @kernel("my_core") decorators. Using this technique, the same experiment can use several core devices.
with self.core = self.get_device("my_core")

kjh-m

Ok, thank you. I'm getting an error, indicating, that Artiq is trying run @kernel("core_2") -decoraded kernels on the first core..

Simple test:

from artiq.experiment import *

class coretest(EnvExperiment):
    def build(self):
        self.setattr_device("core")
        self.setattr_device("core_2")


    def run(self):
        print('Reset core')
        self.run_core()

        print('Reset core_2')
        self.run_core_2()

    @kernel("core")
    def run_core(self):
        self.core.reset()

    @kernel("core_2")
    def run_core_2(self):
        self.core_2.reset()

Running gives:

Reset core
Reset core_2
<artiq>/coredevice/core.py:190:1: fatal: this function runs on a different core device 'core'
def reset(self):
^
core2_test.py:21:1: note: called from this function
def run_core_2(self):
^
core2_test.py:22:9-22:26: note: while inferring a type for an attribute 'reset' of a host object
self.core_2.reset()

Second core is defined in device_db after the definitions for the first core as:

device_db.update({
    "core_2": {
        "type": "local",
        "module": "artiq.coredevice.core",
        "class": "Core",
        "arguments": {"host": core_addr_2, "ref_period": 1e-09}
    },
})

How about the device definitions for the second core? Do I just add them after the core_2 -definitions like this:

device_db["led0_2"] = {
    "type": "local",
    "module": "artiq.coredevice.ttl",
    "class": "TTLOut",
    "arguments": {"channel": 0x00001a}
}

First core already has "led0", so the name needs to be different? How do I define the core the device is connected to?

sb10q

Ah, that's because the core.reset() method is a @kernel("core"). I suppose we should add support for kernel decorators that would run on whatever the caller's core device is. Would you be able to send a PR? That shouldn't be very complicated code.