International Business Machines Corporation

Krishna Nandivada Venkata

Diptikalyan Saha

Pankaj Dhoolia

Mangala Gowri Nanda

Sugata Ghosal

Anup Kumar Ghosh

Asidhara Lahiri

Anjan Nandy

Rajkishore Barik

Vibha Singhal Sinha

Satish Chandra

Vijay Anand Saraswat

Igor Peshansky

Ganesh Bikshandi

A method and system for transforming a first computer program having program statements to a second computer program. A parsed first computer program is translated to the second computer program. The first computer program includes a first program statement that includes a first error. The translating includes: (i) identifying a second program statement in the parsed first computer program that includes a second error and has thrown a translation exception with respect to the second error, (ii) rolling back the translating to a predefined check point prior to the second program statement in the parsed first computer program such that the predefined check point is associated with a statement in the parsed first computer program that was successfully translated, and (iii) generating an executable equivalent translation for the second statement. After the translating, a mapping of one or more statements is generated.

Transformation of computer programs and eliminating errors

Systems and methods for replacing inferior code segments with optimal code segments. Systems and methods for making such replacements for programming languages using Message Passing Interface (MPI) are provided. For example, at the compiler level, point-to-point code segments may be identified and replaced with all-to-all code segments. Programming code may include X10, Chapel and other programming languages that support parallel for loop.

Systems and methods for automatically optimizing high performance computing programming languages

Methods and arrangements for localizing faults in programs. A program is assimilated, the program comprising statements. Output behavior of the statements is modeled, and statement occurrences are annotated. Passing and failing spectra are differenced to yield a difference, and a fault is located via employing the difference.

Fault localization for data-centric programs

A method and system to transform a plurality of programs associated with a plurality of programming languages is provided. In the method, a request is received by a computer to transform a first program in a first programming language to a second program in a second programming language. The first program is then transformed, wherein the transformation includes eliminating errors using predefined criteria. Further, the method maps a statement of the first program with a corresponding statement of the second program.

Techniques for representing a program are provided. The techniques include creating one or more sub-variables for each of one or more variables in the program, and maintaining a single size of each of the one or more variables throughout a life-span of each of the one or more variables. Additionally, techniques for performing register allocation are also provided. The techniques include representing bit-width information of each of one or more variables in a powers-of-two representation, wherein the one or more variables comprise one or more variables in a program, coalescing the one or more variables, packing the one or more coalesced variables, and using the one or more packed variables to perform register allocation.

Intermediate form for bitwidth sensitive applications and uses thereof

The embodiments provide for automatic incremental learning of programming language grammar. A corpus (i.e., a text file of software code written in a particular programming language) is parsed based on a set of grammar rules. An unparsed statement from the corpus is identified along with a section thereof, which did not match any of the grammar rules in the set. A subset of the set of grammar rules at fault for the parsing failure is identified. Groups of new grammar rules are developed such that each group comprises at least one new grammar rule, such that each group can parse the unparsed statement, and such that each new grammar rule is a modification of grammar rule(s) in the subset. One specific group can then be selected for possible incorporation into the set of grammar rules. Optionally, before a specific group is selected, the groups can be heuristically pruned and/or ranked.

Method, system and program storage device for automatic incremental learning of programming language grammar

Systems and methods execute a computer program to produce a trace of the computer program and divide the trace into independent threads of execution. Each of the independent threads of execution comprises an execution sequence of the lines of programming code that ends with an identified write line of programming code that outputs an incorrect result. These systems and methods also identify key field within each of the independent threads of execution. In programming, which is processing records in a table one by one, key-fields are a subset of the fields of the table. The key fields impact the computations sequence leading up to the identified write line of the programming code. These systems and methods identify key-based dynamic slices from the independent threads of execution. Each of the key-based dynamic slices includes lines of programming code that are used in computations, processing the table records corresponding to the key fields.

System and method for dynamic code analysis in presence of the table processing idiom

Disclosed are embodiments a computer-implemented method, a system and an associated program storage device that provide for automatic programming language grammar partitioning to solve the 'code too large' problem. The embodiments partition a particular programming language grammar into logical subsets based on a set of partitioning heuristics and using a dependency graph that is preprocessed so as to be devoid of any cyclically connected grammar rule nodes. For each logical subset, textual code for a corresponding portion of a parsing program can be generated and then converted into machine-readable code for that corresponding portion of the parsing program. Thus, small amounts of textual code for portions of a parsing program are discretely converted into machine-readable code, thereby avoiding the 'code too large' problem. The machine-readable code for all portions of the parsing program can then be merged and the parsing program can be executed in order to parse a corpus.

Growing community of inventors

Bengaluru, India

Krishna Nandivada Venkata