Preloading kernels / enabling a pool of kernels

[astrojuanlu]

I am experimenting with a moderately complex notebook (~10 widgets, among them an ipyleaflet map) and I have seen that, from first GET request to the end of the load, it takes about 1 minute, and sometimes it gives timeouts when loading the JavaScript modules. I wonder if there would be some way to "preload" a pool of kernels to help accelerate page show times. Not sure if this is similar to https://github.com/QuantStack/voila/issues/5.

[SylvainCorlay]

A visual indication that things are loading would be a first step.

[astrojuanlu]

True. At the moment I'm planning to simulate that by embedding the voila HTML in an iframe, and putting some loading indication outside.

[maartenbreddels]

I see a few options here:

• Have a different kernel_manager that will keep some preheated kernels (for instance spinning up N kernels, and doing importing of some modules). This will already speed up execution time in many cases. I think that can live outside of voila, maybe go in jupyter_server.
• Have a pool of already executed kernels ready, this seems like a use case only useful for voila, and requires matching time of executing to the last modification date of the notebook/file to not get old results. I could see this living in voila.
• Same as previous point, but only have 1 executed kernel per notebook, but fork it each time a request is made (see #5).
• 'Async' rendering of the html and showing the notebook output. This kind of moves away from using nbconvert for offlifting the rendering of notebooks, since it requires that there are '2' parts of a template. The initial rendering and the rendering of the 'cells' or whole body.

On the last point, I also want to bring up a use cases that we (me @SylvainCorlay and @pbugnion) discussed yesterday. If you want to render voila in a Jupyter Lab panel (is that the right word?) you only want to render the 'body' part of the HTML.

Also, another use case I have in mind is to have a template served directly, no cell output will be rendered, but the template itself takes care of rendering the widgets at specific locations.

Some food for thought.

[parente]

The jupyter/kernel_gateway has a preheated kernel pool for its notebook-as-an-API mode (https://jupyter-kernel-gateway.readthedocs.io/en/latest/http-mode.html). Maybe something can be ported to jupyter_server from there?

• https://github.com/jupyter/kernel_gateway/blob/master/kernel_gateway/services/kernels/pool.py
• https://github.com/jupyter/kernel_gateway/blob/master/kernel_gateway/notebook_http/handlers.py#L34

[maartenbreddels]

Thanks, that is good to know!

[marscher]

Since almost three years passed since the last update of this issue I kindly ask if there is any progress on this. I'd be interested in forking a "preloaded" ipykernel. This kernel would just heat up the imports, which take some time in my case.

[maartenbreddels]

If you follow the last reference (https://github.com/voila-dashboards/voila/pull/820) you see it links to https://github.com/voila-dashboards/hotpot_km (https://github.com/voila-dashboards/hotpot_km/pull/8 might help settings things up)

[marscher]

Thanks for the quick reply. I should have red this more intensively :) Will check it out!