|
Yes, so how long does it take?
|
|
|
|
|
PIEBALDconsult wrote: Yes, so how long does it take?
Computer: Intel Core I5
.NET 6.0:
Elapsed Time for [String.Replace]: 17.1540338 sec
Elapsed Time for [String.IndexOf]: 32.473905 sec
Elapsed Time for [String.SubString]: 11.9497695 sec
Elapsed Time for [String.Remove]: 9.2207969 sec
.NET 4.8
Elapsed Time for [String.Replace]: 47.532167 sec
Elapsed Time for [String.IndexOf]: 2.3447133 sec
Elapsed Time for [String.SubString]: 12.1748157 sec
Elapsed Time for [String.Remove]: 11.4768551 sec
modified 4-Jun-22 11:46am.
|
|
|
|
|
Hi,
Can you run the String.IndexOf benchmark again using StringComparison.Ordinal and post the result?
|
|
|
|
|
Randor wrote: Can you run the String.IndexOf benchmark again using StringComparison.Ordinal and post the result?
Thanks, it is the solution:
Now .NET 6.0 is 2X times FASTER than .NET Framework 4.8
Starting tests for .NET Framework 3.5, wait...
Elapsed Time for [String.Replace]: 51,0830947 sec
Elapsed Time for [String.IndexOf]: 0,5451713 sec
Elapsed Time for [String.Contains]: 0,5424978 sec
Elapsed Time for [String.SubString]: 17,7345287 sec
Elapsed Time for [String.Remove]: 15,021131 sec
Elapsed Time for [.NET 3.5]: 84,9272387 sec
Starting tests for .NET Framework 4.8, wait...
Elapsed Time for [String.Replace]: 53,2363039 sec
Elapsed Time for [String.IndexOf]: 0,5760411 sec
Elapsed Time for [String.Contains]: 0,595356 sec
Elapsed Time for [String.SubString]: 14,8117435 sec
Elapsed Time for [String.Remove]: 11,2053769 sec
Elapsed Time for [.NET 4.8]: 80,4258634 sec
Starting tests for .NET 6.0, wait...
Elapsed Time for [String.Replace]: 18,5094685 sec
Elapsed Time for [String.IndexOf]: 0,3495122 sec
Elapsed Time for [String.Contains]: 0,32621 sec
Elapsed Time for [String.SubString]: 12,1062252 sec
Elapsed Time for [String.Remove]: 10,1427749 sec
Elapsed Time for [.NET 6.0]: 41,4367067 sec
|
|
|
|
|
Yep,
Nobody even noticed my post. 
Thanks for running the benchmark, I suspected it would be faster.
|
|
|
|
|
It's advisable to use a real benchmarking framework when you want to benchmark operations.
|
|
|
|
|
Pete O'Hanlon wrote: It's advisable to use a real benchmarking framework
Not in this case, StopWatch is sufficient.
|
|
|
|
|
georani wrote: Not in this case, StopWatch is sufficient.
Benchmark.NET makes sure that code is warmed up properly, eliminating simple things like tiered compilation whose defaults may have changed between .NET versions, for example. It also makes it fairly trivial to compare different runtimes: it is, after all, the tool that Microsoft itself uses for comparison of runtimes (to consciously decide when performance regressions are acceptable).
|
|
|
|
|
Does it really matter in real world applications ? it never has in one's I've been involved in
Life should not be a journey to the grave with the intention of arriving safely in a pretty and well-preserved body, but rather to skid in broadside in a cloud of smoke, thoroughly used up, totally worn out, and loudly proclaiming “Wow! What a Ride!" - Hunter S Thompson - RIP
|
|
|
|
|
pkfox wrote: Does it really matter in real world applications ?
Yes, my application become unusable after porting it to .NET 6, it uses a lot of string.IndexOf functions.
|
|
|
|
|
|
They probably fixed it make it theoretically faster to find a random string inside another random string which makes it worse for most common usage.
Is it possible that they are creating more objects with the new library to enable simpler garbage collection across multiple/asynchronous threads? There might be different design goals at play.
There was an interesting article I read years ago about some of the algorithms used for string functions in the early BASIC releases.
|
|
|
|
|
You didn't / should be using / comparing StringBuilder.
"Before entering on an understanding, I have meditated for a long time, and have foreseen what might happen. It is not genius which reveals to me suddenly, secretly, what I have to say or to do in a circumstance unexpected by other people; it is reflection, it is meditation." - Napoleon I
|
|
|
|
|
|
That doesn't mean you exclude it.
For that matter, if the string is already loaded in a StringBuilder, then use (SB instance).ToString().IndexOf()
"Before entering on an understanding, I have meditated for a long time, and have foreseen what might happen. It is not genius which reveals to me suddenly, secretly, what I have to say or to do in a circumstance unexpected by other people; it is reflection, it is meditation." - Napoleon I
|
|
|
|
|
|
Eddy Vluggen wrote: Note the #1 in all tests.
Thank you. I will test it it.
And C Language seems to be a great choice. Or Golang. Or Rust.
|
|
|
|
|
C because it close to assembly. Golang or rust aren't competing there.
If it is a core function of what you do, then it'd make sense; eliminate the dependency.
Bastard Programmer from Hell 
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
|
|
|
|
|
Machine code generated from Rust usually levels with C in terms of raw performance, often outperforming it
|
|
|
|
|
Sure.
Bastard Programmer from Hell
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
|
|
|
|
|
I'd be interested to learn why "rust isn't competing here".
|
|
|
|
|
It's a LLVM.
Running in a fictional machine.
On top of a real machine. 
Bastard Programmer from Hell
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.
|
|
|
|
|
LLVM is not a VM, but a (native) language compiler.
Rust compiles to native code just as C and C++ do, and it uses LLVM as the compiler back-end.
Rust will frequently be faster that C or C++ for implementing the same algorithm, and sometimes a bit slower.
|
|
|
|
|
You got a really weird number at String.IndexOf. Here are my results:
Elapsed Time for [String.Replace]: 16,8695848 sec
Elapsed Time for [String.IndexOf]: 2,0153508 sec
Elapsed Time for [String.SubString]: 11,7445885 sec
Elapsed Time for [String.Remove]: 10,1579051 sec
.NET 6 is 1.7x up to 2.9x faster.
I think these numbers are pretty consistent.
|
|
|
|
|
Prior to .NET 5, culture-specific comparisons used NLS[^] on Windows. Since .NET 5, they switched to using ICU[^] instead.
Globalization and ICU | Microsoft Docs[^]
There is a config switch to force .NET to use NLS instead, but it's not recommended:
Breaking change with string.IndexOf(string) from .NET Core 3.0 -> .NET 5.0[^]
If you change your IndexOf call to specify StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase, the .NET 6 code is roughly 1.5x faster than the .NET Framework 4.8 equivalent.
"These people looked deep within my soul and assigned me a number based on the order in which I joined."
- Homer
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
