Fast expression compiler

[jbogard]

The tests fail though.

[lbargaoanu]

A lot of tests fail.

[jbogard]

Looks like we're getting a lot of System.InvalidProgramException : Common Language Runtime detected an invalid program. @dadhi any ideas of how I should debug this?

[lbargaoanu]

It's possible to see the generated IL in VS using an extension. But generating the right IL, not so simple :)

[dadhi]

@jbogard, first identify what tests are failing. Try to isolate and minimize the expressions used in these tests. Test them with FEC.

I will look when I have time. I remember, that I had a fork with FEC for MediatR maybe a 2 years old. The tests were passing at the end.

[jbogard]

@dadhi lol did you? I guess I do have a bit of Activator.CreateInstance in there.

[jbogard]

@dadhi I made a very simple mapping to show the problem.

Here's the test:

using Shouldly;
using Xunit;

namespace AutoMapper.UnitTests.Bug
{
    public class FastExpressionCompilerBug
    {
        public class Source
        {
            public int Value { get; set; }
        }

        public class Dest
        {
            public int Value { get; set; }
        }

        [Fact]
        public void ShouldWork()
        {
            var config = new MapperConfiguration(cfg => cfg.CreateMap<Source, Dest>());
            var mapper = config.CreateMapper();
            var expression = mapper.ConfigurationProvider.BuildExecutionPlan(typeof(Source), typeof(Dest));

            var source = new Source {Value = 5};
            var dest = mapper.Map<Dest>(source);

            dest.Value.ShouldBe(source.Value);
        }
    }
}

And here's the expression (from ReadableExpressions.Visualizer):

(src, dest, ctxt) =>
{
    FastExpressionCompilerBug.Dest typeMapDestination;
    return (src == null)
        ? null
        : {
            typeMapDestination = dest ?? new FastExpressionCompilerBug.Dest();
            try
            {
                var resolvedValue = ((src == null) || false) ? default(int) : src.Value;
                typeMapDestination.Value = resolvedValue;
            }
            catch (Exception ex)
            {
                throw new AutoMapperMappingException(
                    "Error mapping types.",
                    ex,
                    AutoMapper.TypePair,
                    TypeMap,
                    PropertyMap);

                return default(int);
            }

            return typeMapDestination;
        };
}

[jbogard]

And here's the debug view:

.Lambda #Lambda1<System.Func`4[AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Source,AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest,AutoMapper.ResolutionContext,AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest]>(
    AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Source $src,
    AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest $dest,
    AutoMapper.ResolutionContext $ctxt) {
    .Block(AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest $typeMapDestination) {
        .If ($src == null) {
            .Default(AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest)
        } .Else {
            .Block() {
                $typeMapDestination = ($dest ?? .New AutoMapper.UnitTests.Bug.FastExpressionCompilerBug+Dest());
                .Try {
                    .Block(System.Int32 $resolvedValue) {
                        .Block() {
                            $resolvedValue = .If (
                                $src == null || False
                            ) {
                                .Default(System.Int32)
                            } .Else {
                                $src.Value
                            };
                            $typeMapDestination.Value = $resolvedValue
                        }
                    }
                } .Catch (System.Exception $ex) {
                    .Block() {
                        .Throw .New AutoMapper.AutoMapperMappingException(
                            "Error mapping types.",
                            $ex,
                            .Constant<AutoMapper.TypePair>(AutoMapper.TypePair),
                            .Constant<AutoMapper.TypeMap>(AutoMapper.TypeMap),
                            .Constant<AutoMapper.PropertyMap>(AutoMapper.PropertyMap));
                        .Default(System.Int32)
                    }
                };
                $typeMapDestination
            }
        }
    }
}

[jbogard]

See also: dadhi/FastExpressionCompiler#197

[dadhi]

Hi @jbogard

The cases reported in dadhi/FastExpressionCompiler#196 and dadhi/FastExpressionCompiler#197
are fixed.

Here is the clue about performance (the latest FEC master) using the expression from dadhi/FastExpressionCompiler#196

                                     Method |       Mean |     Error |    StdDev | Ratio | RatioSD | Gen 0/1k Op | Gen 1/1k Op | Gen 2/1k Op | Allocated Memory/Op |
------------------------------------------- |-----------:|----------:|----------:|------:|--------:|------------:|------------:|------------:|--------------------:|
                                    Compile | 254.985 us | 3.9906 us | 3.7328 us | 28.47 |    0.56 |      1.9531 |      0.9766 |           - |            10.93 KB |
                                CompileFast |  11.032 us | 0.0558 us | 0.0522 us |  1.23 |    0.01 |      0.6256 |      0.3052 |      0.0305 |             2.91 KB |
                CompileFast_LightExpression |   8.961 us | 0.0921 us | 0.0769 us |  1.00 |    0.00 |      0.6256 |      0.3052 |      0.0305 |             2.91 KB |
                 CompileFast_WithoutClosure |   9.530 us | 0.0917 us | 0.0858 us |  1.06 |    0.01 |      0.6256 |      0.3052 |      0.0305 |             2.88 KB |
 CompileFast_LightExpression_WithoutClosure |   8.024 us | 0.0447 us | 0.0349 us |  0.90 |    0.01 |      0.6256 |      0.3052 |      0.0305 |             2.88 KB |

[jbogard]

@dadhi Nice!

[jbogard]

Yikes. Still tons of test failures:

Test Run Failed.
Total tests: 1493
     Passed: 465
     Failed: 1028
 Total time: 37.4304 Seconds

[dadhi]

Sad..
I had started some work in my fork https://github.com/dadhi/AutoMapper/tree/FECv3

The problem is that expressions are complex and composed in a different places, so I need ToCodeString them.. but this is currently available for LightExpression - and I've started switching AM to LE. Then I immediately stuck on absence of ExpressionVisitor - now adding it...

[jbogard]

Meh.

[github-actions]

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.