Compute classes for sovereign execution

Sovereign executors use the same compute classes as managed environments: Light, Standard, and Performance. Each class has the same multiplier, and credits are calculated the same way. For multipliers and billing rules, see Execution compute classes.

This page covers what's different on sovereign executors.

Differences from managed environments

The following table compares compute classes in managed and sovereign environments:

	Managed	Sovereign
Where you set the class	Per workflow	Per environment, for every executor connected to it
Unit of parallelism	Set by Knime	Roughly one core, vCore, or hyperthread, depending on your hardware
Memory limit	All memory of running nodes, including Python and R	Java heap of the executor only
Executors	Provided by Knime	Run by you, as many as you need
Price	Execution credits	Execution credits, plus a yearly fee per environment

Resources per class

The compute class sets the Java heap and the number of threads for each executor in the environment. The number of threads limits how many nodes run at the same time.

	Light	Standard	Performance
Java heap	2 GB	5 GB	16 GB
Threads	1	3	6

Sovereign executors currently don't support workflows that need more than 16 GB of Java heap.

Choose a class

You set the compute class in the environment settings. For the steps, see Create an environment. The class applies to every executor connected to the environment. When you change the class, the environment's executors restart automatically, because the Java heap is set when an executor starts.

Running jobs are lost

Changing the compute class restarts the environment's executors, and jobs running on them are lost. Change the class when no jobs are running in the environment.

To run workflows in different classes, create one environment per class. Each environment has its own yearly fee. The fee doesn't depend on how many executors are connected to the environment.

Knime doesn't manage the hardware of sovereign executors. Make sure each machine has enough memory and CPU for the compute class of the executors you run on it.

The following table suggests a class for common workloads:

Workload	Class	Notes
Database-heavy, light data transformations	Light	Run several executors per machine for more throughput
Memory-heavy or CPU-heavy	Standard or Performance	Up to 16 GB Java heap per executor
Mixed	One environment per class	Each environment has its own yearly fee

How executors apply the class

You don't configure the compute class on the executor. When an executor connects to Knime, it fetches the class from its environment. It then starts with the Java heap, thread count, and processor count of that class, and Knime checks that the executor uses them.

This works the same on Linux and Windows, and doesn't need operating-system limits.

Run several jobs on one executor

An executor can run several jobs at the same time. The jobs share the executor's Java heap and threads. Each job gets at most the resources of the class, and less when the executor is busy.

The following rules apply when jobs share an executor:

• Nodes wait for a free thread. A node without a free thread waits, and isn't billed until it starts.
• Waiting nodes free their thread. Database, REST, and Wait... nodes free their thread while they wait on an external system, so more jobs fit on one executor. These nodes are still billed for the time they wait, as in managed environments.
• Billing rules stay the same. Every node is billed for its own execution time. Other jobs on the executor can slow a node down, which increases its execution time.

To increase throughput, add executors. You can run several executors on one machine.