Patent application number | Description | Published |
20140157247 | Enabling Symbol Resolution of Private Symbols in Legacy Programs and Optimizing Access to the Private Symbols - 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. | 06-05-2014 |
20140189665 | System For Applying Transformation To Improve Graph Analysis - 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. | 07-03-2014 |
20140258635 | INVALIDATING ENTRIES IN A NON-COHERENT CACHE - Techniques are provided for performing an invalidate operation in a non-coherent cache. In response to receiving an invalidate instruction, a cache unit only invalidates cache entries that are associated with invalidation data. In this way, a separate invalidate instruction is not required for each cache entry that is to be invalidated. Also, cache entries that are not to be invalidated remain unaffected by the invalidate operation. A cache entry may be associated with invalidation data if an address of the corresponding data item is in a particular set of addresses. The particular set of addresses may have been specified as a result of an invalidation instruction specified in code that is executing on a processor that is coupled to the cache. | 09-11-2014 |
20140258637 | FLUSHING ENTRIES IN A NON-COHERENT CACHE - Techniques are provided for performing a flush operation in a non-coherent cache. In response to determining to perform a flush operation, a cache unit flushes certain data items. The flush operation may be performed in response to a lapse of a particular amount of time, such as a number of cycles, or an explicit flush instruction that does not indicate any cache entry or data item. The cache unit may store change data that indicates which entry stores a data item that has been modified but not yet been flushed. The change data may be used to identify the entries that need to be flushed. In one technique, a dirty cache entry that is associated with one or more relatively recent changes is not flushed during a flush operation. | 09-11-2014 |
20150178125 | REDUCING SYNCHRONIZATION OF TASKS IN LATENCY-TOLERANT TASK-PARALLEL SYSTEMS - Techniques are provided for reducing synchronization of tasks in a task scheduling system. A task queue includes multiple tasks, some of which require an I/O operation while other tasks require data stored locally in memory. A single thread is assigned to process tasks in the task queue. The thread determines if a task at the head of the task queue requires an I/O operation. If so, then the thread generates an I/O request, submits the I/O request, and places the task at (or toward) the end of the task queue. When the task reaches the head of the task queue again, the thread determines if data requested by the I/O request is available yet. If so, then the thread processes the request. Otherwise, the thread places the task at (or toward) the end of the task queue again. | 06-25-2015 |
20150331683 | Automatic Selection Of An Abstract Data Type - An implementation of an abstract data type is automatically selected by a compiler. The compiler chooses an implementation for each instance of an abstract data type in a program based on operations performed in the instance within the program. | 11-19-2015 |
20160048607 | IN-MEMORY GRAPH PATTERN MATCHING - Techniques for identifying, in a target graph, subgraphs that match a query graph are provided. Processing a query graph comprises multiple stages, one for each query node in the query graph. In the first stage, a query node is selected, different portions of the target graph are assigned to different threads, each thread identifies nodes that match the selected query node and stores the identities of those nodes in storage that is local to the thread. The results of each thread are then stored in a “global” data structure. In the second stage, a second query node is selected and different portions of the global data structure are assigned to different threads. Each thread identifies nodes that match the second query node and that are connected to a previously-matched node. The second stage repeats until all nodes in the query graph are processed. | 02-18-2016 |
20160117358 | GRAPH DATABASE SYSTEM THAT DYNAMICALLY COMPILES AND EXECUTES CUSTOM GRAPH ANALYTIC PROGRAMS WRITTEN IN HIGH-LEVEL, IMPERATIVE PROGRAMING LANGUAGE - Techniques are provided for a graph database system that accepts custom graph analytic programs that are written in a high-level graph-specific programming language and compiles the programs into executables that, when executed, directly access graph data of a graph that is stored in the graph database. In this way, a low-level data-access API is avoided. Also, a graph analytic program, which only describes an abstract description of an algorithm, does not include any details regarding data access. In one technique, a user is not required to include explicit parallelization in a graph analytic program in order for the graph analytic program to take advantage of parallelization. A compiler of the graph database system identifies portions of the graph analytic program that can benefit from parallelization and, in response, generates parallelized executable code that corresponds to those portions. | 04-28-2016 |