|Publication number||US7529768 B2|
|Application number||US 11/297,292|
|Publication date||5 May 2009|
|Filing date||8 Dec 2005|
|Priority date||8 Dec 2005|
|Also published as||CN1979492A, CN1979492B, US20070136350|
|Publication number||11297292, 297292, US 7529768 B2, US 7529768B2, US-B2-7529768, US7529768 B2, US7529768B2|
|Inventors||Karla Kay Arndt|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (7), Non-Patent Citations (1), Classifications (13), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
1. Technical Field
This invention generally relates to computer data systems, and more specifically relates to an apparatus and methods for analyzing relationships of objects when all objects in combinations are required for problem resolution to determine which objects to place in a container (cache) to improve system performance.
2. Background Art
Computing which items are most advantageous to keep when not all items can fit within a given container constraint is known as a “knapsack” problem. Solutions to this problem are discussed in resources such as the book Knapsack Problems: Algorithms and Computer Implementations by Silvano Martello and Paolo Toth. This book and other published papers address the most efficient algorithms and various problems with existing algorithms in order to solve the problem of finding the correct subset of individual objects to add to a container within a given constraint. However, these references do not solve the problem of how to analyze the objects' relationships when individual objects alone are not the items to be added to the container. In these cases, it is a combination of individual objects that are required in the container for a search request, and by including one combination, other combinations become more advantageous to include.
Attribute caching in a computer directory server is a specific case where knapsack problems are encountered. A type of directory server common in the art is the Lightweight Directory Access Protocol (LDAP) directory. LDAP is an Internet protocol that is used by programs to look up information from an LDAP repository or directory. Thus, LDAP defines the “language” used by client programs to talk to LDAP servers which can store data in any type of repository. On the client side, a client may be an email program, a printer browser, or an address book. LDAP also defines permissions, set by the administrator to allow only certain people to access the data stored in the LDAP directory structure, and optionally keep certain data private. An LDAP schema is a way to describe the format and attributes of data in the server.
Some LDAP type directory servers have a feature known as attribute caching that allows server administrators to define a set of attributes to cache in memory as well as to configure the maximum amount of memory to use for this caching. These attributes are stored in database tables but continually accessing these tables to resolve LDAP searches requires excessive system resources, so the attributes are cached in memory to increase efficiency. If all attributes necessary for resolving an LDAP search are found in the attribute caches in memory, the search will be resolved quickly in memory by the directory server rather than using database queries against the database tables. Therefore, attribute caching is a performance enhancing feature of the directory server.
Attribute caching in the prior art is incredibly difficult to configure. The administrator needs to understand the types of searches done by all applications accessing the server. Even though the server reports which attributes were most frequently used in search filters, it simply cannot report the relationships between the attributes along with all the attributes required to resolve every type of search filter used in the applications and expect the administrator to configure it manually based on real-time usage.
Without a way to cache objects more efficiently when the individual objects are not the items to be added to the container (such as a memory cache), the computer industry will continue to suffer from inefficiency and poor performance.
In accordance with the preferred embodiments, an apparatus and method analyze relationships of objects when all objects in combinations are required for the problem resolution to determine which objects to place in a container (cache) to thereby improve database performance and utility. Preferred embodiments are illustrated with respect to attribute caching in a computer database system, where the attributes or objects that need to be cached are not individual attributes, but combinations of attributes where including one object affects all combinations in which it exists. In other preferred embodiments, attribute caching is described where including a combination of objects affects all other combinations that contain one or more of the individual objects in the included combination.
The foregoing and other features and advantages of the invention will be apparent from the following more particular description of preferred embodiments of the invention, as illustrated in the accompanying drawings.
The preferred embodiments of the present invention will hereinafter be described in conjunction with the appended drawings, where like designations denote like elements, and:
The present invention relates to an apparatus and method to analyze relationships of objects when all objects in combinations are required for the problem resolution. The preferred embodiments are illustrated with respect to attribute caching in a computer database system. For those not familiar with databases and attribute caching, this Overview section provides additional background information that will help to understand the present invention.
The prior art knapsack method is a systematic way to determine what are the most cost beneficial items to store in fast access memory (the knapsack) to decrease the access time for often used items. A basic knapsack routine takes the individual objects, their relative value, and their cost and creates a benefit ratio that is then used against a space constraint to determine which objects are the most beneficial to place in the knapsack.
The table 300 in
The tables in
Continuing with the previous prior art example, the size constraint of 3000 is now considered. With a size constraint of the container equal to 3000, the first two objects chosen would again be CN and SN, each with a size of 500, since they have the larger benefit ratios. The next object with the largest benefit ratio that fits within the remaining size constraint is Objectclass with a size of 1000. Since there still remains room within the constraint (3000 −500 −500 −1000 =1000) the object that has the highest benefit ratio and size less than or equal to 1000 is UID that has a size of 750. With space still remaining, the object Givenname is chosen as the last object that will fit in the container. The results of the objects placed in the knapsack for the constraint size of 3000 according the prior art method is CN, SN, UID, Objectclass and Givenname.
In the previous example, the choice of what to place in the cache was determined by only analyzing the individual objects of the search filters. However, when a search has a combined object, i.e. more than one object, the search filter cannot be resolved in memory unless all objects of the combination are included in the cache. Therefore, caching only single objects would be a waste of processing time and memory if the search filters are using combined objects and all the combined objects don't end up in the cache. Therefore, the relationships between the attributes used in the search filters must be understood in order to determine what combinations of attributes would be most advantageous to cache within the memory constraint defined by the system administrator.
Knapsack methods such as described above have been used in the prior art to determine what attributes to cache in a directory server environment. Attributes of accesses to information are stored by the directory server in memory to reduce the time for repeated accesses to the same information in the directory server. Attribute caching in the prior art is incredibly difficult to configure and is typically a manual process by a systems administrator. To configure attribute caching in the prior art, an administrator needs to understand the types of searches done by all the applications accessing the server. Even though the server reports which attributes were most frequently used in search filters, it does not report the relationships between the attributes along with all the attributes required to resolve every type of search filter used in the applications based on real-time usage. Further if it did report this much information, it would be extremely difficult for the administrator to analyze the information to configure attribute caching manually.
2.0 Detailed Description
While the prior art has addressed the “knapsack” problem of finding the correct subset of individual objects to add to a container within a given constraint, it has not addressed the problem of how to analyze the objects' relationships when individual objects are not the items to be added to the container. In the preferred embodiments the complete combination of objects that is required to be in the container is considered for placement in the container since the container can respond to the request only if all the objects are present. Further, the embodiments herein handle the scenario where including a combination of objects affects all other combinations that contain one or more of the individual objects in the included combination. In the preferred embodiments the object with the highest benefit ratio is not necessarily the object to choose for the given constraint if a combination of other individual objects provides a better overall benefit.
The preferred embodiments herein provide an apparatus and method to analyze relationships of objects when all objects in combinations are required for the problem resolution. Embodiments herein allow a directory administrator to set up autonomical control parameters for attribute caching in a directory server. Referring now to
Main memory 120 in accordance with the preferred embodiments contains data 121, an operating system 122, a directory server 123, an autonomic cache controller 124, a cache 125 and a database 127. Data 121 represents any data that serves as input to or output from any program in computer system 100. Operating system 122 is a multitasking operating system known in the industry as i5/OS; however, those skilled in the art will appreciate that the spirit and scope of the present invention is not limited to any one operating system. In preferred embodiments herein, the memory 120 includes a directory server 123 as described further below. In preferred embodiments, the directory server 123 is an application. In other embodiments, the directory server 123 is part of the operating system 122. The memory 120 further comprises an autonomic cache controller 124, one or more attribute caches 125, and attribute cache parameters 126. The memory 120 also includes a database 127 that is any suitable database, whether currently known or developed in the future. Database 127 includes one or more tables (not shown).
Computer system 100 utilizes well known virtual addressing mechanisms that allow the programs of computer system 100 to behave as if they only have access to a large, single storage entity instead of access to multiple, smaller storage entities such as main memory 120 and DASD device 155. Therefore, while data 121, operating system 122, directory server 123, autonomic cache controller 124, attribute cache 125, the attribute cache parameters 126, and the database 127 are shown to reside in main memory 120, those skilled in the art will recognize that these items are not necessarily all completely contained in main memory 120 at the same time. It should also be noted that the term “memory” is used herein to generically refer to the entire virtual memory of computer system 100, and may include the virtual memory of other computer systems coupled to computer system 100.
Processor 110 may be constructed from one or more microprocessors and/or integrated circuits. Processor 110 executes program instructions stored in main memory 120. Main memory 120 stores programs and data that processor 110 may access. When computer system 100 starts up, processor 110 initially executes the program instructions that make up operating system 122. Operating system 122 is a sophisticated program that manages the resources of computer system 100. Some of these resources are processor 110, main memory 120, mass storage interface 135, display interface 140, network interface 150, and system bus 160.
Although computer system 100 is shown to contain only a single processor and a single system bus, those skilled in the art will appreciate that the present invention may be practiced using a computer system that has multiple processors and/or multiple buses. In addition, the interfaces that are used in the preferred embodiment each include separate, fully programmed microprocessors that are used to off-load compute-intensive processing from processor 110. However, those skilled in the art will appreciate that the present invention applies equally to computer systems that simply use I/O adapters to perform similar functions.
Display interface 140 is used to directly connect one or more displays 165 to computer system 100. These displays 165, which may be non-intelligent (i.e., dumb) terminals or fully programmable workstations, are used to allow system administrators and users to communicate with computer system 100. Note, however, that while display interface 140 is provided to support communication with one or more displays 165, computer system 100 does not necessarily require a display 165, because all needed interaction with users and other processes may occur via network interface 150.
Network interface 150 is used to connect other computer systems and/or workstations (e.g., 175 in
At this point, it is important to note that while the present invention has been and will continue to be described in the context of a fully functional computer system, those skilled in the art will appreciate that the present invention is capable of being distributed as a program product in a variety of forms, and that the present invention applies equally regardless of the particular type of signal bearing media used to actually carry out the distribution. Examples of suitable signal bearing media include: recordable type media such as floppy disks and CD RW (e.g., 195 of
The preferred embodiments herein address the knapsack (cache) situation where the objects that need to be cached are not individual objects, but combinations of objects where including one object affects all combinations in which the object exists. An example will now be described according to embodiments of the present invention and represented in
The table 400 in
Again referring to
Continuing with the example of the first preferred embodiment, a size constraint of 3000 is now considered. With a size constraint of the container equal to 3000, the first combined objects chosen would again be ObjectclassSNUID because it has the largest benefit ratio that fits in the size constraint. Since there is still available space in the cache container constraint (3000−2250=750), the next combined object with the largest benefit ratio that fits within the remaining constraint is determined. In this case, the combined object GivennameSN with a size of 650 is chosen as the last object that will fit in the container. The results of the objects placed in the knapsack for the constraint size of 3000 according this first preferred embodiment is shown in
Depending on the size constraint, a different combination is included in the cache. If the size constraint is small enough such that only one combination can be included, this method of the preferred embodiments may include the same results as the prior art knapsack method. For example, again beginning with the data shown in table 400 in
However, if a larger size constraint is used such that there are multiple objects with high benefit ratios that have a cumulative size less than the constraint, the method herein analyzes the relationships of the objects to determine which objects should be placed in the cache. For the illustrated example of
From looking at the intermediate table shown in
Referring again to
Now referring to
The above methods can similarly be applied “in reverse” to update a changing cache in a changing environment. For example, during autonomic caching where an attribute table was cached, but it no longer should be cached based upon either access rate or size changing (or both). The attribute that is no longer cached needs to be added back into the correct object combinations and sizes not included and the benefit ratio needs to be recalculated to ensure that only those attributes with the greatest benefit within the configured constraint are included in the caching.
This method described above and illustrated with the previous example can be applied to any application where combinations of objects are required in order to solve a problem and the objects are used within multiple combinations. The relationship between the combination of objects as well as information on the individual objects (i.e., in this case, their sizes) must be kept. These variables are required in order to apply the method to object combinations where objects already included modify the factors of other combinations in order to produce new combinations for every iteration. For example the above method could be used in a database environment or other memory storage environment to determine what are the most beneficial items to store in local memory cache for better access times to the more used items. Thus the preferred embodiments are directed to all knapsack or cache applications where the objects to be stored have relationships to other objects that affect the benefit of a single object being placed in the container (cache). Again referring to
The cache parameters of the preferred embodiment include the following:
Cache Parameter: AttributeAutoAdjust—This is a boolean (TRUE|FALSE) parameter that allows the system administrator to turn on and off autonomic caching. When autonomic caching is off, the cache functions as a prior art manual cache and only what is specified in the Cache Parameter: AttributeName is placed in the cache. When autonomic caching is on, the directory server caches attributes according to the other parameters as described herein.
Cache Parameter: AutoAdjustTime—T000000 to T235959—This parameter is a value that allows the system administrator to determine a time boundary on which to perform autonomic caching. The parameter sets a fixed time of day (hours-minutes-seconds) as a boundary on which to perform caching.
Cache Parameter: AutoAdjustTimelnterval—The interval in hours between the times the server autonomically caches. For example, if autoadjusttime is T060000 and timeinterval is 4, the server will autonomically cache at 2 am., 6 am., 10 am., 2 p.m., 6 p.m., and 10 p.m.
Cache Parameter: Size—The maximum amount of memory in kilobytes to use for auto caching.
Cache Parameter: AttributeName—This parameter may comprise several rows of attribute names. The names in this cache are used when the server is in a manual cache mode (Cache Parameter: AutoAdjust=false). The names in this cache are also used for auto caching at startup and when auto caching hasn't yet been updated or when the auto cache doesn't take up the maximum amount of memory. For example, if Cache Parameter: AutoAdjust was false and then modified to true, the server will cache whatever is listed here until the next auto cache runs automatically at the time/interval specified. Or, if auto cache has been executed and the attributes that have been autonomically detected to cache only take up a portion of the memory, the attributes in AttributeName will also be cached.
Referring now to
The described steps above could also be viewed as being performed by the operating system 122 where the directory server 123 is part of the operating system 122. Further, the described steps could be performed by a database engine to cache accesses to data in a database directly without the services provided by a directory server.
The present invention as described with reference to the preferred embodiments provides significant improvements over the prior art. The described apparatus and method provide an efficient method for determining the placement of objects in a cache where the objects have relationships to other objects that affect the benefit of placing the object in the cache. The present invention provides a way to accurately cache most-used information within a given constraint to improve performance of computer data systems.
One skilled in the art will appreciate that many variations are possible within the scope of the present invention. Thus, while the invention has been particularly shown and described with reference to preferred embodiments thereof, it will be understood by those skilled in the art that these and other changes in form and details may be made therein without departing from the spirit and scope of the invention.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6192470 *||29 Jul 1998||20 Feb 2001||Compaq Computer Corporation||Configuration sizer for selecting system of computer components based on price/performance normalization|
|US6457020||20 Mar 2000||24 Sep 2002||International Business Machines Corporation||Query optimization using a multi-layered object cache|
|US6539382 *||29 Apr 1999||25 Mar 2003||International Business Machines Corporation||Intelligent pre-caching algorithm for a directory server based on user data access history|
|US6904433 *||25 Apr 2001||7 Jun 2005||At&T Corp.||Method for using query templates in directory caches|
|US20040024811 *||16 Sep 2002||5 Feb 2004||Hiroshi Kitada||System, computer program product and method for scanning and managing documents|
|US20050021661 *||1 Nov 2001||27 Jan 2005||Sylvain Duloutre||Directory request caching in distributed computer systems|
|US20050203897 *||19 Apr 2005||15 Sep 2005||Olga Kapitskaia||Method for using query templates in directory caches|
|1||*||Ekow Otoo, Optimal file-bundle caching algorithms for data-grids, IEEE. 2004. pp. 1-8.|
|U.S. Classification||1/1, 711/118, 707/E17.12, 711/133, 709/203, 707/999.102, 707/999.003, 707/999.01|
|Cooperative Classification||Y10S707/99943, G06F17/3048, Y10S707/99933|
|3 Jan 2006||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:ARNDT, KARLA KAY;REEL/FRAME:017159/0837
Effective date: 20051205
|17 Dec 2012||REMI||Maintenance fee reminder mailed|
|5 May 2013||LAPS||Lapse for failure to pay maintenance fees|
|25 Jun 2013||FP||Expired due to failure to pay maintenance fee|
Effective date: 20130505