The Cost of Dynamism in Static Languages for Image Processing

Authors

Baptiste Esteban, Edwin Carlinet, Guillaume Tochon, Didier Verna

Where

Proceedings of the 21st International Conference on Generative Programming: Concepts & Experiences (GPCE 2022)

Place

Auckland, New Zealand

Type

inproceedings

Projects

Olena

Keywords

Image

Date

2022-10-10

Abstract

Generic programming is a powerful paradigm abstracting data structures and algorithms to improve their reusability, as long as they respect a given interface. Coupled with a performance-driven language, it is a paradigm of choice for scientific libraries where the implementation of manipulated objects may change depending on their use case, or for performance purposes. In those performance-driven languages, genericity is often implemented statically to perform some optimization. This does not fit well with the dynamism needed to handle objects which may only be known at runtime. Thus, in this article, we evaluate a model that couples static genericity with a dynamic model based on type erasure in the context of image processing. Its cost is assessed by comparing the performance of the implementation of some common image processing algorithms in C++ and Rust, two performance-driven languages supporting some form of genericity. Finally, we demonstrate that compile-time knowledge of some specific information is critical for performance, and also that the runtime overhead depends on the algorithmic scheme in use.

Documents

• Paper

Bibtex (lrde.bib)

@InProceedings{	  esteban.22.gpce,
  author	= {Baptiste Esteban and Edwin Carlinet and Guillaume Tochon
		  and Didier Verna},
  title		= {The Cost of Dynamism in Static Languages for Image
		  Processing},
  booktitle	= {Proceedings of the 21st International Conference on
		  Generative Programming: Concepts \& Experiences (GPCE
		  2022)},
  year		= 2022,
  address	= {Auckland, New Zealand},
  month		= dec,
  abstract	= {Generic programming is a powerful paradigm abstracting
		  data structures and algorithms to improve their
		  reusability, as long as they respect a given interface.
		  Coupled with a performance-driven language, it is a
		  paradigm of choice for scientific libraries where the
		  implementation of manipulated objects may change depending
		  on their use case, or for performance purposes. In those
		  performance-driven languages, genericity is often
		  implemented statically to perform some optimization. This
		  does not fit well with the dynamism needed to handle
		  objects which may only be known at runtime. Thus, in this
		  article, we evaluate a model that couples static genericity
		  with a dynamic model based on type erasure in the context
		  of image processing. Its cost is assessed by comparing the
		  performance of the implementation of some common image
		  processing algorithms in C++ and Rust, two
		  performance-driven languages supporting some form of
		  genericity. Finally, we demonstrate that compile-time
		  knowledge of some specific information is critical for
		  performance, and also that the runtime overhead depends on
		  the algorithmic scheme in use.},
  doi		= {10.1145/3564719.3568693}
}