In the following section, the Limitations of Lima1 and the Goals for Lima2 are discussed.

Analysis and goals

Distributed DAQ and processing


High performance detectors generate more data than a single backend computer can handle in terms of both data acquisition and processing. Lima1 being a monolithic (single process) solution, it does not scale well.


Support High performance detectors with a horizontally scalable solution. A distributed system, e.g. a cluster of acquisition and processing computer is considered.

Most of the high performance detectors are built by aggregating multiple modules. That means that two frame dispatching strategies are worth considering:

  • Full frame: each acquisition/processing node receives a full detector frame (including all modules)

  • Partial frame: each acquisition/processing node receives data from a single module

The distributed system should be flexible enough to allow a variety of acquisition and processing nodes topology such as:

  • Single acquisition computer, Multiple processing computers

  • Multiple acquisition with processing computers

  • Multiple acquisition computers and Multiple processing computers

The trivial case of a single computer for acquisition and processing should also be supported.

Decoupled DAQ and processing


With Lima1, Acquisition and Processing are coupled to the point that user applications need to wait that the processing of the frames of the current acquisition is finished before restarting a new acquisition.


Let start a new acquisition when the camera is ready without waiting for all the images to go through the full processing pipeline. Eventually a batch of acquisitions could be started and their associated processing differed to a later time, e.g. once all the data are in memory.

Coordinate transformation tracking


With Lima1, coordinate transformation induced by the processing tasks is not formalized and it can be tricky to get back to the detector coordinate system when visualizing an image that has flipped, rotated and cropped, to set a ROI for instance.


Each processing task provides a matrix representing their affine transformation and those transformations can be combined to compute the coordinates of pixels and ROI in the detector coordinate system.

Memory management


In Lima1, there is no global memory management, in particular for data generated in the processing pipeline (compressed images before saving). There is only one buffer allocation engine, the hardware buffers; this is inefficient because a lot of memory must be systematically allocated in order to guarantee the latencies in the processing tasks. The “In-Place” task functionality is not efficient when the resulting image is smaller than the original one. Hardware buffers might be “expensive” and/or “limited”, so they should only serve for the first processing stage. Finally, the “asynchronous” data retrieval is not systematically used, so the buffers implementing this functionality should be optional (see “Observation / Test points” below).


Buffer sizes at different stages should be dynamically adjusted. Usage of allocators should be formalized and generalized.

It would be desirable to formalize the management of different kind of memories, like GPU and FPGA. Page locking and NUMA (CPU affinity), and TLS might be also useful in high-performance applications.

Multiband image support


With Lima1, only grayscale images are fully supported. Color images can be acquired with the so called Video mode.


Color (video) cameras and cameras with multiple energy discriminating thresholds (e.g. Dectris EIGER2) should be supported.

Resource monitoring


With Lima1, there is no “global” resource (memory or CPU) monitoring.


Keep track of the buffer allocations and report to the application (control system). For example, this could help prevent buffer overrun if the scan can be paused.

Multiple parameter sets


With Lima1, if parameters are modified while an acquisition is running, the configuration is inconsistent with the current acquisition:

ct.setBinning(2, 2)
ct.prepareAcq(2, 2)
ct.startAcq(2, 2)

setBinning(1, 1)
assert (ct.getBinning() == (2, 2)) // Oops


Provide a data structure for configuration that will have multiple instance for user (before preparation), effective hardware (after preparation), effective software (after pipeline creation).

Integration of third-party processing


With Lima1, adding a new processing task (external operation) is not documented.

extOpt = ctControl.externalOperation()
self.__maskTask = extOpt.addOp(Core.MASK,


Provide a C++ and Python API to extend the Pipeline with custom Processes. Libraries like PyFAI (that are implemented on GPU) should be supported. Process that have a distributed (MPI) implementation should be supported as well.

Sparse data


With Lima1, only dense storage is supported for images.


Support sparse storage for grayscale images.

Incomplete data sets


With Lima1, the lack of a frame in a sequence is not supported.


Cope with incomplete, sparse data sequences. The origin of the absence of a frame can be:

  • Fault or overrun condition (detector, processing)

    • Multiple fault tolerance policies should be offered

  • Veto mechanisms in data reduction

    • Discard useless data

The cause of the absence of data should be included in the metadata.

Multiple saving / streaming tasks


With LIma1, saving supports only images (2d data) and is performed at a fixed stage in the processing pipeline. Lima does not support foreign data structure (1d data or tables) generate by tasks.


Multiple saving / streaming tasks can be inserted at different stages in the image processing pipeline. They can save raw or partially processed images, as well as byproducts of non 2D type like statistics or reduced 1D/0D data. The saving tasks may write on the same I/O (file) or on different ones.

The saving infrastructure should also include metadata, which can be:

  • At different moments:

    • Static (detector type, instrument name)

    • Per acquisition (Lima configuration, start timestamp)

    • Per frame (detector timestamp)

    • Asynchronous (monitoring, temperature, processing statistics)

  • From different sources:

    • Hardware generated (frame timestamps, temperature, dead-time)

    • Software generated (configuration, processing statistics)

Multiple observation / testing tasks

A new kind of (sink) task can serve for monitoring and retrieving data asynchronously at defined stages in the processing pipeline. Each observation point acts as a cache of that stage, with configurable history and sampling parameters.

Implementation improvements

Explicit state machine

No more if (status == READY) && (previousStatus == RUNNING) soup!

Acquisition and detector have statuses which is an obvious sign of a state machine, if not multiple concurrent state machines.

Using an explicit state machines means that the software is driven by a state transition table and actions are executed when entering and leaving a state.

Prefer events to callbacks

Callbacks are executed in the context of the thread that call them, potentially the acquisition thread. A better approach is to provide a synchronization primitive that the applications use to handle events in its own threads.

Externalize the acquisition thread

The acquisition thread is currently part of the plugin implementation. In other words, it is the responsibility of the plugin to feed the ring buffer. It would be more flexible to have a common acquisition thread(s) and leave the specifics of “getting an image” to the plugin.

Hide vendor SDKs from users

Use the Pointer to implemenation idiom. Checkout the documentation for a thorough explanation on this pattern.

Simplify usage

Camera cam(parameters);
HwInterface hw(cam);
Control ct(hw);

is now


Note you still have access to camera specific functionalities.

Simplify python binding

With introspection, most of the binding can be generated programmatically.

Boilerplate in the plugins code

Reduce repetitive code, using generative programming techniques.

Use established third-party libraries

Benefit from libraries developed, used and maintained by large communities. Examples are:

  • Boost

  • Adobe Stlab.Concurrency

  • MPI