JP7059757B2 - API processing method, terminal, API processing program - Google Patents

Description

The present invention relates to an API processing method, a terminal, and an API processing program.

Conventionally, techniques for efficiently executing program processing have been proposed.

For example, there is a technique of outputting an asynchronous message for synchronous processing in a program, an instruction sequence for performing processing asynchronously, and an instruction sequence for waiting for a library so that they can be distributed and distributed to a plurality of CPUs.

In addition, it is a technique for converting software source code, and the intermediate form before the abstracted intermediate form is abstracted by using the inverse conversion rule stored in the step of abstracting the converted intermediate form. There is a technology to convert to. Further, in this technique, the intermediate format before abstraction is converted into the abstracted source code which is the source code by using the inverse conversion rule stored in the step of converting the source code into the intermediate format.

There is also a technique for writing rules in a rule definition language, passing these rules through a translator, sending them to the runtime engine, and using the runtime engine to schedule translated instructions and process them at the same time.

Japanese Unexamined Patent Publication No. 2001-184320 Japanese Unexamined Patent Publication No. 2013-120491 Japanese Unexamined Patent Publication No. 2007-51907

However, when the API (Application Programming Interface) function is called to execute the program processing, the program may be described inefficiently. For example, a program may be written to call API functions synchronously and execute them sequentially. If the program is written synchronously, even if there are functions that can be executed asynchronously in parallel, they will be executed synchronously and sequentially, which is not time-efficient. There was a problem.

One aspect of the present invention is to efficiently execute a program in consideration of parallelism.

One embodiment is an API processing method which is a program described in the first form and has a terminal for executing a plurality of API call processes defined in the program. Further, it is an API processing method having a plurality of server devices for operating a program described in the second format so as to execute a process corresponding to the API call process in response to the plurality of API call processes. The terminal acquires information about the program described in the second form, and identifies an API call process that can be executed in parallel among the plurality of API call processes based on the acquired information about the program. Sends information about the identified API call process to the server device.

As one aspect, it has the effect that the program can be executed efficiently in consideration of parallelism.

It is a figure which shows an example of the description of the callback of an asynchronous function. It is a figure which shows an example of the description of the asynchronous function using the pattern of Promise. It is a figure which shows an example of the description of the asynchronous function using the pattern of async / await. It is a block diagram which shows the schematic structure of the API processing system which concerns on embodiment of this invention. It is a block diagram which shows the schematic structure of the terminal of 1st Embodiment. It is a figure which shows an example of the program of the format which is the program to be converted and is written in a mixture of synchronous description and asynchronous description. It is a figure which shows an example of conversion by the preprocessing for a program. It is a figure which shows an example of conversion by the preprocessing for a program. It is a figure which shows an example of conversion by the preprocessing for a program. It is a figure which shows an example of conversion by the preprocessing for a program. It is a figure which shows an example of the program of the synchronous description obtained by the conversion of the preprocessing part. It is a figure which shows an example of a function list. It is a figure which shows an example of the conversion process for a program. It is a figure which shows an example of the conversion process for a program. It is a figure which shows an example of the conversion process for a program. It is a figure which shows an example of the conversion process for a program. It is a figure which shows an example of the conversion process for a program. It is a block diagram which shows the schematic structure of the computer which functions as the terminal of 1st Embodiment. It is a flowchart which shows an example of the conversion process of the terminal of 1st Embodiment. It is a block diagram which shows the schematic structure of the terminal of 2nd Embodiment. It is a figure which shows an example of the table created by the table making part. It is a figure which shows an example of the table updated by the table update part. It is a figure which shows an example of a verb table. It is a figure which shows an example of the table updated by the table update part. It is a figure which shows an example of the table updated by the table update part. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a block diagram which shows the schematic structure of the computer which functions as the terminal of 2nd Embodiment. It is a flowchart which shows an example of the conversion process of the terminal of 2nd Embodiment. It is a block diagram which shows the schematic structure of the terminal of 3rd Embodiment. It is a figure which shows an example of the program of the synchronous description obtained by the conversion of the preprocessing part. It is a figure which shows an example of a function list. It is a figure which shows an example of the table created by the table making part. It is a figure which shows an example of the function HTTP request correspondence table. It is a figure which shows an example of the table updated by the table update part. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a block diagram which shows the schematic structure of the computer which functions as the terminal of 3rd Embodiment. It is a flowchart which shows an example of the conversion process of the terminal of 3rd Embodiment. It is a block diagram which shows the schematic structure of the terminal of 4th Embodiment. It is a figure which shows an example of the program of the synchronous description obtained by the conversion of the preprocessing part. It is a figure which shows an example of a function list. It is a figure which shows an example of the table created by the table making part. It is a figure which shows an example of the process of a management table creation part. It is a figure which shows an example of the non-parallel pair management table. It is a figure which shows an example of the table updated by the table update part. It is a figure which shows an example of the reflection in the program of the execution order based on parallelism. It is a block diagram which shows the schematic structure of the computer which functions as the terminal of 4th Embodiment. It is a flowchart which shows an example of the conversion process of the terminal of 4th Embodiment. It is a figure which shows an example of application destination of 2nd to 4th Embodiment.

Hereinafter, an example of the embodiment according to the present invention will be described in detail with reference to the drawings.

First, the background that is the premise of the embodiment of the present invention will be described.

API (Application Programming Interface) is an interface for programmatically accessing useful blackboxed resources (data, functions, etc.). The API referred to here will be described as including the API provided by the library in the local environment and the Web API for accessing over the network.

API is realized by calling an instance method of a function or an object from a program.

There are two types of function call methods in the client library that wrap the API, synchronous and asynchronous, but the basics need to be described asynchronously. Synchronous is a method of executing processes sequentially (API call processing is not executed in parallel), and asynchronous is a method of executing processes in parallel according to the execution status (API call processing is executed in parallel). An executable method). For example, in a Node.js (JavaScript (registered trademark)) program, a callback function (called Error-first Callback) is specified as the last argument of the asynchronous function. For example, specify the callback function as in the following program.

// Open the file
fs.open ('file.txt','r', (err, data) =>{…});

There are also functions that support both synchronous and asynchronous descriptions, but they are only a part. For example, as in the program below, the description of Sync corresponds to the synchronous description.

data = fs.openSync (‘file.txt’, ‘r’); // Synchronized version of fs.open

As mentioned above, the asynchronous function describes the callback, but the so-called callback hell, in which the nesting of callbacks continues, is known. Since the callbacks are nested as shown in FIG. 1, there is a problem that the code management becomes complicated. In FIG. 1, (err, b), (err, c), and (err, d) are nested.

The following two patterns (description methods) are examples of conventional methods for alleviating such callback hell.

The conventional method (1) uses the Promise pattern. In Promise, asynchronous calls can be represented by a string of functions as shown in the underlined code in Figure 2, which can flatten nesting and mitigate callback hell, and understand and maintain asynchronous call programs. Becomes easier. Promise is a pattern that can be used in the ECMAScript standard ES6 specifications. In the following drawings that describe the code of the program, the part of the code of interest shall be underlined.

The conventional method (2) uses the async / await pattern. In async / await, as shown in the underlined part of FIG. 3, a call of an asynchronous function that returns a promise can be described as if it were a call of a synchronous function. This facilitates the understanding and maintenance of asynchronous calling programs. Note that async / await is a pattern that can be used in the ECMAScript standard ES2017 specifications.

Further, although Patent Document 1 is a technique for rewriting sequential processing into distributed processing by sending and receiving asynchronous messages, the purpose is to improve efficiency when a plurality of CPUs are used, and it is easy to describe asynchronous processing by calling API. It wasn't a technique for.

Conventionally, the above-mentioned asynchronously written program has been developed by using tools such as an integrated development environment, a library, and an API client. The integrated development environment is called an IDE (Integrated Development Environment) and includes a language processing system (compiler, script engine, etc.). The library is for storing functions with a notation that makes asynchronous processing easier to write. The API client is equipped with a callback interface.

However, since the description of asynchronous processing is not intuitive, there is a problem that the description, readability, and maintainability are low. In addition, there is a problem that it takes time for a developer to learn how to write code for asynchronous processing and how to use an asynchronous processing library including functions corresponding to asynchronous processing.

Therefore, in the embodiment of the present invention, a case where a program having a synchronous description is converted into an asynchronous description to provide a method capable of performing asynchronous processing will be described as an example. As a result, the developer can realize asynchronous processing by using the tools that have been used conventionally as they are and writing a sequential processing program by simple programming.

In addition, it is assumed that this method is applied to convert the program before executing the program. For functions that can be executed in parallel at the time of conversion, it is possible to execute a program more time-efficiently by converting in consideration of parallelism.

Hereinafter, each embodiment based on the above background will be described. In the following description of each embodiment, the description is based on the environment of JavaScript (registered trademark) of Node.js, but the description is not limited to this, and the same method is described synchronously and asynchronously. It can also be applied to the environment of other programs that have been created.

[First Embodiment]
In this embodiment, a case where a program described synchronously is converted into a program described asynchronously, automatically generated, and executed will be described as an example. Converting to a program written asynchronously is a prerequisite method for converting to a program considering parallelism. Asynchronous processing library is used for conversion of asynchronous processing program. The program described synchronously is an example of the program described in the first format. A program written asynchronously is an example of a program written in the second format.

The outline of the conversion will be described below. In the conversion, the program written synchronously is input. Alternatively, input a program in which synchronous description and asynchronous description are mixed.

When inputting a program with a mixture of synchronous and asynchronous descriptions, the input program is parsed (syntactic analysis) to generate an abstract syntax tree (AST), and then Rewrite the description in a synchronous manner as shown.

In the function definition block, search for the call statement of the function that includes the callback function definition as an argument with depth-first priority. Also, change the name of the second argument of the callback function definition to a unique one. Changes include prefixes (_) and serial numbers. Also, delete the callback function definition from the argument of the function call statement. Also, when the second callback argument is operated in the callback function, the function call statement is converted into a variable declaration statement whose initial value is the return value of the function call. Convert to a variable declaration statement as follows, for example.

foo (a, b, (err, data) => {…}) → let _data0 = foo (a, b)

Also, immediately after the variable declaration statement, insert a piece of code that is normally executed in the callback function. As described above, the program in which the synchronous description and the asynchronous description are mixed is rewritten into the program with the synchronous description.

Then, the program of the synchronous description is rewritten into the asynchronous description by the following method.

First, the function name is referenced from the source code of the API client library, and the library function call statement is specified. Also, the function list published by the library is extracted from the source code of the API client library. Also, if the function name of the specified function call statement is included in the extracted function list and the object variable is derived from the library module itself of the function or the module, that statement is included in the function call statement list. Add to. In addition, an asynchronous processing program using an asynchronous processing library is generated and output using a predetermined conversion rule.

As shown in FIG. 4, the API processing system 100 according to the present embodiment includes a terminal 10 and a plurality of server devices 12, and the terminal 10 and the plurality of server devices 12 are connected to each other via a network 3 such as the Internet. Is connected.

The terminal 10 is an information processing device that converts a program and executes the converted program.

The server device 12 is a device that provides an API that is called by a program. The server device 12 appropriately executes necessary processing (program corresponding to the called function) corresponding to the called function according to the function call of the API of the program executed by the terminal 10, and outputs the processing result to the terminal. Return to 10. The API provided by the server device 12 is, for example, AWS (Amazon Web Services) S3 or another company's API. The terminal 10 side introduces an API client for calling the API provided by the server device 12, and implements a program for calling the API. Further, since the configuration of the server device 12 varies depending on the mode in which the API is provided, the description of the specific configuration will be omitted.

As shown in FIG. 5, the terminal 10 functionally communicates with the API client library 14, the conversion rule 16, the preprocessing unit 22, the function specifying unit 24, the conversion unit 26, and the execution unit 28. Including part 30.

The API client library 14 is a library that stores a list of API function names. The library contains the source code.

The conversion rule 16 is a rule for converting a program described synchronously into an asynchronous description. The details of the rules will be described later.

When the program to be converted is in a format in which a synchronous description and an asynchronous description are mixed, the preprocessing unit 22 converts the program into a synchronous description as preprocessing. Preprocessing is required because the conversion rule 16 used in the conversion unit 26 is premised on conversion from the synchronous description. If the program is written only in a synchronous description, the processing of the preprocessing unit 22 can be omitted.

Hereinafter, specific rewriting contents of the preprocessing unit 22 will be described.

FIG. 6 shows an example of the program to be converted. The processing outline of the program of FIG. 6 is that the contents of orgData are written and saved in file.txt, and the contents of file.txt are uploaded to the AWS S3 bucket using ‘file.txt’ as a key. Note that each callback second argument data is valid only in each function block. Here, the synchronization functions are fs.writeFileSync and fs.readFileSync. Asynchronous functions are s3.createBucket and s3.putObject.

Next, as shown in FIG. 7, the contents of the function definition block are surrounded by try-catch. Only the console output of the caught err is described in the catch block.

Next, as shown in FIG. 8, the synchronization function is converted into a synchronous description. For example, in the case of Node.js, Object.keys (fs) gets a list of function names provided by the module from API client library 14. Next, the synchronous and asynchronous correspondence of each function is specified from the function name list. In the case of JavaScript (registered trademark), the presence or absence of Sync at the end can be regarded as a synchronous or asynchronous correspondence. Next, the code in which the function included in the function name list is called is searched for the module itself of the API client library 14 or the object variable derived from the module. For example, modules and object variables derived from modules are fs, AWS, and s3. The code to be searched is fs.writeFileSync, s3.createBucket, fs.readFileSync, s3.putObject, s3.getObject. Of these, the name of the synchronous function should be the same as that of the asynchronous function. In the case of JavaScript (registered trademark), it becomes the same as that of the asynchronous function by deleting Sync. Making it the same as that of the asynchronous function here is the conversion to a synchronous description.

Next, as shown in FIG. 9, the asynchronous function is converted into a synchronous description. Here, the following is executed for the call statement of the asynchronous function that has the callback function as an argument. First, extract the callback function definition. In addition, the name mangling of the second argument of the callback is performed. Name mangling is to add a prefix and a serial number with the same name at the end. Let the second argument data be _data0. Next, it is converted into a variable declaration of the second argument of the callback. For example, s3.getObject ({…}) is converted to (1) let _data0 = s3.getObject ({…}) as the variable declaration of the second argument of (err, data). Next, from the code shown in FIG. 10, a code piece executed with err! = Null (normal time) is extracted. In the example of FIG. 10, (2) foo (_data0) and console.log ('done') are extracted. Place the code of (2) immediately after the code of (1).

By the above processing of the preprocessing unit 22, the program is converted into a program described synchronously as shown in FIG.

Next, the processing of the function specifying unit 24 will be described.

The function specifying unit 24 identifies the function call statement from the program converted by the preprocessing unit 22 with reference to the API client library 14, and creates a function list listing the names of the functions calling the API in the program. do.

For example, in the case of Node.js, the function specifying unit 24 acquires a list of function names provided by the module from the API client library 14 with Object.keys (fs). Next, the module itself of the API client library 14 or the object variable derived from the module, which is included in the converted program, is acquired. For the acquired module itself or the object variable derived from the module, specify the list of functions for which the function included in the function name list is called. For example, the modules included in the converted program and the object variables derived from the modules are fs, AWS, and s3. The list of functions specified for these is fs.writeFile, s3.createBucket, fs.readFile, s3.putObject, s3.getObject. FIG. 12 shows the function list 24A specified by the above processing of the function specifying unit 24. In the function list 24A, the set of the variable name and the function name of the object is stored as a list.

The conversion unit 26 converts the program converted into the synchronous description by the preprocessing unit 22 into the program described asynchronously based on the function list 24A specified by the function specifying unit 24 and the conversion rule 16. ..

Hereinafter, the processing of the conversion unit 26 based on the conversion rule 16 will be described. See function list 24A for function call statements.

First, as shown in FIG. 13, the contents of the try block are extracted.

Next, as shown in FIG. 14, the first library function call statement in the extracted block is replaced with the one enclosed by await new Promise. Also, add a callback function to the argument of the function call statement. The content of the function is a fixed phrase in which the second argument is the argument of resolve, and if the first argument is specified, it is the argument of reject. Further, FIG. 15 shows an example in the case of another code. The above replacement and addition are repeated for each function call statement in the block, and all functions are processed.

Next, async is added to the function definition as shown in FIG.

The above is the conversion process of the conversion unit 26 based on the conversion rule 16. Finally, FIG. 17 shows an example of a program converted into an asynchronous description.

The execution unit 28 executes the program of the asynchronous description converted by the conversion unit 26. The execution unit 28 asynchronously calls and processes the API function of the server device 12 in response to the function call statement of the program written asynchronously.

The communication unit 30 calls the API of the server device 12 via the network 3 by calling the API function in the processing of the program executed by the execution unit 28. The communication unit 30 acquires the API processing result from the server device 12 and delivers it to the execution unit 28. In the method of the present embodiment described above, the program is not converted in consideration of the parallelism of the functions. However, since the program is described in asynchronous description, not everything is executed sequentially as in the case of synchronous description, and the program is executed in parallel order for functions using callbacks. Will be done. A case where the processing is executed more efficiently in consideration of the parallelism of the functions will be described in each of the second and subsequent embodiments.

The terminal 10 can be realized by, for example, the computer 50 shown in FIG. The computer 50 includes a Central Processing Unit (CPU) 51, a memory 52 as a temporary storage area, and a non-volatile storage unit 53. Further, the computer 50 includes an interface (I / F) 54, a Read / Write (R / W) unit 55 that controls reading and writing of data to the storage medium 59, and a communication interface (communication interface) connected to a network such as the Internet. I / F) 56 is provided. The CPU 51, the memory 52, the storage unit 53, the input / output I / F 54, the R / W unit 55, and the communication I / F 56 are connected to each other via the bus 57. The communication I / F 56 functions as the communication unit 30 shown in FIG.

The storage unit 53 can be realized by a Hard Disk Drive (HDD), a Solid State Drive (SSD), a flash memory, or the like. The storage unit 53 as a storage medium stores an API processing program 60 for making the computer 50 function as a terminal 10. The API processing program 60 includes a preprocessing process 62, a function specifying process 63, a conversion process 64, and an execution process 65.

The CPU 51 reads the API processing program 60 from the storage unit 53, expands the API processing program 60 into the memory 52, and sequentially executes the processes included in the API processing program 60. The CPU 51 operates as the pre-processing unit 22 shown in FIG. 5 by executing the pre-processing process 62. Further, the CPU 51 operates as the function specifying unit 24 shown in FIG. 5 by executing the function specifying process 63. Further, the CPU 51 operates as the conversion unit 26 shown in FIG. 5 by executing the conversion process 64. Further, the CPU 51 operates as the execution unit 28 shown in FIG. 5 by executing the execution process 65. As a result, the computer 50 that has executed the API processing program 60 functions as the terminal 10. The CPU 51 that executes the program is hardware.

The function realized by the API processing program 60 can also be realized by, for example, a semiconductor integrated circuit, more specifically, an Application Specific Integrated Circuit (ASIC) or the like.

Next, the operation of the API processing system 100 according to the present embodiment will be described with reference to the flowchart of FIG.

In step S100, the preprocessing unit 22 rewrites and converts a program in a format in which the program is written in which a synchronous description and an asynchronous description are mixed into a synchronous description.

In step S102, the function specifying unit 24 identifies the function call statement from the program converted by the preprocessing unit 22 with reference to the API client library 14, and lists the function names calling the API in the program. Create a function list.

In step S104, the conversion unit 26 converts the program converted into the synchronous description in step S100 into the program written asynchronously based on the function list 24A specified in step S102 and the conversion rule 16. ..

In step S106, the execution unit 28 executes the program of the asynchronous description converted in step S104. The execution unit 28 asynchronously calls and processes the API function of the server device 12 in response to the function call statement of the program written asynchronously.

As described above, according to the API processing system according to the present embodiment, the program converted into the synchronous description is converted into the program described asynchronously based on the specified function list and the conversion rule. do. It also executes the converted asynchronous description program. Therefore, it is possible to facilitate the creation and execution of asynchronous program processing.

In addition, the program developer can create a program using an asynchronous processing library by simply creating a conventional synchronous function, a program using an asynchronous function, or a program using a synchronous description, and how to use the library and know-how. It is possible to write without learning. In addition, the man-hours for developing a program capable of asynchronous processing are reduced, and the descriptiveness, readability, and maintainability of the program are improved.

[Second Embodiment]
Next, the second embodiment will be described. In the second embodiment, a case where a program reflecting the execution order based on parallelism is generated based on the verbs and nouns included in the function name will be described. The parts that are the same as those in the first embodiment are designated by the same reference numerals and the description thereof will be omitted.

First, the background of this embodiment will be described.

The first embodiment is a method of converting into a program described asynchronously, but as it is, it is unknown which combination of API functions is a combination of functions that can be executed in parallel. Since some APIs have side effects on blackboxed resources, there are restrictions on the combinations of APIs that can be parallelized. The side effect is, for example, a problem of the order in which the resource A cannot be operated until the resource A is created. However, the combination is not easily known from the signatures of the functions in the API library.

Therefore, in the present embodiment, a case where the presence or absence of parallelism is determined from the verbs and nouns included in the function name and the execution order based on the parallelism is reflected in the program will be described as an example. As a premise, the execution order of each statement of the program (variable declaration, value update, deletion, etc.) is calculated and summarized in the management table. It is assumed that the execution order of statements that change the state of variables does not change. Statements containing a variable reference can be executed in parallel in intervals where the variable's state does not change. Using a list that identifies the statements containing the function calls corresponding to the API, it is determined by the parallelism determination method whether or not they can be executed in parallel. Then, the execution order considering parallelism is reflected in the conversion of the asynchronous description into the program.

Next, an outline of the verbs and nouns included in the function name will be described. The basic idea is that a function that contains a specific verb that has a side effect does not always give the same result when calling those functions and another function in parallel, so parallel processing is not possible. .. Also, create a verb table that records the verbs that frequently appear in function names (create, get, put, delete, etc.) and whether they have the meaning of causing side effects (i.e., whether they change the state). back. For example, a verb table such as [(verb, side effect?), (Create, true), (get, false), ...]. Using a verb table, consider the case where the function name of a certain API call statement A contains a verb that causes a side effect. Each statement B containing a function call that contains the same noun as the noun contained in A's function name, or that specifies the same variable as an argument and has a later appearance order in the program, should be executed after A. judge.

As shown in FIG. 20, the terminal 210 of the API processing system 200 functionally executes the API client library 14, the conversion rule 16, the preprocessing unit 22, the function specifying unit 24, and the conversion unit 226. A unit 228 and a communication unit 30 are included. The terminal 210 includes a verb table storage unit 214, a table creation unit 222, and a table update unit 224. The conversion unit 226 is an example of a specific unit. The execution unit 228 is an example of the execution unit.

A program of synchronous description obtained by the conversion in the preprocessing unit 22 is input to the table creation unit 222. In this embodiment, the case where the same program as in FIG. 11 is input will be described as an example.

The table creation unit 222 creates an execution order management table from a program having a synchronous description. First, the table creation unit 222 creates a table 222A from which the statements (code including the function) in the try block are extracted as shown in FIG. 21. Table 222A includes items of "item number", "statement", and "corresponding to API?". For "item number", a descending number is assigned to each "statement". In the item "Supports API?", Set true or false as a Boolean value based on whether each statement contains an object variable name included in the function call statement list or a function name.

The table update unit 224 updates the table 222A created by the table creation unit 222 by adding columns for the items of "variable operation" and "parallelism". First, the table update unit 224 adds each individual variable operation as an item of "variable operation", inserts "x" in the statement for changing the state of the variable, and inserts "↓" in the statement to be referenced. FIG. 22 shows an example of Table 224A to which the item of “variable operation” is added. In FIG. 22, columns "data" and "cb_data0" are added as variable operations, and the state of the corresponding statement is updated. In the process of the table update unit 224, the items "statement" and "API corresponding?" Are not updated, so the description on the drawing is omitted.

Next, the table update unit 224 refers to the verb table 214A of the verb table storage unit 214, and adds a column as an item of "parallelism" for each function including a verb having a side effect. Further, the table update unit 224 inserts "x" in the statement calling the function and "↓" in the statement calling the function containing the same noun as the function or using the same variable as an argument. .. FIG. 23 shows an example of the verb table 214A. The verb table 214A is a table summarizing the presence or absence of side effects on the verb. FIG. 24 shows an example of Table 224B to which the item of “parallelism” is added. In FIG. 24, columns of "writeFile", "createBucket", and "putObject" are added as functions of the item of "parallelism", and the state of the corresponding statement is updated. The verb table 214A is an example of rules regarding verbs and nouns.

Next, the table update unit 224 removes the redundant order of the updated table. As shown in FIG. 25, item number 5 in Table 224B should be executed after item number 2 together with item number 4 with respect to "create Bucket". At the same time, regarding "putObject", it should be executed after item number 4. Therefore, the order can be specified as shown by the arrow in FIG. 25, and the underlined “↓” in item No. 5 is redundant and is removed.

By the above update process of the table update unit 224, the execution order based on the parallelism is specified.

The conversion unit 226 converts the program of the synchronous description into the program of the asynchronous description by the same processing as the conversion unit 26 of the first embodiment described above. The conversion unit 226 generates a program that reflects the execution order based on parallelism from the converted asynchronous description program by using the table 224B updated by the table update unit 224. Although the case of reflecting the execution order for the converted program will be described as an example, the conversion and the reflection of the execution order may be processed at the same time. Further, generating a program that reflects the execution order based on parallelism is an example of specifying an API call process that can be executed in parallel among a plurality of API call processes.

The following processes (1) to (4) will be described with respect to the specific reflection process of the conversion unit 226.

In the process (1), first, the statements with only "x" in Table 224B are extracted. For each extracted statement, enclose it in a promise if the statement corresponds to an API call. FIG. 26 shows an example of a statement processed so as to be surrounded by a promise in the process (1).

Next, in process (2), if there are multiple statements enclosed in Promises in process (1), store each in an array with a unique name as shown in FIG. 27, and finally await Promise.all (). Convert to a description that is enclosed in. In FIG. 28, the portion to be reflected in the process (2) in Table 224B is underlined.

Next, in process (3), the above processes (1) and (2) are executed for the statement with only one "↓", and "x" is displayed in the column with "↓" in Table 224B. Connect to the following of the statement with. If you want to connect to one statement that is Promise.all, replace the statement with one that awaits as shown in Fig. 29, and convert these to a function with async arranged in series. At this time, if the last statement is a variable definition statement or an assignment statement, the last statement is replaced with a return statement and the variable reference of the subsequent statement is replaced with the return value of await Promise.all as in process (2). In FIG. 30, the portion to be reflected in the process (3) in Table 224B is underlined.

Next, in process (4), the statement with two or more "↓" in Table 224B is placed immediately after the statement with "x" in the line with "↓" is await Promise.all. .. Furthermore, if a variable defined and assigned in the last statement of Promise.all is referenced, that variable reference is replaced with the return value _values of await Promise.all, and the above processes (1) and (2) ). For example, as shown in FIG. 31, when referring to the return value (data in this case) of the first pushed Promise, the variable reference is replaced with _values [0]. In FIG. 32, the portion to be reflected in the process (4) in Table 224B is underlined. In addition, do not process anything for statements without "x" and "↓".

By the reflection process of the conversion unit 226 as described above, a program reflecting the execution order based on parallelism is generated. FIG. 33 shows an example of a program that reflects the execution order based on parallelism.

The execution unit 228 executes a program that reflects the execution order based on the parallelism generated by the conversion unit 226. The execution unit 228 calls and processes the API functions of the server device 12 in parallel for the functions that can be executed in parallel according to the execution order of the program. It should be noted that calling and processing the API function of the server device 12 in parallel for the function that can be executed in parallel is an example of transmitting the information regarding the specified API call process to the server device.

The terminal 210 can be realized by, for example, the computer 250 shown in FIG. 34. The computer 250 includes a CPU 51, a memory 52 as a temporary storage area, and a non-volatile storage unit 253. Further, the computer 250 includes an input / output I / F 54, an R / W unit 55 that controls reading and writing of data to the storage medium 59, and a communication I / F 56 connected to a network such as the Internet. The CPU 51, the memory 52, the storage unit 253, the input / output I / F 54, the R / W unit 55, and the communication I / F 56 are connected to each other via the bus 57.

The storage unit 253 can be realized by an HDD, SSD, flash memory, or the like. The storage unit 253 as a storage medium stores an API processing program 260 for making the computer 250 function as a terminal 210. The API processing program 260 has a preprocessing process 62, a function specifying process 63, a table creation process 262, a table update process 263, a conversion process 264, and an execution process 265.

The CPU 51 reads the API processing program 260 from the storage unit 253, expands it into the memory 52, and sequentially executes the processes included in the API processing program 260. The CPU 51 operates as the pre-processing unit 22 shown in FIG. 20 by executing the pre-processing process 62. Further, the CPU 51 operates as the function specifying unit 24 shown in FIG. 20 by executing the function specifying process 63. Further, the CPU 51 operates as the table creation unit 222 shown in FIG. 20 by executing the table creation process 262. The CPU 51 operates as the table update unit 224 shown in FIG. 20 by executing the table update process 263. Further, the CPU 51 operates as the conversion unit 226 shown in FIG. 20 by executing the conversion process 264. Further, the CPU 51 operates as the execution unit 228 shown in FIG. 20 by executing the execution process 265. As a result, the computer 250 that has executed the API processing program 260 will function as the terminal 210. The CPU 51 that executes the program is hardware.

The function realized by the API processing program 260 can also be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC or the like.

Next, the operation of the API processing system 200 according to the present embodiment will be described with reference to the flowchart of FIG.

In step S200, the table creation unit 222 creates an execution order management table (Table 222A) from the program of the synchronous description obtained by the conversion in step S100.

In step S202, the table update unit 224 refers to the verb table 214A, adds columns for the items of "variable operation" and "parallelism" to the table 222A created by the table creation unit 222, and updates the table 224B. do.

In step S204, the conversion unit 226 generates a program reflecting the execution order based on parallelism from the program of the asynchronous description converted in step S104 by using Table 224B updated in step S202.

In step S206, the execution unit 228 executes a program that reflects the execution order based on the parallelism generated in step S204. The execution unit 228 calls and processes the API functions of the server device 12 in parallel for the functions that can be executed in parallel according to the execution order of the program.

Since the other configurations and operations of the second embodiment are the same as those of the first embodiment, the description thereof will be omitted.

As described above, according to the API processing system according to the present embodiment, the program converted into the synchronous description is converted into the program described asynchronously based on the specified function list and the conversion rule. do. Also, from the converted asynchronous description program, the verb table is referenced and a program that reflects the execution order based on parallelism is generated. Execute the program that reflects the execution order. Therefore, it is possible to facilitate the creation and execution of asynchronous program processing, and to efficiently execute the program in consideration of parallelism.

[Third Embodiment]
Next, the third embodiment will be described. In the third embodiment, a case where a program reflecting the execution order based on parallelism is generated from the HTTP request method and the path will be described. The parts that are the same as those in the second embodiment are designated by the same reference numerals and the description thereof will be omitted.

In this embodiment, a case where the presence / absence of parallelism is determined from the method and path of the HTTP request actually issued in the API client library and the execution order based on the parallelism is reflected in the program will be described as an example.

The basic idea is that among the HTTP methods, POST, PUT, DELETE, and PATCH are methods with side effects. If there are side effects, parallel processing is not possible because the same result is not always obtained when calling other APIs in parallel. Also, use the source code of the API library on which the program depends. The program of each function of the API library is statically analyzed, and the code piece that sends the HTTP request is searched for using the HTTP client. Specify the HTTP request method (GET, POST, PUT, DELETE, PATCH, etc.) and path ("/ path / to / resource", etc.) issued by each function from the found code piece, and record it in the function HTTP request correspondence table. And manage. For example, it is a correspondence table such as [(function name, method, path), (getContents, GET, / contents)]. In addition, when the method is POST, PUT, DELETE, PATCH for the statement A that makes a certain API call using the function HTTP request correspondence table, an HTTP request is issued for the path that prefixes with the path of A and is being programmed. For each statement B whose appearance order is after, B determines that it cannot be executed in parallel with A.

As shown in FIG. 36, the terminal 310 of the API processing system 300 functionally executes the API client library 14, the conversion rule 16, the preprocessing unit 22, the function specifying unit 24, and the conversion unit 226. A unit 228 and a communication unit 30 are included. Further, the terminal 310 includes a table creation unit 222, a function correspondence table creation unit 322, and a table update unit 324.

A program of synchronous description obtained by the conversion in the preprocessing unit 22 is input to the table creation unit 222. In this embodiment, the case where the program of the synchronous description shown in FIG. 37 is input will be described as an example. Further, FIG. 38 shows an example of the function list 24B specified by the function specifying unit 24 from the program of FIG. 37.

FIG. 39 shows an example of Table 222B created by the table creation unit 222 from the program of FIG. 37.

The function correspondence table creation unit 322 creates the function HTTP request correspondence table 322A from the program of the synchronous description based on the contents of the API client library 14. The function HTTP request correspondence table 322A is an example of a rule regarding a request.

The function correspondence table creation unit 322 first parses the source code of the API client library 14 and generates an abstract syntax tree (AST). Next, for the input program, search for the statement that declares the target function. Search for the statement in the function declaration where the request is being sent using the HTTP client. The method and path are specified by the method corresponding to the type of HTTP client used, and added to the function HTTP request correspondence table 322A. For example, in the example using the request library of Node.js, the method is "GET" and the path is "http: // myapi" for the statement of request.get ('https://myapi.com/api/users'). Specify as ".com/api/users". FIG. 40 shows an example of the function HTTP request correspondence table 322A. By referring to the function HTTP request correspondence table 322A, it can be seen that the method of createUser is "POST" and putData is prefix-matched to the path of createUser. From this, it can be determined that putData cannot be executed in parallel with createUser.

The table update unit 324 refers to the function HTTP request correspondence table 322A created by the function correspondence table creation unit 322 with respect to the table 222B created by the table creation unit 222, and has items of "variable operation" and "parallelism". Add columns and update. The additional processing of the item of "variable operation" is the same as the table update unit 224 of the second embodiment. For the "Parallel" item, add a column for each prefix-matching path. FIG. 41 shows an example of Table 324A to which the item of “parallelism” is added. In FIG. 41, "/ users" and "/ contents", which are the paths after the fixed part of the path (https://myapi.com/api/) is prefix-matched, are added as "parallelism" items to support them. The state of the statement to be updated. In updating the status, "x" is inserted in the statement to be executed first, and "↓" is inserted in the statement to be executed later.

FIG. 42 shows an example of a program that reflects the execution order based on the parallelism generated by the conversion unit 226 using Table 324A of FIG. 41. The processing of the conversion unit 226 may be carried out by replacing Table 224B of the second embodiment with Table 324A.

The terminal 310 can be realized by, for example, the computer 350 shown in FIG. 43. The computer 350 includes a CPU 51, a memory 52 as a temporary storage area, and a non-volatile storage unit 353. Further, the computer 350 includes an input / output I / F 54, an R / W unit 55 that controls reading and writing of data to the storage medium 59, and a communication I / F 56 connected to a network such as the Internet. The CPU 51, the memory 52, the storage unit 353, the input / output I / F 54, the R / W unit 55, and the communication I / F 56 are connected to each other via the bus 57.

The storage unit 353 can be realized by an HDD, SSD, flash memory, or the like. The storage unit 353 as a storage medium stores an API processing program 360 for making the computer 350 function as a terminal 310. The API processing program 360 includes a preprocessing process 62, a function specifying process 63, a table creation process 262, a table update process 363, a function correspondence table creation process 362, a conversion process 264, and an execution process 265.

The CPU 51 reads the API processing program 360 from the storage unit 353, expands it into the memory 52, and sequentially executes the processes included in the API processing program 360. The CPU 51 operates as the pre-processing unit 22 shown in FIG. 36 by executing the pre-processing process 62. Further, the CPU 51 operates as the function specifying unit 24 shown in FIG. 36 by executing the function specifying process 63. Further, the CPU 51 operates as the table creation unit 222 shown in FIG. 36 by executing the table creation process 262. Further, the CPU 51 operates as the function correspondence table creation unit 322 shown in FIG. 36 by executing the function correspondence table creation process 362. The CPU 51 operates as the table update unit 324 shown in FIG. 36 by executing the table update process 363. Further, the CPU 51 operates as the conversion unit 226 shown in FIG. 36 by executing the conversion process 264. Further, the CPU 51 operates as the execution unit 228 shown in FIG. 36 by executing the execution process 265. As a result, the computer 350 that has executed the API processing program 360 will function as the terminal 310. The CPU 51 that executes the program is hardware.

The function realized by the API processing program 360 can also be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC or the like.

Next, the operation of the API processing system 300 according to the present embodiment will be described with reference to the flowchart of FIG.

In step S300, the function correspondence table creation unit 322 creates the function HTTP request correspondence table 322A from the program described synchronously based on the contents of the API client library 14.

In step S302, the table update unit 324 refers to the function HTTP request correspondence table 322A created by the function correspondence table creation unit 322 with respect to the table 222B created by the table creation unit 222, and refers to "variable operation" and "parallelism". ”Item column is added and updated as Table 324A.

Since the other configurations and operations of the third embodiment are the same as those of the second embodiment, the description thereof will be omitted.

As described above, according to the API processing system according to the present embodiment, the program converted into the synchronous description is converted into the program described asynchronously based on the specified function list and the conversion rule. do. In addition, the function HTTP request correspondence table is referred to from the converted asynchronous description program, and a program that reflects the execution order based on parallelism is generated. Execute the program that reflects the execution order. Therefore, it is possible to facilitate the creation and execution of asynchronous program processing, and to efficiently execute the program in consideration of parallelism.

[Fourth Embodiment]
Next, the fourth embodiment will be described. In the fourth embodiment, a case where a program reflecting the execution order based on parallelism is generated from the appearance order of the function calls of the source code repository such as aws-sdk and GitHub will be described. The same parts as those in the second or third embodiment are designated by the same reference numerals and the description thereof will be omitted.

In this embodiment, a large number of programs using the same API library are analyzed in the source code repository, the presence or absence of parallelism is determined based on whether the appearance order of function calls is the same, and the execution order based on the parallelism is programmed. The case of reflecting in is described as an example.

Extract the program using API client library from the source code repository and use it. All the extracted programs are statically analyzed, and all the pairs of API call functions (function A and function B) that use the same variable as at least one argument without changing the value are extracted. However, the function A comes before the function B in the order of appearance. For a certain function A and function B, if all of the extracted pairs in which function A and function B appear are in the order of function A and function B, the order of implicit call to function A and function B is implicit. It is determined that there is, and it is recorded and managed in the non-parallel pair management table. For example, it is a management table such as [(function called first, function called later), (function A, function B)]. For statement α and statement β that make a certain API call, if the functions being called are function A and function B, and if the non-parallelizable pair management table contains (function A, function B), then α and β determines that parallel processing is not possible.

As shown in FIG. 45, the terminal 410 of the API processing system 400 functionally executes the API client library 14, the conversion rule 16, the preprocessing unit 22, the function specifying unit 24, and the conversion unit 226. A unit 228 and a communication unit 30 are included. Further, the terminal 410 includes a table creation unit 222, a management table creation unit 422, and a table update unit 424. Further, the terminal 410 is connected to an external source code repository 414 such as aws-sdk or GitHub via the network 3.

A program of synchronous description obtained by the conversion in the preprocessing unit 22 is input to the table creation unit 222. In the present embodiment, the case where the program of the synchronous description shown in FIG. 46 is input will be described as an example. Further, FIG. 47 shows an example of the function list 24C specified by the function specifying unit 24 from the program of FIG. 46.

FIG. 48 shows an example of Table 222C created by the table creation unit 222 from the program of FIG. 46.

The management table creation unit 422 creates the non-parallel pair management table 422A by referring to the contents of the source code repository 414 from the program of the synchronous description. Note that the non-parallelable pair management table 422A is an example of the rules related to the repository.

The management table creation unit 422 first extracts from the source code repository 414 all the source code that calls createBucket and putObject with the same reference and value by static analysis, as shown in FIG. 49. createBucket and putObject have the same object variable name in Table 222C. Among the extracted source code, it is detected that there is no other source code to be called from putObject in the order of createBucket, and it is added to the non-parallel pair management table 422A. As shown in FIG. 50, in the non-parallel pair management table 422A, the source code repository name and the object variable name are given at the beginning, "aws-sdk # S3.createBucket" is added to the function to be called first, and the function to be called later is used. Add "aws-sdk # S3.putObject". It should be noted that the non-parallelable pairs other than the above will be described below as undiscovered ones.

The table update unit 424 refers to the non-parallelizable pair management table 422A created by the management table creation unit 422 with respect to the table 222C created by the table creation unit 222, and the columns of the items of "variable operation" and "parallelism". To add and update. The additional processing of the item of "variable operation" is the same as the table update unit 224 of the second embodiment. For the item of "parallelism", add a column for each function corresponding to API. FIG. 51 shows an example of Table 424A to which the item of “parallelism” is added. In FIG. 51, the function names "aws-sdk # S3.createBucket", "aws-sdk # DyanmoDB.createTable", and "aws-sdk # S3."
"PutObject" is added and the state of the corresponding statement is updated. To update the status, "x" is inserted in the statement to be executed first, and "↓" is inserted in the statement to be executed later. A function for which a non-parallelable pair has not been found inserts an "x" only in the statement making the function call.

FIG. 52 shows an example of a program that reflects the execution order based on the parallelism generated by using Table 424A of FIG.

The terminal 410 can be realized by, for example, the computer 450 shown in FIG. 53. The computer 450 includes a CPU 51, a memory 52 as a temporary storage area, and a non-volatile storage unit 453. Further, the computer 450 includes an input / output I / F 54, an R / W unit 55 that controls reading and writing of data to the storage medium 59, and a communication I / F 56 connected to a network such as the Internet. The CPU 51, the memory 52, the storage unit 453, the input / output I / F 54, the R / W unit 55, and the communication I / F 56 are connected to each other via the bus 57.

The storage unit 453 can be realized by an HDD, SSD, flash memory, or the like. The storage unit 453 as a storage medium stores an API processing program 460 for making the computer 450 function as a terminal 410. The API processing program 460 has a preprocessing process 62, a function specifying process 63, a table creation process 262, a table update process 463, a management table creation process 462, a conversion process 264, and an execution process 265.

The CPU 51 reads the API processing program 460 from the storage unit 453, expands the API processing program 460 into the memory 52, and sequentially executes the processes included in the API processing program 460. The CPU 51 operates as the pre-processing unit 22 shown in FIG. 45 by executing the pre-processing process 62. Further, the CPU 51 operates as the function specifying unit 24 shown in FIG. 45 by executing the function specifying process 63. Further, the CPU 51 operates as the table creation unit 222 shown in FIG. 45 by executing the table creation process 262. Further, the CPU 51 operates as the management table creation unit 422 shown in FIG. 45 by executing the management table creation process 462. The CPU 51 operates as the table update unit 424 shown in FIG. 45 by executing the table update process 463. Further, the CPU 51 operates as the conversion unit 226 shown in FIG. 45 by executing the conversion process 264. Further, the CPU 51 operates as the execution unit 228 shown in FIG. 45 by executing the execution process 265. As a result, the computer 450 that has executed the API processing program 460 functions as the terminal 410. The CPU 51 that executes the program is hardware.

The function realized by the API processing program 460 can also be realized by, for example, a semiconductor integrated circuit, more specifically, an ASIC or the like.

Next, the operation of the API processing system 400 according to the present embodiment will be described with reference to the flowchart of FIG.

In step S400, the management table creation unit 422 creates the non-parallel pair management table 422A by referring to the contents of the source code repository 414 from the program described synchronously.

In step S402, the table update unit 324 refers to the non-parallelizable pair management table 422A created by the management table creation unit 422 with respect to the table 222C created by the table creation unit 222, and refers to "variable operation" and "parallelism". The column of the item of is added and updated as Table 424A.

Since the other configurations and operations of the fourth embodiment are the same as those of the third embodiment, the description thereof will be omitted.

As described above, according to the API processing system according to the present embodiment, the program converted into the synchronous description is converted into the program described asynchronously based on the specified function list and the conversion rule. do. Also, from the converted asynchronous description program, refer to the non-parallelizable pair management table and generate a program that reflects the execution order based on parallelism. Execute the program that reflects the execution order. Therefore, it is possible to facilitate the creation and execution of asynchronous program processing, and to efficiently execute the program in consideration of parallelism.

As shown in FIG. 55, the methods of the second to fourth embodiments can be applied by selecting a good application destination suitable for the characteristics of the API. The scope of application is not mutually exclusive, and there are some that can be applied multiple times. Therefore, the methods of the second to fourth embodiments may be combined to generate a program that reflects the execution order based on parallelism.

The following additional notes will be further disclosed with respect to each of the above embodiments.

(Appendix 1)
A program described in the first format, which is a terminal that executes a plurality of API call processes defined in the program, and a terminal.
It has a plurality of server devices for operating a program described in the second format so as to execute a process corresponding to the API call process in response to the plurality of API call processes.
The terminal is
Obtain information about the program described in the second format,
Based on the acquired information about the program, the API call process that can be executed in parallel among the plurality of API call processes is specified.
Send information about the identified API call process to the server device,
API processing method.

(Appendix 2)
The terminal is
The first format is a synchronous description format in which the API call processing is not executed in parallel.
The second form is an asynchronous description form in which the API call processing can be executed in parallel.
The program described in the first form is based on a predetermined list of functions corresponding to the API call processing and a predetermined rule for converting a synchronous description into an asynchronous description. The API processing method according to Appendix 1 for converting to the program described in the second format.

(Appendix 3)
The terminal is
The first format is a format including a synchronous description in which the API call processing is not executed in parallel and an asynchronous description in which the API call processing can be executed in parallel.
The second form is defined as the asynchronous description form.
The asynchronous description contained in the program described in the first format is converted into the synchronous description.
A list of predetermined functions corresponding to the API call processing of the program in which the asynchronous description is converted into the synchronous description, and a predetermined description for converting the synchronous description into the asynchronous description. The API processing method according to Appendix 1, which converts the program into the program described in the second format based on the rule.

(Appendix 4)
The terminal is
When converting the program described in the first form to the program described in the second form, the rules regarding verbs and nomenclature predetermined for the functions included in the API call processing are applied. Based on this, among the plurality of API call processes included in the program described in the first format, the execution order of the processes that can be executed in parallel is specified, and the plurality of processes are executed based on the specified execution order. The API processing method according to Appendix 2 or Appendix 3, which is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the API call processes of the above.

(Appendix 5)
The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the request predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing method according to Appendix 2 or Appendix 3, which is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes.

(Appendix 6)
The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the repository predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing method according to Appendix 2 or Appendix 3, which is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes.

(Appendix 7)
A program described in the first format, which is a terminal that executes a plurality of API call processes defined in the program.
A specific unit that acquires information about a program described in the second format and specifies an API call process that can be executed in parallel among the plurality of API call processes based on the acquired information.
Information about the specified API call processing is transmitted to a plurality of server devices that operate a program described in the second format so as to execute the processing corresponding to the API call processing in response to the plurality of API call processing. The execution part to send and
Terminals including.

(Appendix 8)
The terminal is
The first format is a synchronous description format in which the API call processing is not executed in parallel.
The second form is an asynchronous description form in which the API call processing can be executed in parallel.
The execution unit is predetermined to convert the program described in the first format into a list of predetermined functions corresponding to the API call processing and a synchronous description into an asynchronous description. The terminal according to Appendix 7, which converts the program into the program described in the second format based on the above rule.

(Appendix 9)
The terminal is
The first format is a format including a synchronous description in which the API call processing is not executed in parallel and an asynchronous description in which the API call processing can be executed in parallel.
The second form is defined as the asynchronous description form.
The asynchronous description contained in the program described in the first format is converted into the synchronous description.
The execution unit converts the program obtained by converting the asynchronous description into the synchronous description into a list of predetermined functions corresponding to the API call processing, and the synchronous description into the asynchronous description. The terminal according to Appendix 7 for converting into a program described in the second form based on a predetermined rule for the above.

(Appendix 10)
The terminal is
The execution unit is a verb predetermined for a function included in the API call process when converting a program described in the first format into a program described in the second format. And, based on the rules regarding nomenclature, among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the specified execution order is set. Based on the above, the terminal according to Appendix 8 or Appendix 9 that is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the plurality of API call processes.

(Appendix 11)
The terminal is
When the execution unit converts the program described in the first format into the program described in the second format, the execution unit makes a predetermined request for the function included in the API call process. Based on the rules regarding, among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and based on the specified execution order. The terminal according to Appendix 8 or Appendix 9, which is reflected in the conversion so as to execute processes that can be executed in parallel among the plurality of API call processes.

(Appendix 12)
The terminal is
The execution unit is a repository predetermined for a function included in the API call process when converting a program described in the first format into a program described in the second format. Based on the rules regarding, among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and based on the specified execution order. The terminal according to Appendix 8 or Appendix 9, which is reflected in the conversion so as to execute processes that can be executed in parallel among the plurality of API call processes.

(Appendix 13)
A program described in the first format, which is a terminal that executes a plurality of API call processes defined in the program, and a terminal.
An API processing program that causes a computer to execute a process for a plurality of server devices that operate a program described in the second format so as to execute a process corresponding to the API call process in response to the plurality of API call processes. And
The terminal is
Obtain information about the program described in the second format,
Based on the acquired information about the program, the API call process that can be executed in parallel among the plurality of API call processes is specified.
Send information about the identified API call process to the server device,
An API processing program that causes a computer to execute processing.

(Appendix 14)
The terminal is
The first format is a synchronous description format in which the API call processing is not executed in parallel.
The second form is an asynchronous description form in which the API call processing can be executed in parallel.
The program described in the first form is based on a predetermined list of functions corresponding to the API call processing and a predetermined rule for converting a synchronous description into an asynchronous description. The API processing program according to Appendix 13, which is converted into the program described in the second format.

(Appendix 15)
The terminal is
The first format is a format including a synchronous description in which the API call processing is not executed in parallel and an asynchronous description in which the API call processing can be executed in parallel.
The second form is defined as the asynchronous description form.
The asynchronous description contained in the program described in the first format is converted into the synchronous description.
A program in which the asynchronous description is converted into the synchronous description is a list of predetermined functions corresponding to the API call processing, and a predetermined description for converting the synchronous description into the asynchronous description. The API processing program according to Appendix 13, which is converted into the program described in the second form based on the rule.

(Appendix 16)
The terminal is
When converting the program described in the first form to the program described in the second form, the rules regarding verbs and nomenclature predetermined for the functions included in the API call processing are applied. Based on the above, among the plurality of API call processes included in the program described in the first format, the execution order of the processes that can be executed in parallel is specified, and the plurality of processes are executed based on the specified execution order. The API processing program according to Appendix 2 or Appendix 3, which is reflected in the conversion so as to execute the processes that can be executed in parallel among the API call processes of the above.

(Appendix 17)
The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the request predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing program according to Appendix 2 or Appendix 3 that is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes.

(Appendix 18)
The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the repository predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing program according to Appendix 2 or Appendix 3 that is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes.

3 Network 10, 210, 310, 410 Terminal 12 Server device 16 Conversion rule 22 Preprocessing unit 24 Function specification unit 26, 226 Conversion unit 28, 228 Execution unit 30 Communication unit 50, 250, 350, 450 Computer 51 CPU
52 Memory 53, 253, 353, 453 Storage unit 60, 260, 360, 460 API processing program 214 Verb table storage unit 222 Table creation unit 224, 324, 424 Table update unit 322 Function correspondence table creation unit 414 Source code repository 422 management Table creation department

Claims (7)

A terminal that executes multiple API call processes defined in the program ,
It has a plurality of server devices that execute a program corresponding to a function called in response to the API call processing and return a processing result in response to the plurality of API call processing.
The terminal is
A program described in the first format including a synchronous description for sequentially executing API call processing is described in an asynchronous description with a list of predetermined functions corresponding to the API call processing and a synchronous description. Based on the predetermined rules for conversion, the API call processing is converted into a program described in the second format by asynchronous description that can be executed in parallel according to the execution status.
The plurality of API call processes are asynchronously executed according to the converted program described in the second format, and the corresponding functions are called and processed from the plurality of server devices.
API processing method. The terminal is
When the first form is a form including the synchronous description and the asynchronous description,
After converting the asynchronous description contained in the program described in the first form into the synchronous description,
The program described in the first format after converting the asynchronous description is converted into a list of predetermined functions corresponding to the API call processing and the synchronous description to the asynchronous description. The API processing method according to claim 1, wherein the program is converted into the program described in the second form based on a predetermined rule for the above. The terminal is
When converting the program described in the first form to the program described in the second form, the rules regarding verbs and nomenclature predetermined for the functions included in the API call processing are applied. Based on this, among the plurality of API call processes included in the program described in the first format, the execution order of the processes that can be executed in parallel is specified, and the plurality of processes are executed based on the specified execution order. The API processing method according to claim 1 or 2 , wherein the processing that can be executed in parallel is executed in parallel among the API call processing of the above. The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the request predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing method according to claim 1 or 2 , which is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes. The terminal is
When converting the program described in the first format to the program described in the second format, based on the rules regarding the repository predetermined for the function included in the API call processing. , Among the plurality of API call processes included in the program described in the first form, the execution order of the processes that can be executed in parallel is specified, and the plurality of APIs are specified based on the specified execution order. The API processing method according to claim 1 or 2 , which is reflected in the conversion so that the processes that can be executed in parallel are executed in parallel among the call processes. A terminal that executes multiple API call processes defined in the program .
A program described in the first format including a synchronous description for sequentially executing API call processing is described in an asynchronous description with a list of predetermined functions corresponding to the API call processing and a synchronous description. A conversion unit that converts API call processing into a program described in the second format by asynchronous description that can be executed in parallel according to the execution status based on predetermined rules for conversion .
The plurality of API call processes are asynchronously executed according to the converted program described in the second format, and the program corresponding to the function called corresponding to the API call process is executed and processed. An execution unit that calls and processes the corresponding function from multiple server devices that return the result ,
Terminals including. A terminal that executes multiple API call processes defined in the program ,
API processing that causes a computer to execute processing for a plurality of server devices that execute a program corresponding to the function called in response to the API calling processing and return the processing result in response to the plurality of API calling processing. It ’s a program,
The terminal is
A program described in the first format including a synchronous description for sequentially executing API call processing is described in an asynchronous description with a list of predetermined functions corresponding to the API call processing and a synchronous description. Based on the predetermined rules for conversion, the API call processing is converted into a program described in the second format by asynchronous description that can be executed in parallel according to the execution status.
The plurality of API call processes are asynchronously executed according to the converted program described in the second format, and the corresponding functions are called and processed from the plurality of server devices.
An API processing program that causes a computer to execute processing.

Images