request compiler optimization about casting

[rootflood]

Copy Of : dotnet/roslyn#52889
Brief description:

when a class is inherit and i'm sure will use parent but not sure use child that may have some sort of casting
fo example:

public class clsA
{
    public int A_Value;
}

public class clsB : clsA
{
    public int B_Value;
}
        
public class C {
    static void Main(bool ineed_A)
    {
        clsA x;
        if (ineed_A)
        {
            x = new clsA();
        }
        else
        {
            x = new clsB();
        }
        
        x.A_Value = 12;

        if (ineed_A)
        {
            x.A_Value = 12;
        }
        else
        {
            ((clsB)x).B_Value = 15; // casting
        }

    }
}

this is possible to ignore casting with two variables:

public class clsA
{
    public int A_Value;
}

public class clsB : clsA
{
    public int B_Value;
}
        
public class C {
    static void Main(bool ineed_A)
    {
        clsA x1;
        clsB x2=null;
        
        if (ineed_A)
        {
            x1 = new clsA();   
        }
        else
        {
            x2 = new clsB();
            x1 = x2;   
        }
        x1.A_Value = 12;

        if (ineed_A)
        {
            x1.A_Value = 12;   
        }
        else
        {
            x2.B_Value = 15; // no casting    
        }
    }
}

but i think a developers likes to write first example because of readability and maintainability of code, so i have optimization request if this is possible.

Languages applicable:
C#

note: i have no idea how c# would/wouldn't fix this.

[canton7]

I'm assuming that your request is to be able to write this?

        if (ineed_A)
        {
            x.A_Value = 12;
        }
        else
        {
            x.B_Value = 15; // No casting
        }

I don't think that's actually stated anywhere.

[rootflood]

this link have useful info about casting and benchmarked all type of cast
note that my request is change downcasting to upcasting

https://www.codeproject.com/Articles/8052/Type-casting-impact-over-execution-performance-in

[canton7]

That article is about 7 years old. A lot changed in netcore.

[rootflood]

based on DotNetBenchmark the optimization is not valuable.

Test:

    public class ClsA
    {
        public string str;
    }

    public class ClsB : ClsA
    {
    }
    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
    [RPlotExporter]
    public class Test
    {
        [Params(1000000, 10000000, 100000000, 1000000000)]
        public int x;


        [Benchmark]
        public object DownCast1()
        {
            ClsA myClass = new ClsB();
            for (int i = 0; i < x; i++)
            {
                ((ClsB)myClass).str = "STR";
            }

            return myClass;
        }

        [Benchmark]
        public object DownCast2()
        {
            ClsA myClass = new ClsB();
            for (int i = 0; i < x; i++)
                (myClass as ClsB).str = "STR";

            return myClass;
        }

        [Benchmark]
        public object UpCast()
        {
            ClsB myClass = new ClsB();
            for (int i = 0; i < x; i++)
            {
                ClsA Parent = myClass;
                Parent.str = "STR";
            }

            return myClass;
        }


    }

Method	x	Mean	Error	StdDev	Median
DownCast1	1000000	2.835 ms	0.0103 ms	0.0086 ms	2.836 ms
DownCast2	1000000	2.832 ms	0.0099 ms	0.0083 ms	2.829 ms
UpCast	1000000	2.834 ms	0.0087 ms	0.0068 ms	2.834 ms
DownCast1	10000000	28.275 ms	0.0029 ms	0.0024 ms	28.276 ms
DownCast2	10000000	28.267 ms	0.0094 ms	0.0073 ms	28.268 ms
UpCast	10000000	28.270 ms	0.0070 ms	0.0059 ms	28.271 ms
DownCast1	100000000	283.137 ms	1.8329 ms	1.5305 ms	282.750 ms
DownCast2	100000000	284.534 ms	4.0380 ms	3.7771 ms	282.748 ms
UpCast	100000000	282.737 ms	0.0279 ms	0.0233 ms	282.735 ms
DownCast1	1000000000	3,098.782 ms	183.3300 ms	514.0770 ms	2,827.369 ms
DownCast2	1000000000	2,830.948 ms	8.7161 ms	6.8049 ms	2,827.285 ms
UpCast	1000000000	2,834.309 ms	14.9666 ms	11.6849 ms	2,827.230 ms

[rootflood]

Test failed because of jit

second test:

    public class ClsA
    {
        public string str;
    }

    public class ClsB : ClsA
    {
    }
    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
    [RPlotExporter]
    public class Test
    {
        [Params(1000000, 10000000, 100000000, 1000000000)]
        public int x;
        public bool NeedB=true;

        [Benchmark]
        public object DownCast1()
        {
            ClsA myClass;
            if (NeedB)
                myClass = new ClsB();
            else
                myClass = new ClsA();
            for (int i = 0; i < x; i++)
            {
                ((ClsB)myClass).str = "STR";
            }

            return myClass;
        }

        [Benchmark]
        public object DownCast2()
        {
            ClsA myClass;
            if (NeedB)
                myClass = new ClsB();
            else
                myClass = new ClsA();
            for (int i = 0; i < x; i++)
                (myClass as ClsB).str = "STR";

            return myClass;
        }

        [Benchmark]
        public object UpCast()
        {
            ClsB myClass_B=null;
            ClsA myClass_A;
            if (NeedB)
            {
                myClass_B = new ClsB();
                myClass_A = myClass_B;
            }
            else
                myClass_A = new ClsA();
            for (int i = 0; i < x; i++)
            {
                myClass_B.str = "STR";
            }

            return myClass_B;
        }


    }

Method	x	Mean	Error	StdDev
DownCast1	1000000	3.790 ms	0.0237 ms	0.0222 ms
DownCast2	1000000	2.840 ms	0.0104 ms	0.0092 ms
UpCast	1000000	2.830 ms	0.0041 ms	0.0034 ms
DownCast1	10000000	37.695 ms	0.0143 ms	0.0112 ms
DownCast2	10000000	28.467 ms	0.2779 ms	0.2599 ms
UpCast	10000000	28.505 ms	0.3335 ms	0.3120 ms
DownCast1	100000000	376.947 ms	0.1442 ms	0.1278 ms
DownCast2	100000000	285.725 ms	4.3710 ms	3.6500 ms
UpCast	100000000	283.066 ms	0.8421 ms	0.7032 ms
DownCast1	1000000000	3,770.326 ms	1.3909 ms	1.0859 ms
DownCast2	1000000000	2,846.942 ms	20.6860 ms	19.3497 ms
UpCast	1000000000	2,843.580 ms	33.8027 ms	28.2268 ms

[rootflood]

based on DotNetBenchmark this type of optimization still is not valuable.
reason : (myClass as ClsB)" as fast as not casting.

also still i have my request because "((ClsB)myClass)" isn't fast like two others.

Do you have any benchmarks showing that the cast is slow enough that it's worth removing it?

my answer is yes but this is just a request and at first i told "note: i have no idea how c# would/wouldn't fix this."
so if anything don't change still everything working very well like past was.

[canton7]

[canton7]

The comment was based on a misunderstand. I recommend editing your post to make it clearer for others

[rootflood]

i didn't know the "as" operator is faster than castclass https://www.codeproject.com/Articles/8052/Type-casting-impact-over-execution-performance-in
so my problem cloud fix with that:

public class clsA
{
    public int A_Value;
}

public class clsB : clsA
{
    public int B_Value;
}

public class C {
    static void Main(bool ineed_A)
    {
        clsA x;
        if (ineed_A)
        {
            x = new clsA();
        }
        else
        {
            x = new clsB();
        }

        x.A_Value = 12;

        if (ineed_A)
        {
            x.A_Value = 12;
        }
        else
        {
            ((clsB)x).B_Value = 15; // casting is slow so don't
            (x as clsB).B_Value = 15; // fast and speed is very close to no casting
        }

    }
}

[yaakov-h]

You should probably re-check any performance claims from 2004, especially against .NET Core/5/6.

[huoyaoyuan]

Unsafe.As can give you even better performance with totally losing type safety.