Yahoo! Inc.

Sybase, Inc.

Sybass, Inc.

Girish Vaitheeswaran

Arun Kejariwal

Sapan Panigrahi

Prasanta Ghosh

Vadiraja Bhatt

Praveen Vegulla

Fei Zhou

Srikanth Sampath

Taghi Fatemi

The subject matter disclosed herein relates to alter an expression of executable instructions via a compiler component for use in ranking of electronic documents.

Compiler based code modification for use in document ranking

A computer readable medium stores a program for optimization for a search, and has sets of instructions for receiving a first decision tree. The first decision tree includes several nodes, and each node is for comparing a feature value to a threshold value. The instructions are for weighting the nodes within the first decision tree, determining the weighted frequency of a first feature within the first decision tree, and determining the weighted frequency of a second feature within the first decision tree. The instructions order the features based on the determined weighted frequencies, and store the ordering such that values of features having higher weighted frequencies are retrieved more often than values of features having lower weighted frequencies within the first decision tree.

Efficient data layout techniques for fast machine learning-based document ranking

The subject matter disclosed herein relates to prefetching data for use in ranking of electronic documents via a document ranking component.

Prefetching data for document ranking

Machine-learned ranking algorithms, e.g. for ranking search results, often use a sequence of decision trees involving decision nodes based on threshold values of features. Modules, systems and methods of optimizing such algorithms involve analyzing threshold feature values to determine threshold intervals for each feature and grouping decision trees according to the feature used in a root decision node. Then coalescing the decision trees within each group to form a coalesced group tree for each group and finally coalescing the coalesced group trees to form a coalesced tree that implements the algorithm.

Decision tree coalescing for document ranking

A database system providing self-tuned parallel database recovery is described. In one embodiment, for example, in a database system, a method is described for performing recovery operations using an optimal number of recovery threads, the method comprises steps of: (a) spawning an initial recovery thread to perform recovery operations; (b) measuring I/O (input/output) performance with the initial recovery thread; (c) spawning a subsequent recovery thread to perform recovery operations; (d) measuring I/O performance with the subsequent recovery thread; and (e) as long as I/O performance does not degrade beyond a preselected percentage, repeating steps (c) and (d) for spawning a desired number of additional recovery threads. In another embodiment, the database system auto-tunes the cache during performance of database recovery operations to optimize the performance of recovery operations.

Database system providing self-tuned parallel database recovery

A database system providing methodology for extended memory support is described. In one embodiment, for example, a method is described for extended memory support in a database system having a primary cache, the method comprises steps of: creating a secondary cache in memory available to the database system; mapping a virtual address range to at least a portion of the secondary cache; when the primary cache is full, replacing pages from the primary cache using the secondary cache; in response to a request for a particular page, searching for the particular page in the secondary cache if the particular page is not found in the primary cache; if the particular page is found in the secondary cache, determining a virtual address in the secondary cache where the particular page resides based on the mapping; and swapping the particular page found in the secondary cache with a page in the primary cache, so as to replace a page in the primary cache with the particular page from the secondary cache.

Database system providing methodology for extended memory support

A database system providing improved methods for asynchronous logging of transactions is described. Log records are created describing changes to a database made by a transaction. When a command committing changes to the database for the transaction is received, a logging request is placed in a queue. An asynchronous logging service removes requests from the queue and transfers log records from the transaction to a shared cache. The shared cache stores log records before they are written to the transaction log. The logging service writes log pages containing log records for the transaction from the cache to the transaction log. After all log pages in the cache for the transaction have been written to the transaction log, changes to the database made by the transaction can be committed to the database.

Database system with improved methods for asynchronous logging of transactions

A multi-tier database system is modified such that a middle-tier application server (EJB server) and a database server run on the same host computer and communicate via shared-memory interprocess communication. The system includes a database (e.g., JDBC) driver thread that attaches to the database server, specifically by attaching to the database server's shared memory segment. Operation of the JDBC driver is modified to provide direct access between the middle tier (i.e., EJB server) and the database server, when the two are operating on the same host computer.

Methodology providing high-speed shared memory access between database middle tier and database server

A database system providing a methodology for optimized page allocation is described. During page allocation in the system, once an allocation page with free space has been located in the system's global allocation map or GAM (i.e., using routine page allocation steps), the page identifier for that allocation page is stored in a hint array, as part of that object's (i.e., table's) object descriptor or des. For a table undergoing a lot of splits (i.e., insert-intensive object), the system may store an array of allocation page &ldquo;hints&rdquo; (allocation page identifiers) in the des for that object (e.g., table). The array itself comprises a cache of slots (e.g., eight slots), each of which stores an allocation page identifier (&ldquo;hint&rdquo;) obtained from the GAM (from a GAM traversal occurring during the page allocation process) or is empty (i.e., has not been filled from the GAM and is therefore set to the initial value of null). For example, the first slot may store the page identifier for one allocation page. A second slot may store the page identifier for another, completely different allocation page, and so forth and so on. On subsequent passes through the page allocation process, the system can, rather than going to the GAM, randomly select (e.g., randomly hash on) a particular slot of the cache. In this manner, the incoming clients will, instead of competing for the same first-available allocation page, randomly select among multiple available allocation pages. Since each allocation page itself is protected by a separate latch, the system is able to decrease contention during the page allocation process by randomly accessing different elements of the &ldquo;hint&rdquo; array. In this manner, the system can avoid the computationally-expensive process of page allocation that is usually required as well as avoid contention for the first-available allocation page.

Growing community of inventors

Fremont, CA, United States of America

Girish Vaitheeswaran