Is R # right: call to .ToString () is redundant?

This post is published at the request of mstyura habrauser , which does not have enough karma to publish. If you liked the article, thank the author and help him with karma.

I want to share with the Habrosocommunity the result of my research on packaging / unpacking significant types. Two things led me to write this topic: Richter 's book “CLR via c #” and R # itself . The latter, in my opinion, gave "dishonest" comments to my code.

What is the matter?

The fact is that I wrote a fairly standard code, like this one

string str = "habrahabr" ;

int val = 0;

var resultString = str + val.ToString();

* This source code was highlighted with Source Code Highlighter .

Resharper did not like my explicit call to the ToString () method of the val variable, but I naturally didn’t like what it tells me what to do when I know for sure that in this case it’s better to do what I wrote. Let's see who is right. To begin, I propose to figure out what operations will occur when executing the code proposed by R #, that is, this

string str = "habrahabr" ;

int val = 0;

var resultString = str + val;

* This source code was highlighted with Source Code Highlighter .

In the last line we see the operation of adding two variables of different types, the result of which will be a string. Since the variables are of different types, the next version of the string System method will be called. String .Concat ( object , object ). Those. the actual program code will be as follows

string str = "habrahabr" ;

int val = 0;

var resultString = System. String .Concat(str, val);

* This source code was highlighted with Source Code Highlighter .

When passing the str (string - reference type) and val (integer - significant type) parameters to the Concat method for the second parameter, a packing operation will be performed, because we are trying to pass a significant int type to the method, and he expects a reference object.

What is packaging?

For exact definition, I turned to Richter ’s book “CLR via c #” . So:

Packing (boxing) is the conversion of a meaningful type into a reference. When packing an instance of a significant type, the following occurs.

1. The managed heap is allocated memory. Its volume is determined by the length of the significant type and the two additional members required for all objects in the managed heap — a pointer to the type object and the SyncBlockIndex index.

2. Fields of significant type are copied to the memory just allocated on the heap.

3. Returns the address of the object. This address is an object reference; the significant type has become reference.

And if you still call ToString ()

If you call the ToString () method on the val variable before passing it to the System.String.Concat () method, the compiler will choose the next version of the overloaded string System string method. String .Concat ( string , string ), because Objects of the same reference type string will be already input. In this case, the packing operation will not be performed, which implies allocating memory for the significant type on the heap, copying there all the bytes of the original variable of the significant type, and returning the pointer to the allocated memory.

What is it compiled to?

Without calling ToString ()

1. .locals init ([0] string str, [1] int32 val, [2] string resultString)
2. IL_0000: nop
3. IL_0001: ldstr "habrahabr"
4. IL_0006: stloc.0
5. IL_0007: ldc.i4.0
6. IL_0008: stloc.1
7. IL_0009: ldloc.0
8. IL_000a: ldloc.1
9. IL_000b: box [mscorlib] System. Int32
10. IL_0010: call string [mscorlib] System. String :: Concat ( object , object )
11. IL_0015: stloc.2

* This source code was highlighted with Source Code Highlighter .

With a call tostring ()

1. .locals init ([0] string str, [1] int32 val, [2] string resultString)
2. IL_0000: nop
3. IL_0001: ldstr "habrahabr"
4. IL_0006: stloc.0
5. IL_0007: ldc.i4.0
6. IL_0008: stloc.1
7. IL_0009: ldloc.0
8. IL_000a: ldloca.s val
9. IL_000c: call instance string [mscorlib] System. Int32 :: ToString ()
10. IL_0011: call string [mscorlib] System. String :: Concat ( string , string )
11. IL_0016: stloc.2

* This source code was highlighted with Source Code Highlighter .

The main difference in the given IL codes is the box instruction that performs the packing operation, the opposite unpacking command corresponds to the unbox instruction, I do not consider it here.

')

Performance impact

Obviously, it is difficult to judge the performance of the above code, since a single packing operation occurs fairly quickly. We write the next cycle

for ( int i = 0; i < 10000000; i++)

{

var s = "habrahabr" + i;

}

* This source code was highlighted with Source Code Highlighter .

To measure runtime, we use the Stopwatch class from the System.Diagnostics namespace, since It gives a much more accurate result than using DateTime. For example, on my machine, calling two consecutive DateTime.Now gives the difference 00: 00: 00.0010000, and starting and immediately stopping Stopwatch - 00: 00: 00.0000015. The difference is the Windows with the naked eye.

The final code with which we will test the packing operation will be as follows.

namespace BoxingTraining

{

using System;

using System.Diagnostics;

public class Program

{

private static void Main()

{

var time = Stopwatch.StartNew();

for ( int i = 0; i < 10000000; i++)

{

var s = "habrahabr" + i;

}

Console .WriteLine(time.Elapsed.ToString());

}

}

}



* This source code was highlighted with Source Code Highlighter .

Below is a table with the results of running the above code when packing the value of int (4 bytes)

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0324421	0.0314838	0,0009583	3.043788
1,000,000	0.3329810	0,2927090	0.0402720	13.75837
10,000,000	3.5344330	3.2425843	0.2918487	9,000497
100,000,000	35.9022937	35,4208982	0.4813955	1.359072

As you can see, the results, though not in favor of packaging, are not as terrible as they might have seemed at once. Further, we can assume that the size of the type (the value of the occupied memory) can also affect the result, and the next step will be the packaging of a single value of type char, byte and some kind of heavy, self-written structure.

The code for testing the packaging of any variables of significant type.

namespace boxingTraining

{

using System;

using System.Diagnostics;

public class Program

{

private static void Main()

{

var time = Stopwatch.StartNew();

for ( int i = 0; i < 1000000; i++)

{

var s = "habrahabr" + ;

}

Console .WriteLine(time.Elapsed.ToString());

}

}

}

* This source code was highlighted with Source Code Highlighter .

The result table for char (2 bytes)

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0,0120120	0,0080280	0,003984	49.62631
1,000,000	0.0925545	0.0738690	0.0186855	25,29546
10,000,000	0.8949694	0.7298598	0.1651096	22.6221
100,000,000	9,1908556	6,9977169	2,1931387	31,34077

Result table for byte (1 byte)

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0264363	0.0242211	0,0022152	9,145745
1,000,000	0.2600672	0,2304188	0.0296484	12,86718
10,000,000	2.5563460	2,2713021	0.2850439	12,5498
100,000,000	25,1847944	22,3063352	2,8784592	12,90422

A small lyrical digression. When I wrote this topic and came to this point, habrauzer Aldanko , with whom I consulted when writing this article, strongly recommended testing for more standard types to see how they behave in this situation and to investigate the effect of the internal device on packing operation.

Let's test for the following types System.Int16 (2 bytes), System.Int64 (8 bytes), System.Single (4 bytes), System.Double (8 bytes) and System.Decimal (16 bytes).

For System.Int16

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0268269	0.0252753	0,001552	6.1388
1,000,000	0,2508171	0,2283134	0.022504	9,856496
10,000,000	2,5840173	2,2771103	0,306907	13,47792
100,000,000	25.5575014	22,6322024	2,925299	12,92538

For System.Int64

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0313252	0.0261576	0,005168	19,75564
1,000,000	0.2730405	0.2520212	0.021019	8,34029
10,000,000	2.7573422	2.3089744	0.448368	19,41848
100,000,000	26,6876964	23.3565123	3.331184	14,26234

For System.Single

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0488271	0.0435174	0,00531	12,20133
1,000,000	0.4585808	0.4277303	0.030851	7.212606
10,000,000	4,5009957	4,2313242	0.269671	6.373218
100,000,000	44,9906154	42,5702807	2,420335	5,685503

For System.Double

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0477293	0.0454006	0,002329	5,129227
1,000,000	0.4774911	0.4507611	0.02673	5.92997
10,000,000	4,7426156	4.5235923	0.219023	4.8418
100,000,000	47.4816881	44.3383082	3.14338	7.089535

For System.Decimal

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0342277	0.0302381	0,00399	13,19395
1,000,000	0.3082451	0.2852763	0.022969	8.051422
10,000,000	3.0517615	2,8142709	0.237491	8,438797
100,000,000	30.7824241	27.8104480	2.971976	10.68655

As you can see, the call toString () is always faster. In principle, it cannot be slow, because if it is not called, it will be called anyway, but before that, an object of a significant type will be wrapped.

Performance of user structures

I have already tested the most common standard types. It is time to write your structure. On the advice of the same habrayuzer, Aldanko will write a structure containing 1600 fields of type byte (1 byte) and 100 fields of type Decimal (16 byte). The first structure is as follows.

public struct DecimalStruct

{

public decimal Field1;

public decimal Field2;

public decimal Field3;

public decimal Field4;

...

public decimal Field97;

public decimal Field98;

public decimal Field99;

public decimal Field100;

public override string ToString()

{

return "DecimalStruct" ;

}

}

* This source code was highlighted with Source Code Highlighter .

You can download the full version of the code.

Structure with 1600 byte type fields

public struct ByteStruct

{

public byte Field1;

public byte Field2;

public byte Field3;

public byte Field4;

...

public byte Field1597;

public byte Field1598;

public byte Field1599;

public byte Field1600;

public override string ToString()

{

return "ByteStruct" ;

}

}

* This source code was highlighted with Source Code Highlighter .

You can download the full version of the code.

Correspondingly, the code for which we will test the packing operation will be as follows

namespace boxingTraining

{

using System;

using System.Diagnostics;

public class Program

{

private static void Main()

{

var myStruct = new ByteStruct(); // new DecimalStruct()

var time = Stopwatch.StartNew();



for ( int i = 0; i < 100000; i++)

{

var s = "habrahabr" + myStruct; // myStruct.ToString()

}

Console .WriteLine(time.Elapsed.ToString());

}

}

}

* This source code was highlighted with Source Code Highlighter .

The purpose of these frauds is to see how the internal structure of the structure will affect the time of the packing operation, namely, to copy the internal data into a managed heap.

So the results. For ByteStruct

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0553811	0,0072760	0.048105	661.1476
1,000,000	0.5218077	0.0591120	0.462696	782,7441
10,000,000	5,2083878	0.5520037	4.656384	843,5422
100,000,000	61,8142750	5,5449448	56,26933	1014,786

Total for DecimalString

The number of iterations in the loop	Time, s.		Difference, c.	Winning,%
	Without ToString ()	With ToString ()
100,000	0.0815664	0,0068541	0.074712	1090.038
1,000,000	0.8208648	0.0638818	0.756983	1184,974
10,000,000	6.9349283	0.6249309	6,309997	1009,711
100,000,000	54,7189205	6,8453349	47.87359	699,3608

As can be seen from the above tests on voluminous structures, the ToString call gives a gain up to 10 times. True so that it is clearly visible, you need to repeat the packing operation more than once.

findings

What can we conclude from this mini-study? At least it is obvious to me. For reference types, a call to ToString () will not give any benefit and its use in string operations will be redundant, but for meaningful types, a call to ToString () is necessary. When you call it, we avoid a fairly resource-intensive operation - packaging, which in certain cases can significantly degrade the performance of the code. Well, R # turned out to be wrong, cursing that, the call ToString () of a meaningful type is redundant when concatenating strings. It can be not produced, but you can pay the performance.