Archives for category: Multicore

The II Multicore and Parallel Computing miniconf is now over, a big thank you to all who attended the fantastic presentations. Congratulations to the excellent speakers that timely and professionally delivered great talks, and a big bravo to the LCA2011 Organisation that smoothly overcame all the problems caused for the change of venue in the last week, due to floods in Brisbane.

A large (~200 ppl) and qualified audience attended the miniconf. During good part of the day, we had Vint Cerf (VP of Google and “Father of the Internet”) in the audience, simultaneously with Linus Torvalds (Linux kernel Project Coordinator), Paul McKenney (IBM’s Linux CTO) and Dirk Hohndel (Intel’s Chief Linux and Open Source Technologist). But the most gratifying moments happened after the miniconf and on the following days, when delegates approached me with comments like: “thank you for organising such a good miniconf”, “it was very interesting, a plus of the entire LCA”, “This miniconf just gets better”.  These were the best rewards that I could expect.

Here are the presentations from the talks. Will endeavor to add photos from the miniconf in the following days. Videos will be also available as soon as the general organisers of LCA2011 release them.

Verifying Parallel Software Paul McKenney

Integration of Intel’s TBB with Facebook’s HipHop Open Parallel

In Search of Transmission Capacity – a Multicore Dilemma Vint Cerf

Is Parallel Programming Hard? Paul McKenney

How To Build Large Scale Applications Using PHP Sam Vilain

Parallel Programming – An Overview of Non-Mainstream Languages Lenz Gschwendtner

Multicore vs. FPGA John Williams

Painless Parallelization With Gearman Tim Uckun

Discovering Inherent Parallelism in Sequential Programs Wayne Kelly

Welcome to the II Multicore and Parallel Computing miniconference, part of LCA2011. This edition will be in Brisbane, Australia, Tuesday 25 January 2011

We are pleased to announce Vint Cerf and Paul McKenney as keynotes as part of a list of eight distinguished speakers on a full day packed with exciting and challenging presentations. Full Schedule is now available.

Known as one of the “Fathers of the Internet”, Vinton Cerf is Chief Internet Evangelist and VicePresident of Google, Inc. His one hour talk will be “In Search of Transmission Capacity – a Multicore Dilemma”.

Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. He will prove it along two talks: “Is Parallel Programming Hard, And If So, Why?” and “Verifying Parallel Software: Can Theory Meet Practice?”. Paul is a Distinguished Engineer and Linux Chief Technology Officer of IBM, Inc.

Topics of the day include Lightning Talks about “How to speed up WordPress using Intel’s TBB and Facebook’s HipHop” and about Web Performance Optimization on “How to build large scale applications using PHP”.

Other Talks will be “An overview of Non Mainstream Parallel Programming languages” by Lenz Gschwendtner, Open Parallel; “Multicore vs. FPGAs” by John Williams, Petalogix; “Discovering Inherent Parallelism in Sequential Programs” by Wayne Kelly, Queensland University of Technology; and “Painless Parallelization with Gearman” by Tim Uckun, Enspiral

The day will be summarised with a Panel on “Which Industries / Applications Need Parallelisation Today”, moderated by Nicolás Erdödy, Open Parallel

Here is the Schedule complete with Abstracts and Outlines. The miniconference will be in room N515 (QUT Kelvin Grove Campus). Seating capacity: 250.

For more information, contact Nicolás Erdödy – Miniconference Organiser, at “MulticoreLCA (AT) gmail (DOT) com”


Vint G. Cerf – In Search of Transmission Capacity – a Multicore Dilemma

 

In this talk, I will explore at least one of the challenges that arises in multicore architectures and in large scale data centers in general: moving data out of processors and into the system.

While processing speeds have leveled off, more cores deliver more cycles but moving data on and off chip as well as in and out of multicore processors is proving to be a problem. Can optical communication help?
Changes in protocols? new machine architectures?

 

 

Paul E. McKenney – Is Parallel Programming Hard, And If So, Why?

 

Objective of presentation:

To advocate for the position that although parallel programming might be unfamiliar to many, it is inevitable and not as difficult as the doom-cryers would have you believe.  If done properly, work-a-day parallel programming requires perhaps 5% more training than does sequential programming.

 

Abstract:

In less than a decade, multicore hardware has made the transition from exotic to ubiquitous.  To those of you who fear and loathe parallel programming, I offer my condolences, but the settled fact of the matter is that parallel programming has irrevocably joined mainstream programming practice.  However, I can also offer some good news along with the bad.  The good news is that parallel programming is not all that much more difficult than sequential programming.  Of course, some additional bad news is that most people cannot deal even with sequential programming. This talk will discuss ways that we can not just cope, but actually thrive in this new multicore environment.

Outline:

-Review of MIPS/clock-frequency trends.
-Parallel is here to stay: parallel hand-held battery anecdote.
-Pastiche of “parallel is inhumanly hard” quotes.
-But the universe is concurrent!!!  And people are too!!! (cartoon)  Additional examples.
-But just because concurrency is natural does not mean that concurrent programming is natural.  Especially given that -programming- does not seem to be natural!  Three obstacles: (1) theory of mind (2) common sense (3) fragmentary plans. (Auto-rental example — free upgrade due to being Linux kernel hacker.)

Most people are not going to undertake parallel programming, mostly because most people are not going to program period!!!
Other topics from the blog series will be chosen randomly and capriciously, as there will be time for only a few:

  • The Great Multicore Software Crisis is upon us, but we can learn from the 1970s/1980s Great Software Crisis.
  • Embarrassing parallelism isn’t.
  • Parallel programmers can be trained.  Without experience and/or proper training, high IQ is a negative.
  • Darwinian selection favored fear and loathing of parallelism, but the fitness in the past does not necessarily imply fitness in the future.
  • Code is like water.  It is easy to do something with a cupful of water, but not so easy to do the same thing with the Pacific Ocean.
  • Past serial-only design and coding decisions cannot be wished away.
  • Parallelism introduces global constraints that are not as prevalent in sequential software.  A global view of parallel source code is critically important.
  • You get what you measure.  So be careful what you measure.
  • Amdahl’s Law is a great tool for evaluating scalability. Too bad that performance is what really matters.
  • Tools.  Parallel tools.  We need them.
  • Validating parallel programs requires special care.
  • Don’t ask the janitor to remodel your building. This caution also applies to software, despite the fact that your speaker is an exception to this rule.

But there is hope: like the Great Software Crisis of the 1970s and 1980s, the Great Multicore Software Crisis will spawn the good, the fad, and the ugly.  The new ubiquitous multicore hardware will be available to countless millions of developers and users, which will fuel a huge burst of creativity that will shock and amaze all of us, especially those who still fear and loathe parallel software.  As in the past this creativity will tend to favor open-source projects: if two heads are better than one, just try ten thousand heads!

Target audience:

Parallel developers, sequential developers, academics, users, and most especially innocent bystanders caught in the crossfire.

Project homepage / blog:
http://www.rdrop.com/user/paulmck
http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
http://paulmck.livejournal.com/tag/is%20parallel%20programming%20hard


Paul E. McKenney – Verifying Parallel Software: Can Theory Meet Practice?

 

Objective of presentation:

To advocate for a deeper theoretical toolchest for those who would validate parallel programs.

 

Abstract:

The advent of low-cost readily available multicore hardware has brought new urgency to the question of validating parallel software. The traditional validation approaches leverage linearizability, commutativity, lock freedom, and wait freedom, each of which has attractive theoretical properties, but which collectively suffer from the minor shortcoming of being unable to address common parallel-programming techniques. Given that these techniques include RCU, I have a vested interest in this debate. This talk will discuss what might be done to bridge this researcher-practitioner divide.

 

Outline:

-Quotes:

  • “So read_barrier_depends() stuff in Linux is also totally busted. (Just like refcounting, etc.)” (2005)
  • “And I don’t believe that the semantics of read_barrier_depends() are actually definable” (2006)
  • “And I think that does work for RCU, at least for conventional optimizations. But the more I think about, the less I’m convinced that it’s 100% reliable.” (2007)

-Hardware/physics issues with traditional validation approaches.

-Mechanical-engineering viewpoint: if there are many jobs, there just might be more than one tool required.

-A few new validation tools.

 

Target audience:

Parallel developers, sequential developers, academics, users, and most especially innocent bystanders caught in the crossfire.

 

Project homepage / blog:

http://www.rdrop.com/user/paulmck/RCU

http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html

http://paulmck.livejournal.com/

Vinton G. Cerf is Chief Internet Evangelist and VicePresident of Engineering of Google, Inc.

With a PhD in Computer Science from UCLA and another 15 Honoris Causa from seven countries, Vint is recognised worldwide for his contribution to the creation and development of the internet. With Bob Kahn he co-designed the TCP/IP protocol suite. Active evangelist, has been speaking in thousands of conferences since 1981, publishing 70+ papers since 1970 and having several guest appearances on TV series. He won the Turing award and received medals from Presidents Clinton and George W. Bush but also from Spain, Tunisia and Bulgaria. His career include senior roles at DARPA (Principal Scientist), MCI (SVP), ICANN (Chairman), WorldCom (SVP), and is president of a corporation set up to commercialise Interplanetary Internet protocols. His full CV shows the evolution of technology for the last 45 years and gives a hint of the future. Cerf’s wine cellar is internet-enabled, sending him a text message when the temperature and humidity reach unfavorable levels…His job as CIE Google is to convert the remaining 70% of world population that is not yet connected. Visit his corporate biography at Google and the Wikipedia page about him.

II Multicore and Parallel Computing miniconference, part of LCA2011

Tuesday 25 of January 2011. Brisbane, Australia.

 

SCHEDULE

10:30 – 11:00 Verifying Parallel Software: Can Theory Meet Practice?

Paul McKenney – CTO Linux, IBM.

Abstract – OutlineBio

11:05 – 11:10 Lightning Talk –

How to speed up WordPress using Intel’s Threading Building Blocks (TBB) and Facebook’s HipHop

11:10 – 12:10 In Search of Transmission Capacity – a Multicore Dilemma

Vinton Cerf – VicePresident and Chief Internet Evangelist, Google

Abstract – Outline – Bio

12:15 – 13:30  Lunch

13:30 – 14:20 Is Parallel Programming Hard, And If So, Why?

Paul McKenney – CTO Linux, IBM.

Abstract – OutlineBio

14:25 – 14:30 Lightning Talk – How to build large scale applications using PHP

14:30 – 15:15 Parallel Programming – an Overview of Non Mainstream Languages

Lenz Gschwendtner – Team Leader, Open Parallel

Abstract – Outline – Bio

15:15 – 15:45  Interval

15:45 – 16:10 Multicore vs FPGAs

John Williams – CEO, PetaLogix and Lecturer, University of Queensland

Abstract – Outline – Bio

16:10 – 16:35 Painless Parallelization with Gearman

Tim Uckun – Solutions Architect, Enspiral

Abstract – Outline – Bio

16:35 – 17:00 Discovering Inherent Parallelism in Sequential Programs

Wayne Kelly – Senior Lecturer, Queensland University of Technology

Abstract – OutlineBio

17:00 – 17:20 Panel – Which Industries / Applications Need Parallelization TODAY? –

Moderator –Nicolás Erdödy

17:20 – 17:30 Birds of a Feather

17:30 Miniconference (formally) Ends.

Tradition says that it continues at the nearest pub.

Look forward to see you in Brisbane in January!

Dr. Vinton G. Cerf, Google’s Vice President and Chief Internet Evangelist is another keynote of the II Multicore and Parallel Computing miniconference that will be held on Tuesday 25 of January 2011 in Brisbane, Australia, part of LCA2011.

Known as the “Father of the Internet”, Vint won the ACM Turing award in 2004 with Robert Kahn.

Vint will be presenting from 10:30 till 11:30 am. Details of his talk will be posted soon.

You can still join the speakers of this miniconf: CFP ENDS November 8, 2010.

This is the title of Paul McKenney’s main presentation at the II Open Source, Multicore and Parallel Computing miniconf (part of LCA2011) that will be a full day on Tuesday 25th, January 2011, in Brisbane, Australia. CFP ends November 8, 2010

Abstract:

In less than a decade, multicore hardware has made the transition from exotic to ubiquitous.  To those of you who fear and loathe parallel programming, I offer my condolences, but the settled fact of the matter is that parallel programming has irrevocably joined mainstream programming practice.  However, I can also offer some good news along with the bad.  The good news is that parallel programming is not all that much more difficult than sequential programming.  Of course, some additional bad news is that most people cannot deal even with sequential programming. This talk will discuss ways that we can not just cope, but actually thrive in this new multicore environment.

Outline:

Review of MIPS/clock-frequency trends.
Parallel is here to stay: parallel hand-held battery anecdote.
Pastiche of “parallel is inhumanly hard” quotes.
But the universe is concurrent!!!  And people are too!!! (cartoon)  Additional examples.
But just because concurrency is natural does not mean that concurrent programming is natural.  Especially given that -programming- does not seem to be natural!  Three obstacles: (1) theory of mind (2) common sense (3) fragmentary plans. (Auto-rental example — free upgrade due to being Linux kernel hacker.)

Most people are not going to undertake parallel programming, mostly because most people are not going to program period!!!
Other topics from the blog series will be chosen randomly and capriciously, as there will be time for only a few:

  • The Great Multicore Software Crisis is upon us, but we can learn from the 1970s/1980s Great Software Crisis.
  • Embarrassing parallelism isn’t.
  • Parallel programmers can be trained.  Without experience and/or proper training, high IQ is a negative.
  • Darwinian selection favored fear and loathing of parallelism, but the fitness in the past does not necessarily imply fitness in the future.
  • Code is like water.  It is easy to do something with a cupful of water, but not so easy to do the same thing with the Pacific Ocean.
  • Past serial-only design and coding decisions cannot be wished away.
  • Parallelism introduces global constraints that are not as prevalent in sequential software.  A global view of parallel source code is critically important.
  • You get what you measure.  So be careful what you measure.
  • Amdahl’s Law is a great tool for evaluating scalability. Too bad that performance is what really matters.
  • Tools.  Parallel tools.  We need them.
  • Validating parallel programs requires special care.
  • Don’t ask the janitor to remodel your building. This caution also applies to software, despite the fact that your speaker is an exception to this rule.

But there is hope: like the Great Software Crisis of the 1970s and 1980s, the Great Multicore Software Crisis will spawn the good, the fad, and the ugly.  The new ubiquitous multicore hardware will be available to countless millions of developers and users, which will fuel a huge burst of creativity that will shock and amaze all of us, especially those who still fear and loathe parallel software.  As in the past this creativity will tend to favor open-source projects: if two heads are better than one, just try ten thousand heads!

Target audience:

Parallel developers, sequential developers, academics, users, and most especially innocent bystanders caught in the crossfire.

Objective of presentation:

To advocate for the position that although parallel programming might be unfamiliar to many, it is inevitable and not as difficult as the doom-cryers would have you believe.  If done properly, work-a-day parallel programming requires perhaps 5% more training than does sequential programming.

Project homepage / blog:
http://www.rdrop.com/user/paulmck
http://kernel.org/pub/linux/kernel/people/paulmck/perfbook/perfbook.html
http://paulmck.livejournal.com/tag/is%20parallel%20programming%20hard

Speaker bio:

Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware.  Over the past decade, Paul has been an IBM Distinguished Engineer at the Linux Technology Center, and more recently has taken on the role of CTO Linux.

Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present highly entertaining performance, scalability, real-time response, and energy-efficiency challenges.  Prior to that, he worked on the DYNIX/ptx kernel at Sequent, and prior to that on packet-radio and Internet protocols (but long before it was polite to mention Internet at cocktail parties), system administration, business applications, and real-time systems.  His hobbies include what passes for running at his age along with the usual house-wife-and-kids habit.

The II Open Source, Multicore and Parallel Computing miniconference presents its initial keynotes:

Paul McKenney (CTO of Linux at IBM) will present “Is Parallel Programming Hard, And If So, Why?” and also give an overview of remaining challenges facing transactional memory

James Reinders (Director of Software Products from Intel) will talk about the recent open source developments of TBB 3.0 (Threading Building Blocks) and about Intel Array Building Blocks: a flexible Parallel Programming Model for Multicore and Many-Core Architectures

Join Paul and James and other world class presenters in Brisbane at LCA2011: there is still time to submit proposals for the miniconf!!.

We strongly encourage developers and students to present their work and discuss publicly their interests, either in a lightning talk or during the panels and BOF that characterise the miniconf. This is a unique opportunity to exchange ideas within the growing community of Multicore and Parallel Computing!