International Workshop on Multicore Software Engineering (IWMSE)

By Wolfgang Rosenberg (Intel) (3 posts) on May 9, 2008 at 2:15 pm

Stay tuned about the upcoming workshop. We are expecting interesting discussions about Threading Building Blocks between the subject matter experts, the audience and you.  The International Multicore Software Engineering Workshop is co-located with the 30th International Conference on Software Engineering in Leipzig, Germany on May 12th. The purpose of this workshop is to bring together researchers and practitioners with diverse backgrounds in order to advance the state of the art in software engineering for multi/many-core parallel applications. The organizers are Prof. Walter F. Tichy and Dr. Victor Pankratius. Intel's contribution is a paper presented by Nicolae Popovici and Thomas Willhalm about 'Putting Intel(R) Threading Building Blocks to Work' .Looking forward to see your contributions / opinions!

Categories: Multicore, Uncategorized, University Curriculum

Comments (2) Comments RSS Feed

By Wolfgang Rosenberg (Intel) on May 14th, 2008 at 11:39 am
If you want to read more and understand what Theading Building Blocks are for, check out the link. The proceedings of IWMSE have been published. They contain the description of our tutorial:

http://portal.acm.org/citation.cfm?doid=1370082.1370085

Looking forward to your comments or questions. For a more detailed discussion please use the Forum section.

By octavp on May 16th, 2008 at 11:34 am
Last week I participated to the IWMSE 2008 workshop on parallelizing applications for the multicore era.
The focus of the workshop was on different techniques to ease the burdain on the developers shoulders when writting parallel applications for the multicore systems.

Our contribution to the workshop was a paper on Intel Threading Building Blocks. The focus of the talk was on the unfair,
non-preemptive TBB task scheduler and since the talk spawned a couple of interesting discusions I can say that it was very well received. Our time slot was right after the keynote on Software Transactional Memory held by Intel's Senior Principal Engineer Ali-Reza Adl-Tabatabai from the Intel Programing Systems Lab. The foils in pdf format are available here (http://delivery.acm.org/10.1145/1380000/1370084/p1-adl-tabatabai.pdf?
key1=1370084&k ey2=3384390121&coll=portal&dl=GUIDE&CFID=68389686&CFTOKEN=78260560)

Whi le all talks were very interesting a couple of them were very good ones. The "GNU libstdc++ parallel mode: Software Engineering Considerations" was one of them. The basic ideea was to go and parallelize, using OpenMP annotations, several of the standard algorithms that STL puts at our disposal. One may use the library, which comes for free (experimental) with GCC 4.3, either at compile time (using a specific compiler flag) or directly in the source code by explicit declaration. Using the STL parallel mode enables existing serial code to take advantage of many parallelized STL algorithms, an approach to making use of multi-core processors which are now or will soon will be ubiquitous. You can download the paper from here
http://delivery.acm.org/10.1145/1380000/1370089/p15-singler......=78260560.

In my opinion "The Software Thread-Level Speculation – An Optimistic Library Implementation" talk was one of the highlights of the day. Cosmin Oncea's presentation style made it even more interesting. Software thread level speculation solutions tend to mirror the hardware ones, in the sense that they employ one, exact dependency-tracking mechanism. The paper presents two different approaches: the software TLS model and the PolyLibTLS library which encapsulates several other lightweight models. The library is based heavily on meta-programming techniques and tries like almost all other libraries to pave the way towards an easy parallel programing approach for the multicore era. Fro the foils please check out the link bellow

http://delivery.acm.org/10.1145/1380000/1370090/p23-oancea.p.....=78260560.

In conclusion, it is nice to see that the academic community takes part actively in the transition process from programming for single core towards programing for the multicore systems. We are at the begining of this transition phase and I am very confident that new and better ways of expressing parallelism for multi-core will evolve from different research projects that are going on all over the world. One thing is for certain, multi-core systems are here to stay and we need to come up with better ways to program these systems.


What do you think?

Name (required)

Email (required; will not be displayed on this page)

Your URL (optional)

Comments (required)