| Patent application number | Description | Published |
|---|
| 20080306920 | BYTE-CODE REPRESENTATIONS OF ACTUAL DATA TO REDUCE NETWORK TRAFFIC IN DATABASE TRANSACTIONS - Methods, articles of manufacture, and systems for reducing network traffic for database transactions between a requesting client and a database server are provided. For some embodiments, the client may access statistical information regarding the data, such as that commonly contained in indexes (e.g., encoded vector indexes), conventionally generated for use by a query optimizer. For some embodiments, based on the statistical information regarding the data, the client may request that the server send small byte-code representations of data from the database, rather than the actual data. The small byte-code representations may be significantly smaller than the actual represented data, thus reducing network traffic between the client and server. The client may then retrieve the actual represented data from a corresponding data representation record. | 12-11-2008 |
| 20080320450 | RECOVERABLE RETURN CODE TRACKING AND NOTIFICATION FOR AUTONOMIC SYSTEMS - A system, method and article of manufacture return code management in autonomic systems and more particularly to managing execution of operations in data processing systems on the basis of return code tracking. One embodiment provides a method for managing execution of an operation in a data processing system. The method comprises tracking return codes received from previous executions of the operation in the data processing system, determining an execution behavior of the operation from the tracked return codes, and managing a subsequent execution of the operation on the basis of the determined execution behavior. | 12-25-2008 |
| 20090043728 | Query Optimization in a Parallel Computer System to Reduce Network Traffic - An apparatus and method for a database query optimizer to optimize a query that uses multiple networks. The query optimizer optimizes a query to reduce network traffic on a network or node that is overloaded or above an established parameter in a node/network attribute table. The query optimization to reduce network traffic may result in a sub-optimal query in other respects such as execution time. The result is a query optimizer that rewrites or optimizes a query to execute on multiple nodes or networks to reduce traffic on a network or node according to the loading characteristics and assigned attributes of a node or network. | 02-12-2009 |
| 20090043745 | Query Execution and Optimization with Autonomic Error Recovery from Network Failures in a Parallel Computer System with Multiple Networks - An apparatus and method for a database query execution monitor determines if an network error or low performance condition exists and then where possible modifies the query. The query execution monitor then determines an alternate query execution plan to continue execution of the query. The query optimizer can re-optimize the query to use a different network or node. Thus, the query execution monitor allows autonomic error recovery for network failures using an alternate query execution. The alternate query execution could also be determined at the initial optimization time and then this alternate plan used to execute a query in the case of a particular network failure. | 02-12-2009 |
| 20090043750 | Query Optimization in a Parallel Computer System with Multiple Networks - An apparatus and method for a database query optimizer to optimize a query that uses multiple networks. The database query optimizer optimizes a query that uses multiple networks to satisfy the query by splitting the query execution to use multiple networks. Thus, the query optimizer rewrites or optimizes a query to execute on multiple nodes or networks to more efficiently execute the query and reduce network traffic on a network. The query optimizer uses plan cache statistics to determine whether to use multiple networks to optimize the query. | 02-12-2009 |
| 20090043873 | Methods and Apparatus for Restoring a Node State - In one aspect of the invention, a method is provided. The method may include: (1) storing a snapshot of a system state of a node; (2) executing a job on the node; and (3) restoring the node to the system state using the stored snapshot of the system state. | 02-12-2009 |
| 20090043910 | Query Execution and Optimization Utilizing a Combining Network in a Parallel Computer System - An apparatus and method for a database query optimizer utilizes a combining network to optimize a portion of a query in a parallel computer system with multiple nodes. The efficiency of the parallel computer system is increased by offloading collective operations on node data to the global combining network. The global combining network performs collective operations such as minimum, maximum, sum, and logical functions such as OR and XOR. | 02-12-2009 |
| 20090089743 | Methods and Apparatus for IDE Integration of Database Changes - In one aspect, a method is provided. The method includes (1) generating code in an integrated development environment (IDE), the code including instructions for a database; and (2) receiving feedback in the IDE, the feedback relating to the instructions for the database. | 04-02-2009 |
| 20090100195 | Methods and Apparatus for Autonomic Compression Level Selection for Backup Environments - In one aspect, a method is provided. The method includes: (1) gathering statistics during compression of a dataset into a compressed dataset and during transfer of the compressed dataset over a network connection; and (2) optimizing compression settings based on the gathered statistics. | 04-16-2009 |
| 20090125611 | SHARING LOADED JAVA CLASSES AMONG A PLURALITY OF NODES - Methods, apparatus, and products are disclosed for sharing loaded Java classes among a plurality of nodes connected together for data communications using a data communication network, the plurality of nodes including an execution node and other nodes, that include: executing, by the execution node, a Java application, including identifying a Java class utilized for the Java application; determining, by the execution node, whether the Java class is already loaded on at least one of the other nodes; retrieving, by the execution node, the loaded Java class from the other nodes if the Java class is already loaded on at least one of the other nodes; and executing, by the execution node, the Java application using the loaded Java class retrieved from the other nodes. | 05-14-2009 |
| 20090125883 | NODE SELECTION FOR EXECUTING A JAVA APPLICATION AMONG A PLURALITY OF NODES - Methods, apparatus, and products are disclosed for node selection for executing a Java application among a plurality of nodes connected together for data communications using a data communication network, the plurality of nodes also connected to a service node, that include: tracking, by the service node, loaded Java classes currently loaded on each of the plurality of nodes; receiving, in the service node, an instruction to execute a Java application using the plurality of nodes; identifying, by the service node, Java classes utilized in executing the Java application; selecting, by the service node, one of the plurality of nodes for executing the Java application in dependence upon the loaded Java classes and the Java classes utilized in executing the Java application; and configuring, by the service node, the Java application for execution on the selected node. | 05-14-2009 |
| 20090182705 | Methods and Apparatus for Converting Union Commands to Union All Commands - In one aspect, a method is provided. The method includes: (1) identifying in a query of a database a union command involving data in the database that is mutually exclusive; and (2) changing the union command to a union all command. | 07-16-2009 |
| 20090240930 | Executing An Application On A Parallel Computer - Methods, systems, and products are disclosed for executing an application on a parallel computer including a plurality of nodes connected together through a data communications network. Each node has a plurality of processors capable of operating independently for serial processing and capable of operating symmetrically for parallel processing. The application has parallel segments for parallel processing and serial segments for serial processing. Embodiments of the invention include: booting up a first subset of the plurality of nodes in a serial processing mode; booting up a second subset of the plurality of nodes in a parallel processing mode; and executing the application on the plurality of nodes, including: migrating the application to the nodes booted up in the parallel processing mode upon encountering the parallel segments during execution, and migrating the application to the nodes booted up in the serial processing mode upon encountering the serial segments during execution. | 09-24-2009 |
| 20090265305 | Partial Indexes for Multi-Node Database - Embodiments of the invention enable a database spread over multiple nodes to allow each node to have different indexes over the data in tables, depending on how each node would benefit (or not benefit) from having the index(es). When a database table is spread across the nodes of a multi-node or distributed system, each node may maintain only the portion of the index relevant to that node, if doing so would improve the performance of query processing operations on that node. Further, the database may periodically redistributed across the compute nodes based on index performance. Doing so allows the database system to intelligently trade off between consuming space for the index on a node and the usefulness of having an index on that node. | 10-22-2009 |
| 20090265306 | Index Maintenance in a Multi-Node Database - Embodiments of the invention enable a database spread over multiple nodes to allow each node to have different indexes over the data in tables, depending on how each node would benefit (or not benefit) from having the index(es). When a database table is spread across the nodes of a multi-node or distributed system, each node may maintain only the portion of the index relevant to that node, if doing so would improve the performance of query processing operations on that node. Further, the database may periodically redistributed across the compute nodes based on index performance. Doing so allows the database system to intelligently trade off between consuming space for the index on a node and the usefulness of having an index on that node. | 10-22-2009 |
| 20090271588 | Migrating Program Objects in a Multi-Node Computer System - Embodiments of the invention enable application programs running across multiple compute nodes of a highly-parallel system to selectively migrate objects from one node to another. For example, when an object becomes too large, a node containing the object may migrate the object to another node, thereby freeing memory space. Whether a large object is migrated can be dependent on how frequently the object is used by the application. Because the memory used by such an object is freed for other uses by the application, overall application performance may be improved. On large parallel systems with thousands of compute nodes, even relatively small improvements in application performance an individual compute node may be magnified many times, resulting in dramatic improvements in overall application performance. | 10-29-2009 |
| 20090271595 | Configuring An Application For Execution On A Parallel Computer - Methods, systems, and products are disclosed for configuring an application for execution on a parallel computer that include: booting up a first subset of a plurality of nodes in a serial processing mode; booting up a second subset of the plurality of nodes in a parallel processing mode; profiling, prior to application deployment on the parallel computer, the application to identify the serial segments and the parallel segments of the application; and deploying the application for execution on the parallel computer in dependence upon the profile of the application and proximity within the data communications network of the nodes in the first subset relative to the nodes in the second subset. | 10-29-2009 |
| 20090271596 | Executing An Application On A Parallel Computer - Methods, systems, and products are disclosed for executing an application on a parallel computer having a plurality of nodes. Executing an application on a parallel computer includes: booting up a first subset of a plurality of nodes in a serial processing mode; booting up a second subset of the plurality of nodes in a parallel processing mode; profiling, prior to application execution, an application to identify serial segments of the application, parallel segments of the application, and application data utilized by each of the serial segments and the parallel segments; and executing the application on the plurality of nodes, including migrating, in dependence upon the profile for the application upon encountering the parallel segments during execution, only specific portions of the application and the application data from the nodes booted up in the serial processing mode to the nodes booted up in the parallel processing mode. | 10-29-2009 |
| 20090271775 | Optimizing Just-In-Time Compiling For A Java Application Executing On A Compute Node - Methods, systems, and products are disclosed for optimizing just-in-time (‘JIT’) compiling for a Java application executing on a compute node, the compute node having installed upon it a Java Virtual Machine (‘JVM’) capable of supporting the Java application, that include: identifying, by an application manager, a particular portion of the Java application; assigning, by the application manager, a JIT level to the particular portion of the Java application; and jitting, by the JVM installed on the compute node, the particular portion of the Java application in dependence upon the JIT level assigned to that particular portion of the Java application. | 10-29-2009 |
| 20090271784 | Executing A Distributed Java Application On A Plurality Of Compute Nodes - Methods, systems, and products are disclosed for executing a distributed Java application on a plurality of compute nodes. The Java application includes a plurality of jobs distributed among the plurality of compute nodes. The plurality of compute nodes are connected together for data communications through a data communication network. Each of the plurality of compute nodes has installed upon it a Java Virtual Machine (‘JVM’) capable of supporting at least one job of the Java application. Executing a distributed Java application on a plurality of compute nodes includes: tracking, by an application manager, JVM environment variables for the JVMs installed on the plurality of compute nodes; and configuring, by the application manager, the plurality of jobs for execution on the plurality of compute nodes in dependence upon the JVM environment variables for the JVMs installed on the plurality of compute nodes. | 10-29-2009 |
| 20090271799 | Executing A Distributed Java Application On A Plurality Of Compute Nodes - Methods, systems, and products are disclosed for executing a distributed Java application on a plurality of compute nodes. The Java application includes a plurality of jobs distributed among the plurality of compute nodes. The plurality of compute nodes are connected together for data communications through a data communication network. Each of the plurality of compute nodes has installed upon it a Java Virtual Machine (‘JVM’) capable of supporting at least one job of the Java application. Executing a distributed Java application on a plurality of compute nodes includes: tracking, by an application manager, a just-in-time (‘JIT’) compilation history for the JVMs installed on the plurality of compute nodes; and configuring, by the application manager, the plurality of jobs for execution on the plurality of compute nodes in dependence upon the JIT compilation history for the JVMs installed on the plurality of compute nodes. | 10-29-2009 |
| 20090271807 | Selectively Generating Program Objects on Remote Node of a Multi-Node Computer System - Embodiments of the invention enable application programs running across multiple compute nodes of a highly-parallel system to selectively migrate objects from one node to another. For example, when an object becomes too large, a node containing the object may migrate the object to another node, thereby freeing memory space. Whether a large object is migrated can be dependent on how frequently the object is used by the application. Because the memory used by such an object is freed for other uses by the application, overall application performance may be improved. On large parallel systems with thousands of compute nodes, even relatively small improvements in application performance an individual compute node may be magnified many times, resulting in dramatic improvements in overall application performance. | 10-29-2009 |
| 20090299667 | Qualifying Data Produced By An Application Carried Out Using A Plurality Of Pluggable Processing Components - Methods, apparatus, and products are disclosed for qualifying data produced by an application carried out using a plurality of pluggable processing components. Qualifying data produced by the application includes: receiving, by an application manager, quality metrics for one of the pluggable processing components; determining, by the application manager, a component quality rating for the pluggable processing component in dependence upon the quality metrics; and assigning, by the application manager, a data quality rating to application data for the application in dependence upon the component quality rating for the pluggable processing component. | 12-03-2009 |
| 20090300154 | Managing performance of a job performed in a distributed computing system - Methods, systems, and products are disclosed for managing performance of a job performed in a distributed computing system, the distributed computing system comprising a plurality of compute nodes operatively coupled through a data communications network, the job carried out by a plurality of distributed pluggable processing components executing on the plurality of compute nodes, that include: identifying a current configuration of the pluggable processing components carrying out the job, the current configuration specifying a current distribution of the pluggable processing components among the compute nodes; identifying a network topology of the plurality of compute nodes in the data communications network; receiving a plurality of performance indicators produced during execution of the job; and redistributing, to a different compute node, at least one of the pluggable processing components in dependence upon the current configuration, the network topology, and the performance indicators. | 12-03-2009 |
| 20090300404 | Managing Execution Stability Of An Application Carried Out Using A Plurality Of Pluggable Processing Components - Methods, apparatus, and products are disclosed for managing execution stability of an application carried out using a plurality of pluggable processing components. Managing execution stability of an application includes: receiving, by an application manager, component stability metrics for a particular pluggable processing component; determining, by the application manager, that the particular pluggable processing component is unstable in dependence upon the component stability metrics for the particular pluggable processing component; and notifying, by the application manager, a system administrator that the particular pluggable processing component is unstable. | 12-03-2009 |
| 20090300624 | Tracking data processing in an application carried out on a distributed computing system - Methods, systems, and products are disclosed for tracking data processing in an application carried out on a distributed computing system, the distributed computing system including a plurality of computing nodes connected through a data communications network, the application carried out by a plurality of pluggable processing components installed on the plurality of computing nodes, the pluggable processing components including a pluggable processing provider component and a pluggable processing consumer component, that include: identifying, by the provider component, data satisfying predetermined processing criteria, the criteria specifying that the data is relevant to processing provided by the consumer component; passing, by the provider component, the data to the next pluggable processing component in the application for processing, including maintaining access to the data; receiving, by the consumer component, the data during execution of the application; and sending, by the consumer component, a receipt indicating that the consumer component received the data. | 12-03-2009 |
| 20090300625 | Managing The Performance Of An Application Carried Out Using A Plurality Of Pluggable Processing Components - Methods, apparatus, and products are disclosed for managing the performance of an application carried out using a plurality of pluggable processing components, the pluggable processing components executed on a plurality of compute nodes, that include: identifying a current configuration of the pluggable processing components for carrying out the application; receiving a plurality of performance indicators produced during execution of the pluggable processing components; and altering the current configuration of the pluggable processing components in dependence upon the performance indicators and one or more additional pluggable processing components. | 12-03-2009 |
| 20090313636 | Executing An Application On A Parallel Computer - Methods, apparatus, and products are disclosed for executing an application on a parallel computer that include: executing, by a current compute node, a current task of the application, including producing results; determining, by the current compute node in dependence upon current network characteristics and application characteristics, whether to transfer the results to a next compute node for further processing by a next task on the next compute node or to execute the next task for further processing of the results on the current compute node; transferring, by the current compute node, the results to the next compute node for further processing by the next task on the next compute node if the determination specifies transferring the results to the next node; and executing, by the current compute node, the next task for further processing of the results if the determination specifies executing the next task on the current compute node. | 12-17-2009 |
| 20090319621 | Message Flow Control in a Multi-Node Computer System - Embodiments of the invention provide for controlling message flow across a parallel computer system having multiple compute nodes by selectively grouping compute nodes of such a system into node pools and assigning message flow control policies to nodes in the node pools. The message flow control policies specify logging and/or tracing activities to be performed by instances of applications running on nodes assigned to the node pools. As the application is executed, logging and/or tracing messages are generated on the compute nodes according to message flow control policies assigned to the nodes. Optionally, the message flow is analyzed, the message flow control policies are adjusted, and duplicate messages are eliminated. | 12-24-2009 |
| 20090319662 | Process Migration Based on Exception Handling in a Multi-Node Environment - A process on a highly distributed parallel computing system is disclosed. When a first compute node in a first pool is ready to hand-off a task to second pool for further processing, the first compute node may first determine whether a node is available in the second pool. If no node is available from the second pool, then the first compute node may begin performing a primary task assigned to the second pool of nodes, up to the point where a service available exclusively to the nodes of the second pool is required. In the interim, however, one of the nodes of the second pool may become available. Alternatively, an application program running on a compute node may be configured with an exception handling routine that catches exceptions and migrates the application to a compute node where a necessary service is available, as such exceptions occur. | 12-24-2009 |
| 20090320023 | Process Migration Based on Service Availability in a Multi-Node Environment - A process on a highly distributed parallel computing system is disclosed. When a first compute node in a first pool is ready to hand-off a task to second pool for further processing, the first compute node may first determine whether a node is available in the second pool. If no node is available from the second pool, then the first compute node may begin performing a primary task assigned to the second pool of nodes, up to the point where a service available exclusively to the nodes of the second pool is required. In the interim, however, one of the nodes of the second pool may become available. Alternatively, an application program running on a compute node may be configured with an exception handling routine that catches exceptions and migrates the application to a compute node where a necessary service is available, as such exceptions occur. | 12-24-2009 |
| 20100085870 | GLOBAL DETECTION OF RESOURCE LEAKS IN A MULTI-NODE COMPUTER SYSTEM - A process is disclosed for identifying and recovering from resource leaks on compute nodes of a parallel computing system. A resource monitor stores information about system resources available on a compute node in a clean state. After the compute node runs a job, the resource monitor compares the current resource availability to the clean state. If a resource leak is found, the resource monitor contacts a global resource manger to remove the resource leak. | 04-08-2010 |
| 20100085871 | RESOURCE LEAK RECOVERY IN A MULTI-NODE COMPUTER SYSTEM - A process is disclosed for identifying and recovering from resource leaks on compute nodes of a parallel computing system. A resource monitor stores information about system resources available on a compute node in a clean state. After the compute node runs a job, the resource monitor compares the current resource availability to the clean state. If a resource leak is found, the resource monitor contacts a global resource manger to remove the resource leak. | 04-08-2010 |
| 20100180024 | REDUCING OCCURRENCES OF TWO-PHASE COMMITS IN A MULTI-NODE COMPUTING SYSTEM - Techniques are disclosed for reducing the number of two-phase commits required to perform atomic transactions in a multi-node system. By monitoring atomic operations that require two-phase commit protocols, a system may identify when it would be beneficial to consolidate data onto single (or at least fewer) compute node(s). In doing so, a less compute intensive commit protocol, such as a one-phase commit protocol may be used. Moreover, in situations where data consolidation is not available, the data may be migrated to compute nodes having a closer proximity. Thus, in such cases, network response times for two-phase commits required for an atomic operation may be reduced, thereby increasing the performance of a multi-node system. | 07-15-2010 |
| 20100205578 | PROGRAM DEVELOPMENT TOOL CONFIGURED TO COMPILE SOURCE CODE ACCORDING TO ENERGY CONSUMPTION REQUIREMENTS - Embodiments of the invention provide techniques for presenting energy consumption information in an IDE tool. In one embodiment, the IDE tool may be configured to determine energy requirements associated with specific elements of the source code, and to present graphical indications of energy requirements along with those code elements. Such energy requirements may be determined by matching code elements to a stored data structure describing energy requirements for executing various code elements. The stored data may be based on predefined standards, and/or may be based on historical measurements of energy consumption during prior instances of executing code elements on a target computer system. Additionally, developers may specify priority for compiling portions of source code, according to desired energy requirements. | 08-12-2010 |
| 20100205591 | PRESENTING ENERGY CONSUMPTION INFORMATION IN AN INTEGRATED DEVELOPMENT ENVIRONMENT TOOL - Embodiments of the invention provide techniques for presenting energy consumption information in an IDE tool. In one embodiment, the IDE tool may be configured to determine energy requirements associated with specific elements of the source code, and to present graphical indications of energy requirements along with those code elements. Such energy requirements may be determined by matching code elements to a stored data structure describing energy requirements for executing various code elements. The stored data may be based on predefined standards, and/or may be based on historical measurements of energy consumption during prior instances of executing code elements on a target computer system. Additionally, developers may specify priority for compiling portions of source code, according to desired energy requirements. | 08-12-2010 |
| 20100205619 | ENVIRONMENT MODIFICATION IN A HYBRID NODE COMPUTING ENVIRONMENT - Embodiments of the invention provide techniques that improve resource management on a massively parallel computing system having a plurality of hybrid compute nodes. For example, a job scheduler may be provided which determines a library to link to an application based on system and user requirements. In one embodiment, the libraries may provide optimizations for job execution time, and also provide optimizations directed towards a specific processor architecture. Once the library is determined, the job scheduler may configure the environment of the application so that the application links with the optimized library during run-time. Doing so may improve overall system performance of the massively parallel computing system. | 08-12-2010 |
| 20100242026 | ENHANCED THREAD STEPPING - Embodiments of the invention provide debugging techniques for multithreaded programs. For example, a debugger may reduce the time required to release inactive threads that hold resources needed by an active thread. For example, if a timer expires before a line of code finishes executing, the debugger assumes that the active thread requires a resource locked by an inactive thread and releases other threads. During subsequent execution of the line of code, the debugger reduces the timer length of the timer. In doing so, inactive threads are released sooner, thereby reducing the wait time a user experiences when debugging lines of code. | 09-23-2010 |
