International Business Machines Corporation

Pradeep Varma

Donald Philip Pazel

Vijay Krishnarao Naik

Amitkumar Manoharrao Paradkar

Suresh Kumar

Ashok Anand

Beth Rush Tibbitts

Rudrapatna Kallikote Shyamasundar

Manish Satyapal Gupta

Vijay A Kumar

Krishna Kummamuru

John Arthur Pershing, Jr

Neeran Mohan Karnik

Girish Bhimrao Chafle

William Francis Jerome

Harshit Shah

Ajay Raina

Sameh Afif Fakhouri

Ashish Kundu

Arun Kumar

Rajkishore Barik

Divyesh Jadav

Inderpal Singh Narang

Vikas Agarwal

Peter Richard Badovinatz

Prashant Pandey

Monika Gupta

Upendra Sharma

Naga Praveen Kumar Katta

Manish P Kurhekar

Philippe G Charles

Vitthal Mahadeo Gogate

Nagraj Alur

Johara Shireen Shahabuddin

Peter B Badovinatz

A method of memory management can include creating an initial root set of pointers for a program during execution of the program and performing a marking process by iteratively marking referred objects of each pointer of the root set and expanding the root set with filtered, encoded pointers. The method also can include identifying each non-live object for any marked object as red-marked and performing, using a processor, a re-marking process on the root set in which red-marked objects are excluded. Each object of the root set not marked can be designated as including a memory leak.

Conservative garbage collection and access protection

A system and associated method for automatically pipeline parallelizing a nested loop in sequential code over a predefined number of threads. Pursuant to task dependencies of the nested loop, each subloop of the nested loop are allocated to a respective thread. Combinations of stage partitions executing the nested loop are configured for parallel execution of a subloop where permitted. For each combination of stage partitions, a respective bottleneck is calculated and a combination with a minimum bottleneck is selected for parallelization.

Automatic pipeline parallelization of sequential code

Techniques for generating concurrent static single assignment (CSSA) are provided. The techniques include generating a clocked control flow graph of a program, for each thread of the program created through async instruction, determining each part of the program that can execute concurrently with each thread to create a pair comprising a thread and a parallel program part, for each pair that can execute concurrently, using one or more flow equations to perform node-by-node matching, and using the node-by-node matching to generate CSSA form for the program.

Concurrent static single assignment for general barrier synchronized parallel programs

Techniques for providing safe user-managed memory are provided. The techniques include performing memory allocation in constant time, performing memory de-allocation in constant time, performing memory access overhead for safety checking in constant time, and using the memory allocation, memory de-allocation and memory access overhead to protect at least one memory access, user-specified allocation and de-allocation with at least one exception for said user-managed memory.

Method for protecting user-managed memory using an exception

Embodiments of the invention provide a table-free technique for detecting all temporal and spatial memory access errors in programs supporting general pointers. Embodiments of the invention provide such error checking using constant-time operations. Embodiments of the invention rely on fat pointers, whose size is contained within standard scalar sizes (up to two words) so that atomic hardware support for operations upon the pointers is obtained along with meaningful casts in-between pointers and other scalars. Optimized compilation of code becomes possible since the scalarized-for-free encoded pointers get register allocated and manipulated. Backward compatibility is enabled by the scalar pointer sizes, with automatic support provided for encoding and decoding of fat pointers in place for interaction with unprotected code.

Systems and methods for backward-compatible constant-time exception-protection memory

A decision support system called Mounties that is designed for managing applications and resources using rule-based constraints in scalable mission-critical clustering environments. Mounties consists of four active service components: (1) a repository of resource proxy objects for modeling and manipulating the cluster configuration; (2) an event notification mechanism for monitoring and controlling interdependent and distributed resources; (3) a rule evaluation and decision processing mechanism; and (4) a global optimization service for providing decision making capabilities. The focus of this paper is on the design of the first three services that together connect and coordinate the distributed resources with the decision making component.

Decision based system for managing distributed resources and modeling the global optimization problem

An analysis and source-to-source transformation framework covers dialects of programming languages that lack formal definition for all individual dialects. Multiple instantiations of the same compiler front-end tools can be used with different settings to create distinct intermediate forms and maps. Intermediate forms and maps are used in an individual analysis and source-to-source transformation context, and performing the analysis and source-to-source transformation thereupon. A unified tool set is desirably provided, including standard compiler front-end tools and code transformation/generation tools, wherein source code edits are carried out in order to make the source code more amenable to translation to intermediate forms. The analysis results or intermediate forms created by individual tools are used by other tools as well as further analyzed to create a map of the regions of validity and invalidity of the intermediate forms, and tracking the source-code edits performed in order to obtain the same. Among other benefits, this provides a choice of the best tools combination for maximum code analysis coverage.

Source-to-source transformation for language dialects

A Resource Management and Reservation System (RMRS) for managing and reserving storage bandwidth, is a platform independent middleware layer that provides an interface to applications, their database management systems, or some other higher level data management systems like ADRS which does data management on behalf of the applications. RMRS is highly relevant in hosted environments where one or more applications may be run on behalf of multiple customers each with a unique service level agreement with the Service Provider. Through its interface to the aforementioned applications, RMRS allows each application or an application side management system to communicate expected future storage access requirements (e.g., periodic access for backups). The interface also allows applications to request urgent storage access (e.g., recovery actions may be requested without being planned ahead of time).

System for managing and controlling storage access requirements

A method, apparatus and computer program product for comparing two computer program codes is disclosed. For each code, a stream of lexemes is generated for the program text of each code. The streams are concatenated in the same order as the program text. The two concatenated streams of lexemes are compared on a language-type by language-type basis to identify lexemes present only in one stream. The comparison derives a set of edit operations including minimal text block moves needed to convert one program code into the other program code.

Computer program code comparison using lexemes

A system (and method, and method for deploying computing infrastructure) for facilitating fixing program development errors found during different phases of program development using different programming tools, such as compilers, linkers, library managers, and debuggers, and can be integrated into a program development environment encompassing all tools. The exemplary aspects of the present invention can detect a qualified set of problems from which to recover with sufficient information, as typically provided by a user or other intelligent or artificial intelligent means, and upon error detection, can initiate a communication with the user (or other support software), to acquire information that could remedy the problem.

System and method for interactive and integrated software development process and phases

The provision of methods and apparatus to determine package identity for an application build. The idea is based on providing a mapping of package with affiliated attributes such as paths used for include or linking, along with reverse mappings. This mapping could be provided through any number of conventional environments such as program development environments or operating system registries: Tools would access this information through a programmatic interface, and use that information to identify packages affiliated with some information. For example, a symbol in a program would be defined in some file. That file would be in a path, which maps to the package identity. Thus, the symbol definition can be conceptually affiliated with a package.

Systems and methods for determining software package identity during a system build

Methods and arrangements for managing error messages from a set of programming tools within a program development environment, such as compilers, linkers, library builders, etc. The error messages are arranged as a directed acyclic graph, with the nodes as error messages, and edges as dependency relationships. In accordance with at least one presently preferred embodiment of the present invention, there are broadly contemplated the following: allowing one or more programming tool to report errors to an error manager component; deducing dependencies amongst error messages, based on error dependency definition provided to the error manager; and delivering messages and dependencies to client components. Although framed within the context of program development tools, this solution could be applied to many other tools outside this domain, under suitable and specified requirements.

Systems and methods for managing error dependencies

An embodiment of the invention provides a method of managing a cluster of networked resources and resource groups using rule-based constraints. This method includes the step of building a globally optimal cluster configuration of the resources in accordance with the rule-based constraints and a current state of the resources, including identifying for each of the resources and resource groups an availability and quality of service, which are determined by dependencies among the resources and resource groups, resource equivalency, constraints on the resources and network policies. The method comprises the further steps of bringing the cluster of resources on-line in a systematic manner, given the current state of each of the resources and resource groups; and with the cluster of networked resources on-line, determining dynamic dependencies of and configuration infomration about the cluster of resources (i) statically at defined times and (ii) dynamically during cluster operation.

Managing a cluster of networked resources and resource groups using rule - base constraints in a scalable clustering environment

Methods, compiler apparatus and a computer program product for compiling UPC source code are disclosed. UPC-unique constructs are converted into C-level form. The C-level constructs are inserted into the source code to form a combined code. The combined code is translated into an intermediate form, wherein any surviving UPC-unique components are discarded. All UPC-unique data or statements are converted to a form that can be handled by general compiler architectures, yet retain UPC properties. The resultant intermediate form is converted to compiled machine code. The generation of C-level constructs occurs at a compiler front end module, avoiding difficulties in intermediate code handling.

Compilation of unified parallel C-language programs

In an ASP server farm, requests to use an application are directed to a particular executing instance of the application (or an appropriate component thereof) that is identified as being the least loaded of the available such instances of the application or its component. The number of such instances is dynamically increased or decreased in response to the number of requests for the application or components thereof. Requests may be directed (in accordance with the first aspect) or the instances adjusted (in accordance with a second aspect) on a per client-basis, in which instances of the application and/or components thereof are reserved for the use of a user or a particular group of users. Operation in this manner facilitates compliance with service agreements with respective users or groups of users.

Growing community of inventors

New Delhi, India

Pradeep Varma