From Newsgroup: comp.compilers

The authors built a system that uses a production grammar to create
largish benchmark programs which they then used to evaluate compiler performance and (occasionally) look for bugs.

Abstract
L-systems are a mathematical formalism proposed by biologist Aristid Lindenmayer with the aim of simulating organic structures such as trees, snowflakes, flowers, and other branching phenomena. They are implemented
as a formal language that defines how patterns can be iteratively
rewritten. This paper describes how such a formalism can be used to create artificial programs written in programming languages such as C, C++, Julia
and Go. These programs, being large and complex, can be used to test the performance of compilers, operating systems, and computer architectures.
This paper demonstrates the usefulness of these benchmarks through
multiple case studies. These case studies include a comparison between
clang and gcc; a comparison between C, C++, Julia and Go; a study of the historical evolution of gcc in terms of code quality; a look into the
effects of profile guided optimizations in gcc; an analysis of the
asymptotic behavior of the different phases of clang's compilation
pipeline; and a comparison between the many data structures available in
the Gnome Library (GLib). These case studies demonstrate the benefits of
the L-System approach to create benchmarks, when compared with fuzzers
such as CSmith, which were designed to uncover bugs in compilers, rather
than evaluating their performance.

https://arxiv.org/abs/2512.17616

Regards,
John Levine, johnl@taugh.com, Taughannock Networks, Trumansburg NY
Please consider the environment before reading this e-mail. https://jl.ly
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.compilers

Hi John,

Thank you very much for posting about our paper on comp.compilers. We
truly appreciate it.

One of the goals of BenchGen is to support benchmarking for new
programming languages, as well as new compilers or interpreters for well-established languages. If anyone is interested in benchmarking a
new language, we would be very happy to help set it up within
BenchGen. The system currently supports languages with at least one
data structure. When data structures are not available, simple scalars
can be used instead. It also supports three basic forms of control
flow: function calls, if-then-else constructs, and loops.

Below are a few experiments we have conducted using BenchGen:

A comparison between C, C++, Julia, Go, Zig, V, and Odin: https://github.com/lac-dcc/BenchGen/wiki/Adding-a-New-Programming-Language-to-BenchGen

A comparison between gcc and clang: https://github.com/lac-dcc/BenchGen/wiki/Comparing-gcc-and-clang

A comparison between different versions of gcc: https://github.com/lac-dcc/BenchGen/wiki/Comparing-gcc-versions

A comparison between different GLib data structures: https://github.com/lac-dcc/BenchGen/wiki/Comparing-GLib-data-structures

A study of the impact of profile-guided optimizations: https://github.com/lac-dcc/BenchGen/wiki/Experiment-with-Profile-Guided-Optimization-(PGO)

An analysis of the asymptotic behavior of the Clang and GCC front end,
middle end, and back end: https://github.com/lac-dcc/BenchGen/wiki/Asymptotic-Behavior-of-CLANG-and-GCC-Compilers

Notice that BenchGen is still evolving, and we are open to changes in
the methodology to generate programs.

Best regards,

Fernando

On Tue, Dec 23, 2025 at 12:57rC>AM John R Levine <johnl@taugh.com> wrote:

The authors built a system that uses a production grammar to create
largish benchmark programs which they then used to evaluate compiler performance and (occasionally) look for bugs. ...

https://arxiv.org/abs/2512.17616

--- Synchronet 3.21a-Linux NewsLink 1.2