Multi Threading

Background

Power and heat limitations in server rooms are driving hardware manufacturers to exploit multi-chip and multi-core approaches. In general, multi-core microprocessors allow computing devices to exhibit some form of thread-level parallelism (TLP), without using multiple microprocessors in separate physical packages. This form of TLP is known as chip-level processing or CMP. This novel packaging technique improves performance in many cases, without generating increased demands for greater cooling capacity.

The more functionality that stays on the chip, the more efficient the process. Going off the chip increases path time, and thus latency. Compilers working in conjunction with the operating system are able to utilize opportunities for parallelism in code which can provide dramatic yields in performance.

Conversely, there are potential drawbacks. When applications are not designed with multi-threading in mind then adverse affects may result. Race conditions and deadlocks represent the most common and most detrimental pitfalls of ad-hoc multi-threaded code.
The Problem

A majority of mission critical software is not written with multi-threading in mind. The perceived benefits may be low where hardware capability to utilize it is absent. As these capabilities become more prevalent then problems with concurrency issues begin to emerge.

• The software does not fully leverage the hardware. The investment doesn't produce expected yields. Performance fails to meet expectations.
• Software that ran satisfactorily for years suddenly becomes unstable.
• License charges for proprietary software may increase on multi-core systems without an offsetting improvement in application performance to justify increased cost.
• Inadequate documentation covering the multi-threading model employed results in difficult debugging processes as developers try to expose the real behavior in this new environment.
• Skills for design and development of multi-threaded systems are sadly lacking. Existing systems require analysis and redesign to become thread safe. Solving race conditions, one at a time, is not time/cost effective.

Large scale, real-time distributed systems exhibit many of the same issues found in multi-core systems if they have not been designed with threading in mind. OCI is experienced with the opportunities and pitfalls characteristic of multi-threading problems.

Frameworks such as ACE, Boost and CORBA support large scale implementations through their use of patterns that support thread safe programming. OCI consultants can help with debugging applications and refocusing design on multi-core approaches.