Session: Microsoft Visual Studio: Bringing Out The Best In Multicore Systems

Motivation

major concern for Windows developers

-need help paralleliz  ing applications
-performance suffers with new features

multicore processors are here
-performance burden shifted to software.
-enables new users experiences

Parallel Computing platform team
-help is on the way: visual studio 2010.

Visual Studio 2010:
-PLINQ

parallel application development
the basic: parallelism is about performance
1. understand your goals
2. measure existing performance
3.performance tuning, start with sequential version
4. identify opportunities for parallelism, hide latency, speed up cpu bound phases.
5.express parallelism.

Testing: use realistic benchmark.
-parallelize only if necessary, but PLAN for it.
-I/O, memory latency and algorithmic optimizations, often sufficient to meet goals.
-only parallelize if you need to, because parallelization introduces bugs and complexity.

Demo

-ray tracer program
-locality is where the bottleneck lies. The order of nested loops can have huge impact.
-cache miss issue.
-step by step fixing each performance bottleneck by going through
critical section, cache miss, file buffer, thread block, using concurrency analysis tools.

Visual studio profiling tools
profiler:
-sampling based
-instrumentation based
-Managed memory usage analysis

Measuring performance:
1.Compare actual performance against goals
2.Divide and conquer
-identify scenario phases
-tackle biggest contributors first
-Amdahl’s law

opportunities for parallelism
1. identify opportunities for parallelism
-speed-up CPU-bound phases
-overlap/hide delays fro m user experience
2. visual studio 2010 concurrence analysis tool.
1.cpu utilization analysis
2.Thread blocking analysis
3.core execution analysis

-sometimes performance issues only appear in Release version( debug version would run fine).

PLINQ
Task parallel library
-parallel language integrated query.
-parallel, for, parallel foreach

parallel pattern library
-parallel_for -demon
-parallel task invocations
parallel.invoke(stmt1, stmt2)
task_group g
g.run([g]{quicksort(a,s);}]
g.wait()

remaining developer tasks
1.ensure that parallel tasks can execute concurrently
2.synchronization.

Advertisements
This entry was posted in Uncategorized. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s