def open(self):
self.pipe_dir = pathlib.Path(tempfile.mkdtemp())
self.pipe = self.pipe_dir / "fifo"
self.write_pipe = self.pipe_dir / "fifo.in"
self.read_pipe = self.pipe_dir / "fifo.out"
os.mkfifo(self.write_pipe)
os.mkfifo(self.read_pipe)
env = None
if self.options.get("gdbserver_port"):
env = os.environ.copy()
env["TVM_QEMU_GDBSERVER_PORT"] = self.options["gdbserver_port"]
self.proc = subprocess.Popen(
["make", "run", f"QEMU_PIPE={self.pipe}"],
cwd=BUILD_DIR,
env=env,
stdout=subprocess.PIPE,
)
self._wait_for_qemu()
# NOTE: although each pipe is unidirectional, open both as RDWR to work around a select
# limitation on linux. Without this, non-blocking I/O can't use timeouts because named
# FIFO are always considered ready to read when no one has opened them for writing.
self.read_fd = os.open(self.read_pipe, os.O_RDWR | os.O_NONBLOCK)
self.write_fd = os.open(self.write_pipe, os.O_RDWR | os.O_NONBLOCK)
_set_nonblock(self.read_fd)
_set_nonblock(self.write_fd)
return server.TransportTimeouts(
session_start_retry_timeout_sec=2.0,
session_start_timeout_sec=10.0,
session_established_timeout_sec=10.0,
)
def open(self):
port_path = self._find_serial_port(self._options)
self._port = serial.Serial(port_path, baudrate=self._lookup_baud_rate(self._options))
return server.TransportTimeouts(
session_start_retry_timeout_sec=2.0,
session_start_timeout_sec=5.0,
session_established_timeout_sec=5.0,
)
def open_transport(self, options):
self._proc = subprocess.Popen([self.BUILD_TARGET],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
bufsize=0)
self._set_nonblock(self._proc.stdin.fileno())
self._set_nonblock(self._proc.stdout.fileno())
return server.TransportTimeouts(
session_start_retry_timeout_sec=0,
session_start_timeout_sec=0,
session_established_timeout_sec=0,
)
def open_transport(self, options):
# Zephyr example doesn't throw an error in this case
if self._serial is not None:
return
port = self._get_arduino_port(options)
# It takes a moment for the Arduino code to finish initializing
# and start communicating over serial
for attempts in range(10):
if any(serial.tools.list_ports.grep(port)):
break
time.sleep(0.5)
self._serial = serial.Serial(port, baudrate=115200, timeout=5)
return server.TransportTimeouts(
session_start_retry_timeout_sec=2.0,
session_start_timeout_sec=5.0,
session_established_timeout_sec=5.0,
)
def open(self):
args = ["ninja"]
if self.options.get("verbose"):
args.append("-v")
args.append("run")
env = dict(os.environ)
env["ARMFVP_BIN_PATH"] = str(API_SERVER_DIR / "fvp-hack")
self.proc = subprocess.Popen(
args,
cwd=BUILD_DIR,
env=env,
stdout=subprocess.PIPE,
)
threading.Thread(target=self._fvp_check_stdout, daemon=True).start()
self.iris_port = self._wait_for_fvp()
_LOG.info("IRIS started on port %d", self.iris_port)
NetworkModelInitializer = self._iris_lib.NetworkModelInitializer.NetworkModelInitializer
self._model_init = NetworkModelInitializer(host="localhost",
port=self.iris_port,
timeout_in_ms=1000)
self._model = self._model_init.start()
self._target = self._model.get_target(
"component.FVP_MPS3_Corstone_SSE_300.cpu0")
self._target.handle_semihost_io()
self._target._stdout = BlockingStream()
self._target._stdin = BlockingStream()
self._model.run(blocking=False, timeout=100)
self._wait_for_semihost_init()
_LOG.info("IRIS semihosting initialized.")
return server.TransportTimeouts(
session_start_retry_timeout_sec=2.0,
session_start_timeout_sec=10.0,
session_established_timeout_sec=10.0,
)
