Re: Performance of records with variant parts

[John Perry <john.perry@usm.edu>]

On Tuesday, March 30, 2021 at 2:12:36 AM UTC-5, briot.e...@gmail.com wrote:
> Since you are on linux, you might want to look at `perf` for performance analysis: 
> 
> perf record --call-graph=fp your_program 
> perf report -g

I don't know why I didn't think of that; I've used perf before. It took a while to find the problem (inlining was an issue), but that did the trick! Both variant and non-variant versions now perform at the same speed.

The problem was indeed a different location. A function returns an Intersection_Type, which has several fields, one of which was a Thing_Type. So if Thing_Type is variant, Intersection_Type also has to be variant. The non-variant version in Ada was

|     return (
|             if which = 0 then No_Intersection
|             else (
|                   thing => things(which),
|                   ray => ray,
|                   dist => dist(which)
|                  )
|            );

...and -gnatD's output for the non-variant version was

|     return (if which = 0 then objects__no_intersection else (
|        thing => things (which),
|        ray => ray,
|        dist => dist (which)));

The non-variant Ada version was:

|     return (
|             if which = 0 then No_Intersection
|             else (
|                   kind => things(which).kind,
|                   thing => things(which),
|                   ray => ray,
|                   dist => dist(which)
|                  )
|            );

The -gnatD option (thanks, Simon!) translates this as:

|     R79b : constant objects__object_type := things (which).kind;
|     type objects__intersections__A84b is access all
|       objects__intersection_type;
|     freeze objects__intersections__A84b []
|     R83b : constant objects__intersections__A84b := (if which = 0
|       then objects__no_intersection else
|        do
|           [subtype objects__intersections__T78b is
|             objects__intersection_type (R79b)]
|           A81b : objects__intersections__T78b;
|           A81b.kind := R79b;
|           A81b.thing := things (which);
|           A81b.ray := ray;
|           A81b.dist := dist (which);
|        in A81b end
|     )'reference;
|     R87b : constant objects__object_type := (R83b.all).kind;
|     subtype objects__intersections__S86b is
|       objects__intersection_type (R87b);
|     return (objects__intersections__S86b!((R83b.all)));

That's... wow. Anyone know why all that is necessary? It seems to create a new inline type instead of using the existing type.

Studying the code, I realized that there was no reason that Intersections_Type had to keep a copy of thing(which); it could instead just remember which, and the caller could obtain thing(which) directly.

That's it. There was nothing else to change.

thank you again, very much
john perry