METHOD AND APPARATUS FOR DETERMINING A MINIMUM/MAXIMUM OF A PLURALITY OF BINARY VALUES

Abstract

For determining a minimum/maximum of a plurality of binary values a bit position in the plurality of binary values is determined subsequent to which all bit values are the same. From the plurality of binary values those binary values are selected the bit values of which at the bit position determined in the preceding step and all subsequent positions, if any, has a predetermined value. The preceding steps are then repeated until only one binary value remains which is provided as the minimum or maximum.

Description

BACKGROUND OF THE INVENTION

Embodiments of the invention concern a method and an apparatus for determining a minimum/maximum of a plurality of binary values, more specifically, embodiments of the invention concern a method and an apparatus for determining from a plurality of binary values stored at different locations remote from a central processor a minimum/maximum value.

Memory elements and integrated circuits (IC) need to be tested to ensure proper operation, and in particular, testing is a requirement during IC or memory development in manufacturing. During testing such devices under test (DUTs) are exposed to various types of stimulus signals, and responses from the devices are measured, processed, and usually compared to an expected response. Such testing may be carried out by automated test equipment (ATE) which usually performs these tasks according to a device-specific test program.

Examples for such automated test equipment are the Verigy V93000 Series and the Verigy V5000 Series, the first being a platform for testing system-on-a-chip, system-on-a-package, and high-speed memory devices. The latter series is for testing memory devices including flash memory and multi-chip packages at wafer sort and final test.

In such automated test equipment or testers, a plurality of test results might be obtained and stored at various locations remote from a central processing area. For example the results might be generated on the basis of different stimulus signals provided by a plurality of processing devices, or processors, which not only generate the stimulus signals, but also receive the response signals from the device under test or from a plurality of devices under test. For a test action, usually a test routine is executed on all channels in parallel. The test routines being executed or the data used by the test routines may differ between channels. However, for fast test execution it may be desired to make use of broadcast and common read wherever possible which necessitates that related test data of different channels is stored in all these channels at the same memory address. Finding out how to allocate memory chunks of certain sizes over certain sets of channels is done by the tester memory management. For some complex test applications there may be a constraint that related data of different channels has to be aligned at the same address which results in unused gaps in the tester memory. With increasing computing power of embedded processor inside the test processors each processor may manage its memory on its own and in the communication between the central processor and the test processors only symbolic addresses for memory chunks may be used. By this the constraint that related data of different channels has to be aligned at the same address may be avoided. However this may necessitate that the central processor knows the minimum or maximum of some values stored in the test processors. One example for this is the question: given a set of channels, how much memory can one still allocate over all these channels, i.e., what is the minimum size of the largest contiguous block of free memory on each of these channels?

SUMMARY

According to an embodiment, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors may have the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein step (a) initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in (a) and all subsequent bit positions, if any, comprises a predetermined value;(c) repeating steps (a) and (b), wherein step (a) is repeated on the basis of the binary values selected in step (b) until only one selected binary value, or a plurality of matching binary values, remain; and(d) providing the remaining binary value as the minimum/maximum.

According to another embodiment, a computer storage medium may have a computer readable program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method having the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value; (c) repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; and (d) providing the remaining binary value as the minimum/maximum.

According to another embodiment, a computer program product may have a computer readable program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method having the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value; (c) repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; and (d) providing the remaining binary value as the minimum/maximum.

According to another embodiment, a computer program may have a program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method having the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value; (c) repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; and (d) providing the remaining binary value as the minimum/maximum.

According to another embodiment, a system for determining a minimum/maximum of a plurality of binary values held by a plurality of memories associated with respective processors may have: a central processor; a logic coupled to the central processor and configured to output a bit-wise OR combination and a bit-wise AND combination of a plurality of input values to the central processor; and a plurality of memories associated with respective processors, each of the memories being coupled to the logic and configured to hold one of the plurality of binary values, wherein the central processor is configured to operate in accordance with a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method having the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bitwise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value; (c) repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; and (d) providing the remaining binary value as the minimum/maximum.

According to another embodiment, an apparatus for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors may have: a processor configured to operate in accordance with a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method having the steps of: (a) determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially may have the steps of: (a.1) commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, and (a.2) based on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same; (b) selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value; (c) repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; and (d) providing the remaining binary value as the minimum/maximum.

Embodiments of the invention provide an apparatus for determining a minimum/maximum of a plurality of binary values which comprises a processor which is configured to operate in accordance with the method of embodiments of the invention.

Further embodiments of the invention provide a system for determining a minimum/maximum of a plurality of binary values, wherein the system comprises a central processor, a logic coupled to the central processor and configured to output a bit-wise OR combination and a bit-wise AND combination of a plurality of input values to the central processor, and a plurality of memories associated with respect to processors, each memory being coupled to the logic and coupled to hold one of the plurality of binary values, wherein the central processor is configured to operate in accordance with the method of embodiments of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

Embodiments of the present invention will be described in the following with reference to the accompanying drawings in which:

FIG. 1 shows a schematic view of a conventional tester;

FIG. 2 shows a schematic view of a tester according to an embodiment of the invention; and

FIG. 3 shows a flow diagram illustrating an embodiment for determining a minimum/maximum of a plurality of binary values.

DETAILED DESCRIPTION OF THE INVENTION

FIG. 1 shows a schematic view of a tester 100 comprising a central processor 102 and a plurality of individual processors P₁ to P_n which are coupled to the central processor 102 as is indicated by the respective arrows shown in FIG. 1 connecting the individual processors P₁ to P_n with a central processor 102. The tester 100 may be connected or coupled to a single device under test or a plurality of devices under test as is indicated at 104. Further, the tester 100 comprises an output 106 for providing output signals which are for example indicative of the outcome of a test of the DUT 104. The plurality of processors P₁ to P_n might be provided for providing the respective stimulus signals to the DUT 104, and in turn, for receiving from the DUT respective response signals. As indicated in FIG. 1, each processor P₁ to P_n, might hold one or more values in binary form representing a response signal or another signal indicating a test result of a test which was applied to the DUT 104 by means of a respective processor.

In the embodiment shown in FIG. 1, the individual processor P₁ stores the value of 45 in binary form (101101), the individual processor P₂ stores the value 57 in binary form (111001), the individual processor P₃ stores the value 13 in binary form (001101), the individual processor P₄ stores the value 44 in binary form (101100), the individual processor P₅ stores the value 29 (011101), and the individual processor P_n stores the value 45 in binary form (101101).

In the above-described environment, the tester 100 comprises the front end processors P₁ to P_n, each of which holds an integer value. The central processor 102 may now need to know the minimum or maximum of all those values as fast as possible. In accordance with the conventional tester shown in FIG. 1, the conventional approach for finding the minimum or maximum of all values is to have the central processor 102 read the values from the processors P₁ to P_n one by one, which in turn, will necessitate n read operations.

While the central processor 102, in general, can handle simple processing steps or computations quite fast, it is not possible to obtain the minimum or maximum of all values fast, as in general, the communication between the central processor 102 and the respective individual processor P₁ through P_n is slow, compared to the just-mentioned computation, i.e., the number of communication steps needed dominates the total time needed, provided simple processing steps or computations are to be carried out in the central processor.

Therefore, a need exists to provide an improved approach for determining from a plurality of binary values stored in the different locations, a minimum or maximum value in a processing and time efficient manner. The fast finding of one or more minimum/maximum value(s) may be used in a test system and, more specifically, for managing the memory of distributed processors of such a test system. One example of such a test system uses a plurality of channels (the measuring unit for one pin of DUT) each of which has its own test processor with associated memory. FIG. 2 shows a schematic view of a tester according to an embodiment of the invention. In FIG. 2 those elements already described with regard to FIG. 1 have associated therewith the same reference signs. As can be seen from FIG. 2, in addition to the tester described with regard to FIG. 1, the tester 100 comprises a logic 108 which is coupled between the respective individual processors P₁ to P_n and the central processor 102. The logic 108 is shown as a separate element, however, other embodiments might implement the logic 108 as part of the central processor 102 as is indicated by the dashed line surrounding these two elements. As can be seen, the logic 108 is configured to combine the values read from the processors P₁ to P_n using a bit-wise “AND” or a bit-wise “OR”. The two outputs of the logic 108 are either the “bit-wise OR” or the “bit-wise AND” output, which is input into the central processor 102. In the embodiment shown in FIG. 2, it is assumed that the individual processors P₁ to P_n hold the same values as described with regard to FIG. 1, and in addition, memory elements M₁ to M_n are shown, which hold the values indicated. The memories M₁ to M_n might either be part of the processor P₁ to P_n, e.g. as processor registers, or memory elements coupled to the respective processors. The functionality of the tester shown in FIG. 2 is such that the values can be read from all processors P₁ to P_n into the central processor 102 in one step by combining the values read from the processors using the bit-wise “AND” or the bit-wise “OR”. Using this common read operation on all processors is as fast as reading one value from one specific processor. In a similar manner, in one step data can be broadcast from the central processor to all other processors or to one individual processor.

In the following, examples for quickly determining the minimum or maximum of values stored in the distributed processor P₁ to P_n using common read capabilities will be described with further reference to FIG. 3.

FIG. 3 shows a flow diagram of an embodiment for determining one or more minimum/maximum values associated with a plurality of processors P₁ to P_n. The original values are stored in each of the processors or may be stored elsewhere but are associated with one of the processors. The binary values comprise a number of bits which is set to be k, and the bits in the binary representation are numbered from right (least significant bit) to left (most significant bit), starting with 0, i.e., the number is represented as bits (k−1) . . . 0. i is the first bit position from the left (most significant bit) up to which the bits of the minimum are already known. In the example described with regard to FIG. 3, k=8, and initially i=k.

In step S100 the following variables are initialized:

• • k=8(=eight bits);
  • n=9(=nine processors);
  • R=variable in which the up to now known bits of the result for the determination of the minimum/maximum are stored, and in which the bits not known are set to 0;
  • j=highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0);
  • V_ANDn=actual values for bit-wise AND;
  • V_ORn=actual values for bit-wise OR;
  • P_n=value stored at/associated with processor n

After the initialization in step S100, a value for j which is smaller than i is determined such that bits (k−1) . . . (j+1) of the binary representation of all values provided from the processors P₁ to P_n are equal. Then, bits (k−1) . . . (j+1) of the minimum/maximum value may be the same, and bit j of the minimum may be “0”, and bit j of the maximum may be “1”, respectively. To determine position j, the central processor 102 takes the bit-wise “AND” and the bit-wise “OR” obtained through two common read operations of the binary representations of the numbers of the processors (see step S102). At the bit positions where these two bit patterns are equal all values provided from the processors may be equal. At bit positions where these two bit patterns differ, at least one processor may have provided a 0-bit and at least one may have provided a 1-bit. Thus j is the most significant bit position where the bit-wise AND and the bit-wise OR differ, which can be computed in the central processor by simply examining the individual bits. After this step, bits (k−1) . . . j are known, i.e., i can be set to j (see step S104).

In step S106 the up to now known bits (k−1) to 0 for R are determined by setting bits k−1 to j+1 of R to the matching bits of the results of the bit-wise AND and bit-wise OR operation, setting bit j of R (if any) to 0 in case of search for the minimum and to 1 in case of search for the maximum, and setting the remaining bits j−1 to 0 of R (if any) to 0.

In step S108, it is determined whether j is smaller than or equal to 0. In case it is, the process ends at step S110.

Otherwise, the process proceeds to step S112, where the search is now restricted to those results where the bits (k−1) . . . i equal the already known bits of the smallest maximum. For preparing this step, the central processor 102 communicates the up to now known bits of the minimum/maximum to all processor P₁ to P_n as well as the result of the bit-wise “AND” and the bit-wise “OR” of all values in the preceding iteration (in the first iteration the results of the bit-wise “AND” and the bit-wise “OR” of all original values stored in the processors). Further, the central processor 102 now instructs all processors P₁ to P_n to provide the following values in the next step as follows (see steps S112 to S118):

• • in case bits (k−1) to j of the original value P_n of a respective processor equals the already known bits of the minimum/maximum, the original value P_n is provided (see steps 114 and 116), and
  • for all other processors, the originally binary values are not provided, rather the processors are instructed to provide modified values to the logic 108 (see steps S114 and S118).

To be more specific, in step S118 the modified values are determined dependent on whether a common read with “AND”-operation or a common read with “OR”-operation is to be carried out. For the “common read with “AND”” operation the respective processors are instructed to return the up to now known bits of the minimum for bits (k−1) . . . i. In addition, also the bits of the preceding “OR” of the stored values are provided. In a similar manner, the processors are instructed to return respective modified values for the “common read with “OR”” operation. Again, the up to now known bits of the minimum bits (k−1) . . . i are returned, and the remaining bits are those of the “AND” of all preceding bits. The just-described modified values do not influence the bit-wise “AND” or the bit-wise “OR” over the values of the processors of the restricted search space.

The above process is repeated on the basis of the original/modified values until j≦0 (see steps 108, 110).

In the following examples will be described illustrating the above approach for determining a minimum/maximum value.

EXAMPLE 1

Determining a minimum value from values stored in nine processors P₁ to P₉.

Original values:

	P1 = 112	→	01110000
	P2 = 114	→	01110010
	P3 = 111	→	01101111
	P4 = 99	→	01100011
	P5 = 101	→	01100101
	P6 = 115	→	01110011
	P7 = 115	→	01110011
	P8 = 111	→	01101111
	P9 = 114	→	01110010

Iteration #1

Number of bits of result known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P9)	For OR: (P1 to P9)
	01110000	original	01110000	original
	01110010	original	01110010	original
	01101111	original	01101111	original
	01101111	original	01101111	original
	01100101	original	01100101	original
	01110011	original	01110011	original
	01110011	original	01110011	original
	01101111	original	01101111	original
	01110010	original	01110010	original
01100000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 4(j=4)

=> now the 4 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 4
Bit Mask for bits known up to now: 11110000
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 5)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 011.
  • setting bit j (bit 4) to 0because of search for minimum.
  • remaining bits j−1 to 0 (bits 3 to 0) remain at 0.

              For AND: (P1 to P9)
              (01101111) modified
              (01101111) modified
              01101111   original
              01100011   original
              01100101   original
              (01101111) modified
              (01101111) modified
              01101111   original
              (01101111) modified
Bit-wise AND: 01100001

• • Original: Original value maintained because the up to now known bits of result, i.e. 0110, and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0110, and the corresponding bits in original value do not match.
  • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0110, and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise OR in iteration #1, i.e. 1111.

             For OR: (P1 to P9)
             (01100000) modified
             (01100000) modified
             01101111   original
             01100011   original
             01100101   original
             (01100000) modified
             (01100000) modified
             01101111   original
             (01100000) modified
Bit-wise OR: 01101111

• • Original: Original value maintained because the up to now known bits of result, i.e. 0110and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0110and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0110and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise AND in iteration #1, i.e. 0000.

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 3 (j=3)

=> now the 5 most significant bits of the result are known.

Iteration #3

Number of bits of result known up to now: 5
Bit Mask for bits known up to now: 11111000
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 4)=matching bits of bit-wise AND and bit-wise OR in iteration #2—in this example 0110.
  • setting bit j (bit 3) to 0because of search for maximum.
  • remaining bits j−1 to 0 (2 to 0) remain at 0.

              For AND: (P1 to P9)
              (01100111) modified
              (01100111) modified
              (01100111) modified
              01100011   original
              01100101   original
              (01100111) modified
              (01100111) modified
              (01100111) modified
              (01100111) modified
Bit-wise AND: 01100001

• • Original: Original value maintained because the up to now known bits of result, i.e. 01100and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 01100and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 01100and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise OR in iteration #2, i.e. 111

             For OR: (P1 to P9)
             (01100000) modified
             (01100000) modified
             (01100000) modified
             01100011   original
             01100101   original
             (01100000) modified
             (01100000) modified
             (01100000) modified
             (01100000) modified
Bit-wise OR: 01100111

• • Original: Original value maintained because the up to now known bits of result, i.e. 01100and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 01100and the corresponding bits in original value do not match.
  • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 01100and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise AND in iteration #2, i.e. 000

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 2(j=2)

• • => now the 6 most significant bits of the result are known.

Iteration #4

Number of bits of result known up to now: 6
Bit Mask for bits known up to now: 11111100
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 3)=matching bits of bit-wise AND and bit-wise OR in iteration #3—in this example 01100.
  • setting bit j (bit 2) to 0because of search for maximum.
  • remaining bits j−1 to 0 (1 to 0) remain at 0.

              For AND: (P1 to P9)
              (01100011) modified
              (01100011) modified
              (01100011) modified
              01100011   original
              (01100011) modified
              (01100011) modified
              (01100011) modified
              (01100011) modified
              (01100011) modified
Bit-wise AND: 01100011

• • Original: Original value maintained because the up to now known bits of result, i.e. 011000and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 011000and the corresponding bits in original value do not match.
  • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 011000and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise OR in iteration #3, i.e. 11

             For OR: (P1 to P9)
             (01100000) modified
             (01100000) modified
             (01100000) modified
             01100011   original
             (01100000) modified
             (01100000) modified
             (01100000) modified
             (01100000) modified
             (01100000) modified
Bit-wise OR: 01100011

• • Original: Original value maintained because the up to now known bits of result, i.e. 011000and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 011000and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 011000and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise AND in iteration #3, i.e. 00

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): −1(j=−1)

• • => now the 8 most significant bits of the result are known.

Bit Mask for bits known up to now: 11111111
Bits of result:                  01100011

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 1)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 01100011.
  • bit j (bit -1) does not exist.
  • there are no remaining bits j−1 to 0.
  • => now all bits of the result are known, i.e. the result is 01100011=99. Thus, processor P₄ holds the minimum value.

EXAMPLE 2

Determining a maximum value from values stored in nine processors P₁ to P₉.

Original values:

	P1 = 112	→	01110000
	P2 = 114	→	01110010
	P3 = 111	→	01101111
	P4 = 99	→	01100011
	P5 = 101	→	01100101
	P6 = 115	→	01110011
	P7 = 115	→	01110011
	P8 = 111	→	01101111
	P9 = 114	→	01110010

Iteration #1

Number of bits of result known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P9)	For OR: (P1 to P9)
	01110000	original	01110000	original
	01110010	original	01110010	original
	01101111	original	01101111	original
	01100011	original	01100011	original
	01100101	original	01100101	original
	01110011	original	01110011	original
	01110011	original	01110011	original
	01101111	original	01101111	original
	01110010	original	01110010	original
01100000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 4(j=4)

=> now the 4 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 4
Bit Mask for bits known up to now: 11110000
Bits of result:                  01110000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 5)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 011.
  • setting bit j (bit 4) to 1because of search for maximum.
  • remaining bits j−1 to 0 (bits 3 to 0) remain at 0.

              For AND: (P1 to P9)
              01110000   original
              01110010   original
              (01111111) modified
              (01111111) modified
              (01111111) modified
              01110011   original
              01110011   original
              (01111111) modified
              01110010   original
Bit-wise AND: 01110000

• • Original: Original value maintained because the up to now known bits of result, i.e. 0111, and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0111, and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0111, and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise OR in iteration #1, i.e. 1111.

             For OR: (P1 to P9)
             01110000   original
             01110010   original
             (01110000) modified
             (01110000) modified
             (01110000) modified
             01110011   original
             01110011   original
             (01110000) modified
             01110010   original
Bit-wise OR: 01110011

• • Original: Original value maintained because the up to now known bits of result, i.e. 0111, and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0111, and the corresponding bits in original value do not match.
  • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0111, and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise AND in iteration #1, i.e. 0000.

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 1(j=1)

• • => now the 7 most significant bits of the result are known.

Iteration #3

Number of bits of result known up to now: 7
Bit Mask for bits known up to now: 11111110
Bits of result:                  01110010

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 2)=matching bits of bit-wise AND and bit-wise OR in iteration #2—in this example 011100.
  • setting bit j (bit 1) to 1 because of search for maximum.
  • remaining bits j−1 to 0 (0 to 0) remain at 0.

              For AND: (P1 to P9)
              (01110011) modified
              01110010   original
              (01110011) modified
              (01110011) modified
              (01110011) modified
              01110011   original
              01110011   original
              (01110011) modified
              01110010   original
Bit-wise AND: 01110010

• • Original: Original value maintained because the up to now known bits of result, i.e. 0111001, and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0111001, and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0111001, and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise OR in iteration #2, i.e. 1.

             For OR: (P1 to P9)
             (01110010) modified
             01110010   original
             (01110010) modified
             (01110010) modified
             (01110010) modified
             01110011   original
             01110011   original
             (01110010) modified
             01110010   original
Bit-wise OR: 01110011

• • Original: Original value maintained because the up to now known bits of result, i.e. 0111001, and the corresponding bits in original value match.
  • Modified: Original value modified because the up to now known bits of result, i.e. 0111001, and the corresponding bits in original value do not match.
    • Those bits in the original value, which do not match, are replaced by the up to now known bits of result, i.e. 0111001, and the remaining bits in the original value are replaced by the corresponding bits from the result of the bit-wise AND in iteration #2, i.e. 0.

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 0(j=0)

• • => now the 8 most significant bits of the result are known.

Bit Mask for bits known up to now: 11111111
Bits of result:                  01100011

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 1)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 0111001.
  • setting bit j (bit 0) to 1because of search for maximum.
  • there are no remaining bits j−1 to 0.
  • => now all bits of the result are known, i.e. the result is 01110011=115. Thus, processor P₇ holds the minimum value.

EXAMPLE 3

Determining a minimum value from values stored in eleven processors P₁ to P₁₁. (As to the determination for the values for the bit-wise AND and bit-wise OR please see above examples 1 and 2)

Original values:

	P1 = 70	→	01000110
	P2 = 97	→	01100001
	P3 = 115	→	01110011
	P4 = 116	→	01110100
	P5 = 77	→	01001101
	P6 = 105	→	01101001
	P7 = 110	→	01101110
	P8 = 68	→	01000100
	P9 = 101	→	01100101
	P10 = 109	→	01101101
	P11 = 111	→	01101111

Iteration #1

Number of bits of result R known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P11)	For OR: (P1 to P11)
	01000110	original	01000110	original
	01100001	original	01100001	original
	01110011	original	01110011	original
	01110100	original	01110100	original
	01001101	original	01001101	original
	01101001	original	01101001	original
	01101110	original	01101110	original
	01000100	original	01000100	original
	01100101	original	01100101	original
	01101101	original	01101101	original
	01101111	original	01101111	original
01000000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 5(j=5)

• • => now the 3 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 3
Bit Mask for bits known up to now: 11100000
Bits of result:                  01000000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 6)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 01.
  • setting bit j (bit 5) to 0because of search for minimum.
  • remaining bits j−1 to 0 (bits 4 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	01000110	original	01000110	original
	(01011111)	modified	(01000000)	modified
	(01011111)	modified	(01000000)	modified
	(01011111)	modified	(01000000)	modified
	01001101	original	01001101	original
	(01011111)	modified	(01000000)	modified
	(01011111)	modified	(01000000)	modified
	01000100	original	01000100	original
	(01011111)	modified	(01000000)	modified
	(01011111)	modified	(01000000)	modified
	(01011111)	modified	(01000000)	modified
01000100(bit-wise AND)	01001111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 3(j=3)

• • => now the 5 most significant bits of the result are known.

Iteration #3

Number of bits of result known up to now: 5
Bit Mask for bits known up to now: 11111000
Bits of result:                  01000000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 4)=matching bits of bit-wise AND and bit-wise OR in iteration #2—in this example 0100.
  • setting bit j (bit 3) to 0because of search for minimum.
  • remaining bits j−1 to 0 (2 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	01000110	original	01000110	original
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	01000100	original	01000100	original
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
	(01000111)	modified	(01000000)	modified
01000100(bit-wise AND)	01000110(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 1 (j=1)

• • => now the 7 most significant bits of the result are known.

Iteration #4

Number of bits of result known up to now: 7
Bit Mask for bits known up to now: 11111110
Bits of result:                  01000100

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 2)=matching bits of bit-wise AND and bit-wise OR in iteration #3—in this example 01100.
  • setting bit j (bit 1) to 0because of search for minimum.
  • remaining bits j−1 to 0 (0 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	01000100	original	01000100	original
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
	(01000101)	modified	(01000100)	modified
01000100(bit-wise AND)	01000100(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): −1(j=−1) (i.e. all bits match)

Number of bits of result known up to now: 8
Bit Mask for bits known up to now: 11111111
Bits of result:                  01000100

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 0)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 01000100.
  • bit j (bit −1) does not exist.
  • there are no remaining bits j−1 to 0.
  • => all bits of the result are known, i.e. the result is 01000100=68. Thus, processor P₇ holds the minimum value.

EXAMPLE 4

Determining a maximum value from values stored in eleven processors P₁ to P₁₁. (As to the determination for the values for the bit-wise AND and bit-wise OR please see above examples 1 and 2)

Original values:

	P1 = 70	→	01000110
	P2 = 97	→	01100001
	P3 = 115	→	01110011
	P4 = 116	→	01110100
	P5 = 77	→	01001101
	P6 = 105	→	01101001
	P7 = 110	→	01101110
	P8 = 68	→	01000100
	P9 = 101	→	01100101
	P10 = 109	→	01101101
	P11 = 111	→	01101111

Iteration #1

Number of bits of result known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P11)	For OR: (P1 to P11)
	01000110	original	01000110	original
	01100001	original	01100001	original
	01110011	original	01110011	original
	01110100	original	01110100	original
	01001101	original	01001101	original
	01101001	original	01101001	original
	01101110	original	01101110	original
	01000100	original	01000100	original
	01100101	original	01100101	original
	01101101	original	01101101	original
	01101111	original	01101111	original
01000000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 5(j=5)

• • => the 3 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 3
Bit Mask for bits known up to now: 11100000
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 6)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 01.
  • setting bit j (bit 5) to 1because of search for maximum.
  • remaining bits j−1 to 0 (bits 4 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	(01111111)	modified	(01100000)	modified
	01100001	original	01100001	original
	01110011	original	01110011	original
	01110100	original	01110100	original
	(01111111)	modified	(01100000)	modified
	01101001	original	01101001	original
	01101110	original	01101110	original
	(01111111)	modified	(01100000)	modified
	01100101	original	01100101	original
	01101101	original	01101101	original
	01101111	original	01101111	original
01100000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 4(j=4)

• • => the 4 most significant bits of the result are known.

Iteration #3

Number of bits of result known up to now: 4
Bit Mask for bits known up to now: 11110000
Bits of result:                  01110000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 5)=matching bits of bit-wise AND and bit-wise OR in iteration #2—in this example 011.
  • setting bit j (bit 4) to 1because of search for maximum.
  • remaining bits j−1 to 0 (3 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	01110011	original	01110011	original
	01110100	original	01110100	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
Bit-wise AND: 01110000	01110111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 2(j=2)

• • => the 6 most significant bits of the result are known.

Iteration #4

Number of bits of result known up to now: 6
Bit Mask for bits known up to now: 11111100
Bits of result:                  01110100

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 3)=matching bits of bit-wise AND and bit-wise OR in iteration #3—in this example 01110.
  • setting bit j (bit 2) to 1because of search for maximum.
  • remaining bits j−1 to 0 (1 to 0) remain at 0.

	For AND: (P1 to P11)	For OR: (P1 to P11)
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	01110100	original	01110100	original
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
	(01110111)	modified	(01110100)	modified
01110100(bit-wise AND)	01110100(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): −1(j=−1) (i.e. all bits match)

Number of bits of result known up to now: 8
Bit Mask for bits known up to now: 11111111
Bits of result:                  01110100

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 0)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 01110100.
  • bit j (bit −1) does not exist.
  • there are no remaining bits j−1 to 0.
  • => all bits of the result are known, i.e. the result is 01110100=116. Thus, processor P₄ holds the minimum value.

EXAMPLE 5

Determining a minimum value from values stored in eighteen processors P₁ to P₁₈. (As to the determination for the values for the bit-wise AND and bit-wise OR please see above examples 1 and 2)

Original values:

	P1 = 114	→	01110010
	P2 = 104	→	01101000
	P3 = 97	→	01100001
	P4 = 98	→	01100010
	P5 = 97	→	01100001
	P6 = 114	→	01110010
	P7 = 98	→	01100010
	P8 = 101	→	01100101
	P9 = 114	→	01110010
	P10 = 114	→	01110010
	P11 = 104	→	01101000
	P12 = 97	→	01100001
	P13 = 98	→	01100010
	P14 = 97	→	01100001
	P15 = 114	→	01110010
	P16 = 98	→	01100010
	P17 = 101	→	01100101
	P18 = 114	→	01110010

Iteration #1

Number of bits of result known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P18)	For OR: (P1 to P18)
	01110010	original	01110010	original
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	01110010	original	01110010	original
	01100010	original	01100010	original
	01100101	original	01100101	original
	01110010	original	01110010	original
	01110010	original	01110010	original
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	01110010	original	01110010	original
	01100010	original	01100010	original
	01100101	original	01100101	original
	01110010	original	01110010	original
01100000(bit-wise AND)	01111111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 4(j=4)

• • => the 4 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 4
Bit Mask for bits known up to now: 11110000
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 5)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 011.
  • setting bit j (bit 4) to 0because of search for minimum.
  • remaining bits j−1 to 0 (bits 3 to 0) remain at 0.

	For AND: (P1 to P18)	For OR: (P1 to P18)
	(01101111)	modified	(01100000)	modified
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	(01101111)	modified	(01100000)	modified
	01100010	original	01100010	original
	01100101	original	01100101	original
	(01101111)	modified	(01100000)	modified
	(01101111)	modified	(01100000)	modified
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	(01101111)	modified	(01100000)	modified
	01100010	original	01100010	original
	01100101	original	01100101	original
	(01101111)	modified	(01100000)	modified
01100000(bit-wise AND)	01101111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 3(j=3)

• • => the 5 most significant bits of the result are known.

Iteration #3

Number of bits of result known up to now: 5
Bit Mask for bits known up to now: 11111000
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 4)=matching bits of bit-wise AND and bit-wise OR in iteration #2—in this example 0110.
  • setting bit j (bit 3) to 0because of search for minimum.
  • remaining bits j−1 to 0 (2 to 0) remain at 0.

	For AND: (P1 to P18)	For OR: (P1 to P18)
	(01100111)	modified	(01100000)	original
	(01100111)	modified	(01100000)	modified
	01100001	original	01100001	modified
	01100010	original	01100010	modified
	01100001	original	01100001	modified
	(01100111)	modified	(01100000)	modified
	01100010	original	01100010	modified
	01100101	original	01100101	original
	(01100111)	modified	(01100000)	modified
	(01100111)	modified	(01100000)	modified
	(01100111)	modified	(01100000)	modified
	01100001	original	01100001	modified
	01100010	original	01100010	modified
	01100001	original	01100001	modified
	(01100111)	modified	(01100000)	original
	01100010	original	01100010	modified
	01100101	original	01100101	modified
	(01100111)	modified	(01100000)	modified
01100000(bit-wise AND)	01100111(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 2(j=2)

• • => the 6 most significant bits of the result are known.

Iteration #4

Number of bits of result known up to now: 6
Bit Mask for bits known up to now: 11111100
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 3)=matching bits of bit-wise AND and bit-wise OR in iteration #3—in this example 01100.
  • setting bit j (bit 2) to 0because of search for minimum.
  • remaining bits j−1 to 0 (1 to 0) remain at 0.

	For AND: (P1 to P18)	For OR: (P1 to P18)
	(01100011)	modified	(01100000)	modified
	(01100011)	modified	(01100000)	modified
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	(01100011)	modified	(01100000)	modified
	01100010	original	01100010	original
	(01100011)	modified	(01100000)	modified
	(01100011)	modified	(01100000)	modified
	(01100011)	modified	(01100000)	modified
	(01100011)	modified	(01100000)	modified
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	(01100011)	modified	(01100000)	modified
	01100010	original	01100010	original
	(01100011)	modified	(01100000)	modified
	(01100011)	modified	(01100000)	modified
01100000(bit-wise AND)	01100011(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 1(j=1)

• • => the 7 most significant bits of the result are known.

Iteration #5

Number of bits of result known up to now: 7
Bit Mask for bits known up to now: 11111110
Bits of result:                  01100000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 2)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 011000.
  • setting bit j (bit 1) to 0because of search for minimum.
  • remaining bits j−1 to 0 (0 to 0) remain at 0.

	For AND: (P1 to P18)	For OR: (P1 to P18)
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	01100001	original	01100001	original
	(01100001)	modified	(01100000)	modified
	01100001	original	01100001	original
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	01100001	original	01100001	original
	(01100001)	modified	(01100000)	modified
	01100001	original	01100001	original
	(01100001)	modified	(01100000)	original
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
	(01100001)	modified	(01100000)	modified
01100001(bit-wise AND)	01100001(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): −1 (j=−1) (i.e. all bits match)

Number of bits of result known up to now: 8
Bit Mask for bits known up to now: 11111111
Bits of result:                  01100001

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 0)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 01100001.
  • bit j (bit −1) does not exist.
  • there are no remaining bits j−1 to 0.
  • => all bits of the result are known, i.e. the result is 01100001=97. Thus, processors P₃, P₅, P₁₂ hold the minimum value.

EXAMPLE 6

Determining a maximum value from values stored in eighteen processors P₁ to P₁₈. (As to the determination for the values for the bit-wise AND and bit-wise OR please see above examples 1 and 2)

Original values:

	P1 = 114	→	01110010
	P2 = 104	→	01101000
	P3 = 97	→	01100001
	P4 = 98	→	01100010
	P5 = 97	→	01100001
	P6 = 114	→	01110010
	P7 = 98	→	01100010
	P8 = 101	→	01100101
	P9 = 114	→	01110010
	P10 = 114	→	01110010
	P11 = 104	→	01101000
	P12 = 97	→	01100001
	P13 = 98	→	01100010
	P14 = 97	→	01100001
	P15 = 114	→	01110010
	P16 = 98	→	01100010
	P17 = 101	→	01100101
	P18 = 114	→	01110010

Iteration #1

Number of bits of result known up to now: 0
Bit Mask for bits known up to now: 00000000
Bits of result:                  00000000

Values given from each processor to the central processor in this iteration:

	For AND: (P1 to P18)	For OR: (P1 to P18)
	01110010	original	01110010	original
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	01110010	original	01110010	original
	01100010	original	01100010	original
	01100101	original	01100101	original
	01110010	original	01110010	original
	01110010	original	01110010	original
	01101000	original	01101000	original
	01100001	original	01100001	original
	01100010	original	01100010	original
	01100001	original	01100001	original
	01110010	original	01110010	original
	01100010	original	01100010	original
	01100101	original	01100101	original
	01110010	original	01110010	original
Bit-wise AND: 01100000	Bit-wise OR: 01111111

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): 4(j=4)

• • => the 4 most significant bits of the result are known.

Iteration #2

Number of bits of result known up to now: 4
Bit Mask for bits known up to now: 11110000
Bits of result:                  01110000

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 5)=matching bits of bit-wise AND and bit-wise OR in iteration #1—in this example 011.
  • setting bit j (bit 4) to 1because of search for minimum.
  • remaining bits j−1 to 0 (bits 3 to 0) remain at 0.

	For AND: (P1 to P18)	For OR: (P1 to P18)
	01110010	original	01110010	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	01110010	original	01110010	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	01110010	original	01110010	original
	01110010	original	01110010	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	01110010	original	01110010	original
	(01111111)	modified	(01110000)	modified
	(01111111)	modified	(01110000)	modified
	01110010	original	01110010	original
01110010(bit-wise AND)	01110010(bit-wise OR)

Highest bit position where bit-wise AND and bit-wise OR differ (counting least significant bit as 0): −1 (j=−1)

Number of bits of result known up to now: 8
Bit Mask for bits known up to now: 11111111
Bits of result:                  01110010

Up to now known bits of result generated by:

• • bits k−1 to j+1 (bits 7 to 0)=matching bits of bit-wise AND and bit-wise OR in iteration #4—in this example 01110010.
  • bit j (bit −1) does not exist.
  • there are no remaining bits j−1 to 0.
  • => all bits of the result are known, i.e. the result is 01110010=114. Thus, processors P₆, P₉, P₁₀, P₁₅, P₁₈ hold the minimum value.

In accordance with the embodiments described above, the number of iterations needed for this way of determining the minimum is only the number of bits, in which the binary representation of any two of the original values, differ. Each iteration necessitates one common read with “AND”, one common read with “OR”, and one broadcast.

The number of bits used to represent numbers is typically 32, or may even be 64, and the number of bits in which a set of values differ, may be even less. If the number n of processors is significantly larger than the number of bits in which the set of values differ, for example, larger by several thousand, the “fast minimum finding” is significantly faster than the trivial way indicated above, which needs n read operations.

Embodiments of the invention were described using a plurality of processors P₁ to P_n each providing a binary value. Other embodiments may use only a single processor or a reduced number of processors each holding in respective registers of memory elements associated therewith the binary values the maximum/minimum of which need to be determined by the central processor.

The above-described method can be implemented in hardware or in software. In addition, the implementation can be in a digital storage medium, for example a disc or a CD comprising electronically readable control signals, which can act together with a programmable computer system, for executing the method according to embodiments of the present invention. Generally, the invention is also a computer program product having a program code for executing the method according to embodiments of the present invention being stored on a machine readable carrier and executed when the computer program product runs of a computer. In other words, the invention is also a computer program having program codes for carrying out the method when the computer program runs on a computer.

While this invention has been described in terms of several embodiments, there are alterations, permutations, and equivalents which fall within the scope of this invention. It should also be noted that there are many alternative ways of implementing the methods and compositions of the present invention. It is therefore intended that the following appended claims be interpreted as including all such alterations, permutations and equivalents as fall within the true spirit and scope of the present invention.

Claims

1-14. (canceled)

15. A method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.

16. The method of claim 15, wherein the predefined value is “1” in case a maximum is to be determined, and wherein the predetermined value is “0” in case a minimum is to be determined.

17. The method of claim 15, wherein for generating a subsequent bit-wise OR combination and a subsequent bit-wise AND combination the selecting comprises: in case the bit value of an original binary value at the bit position determined in the determining corresponds to the predetermined value, selecting the original binary values, and otherwise selecting a modified value; andwherein repeating the determining is based on the subsequent bit-wise OR combination and the subsequent bit-wise AND combination.

18. The method of claim 17, wherein for the subsequent bit-wise OR combination the modified value is formed by the up to now known bits of the minimum/maximum and the remaining bits of the existing bit-wise AND combination, andfor the subsequent bit-wise AND combination, the modified value is formed by the up to now known bits of the minimum/maximum and the remaining bits of the existing bit-wise OR combination.

19. The method of claim 18, wherein the determining comprises: communicating the bit-wise OR combination and the bit-wise AND combination to the memories; andthe selecting comprises: communicating the up to now known bit values of the minimum/maximum to the memories,for the subsequent bit-wise OR combination, instructing each memory to return the original value, in case the bit value at the bit position determined in the determining and all subsequent bit positions, if any, correspond to the up to now known bit values of the minimum/maximum, andotherwise, return the up to now known bit values of the minimum/maximum and the bit values of the remaining bit positions of the existing bit-wise AND combinations, andfor the subsequent bit-wise AND combination, instructing each memory to return the original value, in case the bit value at the bit position determined in the determining and all subsequent bit positions, if any, correspond to the up to now known bit values of the minimum/maximum, andotherwise, return the up to now known bit values of the minimum/maximum and the bit values of the remaining bit positions of the existing bit-wise OR combination.

20. A computer storage medium comprising a computer readable program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only on selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.

21. A computer program product, comprising a computer readable program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.

22. A computer program comprising a program code for carrying out, when executing the program code by a processor, a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.

23. A system for determining a minimum/maximum of a plurality of binary values held by a plurality of memories associated with respective processors, the system comprising: a central processor;a logic coupled to the central processor and configured to output a bit-wise OR combination and a bit-wise AND combination of a plurality of input values to the central processor; anda plurality of memories associated with respective processors, each of the memories being coupled to the logic and configured to hold one of the plurality of binary values,wherein the central processor is configured to operate in accordance with a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.

24. The system of claim 23, wherein the logic is implemented by the central processor.

25. The system of claim 23 being a tester for testing electronic devices, wherein the binary values represent test results.

26. An apparatus for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the apparatus comprising: a processor configured to operate in accordance with a method for determining a minimum/maximum of a plurality of binary values held by a plurality of processor memories or memories associated with respective processors, the method comprising: determining a bit position in the plurality of binary values subsequent to which all bit values are the same, wherein the determining initially comprises: commonly reading all binary values from all memories and generating a bit-wise OR combination and a bit-wise AND combination of the commonly read binary values, andbased on the bit-wise OR combination and the bit-wise AND combination of the commonly read binary values, determining the bit location in the plurality of binary values subsequent to which all bit values are the same;selecting from the plurality of binary values, those binary values, the bit value of which at the bit position determined in the determining and all subsequent bit positions, if any, comprises a predetermined value;repeating the determining and selecting, wherein the determining is repeated on the basis of the binary values selected in the selecting until only one selected binary value, or a plurality of matching binary values, remain; andproviding the remaining binary value as the minimum/maximum.