A Fast CSV Reader
A reader that provides fast, non-cached, forward-only access to CSV data.
Share The Load: Report Visual Studio Team System Load Test Results Via A Configurable Web Site
This article discusses a new load test tool in Visual Studio 2005 Team System for performance and stress testing your Web sites, Web services, and other server components. Combined with its handy reporting capabilities, the load test tool provides some powerful options for sharing and managing test results.
Concurrent Affairs: Reader/Writer Locks
The Microsoft .NET Framework Class Library includes a ReaderWriterLock class in the System.Threading namespace. This month Jeffrey Richter explains when to use it and how you can get better threading performance.
.NET Offers a "First Chance" to Squelch Performance-killing Hidden Exceptions
Uncaught exceptions in your .NET applications can turn an otherwise high-performance application into a snail, especially those that are allowed to be "eaten" by subsequent code. Find out how to use very handy "First Chance" exception feature in the .NET debugger to root out nasty hidden exceptions.
Cache In On the Enterprise Library Caching Block for .NET 2.0
Nearly every application needs to cache data. While you're probably familiar wth the caching functionality built into ASP.NET, the Enterprise Library Caching Block provides in-memory, file-based, or database caching storage for all your other .NET applications.
CLR Inside Out: The performance benefits of NGen.
JIT compilation has its advantages, but it has its drawbacks, too. NGen may help to improve the performance of your applications. Surupa Biswas shows you why and when.
TraceTool 6: The Swiss-Army knife of trace
A C#, C++, Delphi, and Java trace framework and a trace viewer: Tail, outputDebugString, event log, and with Log4J, Log4Net, and Microsoft Enterprise Instrumentation Framework (EIF) support. This comes with full support for Pocket PC development.
NTime - Performance unit testing tool
An article on a performance testing tool to test an application against its performance.
Performance Quiz #9 : IList List and array speed -- solution
In the test case as given there's a great deal of repeated work extracting the length of the array and accessing the items. This is because of the unusual property that arrays have -- they implement IList for potetially more than one T even due to inheritance. In the interest of economy alone then it is worthwhile to consolidate the IList implementations into some kind of secret helper but this has some consequences.
Short results:
| Test Case |
Milliseconds |
| Test1: Array |
54 |
| Test2: List<> |
8 |
| Test3: ArrayWrapper |
14 |
| Test4: Array via foreach |
9 |
| Test5: List<> via foreach |
11 |
| Test6: Array via special |
6 |
| Test7: List<> via special |
8 |
Performance Quiz #9 : IList<T> List and array speed
A short and sweet quiz with lots of juicy discussion possibilities:
public int Sum(IList<ushort> indices)
{
int result = 0;
for (int i = 0; i < indices.Count; i++)
result += indices[i];
return result;
}
Considering only the time it takes to do the Sum (i.e. assuming we had already set up the array/list) which gives better performance and why?
// #1
ushort[] tmp = new ushort[500000]; // this doesn't count
Sum(tmp);// this is what we are timing
OR
// #2
List<ushort> tmp = new List<ushort>(500000); // this doesn't count
for (int i = 0; i < 500000; i++)tmp.Add(0); // this doesn't count
Sum(tmp); // this is what we are timing
What say you gentle readers?
