Slow/long background tasks despite visible correctness

I am trying out some interactive code with datashader and noticed that zooming but in particular resetting the plot will trigger some long background task that seem to be independent of the visible appearance.
When switching from a zoomed in view to the default view via figure reset it takes some time until the visible appearance is as expected. However afterwards there is still a Python process running in the background which utilized a CPU core at nearly 100% for around 30 seconds.
This is rather surprising to be and makes me question what is going on here? Are there any additional computations triggered to go beyond the regular datashading? The same can also be observed when switching between different zoom stages though less pronounced.

import pandas as pd
import numpy as np
import datashader as ds
import holoviews as hv
from bokeh.layouts import row, column
from bokeh.models import Button, ColumnDataSource, CDSView, DataTable, IndexFilter, TableColumn, FileInput, Select, \
    PreText, Div
from bokeh.plotting import curdoc, figure
from bokeh.layouts import layout
from holoviews.operation.datashader import datashade, shade, dynspread, spread, rasterize
from holoviews.streams import Pipe, Stream
from dask import dataframe as dd
import multiprocessing as mp
from functools import reduce

renderer = hv.renderer('bokeh').instance(mode='server')
# renderer.webgl = True

doc = curdoc()

def get_data(data, time_col_name, data_col_name):
    return hv.Curve(data, time_col_name, data_col_name).opts(width=1000, height=150)

def get_dmap(pipe, time_col_stream, data_col_stream):
    return hv.DynamicMap(get_data, streams=[pipe, time_col_stream, data_col_stream])

def get_shaded_dmap(dmap):
    return datashade(dmap, cnorm='eq_hist', aggregator=ds.count(), precompute=True, min_alpha=100).opts(width=1000, height=150)

_data_col_streams = None

def generate_df(n_data_cols, n_rows):
    df = pd.DataFrame(np.linspace(0, 10000, n_rows), columns=["t"])
    columns = [f"col{i}" for i in range(n_data_cols)]
    data = np.random.rand(n_rows, n_data_cols)

    # Generate a fake signal
    signal = np.random.normal(0, 0.3, size=n_rows).cumsum()

    # Generate many noisy samples from the signal
    noise = lambda var, bias, n: np.random.normal(bias, var, n)
    for i in range(n_data_cols):
        data[:, i] = i * 10 + signal + noise(1, 10 * (np.random.random() - 0.5), n_rows)
    df[columns] = data

    return dd.from_pandas(df, npartitions=3)

def generate_data_figures():
    df = generate_df(5, 10000)
    time_col = "t"
    data_cols = df.columns.values.tolist()

    pipe = Pipe(data=[])

    TimeCol = Stream.define('TimeCol', time_col_name="")
    DataCol = Stream.define('DataCol', data_col_name="")

    time_col_stream = TimeCol(time_col_name=time_col)
    data_col_streams = [DataCol(data_col_name=data_col) for data_col in data_cols]
    global _data_col_streams
    _data_col_streams = data_col_streams

    ts_shade = [get_shaded_dmap(get_dmap(pipe, time_col_stream, data_col_stream)) for data_col_stream in data_col_streams]

    def link(a, b):
        return a + b

    if len(data_cols) > 1:
        return renderer.get_plot((reduce(link, ts_shade)).cols(1)).state
        return renderer.get_plot(*ts_shade).state

data_placeholder = column()
data_plots = generate_data_figures()

layout = layout(data_placeholder)