-
One Line or Two Lines?
Just like the popular view, I thought lesser code means better performance.
I tested:
vb.net Code:
value = CType(object, ObjectType).Property
against
vb.net Code:
Dim obj As ObjectType = CType(object, ObjectType)
value = obj.Property
The first method doesn't need an intermediate variable in between to store my object. This should also put less burden on the garbage collector as there is no variable. The 2nd way has an intermediate variable required in memory. So I thought it must be faster using the first way rather than the second way. But test results shows just the opposite here.
vb.net Code:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim sw As New Stopwatch, senderName As String
For i As Integer = 1 To 5
sw.Reset() : sw.Start()
For j As Integer = 1 To 100000000
senderName = CType(sender, Button).Name
Next
sw.Stop()
Debug.Print("One Line : " & sw.ElapsedMilliseconds)
sw.Reset() : sw.Start()
For j As Integer = 1 To 100000000
Dim btn As Button = CType(sender, Button)
senderName = btn.Name
Next
sw.Stop()
Debug.Print("Two Lines: " & sw.ElapsedMilliseconds)
Next
End Sub
This is the result:
Code:
One Line : 3786
Two Lines: 3677
One Line : 3787
Two Lines: 3683
One Line : 3787
Two Lines: 3677
One Line : 3790
Two Lines: 3678
One Line : 3783
Two Lines: 3677
Anyone know why this happens? Is the CLR doing some smart optimizations?
Pradeep :)
-
Re: One Line or Two Lines?
Time to fire up ILDASM and look at the IL generated. For that reason alone, I prefer to put my two tests into two separate methods, so that you can bring up the IL for both functions in two different windows, align them side by side, and see exactly which lines are different.
I suspect that if you do that you will find that in the second case, the btn variable is created once when the function is entered. Despite the fact that it is declared within the loop, and has no scope outside of the loop, I think that is handled by the compiler, and the declaration in IL will be once at the top of the method.
You might find that in the first case, a button object is created each time through the loop. Not at all sure about this, though, which is why it is time for ILDASM.
-
Re: One Line or Two Lines?
Nevermind. I love this type of thing, so I modified your code and put it into my test project. Here are the two tests:
Code:
Private Sub test1(ByVal arg As Object)
Dim rating As Integer = 7
Dim n As Long = 0
Dim x As Integer
For x = 0 To 4000000
n += CType(arg, TestCase1).No
Next
End Sub
Private Sub test2(ByVal arg As Object)
Dim rating As Integer = 3
Dim n As Long = 0
Dim x As Integer
Dim setI As TestCase1
For x = 0 To 4000000
setI = CType(arg, TestCase1)
n += setI.No
Next
End Sub
Some of the declarations are just leftover junk. TestCase1 is just a little class I whipped up with a property that returns an integer. The class is created, then passed to each method in this order: Test1, Test2, Test2, Test1.
My results confirmed yours. Test2 was faster each time. I then followed my own suggestion and looked at the two side by side in ILDASM. There were definitely differences, but all the key items were in each one. The total number of lines of IL for the loop in Test1 was LESS than the total number of lines of IL in Test2 by two lines (since the object was stored, then loaded, in Test2), yet Test1 was slower than Test2.
Therefore, I see no reason why this should be true.
-
Re: One Line or Two Lines?
A brilliant, and ultimately pointless conclusion. Perhaps if we step below ILDASM to the assembly code generated for each?
-
Re: One Line or Two Lines?
Rather than recreate a test by myself, can you show me the IL for the two cases?
-
Re: One Line or Two Lines?
I still think that the most information will come from examination of the assembly code. For all we know, the second method while generating more ILDASM code actually results in a more efficient memory structure, reducing the time taken for data to be shuffled in and out of the register.
-
Re: One Line or Two Lines?
have i ever mentioned how much i hate line numbers!
Code:
Public Class Form1
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim sw As New Stopwatch, senderName As String
Const loops As Integer = 100000000
Debug.WriteLine(DateTime.Now.ToString)
For i As Integer = 1 To 5
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
senderName = DirectCast(sender, Button).Name
Next
sw.Stop()
Debug.Print("One Line : " & sw.ElapsedMilliseconds)
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
Dim btn As Button = DirectCast(sender, Button)
senderName = btn.Name
Next
sw.Stop()
Debug.Print("Two Lines: " & sw.ElapsedMilliseconds)
Next
End Sub
'we can see who has the faster processor
'2/15/2009 11:15:49 AM
'One Line : 6108
'Two Lines: 6267
'One Line : 6064
'Two Lines: 6264
'One Line : 6048
'Two Lines: 6277
'One Line : 6138
'Two Lines: 6243
'One Line : 6064
'Two Lines: 6324
End Class
-
Re: One Line or Two Lines?
i think that with loops that long i would have to call the results even. a lot goes on in the PC in seconds.
-
Re: One Line or Two Lines?
Code:
Public Class Form1
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim sw As New Stopwatch, senderName As String
Const loops As Integer = 1000
Dim oneLine As Long
Debug.WriteLine(DateTime.Now.ToString)
For i As Integer = 1 To 5
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
senderName = DirectCast(sender, Button).Name
Next
sw.Stop()
oneLine = sw.ElapsedTicks
Debug.WriteLine("One Line : " & sw.ElapsedTicks)
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
Dim btn As Button = DirectCast(sender, Button)
senderName = btn.Name
Next
sw.Stop()
Debug.Write("Two Lines: " & sw.ElapsedTicks & " ")
Debug.WriteLine((sw.ElapsedTicks - oneLine).ToString)
Next
End Sub
'we can see who has the faster processor
'2/15/2009 11:28:38 AM
'One Line : 312
'Two Lines: 284 -28
'One Line : 313
'Two Lines: 285 -28
'One Line : 313
'Two Lines: 314 1
'One Line : 278
'Two Lines: 311 33
'One Line : 278
'Two Lines: 315 37
End Class
-
Re: One Line or Two Lines?
Never mind, I got the itch too. So I got this
Two lines
Code:
IL_0060: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()
IL_0065: nop
IL_0066: ldc.i4.1
IL_0067: stloc.s V_5
IL_0069: ldarg.1
IL_006a: castclass [System.Windows.Forms]System.Windows.Forms.Button
IL_006f: stloc.s btn
IL_0071: ldloc.s btn
IL_0073: callvirt instance string [System.Windows.Forms]System.Windows.Forms.Control::get_Name()
IL_0078: stloc.0
IL_0079: nop
IL_007a: ldloc.s V_5
IL_007c: ldc.i4.1
IL_007d: add.ovf
IL_007e: stloc.s V_5
IL_0080: ldloc.s V_5
IL_0082: ldc.i4 0x5f5e100
IL_0087: stloc.s VB$CG$t_i4$S0
IL_0089: ldloc.s VB$CG$t_i4$S0
IL_008b: ble.s IL_0069
IL_008d: ldloc.1
IL_008e: callvirt instance void [System]System.Diagnostics.Stopwatch::Stop()
One line
Code:
IL_0060: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()
IL_0065: nop
IL_0066: ldc.i4.1
IL_0067: stloc.s V_5
IL_0069: ldarg.1
IL_006a: castclass [System.Windows.Forms]System.Windows.Forms.Button
IL_006f: stloc.s btn
IL_0071: ldloc.s btn
IL_0073: callvirt instance string [System.Windows.Forms]System.Windows.Forms.Control::get_Name()
IL_0078: stloc.0
IL_0079: nop
IL_007a: ldloc.s V_5
IL_007c: ldc.i4.1
IL_007d: add.ovf
IL_007e: stloc.s V_5
IL_0080: ldloc.s V_5
IL_0082: ldc.i4 0x5f5e100
IL_0087: stloc.s VB$CG$t_i4$S0
IL_0089: ldloc.s VB$CG$t_i4$S0
IL_008b: ble.s IL_0069
IL_008d: ldloc.1
IL_008e: callvirt instance void [System]System.Diagnostics.Stopwatch::Stop()
They have a difference of two lines between them where 'btn' is stored on the stack and loaded from the stack. It appears that the V_5 may be the key here. Because in the two line method you've declared a variable, it can be loaded onto a stack using stloc.0, stloc.1 and so on.
But in the one line method, there's an implicit conversion and a need to hold it in a variable, which is why it declares a virtual label using stloc.s.
The difference between stloc.x and stloc.s and ldloc.x and ldloc.s is not entirely clear to me but it appears that there is a bit of overhead involved in the pushing and popping of the stack as the variables are moved and cast in the *.s IL methods.
Note that I simply copy pasted the code in #1, so I haven't bothered with optimization if any.
-
Re: One Line or Two Lines?
I disagree. Here is the output from the code I posted:
Single line (Test1())
Quote:
.method private instance void test1(object arg) cil managed
{
// Code size 40 (0x28)
.maxstack 2
.locals init ([0] int64 n,
[1] int32 rating,
[2] int32 x,
[3] int32 VB$CG$t_i4$S0)
.language '{3A12D0B8-C26C-11D0-B442-00A0244A1DD2}', '{994B45C4-E6E9-11D2-903F-00C04FA302A1}', '{5A869D0B-6611-11D3-BD2A-0000F80849BD}'
// Source File 'C:\Documents and Settings\charrington\My Documents\Visual Studio 2005\Projects\TestApp\TestApp\Form1.vb'
//000066: Private Sub test1(ByVal arg As Object)
IL_0000: nop
//000067: Dim rating As Integer = 7
IL_0001: ldc.i4.7
IL_0002: stloc.1
//000068: Dim n As Long = 0
IL_0003: ldc.i4.0
IL_0004: conv.i8
IL_0005: stloc.0
//000069: Dim x As Integer
//000070:
//000071: For x = 0 To 4000000
IL_0006: ldc.i4.0
IL_0007: stloc.2
//000072: n += CType(arg, TestCase1).No
IL_0008: ldloc.0
IL_0009: ldarg.1
IL_000a: castclass TestApp.TestCase1
IL_000f: callvirt instance int32 TestApp.TestCase1::get_No()
IL_0014: conv.i8
IL_0015: add
IL_0016: stloc.0
//000073: Next
IL_0017: nop
IL_0018: ldloc.2
IL_0019: ldc.i4.1
IL_001a: add
IL_001b: stloc.2
IL_001c: ldloc.2
IL_001d: ldc.i4 0x3d0900
IL_0022: stloc.3
IL_0023: ldloc.3
IL_0024: ble.s IL_0008
//000074:
//000075:
//000076: End Sub
IL_0026: nop
IL_0027: ret
} // end of method Form1::test1
Two lines (intermediate object) Test2
Quote:
.method private instance void test2(object arg) cil managed
{
// Code size 44 (0x2c)
.maxstack 2
.locals init ([0] int64 n,
[1] int32 rating,
[2] class TestApp.TestCase1 setI,
[3] int32 x,
[4] int32 VB$CG$t_i4$S0)
.language '{3A12D0B8-C26C-11D0-B442-00A0244A1DD2}', '{994B45C4-E6E9-11D2-903F-00C04FA302A1}', '{5A869D0B-6611-11D3-BD2A-0000F80849BD}'
// Source File 'C:\Documents and Settings\charrington\My Documents\Visual Studio 2005\Projects\TestApp\TestApp\Form1.vb'
//000078: Private Sub test2(ByVal arg As Object)
IL_0000: nop
//000079: Dim rating As Integer = 3
IL_0001: ldc.i4.3
IL_0002: stloc.1
//000080: Dim n As Long = 0
IL_0003: ldc.i4.0
IL_0004: conv.i8
IL_0005: stloc.0
//000081: Dim x As Integer
//000082: Dim setI As TestCase1
//000083:
//000084: For x = 0 To 4000000
IL_0006: ldc.i4.0
IL_0007: stloc.3
//000085: setI = CType(arg, TestCase1)
IL_0008: ldarg.1
IL_0009: castclass TestApp.TestCase1
IL_000e: stloc.2
//000086: n += setI.No
IL_000f: ldloc.0
IL_0010: ldloc.2
IL_0011: callvirt instance int32 TestApp.TestCase1::get_No()
IL_0016: conv.i8
IL_0017: add
IL_0018: stloc.0
//000087: Next
IL_0019: nop
IL_001a: ldloc.3
IL_001b: ldc.i4.1
IL_001c: add
IL_001d: stloc.3
IL_001e: ldloc.3
IL_001f: ldc.i4 0x3d0900
IL_0024: stloc.s VB$CG$t_i4$S0
IL_0026: ldloc.s VB$CG$t_i4$S0
IL_0028: ble.s IL_0008
//000088:
//000089: End Sub
IL_002a: nop
IL_002b: ret
} // end of method Form1::test2
My code was stripped down to the bare bones for cleanliness, and compares integers instead of objects. I included the entire IL for each sub, just for completeness, but the difference is found between the For line and the Next line (naturally). I don't have any of that stlloc.s or stlloc.x stuff, yet I got the same results.
-
Re: One Line or Two Lines?
You disagree? You're not an ILDASM! Your ILDASM disagrees. You are merely a humble and lowly messenger. :afrog:
Oh but that aside, I think you should re-test or re-generate your IL after moving
to inside the loop rather than having it sit outside and be reused.
-
Re: One Line or Two Lines?
Hmm, after modifying SH's code, I get this output
Quote:
One line: 595
One line: 594
One line: 590
One line: 593
One line: 590
Two lines: 604
Two lines: 601
Two lines: 602
Two lines: 608
Two lines: 601
-
Re: One Line or Two Lines?
What about my case? I couldn't get even one test that says One Line is faster than Two Lines.
This is the lastest one:
Code:
One Line : 3790
Two Lines: 3672
One Line : 3793
Two Lines: 3682
One Line : 3787
Two Lines: 3673
One Line : 3782
Two Lines: 3677
One Line : 3784
Two Lines: 3680
-
Re: One Line or Two Lines?
Hands up if you think this boils down to processors rather than code...
I think we can know for sure if we all try the exact same code.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by mendhak
You disagree? You're not an ILDASM! Your ILDASM disagrees. You are merely a humble and lowly messenger. :afrog:
Oh but that aside, I think you should re-test or re-generate your IL after moving
to inside the loop rather than having it sit outside and be reused.
Lowly I may be, but humble I am not.:mad:
I'm not on that computer anymore, and won't get back on it just to test that.
How can this be a processor issue when all three of us got the same results? In all tests of one line vs two lines, two lines is always faster. The actual amounts vary due to the number of loops and processor speed, but the relative performance remains the same.
EDIT: Oops, misread what the frog posted. Ok, so Pradeep and I get the same results, and Mendhak is the exception that proves the rule.
Darn, maybe I WILL have to re-start that computer....but not for a few hours. Off to other things, for now.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by Pradeep1210
What about my case? I couldn't get even one test that says One Line is faster than Two Lines.
This is the lastest one:
Code:
One Line : 3790
Two Lines: 3672
One Line : 3793
Two Lines: 3682
One Line : 3787
Two Lines: 3673
One Line : 3782
Two Lines: 3677
One Line : 3784
Two Lines: 3680
3 seconds on a PC is forever, so a .1 second difference is nothing really.
switch the running order and see if you get different results.
in your OP you said "Just like the popular view, I thought lesser code means better performance. " another adage is that 10% of the code accounts for 90% of the CPU usage.
-
Re: One Line or Two Lines?
I got itchy as well. My test code:
VB Code:
Module Module1
Const LOOPS As Integer = 200000000
Sub Main()
TestWithoutCast()
TestWithExplicitCast()
TestWithoutCast()
TestWithExplicitCast()
Console.ReadLine()
End Sub
Private Sub TestWithExplicitCast()
Dim sw As New Stopwatch
sw.Start()
For i As Integer = 1 To LOOPS
Dim objTest As New test
Dim obj As Object = objTest
Dim otherObj As test = CType(obj, test)
Dim val As Integer = otherObj.val
Next
Console.WriteLine(sw.ElapsedMilliseconds.ToString + " <<< With explicit cast")
End Sub
Private Sub TestWithoutCast()
Dim sw As New Stopwatch
sw.Start()
For i As Integer = 1 To LOOPS
Dim objTest As New test
Dim obj As Object = objTest
Dim val As Integer = CType(obj, test).val
Next
Console.WriteLine(sw.ElapsedMilliseconds.ToString + " <<< Without cast")
End Sub
Private Class test
Public val As Integer = 1
End Class
End Module
The reason I'm calling the tests twice is to have any JIT time cancelled out during the second run and I'm glad I put it there. IL code for the test methods:
Code:
.method private static void TestWithExplicitCast() cil managed
{
// Code size 82 (0x52)
.maxstack 2
.locals init ([0] class [System]System.Diagnostics.Stopwatch sw,
[1] int32 i,
[2] object obj,
[3] class ConsoleApplication1.Module1/test objTest,
[4] class ConsoleApplication1.Module1/test otherObj,
[5] int32 val,
[6] int64 VB$t_i8$S0)
IL_0000: newobj instance void [System]System.Diagnostics.Stopwatch::.ctor()
IL_0005: stloc.0
IL_0006: ldloc.0
IL_0007: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()
IL_000c: ldc.i4.1
IL_000d: stloc.1
IL_000e: newobj instance void ConsoleApplication1.Module1/test::.ctor()
IL_0013: stloc.3
IL_0014: ldloc.3
IL_0015: stloc.2
IL_0016: ldloc.2
IL_0017: castclass ConsoleApplication1.Module1/test
IL_001c: stloc.s otherObj
IL_001e: ldloc.s otherObj
IL_0020: ldfld int32 ConsoleApplication1.Module1/test::val
IL_0025: stloc.s val
IL_0027: ldloc.1
IL_0028: ldc.i4.1
IL_0029: add.ovf
IL_002a: stloc.1
IL_002b: ldloc.1
IL_002c: ldc.i4 0xbebc200
IL_0031: ble.s IL_000e
IL_0033: ldloc.0
IL_0034: callvirt instance int64 [System]System.Diagnostics.Stopwatch::get_ElapsedMilliseconds()
IL_0039: stloc.s VB$t_i8$S0
IL_003b: ldloca.s VB$t_i8$S0
IL_003d: call instance string [mscorlib]System.Int64::ToString()
IL_0042: ldstr " <<< With explicit cast"
IL_0047: call string [mscorlib]System.String::Concat(string,
string)
IL_004c: call void [mscorlib]System.Console::WriteLine(string)
IL_0051: ret
} // end of method Module1::TestWithExplicitCast
.method private static void TestWithoutCast() cil managed
{
// Code size 78 (0x4e)
.maxstack 2
.locals init ([0] class [System]System.Diagnostics.Stopwatch sw,
[1] int32 i,
[2] object obj,
[3] class ConsoleApplication1.Module1/test objTest,
[4] int32 val,
[5] int64 VB$t_i8$S0)
IL_0000: newobj instance void [System]System.Diagnostics.Stopwatch::.ctor()
IL_0005: stloc.0
IL_0006: ldloc.0
IL_0007: callvirt instance void [System]System.Diagnostics.Stopwatch::Start()
IL_000c: ldc.i4.1
IL_000d: stloc.1
IL_000e: newobj instance void ConsoleApplication1.Module1/test::.ctor()
IL_0013: stloc.3
IL_0014: ldloc.3
IL_0015: stloc.2
IL_0016: ldloc.2
IL_0017: castclass ConsoleApplication1.Module1/test
IL_001c: ldfld int32 ConsoleApplication1.Module1/test::val
IL_0021: stloc.s val
IL_0023: ldloc.1
IL_0024: ldc.i4.1
IL_0025: add.ovf
IL_0026: stloc.1
IL_0027: ldloc.1
IL_0028: ldc.i4 0xbebc200
IL_002d: ble.s IL_000e
IL_002f: ldloc.0
IL_0030: callvirt instance int64 [System]System.Diagnostics.Stopwatch::get_ElapsedMilliseconds()
IL_0035: stloc.s VB$t_i8$S0
IL_0037: ldloca.s VB$t_i8$S0
IL_0039: call instance string [mscorlib]System.Int64::ToString()
IL_003e: ldstr " <<< Without cast"
IL_0043: call string [mscorlib]System.String::Concat(string,
string)
IL_0048: call void [mscorlib]System.Console::WriteLine(string)
IL_004d: ret
} // end of method Module1::TestWithoutCast
After looking at the IL, the declaration and use of otherObj (created and loaded from the stack) seems to be the only difference.
Build in release mode with optimizations enabled. Results from within the IDE:
3015 <<< Without cast
3112 <<< With explicit cast
3023 <<< Without cast
3100 <<< With explicit cast
Results from the command line:
1254 <<< Without cast
1199 <<< With explicit cast
1129 <<< Without cast
1199 <<< With explicit cast
Note that when run from the command line the first test without cast is slower than the first test with the cast. This is because the code gets JITted behind the scenes and that time affects the test. In the second run of both tests, the results are what one would expect. BTW, I think that the declaration or not of an intermediate variable does not really help GC - it can routinely spot things like that otherwise there would be lots of crying .Net developers out there.
Interestingly enough, when I disable optimizations I get the VB$CG$t_i4$S0 variable in my IL, just like mendhak and Shaggy.
-
Re: One Line or Two Lines?
OK, I moved the declaration inside the loop, so that my code for Test2 looks like this:
Code:
Private Sub test2(ByVal arg As Object)
Dim rating As Integer = 3
Dim n As Long = 0
Dim x As Integer
For x = 0 To 4000000
Dim setI As TestCase1
setI = CType(arg, TestCase1)
n += setI.No
Next
End Sub
I also moved the whole thing to a different computer. The timing is different on the two computers, of course, but the relative results are the same.
The IL for the new version of Test2 is this:
Quote:
.method private instance void test2(object arg) cil managed
{
// Code size 37 (0x25)
.maxstack 2
.locals init ([0] int64 n,
[1] int32 rating,
[2] int32 x,
[3] class TestApp.TestCase1 setI)
IL_0000: ldc.i4.3
IL_0001: stloc.1
IL_0002: ldc.i4.0
IL_0003: conv.i8
IL_0004: stloc.0
IL_0005: ldc.i4.0
IL_0006: stloc.2
IL_0007: ldarg.1
IL_0008: castclass TestApp.TestCase1
IL_000d: stloc.3
IL_000e: ldloc.0
IL_000f: ldloc.3
IL_0010: callvirt instance int32 TestApp.TestCase1::get_No()
IL_0015: conv.i8
IL_0016: add
IL_0017: stloc.0
IL_0018: ldloc.2
IL_0019: ldc.i4.1
IL_001a: add
IL_001b: stloc.2
IL_001c: ldloc.2
IL_001d: ldc.i4 0x3d0900
IL_0022: ble.s IL_0007
IL_0024: ret
} // end of method Form1::test2
This IL version is the release version, rather than the, easier to follow, debug version, but the result is still the same. When compared to the release version of Test1 (the code is the same as in my original post):
Quote:
.method private instance void test1(object arg) cil managed
{
// Code size 35 (0x23)
.maxstack 2
.locals init ([0] int64 n,
[1] int32 rating,
[2] int32 x)
IL_0000: ldc.i4.7
IL_0001: stloc.1
IL_0002: ldc.i4.0
IL_0003: conv.i8
IL_0004: stloc.0
IL_0005: ldc.i4.0
IL_0006: stloc.2
IL_0007: ldloc.0
IL_0008: ldarg.1
IL_0009: castclass TestApp.TestCase1
IL_000e: callvirt instance int32 TestApp.TestCase1::get_No()
IL_0013: conv.i8
IL_0014: add
IL_0015: stloc.0
IL_0016: ldloc.2
IL_0017: ldc.i4.1
IL_0018: add
IL_0019: stloc.2
IL_001a: ldloc.2
IL_001b: ldc.i4 0x3d0900
IL_0020: ble.s IL_0007
IL_0022: ret
} // end of method Form1::test1
Test2 performs considerably better than Test1 in release version (~10%), and marginally better than Test1 in debug version (~2%). I didn't test the release version of the code on the first computer.
Therefore, I don't see how computer differences can account for this. There are two extra lines of IL (a store and load) in Test2 than in Test1, yet Test2 runs faster. The only way I can account for Mendhaks anomalous results are by attacking his character, which, while satisfying and politically correct, really doesn't help anything.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by dbasnett
3 seconds on a PC is forever, so a .1 second difference is nothing really.
switch the running order and see if you get different results.
in your OP you said "Just like the popular view, I thought lesser code means better performance. " another adage is that 10% of the code accounts for 90% of the CPU usage.
Maybe it is a very small difference, but worth knowing why there is such a difference. It can't be due to external factors like OS doing some other background tasks during that time, since it seems to affect only one of them and not the other.
I was just interested in knowing how the two lines are always faster than the single line code, though logically single line code should have performed better as the compiler has lesser overheads involved.
How does the compiler favor 2 lines instead of the one line code even after having overheads of more instructions and memory?
Switching the order of test doesn't seem to affect the test result. 2 lines are still faster than the single line code.
-
Re: One Line or Two Lines?
Honestly, looking the results, no conclusion can be drawn beyond the fact that one piece of code produces different results than another.
There are many many optimizations that the compiler can perform: for example:
Dim d as double = 1
produces different assembly from:
Dim d as double = 53.4
This is a 'special' case scenario; just as casting is a special case scenario, and has nothing to do with the number of lines of code typed into the IDE. It doesn't necessarily apply in this case, but the point is that the quantity of code we write has absolutely no correlation with performance. Indeed, more lines of IDE code can result in a significant performance increase in some cases (my brush with this was going from a nice, compact routine to a horrible piece of lengthy code with many nested if/then statements).
At this point, I'd like to say that I get 'opposite' results than the OP with the OP code - opposite in that the difference number of milliseconds out of a 5 second execution time for each loop is around 100. Essentially, the execution time is the same - this is in debug mode, verses release mode.
A cursory glance at the generated (debug and release) assembly indicates that the 'two line' entry results in an additional line of assembly.
While inline code can be very useful, it doesn't necessarily tell the whole story. The underlying assembly language is probably a better indicator of performance, since you will be able to see compiler optimizations (inlining and constant substitution, for example).
Declaring a variable in a loop or outside a loop makes no difference - we can put that one to to rest, but all are welcome to prove (demonstrate?) that for themselves.
-
Re: One Line or Two Lines?
What's your point? Would you not look at this? If you found a difference, would you not wonder why? Surely you wouldn't take any difference and just pass it off as some kind of compiler optimization, nor would you find a difference and just ignore it. So what are you getting at?
-
Re: One Line or Two Lines?
the test is flawed.
if the difference is troublesome the first place to start is to explain why all of the test of a certain type aren't identical.
Code:
One Two
3786 3677 109
3787 3683 104
3787 3677 110
3790 3678 112
3783 3677 106
Average 3786.6 3678.4 108.2
Median 3786.8 3677.5 109.3
High 3790 3683 107
Small 3783 3677 106
StdDev 2.50998008 2.607680962
57.07743279
if the numbers were 4000 and 2000 it would be different.
-
Re: One Line or Two Lines?
Code:
Dim stpw As New Stopwatch, i, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 500000000, tests As Integer = 5
Dim results As New List(Of Long)
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Next
stpw.Stop()
results.Add(stpw.ElapsedMilliseconds)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.WriteLine("'" & results(i).ToString)
Next
'1705
'1632
'1607
'1605
'1696
shouldn't these results be identical????????
-
Re: One Line or Two Lines?
-
Re: One Line or Two Lines?
Not sure what you are getting at. Are you suggesting that the differences we are seeing are just simple variation about a mean? That's not the case for the tests I posted, as the variation I was observing within a group was dwarfed by the variation I was observing between the two groups. The confidence intervals were never even close to overlapping. For instance, I was seeing a 10% difference between the means of the two groups in the second test (with release code), while the maximum variation within the group was around 0.5%
-
Re: One Line or Two Lines?
Having read the link, which you posted while I was writing that, I would argue that, while micro optimization is not going to make much of a difference in any business code, there are still two reasons to partake:
1) You learn more about the language and how it works. Who knows how and when the knowledge will be of benefit, but the more you know, the better you will do.
2) It's fun. If you don't think so, look at the list of people in this thread who put together tests of one thing or another and cited nothing more than curiosity.
-
Re: One Line or Two Lines?
the difference in the test, using the original numbers, was within the margin of error (twice the standard deviation?).
-
Re: One Line or Two Lines?
I don't see that. In your post #23, you show the range and SD of the two groups. The SD in both cases was ~2.5, while the difference between the means was 108.2 That's 50x the SD, which is considerably larger than 2x.
This one passes the Interocular Arm-Length Test, which is the most robust statistical test in existence.
Edit: Not 50x, but 43x, which is still a big number.
-
Re: One Line or Two Lines?
the difference in each line was 100'ish and the SD of the entire set was 57.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by Shaggy Hiker
What's your point? Would you not look at this? If you found a difference, would you not wonder why? Surely you wouldn't take any difference and just pass it off as some kind of compiler optimization, nor would you find a difference and just ignore it. So what are you getting at?
If you referring to my post...who said anything about 'ignoring it'? The 'point', is that the compiler does perform optimizations which you may not be aware of - is it the case in this situation? perhaps not, but you cannot dismiss that. Looking at the assembly code, it resulted in a single line of assembly code difference between the two large loops - yet two lines of IL code.
That was an attempt to explain and examine the difference, even though it doesn't explain why Pradeep got faster times for the 'two line' loop verses the 'one line' loop.
Additionally, the different results from different people demonstrate that we are examining the results from a flawed test. As dbasnett demonstrated, and raised the question, why are the results from the same loop so different?
Quote:
Originally Posted by Pradeep1210
Maybe it is a very small difference, but worth knowing why there is such a difference. It can't be due to external factors like OS doing some other background tasks during that time, since it seems to affect only one of them and not the other.
I was just interested in knowing how the two lines are always faster than the single line code, though logically single line code should have performed better as the compiler has lesser overheads involved.
How does the compiler favor 2 lines instead of the one line code even after having overheads of more instructions and memory?
I would be curious about the scalability, Pradeep: what results do you get if you run the loops for 10 times the values you have given in the original post? Does it scale and give the same relative difference?
I don't get the size of variation that you post; I posted your exact code into a new project.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by dbasnett
the difference in each line was 100'ish and the SD of the entire set was 57.
You don't compare the SD of the entire set, but the error of each group. The question is whether an item of set A can reasonably be mistaken for an item of set B. In this case, with no overlap between the groups, that type of mistake can't be made. The two are significantly different by any test.
@SJWhiteley: Ok, I understand you now, I think. Normally, when you see a difference in performance between two minor chunks of code, you need look no further than the IL, which I mentioned in my first post in this thread. The interesting point about this particular difference is that you can't explain the difference via IL alone. While I recognize that the conversion from IL to machine code is not simplistic, and ripe for optimization, in my experience, I have never before seen a question like this that required digging deeper than the IL, so for me, it is novel.
As for the variations between runs: I didn't examine it carefully, but most people were running tests on different code, and everybody was running tests on different computers (of course). No absolute measurement, nor any single measurement, has any meaning. There are interrupts being handled by the OS at a level well below our code, and we can't predict the exact state of any particular run, which is why it is essential to run many times with very high iteration rates. The high iteration rates reduces the error in any one iteration to a negligible level (though it is not a random error, but shows a distinct bias high), while averaging multiple tests takes care of the variation between the tests as far as we care.
-
Re: One Line or Two Lines?
Shaggy: you are right, you wouldn't normally need to go down to assembly level. In fact, it's not often that you need to go and look at IL... :) You brought up a good point that something like this is rarely necessary in business code - the impact is usually minimal.
Then again, these are the sorts of things which bite us on the bum, so to speak. Although not relevant to this topic, IL code won't show when a compile in-lines a function to increase performance.
And you are right - the IL cannot give a reason for a difference, and neither can the assembly. But it hints at a much smaller difference than what the OP is seeing, and indeed, would indicate a difference in the other direction.
In any case, I suppose I'm just chucking ideas out there...code timing is actually a fickle thing. db, I think, has shown that the basis on which we are working is fundamentally flawed; in addition there isn'a a commonality between the posts with code - kind of like arguing which of us gets to work the quickest between two routes we may take ;) (I think I'd beet all of y'all...).
-
Re: One Line or Two Lines?
Quote:
Originally Posted by dbasnett
the test is flawed.
if the difference is troublesome the first place to start is to explain why all of the test of a certain type aren't identical.
Code:
One Two
3786 3677 109
3787 3683 104
3787 3677 110
3790 3678 112
3783 3677 106
Average 3786.6 3678.4 108.2
Median 3786.8 3677.5 109.3
High 3790 3683 107
Small 3783 3677 106
StdDev 2.50998008 2.607680962
57.07743279
if the numbers were 4000 and 2000 it would be different.
This is OK... but why is each individual result row of 2 lines test always faster than the one line test whatever way we test. Not even one result points the opposite?
We would take statistical analysis only when the results are mixed. Isn't it? But here the speedometer always points towards 2 lines test and not once towards one line test.
Pradeep :)
-
Re: One Line or Two Lines?
Code:
Ctype
Start Normal
2/17/2009 8:48:28 AM
ONE TWO DIFF
1936 2073 -137
1968 1975 -7
2002 1943 59
1938 1971 -33
1942 1954 -12
1953 1955 -2
1949 2077 -128
2008 1983 25
1978 1989 -11
1973 2005 -32
2/17/2009 8:49:07 AM
Start Highest
2/17/2009 8:47:11 AM
ONE TWO DIFF
1836 1837 -1
1853 1839 14
1857 1847 10
1834 1848 -14
1845 1837 8
1836 1843 -7
1832 1835 -3
1833 1833 0
1836 1843 -7
1840 1832 8
2/17/2009 8:47:49 AM
DirectCast
Start Normal
2/17/2009 8:50:20 AM
ONE TWO DIFF
1964 2112 -148
1989 2062 -73
1996 2054 -58
1968 2105 -137
2004 2031 -27
1987 2022 -35
1960 2156 -196
1992 2077 -85
2012 2029 -17
1964 2034 -70
2/17/2009 8:51:00 AM
Start Highest
2/17/2009 8:51:44 AM
ONE TWO DIFF
1837 1847 -10
1838 1832 6
1861 1833 28
1835 1847 -12
1840 1847 -7
1835 1837 -2
1834 1831 3
1838 1838 0
1836 1847 -11
1834 1832 2
2/17/2009 8:52:21 AM
Code:
Option Strict On : Option Explicit On
Imports System.Threading
Public Class Form1
Private Sub Form1_Shown(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Shown
Timer1.Interval = 1000
Timer1.Start()
Me.WindowState = FormWindowState.Minimized
End Sub
Dim t As Thread = New Thread(AddressOf test)
Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
Timer1.Stop()
t.Priority = ThreadPriority.Highest
Debug.WriteLine("Start " & t.Priority.ToString)
t.Start()
End Sub
Private Sub test()
Dim but As New Button
DUT(DirectCast(but, Object))
End Sub
Private Sub DUT(ByVal sender As System.Object)
Dim sw As New Stopwatch, senderName As String
Dim one, two As Long
Const loops As Integer = 20000000
Debug.WriteLine(DateTime.Now.ToString)
Debug.WriteLine("ONE " & ControlChars.Tab & "TWO " & ControlChars.Tab & "DIFF ")
For i As Integer = 1 To 10
'one
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
senderName = DirectCast(sender, Button).Name
Next
sw.Stop()
one = sw.ElapsedMilliseconds
'two
sw.Reset() : sw.Start()
For j As Integer = 1 To loops
Dim btn As Button = DirectCast(sender, Button)
senderName = btn.Name
Next
sw.Stop()
two = sw.ElapsedMilliseconds
Debug.WriteLine(one.ToString.PadRight(4, " "c) & ControlChars.Tab & _
two.ToString.PadRight(4, " "c) & ControlChars.Tab & _
(one - two).ToString)
Next
Debug.WriteLine(DateTime.Now.ToString)
End Sub
End Class
-
Re: One Line or Two Lines?
Quote:
Originally Posted by SJWhiteley
...
I would be curious about the scalability, Pradeep: what results do you get if you run the loops for 10 times the values you have given in the original post? Does it scale and give the same relative difference?
I don't get the size of variation that you post; I posted your exact code into a new project.
I tried with increasing the loops to 10 times instead of 5. Here are the results:
Code:
One Line : 3812
Two Lines: 3705
One Line : 3818
Two Lines: 3702
One Line : 3807
Two Lines: 3700
One Line : 3808
Two Lines: 3700
One Line : 3809
Two Lines: 3696
One Line : 3806
Two Lines: 3699
One Line : 3811
Two Lines: 3701
One Line : 3808
Two Lines: 3703
One Line : 3810
Two Lines: 3700
One Line : 3809
Two Lines: 3698
-
Re: One Line or Two Lines?
Quote:
Originally Posted by Pradeep1210
I tried with increasing the loops to 10 times instead of 5. Here are the results:
I mean multiply your inner loop by 10, so you are running it for half a minute or so per loop.
Basically, if it takes 3800ms for loop 1 and 3700 for loop 2, what would be the results for 1x the number of loops. We will get:
Loop One: 38000 ms
Loop Two: 37000 ms (1 second difference)
or:
Loop One: 38000 ms
Loop Tow: 37900 ms (still a 100ms difference)
or, something else.
Personally, I don't get the same results as you at all - the results are all within 10mS or so on my PC, so don't see a problem.
Obviously, you do see a difference; the IL and assembly code would contradict your evidence, so we'd have to determine a pattern for the results to see if there's potentially another reason for the discrepancy.
-
Re: One Line or Two Lines?
i can't replicate the results that pradeep had. it is still my opinion that the experiment is flawed.
in post #24 i think i showed that.
Code:
'Start Normal
'2/17/2009 2:13:56 PM
'BaseLine
'288
'300
'293
'292
'287
'Test
'509
'497
'496
'487
'510
'Start Highest
'2/17/2009 2:14:07 PM
'BaseLine
'300
'289
'283
'284
'284
'Test
'479
'478
'475
'476
'475
Option Strict On : Option Explicit On : Option Infer Off
Imports System.Threading
Public Class Form1
Dim stpw As New Stopwatch, i, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 50000000, tests As Integer = 5
Dim results As New List(Of Long)
Private Sub test()
Debug.WriteLine("'" & DateTime.Now.ToString)
Debug.WriteLine("'BaseLine")
BaseLine()
Debug.WriteLine("'Test")
UnitTest()
End Sub
Private Sub BaseLine()
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
'shouldn't .ElapsedMilliseconds be the same???????
Next
stpw.Stop()
results.Add(stpw.ElapsedMilliseconds)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.WriteLine("'" & results(i).ToString)
Next
End Sub
Dim foo As Double
Private Sub UnitTest()
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
foo = CDbl(i)
Next
stpw.Stop()
results.Add(stpw.ElapsedMilliseconds)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.WriteLine("'" & results(i).ToString)
Next
End Sub
Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
Dim t As Thread = New Thread(AddressOf test)
Timer1.Stop()
If CheckBox1.Checked Then t.Priority = ThreadPriority.Highest
Debug.WriteLine("'Start " & t.Priority.ToString)
t.Start()
End Sub
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Timer1.Interval = 1000
If Not Timer1.Enabled Then
Debug.WriteLine("")
Timer1.Start()
End If
End Sub
End Class
-
Re: One Line or Two Lines?
Quote:
Originally Posted by SJWhiteley
I mean multiply your inner loop by 10, so you are running it for half a minute or so per loop.
Basically, if it takes 3800ms for loop 1 and 3700 for loop 2, what would be the results for 1x the number of loops. We will get:
Loop One: 38000 ms
Loop Two: 37000 ms (1 second difference)
or:
Loop One: 38000 ms
Loop Tow: 37900 ms (still a 100ms difference)
or, something else.
Personally, I don't get the same results as you at all - the results are all within 10mS or so on my PC, so don't see a problem.
Obviously, you do see a difference; the IL and assembly code would contradict your evidence, so we'd have to determine a pattern for the results to see if there's potentially another reason for the discrepancy.
Multiplied the inner loops by 10 (increased one zero). Here are the results now:
Code:
One Line : 36727
Two Lines: 36702
One Line : 36713
Two Lines: 36713
One Line : 36714
Two Lines: 36709
The thread 0x17c has exited with code 0 (0x0).
One Line : 36702
Two Lines: 36708
One Line : 36700
Two Lines: 36707
One Line : 36704
Two Lines: 36702
One Line : 36699
Two Lines: 36708
One Line : 36711
Two Lines: 36705
One Line : 36737
Two Lines: 36718
One Line : 36709
Two Lines: 36716
Amazingly the difference seems to be reducing instead of increasing :confused:
-
Re: One Line or Two Lines?
Which just means that the first one has a fixed overhead associated with it. The more loops you run, the less significant the overhead to the total time taken.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by dbasnett
i can't replicate the results that pradeep had. it is still my opinion that the experiment is flawed.
in post #24 i think i showed that.
...
I still wonder why results are inclined towards only one side. Even if the stopwatch is inaccurate, shouldn't it affect both tests? :rolleyes:
-
Re: One Line or Two Lines?
Quote:
Originally Posted by Pradeep1210
I still wonder why results are inclined towards only one side. Even if the stopwatch is inaccurate, shouldn't it affect both tests? :rolleyes:
It's not necessarily that the stopwatch is inaccurate, but the nature of what is being measured. For example, get a real physical stopwatch and try timing it. You'll obviously get poor and inaccurate results - it doesn't mean a hand-held stopwatch is inaccurate, just the wrong tool to perform the test.
Now you have two sets of results, you can see that 'two lines is faster than one' isn't necessarily true. There's evidently something going on which none of us have noted: but from experience, often if you get unexpected results then your first instinct should be to determine if you are 'doing it right'. That is, you need to test the test. Further, ad-hoc timing tests tend to be inherently flawed if you are trying to produce a black/white conclusion.
So, to answer your question, why is the initial test producing on the face of it, opposite results to what is expected? The answer isn't conclusive. Running the second test (longer) you'll see that it demonstrates two things:
A flawed test; and
It doesn't matter.
Regarding the second item. It doesn't matter because it doesn't scale. What you are actually trying to measure takes an immeasurably(?) small amount of time, the difference between the two is inconsequential. But, small things add up - the second test demonstrates that the difference, if any, doesn't scale, and also shows that the difference in the first test (even assuming a test which is not flawed) has little to do with the test in question.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by dbasnett
i can't replicate the results that pradeep had. it is still my opinion that the experiment is flawed.
in post #24 i think i showed that.
Actually, your post #24 is flawed. The results of any one run through a loop is going to vary. The first reading is high due to the JIT compiling the code, which doesn't happen afterwards, so throw out the first reading. After that, you need to repeat several times, because there is no way (not even by setting the threading priority) to block the OS from handling processor interrupts, which will add a few cycles to some runs, more to other runs, etc. It takes several runs to resolve whether there is a difference, and there is, in this case.
@SJWhiteley: I ran the second test on my simplified example of the original post, and it confirmed the results of the earlier test. By slowing the test by a factor of 100x, I increased the difference by a similar margin. The difference DOES scale. However, it isn't clear what "second test" you are talking about. Which post?
-
Re: One Line or Two Lines?
"After that, you need to repeat several times, because there is no way (not even by setting the threading priority) to block the OS from handling processor interrupts..." Exactly why I have said, the experiment is flawed or more precisely the interpretation of the results as having a meaning that they don't is. I don't know how large the time slice (Quantum?) is, but any experiment that runs longer than that has to have some variance. And then there are IO interrupts...
-
Re: One Line or Two Lines?
First result set:
Code:
One Line : 3786
Two Lines: 3677
One Line : 3787
Two Lines: 3683
One Line : 3787
Two Lines: 3677
One Line : 3790
Two Lines: 3678
One Line : 3783
Two Lines: 3677
Second result set:
Code:
One Line : 36727
Two Lines: 36702
One Line : 36713
Two Lines: 36713
One Line : 36714
Two Lines: 36709
The thread 0x17c has exited with code 0 (0x0).
One Line : 36702
Two Lines: 36708
One Line : 36700
Two Lines: 36707
One Line : 36704
Two Lines: 36702
One Line : 36699
Two Lines: 36708
One Line : 36711
Two Lines: 36705
One Line : 36737
Two Lines: 36718
One Line : 36709
Two Lines: 36716
The perception error from the first result set does not exist in the second result set. We can't mix results from different computers, or different tests, of course. Since Pradeep has shown the largest error and is looking for a reason, I think it only fair we use his results :)
I don't think we even need to go as far as calculating any statistics on the second set of results to see that there is no measurable difference between one-line and two-line.
edit: bottom line, for me, is a *shrug*: I cannot definitively explain why result set 1 looks like it does, but with the addition of result set 2, I'd say that it's an anomaly - no conclusion can be drawn about anything by examining result set 1 in isolation.
-
Re: One Line or Two Lines?
So how does it make the experiment flawed? You showed with your own example that the variance around the mean for each group is minor compared to the separation between the means, so no statistical test ever correctly applied will say that the two groups are indistinguishable.
-
Re: One Line or Two Lines?
Doggone, you were posting that as I was writing the other. It appears that your first test results showed the results that Pradeep posted in the first post. Where did the second set of test results come from?
I posted the code I used for my test. It wasn't casting buttons, but a custom class that I had more control of. The results supported what Pradeep originally asserted, and have less uncontrolled variation than his code. The results also scaled to any level.
-
Re: One Line or Two Lines?
Quote:
Originally Posted by SJWhiteley
The perception error from the first result set does not exist in the second result set. We can't mix results from different computers, or different tests, of course. Since Pradeep has shown the largest error and is looking for a reason, I think it only fair we use his results :)
I don't think we even need to go as far as calculating any statistics on the second set of results to see that there is no measurable difference between one-line and two-line.
edit: bottom line, for me, is a *shrug*: I cannot definitively explain why result set 1 looks like it does, but with the addition of result set 2, I'd say that it's an anomaly - no conclusion can be drawn about anything by examining result set 1 in isolation.
What about MaximilianMayrhofer said in Post #40. Could that be the case?
-
Re: One Line or Two Lines?
Code:
Dim stpw As New Stopwatch, i, j, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 50000, tests As Integer = 25, outLoop As Integer = 3
Dim results As New List(Of Long), y As Long
For j = i1 To outLoop
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
y = i * 5
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
y = i + i + i + i + i
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
Next
Code:
'i would say that multiplying a number by 5 is faster than adding the same number together five times
' 2153 ' 2152 ' 2134 ' 2134 ' 2135 ' 2134 ' 2135 ' 2135 ' 2134 ' 2134 ' 2135 ' 2134 ' 2313 ' 2151 ' 2134 ' 2135 ' 2134 ' 2134 ' 2135 ' 2135 ' 2134 ' 2134 ' 2134 ' 2135 ' 2134
' 816 ' 803 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802
' 1502 ' 1500 ' 1501 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501 ' 1500 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501 ' 1815 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500
' 719 ' 719 ' 713 ' 714 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713
' 809 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 803 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 803 ' 802 ' 802 ' 802 ' 802 ' 802
' 1502 ' 1500 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501 ' 1501 ' 1972 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500
' 720 ' 719 ' 713 ' 713 ' 713 ' 713 ' 713 ' 713 ' 714 ' 713 ' 713 ' 713 ' 714 ' 713 ' 714 ' 713 ' 713 ' 713 ' 713 ' 714 ' 713 ' 713 ' 713 ' 713 ' 714
' 804 ' 1502 ' 815 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 803 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802 ' 802
' 1501 ' 1500 ' 1500 ' 1501 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 2049 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1500 ' 1501
-
Re: One Line or Two Lines?
Code:
Dim checkQ As New CheckBox, obj As New Object, objCHKD As Boolean
Dim stpw As New Stopwatch, i, j, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 25000, tests As Integer = 25, outLoop As Integer = 3
Dim results As New List(Of Long), y As Long
obj = DirectCast(checkQ, Object)
For j = i1 To outLoop
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
objCHKD = CType(obj, CheckBox).Checked
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Dim chkB As CheckBox = CType(obj, CheckBox)
objCHKD = chkB.Checked
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
Next
Code:
'one or two lines doesn't matter
' 1073 ' 1084 ' 1071 ' 1071 ' 1070 ' 1071 ' 5106 ' 1083 ' 1070 ' 1070 ' 1070 ' 1071 ' 1070 ' 1070 ' 1070 ' 1071 ' 1071 ' 1071 ' 1071 ' 1071 ' 1070 ' 1071 ' 1071 ' 1070 ' 1071
' 1356 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1350 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1352 ' 1738 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351
' 1356 ' 1351 ' 1350 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1887 ' 1351 ' 1351 ' 1350 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1350
' 361 ' 364 ' 358 ' 359 ' 359 ' 359 ' 358 ' 359 ' 359 ' 359 ' 358 ' 359 ' 359 ' 359 ' 359 ' 359 ' 358 ' 359 ' 358 ' 359 ' 358 ' 359 ' 359 ' 359 ' 359
' 1356 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1352 ' 1351 ' 1350 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1896 ' 1351 ' 1352 ' 1351 ' 1350 ' 1352 ' 1351 ' 1351 ' 1351 ' 1351
' 1357 ' 1350 ' 1786 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1352 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1352 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1352
' 361 ' 364 ' 359 ' 359 ' 358 ' 359 ' 359 ' 359 ' 358 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 358 ' 358 ' 359 ' 358 ' 359 ' 359 ' 359 ' 360 ' 359
' 1356 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1350 ' 1351 ' 1350 ' 1350 ' 1351 ' 1351 ' 1351 ' 1938 ' 1351 ' 1350
' 1357 ' 1350 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1350 ' 1351 ' 1352 ' 1351 ' 1351 ' 1351 ' 1351 ' 1351 ' 1350 ' 1351 ' 1351 ' 1351 ' 1351 ' 1713
-
Re: One Line or Two Lines?
Care to comment that? I'm not quite sure what I am looking at.
By the way, in ASM, adding is almost certainly more than five times as fast as multiplying when it comes to integers (at least it was up through the Pentium I processor). However, the advantages of RISC subset instructions like Integer Add do not translate well to .NET.
@Pradeep: What he said doesn't account for the results I got, which did scale. However, if it was just an overhead issue, you could reduce the number of iterations on the loop, and get an increasing difference, as the overhead would become an increasingly large part of the difference.
-
Re: One Line or Two Lines?
Gad, that's painful to look at in the IL. However, those two should perform exactly the same because the IL that is generated is virtually identical. The only difference is that an intermediate is stored and loaded in adjacent lines. Since that's a non-operation, it is probably optimized out of there.
-
Re: One Line or Two Lines?
Code:
Dim checkQ As New CheckBox, obj As New Object, objName As String
Dim stpw As New Stopwatch, i, j, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 25000, tests As Integer = 25, outLoop As Integer = 3
Dim results As New List(Of Long), y As Long
obj = DirectCast(checkQ, Object)
For j = i1 To outLoop
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
objName = CType(obj, CheckBox).Name
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Dim chkB As CheckBox = CType(obj, CheckBox)
objName = chkB.Name
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
Next
Code:
'what happens when strings are involved
' 1093 ' 1085 ' 1072 ' 1071 ' 1071 ' 1071 ' 1072 ' 1072 ' 1071 ' 1071 ' 1072 ' 1072 ' 2204 ' 1085 ' 1072 ' 1071 ' 1072 ' 1072 ' 1072 ' 1072 ' 1071 ' 1071 ' 1071 ' 1095 ' 1071
' 18029 ' 18937 ' 17962 ' 11250 ' 5996 ' 5993 ' 5991 ' 5991 ' 6750 ' 5989 ' 5996 ' 5995 ' 5990 ' 5989 ' 6201 ' 5989 ' 5993 ' 5990 ' 5995 ' 5991 ' 6313 ' 5998 ' 5992 ' 5996 ' 5995
' 5986 ' 6542 ' 5964 ' 5965 ' 5965 ' 5964 ' 5965 ' 6278 ' 5965 ' 5965 ' 5965 ' 5964 ' 5965 ' 6245 ' 5965 ' 5965 ' 5965 ' 5965 ' 5965 ' 6358 ' 5965 ' 5965 ' 5965 ' 5965 ' 5966
' 367 ' 364 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 360 ' 359
' 6018 ' 5991 ' 6576 ' 5994 ' 5993 ' 5987 ' 5994 ' 5988 ' 6212 ' 5992 ' 5995 ' 5986 ' 5998 ' 5991 ' 6373 ' 5991 ' 5988 ' 6001 ' 5993 ' 6239 ' 5987 ' 5987 ' 5992 ' 5986 ' 5987
' 5989 ' 5964 ' 5965 ' 6349 ' 5964 ' 5965 ' 5965 ' 5965 ' 5966 ' 6471 ' 5964 ' 5965 ' 5965 ' 5965 ' 5965 ' 6246 ' 5965 ' 5965 ' 5965 ' 5964 ' 5964 ' 6303 ' 5965 ' 5965 ' 5965
' 371 ' 364 ' 359 ' 360 ' 1113 ' 364 ' 362 ' 360 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 360 ' 359 ' 359 ' 359 ' 359 ' 359 ' 359 ' 360 ' 359
' 6649 ' 5996 ' 5992 ' 5993 ' 5993 ' 6386 ' 5989 ' 5994 ' 5991 ' 5990 ' 5995 ' 6512 ' 5994 ' 5989 ' 5996 ' 5990 ' 5989 ' 6238 ' 5996 ' 5996 ' 5989 ' 5991 ' 5993 ' 6172 ' 5993
' 6688 ' 5965 ' 5965 ' 5964 ' 5965 ' 5965 ' 6261 ' 5965 ' 5965 ' 5965 ' 5965 ' 5965 ' 6377 ' 5964 ' 5965 ' 5965 ' 5965 ' 5965 ' 6195 ' 5964 ' 5965 ' 5965 ' 5965 ' 5965 ' 6263
-
Re: One Line or Two Lines?
Code:
Dim Tc, Tf As Double 'declare Tc and Tf
Dim stpw As New Stopwatch, i, j, z As Integer
Const i1 As Integer = 1, iLoop As Integer = 25000, tests As Integer = 25, outLoop As Integer = 3
Dim results As New List(Of Long), y As Long
Tf = 212 'assume we know Fahrenheit
For j = i1 To outLoop
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Tc = (5 / 9) * (Tf - 32)
Tf = (9 / 5) * Tc + 32
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
results.Clear()
For z = i1 To tests
stpw.Start()
For i = i1 To iLoop
Tc = (Tf - 32) / 1.8
Tf = (1.8 * Tc) + 32
Next
stpw.Stop()
results.Add(stpw.ElapsedTicks)
stpw.Reset()
Next
For i = 0 To results.Count - 1
Debug.Write(" ' " & results(i).ToString.PadRight(5, " "c))
Next
Debug.WriteLine("")
Next
Code:
'which is faster conversion Celsius/Fahrenheit
' 906 ' 905 ' 908 ' 919 ' 933 ' 913 ' 906 ' 920 ' 907 ' 914 ' 929 ' 905 ' 909 ' 908 ' 920 ' 908 ' 914 ' 2358 ' 906 ' 920 ' 906 ' 907 ' 909 ' 908 ' 905
' 1803 ' 1799 ' 1800 ' 1800 ' 1800 ' 2670 ' 1800 ' 1799 ' 1799 ' 1799 ' 1799 ' 1799 ' 1799 ' 1800 ' 1799 ' 1799 ' 1799 ' 1800 ' 1800 ' 1799 ' 1800 ' 1800 ' 1799 ' 1800 ' 2084
' 3192 ' 3146 ' 3146 ' 3146 ' 3146 ' 3147 ' 3146 ' 3146 ' 3656 ' 3146 ' 3146 ' 3146 ' 3147 ' 3147 ' 3327 ' 3146 ' 3147 ' 3392 ' 3146 ' 3405 ' 3146 ' 3146 ' 3147 ' 3146 ' 3146
' 305 ' 303 ' 305 ' 318 ' 307 ' 314 ' 305 ' 312 ' 306 ' 309 ' 322 ' 306 ' 310 ' 311 ' 306 ' 311 ' 314 ' 308 ' 316 ' 315 ' 318 ' 318 ' 309 ' 318 ' 313
' 1804 ' 1800 ' 1800 ' 1800 ' 1799 ' 1801 ' 1799 ' 1799 ' 1799 ' 2460 ' 1800 ' 1799 ' 1799 ' 1799 ' 1799 ' 1801 ' 1800 ' 1799 ' 1799 ' 1799 ' 1799 ' 1799 ' 1800 ' 1800 ' 1800
' 3187 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3536 ' 3146 ' 3147 ' 3406 ' 3147 ' 3358 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3464 ' 3146 ' 3146 ' 3146 ' 3146
' 306 ' 303 ' 311 ' 518 ' 309 ' 305 ' 307 ' 304 ' 318 ' 322 ' 304 ' 308 ' 304 ' 307 ' 304 ' 316 ' 319 ' 311 ' 307 ' 309 ' 316 ' 317 ' 317 ' 315 ' 314
' 1803 ' 1800 ' 1799 ' 1799 ' 1800 ' 1800 ' 1799 ' 1799 ' 1800 ' 1800 ' 1800 ' 1799 ' 1800 ' 1800 ' 1799 ' 2388 ' 1799 ' 1799 ' 1800 ' 1800 ' 1799 ' 1800 ' 1799 ' 1800 ' 1799
' 3200 ' 3347 ' 3146 ' 3859 ' 3360 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3677 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3146 ' 3147 ' 3146 ' 3146 ' 3146
i actually though the second method would be faster.
-
Re: One Line or Two Lines?
Why? They are the same as far as I can see. The 5/9, since it involves no variables, will be converted to a single value at compile time, so that equation becomes a constant.
-
Re: One Line or Two Lines?
if i get rid of these two lines
Tc = (5 / 9) * (Tf - 32)
Tc = (Tf - 32) / 1.8
the results are the same
-
Re: One Line or Two Lines?
You have me confused. Does that mean that these two lines:
Tf = (9 / 5) * Tc + 32
Tf = (1.8 * Tc) + 32
Take the same amount of time? They should, since there is no difference between them. 9/5 will be evaluated to 1.8 at compile time, rather than run time, so the generated code will be identical.
-
Re: One Line or Two Lines?
-
Re: One Line or Two Lines?
big duh on me, it was the division
Tc = (Tf - 32) * 0.55555555555555558
instead of
Tc = (Tf - 32) / 1.8
