The present invention relates generally to logical partitioning of computer systems and, more particularly, to a method for efficient utilization of processors in a virtual shared environment. 
In a single physical computer system having multiple physical processors with logical resource partitioning capabilities (e.g., U.S. Pat.  No.  4,843,541), it is possible to have two or more operating systems (OSs) simultaneously executing on the physical processors.  Two higher-level configurations generally exist when defining the use of the available processors by the logical partitions: dedicated or shared.  A partition that makes use of dedicated processors signifies that physical processors are dedicated to a particular partition.  In other words, a dedicated physical processor handles the processing for one specific logical partition.  FIG.  1 illustrates a single system configuration that features dedicated partitions. 
On the other hand, a partition that makes use of shared processors means that the physical processors can be assigned in partial processor increments to particular partitions.  An example of such a shared partition configuration 200 is shown in FIG.  2, where the two logical partitions, combined, contain a total of five logical processors (having varying percentages of a complete physical processor) even though there are only four physical processors present in the computer system. 
In either the dedicated or shared configurations, a partition can define both a minimum number of processors (and partial processors for the shared case) and a maximum number of processors, such that the sum of each of the minimum values (including partial processor increments) of each of the partitions defined cannot exceed the number of actual physical processors.  For example, in the dedicated configuration of FIG.  1, under certain logical resource partitioning facilities, Partition 1 would be defined as having a minimum of three processors (full) but it could have a maximum of four (wherein the fourth processor would only be usable if Partition 2 is not active).  Moreover, Partition 2 would be defined to have a minimum of one processor (full) and could be defined to have a maximum of four processors (full), if Partition 1 were not active. 
With regard to the shared configuration of FIG.  2, the same principles are also applicable.  For example, Partition 1 includes of a minimum of three logical processors (wherein at least one of them is not the equivalent of a “full” processor), while Partition 2 includes of a minimum of two logical processors (wherein at least one of them is not the equivalent of a full processor).  If this was not the case, and each partition only consisted of full processors, then the two partitions would not be able to coexist on the computer system since the systems only contains four full physical processors. 
In both FIGS.  1 and 2, there exists a layer that separates the logical partitioning from the physical resources, which is referred to hereinafter as a “hypervisor.”  As is known in the art, a hypervisor layer can provide the virtualization of any number of different types of resources found in a computer system and can provide for various management functions.  As used herein, the term “hypervisor” specifically refers to the virtualization and partitioning of the available physical processors. 
When operating in a shared environment such as shown in FIG.  2, programming system services may be provided (dependent on the specifics of the computer system) to each of the OSs that are operating in the partitions by the hypervisor and the system itself.  These system services allow for the acquiring and relinquishing of the available processors.  Depending on the specific requirements of the individual OS, each OS can utilize these exposed system services in differing ways.  For example, an OS that contains a strict response time design constraint may not be permitted to relinquish a processor on its own accord, and will thus always rely on the hypervisor to take a processor away based solely on the partition definitions.  Although such a constraint makes sense for the singular OS instance, it does not ensure the efficient utilization of the available resources of the entire computer system across operating OS instances. 
To address this concern, certain OS instances attempt to utilize the exposed system services to relinquish a processor when a low utilization (of processing capability) is detected, and also attempt to acquire a processor when a low-to-high utilization transition is detected.  The specific internals of a particular OS will dictate how the low utilization and low-to-high utilization transitions are detected, the mechanics of which are not discussed in further detail hereinafter.  One of the more common methods for selecting a particular processor to acquire is to simply select all of the system processors and attempt to acquire each one of them, as opposed to selecting a single specific processor.  However, in certain instances, this can actually be a less efficient approach as compared to relying solely on the hypervisor to manage the processor resources, due to the increased use of the hypervisor by the requesting OS.  Furthermore, this blanket approach could also result in several of the acquired processors becoming active with no application workload to process, as other previously acquired processors have already begun to process the workload. 
Another possibility is to maintain a list of available processors and use a round-robin approach to select the next processor to acquire whenever a low-to-high utilization transition is detected.  Although this approach represents somewhat of an improvement over the first approach of attempting to acquire all available processors, it is still not ideal since a rudimentary round-robin search may attempt to acquire a processor that provides a unique functionality with respect to available processors, and would thus not be an appropriate choice for acquisition. 
Accordingly, it would be desirable to be able to more efficiently select a processor following a low-to-high transition a in a virtual, shared processing environment.