Abstract: The method includes:—pre-compiling a source code including determining (212), in the source code, the presence of one or a plurality of array computations on one or a plurality of arrays, referred to as input arrays, the result whereof is assigned to an array, referred to as a result array, and modifying (214) the source code according to the array computation(s) for which the presence has been determined; and—compiling (238) the modified source in machine code intended to be executed by a computer system, referred to as a target computer system, having a processor, the compiling (238) of the modified source code including compiling the command instructions in instructions which, when executed by the processor of the target computer system, command a specialized electronic device, different from the processor, to carry out each array computation detected.

Abstract: Systems and methods disclosed herein uniquely define each type of Fortran type descriptor within an executable file or shared library to allow for a rapid determination of how the dynamic type of one object (e.g., a first polymorphic entity) relates to that of another object (e.g., a second polymorphic entity) while allowing for the lazy loading of shared libraries. In one aspect, type descriptor definitions are instantiated (e.g., during compile-time) in each of a number of object files in which polymorphic entities are defined, each type descriptor definition is marked with a singleton attribute, and each group of common type descriptor definitions is associated with a COMDAT group to ensure that only a single copy of each type descriptor is defined in a corresponding executable file at a particular address in memory to which polymorphic entities can reference. Type descriptor addresses can be compared to determine dynamic type relations between two or more polymorphic entities.

Abstract: Methods, systems and techniques for managing revisions of documents in a collaborative, multiuser document store are provided. Example embodiments provide an Automated Document Revision Management Server (“ADRMS”) to automatically cluster and remove revisions of file content for easy navigation and management. Revisions are trimmed when necessary to conserve storage space. The ADRMS creates logical clusters of revisions based upon some measure of their similarities. That is, revisions that are similar and can be represented by the latest revision in the cluster formulate one cluster, and those that are markedly dissimilar are placed in a different cluster. The logic used to cluster revisions accounts for time-based factors, content-based factors, and context-based factors to determine whether a revision is incremental and can be grouped in the same cluster or is significant enough to warrant a new cluster. Revisions may be trimmed based upon age and/or available space by a revision trimming component.

Abstract: A neuromorphic compiler includes a placement module to provide analytic placement of neurons in a neural network description. The analytic placement is to produce placed neurons. The neuromorphic compiler further includes a smoothing module to perform diffusion-based smoothing of the placed neurons; a legalization module to adjust locations of the placed neurons to correspond to legal locations of neuromorphic neurons within a neural fabric; and a simulated annealing module to refine locations of the placed neurons within the neural fabric using simulated annealing following location adjustment by the legalization module. The neural fabric is to implement a synaptic time-multiplexed (STM) neuromorphic network.

Abstract: A process, a computer program product, and a computer system for efficient code cache management implemented by a just-in-time compiler are provided. Embodiments of the present invention provide a practical approach to compile effectively for methods that are frequently executed over a short time period but are subsequently not executed frequently. The disclosed approach reduces the detrimental effects of compilation of such infrequently executed methods on throughput and garbage collection pause times.

Abstract: Methods for encoding a program. Each program instruction in a program has one or more possible encodings, and each instruction encoding may have a different length. The instruction encodings are selected such that the resulting encoding of the program as a whole minimizes the number of program cycles used in a decoding stage of a processor. Instruction padding or program padding may be used to create instruction encodings of lengths.

Abstract: The concept of faults and fault handling are added to the execution of continuous event processing (CEP) queries. By introducing fault handling techniques to the processing of CEP queries, users are enabled to instruct a CEP query processor to respond to faults in a customized manner that does not necessarily involve the halting of the CEP query relative to which the faults occurred. For example, a fault might be due to a temporary problem. Under such circumstances, the CEP query processor can be instructed to ignore the fault and allow the execution of the CEP query to continue relative to the remainder of the event stream. Alternatively, if the fault is due to a problem with the CEP query itself, then the CEP query processor can be instructed to propagate the fault through the query processing system until the fault ultimately causes the problematic CEP query to be halted.

Abstract: A computer-readable recording medium having stored therein a program for causing a computer to execute a digital signature process includes determining that a first specific instruction for executing parallel calculations of the same type, each calculation operating on a different piece of data, is generated by combining first and second instructions included in a first code, retrieving, from the first code, a third instruction for calculating data referenced by the first instruction and a fourth instruction for calculating data referenced by the second instruction, and selecting the third and fourth instructions as candidates of instructions to be combined with each other preferentially to generate a second specific instruction which is different from the first specific instruction.

Abstract: Techniques for incorporating performance data into an executable file for an application are described. Embodiments monitor performance of an application while the application is running. Additionally, historical execution characteristics of the application are determined based upon the monitored performance and one or more system characteristics of a node on which the application was executed on. Embodiments also incorporate the historical execution characteristics into executable file for the application, such that the historical execution characteristics can be used to manage subsequent executions of the application.

Abstract: Techniques for incorporating performance data into an executable file for an application are described. Embodiments monitor performance of an application while the application is running. Additionally, historical execution characteristics of the application are determined based upon the monitored performance and one or more system characteristics of a node on which the application was executed on. Embodiments also incorporate the historical execution characteristics into executable file for the application, such that the historical execution characteristics can be used to manage subsequent executions of the application.

Abstract: A program entity that generates code but that does not perturb global state is identified. Code produced by the identified program entity can be assigned an identifier and cached the first time it is executed. Subsequent executions of the program entity can eliminate generation of the code and/or translation of the generated code into native binary code. The runtime generated code and native binary code can be cached in a machine-wide cache, or can be added to the metadata of the assembly generated from the source code of the program entity.

Abstract: Some embodiments provide a media-editing application. The application includes several image processing destinations for performing operations on video images. The application includes a scheduling engine for scheduling disk read, decode, and graphics processing operations to perform on images to prepare the images for the several destinations. The scheduling engine includes a first set of instructions for scheduling images based on a speed at which a particular one of the several destinations processes the images when none of the destinations require images in real-time. The scheduling engine includes a second set of instructions for scheduling images based on a real-time clock when at least one of the several destinations requires images in real-time.

Abstract: Methods, systems, and products are disclosed for optimizing just-in-time (‘JIT’) compiling for a Java application executing on a compute node, the compute node having installed upon it a Java Virtual Machine (‘JVM’) capable of supporting the Java application, that include: identifying, by an application manager, a particular portion of the Java application; assigning, by the application manager, a JIT level to the particular portion of the Java application; and jitting, by the JVM installed on the compute node, the particular portion of the Java application in dependence upon the JIT level assigned to that particular portion of the Java application.

Abstract: Discovering timing attack vulnerabilities in a computer software application by statically analyzing instructions of a computer software application to identify multiple possible execution paths traversing any of the instructions, calculating, for each of the possible execution paths, a cost associated with the execution of the instructions traversed by the possible execution path, comparing the costs of at least two of the possible execution paths having inputs of the same size, and identifying as a timing attack vulnerability any of the compared possible execution paths whose cost differs, by at least a predetermined amount, from the cost of any other of the compared possible execution paths.

Abstract: Discovering timing attack vulnerabilities in a computer software application by statically analyzing instructions of a computer software application to identify multiple possible execution paths traversing any of the instructions, calculating, for each of the possible execution paths, a cost associated with the execution of the instructions traversed by the possible execution path, comparing the costs of at least two of the possible execution paths having inputs of the same size, and identifying as a timing attack vulnerability any of the compared possible execution paths whose cost differs, by at least a predetermined amount, from the cost of any other of the compared possible execution paths.

Abstract: Methods, systems, and products are disclosed for optimizing just-in-time (‘JIT’) compiling for a Java application executing on a compute node, the compute node having installed upon it a Java Virtual Machine (‘JVM’) capable of supporting the Java application, that include: identifying, by an application manager, a particular portion of the Java application; assigning, by the application manager, a JIT level to the particular portion of the Java application; and jitting, by the JVM installed on the compute node, the particular portion of the Java application in dependence upon the JIT level assigned to that particular portion of the Java application.

Abstract: A consumption data monitoring method may identify an interface provided by an operating system running on a server. A monitoring module populates an operating system database with information on the identified interface. The monitoring module populates a host database with consumption details received from a host machine, the consumption details comprising one or more interfaces of an operating system on the host machine used by a computer application program running on the host machine. The monitoring module compares the host database to the operating system database to determine if the interface provided by the operating system running on the server matches the one or more interfaces of the operating system on the host machine.

Abstract: A user equipment (UE) device for programmatic runtime generation of an application. The UE device receives a UI definition file that includes definitions indicating visual appearance attributes of portions of the application, a set of components that are UI building blocks to be presented within the application, and a set of behaviors that may be performed by the components, where the definitions include attribute-value pairs. The UE device receives a set of component definition files that include code for implementing components that includes the components indicated by the UI definition file and after a beginning of an execution of the application, the UE device parses the UI definition file to identify the visual appearance attributes, the set of components, and the set of behaviors; and dynamically instantiates the set of components based upon the parsed UI definition file and the set of component definition files to create the application.

Abstract: Embodiments are directed towards generating applications that include multi-sized types running in managed code. During the compilation of an intermediate language version of an application, if a multi-size type is encountered, a runtime engine may perform actions to process the multi-size types. Accordingly, architecture information associated with the target computer may be determined. Data types corresponding to the architecture of the target computer and the multi-sized types may be determined based on the architecture information. Native code calls associated with an intermediate language code calls may be determined such that the parameters of the native code calls match the architecture dependent data types. And, a machine code version of the intermediate language code call may be generated. The generated machine code version of the intermediate language code may be executed with the data types specific to the target computer.

Abstract: In accordance with disclosed embodiments, there are provided methods, systems, and apparatuses enabling polymorphic objects across devices in a heterogeneous platform. According to the disclosed embodiments, such means include, for example, receiving, at a device aware compiler, source code for a computer program as input; compiling the source code for the computer program, in which the compiling includes at least: generating two distinct sets of executable binary instructions for a method of an object; in which a first of the two distinct sets of executable binary instructions for the method of the object provides first binary instructions for the method executable by a first computing device and not executable by a second computing device; and in which a second of the two distinct sets of executable binary instructions for the method of the object provides second binary instructions for the method executable by the second computing device and not executable by the first computing device.

Abstract: A computerized apparatus, a computer-implemented method and a computer program product for manipulating source code patches. The apparatus comprising a processor that is configured to: obtain a source code patch comprising plurality of source code modification instructions with respect to a source code and to automatically split the source code patch into plurality of sub-patches, wherein applying the plurality of sub-patches on the source code in an order is equivalent to applying the source code patch.

Abstract: A method for automatically provisioning a platform implementation package to a client device may include receiving from an application executing on the client device, a request for functionality. The request may be received via a client library distributed with the application, and may be for functionality provided by the platform implementation package. The platform implementation package may provide functionality that is not provided by the client library. It may be further automatically determined, by the client device, that the functionality requires an update to the platform implementation package. In response, a request for the update to the platform implementation package may be communicated to a computing system. The update to the platform implementation package may be received from the computing system and installed on the client device. The requested functionality may be provided to the application by the updated platform implementation package.

Abstract: Methods, apparatus and computer program products implement embodiments of the present invention that include replacing, in one or more initial source code files, each reference to a first function configured to convey system messages with a respective reference to a second function configured to convey the system messages, thereby producing respective corresponding preprocessed source code files for the one or more initial source code files. The respective corresponding preprocessed source code files are then compiled, thereby creating an executable file. While executing the executable file, a call to the second function is received, wherein the call includes a text string. A name of one of the respective corresponding preprocessed source code files storing the call to the second function is identified, and based on the identified name and the text string, a computed destination is determined for the text string. Finally, the text string is conveyed to the computed destination.

Abstract: A method for distributing execution of a computer program to a plurality of hardware architectures of different types including: analyzing the computer program to identify a plurality of execution boundaries; selecting one or more execution boundaries from the plurality of execution boundaries; linking the computer program to the selected one or more execution boundaries; executing the computer program with linked execution boundaries; saving a hardware agnostic state of the execution of the computer program, when the execution encounters a boundary from the selected one or more execution boundaries; and transmitting the hardware agnostic state to a remote hardware architecture to be executed on the remote hardware architecture, responsive to the hardware agnostic state.

Abstract: A system may include an application programming interface (API) layer, a cache layer, and an object storage/access layer. The API layer may expose an interface to store a business object and an interface to retrieve the business object, and may transmit a request to store the business object and a request to retrieve the business object, and the cache layer may cache the business object and transmit the request to store the business object and the request to retrieve the business object. The object storage/access layer may receive the request to store the business object and, in response to the request to store the business object, to invoke a serialization method exposed by the business object to store the data associated with the object in a data structure.

Abstract: Methods, systems, and computer programs manage memory of a runtime environment executing on a virtual machine. A runtime environment, such as a Java Virtual Machine, may deterministically arrange immutable data within memory such that a hypervisor may perform page sharing on the immutable data. The runtime environment may page-align the immutable data within memory. The runtime environment may further store the immutable within memory using self-referenced or self-relative pointers.

Abstract: A wireless end-user device has wireless wide-area network (WWAN) and wireless local-area network (WLAN) modems. One or more processors classify when an application is interacting in the device foreground with a user. For a time period when data for Internet service activities is communicated through the WWAN modem, the processors use a differential traffic control policy to selectively block and allow network access for an application based on whether the application is classified as interacting in the device foreground with a user. The processors provide a network access condition to the application through an application program interface (API), and thus can indicate that Internet data service is unavailable to that particular application based on the classification. A different policy may apply to WLAN modem usage and/or to different WWAN networks.

Abstract: A completion time is obtained for each phase of a plurality of phases in a user story. Completion times of phases are obtained for each user story of a plurality of user stories. A maximum completion time, a minimum completion time and a composite metric are determined for phases common among the user stories. A chart displays the phases common among the user stories over the sprint time period. Sprint time period is used to define a first axis and phase completion time is used to define a second axis. A vertical bar is displayed for each respective phase, parallel with the second axis, having a top end on the second axis based on a maximum completion time for the respective phase and a bottom end on the second axis based on a minimum completion time.

Abstract: Systems and methods for handling an OPEN CHANNEL command from a universal integrated circuit card (UICC) of a mobile device are disclosed. In some implementations, a mobile device hosting a UICC receives, from the UICC, an initiation of an OPEN CHANNEL command with a uniform resource locator (URL) of a subscriber identity module over the air (SIMOTA) server. The mobile device signals for attempting to resolve the URL to an Internet Protocol (IP) address. Upon successfully resolving the URL to the IP address, the mobile device obtains the IP address associated with the SIMOTA server, connects to the SIMOTA server using the IP address, and returns a successful TERMINAL RESPONSE to the UICC. Upon failing to resolve the URL to the IP address, the mobile device returns an unsuccessful TERMINAL RESPONSE to the UICC.

Abstract: Disclosed herein are systems, computer-implemented methods, and non-transitory computer-readable storage media for obfuscating code, such as instructions and data structures. Also disclosed are non-transitory computer-readable media containing obfuscated code. In one aspect, a preprocessing tool (i.e. before compilation) identifies in a source program code a routine for replacement. The tool can be a software program running on a computer or an embedded device. The tool then selects a function equivalent to the identified routine from a pool of functions to replace the identified routine. A compiler can then compile computer instructions based on the source program code utilizing the selected function in place of the identified routine. In another aspect, the tool replaces data structures with fertilized data structures. These approaches can be applied to various portions of source program code based on various factors. A software developer can flexibly configure how and where to fertilize the source code.

Abstract: A device receives program code, and receives size/type information associated with inputs to the program code. The device determines, prior to execution of the program code and based on the input size/type information, a portion of the program code that is executable by a graphical processing unit (GPU), and determines, prior to execution of the program code and based on the input size/type information, a portion of the program code that is executable by a central processing unit (CPU). The device compiles the GPU-executable portion of the program code to create a compiled GPU-executable portion of the program code, and compiles the CPU-executable portion of the program code to create a compiled CPU-executable portion of the program code. The device provides, to the GPU for execution, the compiled GPU-executable portion of the program code, and provides, to the CPU for execution, the compiled CPU-executable portion of the program code.

Abstract: An apparatus supporting MTC in an LTE environment including an LTE modem and a CDMA modem. The LTE modem accesses a first wireless network and executes first data transactions, where the first wireless network comports with LTE standards. The CDMA modem is operationally coupled to the LTE modem, and accesses a second wireless network and executes second data transactions, where the second wireless network comports with one or more CDMA-based standards. The CDMA modem includes an inter-radio access technology (IRAT) API element and an inter-process communication (IPC) module. The IRAT API element is configured to send/receive IRAT messages via function calls to/from the LTE modem, where the IRAT messages remain the same regardless of interface requirements for the LTE modem. The IPC module is coupled to the IRAT API element, and is configured to generalize the function calls to enable the CDMA modem to interoperate with the LTE modem.

Abstract: A method for managing class metadata in a garbage collected system, including (i) allocating a metaspace to a class loader of a mutator using a memory heap, where the metaspace is configured to store the class metadata generated by the class loader, (ii) storing, in the metaspace, class metadata items associated with classes defined by the class loader, where the class metadata items and the class loader are coterminous, and where all of the class metadata items are identified by a garbage collector as live if any of the class metadata items is reachable by the mutator, (iii) updating a linkset graph during resolution of symbolic links to sumarize cross-metaspace references, and (iv) reclaiming, by the garbage collector based on a pre-determined algorithm using the metaspace, memory locations unreachable by the mutator, where all memory locations allocated to the class metadata items are reclaimed together as a group.

Abstract: An apparatus includes a memory that stores an instruction including an opcode and an operand. The operand specifies an immediate value or a register indicator of a register storing the immediate value. The immediate value is usable to identify a function call address. The function call address is selectable from a plurality of function call addresses.

Abstract: Technologies are generally described herein for supporting program and data annotation for hardware customization and energy optimization. A code block to be annotated may be examined and a hardware customization may be determined to support a specified quality of service level for executing the code block with reduced energy expenditure. Annotations may be determined as associated with the determined hardware customization. An annotation may be provided to indicate using the hardware customization while executing the code block. Examining the code block may include one or more of performing a symbolic analysis, performing an empirical observation of an execution of the code block, performing a statistical analysis, or any combination thereof. A data block to be annotated may also be examined. One or more additional annotations to be associated with the data block may be determined.

Abstract: Aspects of the subject matter described herein relate to imperative attribution. In aspects, metadata of a managed runtime environment may be set by imperative statements included in code of a program executing in the managed runtime environment. A metadata consumer may request the metadata. A metadata identifier of the metadata requested may be provided implicitly or explicitly. A parameter that indicates how to obtain the metadata may also be provided. In response, the metadata may be obtained and provided. The metadata may be computed at parse time, run time, or another time and may be computed based on state available to a managed runtime environment at the time the metadata is computed.

Abstract: One embodiment of the present invention provides a system that facilitates diagnostic logging for software components. During operation, the system receives program code for a software component that was generated from an object model, where a key attribute has been specified for the object model. During execution of the program code, the system detects when an instance of the key attribute for the object model is accessed, and attaches state associated with the instance to a thread context in the runtime environment. The system then appends this state to a log during a logging operation to facilitate discovering and analyzing program faults.

Abstract: Embodiments of the present invention provide an approach for integrated development environment (IDE)-based repository searching (e.g., for library elements such as classes and/or functions) in a networked computing environment. In a typical embodiment, a first program code file is received from a first integrated development environment (IDE). The first program file may be associated with a set of attributes as stored in an annotation, header, or the like. Regardless, the first program file may be parsed and indexed into a repository based on the set of attributes. A search request may then be received from a second IDE. Based on the search request and the set of attributes, a matching program code file may then be identified as stored in the repository. Once identified, the matching program code file may be transmitted/communicated to the second IDE to fulfill the search request.

Abstract: A dynamic, lazy type system is provided for a dynamic, lazy programming language. Consequently, programs can benefit from runtime flexibility and lightweight notation in combination with benefits afforded by a substantial type system.

Abstract: The invention relates to a computer-implemented method for displaying data values calculated by a spreadsheet-function, the method comprising: Specifying one or more formal output parameters by specifying, for each formal output parameter, a first cell of a spreadsheet document, Specifying one or more formal input parameters by specifying, for each formal input parameter, a second cell, Specifying a spreadsheet-function body, wherein the specified spreadsheet-function in operation provides a user with the option for: Calculating a first output parameter value, Displaying the one or more first output parameter values or a data value having been derived thereof in a 3rd cell, Calculating a second output parameter value, and Displaying the one or more second output parameter values or a data value having been derived thereof in a 4th cell, wherein the 3rd cell and the 4th cell display their respective data content within the spreadsheet document at the same time.

Abstract: A control system development platform is provided. The platform includes a shell component adapted to support development of a control systems application. An abstract model is associated with the shell component to facilitate development of the control systems applications.

Abstract: An aspect of the present disclosure provides for applying hot fixes to metadata customizing user interactions based on a software program. In an embodiment, a hot fix containing new files is received. Each new file contains a corresponding modified metadata. The user is presented for selection, differences between each new file and a corresponding existing file. Only the selected differences are then used to form patched files, which thereafter control the user interactions, for example, by replacing the corresponding existing file with the patched file. Accordingly the user is provided enhanced control over which of the differences is applied to the metadata.

Abstract: A single software project in an integrated development environment (IDE) may be built for multiple target environments in a single build episode. Multiple different output artifacts may be generated by the build process for each of the target environments. The output artifacts are then deployed to the target environments, which may be homogeneous or heterogeneous environments. The same source project may be used to generate multiple output artifacts for the same target environment.

Abstract: A software development environment (SDE) and a method of compiling integrated source code. One embodiment of the SDE includes: (1) a parser configured to partition an integrated source code into a host code partition and a device code partition, the host code partition including a reference to a device variable, (2) a translator configured to: (2a) embed device machine code, compiled based on the device code partition, into a modified host code, (2b) define a pointer in the modified host code configured to be initialized, upon execution of the integrated source code, to a memory address allocated to the device variable, and (2c) replace the reference with a dereference to the pointer, and (3) a host compiler configured to employ a host library to compile the modified host code.

Abstract: During compilation, the interval bounds for a programmable culling unit are calculated if possible. For each variable, interval bounds are calculated during the compilation, and the bounds together with other metadata are used to generate an optimized culling program. If not possible, then an assumption may be made and the assumption used to compile the code. If the assumption proves to be invalid, a new assumption could be made and the code may be recompiled in some embodiments.

Abstract: Techniques for minifying a client-side web application are described. In one embodiment, a computer-implemented method includes performing a static analysis of a set of files written in a dynamic programming language that make up the web application. A single minified web application file is generated based on a traversal of a dependency graph that includes, in proper dependency order, components that are needed at runtime and does not include components of the set of files that will not be needed at runtime. The single minified web application file may be delivered to end user computing devices in place of the original set of files without loss of web application functionality.

Abstract: Methods, systems, and apparatus, including computer programs encoded on a computer storage medium, for just in time compilation. In one aspect, a method includes receiving an application on a mobile device, the mobile device including a processor for executing native code and an interpreter for interpreting intermediate code, wherein an application includes at least one machine instruction; receiving data characterizing prior actions of the application on the mobile device; determining a portion of intermediate code to be compiled into native code based at least in part on the data, wherein the portion includes some but not all of the application; sending the portion of intermediate code over a network to a compilation server; receiving native code corresponding to the portion of intermediate code from the compilation server; and executing the native code on the processor.

Abstract: A computing device displays a call history graphical user interface (GUI). The call history GUI includes a new list and an old list. The new list may include new missed call elements and missed call elements associated with new unopened voicemails. The old list may include other call history GUI elements, such as old missed call elements and missed call elements associated with opened voicemails.

Abstract: A computing method includes accepting a definition of a computing task, which includes multiple Processing Elements (PEs) having execution dependencies. The computing task is compiled for concurrent execution on a multiprocessor device, by arranging the PEs in a series of two or more invocations of the multiprocessor device, including assigning the PEs to the invocations depending on the execution dependencies. The multiprocessor device is invoked to run software code that executes the series of the invocations, so as to produce a result of the computing task.

Abstract: A system includes a memory and a processor communicatively coupled to the memory. The processor accesses a particular build schedule from one or more build schedules stored in the memory. The processor accesses, according to the particular build schedule, one or more artifacts and a label associated with the one or more artifacts stored in one or more data repositories. The label associated with the one or more artifacts corresponds to a particular software environment. The processor builds a software package using the one or more artifacts and deploys the software package to the software environment corresponding to the label of the one or more artifacts.