The cost of dynamism in static languages for image processing (Short Paper)

From LRDE

Abstract

Generic programming is a powerful paradigm abstracting data structures and algorithms to improve their reusability as long as they respect agiven interface. Coupled with a performance-driven language, it is a paradigm of choice for scientific libraries where the implementation of manipulated objects may change in function of their use case or for performance purposes. In those performance-driven languages, genericity is often implemented statically to perform some optimization at compile time. 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 image processing algorithms in C++ and Rust, two performance-driven languages supporting the genericity paradigm. We finally show that the knowledge of some information at compile time is more important than others, but also that the runtime overhead depends on the algorithmic scheme.

Documents

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 (Short Paper)},
  booktitle	= {Proceedings of the 21st International Conference on
		  Generative Programming: Concepts \& Experiences},
  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 agiven interface. Coupled with a
		  performance-driven language, it is a paradigm of choice for
		  scientific libraries where the implementation of
		  manipulated objects may change in function of their use
		  case or for performance purposes. In those
		  performance-driven languages, genericity is often
		  implemented statically to perform some optimization at
		  compile time. 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 image processing algorithms in C++
		  and Rust, two performance-driven languages supporting the
		  genericity paradigm. We finally show that the knowledge of
		  some information at compile time is more important than
		  others, but also that the runtime overhead depends on the
		  algorithmic scheme.},
  note		= {accepted}
}