nCore is offering an Embedded Systems Conference 2010 – Multicore Expo Discount until August 31, 2010.

Take $150 off each person for an onsite class or 10% off any consulting engagement.

NCT-100 Programming Multicore Processors
NCT-300 Programming GPU Processors

Ask about our NCT-200 Advanced Multicore Techniques class now in development.

How can we help you make the performance promise a reality? Email info@ncoredesign.com or ring +1-971-228-0700 to speak with a representative.

nCore at the Multicore Expo in Silicon Valley

April 2010 – nCore’s Managing Director Ian Lintault will speak at the Multicore Expo running concurrently with the Silicon Valley Embedded Systems Conference, April 26th-29th. Please join us for an interesting and informative talk on multicore strategies for organizational preparedness.

ME805: Are You Ready for Multicore?
4/28/10 16:00 – 16:45
“Much attention has been paid to the technical side of multicore migration and optimization. However, as a software development leader, your organization’s readiness and ability to migrate products to multicore directly impacts the success of such efforts. This talk outlines strategies for determining organizational readiness in a technical context. As a take away, you’ll be able to perform a self-assessment that uses checklist discipline.”

Lintault will also chair the roundtable panel on sliver bullet parallel solutions:

ME767: Panel: Parallelization Strategies – Finding the silver bullet
4/27/10 15:00 – 15:45
“There will NEVER be a ’silver bullet’ to save programmers from the complexities of multicore — at least that’s what industry experts believe. With regards to tools to parallelize application programs, the programmer will almost always be faced with a tedious process. This will be true whether porting legacy code to an SMP architecture or developing new code targeted for a heterogeneous SoC, and it applies to both HPC and embedded. However, this is not to say that all hope should be lost, as there are many tool developers working diligently to solve some of the problems. This panel of experts will provide their insight into the state-of-the-art in commercially viable solutions for parallelization to take advantage of multicore”

Based on the success of the NCT-100 Programming Multicore Processors training course released in June, nCore Design is offering an instructor-led, hands-on GPU programming course. nCore joined the Multicore Association in August and will be at SuperComputing ‘09 in November.

Beaverton, OR (PRWEB) Sept 30, 2009 – Following the success of the NCT-100 Programming Multicore Processors training course, nCore Design announces the immediate availability of the NCT-300 Programming GPU Processors course. Responding to feedback from students who took the multicore programming course, nCore has created a comprehensive GPU programming class. Conceived with the experienced C/C++ programmer in mind, NCT-300 covers concepts and approaches related to programming GPU processors using both CUDA and OpenCL.

“The response to the first multicore programming class was overwhelmingly positive. We asked the attendees what other multicore technologies they would be interested in. The consensus was to have a thorough introductory course on developing software for GPU processors,” said Ian Lintault, Managing Director at nCore Design.

The course covers GPU hardware, memories, data transport, CUDA and OpenCL APIs, programming methods and performance optimization. It will enable students to understand the fundamental aspects of GPU programming and become proficient in a relatively short time. Extensive hands-on laboratories demonstrate how to apply common numerical methods using both native APIs and open source libraries. Other topics covered in the course include integrating the Intel Threading Building Blocks (TBB) abstraction layer with native GPU software APIs in addition to a GPU debugging primer. To get more details download the class brochure here: NCT-300 Programming GPU Processors Brochure

The course is 4 days and the cost is $3400/person. To register, schedule an on-site session or contact nCore Design, go to http://www.ncoredesign.com/company/contact_us/

Connect with nCore on Twitter: @ncoredesign

Visit nCore Design November 14-20 at Supercomputing ’09 in Portland, Oregon at booth 2539.

About nCore Design

nCore Design LLC develops high performance software and systems for multicore microprocessors, GPUs and embedded systems. nCore has significant expertise on wide variety of computing platforms and specialized knowledge of applied software optimization techniques. nCore is a leading provider of hands-on, instructor-led training courses focused on programming multicore and GPU processors.

nCore Design is a Multicore Programming Practices (MPP) working group member of The Multicore Association

Founded in 2007, nCore Design is a privately held company with offices in the US and Japan. nCore works with local partners to deliver state-of-the-art solutions to multinational technology companies. To learn more about how nCore Design solutions can contribute to your success, call 971-228-0700.

###

The Multicore Association recently finished their 4th annual Multicore Expo show. The association was formed to foster industry standardization efforts amongst vendors including the exploration of potential multicore programming APIs. Aside from some of the most talked about reasons for the rise of multicore (power consumption, transistor geometry, manufacturing limitations, clock rates and Moore’s Law), the continuation of this expo is a good indicator of broad industry support for multicore computing and its adoption by scientific, commercial and military organizations.

Most major microprocessor vendors like Intel, AMD and Sun have already turned their fabrication facilities towards manufacturing products with ever an increasing number of cores. The variety of multicore architectures – GPU included – is expanding rapidly. In fact we may see single core processors disappear from the menu altogether in the not too distant future.

If you’re one of the few people who hasn’t heard about multicore processors or multicore programming (parallel programming), now might be a good time to brush-up. Without a plan to transition your products to multicore, your organization’s competitive advantage may be at risk. In the past, parallel programming was a little known domain occupied by of a handful of specialists and researchers working on sophisticated problems. This is no longer the case. If necessary, you must learn to create and adapt software to run efficiently on many cores. Even if you’re an old hand at parallel software construction, current multicore architectures offer a host of benefits that can translate to increased performance for existing software.

Since current commercial compilers possess a limited ability to automatically parallelize software for multicore architectures, developers must prepare to tackle multicore by learning some new skills and techniques. Until compilers become clever enough to analyze a program’s structure and content in order to make multicore-aware parallelization decisions, you are an integral part of parallelization process. Of course What to do and How to do it is very important, but Where to do it can be the difference between success and failure. Careful analysis using acquired skills and a solid methodology is the key to extracting every last ounce of parallelism from your application.

I get a lot of questions from developers asking how they can learn multicore programming – the What, Where and How. Recently I gave an invited talk to a group of performance engineers where much like Steven Covey’s Seven Habits, I outlined five steps that can help developers assess and direct their multicore efforts. I’m going to cover these five steps in a three part series on this blog.

1. What’s in your toolbox?

In any serious pursuit, it’s important to understand where you want to be in relation to where you are. The first questions should be “What role do I play?” and its equally important twin “What’s my overriding goal?”.

This slide, extracted from the talk presentation, indicates three broad categories of people and their roles. (click the chart to view a larger version):

Developers Most developers don’t need to create complex synchronization primitives or task queues themselves – in fact it’s extremely difficult and potentially counter productive. Creating low level software objects just isn’t necessary (think time-to-market, ROI focus, shrinking development budgets, delivery deadlines) and just diverts precious time and resources away from working on the project’s core problems. I’ve seen countless hours wasted by teams developing their version of a low-level, cross-platform library because they thought it was project critical or a unique piece of intellectual property. In most cases, development managers and teams in the trenches just need to know how to get their software working effectively on multicore. A basic understanding of the options, means and methods is all one needs. This typically includes some basic tools such as a nice compiler/debugger, a thread analysis tool and a thread abstraction method. More on those later.

Researchers Conversely, if you’re a scientist with special computing requirements, you’ll want to delve much deeper to understand the minutiae. Academics involved in parallel computing research may even publish their work in peer reviewed journals thereby hopefully advancing the state of the art. High-performance computing (HPC) researchers involved in unique physical simulations and visualization projects may need to develop purpose-built tools and techniques to realize peak performance when running on thousands and thousands of processing cores spread across hundreds of compute nodes.

Practitioners Some of you fall, perhaps not so squarely, into the middle ground between Developers and Researchers. You’ll need a broad background and a certain depth of experience with advanced tools and techniques on many platforms. You might be called upon to develop some time critical low-level code, a memory allocator or a kernel module. Practitioners may be responsible for overall application performance, lead the development team of a mission critical OS abstraction layer or the implementation of high-performance software like a database. These projects require more specialized methods as well as a thorough grounding in parallel programming theory and operating systems.

This three level segmentation is a good rule of thumb to help decide which tools should be in your multicore toolbox. That being said, it’s a very simple guide. If you have the time and energy it’s always a good idea to push the limits and expand your comfort zone – my advice is to learn as much as you can. You never know when working knowledge of a concept or tool might help land a new job or get a coveted promotion.

2. Body of Knowledge

Most people new to the world of parallel programming (and even some with experience) haven’t touched on any parallel/multicore programming topics during their tenure as serial software engineers. Coming to grips with the subject matter can be a daunting task and books like “Learn Multicore Programming in 21 days” don’t begin to cover it.

I’ve made an initial attempt to categorize these subjects into eight discreet subject areas. Depending on your goal you may need to acquire a familiarity with some or all of the eight areas.

• Foundations – The basic knowledge necessary to understand parallel programming
• Mutual Exclusion – Simultaneous use of common resources like memory
• Synchronization – Coordination of actions during program execution
• Algorithms/Methods – Patterns and algorithms used to construct parallel programs including the method of application
• Parallel Problems – Problems and pitfalls that arise during parallel program development
• Languages – Programming languages used to express parallel software
• Tools – Tools to help construct software, compile programs and analyze performance
• Optimization – Methods and techniques to optimize the serial parts of a program

I’ve put together a map of these major knowledge areas that I call the “Multicore Body of Knowledge”.

Click the image above for a larger version or you can download an A4 size PDF from here to print out and tack on your wall. The document is a work in progress so if you have any suggestions or comments please feel free to contact me.

We’ll cover the remaining three steps before jumping into multicore in a soon to appear blog post – stay tuned!

Technorati Tags:
Multicore, Software Development, Compilers