×
  • Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
 

Exploiting Multicore CPUs Now: Scalability and Reliability for Off-the-shelf Software

by Associate Professor at University of Massachusetts, Amherst on Oct 03, 2007

  • 5,696 views

Multiple core CPUs are here. Conventional wisdom holds that, to take best advantage of these processors, we now need to rewrite sequential applications to make them multithreaded. Because of the ...

Multiple core CPUs are here. Conventional wisdom holds that, to take best advantage of these processors, we now need to rewrite sequential applications to make them multithreaded. Because of the difficulty of programming correct and efficient multithreaded applications (e.g., race conditions, deadlocks, and scalability bottlenecks), this is a major challenge.

This talk presents two alternative approaches that bring the power of multiple cores to today's software. The first approach focuses on building highly-concurrent client-server applications from legacy code. I present a system called Flux that allows users to take unmodified off-the-shelf *sequential* C and C++ code and build concurrent applications. The Flux compiler combines the Flux program and the sequential code to generate a deadlock-free, high-concurrency server. Flux also generates discrete event simulators that accurately predict actual server performance under load. While the Flux language was initially targeted at servers, we have found it to be a useful abstraction for sensor networks, and I will briefly talk about our use of an energy-aware variant of Flux in a deployment on the backs of endangered turtles. The second approach uses the extra processing power of multicore CPUs to make legacy C/C++ applications more reliable. I present a system called DieHard that uses randomization and replication to transparently harden programs against a wide range of errors, including buffer overflows and dangling pointers. Instead of crashing or running amok, DieHard lets programs continue to run correctly in the face of memory errors with high probability. This is joint work with Brendan Burns, Kevin Grimaldi, Alex Kostadinov, Jacob Sorber, and Mark Corner (University of Massachusetts Amherst), and Ben Zorn (Microsoft Research).

Statistics

Views

Total Views
5,696
Views on SlideShare
5,686
Embed Views
10

Actions

Likes
3
Downloads
165
Comments
1

1 Embed 10

http://www.slideshare.net 10

Accessibility

Categories

Upload Details

Uploaded via SlideShare as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1 previous next

  • MikeArdelean Mike Ardelean, Software Engineer Another excellent slide show to understand multicore CPUs.

    It is easy to create C# applications that take advantage of multicore CPUs. You need to read a good book. That's all!!

    Read this article and the book 'C# 2008 and 2005 threaded programming'. http://www.packtpub.com/article/simplifying-parallelism-complexity-c-sharp

    I had never used threads and after reading the first 7 chapters, I am exploiting my Core 2 Quad. Highly recommended to C# developers.

    http://www.packtpub.com/beginners-guide-for-C-sharp-2008-and-2005-threaded-programming/book

    Cheers!

    Henry Simlan
    5 years ago
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Exploiting Multicore CPUs Now: Scalability and Reliability for Off-the-shelf Software Exploiting Multicore CPUs Now: Scalability and Reliability for Off-the-shelf Software Presentation Transcript