Developing high performance applications with.NET Compact Framework Deepak Gulati ISV Developer Evangelist Microsoft

Developing high Developing high performance applications performance applications with .NET Compact with .NET Compact FrameworkFramework

Deepak GulatiDeepak GulatiISV Developer EvangelistISV Developer EvangelistMicrosoftMicrosoft

MManagementanagementTToolsools

CCommunicationsommunications& & MMessagingessaging

Device Update Agent

Software Update Services

Live Communications Server

Exchange Server

Internet Security and Acceleration Server

Speech Server

Image Update

LLocation ocation SServiceservices

MMultimediaultimedia

MapPoint

DirectX

Windows Media

Visual Studio 2005DDevelopment evelopment TToolsools

MFC 8.0, ATL 8.0

Win32NNativeative

MManagedanaged

SServer erver SSideide

LLightweightightweight

RRelationalelationalSQL Server 2005 Express EditionEDB

DDa

taata

PPro

gra

mm

ing

ro

gra

mm

ing

MM

od

el

od

el

DDevice evice BBuilding uilding TToolsools

HHardware/ardware/DDriversrivers

Windows XP DDK

Windows Embedded Studio

Platform Builder

OEM/IHV SuppliedBSP

(ARM, SH4, MIPS)OEM Hardware and Standard Drivers

Standard PC Hardware and Drivers

SQL Server 2005SQL Server 2005 Mobile Edition

ASP.NET Mobile Controls ASP.NET

.NET Compact Framework .NET Framework

Microsoft Operations Manager

Systems Management Server

Measuring PerformanceMeasuring PerformanceOverviewOverview

Basic technique involves:Basic technique involves:Find start timeFind start time

Find end timeFind end time

Calculate deltaCalculate delta


Start and End times can be measured Start and End times can be measured in various waysin various ways

GetTickCount, a Win32 API function GetTickCount, a Win32 API function

Environment.TickCount is its managed Environment.TickCount is its managed code equivalentcode equivalent

Both return int that represents time in ms that Both return int that represents time in ms that has passed since the device was bootedhas passed since the device was booted

Can also use System.DateTime and get Can also use System.DateTime and get System.TimeSpan by subtracting Start System.TimeSpan by subtracting Start and End valuesand End values


There can be issues with these There can be issues with these techniques:techniques:

For a device that has been on for a long For a device that has been on for a long time, TickCount clips and goes negativetime, TickCount clips and goes negative

Not great for measuring ‘short’ operations, Not great for measuring ‘short’ operations, there can be a variation of upto 500 ms there can be a variation of upto 500 ms

System.Date also suffers from accuracy System.Date also suffers from accuracy issuesissues


QueryPerformanceCounter/QueryPerformanceCounter/QueryPerformanceFrequency to the QueryPerformanceFrequency to the rescue!rescue!

High resolution timer – OEM specific High resolution timer – OEM specific implementationimplementation

Defaults to GetTickCount if not availableDefaults to GetTickCount if not available


No managed implementation available for No managed implementation available for QueryPerformanceCounter or FrequencyQueryPerformanceCounter or Frequency

PInvoke QueryPerformanceFrequency and PInvoke QueryPerformanceFrequency and get the clock frequency of the device/sec. get the clock frequency of the device/sec. Divide by 1000 to get the clock frequency/msDivide by 1000 to get the clock frequency/ms

PInvoke QueryPerformanceCounter before PInvoke QueryPerformanceCounter before your call. Make your call. PInvoke your call. Make your call. PInvoke QueryPerformanceCounter againQueryPerformanceCounter again

End – Start / frequency/ms will give you time End – Start / frequency/ms will give you time for your call in msfor your call in ms

DemoDemoUsing QueryPerformanceCounterUsing QueryPerformanceCounter


Micro-benchmarks versus ScenariosMicro-benchmarks versus Scenarios

Benchmarking tipsBenchmarking tipsStart from known stateStart from known state

Ensure nothing else is runningEnsure nothing else is running

Measure multiple times, take averageMeasure multiple times, take average

Run each test in own AppDomain / ProcessRun each test in own AppDomain / Process

Log results at the endLog results at the end

Understand JIT-time versus runtime costUnderstand JIT-time versus runtime cost

.NET Compact Framework.NET Compact Framework

.NET Compact Framework Performance v1->v2.NET Compact Framework Performance v1->v2

(Pocket PC 2003, XScale 400MHz)(Pocket PC 2003, XScale 400MHz) 1.01.0 1.0 SP31.0 SP3V2 V2

Beta1Beta1V2 B2+V2 B2+

Method Calls (Calls/sec) 3.7M 7.1M 8.1M

Virtual Calls (Calls/sec) 2.4M 2.7M 5.6M

Simple P/Invoke (Calls/sec) 733K 1.7M

Primes (to 1500) (iterations/sec) 562 832 853

GC Small (8 bytes) (Bytes/sec) 1M 7M 7.5M

GC Array (100 int’s) (Bytes/sec) 25M 43M 112M

XML Text Reader 200KB (seconds) 1.7 1.2 0.72 0.69

DataSet (static data)4 tables, 1000 records (seconds) 13.1 6.6 7.3 3.3

DataSet (ReadXml)3 tables, 100 records (seconds) 12.3 6.5 5.2 4.4

BiggerBiggeris betteris better

SmallerSmalleris betteris better

Measuring PerformanceMeasuring PerformancePerformance CountersPerformance Counters

There will be times when an application runs slow and the code There will be times when an application runs slow and the code looks finelooks fine.NET CompactFramework can be made to report performance .NET CompactFramework can be made to report performance statisticsstatistics

<My App>.stat (formerly mscoree.stat)<My App>.stat (formerly mscoree.stat)http://msdn.microsoft.com/library/en-us/dnnetcomp/html/netcfperf.aspRegistryRegistry

HKLM\SOFTWARE\Microsoft\.NETCompactFramework\PerfMonitorHKLM\SOFTWARE\Microsoft\.NETCompactFramework\PerfMonitorCounters (DWORD) = 1Counters (DWORD) = 1

What does .stat tell you?What does .stat tell you?Working set and performance statisticsWorking set and performance statistics

More counters added in v2More counters added in v2Generics usageGenerics usageCOM interop usageCOM interop usageNumber of boxed valuetypesNumber of boxed valuetypesThreading and timersThreading and timersGUI objectsGUI objectsNetwork activity (socket bytes send/received)Network activity (socket bytes send/received)

http://msdn.microsoft.com/library/en-us/dnnetcomp/html/netcfperf.asp

http://msdn.microsoft.com/library/en-us/dnnetcomp/html/netcfperf.asp

DemoDemoEnabling .NET Compact Framework Enabling .NET Compact Framework Performance StatisticsPerformance Statistics

.stat.statcounter total last datum n mean min maxTotal Program Run Time (ms) 55937 - - - - -App Domains Created 18 - - - - -App Domains Unloaded 18 - - - - -Assemblies Loaded 323 - - - - -Classes Loaded 18852 - - - - -Methods Loaded 37353 - - - - -Closed Types Loaded 730 - - - - -Closed Types Loaded per Definition 730 8 385 1 1 8Open Types Loaded 78 - - - - -Closed Methods Loaded 46 - - - - -Closed Methods Loaded per Definition 46 1 40 1 1 2Open Methods Loaded 0 - - - - -Threads in Thread Pool - 0 6 1 0 3Pending Timers - 0 93 0 0 1Scheduled Timers 46 - - - - -Timers Delayed by Thread Pool Limit 0 - - - - -Work Items Queued 46 - - - - -Uncontested Monitor.Enter Calls 57240 - - - - -Contested Monitor.Enter Calls 0 - - - - -Peak Bytes Allocated (native + managed) 4024363 - - - - -Managed Objects Allocated 1015100 - - - - -Managed Bytes Allocated 37291444 28 1015100 36 8 55588Managed String Objects Allocated 112108 - - - - -Bytes of String Objects Allocated 4596658 - - - - -Garbage Collections (GC) 33 - - - - -Bytes Collected By GC 25573036 41592 33 774940 41592 1096328Managed Bytes In Use After GC - 23528 33 259414 23176 924612Total Bytes In Use After GC - 3091342 33 2954574 1833928 3988607GC Compactions 17 - - - - -Code Pitchings 6 - - - - -Calls to GC.Collect 0 - - - - -GC Latency Time (ms) 279 16 33 8 0 31Pinned Objects 156 - - - - -Objects Moved by Compactor 73760 - - - - -Objects Not Moved by Compactor 11811 - - - - -Objects Finalized 6383 - - - - -Boxed Value Types 350829 - - - - -Process Heap - 1626 430814 511970 952 962130Short Term Heap - 0 178228 718 0 21532JIT Heap - 0 88135 357796 0 651663App Domain Heap - 0 741720 647240 0 833370GC Heap - 0 376 855105 0 2097152Native Bytes Jitted 7202214 152 26910 267 80 5448Methods Jitted 26910 - - - - -Bytes Pitched 1673873 0 7047 237 0 5448

Peak Bytes Allocated (native + managed)

JIT Heap App Domain Heap GC Heap

GC Latency Time (ms)

Garbage Collections (GC)

Managed String Objects Allocated

Boxed Value Types

.NET Compact Framework.NET Compact FrameworkHow we are different?How we are different?

Portable JIT CompilerPortable JIT CompilerFast code generation, less optimizedFast code generation, less optimized

May pitch JIT-compiled code under May pitch JIT-compiled code under memory pressurememory pressure

No NGen, install time or persisted codeNo NGen, install time or persisted code

Interpreted virtual calls (no v-tables)Interpreted virtual calls (no v-tables)

Simple mark and sweep GC, Simple mark and sweep GC, non generationalnon generational

Common Language RuntimeCommon Language RuntimeExecution EngineExecution Engine

Call pathCall pathManaged calls are more expensive than nativeManaged calls are more expensive than native

Instance call: ~2-3X the cost of a native function callInstance call: ~2-3X the cost of a native function callVirtual call: ~1.4X the cost of a managed instance callVirtual call: ~1.4X the cost of a managed instance callPlatform invoke: ~5X the cost of managed instance call Platform invoke: ~5X the cost of managed instance call (*Marshal int parameter)(*Marshal int parameter)

Properties are callsProperties are calls

JIT compilersJIT compilersAll platforms has the same optimizing JIT compiler All platforms has the same optimizing JIT compiler architecture in v2architecture in v2OptimizationsOptimizations

Method inlining for simple methodsMethod inlining for simple methodsVariable enregistration Variable enregistration

Common Language RuntimeCommon Language Runtime Call path (sample) Call path (sample)public class Shape public class Shape

{{

protected int m_volume; protected int m_volume;

public public virtualvirtual int Volume int Volume

{ {

get {return m_volume;}get {return m_volume;}

}}

}}

public class Cube:Shape public class Cube:Shape

{{

public MyType(int vol) public MyType(int vol)

{ {

m_volume = vol;m_volume = vol;

}}

}}

public class Shape public class Shape

{{


public int Volume public int Volume

{ {


}}

}}


{{


{ {


}}

}}

Common Language RuntimeCommon Language Runtime Call path (sample) Call path (sample) public class MyCollectionpublic class MyCollection

{{private const int m_capacity = 10000;private const int m_capacity = 10000;private Shape[] storage = new Shape[m_capacity];private Shape[] storage = new Shape[m_capacity];……public void Sort()public void Sort(){{

Shape tmp;Shape tmp; for (int i=0; i<m_capacity-1; i++) {for (int i=0; i<m_capacity-1; i++) {

for (int j=0; j<m_capacity-1-i; j++)for (int j=0; j<m_capacity-1-i; j++) if (if (storage[j+1].Volumestorage[j+1].Volume < < storage[j].Volumestorage[j].Volume){ ){

tmp = storage[j]; tmp = storage[j]; storage[j] = storage[j+1];storage[j] = storage[j+1];storage[j+1] = tmp;storage[j+1] = tmp;

}} }}}}

}}

callvirt instance int32 Shape::get_Volume()

Common Language RuntimeCommon Language Runtime Call path (sample) Call path (sample)


{{


public public virtualvirtual int Volume int Volume

{ {


}}

}}


{{


{ {


}}

}}


{{


public int Volume public int Volume

{ {


}}

}}


{{


{ {


}}

}}

•No virtual call overheadNo virtual call overhead

•Inlined (no call overhead at all)Inlined (no call overhead at all)

~ Equal to accessing field~ Equal to accessing field

57 sec57 sec 39 sec39 sec

Common Language RuntimeCommon Language RuntimeGarbage CollectorGarbage Collector

What triggers a GC?What triggers a GC?Memory allocation failureMemory allocation failure1M of GC objects allocated (v2)1M of GC objects allocated (v2)Application going to backgroundApplication going to backgroundGC.Collect() (Avoid “helping” the GC!)GC.Collect() (Avoid “helping” the GC!)

What happens at GC time?What happens at GC time?Freezes all threads at safe pointFreezes all threads at safe pointFinds all live objects and marks themFinds all live objects and marks them

An object is live if it is reachable from root locationAn object is live if it is reachable from root locationUnmarked objects are freed and added to finalizer queueUnmarked objects are freed and added to finalizer queue

Finalizers are run on a separate threadFinalizers are run on a separate threadGC pools are compacted if required (less than 750K of GC pools are compacted if required (less than 750K of free space)free space)Return free memory to the operating systemReturn free memory to the operating system

In general, if you don’t allocate objects, In general, if you don’t allocate objects, GC won’t occurGC won’t occur

Beware of side-effects of calls that may allocate objectsBeware of side-effects of calls that may allocate objects

http://blogs.msdn.com/stevenpr/archive/2004/07/26/197254.aspxhttp://blogs.msdn.com/stevenpr/archive/2004/07/26/197254.aspx

http://blogs.msdn.com/stevenpr/archive/2004/07/26/197254.aspx


0

10

20

30

40

50

60

70

80

90

0 100000 300000 500000

Number of Live Objects

GC

late

nc

y (

ms

)

GC Latency per collection


0

20000

40000

60000

80000

100000

120000

140000

160000

400 4000 20000 40000 80000

Object size (bytes)

Allo

cati

on

rate

ite

r/sec

Allocation rate


0

10

20

30

40

50

60

70

80

90

8 400 4000 20000 40000 80000

Object size (bytes)

Allo

cati

on

th

rou

gh

pu

t M

b/s

ec

Allocation throughput

Common Language RuntimeCommon Language RuntimeWhere garbage comes from?Where garbage comes from?

Unnecessary string copiesUnnecessary string copiesStrings are immutable Strings are immutable

String manipulations (Concat(), etc.) String manipulations (Concat(), etc.) cause copies cause copies

Use StringBuilderUse StringBuilder

String result = "";String result = "";

for (int i=0; i<10000; i++) {for (int i=0; i<10000; i++) {

result += result +=

".NET Compact Framework";".NET Compact Framework";

result += " Rocks!";result += " Rocks!";

} }

StringBuilder result = StringBuilder result =

new StringBuilder();new StringBuilder();

for (int i=0; i<10000; i++){for (int i=0; i<10000; i++){

result.Append(".NET Compact result.Append(".NET Compact Framework");Framework");

result.Append(" Rocks!");result.Append(" Rocks!");

}}

.stat.statcounter total last datum n mean min maxTotal Program Run Time (ms) 11843 - - - - -App Domains Created 1 - - - - -App Domains Unloaded 1 - - - - -Assemblies Loaded 2 - - - - -Classes Loaded 175 - - - - -Methods Loaded 198 - - - - -Closed Types Loaded 0 - - - - -Closed Types Loaded per Definition 0 0 0 0 0 0Open Types Loaded 0 - - - - -Closed Methods Loaded 0 - - - - -Closed Methods Loaded per Definition 0 0 0 0 0 0Open Methods Loaded 0 - - - - -Threads in Thread Pool - 0 2 0 0 1Pending Timers - 0 2 0 0 1Scheduled Timers 1 - - - - -Timers Delayed by Thread Pool Limit 0 - - - - -Work Items Queued 1 - - - - -Uncontested Monitor.Enter Calls 2 - - - - -Contested Monitor.Enter Calls 0 - - - - -Peak Bytes Allocated (native + managed) 3326004 - - - - -Managed Objects Allocated 60266 - - - - -Managed Bytes Allocated 5801679432 28 60266 96267 8 580020Managed String Objects Allocated 20041 - - - - -Bytes of String Objects Allocated 5800480578 - - - - -Garbage Collections (GC) 4912 - - - - -Bytes Collected By GC 5918699036 1160076 4912 1204946 597824 1572512Managed Bytes In Use After GC - 580752 4912 381831 8364 580752Total Bytes In Use After GC - 1810560 4912 1611885 1097856 1810560GC Compactions 0 - - - - -Code Pitchings 0 - - - - -Calls to GC.Collect 0 - - - - -GC Latency Time (ms) 686 0 4912 0 0 16Pinned Objects 0 - - - - -Objects Moved by Compactor 0 - - - - -Objects Not Moved by Compactor 0 - - - - -Objects Finalized 1 - - - - -Boxed Value Types 3 - - - - -Process Heap - 278 235 2352 68 8733Short Term Heap - 0 278 986 0 10424JIT Heap - 0 360 12103 0 24444App Domain Heap - 0 1341 46799 0 64562GC Heap - 0 35524 2095727 0 3276800Native Bytes Jitted 22427 140 98 228 68 1367Methods Jitted 98 - - - - -Bytes Pitched 0 0 0 0 0 0Methods Pitched 0 - - - - -Method Pitch Latency Time (ms) 0 0 0 0 0 0Exceptions Thrown 0 - - - - -Platform Invoke Calls 0 - - - - -

Managed String Objects Allocated 20040Garbage Collections (GC) 4912Bytes of String Objects Allocate 5,800,480,574Bytes Collected By GC 5,918,699,036GC latency 107128 ms

String result = "";for (int i=0; i<10000; i++) { result += ".NET Compact Framework"; result += " Rocks!";}

Run time 173 secRun time 173 sec

counter total last datum n mean min maxTotal Program Run Time (ms) 11843 - - - - -App Domains Created 1 - - - - -App Domains Unloaded 1 - - - - -Assemblies Loaded 2 - - - - -Classes Loaded 175 - - - - -Methods Loaded 198 - - - - -Closed Types Loaded 0 - - - - -Closed Types Loaded per Definition 0 0 0 0 0 0Open Types Loaded 0 - - - - -Closed Methods Loaded 0 - - - - -Closed Methods Loaded per Definition 0 0 0 0 0 0Open Methods Loaded 0 - - - - -Threads in Thread Pool - 0 2 0 0 1Pending Timers - 0 2 0 0 1Scheduled Timers 1 - - - - -Timers Delayed by Thread Pool Limit 0 - - - - -Work Items Queued 1 - - - - -Uncontested Monitor.Enter Calls 2 - - - - -Contested Monitor.Enter Calls 0 - - - - -Peak Bytes Allocated (native + managed) 3326004 - - - - -Managed Objects Allocated 60266 - - - - -Managed Bytes Allocated 5801679432 28 60266 96267 8 580020Managed String Objects Allocated 20041 - - - - -Bytes of String Objects Allocated 5800480578 - - - - -Garbage Collections (GC) 4912 - - - - -Bytes Collected By GC 5918699036 1160076 4912 1204946 597824 1572512Managed Bytes In Use After GC - 580752 4912 381831 8364 580752Total Bytes In Use After GC - 1810560 4912 1611885 1097856 1810560GC Compactions 0 - - - - -Code Pitchings 0 - - - - -Calls to GC.Collect 0 - - - - -GC Latency Time (ms) 686 0 4912 0 0 16Pinned Objects 0 - - - - -Objects Moved by Compactor 0 - - - - -Objects Not Moved by Compactor 0 - - - - -Objects Finalized 1 - - - - -Boxed Value Types 3 - - - - -Process Heap - 278 235 2352 68 8733Short Term Heap - 0 278 986 0 10424JIT Heap - 0 360 12103 0 24444App Domain Heap - 0 1341 46799 0 64562GC Heap - 0 35524 2095727 0 3276800Native Bytes Jitted 22427 140 98 228 68 1367Methods Jitted 98 - - - - -Bytes Pitched 0 0 0 0 0 0Methods Pitched 0 - - - - -Method Pitch Latency Time (ms) 0 0 0 0 0 0Exceptions Thrown 0 - - - - -Platform Invoke Calls 0 - - - - -

.stat.stat

Managed String Objects Allocated 56Bytes of String Objects Allocated 2097718Garbage Collections (GC) 2Bytes Collected By GC 1081620GC Latency 21 ms

StringBuilder result = new StringBuilder();for (int i=0; i<10000; i++){

result.Append(".NET Compact Framework");

result.Append(" Rocks!");}

Run time 0.1 secRun time 0.1 sec

Last notes on StringBuilderLast notes on StringBuilder

Remember it's all about reducing Remember it's all about reducing memory trafficmemory traffic

If you roughly know the expected If you roughly know the expected length of your final string – allocate length of your final string – allocate that much before hand (StringBuilder that much before hand (StringBuilder constructor)constructor)

Getting the string out of a StringBuilder Getting the string out of a StringBuilder doesn't cause a new alloc, the existing doesn't cause a new alloc, the existing buffer is converted into a stringbuffer is converted into a string

http://weblogs.asp.net/ricom/archive/2003/12/02/40778.aspx

http://weblogs.asp.net/ricom/archive/2003/12/02/40778.aspx

Common Language RuntimeCommon Language RuntimeWhere garbage comes from?Where garbage comes from?

Unnecessary boxingUnnecessary boxingValue types allocated on the stack Value types allocated on the stack (fast to allocate)(fast to allocate)Boxing causes a heap allocation and a copyBoxing causes a heap allocation and a copyUse strongly typed arrays and collectionsUse strongly typed arrays and collections(framework collections are (framework collections are NOTNOT strongly typed) strongly typed)class Hashtable {class Hashtable {

struct bucket {struct bucket {Object keyObject key;;Object valObject val; ;

} } bucket[] buckets;bucket[] buckets;

public public ObjectObject this[ this[Object keyObject key] { get; set; }] { get; set; }}}

DemoDemoString vs. StringBuilderString vs. StringBuilder

Common Language RuntimeCommon Language RuntimeGenericsGenerics

Fully specialized implementation in .NET Fully specialized implementation in .NET Compact Framework v2Compact Framework v2

ProsProsStrongly typedStrongly typed

No unnecessary boxing and type castsNo unnecessary boxing and type casts

Specialized code is more efficient than sharedSpecialized code is more efficient than shared

ConsConsInternal execution engine data structures and JIT-Internal execution engine data structures and JIT-compiled code aren’t sharedcompiled code aren’t shared

List<int>, List<string>, List<MyType>List<int>, List<string>, List<MyType>

http://blogs.msdn.com/romanbat/archive/2005/01/0http://blogs.msdn.com/romanbat/archive/2005/01/06/348114.aspx6/348114.aspx

http://blogs.msdn.com/romanbat/archive/2005/01/06/348114.aspx

http://blogs.msdn.com/romanbat/archive/2005/01/06/348114.aspx

Common Language RuntimeCommon Language RuntimeFinalization and DisposeFinalization and Dispose

Cost of finalizersCost of finalizersNon-deterministic cleanupNon-deterministic cleanupExtends lifetime of objectExtends lifetime of object

In general, rely on GC for automatic memory In general, rely on GC for automatic memory cleanupcleanupThe exceptions to the rule…The exceptions to the rule…

If your object contains an unmanaged resource If your object contains an unmanaged resource that the GC is unaware of, you that the GC is unaware of, you need need to implement a to implement a finalizerfinalizer

Also implement Also implement DisposeDispose pattern to release unmanaged pattern to release unmanaged resource in deterministic mannerresource in deterministic mannerDispose Dispose method should suppress finalizationmethod should suppress finalization

If the object you are using implements If the object you are using implements DisposeDispose, , call it when you are done with the objectcall it when you are done with the object

Assumes an unmanaged resource in the object chainAssumes an unmanaged resource in the object chain

Common Language RuntimeCommon Language RuntimeSample Code: Finalization and Dispose Sample Code: Finalization and Dispose class SerialPort : IDisposable { IntPtr SerialPortHandle;

public SerialPort(String name) { // Platform invoke to native code to open serial port SerialPortHandle = SerialOpen(name); }

~SerialPort() { // Platform invoke to native code to close serial port SerialClose(SerialPortHandle); }

public void Dispose() { // Platform invoke to native code to close serial port SerialClose(SerialPortHandle); GC.SuppressFinalize(this); }}

Common Language RuntimeCommon Language RuntimeSample Code: Finalization and DisposeSample Code: Finalization and Dispose

class SerialTrace : IDisposable { SerialPort serialPort;

public SerialTrace() { serialPort = new SerialPort(); }

public void Dispose() { serialPort.Dispose(); }}

Common Language RuntimeCommon Language RuntimeExceptionsExceptions

Exceptions are cheap…until you throwExceptions are cheap…until you throwThrow exceptions in exceptional Throw exceptions in exceptional circumstancescircumstancesDo not use exceptions for normal Do not use exceptions for normal flow controlflow controlUse performance counters to track the Use performance counters to track the number of exceptions thrownnumber of exceptions thrownReplace “On Error/Goto” with Replace “On Error/Goto” with “Try/Catch/Finally” in Microsoft Visual “Try/Catch/Finally” in Microsoft Visual BasicBasic®® .NET .NET

Common Language RuntimeCommon Language RuntimeReflectionReflection

Reflection can be expensiveReflection can be expensiveReflection performance costReflection performance cost

Type comparisons (for example: typeof() )Type comparisons (for example: typeof() )Member enumerations (for example: Type.GetFields())Member enumerations (for example: Type.GetFields())Member access (for example: Type.InvokeMember())Member access (for example: Type.InvokeMember())Think ~10-100x slowerThink ~10-100x slower

Working set costWorking set costRuntime data structures Runtime data structures

Think ~100 bytes per loaded type, ~80 bytes per loaded methodThink ~100 bytes per loaded type, ~80 bytes per loaded method

Be aware of APIs that use reflection as a side effectBe aware of APIs that use reflection as a side effectOverride Override

Object.ToString() Object.ToString() GetHashCode() and Equals() (for value types)GetHashCode() and Equals() (for value types)

Common Language RuntimeCommon Language RuntimeBuilding a Cost Model for Managed MathBuilding a Cost Model for Managed Math

Math performanceMath performance32 bit integers: Similar to native math32 bit integers: Similar to native math

64 bit integers: ~5-10X cost of native math64 bit integers: ~5-10X cost of native math

Floating point: Similar to native mathFloating point: Similar to native mathARM processors do not have FPU ARM processors do not have FPU

FXFX

.NET Compact Framework.NET Compact Framework

CLRCLR

Windows CEWindows CE

GlobalizationGlobalization GUIGUINetNetI/OI/OCryptoCrypto

System.System.GlobalizationGlobalization

System.System.CryptographyCryptography

System.System.IO.PortsIO.Ports

Microsoft.Microsoft.Win32.RegistryWin32.Registry

System.IO.System.IO.FileFile

System.System.DataData

System.XmlSystem.Xml

SystemSystem

mscorlibmscorlib

Microsoft.Microsoft.VisualBasicVisualBasic

JIT CompilerJIT Compiler& GC& GC

DebuggerDebugger

ClassClassLoaderLoader

AssemblyAssemblyCacheCache

NativeNativeInteropInterop

App DomainApp DomainLoaderLoader

ProcessProcessLoaderLoader

Memory and Memory and ThreadingThreading

File MappingFile MappingCert/SecurityCert/SecurityVerificationVerification

System.System.WebServicesWebServices

System.Net.System.Net.Http*Http*

System.Net.System.Net.SocketsSockets

DirectX.DirectX.DirectD3DMDirectD3DM

Windows.Windows.FormsForms

System.System.DrawingDrawing

SSLSSL

SocketsSockets

NTLMNTLM

GDI/GWESGDI/GWES

CommonCommonControlsControls

RegistryRegistry

File I/OFile I/O

EncodingsEncodings

SortingSorting Crypto APICrypto API

CalendarCalendarDataData

CultureCultureDataData

RedistRedist

HostHost

Visual StudioVisual Studio

Debug EngineDebug Engine

ICorDbgICorDbg

Managed LoaderManaged Loader

MSI SetupMSI Setup(ActiveSync)(ActiveSync)

Per Device CABPer Device CABInstall (SMS, etc)Install (SMS, etc)

System.System.ReflectionReflection

CasingCasing D3DMD3DM

Base Class LibraryBase Class LibraryCollectionsCollections

Pre-size collection classes appropriatelyPre-size collection classes appropriatelyResizing creates unnecessary copiesResizing creates unnecessary copies

Beware of foreach overhead, use indexer Beware of foreach overhead, use indexer when availablewhen available

ArrayList al = new ArrayList(string_array);ArrayList al = new ArrayList(string_array); foreach (MyType mt in al){//do something;}foreach (MyType mt in al){//do something;} will be compiled into:will be compiled into: callvirt instance class callvirt instance class

IEnumerator::GetEnumerator()IEnumerator::GetEnumerator() … … callvirt instance object callvirt instance object

IEnumerator::get_Current()IEnumerator::get_Current() … … callvirt instance bool callvirt instance bool

IEnumerator::MoveNext()IEnumerator::MoveNext()

Windows FormsWindows FormsBest PracticesBest Practices

Load and cache Forms in the backgroundLoad and cache Forms in the backgroundPopulate data separate from Form.Show()Populate data separate from Form.Show()

Pre-populate data, orPre-populate data, orLoad data async to Form.Show()Load data async to Form.Show()

Use BeginUpdate/EndUpdate when it is availableUse BeginUpdate/EndUpdate when it is availablee.g. ListView, TreeViewe.g. ListView, TreeView

Use SuspendLayout/ResumeLayout when Use SuspendLayout/ResumeLayout when repositioning controlsrepositioning controlsKeep event handling code tightKeep event handling code tight

Process bigger operations asynchronouslyProcess bigger operations asynchronouslyBlockingBlocking in event handlers will affect UI responsiveness in event handlers will affect UI responsiveness

Form load performanceForm load performanceReduce the number of method calls during initializationReduce the number of method calls during initialization

Graphics And GamesGraphics And GamesBest PracticesBest Practices

Compose to off-screen buffers to minimize Compose to off-screen buffers to minimize direct to screen blittingdirect to screen blitting

Approximately 50% fasterApproximately 50% faster

Avoid transparent blitting in areas that Avoid transparent blitting in areas that require performancerequire performance

Approximate 1/3 speed of normal blittingApproximate 1/3 speed of normal blitting

Consider using pre-rendered images versus Consider using pre-rendered images versus using System.Drawing rendering primitivesusing System.Drawing rendering primitives

Need to measure on a case-by-case basisNeed to measure on a case-by-case basis

XMLXMLBest Practices for Managing Large XML Data FilesBest Practices for Managing Large XML Data Files

Use XMLTextReader/XMLTextWriterUse XMLTextReader/XMLTextWriter

Smaller memory footprint than using XmlDocumentSmaller memory footprint than using XmlDocument

XmlTextReader is a pull model parser which only reads a XmlTextReader is a pull model parser which only reads a “window” of the data“window” of the data

XmlDocument builds a generic, untyped object model XmlDocument builds a generic, untyped object model using a treeusing a tree

Type stored as stringType stored as string

OK to use with smaller documents (64K XML: ~0.25s)OK to use with smaller documents (64K XML: ~0.25s)

Optimize the structure of XML document Optimize the structure of XML document Use elements to groupUse elements to group

Allows use of Skip() in XmlReaderAllows use of Skip() in XmlReader

Use attributes to reduce size – processing attribute-centric Use attributes to reduce size – processing attribute-centric documents is fasterdocuments is faster Keep it short! (attribute and element names)Keep it short! (attribute and element names)

Avoid gratuitous use of white spaceAvoid gratuitous use of white space

XMLXMLCreating optimized Reader/WriterCreating optimized Reader/Writer

In v2 use XmlReader/XmlWriter factory In v2 use XmlReader/XmlWriter factory classes to create optimized reader or writerclasses to create optimized reader or writer

Applying proper XMLReaderSettings can Applying proper XMLReaderSettings can improve performanceimprove performance

XmlReaderSettings settings = new XmlReaderSettings();XmlReaderSettings settings = new XmlReaderSettings();

settings.IgnoreWhitespace = true;settings.IgnoreWhitespace = true;

XmlReader reader = XmlReader.Create(“my.xml”,settings);XmlReader reader = XmlReader.Create(“my.xml”,settings);

Up to 30% performance increase when Up to 30% performance increase when IgnoreWhitespace = true is specified IgnoreWhitespace = true is specified (depends on document format)(depends on document format)

DemoDemoXmlDocument vs. XmlTextReaderXmlDocument vs. XmlTextReader

XMLXMLReading local data with DataSetReading local data with DataSet

DataSet is a database independent DataSet is a database independent container of relational datacontainer of relational dataAllows you to work with XMLAllows you to work with XML

ReadXml Allows you to load XML data into ReadXml Allows you to load XML data into DataSetDataSet

Simple to use, but performs badly, Simple to use, but performs badly, especially with large XML filesespecially with large XML filesIf you must use DS.ReadXml, make sure If you must use DS.ReadXml, make sure that you first supply the schemathat you first supply the schemaUse XmlReader whereever possible for Use XmlReader whereever possible for traversing through your datatraversing through your data

DemoDemoDataSet and .NET CompactFrameworkDataSet and .NET CompactFramework

Non-XML local dataNon-XML local dataReading files locallyReading files locally

It might be required to read text file It might be required to read text file stored locally on the devicestored locally on the device

StreamReader and FileStream classes StreamReader and FileStream classes are typically employedare typically employed

For large file sizes (>100 K), FileStream For large file sizes (>100 K), FileStream outperforms StreamReaderoutperforms StreamReader

StreamReader specifically looks for line-StreamReader specifically looks for line-breaks, FileStream does notbreaks, FileStream does not

Web ServicesWeb ServicesWhere is a bottleneckWhere is a bottleneck

Are you network bound or CPU bound?Are you network bound or CPU bound?Use perf counters: socket bytes sent / received Use perf counters: socket bytes sent / received Do you come close to the network capacity? Do you come close to the network capacity?

If you are network bound – work on reducing the size If you are network bound – work on reducing the size of the messageof the message

Create a “canned” message, send over HTTP; Create a “canned” message, send over HTTP; Compare performance with the web service; Compare performance with the web service;

If you are CPU bound, optimize the serialization If you are CPU bound, optimize the serialization scheme for speedscheme for speed

http://blogs.msdn.com/mikezintel/archive/2005/03http://blogs.msdn.com/mikezintel/archive/2005/03/30/403941.aspx/30/403941.aspx

http://blogs.msdn.com/mikezintel/archive/2005/03/30/403941.aspx

http://blogs.msdn.com/mikezintel/archive/2005/03/30/403941.aspx

Moving ForwardMoving Forward

More toolsMore toolsLive Remote Performance Counters Live Remote Performance Counters (new in v2)(new in v2)

Under construction:Under construction:Allocation profiler (CLR profiler)Allocation profiler (CLR profiler)Call profilerCall profiler

Working set improvementsWorking set improvementsMore speedMore speed

http://blogs.msdn.com/netcfteam/archive/2005/05/04/414820.aspx

SummarySummaryMake performance a requirement Make performance a requirement and measureand measureUnderstand the APIsUnderstand the APIsIsolate exactly what is being measured Isolate exactly what is being measured Repeat tests several times and ignore the first time which is Repeat tests several times and ignore the first time which is affected by JITting affected by JITting Track the results in order for later comparisons and review Track the results in order for later comparisons and review Ensure comparison of Apples to Apples Ensure comparison of Apples to Apples Use real code when possible Use real code when possible Test multiple designs and strategies - Understand the Test multiple designs and strategies - Understand the differences or variation differences or variation Avoid unnecessary object allocation and copies due toAvoid unnecessary object allocation and copies due to

String manipulationsString manipulationsBoxingBoxingNot pre-sized collectionsNot pre-sized collections

Performance FAQPerformance FAQ

http://blogs.msdn.com/netcfteam/archive/2005/05/04/414820.aspx

Documents

Developing high performance applications with.NET Compact Framework Deepak Gulati ISV Developer Evangelist Microsoft