You can't request more than 20 challenges without solving them. Your previous challenges were flushed.

The lightweight process pool

March 16, 2001, 04:54 PM —  Unix Insider — 

Let's start by revisiting what we know.


We know that Solaris implements a two-layer threads model. The model defines thread abstractions at both the kernel and user layers, and user threads are created using thread library interfaces.


In the kernel, there are two entities abstracted: the kernel thread and the LWP. We think of kernel threads and LWPs as a single entity because every kernel thread that exists on behalf of a user process has a corresponding LWP, and vice versa. We know from past columns that the kernel thread/LWP combinations is what's scheduled by the kernel on an available processor.


Lastly, we know that the scheduling of an unbound user thread requires that the user thread be linked to an available LWP. This happens at the threads library level, through well-defined preemption points in the library code.


This brings us to the subject at hand, the implementation of the pool of available LWPs for unbound threads. (Remember that by definition bound threads always have an available LWP.) If there are more runnable user threads in a process than available LWPs, user threads must wait until the pool of LWPs is replenished before they can be scheduled. Conversely, more LWPs than user threads require maintenance and consume resources (a kernel stack) without serving as an execution resource of threads. Thus, the system must continually find a balance between keeping enough LWPs available for runnable user threads and keeping the pool small enough so as not to waste kernel resources.


The original solution to this problem in Solaris was built on the signals model. Basically, if all the LWPs in the process were blocked, a SIGWAITING signal was sent from the kernel to the threads library, where a SIGWAITING signal handler would create a new LWP. This system works as long as user threads are issuing system calls and entering the kernel. If a user thread is compute bound in user code, it's possible for the runnable user threads to wait indefinite periods of time for an available LWP, as the kernel has no way of knowing if a particular process has runnable user threads and needs more LWPs.


The method of detection and replenishment of LWPs for the threads library went through some changes beginning in Solaris 2.6. A new subsystem built on doors was introduced. However, the original mechanism is still in place, and, under certain conditions, SIGWAITING is still used. Let's take a closer look at the original implementation, and then look at the doors-based code.


A multithreaded program is any program that's been linked with the threads library at compile time.

Sign up for ITworld's Daily newsletter
Follow ITworld on Twitter @IT_world

I like it!
Post a comment
The content of this field is kept private and will not be shown publicly.
  • Allowed HTML tags: <a> <em> <strong> <cite> <code> <ul> <ol> <li> <dl> <dt> <dd>
  • Lines and paragraphs break automatically.
peer-to-peer

jfruh
Apple syncing patent can't come soon enough

pasmith
New Twitter features borrow from 3rd party clients

Esther Schindler
Open Source Changes the Software Acquisition Process

mikelgan
How to set up continuous podcast play on the new iTunes

David Strom
Five important Windows 7 mobility features

sjvn
Guard your Wi-Fi for your own sake                        

Sandra Henry-Stocker
Grepping on Whole Words

 

Sidekick: The Good News & the Bad News
Either way you look at it Microsoft Data Center management did not follow standards or best practices in this failure. In which case it makes me wonder more about the outsourcing of corporate data much less personal data.
- mburton325

Join the conversation here

The Daily Tip

The Daily TipQuick, practical advice for IT pros. Made fresh daily.

Hot tips:

Want to cash in on your IT savvy? Send your tip to tips@itworld.com. If we post it, we'll send you a $25 Amazon e-gift card.

Newsletters

Subscribe to ITWORLD TODAY and receive the latest IT news and analysis.

I would like to receive offers via email from ITworld partners.
By clicking submit you agree to the terms and conditions outlined in ITworld's privacy policy.
Featured Sponsor

AISO founders envisioned a Web hosting company that was environmentally friendly. While the company employed energy-efficient innovations like solar panels, its infrastructure produced unacceptable power and cooling requirements. Find out how AISO leveraged AMD technology to overcome their challenge in this case study white paper.

In this whitepaper, Scalar explores the opportunity to change the landscape with respect to mission critical databases built around Oracle. Leveraging technologies such as Linux, high-end commodity processing power and Oracle RAC technology to architect, design, build and maintain database infrastructure that delivers maximum availability, reliability and performance at a fraction of traditional cost.

On a typical day, weather.com, the Web site for The Weather Channel in Atlanta, serves up between 15 million and 20 million page views. But in September 2004, when back-to-back hurricanes ransacked Florida, the peak traffic on one day more than tripled: over 70 million page views by more than 7 million unique visitors. Read the full success story now.

Marketplace