Oracle International Corporation

Amazon Technologies, Inc.

Venkatraman Govindaraju

Sam Idicula

Naresh Chainani

Ippokratis Pandis

Arun Raghavan

Gong Zhang

Kiran Kumar Chinta

Kirtikar Kashyap

Evangelos Vlachos

Andrew Edward Caldwell

Pavel Sokolov

Martin Grund

Fabian Oliver Nagel

Nemanja Boric

Naveen Muralimanohar

Hui Shi

Demala Palliye Gurunnanselage Shermal Ruwantha Fernando

Nikolaos Armenatzoglou

Hanna Loboda

Improved crash resilience is implemented in shared memory processing systems. A processing application including a plurality processing groups may be configured, and a processing group including a plurality of processes may allocate memory from a global shared memory to a group-private shared memory arena. Then, an abnormal execution condition for a failing process of the processing group may be detected during execution of a processing job. Responsive to the detection, a recovery of execution of the processing group may be performed while continuing execution of processing groups of the application. The recovery may include restoring the processing group to a normal execution state and returning the allocated memory of the group-private memory arena to the global shared memory.

Crash resilience in shared memory processing systems

Dynamic plan interpretation may be implemented to perform queries. A query is received at a database system. A plan to perform the query is generated. For at least a portion of the plan to perform the query, a domain-specific language may be applied to interpret and execute the portion of the plan to perform the query using one or more previously compiled executors instead of generating and compiling code to execute the portion of the plan. Returning a result of the query according to the execution of the plan.

Dynamic selection of plan interpretation to perform queries

Compiled portions of code generated to perform a query plan at a query engine may be shared with other query engines. A data store, separate from the query engines, may store compiled portions of query code generated for different queries. If a query engine does not have a locally stored compiled portion of query code, then the separate data store may be accessed in order to obtain a compiled portion of query code, allowing reuse of compiled query code across different queries engines for queries directed to different databases.

Sharing compiled code for executing queries across query engines

Techniques are described for executing a query with a top-N clause to select a first N-number of rows in a data source arranged at least according to a first key and a second key of the data source using a first sort order respectively specified for the first key and a second sort order respectively specified for the second key by the query. The data source may include one or more tiles that include at least a portion of the first key and the second key. To execute the query, in an embodiment, a DBMS determines, in a first vector of first key values that are in a first tile, row identifiers identifying entries of the first vector that contain values equal to a tail value that follows a particular top number of the first key values. The DBMS may select, from a second vector of values of the second key in the first tile, second key values identified based on the determined row identifiers of the first vector. In an embodiment, the DBMS generates a result set of the query that includes at least a value from the second key values selected from the second vector based on the determined first row identifiers.

Tail-based top-N query evaluation

Techniques are provided for redundant execution by a better processor for intensive dynamic profiling after initial execution by a constrained processor. In an embodiment, a system of computer(s) receives a request to profile particular runtime aspects of an original binary executable. Based on the particular runtime aspects and without accessing source logic, the system statically rewrites the original binary executable into a rewritten binary executable that invokes telemetry instrumentation that makes observations of the particular runtime aspects and emits traces of those observations. A first processing core having low power (capacity) performs a first execution of the rewritten binary executable to make first observations and emit first traces of the first observations. Afterwards, a second processing core performs a second (redundant) execution of the original binary executable based on the first traces. The second execution generates a detailed dynamic performance profile based on the second execution.

Hybrid instrumentation framework for multicore low power processors

Growing community of inventors

Fremont, CA, United States of America

Venkatraman Govindaraju