Difference between revisions of "Publications/esteban.22.gpce"

From LRDE
 
(3 intermediate revisions by the same user not shown)
Line 3: Line 3:
 
| date = 2022-10-10
  
| date = 2022-10-10
 
| authors = Baptiste Esteban, Edwin Carlinet, Guillaume Tochon, Didier Verna
  
| authors = Baptiste Esteban, Edwin Carlinet, Guillaume Tochon, Didier Verna
−
| title = The cost of dynamism in static languages for image processing (Short Paper)
 +
| title = The Cost of Dynamism in Static Languages for Image Processing
−
| booktitle = Proceedings of the 21st International Conference on Generative Programming: Concepts & Experiences
 +
| booktitle = Proceedings of the 21st International Conference on Generative Programming: Concepts & Experiences (GPCE 2022)
 
| address = Auckland, New Zealand
  
| address = Auckland, New Zealand
−
| 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.
 +
| 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.
  +
| lrdepaper = http://www.lrde.epita.fr/dload/papers/esteban.22.gpce.pdf
 
| lrdeprojects = Olena
  
| lrdeprojects = Olena
 
| lrdekeywords = Image
  
| lrdekeywords = Image
 
| lrdenewsdate = 2022-10-10
  
| lrdenewsdate = 2022-10-10
−
| note = accepted
  
 
| type = inproceedings
  
| type = inproceedings
 
| id = esteban.22.gpce
  
| id = esteban.22.gpce
  +
| identifier = doi:10.1145/3564719.3568693
 
| bibtex =
 
| bibtex =
 
@InProceedings<nowiki>{</nowiki> esteban.22.gpce,
  
@InProceedings<nowiki>{</nowiki> esteban.22.gpce,
 
author = <nowiki>{</nowiki>Baptiste Esteban and Edwin Carlinet and Guillaume Tochon
  
author = <nowiki>{</nowiki>Baptiste Esteban and Edwin Carlinet and Guillaume Tochon
 
and Didier Verna<nowiki>}</nowiki>,
  
and Didier Verna<nowiki>}</nowiki>,
−
title = <nowiki>{</nowiki>The cost of dynamism in static languages for image
 +
title = <nowiki>{</nowiki>The Cost of Dynamism in Static Languages for Image
−
processing (Short Paper)<nowiki>}</nowiki>,
 +
Processing<nowiki>}</nowiki>,
 
booktitle = <nowiki>{</nowiki>Proceedings of the 21st International Conference on
  
booktitle = <nowiki>{</nowiki>Proceedings of the 21st International Conference on
−
Generative Programming: Concepts \& Experiences<nowiki>}</nowiki>,
 +
Generative Programming: Concepts \& Experiences (GPCE
  +
2022)<nowiki>}</nowiki>,
 
year = 2022,
  
year = 2022,
 
address = <nowiki>{</nowiki>Auckland, New Zealand<nowiki>}</nowiki>,
  
address = <nowiki>{</nowiki>Auckland, New Zealand<nowiki>}</nowiki>,
 
month = dec,
  
month = dec,
 
abstract = <nowiki>{</nowiki>Generic programming is a powerful paradigm abstracting
  
abstract = <nowiki>{</nowiki>Generic programming is a powerful paradigm abstracting
−
data structures and algorithms to improve their reusability
 +
data structures and algorithms to improve their
−
as long as they respect agiven interface. Coupled with a
 +
reusability, as long as they respect a given interface.
−
performance-driven language, it is a paradigm of choice for
 +
Coupled with a performance-driven language, it is a
−
scientific libraries where the implementation of
 +
paradigm of choice for scientific libraries where the
−
manipulated objects may change in function of their use
 +
implementation of manipulated objects may change depending
−
case or for performance purposes. In those
 +
on their use case, or for performance purposes. In those
 
performance-driven languages, genericity is often
  
performance-driven languages, genericity is often
−
implemented statically to perform some optimization at
 +
implemented statically to perform some optimization. This
−
compile time. This does not fit well with the dynamism
 +
does not fit well with the dynamism needed to handle
−
needed to handle objects which may only be known at
 +
objects which may only be known at runtime. Thus, in this
−
runtime. Thus, in this article, we evaluate a model that
 +
article, we evaluate a model that couples static genericity
−
couples static genericity with a dynamic model based on
 +
with a dynamic model based on type erasure in the context
−
type erasure in the context of image processing. Its cost
 +
of image processing. Its cost is assessed by comparing the
  +
performance of the implementation of some common image
−
is assessed by comparing the performance of the
  
−
implementation of some image processing algorithms in C++
 +
processing algorithms in C++ and Rust, two
−
and Rust, two performance-driven languages supporting the
 +
performance-driven languages supporting some form of
−
genericity paradigm. We finally show that the knowledge of
 +
genericity. Finally, we demonstrate that compile-time
  +
knowledge of some specific information is critical for
−
some information at compile time is more important than
  
−
others, but also that the runtime overhead depends on the
 +
performance, and also that the runtime overhead depends on
−
algorithmic scheme.<nowiki>}</nowiki>,
 +
the algorithmic scheme in use.<nowiki>}</nowiki>,
−
note = <nowiki>{</nowiki>accepted<nowiki>}</nowiki>
 +
doi = <nowiki>{</nowiki>10.1145/3564719.3568693<nowiki>}</nowiki>
 
<nowiki>}</nowiki>
  
<nowiki>}</nowiki>
   

Latest revision as of 12:51, 8 December 2022

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

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}
}





Retrieved from "https://www.lrde.epita.fr/index.php?title=Publications/esteban.22.gpce&oldid=128070"