Abstract: An apparatus, system, and storage medium that in an embodiment collect a performance metric of a first partition in a logically-partitioned computer. If the difference between the performance metric and an expected performance metric exceeds a threshold, then a job or another partition is shut down or suspended. The expected performance metric is calculated based on the performance that is expected if the first partition is the only partition.

Abstract: A parallel computer system has multiple nodes that have independent clocks, where the different nodes may include different database portions that are referenced by a query. A timestamp parameter in a query is synchronized across the different nodes that are referenced by the query to assure the timestamps in the different nodes are consistent with each other notwithstanding the independent clocks used in each node. As a result, a database may be scaled to a parallel computer system with multiple nodes in a way that assures the timestamps for different nodes referenced during a query have identical values.

Abstract: A method and apparatus creates and manages persistent memory (PM) in a multi-node computing system. A PM Manager in the service node creates and manages pools of nodes with various sizes of PM. A node manager uses the pools of nodes to load applications to the nodes according to the size of the available PM. The PM Manager can dynamically adjust the size of the PM according to the needs of the applications based on historical use or as determined by a system administrator. The PM Manager works with an operating system kernel on the nodes to provide persistent memory for application data and system metadata. The PM Manager uses the persistent memory to load applications to preserve data from one application to the next. Also, the data preserved in persistent memory may be system metadata such as file system data that will be available to subsequent applications.

Abstract: A method, apparatus, and program product share a resource in a computing system that includes a plurality of computing cores. A request from a second execution context (“EC”) to lock the resource currently locked by a first EC on a first core causes replication of the second EC as a third EC on a third core. The first and third ECs are executed substantially concurrently. When the first EC modifies the resource, the third EC is restarted after the resource has been modified. Alternately, a first EC is configured in a first core and shadowed as a second EC in a second core. In response to a blocked lock request, the first EC is halted and the second EC continues. After granting a lock, it is determined whether a conflict has occurred and the first and second EC are particularly synchronized to each other in response to that determination.

Abstract: An apparatus, program product and method for determining a cost for using a standby resource that accounts for the cause for the resource=s usage. A standby resource, such as a processor, is activated in response to a resource requirement. The cause of the resource requirement is automatically determined. The result of that automatic determination is used to determine a charge indicator for using the standby resource. For instance, performance code associated with a failure may be associated with a charge indicator. A user may later be billed according to the determined charge indicator, i.e., according to their actual use of the standby resource and/or their usage status.

Abstract: A performance monitor reports SAN performance so that issues within the SAN are not masked from the client. Accesses to the SAN may be grouped into the categories of SAN logical or SAN physical. In one specific embodiment, the ranges of service times for accesses to the SAN are determined by monitoring service times of accesses to the SAN from the client perspective. In another specific embodiment, the ranges of service times for the SAN are determined by the SAN returning data with each request that indicates the service time from the SAN perspective. This allows reporting not only SAN logical and SAN physical accesses, but also allows reporting SAN service time. By specifying SAN service time, the client is able to better determine network delays. In yet another embodiment, information is returned by the SAN to indicate whether the access is SAN logical or SAN physical.

Abstract: An apparatus and method for a multi-partition query governor in a partitioned computer database system. In preferred embodiments a query governor uses data of a query governor file that is associated with multiple partitions to determine how the query governor manages access to the database across multiple partitions. Also, in preferred embodiments, the query governor in a local partition that receives a query request communicates with a query governor in a target partition to accumulate the total resource demands of the query on the local and target partitions. In preferred embodiments, a query governor estimates whether resources to execute a query will exceed a threshold over all or a combination of database partitions.

Abstract: An apparatus and method monitor database queries and allow determining database relationships from the analysis of the database queries. The database relationships are inferred from the analysis of the database queries. The result sets of queries are analyzed to determine if any relationships between the columns specified in the queries may be inferred. In one embodiment, when a relationship between columns is discovered from analyzing query results, a system administrator is notified. In another embodiment, the relationship is stored so it may be retrieved and viewed at a later time by the system administrator.

Abstract: A method, apparatus, and program product optimize power consumption in a parallel computing system that includes a plurality of computing nodes by selectively throttling performance of selected nodes to effectively slow down the completion of quicker executing parts of a workload of the computing system when those parts are dependent upon or otherwise associated with the completion of other, slower executing parts of the same workload. Parts of the workload are executed on the computing nodes, including concurrently executing a first part on a first computing node and a second part on a second computing node. The first node is selectively throttled during execution of the first part to decrease power consumption of the first node and conform a completion time of for the first node in completing the first part of the workload with a completion time for the second node in completing the second part.

Abstract: Embodiments of the invention enable application programs running across multiple compute nodes of a highly-parallel system to compile source code into native instructions, and subsequently share the optimizations used to compile the source code with other nodes. For example, determining what optimizations to use may consume significant processing power and memory on a node. In cases where multiple nodes exhibit similar characteristics, it is possible that these nodes may use the same set of optimizations when compiling similar pieces of code. Therefore, when one node compiles source code into native instructions, it may share the optimizations used with other similar nodes, thereby removing the burden for the other nodes to figure out which optimizations to use. Thus, while one node may suffer a performance hit for determining the necessary optimizations, other nodes may be saved from this burden by simply using the optimizations provided to them.

Abstract: Methods, systems, and computer program products for dynamically adjusting computer resources, as appropriate, in response to predictions of query runtimes as well as for rendering costs of the computer resources actually utilized, which costs are consistent with consumer demands.

Abstract: A handheld electronic book reader, program product, and method incorporate enhanced annotation and/or usage tracking capabilities. Users may create “contexts” for defined terms in an electronic document. Moreover, annotation data such as contexts, comments and highlighting may be associated with various users, and displayed in connection with the display of an electronic document so as to indicate that different annotation data has been originated by different users. In addition, from the standpoint of usage tracking, usage statistics for an electronic document displayed in a handheld electronic reader may be generated on a page-by-page basis, and/or in association with term definitions. Moreover, usage statistics for multiple users may be combined and analyzed.

Abstract: Embodiments of the invention may be used to increase query processing parallelism of an in-memory database stored on a parallel computing system. A group of compute nodes each store a portion of data as part of the in-memory database. Further, a pool of compute nodes may be reserved to create copies of data from the compute nodes of the in-memory database as part of query processing. When a query is received for execution, the query may be evaluated to determine whether portions of in-memory should be duplicated to allow multiple elements of the query (e.g., multiple query predicates) to be evaluated in parallel.

Abstract: A method and apparatus distributes database query joins on a multi-node computing system. In the illustrated examples, a join execution unit utilizes various factors to determine where to best perform the query join. The factors include user controls in a hints record set up by a system user and properties of the system such as database configuration and system resources. The user controls in the hints record include a location flag and a determinicity flag. The properties of the system include the free space on the node and the size join, the data traffic on the networks and the data traffic generated by the join, the time to execute the join and nodes that already have code optimization. The join execution unit also determines whether to use collector nodes to optimize the query join.

Abstract: An apparatus and method for a query governor to govern query execution in a parallel computer system with one or more networks. The query governor uses a network monitor to gather network status information to determine how to govern query execution. The query governor may also use historical information of previous query execution stored in a query file to determine if the query should be allowed to execute. The query governor may also use node and network restrictions to determine what networks the query can use.

Abstract: A method to trace a variable or other expression through a computer program is disclosed. A user determines the variable and the conditions upon which activity of the variable will be monitored. As a result of the invention, every time that variable is referenced in a memory operation or other activity by the program and the conditions set forth by the user are satisfied, the state of that variable is saved as a snapshot without interrupting or stopping execution of the program. The snapshots are accumulated in a history table. The history table can be retrieved and the state of the variable in any given snapshot can be restored. Other variables and expressions can be attached to the trigger variable and the states of these other variables at the time of the activity of the trigger variable may also be saved in the snapshot. The method may be incorporated into a program as a tracing device or a program product separate from the logical processing device executing the program.

Abstract: An apparatus and method optimize a query in a computer database system having a DISTINCT specifier. An SQL SELECT statement with a DISTINCT specifier is analyzed to determine if the expression can be optimized, and if so, the SELECT statement is reformulated to improve system performance. In preferred embodiments, the query optimizer eliminates the DISTINCT specifier in the outer select statement to reformulate the query. In other preferred embodiments, a query optimizer reformulates the query before being sent to the database manager to optimize the query to improve system performance.

Abstract: Embodiments of the invention may be used to normalize data stored in an in-memory database on a parallel computer system. The data normalization may be used to achieve memory savings, thereby reducing the number of compute nodes required to store an in-memory database. Thus, as a result, faster response times may be achieved when querying the data. In one embodiment, normalization may be performed in a manner to avoid datasets that cross physical or logical boundaries of the compute nodes of a parallel system.

Abstract: In a networked computer system that includes multiple interconnected nodes, a commitment control mechanism allows designating certain portions of a record in an in-memory database as mandatory and other portions of the record as secondary, and performs mandatory commitment control once all the mandatory portions are available even if one or more secondary portions are not yet available. The secondary portions may be under separate commitment control that is asynchronous to the commitment control for the mandatory portions, or may be under no commitment control at all. The result is a commitment control mechanism that performs commitment control for portions of a record that are marked mandatory even when one or more of the portions marked secondary are not available.

Abstract: An apparatus, program product and method improve reporting of performance data in computing systems having uncapped partitions, or partitions that can borrow computer resources. A system measures or otherwise determines time of processor use or another metric that relates to the actual use of a computer resource by the uncapped logical partition. The metric is determined during a computer operation that may include a thread or job, and that may span an interval or period of intervals. The system uses the metric to estimate what the response time would have been if a capped logical partition was alternatively used. Information derived from this estimated response time is reported to the user.