| Entries |
| Document | Title | Date |
|---|
| 20080271006 | Technologies for Code Failure Proneness Estimation - The present examples provide technologies for estimating code failure proneness probabilities for a code set and/or the files that make up the set. The code set being evaluated is typically comprised of binary and/or source files that embody the software for which the estimates are desired. The estimates are typically based on a set of selected code metrics, the code metrics typically selected based on corresponding failures of a previous version of the software. A historically variant metric feedback factor may also be calculated and code metric values classified relative to a baseline code set embodying the previous version of the software. | 10-30-2008 |
| 20080282238 | STATIC TYPE FOR LATE BINDING - A static type computer language provides optional dynamic typing triggered by a unique static type. The unique static type can be utilized anywhere other types can be employed to identify programmatic elements that are late bound. As a result, static types can be analyzed at compile time while deferring analysis of dynamic types until runtime. | 11-13-2008 |
| 20080307404 | DYNAMIC LINKING AND LOADING OF POST-PROCESSING KERNELS - A computer system may generate a plurality of component kernels, which are to be linked during the runtime. The system may determine whether a combined kernel K is present in response to receiving a first request to retrieve the combined kernel K. The system may compose the combined kernel K from the selected component kernels of the plurality of component kernels during the runtime if the combined kernel is not already present. | 12-11-2008 |
| 20080313623 | CHANGING METADATA WITHOUT INVALIDATING CURSORS - A method and apparatus for changing versioned metadata without invalidating cursors is provided. Cursors may be linked to the appropriate version of metadata at execution time as opposed to compilation time, meaning that they do not require recompilation to link to a new version of metadata. A database system maintains compiled code implementing a plan with respect to data items in a data storage space. The compiled code may have been generated in response to receiving a request to perform an operation that may be implemented using the plan. A version of metadata is also maintained. The metadata describes characteristics of the data storage space implicated by the plan. The compiled code is executed. The step of execution comprises binding the compiled code to the version of metadata. A proxy object referenced in the compiled code may facilitate the binding of the compiled code to the appropriate version of metadata. | 12-18-2008 |
| 20080313624 | Dynamic loading and unloading for processing unit - Methods and apparatus are provided for enhanced instruction handling in processing environments. A program reference may be associated with one or more program modules. The program modules may be loaded into local memory and information, such as code or data, may be obtained from the program modules based on the program reference. New program modules can be formed based on existing program modules. Generating direct references within a program module and avoiding indirect references between program modules can optimize the new program modules. A program module may be preloaded in the local memory based upon an insertion point. The insertion point can be determined statistically. The invention is particularly beneficial for multiprocessor systems having limited amounts of memory. | 12-18-2008 |
| 20080320459 | Method And Systems For Providing Concurrency Control For Addressable Entities - Methods and systems are described for providing concurrency control for addressable entities. In one embodiment, a concurrency policy is associated with an addressable entity in an executable program component generated from source code, the concurrency policy controlling an order of access by a plurality of runtime processes each executing machine code instructions for accessing the addressable entity, the machine code instructions generated from source code, wherein the concurrency policy is associated with the addressable entity independent of the source code of the executable program component and the source code of the machine code instructions. An attempt to access the addressable entity by a machine code instruction executed by a runtime process of the plurality of runtime processes is detected. The machine code instruction is allowed to access the addressable entity based on the concurrency policy. | 12-25-2008 |
| 20080320460 | Fulfillment of requirement for versioned resource - A requirement for a versioned resource is fulfilled, particularly in light of compatibility constraints of the requirement. Versions of the versioned resource are associated with compatibility information, such as a feature version and a service version, for example. In fulfilling the requirement, compatibility logic may be applied to identify versions that are compatible with the requirement, and selection logic may be applied to select a preferred version from the compatible versions. | 12-25-2008 |
| 20090037894 | SYSTEM AND METHOD FOR SOFTWARE LOGGING - System and method for providing logging information associated with development of executable program code. The method may include inserting a plurality of logging information elements into program code, the plurality of logging information elements having at least one logging parameter associated with the program code. In one embodiment, filtering criteria may be defined corresponding to the at least one logging parameter. In another embodiment, the program code may be filtered based on the filtering criteria. According to another embodiment, a result of the filtering may be provided including a subset of the plurality of logging information elements corresponding to said filtering criteria. | 02-05-2009 |
| 20090164985 | COMPILING WORKFLOWS INTO INSTRUCTIONS FOR A STATE CORRELATION ENGINE - Methods and apparatus, including computer program products, for compiling workflows into instructions for a state correlation engine. In general, data characterizing a workflow of a process is received and a network representation of event-condition-action rules representing the workflow is generated. The workflow of the process may be modeled in accordance with a notation similar to the Business Process Modeling Notation. The network representation of event-condition-action rules may include a combination of source nodes representing events, operator nodes representing conditions, and action nodes representing transactions. Events of the source nodes may be represented types of objects of a type language, where a correlation engine is to execute an event-condition-action rule based on an existence of a combination of types of a rule. | 06-25-2009 |
| 20090199170 | Helper Thread for Pre-Fetching Data - A set of helper thread binaries is created to retrieve data used by a set of main thread binaries. If executing a portion of the set of helper thread binaries results in the retrieval of data needed by the set of main thread binaries, then that retrieved data is utilized by the set of main thread binaries. | 08-06-2009 |
| 20090307676 | Dead Functions Elimination in Dynamic Linked Libraries for Code Size Reduction of Operating Systems in Embedded Systems - This invention relates to a method for reducing the size of a set of computer code by replacing unused functions in the set of code with void functions having no operative content. The invention may be applied to a core operating system in order to reduce the amount of code that is permanently loaded on a computing device while the device is operating, thereby potentially reducing the requirements for both read-only non-execute-in-place memory and randomly addressable memory. The removed functionality may be provided separately in read-only memory if desired, so that it can be loaded when needed. | 12-10-2009 |
| 20100005458 | METHOD FOR MAKING LINKER PROGRAM - A method for making a linker program comprises the steps of (1) initializing a linker script; (2) selecting functions and sequence of the functions by a user; and (3) sequentially writing the functions to the linker script in accordance with the sequence of the functions. In an embodiment, the method further comprises the step of checking whether all the functions are written to the linker script. If all the functions are written to the file of the linker script, the linker script is completed. If at least one of the functions is not written to the file of the linker script, a user may determine to either complete the file of linker script or again write the functions to the linker script. | 01-07-2010 |
| 20100017792 | OPEN APPLICATION LIFECYCLE MANAGEMENT FRAMEWORK - Techniques for open application lifecycle management frameworks are described, including using a framework hosted on one or more computers and having one or more services to integrate the one or more services with one or more applications using one or more providers, each of the one or more providers is adapted to at least one of the one or more applications, registering one or more repositories associated with the one or more applications using a location service module, receiving an input creating a project context associated with a project, data associated with the input being stored in a data structure associated with the project, the data structure being stored in a repository associated with the framework, generating a link, after registering the one or more repositories, between one or more element containers associated with the project, the link and the one or more element containers being stored in the repository, and configuring the framework to detect another input indicating interaction with an artifact, other data associated with the interaction being mapped between the one or more repositories and the repository using a domain model. | 01-21-2010 |
| 20100050165 | METHODS AND APPARATUS TO SUPPORT MIXED-MODE EXECUTION WITHIN A SINGLE INSTRUCTION SET ARCHITECTURE PROCESS OF A VIRTUAL MACHINE - Methods and apparatus to support the execution of a managed application that is linked to a native library or application are disclosed. The disclosed methods and apparatus support a virtual machine that is associated with the same ISA as the executing platform, while the ISA of the native library or application is of a different ISA. The disclosed methods and apparatus also support the execution of a managed application that is linked with several native libraries or applications that are associated with several different ISAs respectively. | 02-25-2010 |
| 20100058305 | Automatic Generation of Language Bindings for Libraries Using Data from Compiler Generated Debug Information - Described herein is a method and apparatus for generating automatic language bindings. The method includes receiving a request for a first program module in a first language from a second program in a second language. A binding module is created in the second language in response to the request, where the binding module is generated from debug data of the first program module. The the binding module is returned to the second program module. The second program module can then access the functionality of the first program module through use of the functions of the binding module. | 03-04-2010 |
| 20100229164 | METHOD AND SYSTEM GENERATING EXECUTION FILE SYSTEM DEVICE - Provided is a method and system generating an execution file. The method includes determining number-of-calls information for a number of functions and then generating the execution file by locating the functions based on the number-of-calls information. | 09-09-2010 |
| 20120124565 | LINKING MODEL INSTANCES TO PACKAGES - In a method | 05-17-2012 |
| 20120185837 | METHODS AND SYSTEMS FOR LINKING OBJECTS ACROSS A MIXED COMPUTER ENVIRONMENT - A method of linking a computer program across a mixed computing environment is provided. The method includes, performing on one or more processors: identifying signatures of elements of the computer program; loading a plurality of modules of the computer program; and linking the plurality of modules using the signatures of the elements. | 07-19-2012 |
| 20120260241 | SYSTEM AND METHOD FOR GENERATING DISTRIBUTED INFORMATION SYSTEMS - A distribution information system includes a local system repository, a run-time engine, and an active links table. The local system repository stores component instance data. The run-time engine creates an instance of one or more components based on the component instance data stored in the local system repository. The active links table defines links between the created component instances, wherein the run-time engine manages communication between the created component instances based on the active links table. | 10-11-2012 |
| 20120324432 | SYSTEMS AND METHODS TO AUTOMATICALLY GENERATE CLASSES FROM API SOURCE CODE - According to some embodiments, Application Programming Interface (API) source code, including command design patterns, is determined to be executed as a runtime scenario. Class may then be automatically generated as linkable building blocks in accordance with the API source code and command design patterns. For example, API command classes and associated methods may be dynamically read using reflection, and a building block class associated with each API command class may be generated. Runtime readable embedded metadata may be planted in the building block classes, at least some of the metadata being provided by the reflection. According to some embodiments, a logical sequence of the building blocks classes may be linked in accordance with the runtime scenario. | 12-20-2012 |
| 20130305233 | METHOD AND SYSTEM FOR SEPARATE COMPILATION OF DEVICE CODE EMBEDDED IN HOST CODE - Embodiments of the present invention provide a novel solution that supports the separate compilation of host code and device code used within a heterogeneous programming environment. Embodiments of the present invention are operable to link device code embedded within multiple host object files using a separate device linking operation. Embodiments of the present invention may extract device code from their respective host object files and then linked them together to form linked device code. This linked device code may then be embedded back into a host object generated by embodiments of the present invention which may then be passed to a host linker to form a host executable file. As such, device code may be split into multiple files and then linked together to form a final executable file by embodiments of the present invention. | 11-14-2013 |
| 20130305234 | METHOD AND SYSTEM FOR MULTIPLE EMBEDDED DEVICE LINKS IN A HOST EXECUTABLE - Embodiments of the present invention provide a novel solution to generate multiple linked device code portions within a final executable file. Embodiments of the present invention are operable to extract device code from their respective host object filesets and then link them together to form multiple linked device code portions. Also, using the identification process described by embodiments of the present invention, device code embedded within host objects may also be uniquely identified and linked in accordance with the protocols of conventional programming languages. Furthermore, these multiple linked device code portions may be then converted into distinct executable forms of code that may be encapsulated within a single executable file. | 11-14-2013 |
| 20140047424 | Simultaneous Compiler Binary Optimizations - The present invention provides a method to optimize object code files produced by a compiler for several different types of target processors. The compiler divides the source code to be compiled into several functional modules. Given a specified set of target processors, each functional module is compiled resulting in a target object version for each target processor. Then, for each functional module, a merging process is performed wherein identical target object versions or target object versions with similar contents are merged by deleting the identical or similar versions. After this merging process, a composite object code file is formed containing all of the non-deleted target object versions of the function modules. | 02-13-2014 |
| 20140059525 | METHOD AND SYSTEM FOR FACILITATING REPLACEMENT OF SYSTEM CALLS - One embodiment of the present invention provides a system for facilitating replacement of a system call in an application with a customized function call. During operation, the system re-links the application's executable file with additional code or dynamically injects the additional code to the application's executable file during run time. The additional code can change a pointer in a table which indicates addresses of imported functions so that the pointer indicates an address of the customized function call. | 02-27-2014 |
| 20140304692 | SYSTEMS AND METHODS FOR IMPLEMENTING A UNIFORM APPLICATION USER INTERFACE ACROSS A MULTI-TENANT ENVIRONMENT - In accordance with disclosed embodiments, there are provided systems and methods for implementing a uniform application user interface across a hosted computing environment, such as an on-demand or cloud computing environment which utilizes multi-tenant database technologies, client-server technologies, traditional database technologies, or other computing architecture in support of the hosted computing environment. According to a particular embodiment such a system includes a processor and a memory to execute instructions at the system; a foundation layer to define a plurality of components; the plurality of components, each to define one or more features to be consumed by an arbitrary application built from the features; wherein the one or more features are to each incorporate one or more of the components defined by the foundation layer and further wherein each of the one or more features have visibility to one or more interfaces available for the respective features to connect with but have no visibility to or about any arbitrary application that will consume them; a glue logic layer to link the features to the arbitrary application built from the features, wherein the arbitrary application built from the features has a one-way view of the features consumed through the glue logic layer without permitting the features visibility to or about the arbitrary application built; and wherein the arbitrary application built from the features is to execute within the host organization. Other related embodiments are disclosed. | 10-09-2014 |
| 20150128117 | LINKER THAT STATICALLY ALLOCATES NON-MEMORY RESOURCES AT LINK TIME - A novel linker statically allocates resource instances of a non-memory resource at link time. In one example, a novel declare instruction in source code declares a pool of resource instances, where the resource instances are instances of the non-memory resource. A novel allocate instruction is then used to instruct the linker to allocate a resource instance from the pool to be associated with a symbol. Thereafter the symbol is usable in the source code to refer to an instance of the non-memory resource. At link time the linker allocates an instance of the non-memory resource to the symbol and then replaces each instance of the symbol with an address of the non-memory resource instance, thereby generating executable code. Examples of instances of non-memory resources include ring circuits and event filter circuits. | 05-07-2015 |
| 20150128118 | HIERARCHICAL RESOURCE POOLS IN A LINKER - A novel declare instruction can be used in source code to declare a sub-pool of resource instances to be taken from the resource instances of a larger declared pool. Using such declare instructions, a hierarchy of pools and sub-pools can be declared. A novel allocate instruction can then be used in the source code to instruct a novel linker to make resource instance allocations from a desired pool or a desired sub-pool of the hierarchy. After compilation, the declare and allocate instructions appear in the object code. The linker uses the declare and allocate instructions in the object code to set up the hierarchy of pools and to make the indicated allocations of resource instances to symbols. After resource allocation, the linker replaces instances of a symbol in the object code with the address of the allocated resource instance, thereby generating executable code. | 05-07-2015 |
| 20150128119 | RESOURCE ALLOCATION WITH HIERARCHICAL SCOPE - A source code symbol can be declared to have a scope level indicative of a level in a hierarchy of scope levels, where the scope level indicates a circuit level or a sub-circuit level in the hierarchy. A novel instruction to the linker can define the symbol to be of a desired scope level. Location information indicates where different amounts of the object code are to be loaded into a system. A novel linker program uses the location information, along with the scope level information of the symbol, to uniquify instances of the symbol if necessary to resolve name collisions of symbols having the same scope. After the symbol uniquification step, the linker performs resource allocation. A resource instance is allocated to each symbol. The linker then replaces each instance of the symbol in the object code with the address of the allocated resource instance, thereby generating executable code. | 05-07-2015 |
| 20150347162 | PRELINKED EMBEDDING - This application discloses a computing system configured to perform a pre-linked embedding process during build-time of a root-kernel application. The computing system can pre-link one or more dynamically-linkable executable modules against exported symbols of a root-kernel image, and embed the pre-linked executable modules into the root-kernel image. The computing system can load the root-kernel image having the embedded pre-linked executable modules into a memory of an embedded system, wherein at least one processing device in the embedded system is configured to execute the embedded pre-linked executable modules directly from the memory. | 12-03-2015 |
| 20150378699 | GRAPHICAL SCREEN ELEMENT - A graphical screen element which is displayable on at least one screen of at least one computer device; with the aid of the screen element useful data for different application programs being manageable in a program-spanning manner; with the aid of the screen element the application programs being able to be linked together. | 12-31-2015 |
| 20160041825 | METHOD AND APPARATUS FOR OBTAINING CONTEXT INFORMATION FOR A SOFTWARE DEVELOPMENT TASK - Aspects are directed to obtaining context information for a software development task. A method includes finding, in response to designating any one tool component associated with the software development task as a root component, at least one other tool component having an at least one-level link with the root component. Context information is extracted n from the root component and the at least one other tool component. A context set is generated based on the extracted context information. | 02-11-2016 |
| 20160124733 | REWRITING SYMBOL ADDRESS INITIALIZATION SEQUENCES - A system includes a memory to store a linker and one or modules, and a processor, communicatively coupled to the memory. The computer system is configured to recognize a first symbol address initialization sequence in a module. The system determines whether the first symbol address initialization sequence is a candidate for replacement, determines whether to replace the first symbol address initialization sequence with a second symbol address initialization sequence, and replaces the first symbol address initialization sequence with the second symbol address instruction sequence when it is determined to replace the first symbol address initialization sequence with the second symbol address initialization sequence. | 05-05-2016 |
| 20160253158 | BACKEND CUSTOM CODE EXTENSIBILITY | 09-01-2016 |
