Sun Microsystems, Inc.

Oracle America, Inc.

Dakota Legal Software, Inc.

Michael L Boucher

Paul J Hinker

Bradley Romain Lewis

Shaun M Dennie

Noah Horton

Terrence C Miller

Lawrence Alan Crowl

Jeremy Week

Theresa H Do

Brad R Lewis

Shandong Lao

Methods and systems facilitating a programmer to program parts of a program in data flow programming to produce directed acyclic graphs ('DAGs'), and then merge the graphs at runtime for efficiency and scalability. Large merged DAG can typically be processed with greater efficiency than the collection of smaller DAGs. As a result, smaller DAGs may be created while the execution of the program realizes the increased efficiency of executing a larger DAG based on the merging of the smaller DAGs. In accordance with methods and systems consistent with the present invention, a programmer creates individual data flow directed acyclic graphs in a program.

Method and system for merging directed acyclic graphs representing data flow codes

A citation system parses, error checks, corrects, and transforms citations between citation systems. The system may determine the available citation systems, such as The Bluebook, The Chicago Manual of Style, or other citation systems available for selection. The system also determines a selected citation system from among the multiple citation systems. For example, the system may determine that a writer has selected The Bluebook citation system from among those available to the system. The system also determines an applicable rule set for the selected citation system, and applies to rule set to an input citation to obtain an output citation component.

Citation processing system with multiple rule set engine

Methods, systems, and articles of manufacture consistent with the present invention provide an improved technique for analyzing statements that use pointer or array syntax to access dynamically-allocated arrays to determine whether the statement generates a reference that is outside the bounds of the array's allocated memory. Statements that use pointer or array syntax to access dynamically-allocated arrays can be either statically (at compile-time) or dynamically bounds (at run-time) checked. Methods and systems in accordance with the present invention determine at compile-time if an array reference can be determined to always be in bounds or definitely out of bounds at least once, and if not, insert code into the program to check the array bounds dynamically at run-time before the access of the array reference.

Method and system for analyzing array access to a pointer that is referenced as an array

Methods, systems, and articles of manufacture consistent with the present invention optimize a program by analyzing a statistical profile of a program execution, and automatically optimizing the program based on at least one of the analysis, information about at least one prior compilation of the program, and information about at least one prior optimization of the program. The optimization of the program can therefore take into consideration changes made during prior compilations and optimization and the results of the changes.

Method and system for code optimization

Methods, systems, and articles of manufacture consistent with the present invention provide a optimization tool for avoiding an address dependency between tasks in a program. The tool determines whether two or more tasks of the program are dependent on at least one same address, which is associated with a first memory block. When it is determined that the two or more tasks of the program are dependant on the at least one same address, the tool allocates a second memory block and changes a read reference by at least one of the two or more tasks from the first memory block associated with the at least one same address to the second memory block.

Methods and systems for detecting and avoiding an address dependency between tasks

Methods, systems, and articles of manufacture consistent with the present invention optimize allocation of items to a stack memory instead of a heap memory. It is determined whether an item to be placed on the heap memory escapes from the scope of the item's allocator, and whether the item survives the item's allocator. The item is allocated to the stack memory responsive to the item not escaping from the scope of the item's allocator and not surviving the item's allocator.

Method and system for optimizing memory allocation

Methods, systems, and articles of manufacture consistent with the present invention provide a memory instruction manager for managing the execution of instructions associated with a program. The memory instruction manager assigns a first group identifier to a first instruction associated with a program and to a second instruction associated with the program, and provides, after the first instruction, a memory barrier instruction having the first group identifier such that one or more processors with access to the program are inhibited from executing the second memory instruction until the first memory instruction is executed.

Methods and systems for grouping instructions using memory barrier instructions

Methods and systems consistent with the present invention provide a statistical profile of execution characteristics of a program, then use that statistical profile to regenerate code at run-time. When the information in the statistical profile is insufficient to make an optimization decision, methods and systems in accordance with the present invention may use the statistical profile plus additional information described below to determine a minimal level of instrumentation required to answer a particular optimization question. They then add at run-time the minimal instrumentation required to decide an optimization question, continue running the program for a period of time, and then analyze the resulting instrumentation data. These systems may either iterate the process to get more data or use the available data to compile a more highly optimized program.

Method and system for targeting profile gathering through real-time data

Methods, systems, and articles of manufacture consistent with the present invention compute a multidimensional fast Fourier transform of an original matrix having rows and columns of data. The original matrix is divided into a number of blocks of data, each block including at least one datum, the number of rows of data in each block being less than a total number of rows of data in the original matrix. A one-dimensional partial fast Fourier transform of each block in a row of blocks is computed. A result of the computations is stored in a resultant matrix having rows and columns. The resultant matrix is transposed to a transposed matrix having rows and columns. While transposing the resultant matrix, one-dimensional partial fast Fourier transforms of each block of subsequent rows of blocks are simultaneously computed, one row of blocks at a time, until one-dimensional partial fast Fourier transforms are computed for each block.

Method and system for computing multidimensional fast Fourier transforms

Methods and systems consistent with the present invention allow a program designer to conveniently specify and support watchdog checking of a program under development. The resulting programs are more robust than programs developed without watchdog support. The method and systems provide a convenient, automated mechanism for adding watchdog support to a program. Thus, a developer need not incur the substantial time and effort costs that would be associated with manually designing and configuring separate watchdog programs. Rather, the methods and systems provide substantial assistance to the developer in designing a robust program.

Methods and systems for software watchdog support

An allocation instructions and an extension instructions allow a program to continue to execute even when the program requires more stack space than has been allocated to the program. The methods and systems thereby allow programs to run to completion in more situations than programs running in conventional data processing systems. As a result, the programs avoid wasting computing resources by terminating prematurely, without producing results.

Methods and systems for dynamically growing multiple stacks

Methods, systems, and articles of manufacture consistent with the present invention provide a development tool that enables computer programmers to design and develop a data flow program for execution in a multiprocessor computer system. The tool allows the programmer to define a region divided into multiple blocks, wherein each block is associated with data operated on by code segments of the data flow program. The development tool also maintains dependencies among the blocks, each dependency indicating a relationship between two blocks that indicates that the portion of the program associated with a first block of the relationship needs the resultant data provided by the portions of the program associated with a second block of the relationship. The development tool supports several debugging commands, including insertion of multiple types of breakpoints, adding and deleting dependencies, single stepping data flow program execution, and the like.

Methods and systems for developing data flow programs

This functions maintains two trees: a fast access tree referring to memory blocks of a size most often requested, and a general access tree referring to memory blocks of a size less often requested. After satisfying a request for a memory block, the function adjusts the trees to ensure that the fast access tree refers to memory blocks of the size most often requested. By providing such functionality, the function improves its performance over time through self-adaptation.

Adaptive memory allocation

Improved transposition of a matrix in a computer system may be accomplished while utilizing at most a single permutation vector. This greatly improves the speed and parallelability of the transpose operation. For a standard rectangular matrix having M rows and N columns and a size M&#xd7;N, first n and q are determined, wherein N=n*q, and wherein M&#xd7;q represents a block size and wherein N is evenly divisible by p. Then, the matrix is partitioned into n columns of size M&#xd7;q. Then for each column n, elements are sequentially read within the column row-wise and sequentially written into a cache, then sequentially read from the cache and sequentially written row-wise back into the matrix in a memory in a column of size q&#xd7;M. A permutation vector may then be applied to the matrix to arrive at the transpose. This method may be modified for special cases, such as square matrices, to further improve efficiency.

Growing community of inventors

Lafayette, CO, United States of America

Michael L Boucher