Sign up to receive free email alerts when patent applications with chosen keywords are publishedSIGN UP

Abstract:

A "Stochastic Clustering-Based Network Generator" enables rapid formation
of an interconnected hierarchical network structure from an arbitrary
number of agents via an iterative turn-based coalescence process. Given N
agents wishing to coalesce into one hierarchical network, a turn-based
process allows each agent (or the head of each hierarchical cluster of
agents), to randomly decide whether to issue or listen for merge requests
in each round. Issuing a request amounts to contacting a randomly chosen
agent with a merge request. Given multiple received requests, a cluster
head will randomly accept one request for a merge received by any agent
in that cluster. The requesting cluster then merges as a hierarchical
child of the accepting cluster. In a related embodiment, given multiple
merge requests, the request from the smallest cluster is accepted. In
further embodiments, ties of the smallest cluster size are broken based
on various options.

Claims:

1. A method for forming a hierarchical network from an arbitrary set of
agents, comprising steps for: initially designating each agent of an
arbitrary set of agents as a "head node" of its own hierarchical cluster;
initiating an iterative process comprising steps for: causing each head
node of each hierarchical cluster to randomly choose between a role as a
"requestor" and a role as a "listener"; for each requestor, randomly
selecting an agent from the set of agents and sending a merge request to
that agent; for each agent receiving a merge request, recursively passing
that merge request to that agents head node; for each head node acting as
a listener that receives only a single merge request, causing the head
node to accept the merge request; for each head node acting as a listener
that receives multiple merge requests, causing the head node to select a
single one of the multiple merge requests; for all accepted merge
requests, performing a separate disjoint merge to merge the hierarchical
cluster of the requestor as a child cluster to the agent receiving the
corresponding merge request; and repeating the steps of the iterative
process until only a single hierarchical cluster remains for the
arbitrary set of agents.

2. The method of claim 1 wherein causing the head node to select a single
one of the multiple merge requests further comprising steps for randomly
selecting one of the multiple merge requests.

3. The method of claim 1 wherein each requestor keeps track of and sends
its current hierarchical cluster size along with the merge request.

4. The method of claim 3 wherein causing the head node to select a single
one of the multiple merge requests further comprising steps for selecting
the merge request from the head node having the smallest hierarchical
cluster size.

5. The method of claim 4 further comprising steps for breaking a tie of
the smallest hierarchical cluster size between two or more head nodes by
accepting one of the merge requests of tying head nodes randomly.

6. The method of claim 4 further comprising steps for breaking a tie of
the smallest hierarchical cluster size between two or more head nodes by
accepting one of the merge requests of the tying head nodes having a
smallest hierarchical depth.

7. The method of claim 4 further comprising steps for breaking a tie of
the smallest hierarchical cluster size between two or more head nodes by
accepting one of the merge requests of the tying head nodes having a
smallest network latency.

8. A system for forming a hierarchical network of agents, comprising: a
device for identifying an arbitrary set of agents having network
communications capabilities; a device for providing each agent contact
information for each other agent; a device for initially designating each
agent as a root of its own hierarchical cluster; a device for initiating
a round-based coalescence process comprising: a device for causing each
root of each hierarchical cluster to randomly choose between a role as a
"requestor" and a role as a "listener"; a device for causing each
requestor to randomly select an agent from the set of agents and sending
a merge request to that agent; a device for causing each agent receiving
a merge request to recursively pass that merge request to that agents
root; a device for causing each listener that receives only a single
merge request to accept the merge request; a device for causing for each
listener that receives multiple merge requests to select a single one of
the multiple merge requests; a device for performing a separate disjoint
merge for all accepted merge requests to merge the hierarchical cluster
of the corresponding requestor as a child cluster to the agent receiving
the corresponding merge request; and a device for iterating the
round-based coalescence process until only a single hierarchical cluster
remains for the arbitrary set of agents.

9. The system of claim 8 wherein causing each listener to select a single
one of the multiple merge requests further comprises randomly selecting
one of the multiple merge requests.

10. The system of claim 8 wherein each requestor keeps track of and sends
its current hierarchical cluster size along with the merge request.

11. The system of claim 10 wherein causing each listener to select a
single one of the multiple merge requests further comprises selecting the
merge request from the root having the smallest hierarchical cluster
size.

12. The system of claim 11 further comprising breaking a tie of the
smallest hierarchical cluster size between two or more roots by accepting
the merge request of one of the tying roots randomly.

13. The system of claim 11 further comprising breaking a tie of the
smallest hierarchical cluster size between two or more head nodes by
accepting one of the tying head nodes having a smallest hierarchical
depth.

14. The system of claim 11 further comprising breaking a tie of the
smallest hierarchical cluster size between two or more head nodes by
accepting one of the tying head nodes having a smallest computed network
latency.

15. A computer-readable medium having computer executable instructions
stored therein for causing an arbitrary set of agents to coalesce into a
hierarchical network of agents, comprising instructions for: providing
each agent contact information for each other agent; initially
designating each agent as a root of its own hierarchical cluster;
initiating a round-based coalescence process comprising: causing each
root of each hierarchical cluster to randomly choose between a role as a
"requestor" and a role as a "listener"; causing each requestor to
randomly select an agent from the set of agents and sending a merge
request to that agent; causing each agent receiving a merge request to
recursively pass that merge request to that agents root; causing each
listener that receives only a single merge request to accept the merge
request; causing for each listener that receives multiple merge requests
to select a single one of the multiple merge requests; performing a
separate disjoint merge for all accepted merge requests to merge the
hierarchical cluster of the corresponding requestor as a child cluster to
the agent receiving the corresponding merge request; and iterating the
round-based coalescence process until only a single hierarchical cluster
remains for the arbitrary set of agents.

16. The computer-readable medium of claim 15 wherein causing each
listener to select a single one of the multiple merge requests further
comprises randomly selecting one of the multiple merge requests.

17. The computer-readable medium of claim 15 wherein each requestor keeps
track of and sends its current hierarchical cluster size along with the
merge request.

18. The computer-readable medium of claim 17 wherein causing each
listener to select a single one of the multiple merge requests further
comprises selecting the merge request from the root having the smallest
hierarchical cluster size.

19. The computer-readable medium of claim 18 further comprising breaking
a tie of the smallest hierarchical cluster size between two or more roots
by accepting the merge request of one of the tying roots randomly.

20. The computer-readable medium of claim 18 further comprising breaking
a tie of the smallest hierarchical cluster size between two or more head
nodes by accepting one of the tying head nodes having a smallest
hierarchical depth.

Description:

BACKGROUND

[0001] 1. Technical Field

[0002] A "Stochastic Clustering-Based Network Generator" provides various
automated techniques that enable rapid formation of an interconnected
hierarchical network structure from an arbitrary number of agents via an
iterative turn-based coalescence process.

[0003] 2. Background

[0004] Conventional stochastic coalescence techniques typically involve
processes that act via a continuous-time process where the coalescence
rate of two clusters with given masses x,y (which can be either discrete
or continuous) is dictated up to re-scaling by a rate kernel K. One
well-known example of such techniques, referred to as "Kingman's
coalescent," corresponds to the kernel K(x,y)=1 and has been intensively
studied in mathematical population genetics. In general, Kingman's
coalescent can be obtained as the continuous/infinite limit of a process
where at each time t there is a population of N individuals, and each
individual picks a parent at random from the previous generation of
individuals, located in time t+1/N. Other examples of highly studied rate
kernels include "Aldous's continuum random tree" which provides the
additive coalescent K(x,y)=x+y, and "Erdos-Renyi random graphs" which
provide the multiplicative coalescent K(x,y)=xy. These types of classical
stochastic coalescence processes are generally understood to function as
an asynchronous series of individual merges whose occurrences are
governed by independent exponentials.

SUMMARY

[0005] This Summary is provided to introduce a selection of concepts in a
simplified form that are further described below in the Detailed
Description. This Summary is not intended to identify key features or
essential features of the claimed subject matter, nor is it intended to
be used as an aid in determining the scope of the claimed subject matter.
Further, while certain disadvantages of prior technologies may be noted
or discussed herein, the claimed subject matter is not intended to be
limited to implementations that may solve or address any or all of the
disadvantages of those prior technologies.

[0006] In general, a "Stochastic Clustering-Based Network Generator," as
described herein, provides various techniques that enable rapid formation
of an interconnected hierarchical network structure from an arbitrary set
of N agents via an iterative turn-based coalescence process.

[0008] Note also that during the coalescence process, any agent that is
not currently in a hierarchical cluster is considered a "head node," such
agents are also referred to as "singletons," with all agents being
singletons at the initialization of the coalescence process. Furthermore,
all hierarchical clusters of two or more agents have a single agent at
the root of that cluster (i.e., the uppermost level in the
hierarchically) that acts as the head node of that cluster. Therefore,
once the coalescence is complete, there will be only a single
hierarchical network structure with a single head node for the entire
cluster of agents.

[0009] At each turn or round of the iterative turn-based coalescence
process, each head node makes a random determination as to whether it
will receive merge requests or issue merge requests. Head nodes making or
issuing requests are referred to herein as "requestors," while head nodes
receiving requests are referred to herein as "listeners."

[0010] When a requestor issues a merge request, that request is sent to a
single randomly chosen agent from within the entire set of agents.
Requests received by an agent that is not a head node are recursively
passed by that agent to its head node. Requests received by a head node
that is also a requestor in the current round are ignored by that head
node. One or more requests received by a head node, either directly or
when passed up from a child agent, are considered for acceptance by that
head node only when the head node is acting as a listener in the current
round.

[0011] In particular, a listener receiving only one request will simply
accept that request for a merge. However, given multiple received
requests, a listener will randomly accept only one of the requests for a
merge. When a request is accepted by a listener, the requestor, along
with any child cluster attached to that requestor, merges with the
listener as a direct child of the agent that was originally contacted
with the merge request to form a hierarchy. The above-summarized
turn-based process then repeats until all agents or agent clusters have
merged to the point where a single hierarchical network structure has
been formed with a single head node.

[0012] In a related embodiment, merge requests are sent along with the
current cluster size of the requestor. In this embodiment, given multiple
merge requests received by a listener, the merge request from the head
node of the smallest cluster is accepted rather than making a random
acceptance. In various embodiments, ties of the smallest cluster size are
broken based on various options such as random selection of the smallest,
overall cluster network latency, maximum or minimum cluster hierarchical
depth, etc. Further, in additional embodiments, the length of any branch
in the hierarchical structure is capped at a predetermined or
user-adjustable maximum value such that requests to an agent already at
that maximum length will simply be ignored by that agent or that agents
head node.

[0013] In view of the above summary, it is clear that the Stochastic
Clustering-Based Network Generator described herein provides various
techniques that enable rapid formation of an interconnected hierarchical
network structure from an arbitrary number of agents via an iterative
turn-based coalescence process. In addition to the just described
benefits, other advantages of the Stochastic Clustering-Based Network
Generator will become apparent from the detailed description that follows
hereinafter when taken in conjunction with the accompanying drawing
figures.

DESCRIPTION OF THE DRAWINGS

[0014] The specific features, aspects, and advantages of the claimed
subject matter will become better understood with regard to the following
description, appended claims, and accompanying drawings where:

[0015]FIG. 1 illustrates an exemplary architectural flow diagram that
illustrates program modules for implementing various embodiments of a
"Stochastic Clustering-Based Network Generator" that automatically forms
a hierarchical network structure from an arbitrary set of computing
devices (referred to herein as "agents") via a turn-based coalescence
process, as described herein.

[0016]FIG. 2 provides illustration of a set of arbitrary agents in
communication via various wired or wireless communications protocols, as
described herein.

[0017]FIG. 3 illustrates an exemplary coalescence sequence for an
arbitrary set of agents into a hierarchical network structure, as
described herein.

[0018]FIG. 4 is a general system diagram depicting a simplified
general-purpose computing device having simplified computing and I/O
capabilities for use in implementing various embodiments of the
Stochastic Clustering-Based Network Generator, as described herein.

DETAILED DESCRIPTION OF THE EMBODIMENTS

[0019] In the following description of the embodiments of the claimed
subject matter, reference is made to the accompanying drawings, which
form a part hereof, and in which is shown by way of illustration specific
embodiments in which the claimed subject matter may be practiced. It
should be understood that other embodiments may be utilized and
structural changes may be made without departing from the scope of the
presently claimed subject matter.

[0020] 1.0 Introduction:

[0021] In general, a "Stochastic Clustering-Based Network Generator," as
described herein, provides various techniques that enable rapid formation
of an interconnected hierarchical network structure from an arbitrary set
of N agents via an iterative turn-based coalescence process. The
synchronous nature of this coalescence process is enabled by rounds where
all clusters of agents act simultaneously and the outcome of a round is a
set of multiple disjoint merges that are a function of these combined
actions.

[0023] Note also that during the coalescence process, any agent that is
not currently in a hierarchical cluster is considered a "head node," such
agents are also referred to as "singletons," with all agents being
singletons at the initialization of the coalescence process. Furthermore,
all hierarchical clusters of two or more agents have a single agent at
the root of that cluster (i.e., the uppermost level in the
hierarchically) that acts as the head node of that cluster. Therefore,
once the coalescence is complete, there will be only a single
hierarchical network structure with a single head node (i.e., a single
root) for the entire cluster of agents.

[0024] In contrast to conventional stochastic coalescence techniques where
the coalescence rate of two clusters is given by some rate kernel K as a
function of their masses, the coalescence rate of the Stochastic
Clustering-Based Network Generator is a function of the entire cluster
distribution. Furthermore, in contrast to conventional "Random Mate" type
applications (which have been used for purposes such as parallel graph
components and parallel tree contraction), the network coalescence
processes described herein evolve through time without the need for any
of the agents to consider the distributions or clusters of other peers.

[0025] In various embodiments, the arbitrary set of N agents is
periodically or occasionally constructed or updated using any desired
technique for forming a list or index of participating or available
agents (e.g., by using the agents to identify themselves to each other
using various P2P techniques). Each agent is then provided either with a
copy of the resulting list or index of agents, or provided with access to
the resulting list or index. Advantageously, using the agents to
self-report using various P2P type techniques eliminates the need for a
central server or the like to identify or maintain the list or set of
agents. However, it should be understood that a central server could be
used for this purpose, if desired. In either case, it should be
understood that the coalescence processes described herein assume that
the list or index of agents is available to the agents at the beginning
of the coalescence process, and that formation of this list or index is
not generally performed at the beginning of any particular network
formation session.

[0026] Note that it has been observed that the above-described process
that makes a random selection given multiple requests to a listener
concludes in superlogarithmic time relative to the number of agents.
However, in the related embodiment where incoming merge requests from the
smallest cluster are favored in the case of multiple requests to a
listener, it has been observed that this process coalesces much faster
with conclusion of network formation occurring in a number of rounds that
is logarithmic in N (i.e., the total number of agents).

[0027] 1.1 System Overview:

[0028] As noted above, the "Stochastic Clustering-Based Network
Generator," provides various techniques that enable rapid formation of an
interconnected hierarchical network structure from an arbitrary set of N
agents via an iterative turn-based coalescence process. The processes
summarized above are illustrated by the general system diagram of FIG. 1.
In particular, the system diagram of FIG. 1 illustrates the
interrelationships between program modules for implementing various
embodiments of the Stochastic Clustering-Based Network Generator, as
described herein. Furthermore, while the system diagram of FIG. 1
illustrates a high-level view of various embodiments of the Stochastic
Clustering-Based Network Generator, FIG. 1 is not intended to provide an
exhaustive or complete illustration of every possible embodiment of the
Stochastic Clustering-Based Network Generator as described throughout
this document.

[0029] In addition, it should be noted that any boxes and interconnections
between boxes that may be represented by broken or dashed lines in FIG. 1
represent alternate embodiments of the Stochastic Clustering-Based
Network Generator described herein, and that any or all of these
alternate embodiments, as described below, may be used in combination
with other alternate embodiments that are described throughout this
document.

[0030] In general, as illustrated by FIG. 1, the processes enabled by the
Stochastic Clustering-Based Network Generator begin operation by using an
initialization module 100 running on each agent that initializes each
agent as a singleton (i.e., head node of a single-agent cluster) and
provides each agent with a list or set of all other participating agents.
Further, this list or set of available agents includes the information
necessary (e.g., IP address, etc.) for each agent to contact any other
agent in the set of agents.

[0031] Note that In various embodiments, the list or set of participating
agents is periodically or occasionally constructed or updated by an
optional indexing module 103. In general, the indexing module 103 uses
conventional means, such as, for example, typical P2P techniques that
allow peers (or agents) to contact other peers using various wired or
wireless reporting protocols. In other words, the indexing module 103
uses any desired technique for forming a list or index of participating
or available agents whenever necessary, with that list or index then
being provided to participating agents, as needed. However, it should be
understood that the coalescence processes described herein assume that
the list or index of agents is available to each participating agent at
the beginning of the coalescence process, and that formation of this list
or index is not generally performed at the beginning of any particular
network formation session.

[0032] Following the initialization process performed by the
initialization module 100, a role selection module 105 running on each
head node is used at the beginning of each round to allow all head nodes
to make a random selection from one of two available roles for the
current round. The available roles include a "requestor" agent that will
make merge requests and a "listener" agent that will receive merge
requests for the current round.

[0033] Once these roles have been selected, a merge request module 110
running on each requestor agent is used by requestors to send a merge
request to a randomly selected agent from within the entire set of
agents. Note that in various embodiments, this request may also include
additional optional information that includes, but is not limited to
cluster size of the requestor, hierarchical depth (number of levels) of
agent children of the requestor, requestor cluster network latency
information (may also be automatically derived from packet information on
the network), etc.

[0034] Once each of the requestors has sent a request to a randomly
selected agent, a request validation module 115 running on each agent
makes a determination as to whether any received merge requests are
valid. In particular, requests received by an agent that is not a head
node are recursively passed by that agent to its head node. Requests
received by a head node that is also a requestor in the current round are
ignored by that head node. One or more requests received by a head node,
either directly or when passed up from a child agent, are considered to
be valid merge requests by that head node only when the head node is
acting as a listener in the current round.

[0035] In a related embodiment, valid merge request are further evaluated
by a request evaluation module 120. In general, the request validation
module 120 optionally rejects or invalidates otherwise valid merge
requests from clusters that are already at a maximum allowable size
and/or that are already at a maximum allowable hierarchical depth. Note
that an optional UI module 125 is provided in various embodiments to
adjust or set these maximum values.

[0036] In either case, once one or more valid requests are available to
any head node acting in the role of a listener in the current round, each
of those listeners decide whether to accept a single one of those merge
requests. In particular, if the listener has received 130 only a single
valid request, then that merge request is accepted 135. However, if any
listener has received two or more valid requests for the current round,
then a request selection module 140 is used by that listener select a
single merge request from among the available valid merge requests. In
general, given multiple valid merge requests, the listener will simply
make a random selection from among those requests, with the single
selected request then being accepted 135. Note that due to the random
nature of merge requests, it is also possible that any particular
listener will not receive any merge requests in a particular round.

[0037] In various embodiments, rather than select a random request, the
request selection module 140 is used by the listener to optionally select
a single request originating from the cluster having the smallest size.
In this case, it is possible that multiple requests can originate from
different clusters having the same smallest size. Therefore, to address
such issues, an optional tie-breaker module 145 is provided to select
from among two or more merge requests from clusters having the same
smallest size. Tie breaking in this case is performed based on one of
several optional criteria. For example, in one embodiment, a single
selection from among tied requests is made via a random 150 selection. In
another embodiment, a single selection from among tied requests is made
via by selecting the cluster having the smallest hierarchical depth 155.
In another embodiment, a single selection from among tied requests is
made by selecting the cluster having the smallest network latency 160.

[0038] Once one or more of the listeners have accepted a single request, a
merge module 165 is used to perform the corresponding disjoint merges. In
particular, the requestor, along with any child agents clustered or
attached to that requestor, merge with the listener cluster as a direct
child of the agent that was originally contacted with the merge request
to form a hierarchy.

[0039] A check 170 is then made to determine whether all of the agents
have coalesced into a single cluster. If true, the coalescence is
complete 175. However, if the agents have not all coalesced into a single
cluster, the above-summarized turn-based process then repeats, beginning
with a new round using the role selection module 105, until all agents or
agent clusters have merged to the point where a single hierarchical
network structure has been formed with a single head node.

[0040] 2.0 Operational Details:

[0041] The above-described program modules are employed for implementing
various embodiments of the Stochastic Clustering-Based Network Generator.
As summarized above, the Stochastic Clustering-Based Network Generator
provides various techniques that enable rapid formation of an
interconnected hierarchical network structure from an arbitrary set of
agents. Note that FIG. 2 illustrates an example of an arbitrary set of
agents (205 through 260) that are in communication across a network or
the internet 265 or some other communications net via various wired or
wireless communications protocols.

[0042] The following sections provide a detailed discussion of the
operation of various embodiments of the Stochastic Clustering-Based
Network Generator, and of exemplary methods for implementing the program
modules described in Section 1 with respect to FIG. 1. In particular, the
following sections provides examples and operational details of various
embodiments of the Stochastic Clustering-Based Network Generator,
including: basic operation; additional optional embodiments and
enhancements; and a discussion of an exemplary merge scenario for
creating a hierarchical network structure from an arbitrary set of
agents.

[0043] 2.1 Basic Operation:

[0044] As noted above, at each turn or round of the iterative turn-based
coalescence process, each head node makes a random determination as to
whether to receive requests or to issue requests. Agents making or
issuing requests are referred to herein as "requestors," while agents
receiving requests are referred to herein as "listeners."

[0045] Issuing a request amounts to contacting a randomly chosen agent
from the entire set of agents with a merge request. Requests received by
an agent that is not a head node are recursively passed by that agent to
its head node. Requests received by a head node that is also a requestor
agent are ignored. Requests received by a listener agent are considered
for acceptance.

[0046] More specifically, the stochastic distributed coalescence processes
described herein allows an arbitrary set of N participating agents to
reliably and efficiently coalesce into a single hierarchal cluster
without the need to rely on a centralized authority such as a central
server computer or the like. The protocol first identifies each agent as
a cluster (a singleton), and then proceeds in rounds as follows:

[0047] 1. Each head node independently and randomly chooses to act either
as a listener or as a requestor.

[0049] 3. Agents that receive requests recursively pass them to their
parents until the requests reach head nodes.

[0050] 4. Each listening head node that receives only a single request
accepts that request and forms a two-way connection with the requesting
head node. For accepted requests, the cluster of the requesting head node
is merged with the agent receiving its request, with that requestor
becoming a child of that agent.

[0051] 5. Each listening head node that receives multiple requests
randomly chooses one request to accept. This acceptance results in a
merge as described above in Step 4.

[0052] 2.2 Additional Embodiments and Enhancements:

[0053] The techniques described in Section 2.1 are adapted using various
optional enhancements to improve the overall coalescence process as
discussed below. In particular, the primary modification to the
above-described process relates to the choice of which merge-request a
cluster should approve if that cluster receives multiple requests. It has
been observed that the modification to favor the smallest incoming
request is sufficient to guarantee coalescence in a number of rounds that
is logarithmic in N, while generally providing a more balanced
hierarchical structure.

[0054] The protocol proceeds through a sequence of rounds. In contrast to
the basic process described above, to enable the consideration of cluster
size in choosing between multiple merge requests, agents maintain the
following two pieces of information throughout the process: the identity
of their "parent," and an integer value representing the current size of
their connected component. At the beginning, each agent's parent is
initialized to equal the agent itself (i.e., each agent is initially a
singleton that is the head node of its own single-agent cluster), and all
of the integers are initialized to equal 1. Throughout the process,
whenever an agent's parent is equal to itself, it is called a "head
node," and its integer will equal the size of its connected component
(i.e., the total number of agents in the cluster).

[0055] Given this additional information, the following occurs at each
round:

[0056] 1. Each head node independently and randomly chooses to act either
as a listener or as a requestor.

[0057] 2. Each requestor independently sends a connection request to a
uniformly random agent, including information about the current size of
its connected component.

[0058] 3. Agents that receive requests recursively pass them to their
parents until the requests reach head nodes.

[0059] 4. Each listening head node that only receives a single request
accepts that request and forms a two-way connection with the requesting
head node. For accepted requests, the cluster of the requesting head node
is merged with the agent receiving its request, with that requestor
becoming a child of that agent. The corresponding head node of the
listener accepting the merge request then updates its integer count to
include the number of agents in the newly merged cluster.

[0060] 5. Each listening head node that receives multiple requests chooses
the request coming from the smallest cluster, breaking ties if necessary.
Further, as discussed above, the tie-breaking process can be random, a
function of hierarchical depth, cluster network latency, etc. This
acceptance results in a merge as described above in Step 4.

[0061] 2.3 Exemplary Merge Scenario:

[0062]FIG. 3 provides a simplified example of an exemplary merge scenario
under which the techniques enabled by the Stochastic Clustering-Based
Network Generator result in the rapid coalescence of an arbitrary set of
agents into a hierarchical network. It should be understood that the
example described below is provided only for purposes of explanation and
is not intended to be representative of all of the different embodiments
of the Stochastic Clustering-Based Network Generator described herein.

[0073] Results of the above-described merge requests are explained as
follows:

[0074] Both A and J requested a merge with C. A's request is
randomly accepted by listener C for merge over J's. Note here that as
discussed above, given the two requests, the acceptance decision can
alternately be made using other criteria such as smallest cluster size,
with tie breaking, as necessary;

[0075] B's request to K is accepted
since it is the only request to listener K;

[0076] F's request to M
ignored since both are requestors;

[0077] H's request to E is accepted
since it is the only request to listener E;

[0078] L's request to A
ignored since both are requestors;

[0079] M's request to I ignored since
both are requestors;

[0080] N's request to G is accepted since it is the
only request to listener G;

[0081] Once all of the above merge decisions have been made, the
corresponding disjoint merges are performed for the accepted merge
requests, resulting in the set of clusters shown in box 310.

[0113] Requestor J then issues the following merge requests to a randomly
selected agent:

[0114] J requests merge with K;

[0115] Results of the above-described merge request is explained as
follows:

[0116] J's request to K accepted by head node G since it is
the only request to listener G;

[0117] Once the above merge decision has been made, the corresponding
disjoint merge is performed for the accepted merge request, resulting in
the set of clusters shown in box 350. Finally, as illustrated by box 350
of FIG. 3, following the fifth round, all of the agents are now in a
single hierarchical network structure. Therefore, the coalescence process
terminates.

[0118] 3.0 Exemplary Operating Environments:

[0119] The Stochastic Clustering-Based Network Generator described herein
is operational within numerous types of general purpose or special
purpose computing system environments or configurations. FIG. 4
illustrates a simplified example of a general-purpose computer system on
which various embodiments and elements of the Stochastic Clustering-Based
Network Generator, as described herein, may be implemented. It should be
noted that any boxes that are represented by broken or dashed lines in
FIG. 4 represent alternate embodiments of the simplified computing
device, and that any or all of these alternate embodiments, as described
below, may be used in combination with other alternate embodiments that
are described throughout this document.

[0120] For example, FIG. 4 shows a general system diagram showing a
simplified computing device such as computer 400. Such computing devices
can be typically be found in devices having at least some minimum
computational capability, including, but not limited to, personal
computers, server computers, hand-held computing devices, laptop or
mobile computers, communications devices such as cell phones and PDA's,
multiprocessor systems, microprocessor-based systems, set top boxes,
programmable consumer electronics, network PCs, minicomputers, mainframe
computers, audio or video media players, etc.

[0121] To allow a device to implement the Stochastic Clustering-Based
Network Generator, the device should have a sufficient computational
capability and system memory to enable basic computational operations as
well as some form of network communications capabilities. In particular,
as illustrated by FIG. 4, the computational capability is generally
illustrated by one or more processing unit(s) 410, and may also include
one or more GPUs 415, either or both in communication with system memory
420. Note that that the processing unit(s) 410 of the general computing
device of may be specialized microprocessors, such as a DSP, a VLIW, or
other micro-controller, or can be conventional CPUs having one or more
processing cores, including specialized GPU-based cores in a multi-core
CPU.

[0122] In addition, the simplified computing device of FIG. 4 may also
include other components, such as, for example, a communications
interface 430. The simplified computing device of FIG. 4 may also include
one or more conventional computer input devices 440 (e.g., pointing
devices, keyboards, audio input devices, video input devices, haptic
input devices, devices for receiving wired or wireless data
transmissions, etc.). The simplified computing device of FIG. 4 may also
include other optional components, such as, for example, one or more
conventional computer output devices 450 (e.g., display device(s) 455,
audio output devices, video output devices, devices for transmitting
wired or wireless data transmissions, etc.). Note that typical
communications interfaces 430, input devices 440, output devices 450, and
storage devices 460 for general-purpose computers are well known to those
skilled in the art, and will not be described in detail herein.

[0123] The simplified computing device of FIG. 4 may also include a
variety of computer readable media. Computer readable media can be any
available media that can be accessed by computer 400 via storage devices
460 and includes both volatile and nonvolatile media that is either
removable 470 and/or non-removable 480, for storage of information such
as computer-readable or computer-executable instructions, data
structures, program modules, or other data. By way of example, and not
limitation, computer readable media may comprise computer storage media
and communication media. Computer storage media includes, but is not
limited to, computer or machine readable media or storage devices such as
DVD's, CD's, floppy disks, tape drives, hard drives, optical drives,
solid state memory devices, RAM, ROM, EEPROM, flash memory or other
memory technology, magnetic cassettes, magnetic tapes, magnetic disk
storage, or other magnetic storage devices, or any other device which can
be used to store the desired information and which can be accessed by one
or more computing devices.

[0124] Storage of information such as computer-readable or
computer-executable instructions, data structures, program modules, etc.,
can also be accomplished by using any of a variety of the aforementioned
communication media to encode one or more modulated data signals or
carrier waves, or other transport mechanisms or communications protocols,
and includes any wired or wireless information delivery mechanism. Note
that the terms "modulated data signal" or "carrier wave" generally refer
a signal that has one or more of its characteristics set or changed in
such a manner as to encode information in the signal. For example,
communication media includes wired media such as a wired network or
direct-wired connection carrying one or more modulated data signals, and
wireless media such as acoustic, RF, infrared, laser, and other wireless
media for transmitting and/or receiving one or more modulated data
signals or carrier waves. Combinations of the any of the above should
also be included within the scope of communication media.

[0125] Further, software, programs, and/or computer program products
embodying the some or all of the various embodiments of the Stochastic
Clustering-Based Network Generator described herein, or portions thereof,
may be stored, received, transmitted, or read from any desired
combination of computer or machine readable media or storage devices and
communication media in the form of computer executable instructions or
other data structures.

[0126] Finally, the Stochastic Clustering-Based Network Generator
described herein may be further described in the general context of
computer-executable instructions, such as program modules, being executed
by a computing device. Generally, program modules include routines,
programs, objects, components, data structures, etc., that perform
particular tasks or implement particular abstract data types. The
embodiments described herein may also be practiced in distributed
computing environments where tasks are performed by one or more remote
processing devices, or within a cloud of one or more devices, that are
linked through one or more communications networks. In a distributed
computing environment, program modules may be located in both local and
remote computer storage media including media storage devices. Still
further, the aforementioned instructions may be implemented, in part or
in whole, as hardware logic circuits, which may or may not include a
processor.

[0127] The foregoing description of the Stochastic Clustering-Based
Network Generator has been presented for the purposes of illustration and
description. It is not intended to be exhaustive or to limit the claimed
subject matter to the precise form disclosed. Many modifications and
variations are possible in light of the above teaching. Further, it
should be noted that any or all of the aforementioned alternate
embodiments may be used in any combination desired to form additional
hybrid embodiments of the Stochastic Clustering-Based Network Generator.
It is intended that the scope of the invention be limited not by this
detailed description, but rather by the claims appended hereto.