# US 2021/0240458 A1 · Systems and methods for generating distributed software packages using nondistributed source code

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2021/0240458 A1
- Document ID: US20210240458A1
- Status: Published application
- Kind: A1
- Application number: 17/239,108
- Filed: 2021-04-23
- Published: 2021-08-05
- Earliest claimed: 2020-02-04
- Assignees: Visa International Service Association
- Applicants: Visa International Service Association
- Inventors: Craig O'Connell; Theodore Harris; Yue Li; Tatiana Korolevskaya
- Web page: https://patentgrep.com/patent/US20210240458A1

## CPC

- G06F 8/51: Source to source
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Systems and methods are provided for transcompiling non-distributed source code for a non-distributed software program into a distributed software package for implementation on a distributed computing system. A transcompiler can identify loops within non-distributed source code written in a data-driven language. The transcompiler can generate MapReduce jobs using mapper keys based on grouping indicators associated with each of the loops. The MapReduce jobs can be linked together based on input-output connections of the loops in the non-distributed source code. Then, the transcompiler can generate a distributed software package including the generated MapReduce jobs to implement the same functionality as the non-distributed source code on the distributed computing system, thereby improving the speed of execution over very large datasets. The distributed software package can be optimized using machine learning searching algorithms. The distributed software package can also be optimized based on execution usage statistics.

## Claims

### Claim at position 1

1-20. (canceled)

### Claim 21

A method comprising:
identifying a first loop within the non-distributed software program using the non-distributed source code;
determining a first grouping indicator associated with the first loop;
determining a first mapper key based on the first grouping indicator associated with the first loop;
generating a first MapReduce job based on the first mapper key and the non-distributed source code within the first loop, the first MapReduce job including a first mapper code and a first reducer code;
generating the distributed software package, the distributed software package including the first MapReduce job;
monitoring an execution of the distributed software package; and
modifying at least one of the first mapper code and the first reducer code based on the monitoring.

### Claim 22 (depends on 21)

The method of claim 21, wherein the modifying further comprises:
moving a set of code functionality from a reducer of the first MapReduce job into a mapper of the first MapReduce job based on a usage table;
regenerating the first MapReduce job; and
regenerating the distributed software package using the regenerated the first MapReduce job.

### Claim 23 (depends on 22)

The method of claim 22, further comprising:
identifying one or more rules for regenerating the distributed software package using a machine learning searching algorithm.

### Claim 24 (depends on 22)

The method of claim 22, wherein the usage table is generated based on the monitoring.

### Claim 25 (depends on 21)

The method of claim 21, further comprising:
generating a directed input-output graph including the first MapReduce job and a second MapReduce job, an output of the first MapReduce job or the second MapReduce job being connected to an input of other of the first MapReduce job or the second MapReduce job.

### Claim 26 (depends on 25)

The method of claim 25, further comprising:
identifying a first input of the first loop and a first output of the first loop;
identifying a second loop within the non-distributed software program using the non-distributed source code;
identifying a second input of the second loop and a second output of the second loop; and
generating the second MapReduce job using the non-distributed source code within the second loop.

### Claim 27 (depends on 25)

The method of claim 25, further comprising determining a second mapper key for a second loop based on the directed input-output graph, the second MapReduce job occurring before the first MapReduce job in the directed input-output graph, the second mapper key being same as the first mapper key, and wherein the second MapReduce job includes second mapper code using the second mapper key.

### Claim 28 (depends on 26)

The method of claim 26, further comprising analyzing the non-distributed source code using a second compiler or interpreter for a programming language that the non-distributed source code is written in, the second compiler creating a code generator object for the non-distributed software program,
wherein the identifying of the first loop within the non-distributed software program is based on the code generator object,
wherein the identifying of the first input, the first output, and the first grouping indicator is based on the code generator object,
wherein the identifying of the second loop is based on the code generator object, and
wherein the identifying of the second input of the second loop and the second output of the second loop is based on the code generator object.

### Claim 29 (depends on 28)

The method of claim 28, further comprising identifying a first aggregation type of the first loop, the first aggregation type being aggregative, and wherein the determining of the first mapper key is further based on the first aggregation type being aggregative.

### Claim 30 (depends on 29)

The method of claim 29, wherein the analyzing of the non-distributed source code using the second compiler determines the first aggregation type associated with the first loop using a configuration file for a function performed by the first loop, and wherein the second compiler determines the first grouping indicator.

### Claim 31

A computer, the computer comprising:
a processor; and
a non-transitory computer readable medium coupled to the processor, the computer readable medium comprising code that, when executed by the processor, cause the processor to:
identify a first loop within the non-distributed software program using the non-distributed source code;
determine a first grouping indicator associated with the first loop;
determine a first mapper key based on the first grouping indicator associated with the first loop;
generate a first MapReduce job based on the first mapper key and the non-distributed source code within the first loop, the first MapReduce job including a first mapper code and a first reducer code;
generate the distributed software package, the distributed software package including the first MapReduce job;
monitor an execution of the distributed software package; and
modify at least one of the first mapper code and the first reducer code based on the monitoring.

### Claim 32 (depends on 31)

The computer of claim 31, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
move a set of code functionality from a reducer of the first MapReduce job into a mapper of the first MapReduce job based on a usage table;
regenerate the first MapReduce job; and
regenerate the distributed software package using the regenerated the first MapReduce job.

### Claim 33 (depends on 32)

The computer of claim 32, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
identify one or more rules for regenerating the distributed software package using a machine learning searching algorithm.

### Claim 34 (depends on 32)

The computer of claim 32, wherein the usage table is generated based on the monitoring.

### Claim 35 (depends on 31)

The computer of claim 31, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
generate a directed input-output graph including the first MapReduce job and a second MapReduce job, an output of the first MapReduce job or the second MapReduce job being connected to an input of other of the first MapReduce job or the second MapReduce job.

### Claim 36 (depends on 35)

The computer of claim 35, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
identify a first input of the first loop and a first output of the first loop;
identify a second loop within the non-distributed software program using the non-distributed source code;
identify a second input of the second loop and a second output of the second loop; and
generate the second MapReduce job using the non-distributed source code within the second loop.

### Claim 37 (depends on 35)

The computer of claim 35, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
determine a second mapper key for a second loop based on the directed input-output graph, the second MapReduce job occurring before the first MapReduce job in the directed input-output graph, the second mapper key being same as the first mapper key, and wherein the second MapReduce job includes second mapper code using the second mapper key.

### Claim 38 (depends on 36)

The computer of claim 36, further comprising analyzing the non-distributed source code using a second compiler or interpreter for a programming language that the non-distributed source code is written in, the second compiler creating a code generator object for the non-distributed software program,
wherein the identifying of the first loop within the non-distributed software program is based on the code generator object,
wherein the identifying of the first input, the first output, and the first grouping indicator is based on the code generator object,
wherein the identifying of the second loop is based on the code generator object, and
wherein the identifying of the second input of the second loop and the second output of the second loop is based on the code generator object.

### Claim 39 (depends on 38)

The computer of claim 38, wherein the computer readable medium further comprises code that, when executed by the processor, cause the processor to:
identify a first aggregation type of the first loop, the first aggregation type being aggregative, and wherein the determining of the first mapper key is further based on the first aggregation type being aggregative.

### Claim 40 (depends on 39)

The computer of claim 39, wherein the analyzing of the non-distributed source code using the second compiler determines the first aggregation type associated with the first loop using a configuration file for a function performed by the first loop, and wherein the second compiler determines the first grouping indicator.
