About the reset of kernelExecutor

[lusunday]

Hello, author. I’m feeling confused while using OpenTCS. I don’t understand how kernelExecutor works when restarting the map. It seems like kernelExecutor is being reset somehow. I created my own thread pool and want it to behave like kernelExecutor, but I’m not sure how to achieve that. I noticed there's a call to kernelExecutor.shutdown() in the code, but that doesn’t seem to be the correct place.

[lusunday]

private void configureCustomExecutor() {
   // Create a custom thread pool
   int corePoolSize = 4;      // Core number of threads
   int maximumPoolSize = 8;   // Maximum number of threads
   long keepAliveTime = 60L;  // Keep-alive time for idle threads
   TimeUnit unit = TimeUnit.SECONDS; // Time unit for keep-alive time
   BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(); // Unbounded work queue

   // Custom thread factory (for naming threads)
   ThreadFactory threadFactory = r -> {
       Thread thread = new Thread(r);
       thread.setName("custom-pool-thread-" + thread.getId()); // Set thread name
       return thread;
   };

   // Rejection policy: run task in caller thread instead of rejecting
   RejectedExecutionHandler handler = new ThreadPoolExecutor.CallerRunsPolicy();

   // Create the custom thread pool
   ExecutorService executorService = new ThreadPoolExecutor(
       corePoolSize, maximumPoolSize, keepAliveTime, unit,
       workQueue, threadFactory, handler
   );
   bind(ExecutorService.class)
       .annotatedWith(CustomExecutor.class)
       .toInstance(executorService);
   bind(Executor.class)
       .annotatedWith(CustomExecutor.class)
       .toInstance(executorService);

   // Create a scheduled thread pool for scheduled tasks
   ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
   bind(ScheduledExecutorService.class)
       .annotatedWith(CustomScheduledExecutor.class)
       .toInstance(scheduler);
}
nd(ScheduledExecutorService.class)
     .annotatedWith(CustomScheduledExecutor.class)
     .toInstance(scheduler);
 }

[swltr]

@lusunday What do you mean with "restarting the map"? Why do you think the kernel executor is being reset in some way when this restart happens?

You may want to create a KernelExtension implementation and register it with the kernel. This extension could shut down the executor when it itself is terminated. An example for a KernelExtension you could look at for reference is the class ServiceWebApi in the baseline code.

[lusunday]

While uploading a map to the kernel, I noticed that all tasks in the kernelExecutor seemed to be cleared, and even the currently executing task was terminated. For example, during a dispatch call, a thread was actively processing, but after uploading the map, all the state appeared to be reset. The kernel code seems to rely heavily on kernelExecutor for handling scheduled tasks.I want to understand the underlying mechanism so that I can implement custom thread pool behavior.

[lusunday]

‘Restarting the map’ means "uploading the model to the kernel".

[lusunday]

@swltr

  @Override
  public void initialize() {
    if (isInitialized()) {
      return;
    }

    LOG.debug("Initializing...");

    transportOrderUtil.initialize();
    orderReservationPool.clear();

    fullDispatchTask.initialize();

    LOG.debug(
        "Scheduling periodic dispatch task with interval of {} ms...",
        configuration.idleVehicleRedispatchingInterval()
    );
    periodicDispatchTaskFuture = kernelExecutor.scheduleAtFixedRate(
        periodicDispatchTaskProvider.get(),
        configuration.idleVehicleRedispatchingInterval(),
        configuration.idleVehicleRedispatchingInterval(),
        TimeUnit.MILLISECONDS
    );

    initialized = true;
  }

  @Override
  public void terminate() {
    if (!isInitialized()) {
      return;
    }

    LOG.debug("Terminating...");

    periodicDispatchTaskFuture.cancel(false);
    periodicDispatchTaskFuture = null;

    fullDispatchTask.terminate();

    initialized = false;
  }

The above code is from the DefaultDispatcher. Can I assume that each time terminate is called, it will stop this loop task? Are other similar components the same in this regard? However, how are one-time submitted tasks and tasks in the waiting queue cleaned up?

[swltr]

@lusunday Which loop task do you mean?

Indeed, the kernel does rely on the (single-threaded) kernel executor to handle tasks. Modfication of any data, e.g. in the plant model or the transport order pool, is supposed to happen on that thread only, to avoid concurrency issues.

The code you quoted does terminate the tasks related to the dispatcher, and terminate() is called when the kernel either briefly switches to modeling mode (usually when a new plant model is uploaded), or when it shuts down. If you want your own, multi-threaded ScheduledExecutorService to be terminated, you'll need to register a KernelExtension similar to ServiceWebApi, as mentioned.