Abstract:
Techniques are described for unifying static and dynamic compiler optimizations in source code bases. In an embodiment, a first compiler compiles source code of a target function to generate ahead-of-time (AOT) compiled machine code. A second compiler compiles the source code to generate an intermediate representation (IR) of the target function. In response to determining that the target function should be just-in-time (JIT) compiled, the AOT-compiled machine code for the target function is linked to the IR of the target function. During runtime, a physical processor executes AOT-compiled machine code of an executable program. When the target function is encountered for the first time, a JIT compiler is invoked. The JIT compiler generates JIT-compiled machine code for the target function. The physical processor executes the JIT-compiled machine code in place of the AOT-compiled machine code for the target function.
Abstract:
A method for performing a neighbor-flipping transformation is provided. In one embodiment, a graph analysis program for computing a function relating to nodes in a directed graph is obtained and analyzed for neighborhood iterating operations, in which a function is computed over sets of nodes in the graph. For any detected neighborhood iterating operation, the method transforms the iterating operation by reversing the neighbor node relationship between the nodes in the operation. The transformed operation computes the same value for the function as the operation prior to transformation. The method alters the neighbor node relationship automatically, so that a user does not have to recode the graph analysis program. In some cases, the method includes construction of edges in the reverse direction while retaining the original edges in addition to performing the transformation.
Abstract:
A method and apparatus for processing path-based database operations is provided. According to one aspect, a path cache is maintained. For each hierarchical node that is traversed during a path-determining operation, it is determined whether a cache entry corresponding to that node is already contained in the path cache. If such a cache entry is already contained in the path cache, then the path indicated in that cache entry is used to complete the pathname for the node for which the operation is being performed. As a result, hierarchically higher nodes do not need to be traversed to complete the operation. Alternatively, if such a cache entry is not already contained in the path cache, then a cache entry for the node currently being traversed is generated and inserted into the path cache for use in subsequent path-determining operations.
Abstract:
A method for generating a binary executable of a program so that private symbols in a module are accessible from another module. In one embodiment, the method compiles a source program to an intermediate representation and scans the representation to find the private symbols in the program's modules. It then wraps a function around each private symbol. When called, the function returns an address of the private symbol, so that the other module can access the symbol from outside the module in which the symbol is found. At run time, a call is made to obtain the address of the function, which is then executed to obtain the address of the private symbol so that the symbol can be accessed. In another embodiment, a Just-In-Time compiler executes the wrapper functions and patches the executable program with the direct address of the private symbol to avoid a call to the wrapper function.
Abstract:
A method for generating a binary executable of a program so that private symbols in a module are accessible from another module. In one embodiment, the method compiles a source program to an intermediate representation and scans the representation to find the private symbols in the program's modules. It then wraps a function around each private symbol. When called, the function returns an address of the private symbol, so that the other module can access the symbol from outside the module in which the symbol is found. At run time, a call is made to obtain the address of the function, which is then executed to obtain the address of the private symbol so that the symbol can be accessed. In another embodiment, a Just-In-Time compiler executes the wrapper functions and patches the executable program with the direct address of the private symbol to avoid a call to the wrapper function.
Abstract:
Techniques are provided for managing versions of files in a file system. According to one technique, new versions of directories are created in response to creation of new versions of files that descend from the directories, where the different versions of a versioned directory are associated with different points in time. Links are maintained between the files in the file system such that the versions of the files that descend from a particular version of a versioned directory reflect the point in time associated with the versioned directory.
Abstract:
Herein for each source logic in a corpus, a computer stores an identifier of the source logic and operates a logic encoder that infers a distinct fixed-size encoded logic that represents the variable-size source logic. At build time, a multidimensional index is generated and populated based on the encoded logics that represent the source logics in the corpus. At runtime, a user may edit and select a new source logic such as in a text editor or an integrated development environment (IDE). The logic encoder infers a new encoded logic that represents the new source logic. The multidimensional index accepts the new encoded logic as a lookup key and automatically selects and returns a result subset of encoded logics that represent similar source logics in the corpus. For display, the multidimensional index may select and return only encoded logics that are the few nearest neighbors to the new encoded logic.
Abstract:
Herein, a guest language is a programing language that is not the native data access language (e.g. structured query language, SQL) of a database server. When instantiated in the database server, a guest language runtime environment provides any mechanisms needed to execute the guest language. In an embodiment contained entirely within the database server, multiple guest language runtime environments for same or different guest languages use respective database sessions to share a key-value store in RAM that stores rows from a persistent relational table. Consumption of computer resources such as time and memory space is decreased because the persistent relational table's operation by the key-value store does not generate a database statement, does not parse a database statement, does not query plan, and does not execute a database statement.
Abstract:
A mechanism is provided for detecting and disregarding application specific nodes contained in shared XML documents. The techniques described involve determining one or more application specific nodes within XML documents and performing path expression evaluations of the XML documents as if the nodes are not present. In one embodiment, a mechanism is provided by which a user may specify the criterion that determine which subset of node in XML documents are to be ignored from path expression evaluations and evaluating a query that specifies a path operation based on a path and ignoring said identified nodes when evaluating said path operation.
Abstract:
A platform (referred to herein as Extensible Application Platform, or XAP) for developing extensible business applications. In one set of embodiments, XAP can include an Extensible Markup Language (XML) based application model that is designed to support a high degree of application extensibility. For example, the XAP application model can support declarative definition of application semantics, separation of application data and metadata, and a flexible type system that allows constraints and calculations (e.g., XQuery constraints and calculations) for a data object instance (e.g., an XML document) to change over time. In certain embodiments, the XAP application model can be implemented via a server-side database/application engine that is configured to interoperate with a spreadsheet-like, client-side user interface. Using the spreadsheet-like UI, a non-programmer can build, customize, and run an application workflow that operates on top of a shared database like a traditional business application.