Abstract:
A method and apparatus for efficiently matching a large collection of user profiles against a large volume of data in a webcasting system. The invention generally includes in one embodiment four steps to parallelize the profiles. First, an initial profile set is partitioned into several subsets also referred to as sub-partitions using various heuristic methods. Second, each sub-partition is mapped onto one or more independent processing units. Each processing unit is not required to have equal processing performance. However, for best performance results, subset data should be mapped in one embodiment where the subset with a highest cost is mapped to a fastest processor, and the next highest cost subset mapped to the next fastest processor. Where appropriate, the invention evaluates the relative subset processing speed of each processor and adjusts future subset mapping based upon these evaluations. For each information item I that needs to be matched with a profile predicate, a third and a fourth step are executed. The third step broadcasts I to all processing units, and a fourth step performs a sequential profile match on I.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The present invention relates to the efficient management of a large collection of user profiles and matching the profiles against a large volume of data. More particularly, the invention concerns a parallel profile matching method that efficiently manages the profiles, matches them to desired data using existing profile matching methods, and efficiently pushes the data to a user. 
     2. Description of the Related Art 
     Within the last twelve months, a new breed of Internet information system called webcasting or “push” systems has attracted enormous attention in the Internet industry. Instead of using a browser to pull information from the Internet, a push system automatically delivers information contents such as news and weather forecasts to a user based on a user&#39;s interest profile. The user&#39;s profile is a collection of predicates that identify the type, quantity or quality of information that should be pushed to the user. Because of its tremendous potential for completely changing the shape of the Internet, the battle for leadership has increasingly intensified. 
     Webcasting technology not only thrives on the Internet, but it can also be effectively applied in corporate intranets to vastly improve business operations and productivity. For example, a sales representative can be constantly alerted with new product information and price updates to better serve his or her customers, or on-line classified advertisements on apartments for rent can be automatically pushed to corporate employees who are looking for a place to live. Another application of webcasting is that newly issued U.S. patents within designated technology fields can be pushed to the users who have interests in them. 
     Currently, information delivered by a webcasting system is typically organized into a hierarchy of content channels. Because of the sheer volume of information in cyberspace, the key to allowing the webcasting technology to realize its full potential is giving users the ability to personalize their information selection and filter out “noise.” For example, a user subscribing to the IBM-Almaden-Seminar channel may use a filter to select only those seminars related to database technology. Non-related seminars or “noise” are thereby filtered out. This kind of personalized information content selection is recorded in user profiles and matched against all the information delivered by webcasting. The common practice in Internet information systems is to use traditional database indexing schemes on information contents, where user profiles are applied to an information index one at a time. 
     A main drawback in webcasting today is the lack of personalization. For example, users cannot customize their profile to only receive information about their favorite team when subscribing to a sports channel. Information covering all teams is usually pushed to the user because it is not possible to personalize the information. 
     At the heart of content personalization is the profile matching problem. Each user has a “personal” profile that specifies his or her interests and is usually represented as a Boolean expression over a basic predicate. A profile matching method will match a document with all profiles in a profile-database and return only those profiles whose Boolean expression is satisfied by the content of the document. This is a computationally expensive problem because of the large subscription volume and the diversity of information content. Regardless, webcasting systems must quickly perform profile matching “on-line” because they must deliver information in a timely fashion. Further, they have to maintain a dynamically changing profile database. 
     Cyberspace continues to expand as more and more people gain access to the Internet, resulting in an exponential increase in user profiles. What is needed is an invention that can perform large scale and high performance profile matching with a parallel profile matching method that can be applied to any Boolean based query language. Preferably, the method would utilize existing sequential profile matching methods currently used in webcasting systems. 
     DEFINITIONS AND NOTATIONS 
     Throughout the following discussion, the following definitions and notations apply: 
     A={A 1 , . . . , A n } is a set of Boolean profile expressions, 
     BP={p 1 , . . . , p m } is a set of basic predicates, 
     W={w 1 , . . . , w m } is a set of weights, that are associated with each basic predicate, and 
     G 1 , . . . , G k  is a set of directed acyclic graphs (DAGs). 
     Each profile expression A i  contains a set of basic predicates, which are connected by the Boolean operators AND, OR and NOT (see FIG.  6 ). A profile expression A i  can be represented by a DAG where the basic predicates are mapped to leaf nodes and the Boolean operators are mapped to inner nodes of the DAG. Using this representation for a set of profile expressions A yields a set of DAGs. All DAGs&#39; root nodes are connected by a single root node to form a single DAG. 
     SUMMARY OF THE INVENTION 
     Broadly, the present invention solves a new technical challenge posed by the rapid growth of webcasting systems: how to efficiently match a large collection of user profiles against a large volume of data using parallel profile matching. 
     The invention may be implemented on a webcasting system that maintains a large collection of user profiles. The user profiles express each users interest and are based on any Boolean query language using basic predicates. These predicates are used to assert certain properties to information items. Basic predicates can be connected together with Boolean operators AND, OR and NOT to form more complex queries. As an example, the profile “Channel(Almaden-Calendar) AND Keyword(database)” expresses that the user is only interested in events at a location Almaden related to database topics. Channel(Almaden-Calendar) and Keyword(database) are examples for basic predicates connected by the AND operator. An example of one such webcasting system may be found in U.S. patent application Ser. No. 08/978,737, by M. Eichstaedt et al, entitled “METHOD AND APPARATUS FOR EFFICIENT PROFILE MATCHING IN A LARGE SCALE WEBCASTING SYSTEM,” filed Nov. 26, 1997, assigned to the assignee of the present invention and incorporated herein by reference. This information delivery system matches information items from a stream of documents against a profile collection and sends a personalized stream of information to each user based upon the user&#39;s profile. 
     In one embodiment, the invention may be implemented to provide a method to partition a profile database and distribute each partition to a separate processor. The invention partitions a large collection of user profiles into smaller profile subsets and assigns those subsets to separate processing units based upon a subset&#39;s cost. A subset&#39;s cost is substantially the cumulative total of the individual costs for profile data contained in the subset. Profiles are partitioned in such a way that each subset can be processed individually without extensive communication with other subsets being processed. 
     The invention includes in one embodiment four steps to parallelize the profiles. First, an initial profile set is partitioned into several subsets (also referred to as sub-partitions) using various heuristic methods. Second, each sub-partition is mapped onto one or more independent processing units. Each processing unit is not required to have equal processing performance. However, for best performance results, subset data should be mapped in one embodiment where the subset with a highest cost is mapped to a fastest processor, and the next highest cost subset mapped to the next fastest processor. Where appropriate, the invention evaluates the relative subset processing speed of each processor and adjusts future subset mapping based upon these evaluations. For each information item I that needs to be matched with a profile predicate, a third and a fourth step are executed. The third step broadcasts I to all processing units, and a fourth step performs a sequential profile match on I. 
     Given a positive integer k, the profile matching problem is to minimize the maximum total weight of the basic predicates in each subset. One method for partitioning and mapping the subsets, called Greedy-Mapping (GM), generates subsets that have a small overlap with each other. Let S 1  and S 2  be two subsets of profiles and let D 1  and D 2  be their DAGs respectively. Let B be the set of basic predicates shared by both D 1  and D 2 , then the overlap between S 1  and S 2  is equal to the total weight of the basic predicates in B. The Greedy-Mapping processes profiles in the profile database one after another. Initially we have k empty subsets (a placeholder for the final partition of the profiles). Based on the notion of overlap, the “fitness” is determined for each profile and the profile is assigned to a subset with the best fitness. 
     In an alternative embodiment, an incremental clustering (IC) method builds the subsets of profiles one after another. The basic idea is to properly choose a profile that can be mapped to the current subset until a certain threshold of the total weight of the basic predicates is reached. Generally, the threshold is determined by the expected total weight of each subset. 
     In another embodiment, the invention may be implemented to provide an apparatus capable of efficiently matching a large collection of user profiles against a large volume of data using parallel profile matching and delivering the data to a user. 
     In still another embodiment, the invention may be implemented to provide a signal-bearing medium tangibly embodying a program of machine-readable instructions executable by a digital data processing apparatus to perform method steps for efficiently matching a large collection of user profiles against a large volume of data using parallel profile matching. 
     The invention affords its users with a number of distinct advantages. One advantage is that the parallel profile matching method automatically partitions a profile database. This provides a scalable method to match a large collection of user profiles against a large volume of data. 
     Another advantage is adaptability. The methods of this invention can adapt to changes in user profiles and information feeds to maintain efficient performance by adjusting the processing load balance of the profiles. As mentioned above, the invention is directed towards information push systems, but can also be applied in notification, alert, or other kinds of information push systems that use a Boolean-based profile language. 
     Yet another advantage is performance. The techniques employed by the invention efficiently utilize dynamic cost/credit information and a logical structure among predicates to achieve high performance over time. In essence, the invention learns as it goes along. One more advantage is that the invention employs a plurality of processors to perform the parallel profile matching. However, the invention intentionally minimizes interaction among the processors to further expedite profile processing. 
     One additional advantage is that the invention utilizes existing sequential matching methods and can be applied to any Boolean based query language. As readily recognizable to one schooled in the art, the invention also provides a number of other advantages and benefits, that will become apparent after reviewing the following description of the invention. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The nature, objects, and advantages of the invention will become more apparent to those skilled in the art after considering the following detailed description in connection with the accompanying drawings, in which like reference numerals designate like parts throughout, and wherein: 
     FIG. 1 is a block diagram of the hardware components and interconnections of a network used to transfer information in accordance with one embodiment of the invention; 
     FIG. 2 is a block diagram of a digital data processing machine shown in FIG. 1 in accordance with the invention; 
     FIG. 3 is a block diagram of a profile matching system for a large-scale webcasting environment in accordance with the invention; 
     FIG. 4 shows a block diagram of a profile engine of FIG. 3 in accordance with one embodiment of the present invention; 
     FIG. 5 is a flowchart of a general operational sequence for profile matching for the large-scale webcasting environment in accordance with one embodiment of the invention; 
     FIG. 6 illustrates a graph used to distinguish data using AND nodes from OR nodes as used in accordance with the invention; 
     FIG. 7 shows a graph used to explain a parallel processing method used to match predicates with desired information in accordance with the present invention; 
     FIG. 8 is a flowchart of an operational sequence for parallel profile matching method in accordance with the invention; and 
     FIGS. 9 is a flow chart of an operational sequence used for the set decomposition of FIG. 8 in accordance with one embodiment of the invention; and 
     FIG. 10 shows an exemplary signal-bearing medium in accordance with the invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     The nature, objects, and advantages of the invention will become more apparent to those skilled in the art after considering the following detailed description in connection with the accompanying drawings. As mentioned above, the invention concerns a method and system for efficiently matching user profiles with desired information. 
     HARDWARE COMPONENTS &amp; INTERCONNECTIONS 
     One aspect of the invention concerns a webcasting system  100 , which may be embodied by various hardware components and interconnections as described in FIG.  1 . 
     The webcasting system may be composed of several independent communicatively-connected functional components. The system  100  may comprise a large number of clients, where each client uses a user interface  102  that is continually updated with information that matches a profile specified by a user. The user interface may be a programming interface or a graphic users interface (GUI), such as those used by push-client vendors. The interface  102  allows a user to specify an address in the webcasting system that may contain information that matches a particular user-specified profile. For instance, a user could define a webcasting location that contains local traffic reports from a public Web server. Any time a traffic report is updated, a copy of the report or a short summary appears on the user interface. In order for the summary to appear, the user interface  102  may be communicatively-connected to a host  108  which is turn may be connected to a central host  114 . The hosts communicate with a profile handler  306  and profile matcher  308  embodied in the webcasting system  100 , shown in FIG. 3, and discussed below. 
     As shown in FIG. 2, any host, such as exemplified by central host  114 , may include a processor  204 , such as a microprocessor, application specific hardware, or other processing machine, coupled to a storage  212 . In the present example, the storage  212  includes fast-access-storage  206  as well as non-volatile storage  208 . The fast-access-storage preferably comprises random access memory, and may be used to store the program instructions executed by the processor  204 . The non-volatile storage  208  may comprise, for example, one or more magnetic data storage disks such as a “hard drive”, a tape drive, or any other suitable storage device. A host may also include an input/output (I/O) controller  202  to coordinate the flow of data and commands to the processor  204 . The I/O controller  202  may be communicatively-linked to lines  106 ,  110  and  112  such as a line, bus, cable, electromagnetic link, communication channel, interface or other means for exchanging data with the processor  204 . A host may include a display  210  comprising a video monitor, printer, memory, or any type of display suitable for displaying the user interface  102 . 
     As shown in FIG. 1, the central host  114  is connected to one or more servers  104  via communication channels  116  and  118 . These communication channels may be a line, bus, cable, electromagnetic link, or any other means used for exchanging data between a user  102  and a server  104 . The server  104  may contain a digital processing apparatus, storage, a database, or various other apparatuses commonly used in Internet server sites. A server  104  of the webcasting system  100  may include a profile system  300  shown in FIG.  3  and used to match a client-specific profile with information located on the server  104 . 
     FIG. 3 shows a logical configuration for a profile system  300  used in one embodiment of the present invention. One or multiple clients  302 —each which access the profile system  300  through the user interface  102  shown in FIG.  1 —communicates with a profile engine  305  comprising a profile handler  306  and a profile matcher  308 . The system  300  may include one or more profile engines  305 . Each profile handler receives specified profiles from a client. Clients  302  are represented as clients  1  through n, where n equals the total number of clients having access to the system  300 . Once a profile is received from a client, the profile is stored in the profile database  304 . If a client  302  is a new user to the profile system  300 , the new client can be registered with the system, and existing profiles contained within the profile database  304  are updated. 
     Registration may be by both open and closed registration. Open registration allows a new user to connect to the profile handler  306  at any time to create a new account on his or her behalf. The new account is then stored in the profile database  304 . Because the overhead to the database  304  for open registration is minimal, any user can create an unlimited number of accounts within a profile. Closed registration refers to all accounts for regular users which must be created by an administrator of the profile handler  306 . The administrator (not shown) initializes new accounts and provides a password for every new user, and may be contained within the profile handler or the server  104 . The administrator and the profile handler  306  are communicatively-coupled to the profile database  304  and data sources  314 - 318 . 
     The profile system  300  may also include one or more profile matchers  308 . A profile matcher compares each information item against each user profile. In other words, each item of information relating to the traffic data referred to in the example above would be matched to each user profile requesting such traffic information. The profile matcher  308  output may be a sequence of tuples in the preferred embodiment that consists of a data pair comprising an information item and a profile identification item. These items are sent to the matching client  302  which in turn displays the items to the user interface  102 . In the preferred embodiment, the profile matcher  308  updates its internal data structure whenever changes to the profiles are made and recorded in profile database  304 . 
     One or more item fetchers  320  may be included in the profile system. An item fetcher  320  may comprise different forms known to those schooled in the art depending on the type of data that is to be distributed by the profile system  300 . For example, FIG. 3 shows an item fetcher  320  for a HTTP server, a DATABASE server and a FILE SYSTEM server. The item fetcher  320  is communicatively-coupled to the profile matcher  308  and each of the components contained therein collect data from a variety of data sources. In the preferred embodiment, the item fetcher  320  periodically delivers a set of information items to the profile matcher  308 . In another embodiment the item fetcher  320  delivers information sets only when requested by the profile matcher  308 . The item fetcher may comprise an apparatus such as shown in FIG. 2 for a host  114 , or may be integral to the structure of a server  104  shown in FIG.  1 . 
     As shown in FIG. 4, the profile engine  305  may include multiple processors  402 . Although pictured in the profile matcher  308 , the processors can be physically located anywhere in the profile system  300  as long as they remain logically configured to perform the profile matcher  308  processing as described below. The processors may be communicatively coupled by a line, bus, cable, electromagnetic link, communication channel, interface or other means for exchanging information. Mapping of data to and from the processors may occur in one embodiment, at least in part, as described below. 
     Despite the specific foregoing description, ordinarily skilled artisans having the benefit of this disclosure will recognize that the apparatuses discussed above may be implemented in machines of different construction without departing from the scope of the invention. As a specific example, the non-volatile storage component  208  of FIG. 2 may be eliminated or replaced by tape storage; furthermore, the fast-access-storage  206  may be provided on-board the processor  204 , or even provided externally to a host  108 . Also, one schooled in the art will readily understand that various processing configurations may be used for the profile handler  306  and the profile matcher  308  to perform their respective processing machinations. For example, the profile handler  306  and profile matcher  308  may be configured similarly to a host apparatus as shown in FIG.  2 . 
     OPERATION 
     In addition to the various hardware embodiments described above, a different aspect of the invention concerns a method for efficient profile matching in a large scale webcasting system. 
     Overall Sequence of Operation 
     FIG. 5 shows a sequence of method steps  500  to illustrate a general example of a Boolean based query language profile method used in one embodiment of the present invention. For ease of explanation, but without any limitation intended thereby, the example of FIG. 5 is described in the context of the webcasting system  100 , and more particularly the profile system  300 , described above. 
     The method of invention allows for scalability and improved performance in large-scale profile matching systems such as found on a server  104  (FIG. 1) commonly used by Internet service providers (Provider). Most subscribers to a Provider share similar interests with other subscribers to the same Provider, and many of the primary predicates specified in a large collection of user profiles are shared by a number of users. In one embodiment, the present invention takes advantage of this relational fact beginning in step  502 , when the method of the present invention is employed, for example, in a server  104 . 
     A profile index is built and maintained in step  504  with a complete collection of user profiles for each basic predicate. Adding a new user profile will have negligible negative effect because most of the basic predicates in the new profile are very likely already represented in the profile index. 
     The underlying data structure for building and maintaining the profile index is a DAG—such as shown in FIG.  6 —widely used in managing data and known to those schooled in the art. Every leaf node of the DAG shown in FIG.  6 —a leaf node being a node without out-going links—corresponds to a predicate pn. Hereafter, the term basic predicate and leaf node will be used interchangeably unless otherwise specified in discussing the rest of the invention. Because every internal node corresponds to a Boolean operator of AND, OR or NOT, the data structure is a AND-OR-GRAPH (AOG). The AOG has a special root node that does not have any incoming links. Each direct child of the root node represents one or more user profiles. Within each profile resides the user specified predicates. 
     After a profile index has been built and maintained in step  504 , the basic predicates of the index are evaluated in step  506 . Evaluation of the basic predicates involves the matching of the user-specified predicate with the information designated by the predicate. However, in performing the evaluation method of step  506 , the matching must take place within a finite amount of time. Additionally, the computation cost of any instance of applying a basic predicate to an information item can always be obtained. The computation cost is represented in the form of a value that reflects the amount of computational resources spent by the evaluation process, which may include processor, memory, I/O, disk space and other associated costs of evaluating a basic predicate. 
     Evaluation of a profile index in step  508  is a method of evaluating a profile index to obtain a truth-value for every predicate of the profile index and to propagate the value upward through the internal nodes of the DAG representing the profile index all the way to the root node. Some of the leaf nodes encountered during the propagation to the root node may not be evaluated because the evaluation of an associated node may make a given leaf node inconsequential to the profile-matching outcome. 
     A cost credit adjustment may be made in one embodiment in step  510 . This dynamic cost/credit adjustment exploits the Boolean structure found within a user profile. Conceptually, the logical process of matching a user profile against an information item is to apply the Boolean expression of the profile to the information content of the item and decide whether the outcome is True or False. For example, suppose a user profile is a Boolean expression Media-Type(text) and Channel(Almaden-Events). If first predicate is evaluated to FALSE, the entire profile can be evaluated to FALSE without checking the second predicate. In other words, the evaluation of the first predicate will cause the second predicate to become a value that does not affect the outcome of the profile matching. 
     Profiles are matched with each other and with the information fitting the profile in step  512 . Whenever new information is received, a bottom-up evaluation is made through the profile index. Bottom-up refers to beginning at the bottom of the DAG and proceeding to the root node of the DAG. Every leaf of the profile index is evaluated to obtain its current Truth-value. Again, the Truth-value is propagated upward to the root node. The Truth-value of each node representing user profiles is then known and matched to a given information item. 
     The profile-to-information matching that occurs in step  512  may include profile customization. A user  102  may “personalize” his profile so that only specific information is matched. For example, the user  102  may customize his profile to receive from a sports web site only information about his favorite team, as opposed to receiving information for all teams for a given day. Further, the present invention will in one embodiment match the personalized profile with the corresponding information using a parallel profile matching method as discussed below. The information, once matched to a profile, is pushed to the user in step  514 . After the information is pushed, the method ends in task  516 . 
     A fuller understanding of the profile matching method  500 —an example of one Boolean based profile matching method—may be found in U.S. patent application Ser. No. 08/978,737, by M. Eichstaedt et al., entitled “METHOD AND APPARATUS FOR EFFICIENT PROFILE MATCHING IN A LARGE SCALE WEBCASTING SYSTEM,” which was filed Nov. 26, 1997, assigned to the assignee of the current invention and incorporated by reference herein. 
     Although a general discussion of one embodiment of the present invention has been made above in regard to FIG. 5, a more detailed discussion of each step follows. 
     A. Query Language for Profile Specification 
     A user profile is a persistent query that specifies the kind of information that is of interest to the user and the query language used dictates the way users specify their profile. This invention assumes a Boolean-based query language where each profile is a set of basic predicates connected by Boolean operators. The invention requires the basic predicates to yield a Truth-value of either True or False when they are applied to an information item. For example, a basic predicate can be in the form of “Media-type(text)” or “Channel(Almaden-Events)”, where the first predicate requires an information item to be represented in text whereas the second predicate requires it to be from Channel(Almaden-Events). 
     The fact that no special property on the basic predicates in the query language is required gives this invention wide applicability. For example, it can be effectively applied to systems where only basic text predicates are used, and to systems employing a rich set of basic predicates that allows the users to select fine-grain features of an information item such as color and shape in images. 
     Furthermore, the method is very adaptable and extensible. For example, the method can effectively be used to match a profile against a set of indexed information items to take advantage of an existing data index. This obviously speeds up the matching process because each data item does not need to be evaluated; only the item identifier contained in the existing data index. The method can also implement multi-predicate evaluation techniques to enhance performance. 
     1. Build/Maintain Profile Index 
     The initial state of the profile index referenced in step  504  of FIG. 5 is best visualized as a graph with only one node—the ROOT. However, building and maintaining a profile index after it has been initialized includes creating a profile, and may include adding a new profile, removing a profile, updating an existing profile, or sharing internal nodes of the profile. 
     a. Creating a Profile 
     To create a profile (P) in a profile index, a new child C of the ROOT must be created for P. New child C is then assigned a profile ID based on the user ID and his or her channel selection, assuming that a profile with this particular ID does not currently exist in the profile index. If an identical ID already exists, it must be removed before inserting the new profile. Based on the Boolean composition of P, the profile index is expanded as follows. 
     If P is in the form of P 1  AND P 2  AND . . . AND Pn, P is marked as an AND node. For each sub-expression Pi (i=1, . . . , n), a check is performed to see if Pi is a basic predicate or not. If Pi is already a basic predicate, then a check is made to find out if the same predicate is already in the profile index. If so, a new link is inserted so that P will point to that node as one of its children. If not, a new leaf node for Pi is entered into the profile index as the child of P. If Pi is not a basic predicate, the same graph expansion process is used recursively. 
     If P is in the form of P 1  OR P 2  OR . . . Pn, P is marked as an OR node. The remaining steps of handling P 1 , . . . , Pn is the same as if P is an AND node as discussed above. 
     If P is in the form of NOT P 1 , P is marked as a NOT node and the remaining steps of handling P 1 , . . . , Pn is the same as if P is an AND node as discussed above. However, the node of P for the unary operator NOT may not be expanded. In this case, a tag is placed on the node P to indicate that its Truth-value should be reverted. If profile P has only one single node, special consideration is needed because a profile node cannot hold a basic predicate. In this case, a new child C of ROOT is created as described above, where C is an AND or an OR node. A new leaf node is initialized which holds the basic predicate of P. This leaf node becomes the only child of the new profile node. If the profile index already has a leaf node with the requested predicate, the same steps of handling P 1  . . . Pn discussed above is used and the existing leaf node is shared. 
     In the preferred embodiment, a reference of all leaf nodes that have been inserted or shared during the steps above are kept in a separate data structure. This data structure allows efficient access to all relevant leaf nodes for a new profile. The optimization and normalization steps which may also be used in one embodiment are discussed below with respect to sharing nodes. 
     b. Removing an Existing Profile 
     If an existing profile needs to be removed, removal is performed similarly to traversing and removing links. For each node visited during the traversal, the link between that node and its parent node is removed. If any node encountered in the process has zero incoming-links, that node is also removed. 
     If a new profile is received, the invention handles processing of a new profile depending upon whether or not the user requesting the profile currently exists in the profile database. If the user requesting a new profile does not exist in the database, then a determination is made as to whether open or closed registration mode is being used. If open registration mode is not being used, the profile is rejected. If open registration is being used, then a new user record is created in the profile database. Open registration and closed registration are discussed above. 
     If the user requesting the new profile does exist in the profile database, then a password may be required in order for the new profile to be received into the profile database. If an incorrect password is supplied, the profile is rejected. However, if the supplied password is correct, the user record in the profile database is updated according to the supplied information. Updating a user record may comprise changing information contained in a current record or creating a new user profile as requested. If the user requested additional profiles, then the method repeats. 
     It is expected that users will update their profiles to adjust for their changing needs for information feeding. A simple way to update an existing profile in the profile index is to remove that profile and then add a new profile as discussed above. For optimization, internal nodes may be shared. 
     c. Sharing Internal Nodes 
     An optimization to significantly reduce the size of the profile is to share internal nodes in the profile index. It is quite possible that many users will share the same interests on certain topics and therefore end up using the same Boolean expression at different levels of their profiles. It may also be true that multiple users will have identical profiles. To exploit this kind of profile redundancy, internal nodes may be shared in the profile index in the preferred embodiment. For an in depth discussion of methods used for sharing internal nodes, reference is made to U.S. patent application Ser. No. 08/978,737, mentioned above. 
     2. Evaluating Basic Predicates 
     Step  506  of FIG. 5 addresses evaluating basic predicates. The present invention employs at least two methods for dealing with these evaluations. 
     a. Evaluating a Single Basic Predicate 
     Generally, the present invention does not require any special method for evaluating a basic predicate and may be evaluated on an individual basis using the group evaluation method discussed below. However, two basic requirements to evaluating basic predicates must be followed. First, the Truth-value of a basic predicate when applied to any information item must always been obtained within a finite amount of time. In other words, if the Truth-value cannot be contained within a designated period of time, the predicate is not evaluated. Second, the computation cost of any instance of applying a basic predicate to a specific information item can always be obtained. Computation cost is represented in the form of a numerical value reflecting the amount of computation resources spent on the evaluation process. This computation time may include costs for the processor, memory, I/O, disk space, etc. 
     b. Group Evaluation of Basic Predicates 
     Basic predicates do not have to be evaluated one at a time. Depending on the nature of the predicates, evaluating a group of predicates at once may yield superior performance. The basic profile-matching process of this invention is very flexible and can easily accommodate the grouping of a set of basic predicates into a single unit to be evaluated together against an information item. The criteria for selecting a predicate group may depend very much on the nature of the predicates and their integration with the overall dynamic cost/credit-based evaluation process. Such kind of integration can be done by assigning different predicates into one or more evaluation groups as discussed below before evaluating a specific information item. These evaluation groups may be mapped to separate processors operating in parallel to process the data. 
     As an example, consider text predicates that require a text document to satisfy certain properties. The evaluation of a text predicate is equivalent of finding a specific text pattern in the document. In other words, a text predicate can be viewed as asserting a text pattern. As discussed in S. Wu et al., “A Fast Method for Multi-Pattern Searching”,  Technical Report TR 94-17, Department of Computer Science, University of Arizona, May 1994; R. S. Boyer et al., “A Fast String Searching Method”,  Communications of the ACM  20, pp. 762-772, October 1977; and S. Wu et al., “Agrep—A Fast Approximate Pattern-Matching Tool”,  Usenix Winter  1992  Technical Conference , San Francisco, pp. 153-162, January 1992, finding multiple text patterns in a document is often more efficient than finding one pattern at a time. 
     3. Using Multiple Processors 
     FIG. 7 shows a DAG  702  constructed for the profile of a user  704 . The DAG  702  is evaluated by a processor A that is used in evaluating predicates P 1 -P 4 . The predicates correspond to specific information that the user  704  wants to be pushed to a designated address or addresses. The address may be an Internet address, a logical address, a telephonic address or any other address that defines a logical or physical location to which the specific information is pushed. Also shown in FIG. 7 is a processor B that is used in evaluating predicates P 2 -P 5  selected for a profile by a user  708 . As discussed above, a DAG  706  is logically constructed to profile the desires of the user  708  and is processed by processor B. 
     In one embodiment, the processor A only processes data relating to a set designated profiles. When the processing of the data is completed, a next data set relating to this set of profiles is processed. The processor B executes commands in a similar manner. There is no communication needed between A and B. In another embodiment, processor A or B may evaluate the data item against the set of predicates common to their profiles. Then, in parallel, they process the predicates that only belong to themselves exclusively. 
     To further expedite the processing, the present invention, in one embodiment, may partition a designated profile and use multiple processors to process the profile data. These processors are preferably dedicated to processing the designated profile to completion before accepting new work. However, in another embodiment, the multiple processors may be shared with other resources while processing a designated profile partition. 
     4. Parallel Profile Matching 
     The profile-to-information matching of step  512  occurs in parallel in one embodiment of the present invention as diagramed in FIG.  8 . 
     Let A={A 1 , . . . , A n }, be a set of profile expressions over a predicate set P={P 1 , . . . P m }. Let G be the reduced DAG for all expressions in A. If the profile system  300  shown in FIGS. 3 and 4 have k processors, the present invention decomposes G into k DAGs G 1 , . . . , G k  in step  804  and maps each sub-DAG to a processor in step  806 . 
     The main cost evaluating a DAG is the evaluation of basic predicates. In order to efficiently handle the partitioning problem, the evaluation work is balanced across multiple processors as shown in FIG.  7 . Dependency or redundancy among the processors is minimized to simplify parallel profile matching and to reduce the overhead. 
     a. Set Decomposition 
     In one embodiment, the present invention decomposes G as shown in step  804  of FIG. 8 using a combinatorial optimization SET DECOMPOSITION as shown in FIG.  9 . In general, this method is summarized as: 
     Given a ground set Γ={g 1 , . . . , g m } with weights {w 1 , . . . , w m }, and a collection of subsets A 1 , . . . , A n  of Γ, and an integer k, construct k subsets of Γ, G 1 , . . . , G k  such that for each i in the range 1≦i≦n, there exists a j such that A i   ⊂ G j . In the preferred embodiment, max          max     j   =   1     k          (       ∑     s   ∈     G   j              w        (   s   )         )                            
     is minimized. 
     Given a collection of Boolean expressions E={E 1 , . . . , E n } over basic predicates BP={P 1 , . . . , P m }, E is first divided into k subsets e 1 , . . . , e k  in step  904 . Thereafter, a DAG G i  is formed for each subset E i  in step  906 . Each expression e ε E is defined as a subset of BP. This results in a natural mapping of the partitioned profiles to SET DECOMPOSITION. The basic predicates are mapped to the ground set Γ in step  908 , the cost for evaluating a predicate is mapped to the weight of a set element in step  910 , and the subset of predicates used by each expression e i  is mapped to A i  in step  912 . The method ends in step  914 . 
     In the following subsection, efficient heuristics for SET DECOMPOSITION as used in various embodiments of the present invention to partition a profile are discussed. 
     b. Greedy Clustering 
     In one embodiment, SET DECOMPOSITION may comprise a greedy scheme for the mapping of steps  908 - 912  of FIG. 9, motivated by list scheduling. A full discussion of list scheduling may be found in R. L. Graham, “Bound for Certain Multiprocessor Anomalies,”  Bell System Technical Journal , 1996, pp. 1563-1581, incorporated herein by reference. For any subset B  ⊂ Γ, let w          w        (   B   )       =       ∑       g   j     ∈   B            w   j                              
     be the total weight of elements in B. For any two subsets B, C εΓ, let overlap (B,C)=w(B∩C). Therefore w(B∪C)=w(B)+w(C)−overlap(B, C). 
     Let π be a permutation of {1, 2, . . . n}. For example, π is the permutation generated by sorting w(A 1 ), . . . , w(A n ) in a descending ordering, or π is the identity permutation. The set A is permeated with π and now assume A is given in order of the permutation. The greedy scheme can be presented as follows: 
     Greedy-Mapping 
     1. Let G 1 , . . . , G k  be k empty sets. 
     2. For i=1 to n, 
     (a) For each j=1, 2, . . . , k, let fitness(j)=w(A i ∪G j )=w(A i )+w(G j )−overlap(A p , G j ). 
     (b) Let j be the index with the smallest fitness. 
     (c) G j =G j ∪A r    
     3. Return G l , . . . , G k . 
     This greedy scheme is used where sets do not have unacceptable overlap, denoted by ply, as          ply        (   A   )       =       (       ∑     j   =   1     n          w        (     A   i     )         )     /     w        (       ⋃     j   =   1     n          A   j       )                                
     The simplicity and efficiency of the Greedy Method makes it very attractive for practical implementations. If a hash function is used to compute the overlap between two sets, the method implements the method in        O        (     k          ∑     i   =   1     n               A   i              )                            
     time. Notice that the number of user profiles is typically of a large scale (e.g., 1,000,000 or more), and the method takes no more than        O        (     k          ∑     i   =   1     n               A   i              )                            
     time. 
     c. β-Mapping 
     The Greedy Method, may not produce a solution close to the optimal solution in the worst case. One such “bad” example follows. 
     Suppose n=k 2  sets A 1,1 , A 2,2  . . . , A k,k , where A ij ={a i,1 , a i,2 , . . . , a i,k , b j }. Notice that A ij1  and A ij2  differ by only one entry, b j1  versus b j2 . The optimal decomposition is to merge all A i, * to give G i  of size 2k. The greedy-method, however, first assigns A 1j  to S j , for all 1≦j≦k. Then it iteratively assigns A ij  for all 2≦i≦k and 1≦j≦k. The cost of its decomposition is more than k 2 +1 and its ratio to the optimal solution is k/2. 
     More specifically, the greedy-method assigns A 2,2  to G 2  instead of G 1 , because the merge of A 2,2  with G 2  (which is A 1,2 ) has size 2k+1 and overlap 1, while the union of A 2,2  with G 1  has size 2k+2 but overlap k. This results in the size 2k+1 being given more weight than the overlap. In another embodiment, this method gives the overlap more credit resulting in a better relationship between the overlap and the size. 
     In this β-Mapping embodiment, β≧1 is a constant. 
     1. Let G 1 , . . . , G k  be k empty set. 
     2. For i=1 to n. 
     (a) for each j=1,2, . . . , k, let fitness(j)=w(A i ∪G j )=w(A i )+w(G j )−β· overlap(A i , G j ). 
     (b) Let j be the index with the smallest fitness. 
     (c) G j =G j ∪A i . 
     3. Return G 1 , . . . , G k . 
     When β=1, the β-Mapping embodiment is the greedy-mapping embodiment. If β=1.1, and the β-Mapping methods are applied to the example above, a decomposition of size 3k occurs because it assigns A ij , for all 1≦j≦k together with A 1,i  to G i . A 1,i  is assigned to G i  because it was assigned as the first k sets. However, if the first k sets in the permutation are A 1,1 , A 2,1 , . . . , A p,1  then the 1.1-mapping finds the optimal decomposition. 
     As shown above, the β-Mapping embodiment of the present invention enjoys the same simplicity and efficiency as the Greedy-Mapping method. But by properly choosing β, better performance can be obtained using β-Mapping instead of greedy-mapping. 
     However, the size of β is not unlimited. There are a two constants α 1  and α 2  such that the performance of β-Mapping method depends on β according to α 1 β+α 2 /β. If β is too large, say ∞, then β-Mapping tends to assign all sets into one component. Conversely, the β-Mapping method may not give enough credit to overlaps. Therefore, cost function is modeled as α 1 β+α 2 /β to determine the parameters α 1  and α 2  after two choices of β, then applying β-Mapping with        β   =           α   1     /     α   2         .                            
     This allows the method to optimize β according to the structure of the profiles. 
     d. Clustering 
     The example and discussion of the previous subsection shows that the performance of both the greedy-mapping method and the β-Mapping method are sensitive to the assignment of the first k sets, hereafter called the “seeds” of the components. 
     Another embodiment of the present invention implements multi-way graph partitioning via clustering. To partition a graph into k subgraphs, clustering starts with k nodes as seeds and tries to grow all seeds simultaneously (e.g., in breadth-first fashion) to obtain k-equally sized subgraphs. At each step, each seed tries to include its neighboring nodes into its components. Any conflict is resolved by making most of the edges local to each component. To obtain better partition, the k seeds should be pairwisely “far” away from each other. 
     In this embodiment, overlap ratio φ(A i , A j ) between A i  and A j  is defined as overlap          (       A   i     ,     A   j       )     /           w        (     A   i     )            w        (     A   j     )           .                            
     Two subsets are “close” if their overlap ratio is large. 
     Accordingly, k mutually faraway seeds are chosen as follows: Let S 1  be the set with the largest weight. For i=2 to k, let S i  be the set with the largest weight among those whose largest overlap ratio with G 1 , . . . , G i−1  is the smallest. Several related heuristics for finding mutually far away seeds are discussed in S. H. Teng, “Greedy Algorithms for Low Energy and Mutually Distant Sampling,”  J. Algorithms , 1999, and incorporated herein by reference. After selecting the first k seeds, the β-Mapping method is applied to the rest of the sets. 
     e. Incremental Clustering 
     In another embodiment, the method for finding k mutually far away seeds can be extended to the design of an incremental clustering method for SET DECOMPOSITION. This incremental clustering method uses the two natural lower bounds on SET DECOMPOSITION, W max =max i w(A i ) and          W   avg     =       (       ∑     i   =   1     n          w        (     A   i     )         )     /     k   .                              
     Let W=max (W max , W avg ). Choose a constant 1≦α≦2. In this implementation, α is chosen to be about 1.1. The method is as follows: 
     1. Let G 1 , . . . , G k  to kempty sets and A={A 1 , . . . , A n }. 
     2. For i=1 to k, 
     (a) If i=1 then let j be the index of the set in A with the largest cost; otherwise, let j be the index of the set in A with the largest cost among those whose largest overlap ratio with G 1 , . . . , G i−1  is the smallest. Let G i =A j . Remove A j  from A. 
     (b) While (w(G i )&lt;αW) and A is not empty: 
     Let j be the index of the set in A whose overlap ratio with G i  is the largest. If w(G i ∪A j )≦αW, then let G i =G i ∪A j . Remove A j  from A; otherwise exit the while loop. 
     3. If A is not empty, apply β-Mapping to the rest of the sets in A. 
     4. Return G 1 , . . . , G k . 
     The Incremental Clustering method grows one cluster at a time until a certain size is reached. The method then chooses a seed that is farthest away from the current clusters to grow a new cluster, and then applies the β-Mapping method to map the rest of the sets. 
     As discussed below, each method of the invention finds a set of sub-DAGs so that each information item can be evaluated using the sub-DAGs. If the evaluation of the sub-DAGs is performed on separate processors, further reductions in overall evaluation time may be realized. 
     Signal-Bearing Media 
     In the context of FIGS. 1 through 3, such a method may be implemented, for example, by operating the profile system  300 , as embodied by a digital data processing apparatus contained within the webcasting system  100 , to execute a sequence of machine-readable instructions. These instructions may reside in various types of signal-bearing media. In this respect, one aspect of the present invention concerns a programmed product, comprising signal-bearing media tangibly embodying a program of machine-readable instructions executable by a digital data processor to perform a method to match user specified profiles with desired information. 
     This signal-bearing media may comprise, for example, RAM (not shown) contained within the webcasting system  100 . Alternatively, the instructions may be contained in another signal-bearing media, such as a magnetic data storage diskette  1000  shown in FIG.  10  and contained within a server  104  or a host  108 , and directly or indirectly accessible by the profile system  300 . Whether contained in the system  100  or elsewhere, the instructions may be stored on a variety of machine-readable data storage media, such as DASD storage (e.g., a conventional “hard drive” or a RAID array), magnetic tape, electronic read-only memory (e.g., ROM, EPROM, or EEPROM), an optical storage device (e.g., CD-ROM, WORM, DVD, digital optical tape), paper “punch” cards, or other suitable signal-bearing media including transmission media such as digital and analog, and communication links and wireless. In an illustrative embodiment of the invention, the machine-readable instructions may comprise software object code, compiled from a language such as C, C-compatible, or other programming language commonly used for programming with respect to the present invention&#39;s environment. 
     OTHER EMBODIMENTS 
     While there have been shown what are presently considered to be preferred embodiments of the invention, it will be apparent to those skilled in the art that various changes and modifications can be made herein without departing from the scope of the invention as defined by the appended claims.