Information processing device and information processing method

Abstract

This information processing device is provided with: a reception unit that receives a request to use a common infrastructure that is an IT infrastructure shared by a plurality of applications different from each other; and a program configuration unit that generates an executable program for the applications using at least one common infrastructure that has been initialized in advance.

Description

Information processing device and information processing method

[0001] The present invention relates to an information processing device and an information processing method.

[0002] When an application runs on a terminal device or the like, multiple functions are realized in the order specified in the execution program that constitutes the application. The multiple functions include, for example, communication with a web server and data conversion. The realization of these functions requires a combination of hardware, such as a processor including a central processing unit (CPU), and software, such as an operating system (OS) and software libraries (hereinafter referred to as "IT infrastructure").

[0003] When starting an application, it is necessary to start both the application's IT infrastructure and its executable program. Therefore, the startup time of the application depends on the scale of the IT infrastructure. To start the IT infrastructure, the hardware that makes up the IT infrastructure must be initialized and made available. Note that because starting an executable program mainly involves writing data from storage to memory, the startup time of the executable program is generally much shorter than the startup time of the IT infrastructure. Therefore, the impact of starting an executable program on the startup time of the application is minor.

[0004] Conventionally, there is a technology in which functions shared by multiple applications are implemented in advance as a framework on a server, and clients use the functions to run the applications (see, for example, Non-Patent Document 1). By using such a technology, when launching an application, the client only needs to launch the IT infrastructure of the application outside the framework (i.e., not compatible with the framework). This reduces the scale of the IT infrastructure that needs to be launched on the client side when launching the application, thereby shortening the application launch time.

[0005] "What is the .NET Framework? The .NET Framework is a software development framework for building and running applications on Windows." Microsoft website, [Retrieved May 21, 2023], Internet (URL: https: / / dotnet.microsoft.com / ja-jp / learn / dotnet / what-is-dotnet-framework)

[0006] However, because there are a wide variety of applications available these days, launching many applications requires the startup of at least some IT infrastructure on the client side, which means that even if the above-mentioned frameworks are used, the startup time of all applications used cannot be significantly reduced.

[0007] In view of the above circumstances, an object of the present invention is to provide a technique that can reduce the startup time of all applications used.

[0008] One aspect of the present invention is an information processing device that includes a reception unit that receives a request to use a common infrastructure, which is an IT infrastructure shared by multiple different applications, and a program configuration unit that generates an execution program for the application using at least one of the common infrastructures that has been pre-initialized.

[0009] Another aspect of the present invention is an information processing method using a computer, which includes a common infrastructure, which is an IT infrastructure shared by multiple different applications, and which includes a reception step of receiving a request to use the common infrastructure that has been pre-initialized, and a program configuration step of generating an execution program for the application using the common infrastructure.

[0010] The present invention makes it possible to reduce the startup time of all applications used.

[0011] 1 is a diagram for explaining matters that are prerequisites for the information processing device and information processing method of the present invention. FIG. 1 is an overall configuration diagram of an execution program development tool 1A in a first embodiment of the present invention. FIG. 2 is a diagram showing an example of source code of an application input to a processing conversion unit 11A in the first embodiment of the present invention. FIG. 3 is a diagram showing an example of a table of basic data conversion processing referenced by the processing conversion unit 11A in the first embodiment of the present invention. FIG. 4 is a diagram showing an example of a table of advanced data conversion processing referenced by the processing conversion unit 11A in the first embodiment of the present invention. FIG. 5 is a diagram showing an example of processing conversion source code generated by the processing conversion unit 11A in the first embodiment of the present invention. FIG. 6 is a diagram showing an example of a constant memory generated by the processing conversion unit 11A in the first embodiment of the present invention. FIG. 7 is a diagram showing an example of converted source code generated by an input variable division unit 12A in the first embodiment of the present invention. FIG. 8 is a diagram showing an example of a processing order list generated by a processing order list construction unit 21 in the first embodiment of the present invention. FIG. 9 is a diagram for explaining that an application developed in a specific example operates according to the source code. FIG. 10 is an overall configuration diagram of an execution program development tool 1B in a modified example of the first embodiment of the present invention. FIG. 11 is a diagram showing an example of input variable division source code generated by an input variable division unit 12B in the modified example of the first embodiment of the present invention. 1 is a diagram showing the overall configuration of an execution program development tool 1C according to a second embodiment of the present invention; FIG. 2 is a diagram showing the derivation of common processes from an abstract syntax tree by a specific process configuration unit 23C according to the second embodiment of the present invention; and FIG. 3 is a diagram showing an example of a processing order list' generated by a specific process conversion unit 24C according to the second embodiment of the present invention.

[0012] Hereinafter, an information processing apparatus and an information processing method according to an embodiment of the present invention will be described in detail with reference to the drawings.

[0013] First, the source code of the application, the processing designated by the server, the processing information, and the common infrastructure that are prerequisites for the information processing device and information processing method of the present invention will be described.

[0014] Fig. 1 is a diagram for explaining the prerequisites for the information processing device and information processing method of the present invention. Fig. 1 shows an outline of the configuration of the information processing device of the present invention. As shown in Fig. 1, the information processing device includes a source code conversion unit 10 and an execution program construction unit 20.

[0015] The source code conversion unit 10 receives input of application source code. The source code conversion unit 10 converts the application source code to generate converted source code. The source code conversion unit 10 outputs the converted source code and constant memory to the execution program configuration unit 20.

[0016] The execution program construction unit 20 receives the converted source code and constant memory output from the source code conversion unit 10. Based on the converted source code and constant memory, the execution program construction unit 20 generates an execution program that uses only the pre-initialized common infrastructure. The execution program construction unit 20 outputs an execution program that uses only the common infrastructure, a processing order list, and a constant memory.

[0017] The source code of an application describes the procedure for realizing a certain function. The source code of an application contains information written in the following order: input / output definitions, variable definitions, constant definitions, and processing. The processing here refers to the processing defined in the library specified by the server. Such processing is classified into data assignment processing, data reading processing, conditional expression processing, and data conversion processing.

[0018] Data assignment processing is processing in which a constant is assigned to a variable.

[0019] The data read process is a process of reading data from variables or memory.

[0020] Conditional processing is a process for determining conditional branching. The arguments in conditional processing are two values ​​to be compared (hereinafter referred to as "binary values") and a value indicating the process to be executed depending on the comparison result of these values. Specifically, the value indicating the process to be executed is the line number of the source code to be executed next when the magnitudes of the two values ​​being compared satisfy the conditions of greater than (>), equal to (=), or less than (<).

[0021] Data conversion processing is processing for converting data, and is classified into basic data conversion processing and advanced data conversion processing.

[0022] The basic data conversion process is a process of performing logical operations (such as AND) and addition and subtraction.

[0023] The advanced data conversion process is a collection of the above basic data conversion processes, such as matrix multiplication and polynomial operations.

[0024] The server-specified processes are processes executed by a pre-initialized common infrastructure. There are four types of server-specified processes: basic processes, common processes, read processes, and comparison processes.

[0025] The basic process is a basic data conversion process for binary data of a specified size. The argument of the basic process includes a value indicating the basic data conversion process.

[0026] The common process is a specific data conversion process that is not a basic process for data of a specified size.

[0027] The read process is a process for generating data made up of elements whose address values ​​are indicated by the elements of argument data of a specified size.

[0028] A comparison process compares the sizes of two specified data items. The arguments for the comparison process are the two values ​​to be compared and the line number of the source code to be executed next if the sizes of these two values ​​satisfy the conditions of greater than (>), equal to (=), or less than (<).

[0029] 1, when converting source code, the source code conversion unit 10 refers to "processing information" stored in advance on the server side. The processing information includes a table of basic data conversion processes and information indicating argument sizes for common processes.

[0030] The table of basic data conversion processes is a list of process names of basic data conversion processes.

[0031] The argument size of a common process is the data size of the argument that the process uses as a reference.

[0032] First Embodiment A first embodiment of the present invention will be described below.

[0033] [Configuration of Execution Program Development Tool] The configuration of the execution program development tool 1A in the first embodiment will be described below. The execution program development tool 1A is an example of the information processing device of the present invention.

[0034] 2 is a diagram showing the overall configuration of an execution program development tool 1A according to a first embodiment of the present invention. As shown in FIG. 2, the execution program development tool 1A includes a source code conversion unit 10A and an execution program construction unit 20. The source code conversion unit 10A also includes a processing conversion unit 11A and an input variable division unit 12A. The execution program construction unit 20 includes a processing order list construction unit 21 and a program construction unit 22.

[0035] The processing conversion unit 11A receives input of application source code. The processing conversion unit 11A converts the application source code to generate processing conversion source code. The processing conversion unit 11A outputs the processing conversion source code to the input variable division unit 12A and outputs constant memories to the processing order list construction unit 21 and program construction unit 22 of the execution program construction unit 20.

[0036] The processing conversion unit 11A sequentially stores data defined as constants in the source code of the input application in a constant memory, and generates processing conversion source code as a set of common processing, basic processing, and comparison processing that can be executed by the common infrastructure. To generate the processing conversion source code, the processing conversion unit 11A first replaces the assignment destination variables of data assignment processing of the common processing with assignment constants, thereby deleting the data assignment processing. The processing conversion unit 11A then converts the processing that appears in the acquired source code according to the following rules:

[0037] - Convert basic data conversion processes into repetitions of basic processes.

[0038] - An advanced data conversion process is converted into a set of basic processes and common processes by referring to a table (correspondence table) of advanced data conversion processes. The constants used in this conversion are then stored sequentially in a constant memory. Note that the correspondence table used for this conversion is assumed to be created after the common process is specified. However, instead of using such a correspondence table, the above conversion may be performed by referring to a document or input / output sample. Alternatively, the above conversion may be performed by analyzing the document or the generated input data and applied output data to make predictions.

[0039] - Convert the data read process into a read process.

[0040] -Converts conditional expression processing into comparison processing, and stores information as an argument indicating the location of the processing to be executed next (for example, the line number of the source code) depending on the comparison result.

[0041] The input variable division unit 12A receives the processing conversion source code output from the processing conversion unit 11A. The input variable division unit 12A generates converted source code based on the processing conversion source code. The input variable division unit 12A outputs the generated converted source code to the processing order list construction unit 21 of the execution program construction unit 20.

[0042] The input variable splitting unit 12A converts the input processing conversion source code by splitting the input variables so that common processing, basic processing, etc. can be applied. Specifically, the input variable splitting unit 12A duplicates the processing by the number of splits of the input variables. Then, the input variable splitting unit 12A splits the input variables so that variables other than the input variables are assigned to the split inputs.

[0043] The processing order list construction unit 21 receives input of the converted source code output from the input variable division unit 12A of the source code conversion unit 10A. The processing order list construction unit 21 also receives input of the constant memory output from the processing conversion unit 11A of the source code conversion unit 10A. The processing order list construction unit 21 generates a processing order list based on the converted source code and the variable memory. The processing order list construction unit 21 outputs the generated processing order list to the program construction unit 22.

[0044] The processing order list construction unit 21 generates a processing order list by arranging each process included in the input converted source code so that they are executed in the order in which they appear. At this time, the processing order list construction unit 21 stores, as an argument of a process, a processing order list number if the argument is the result of a past process, or a data address such as a constant memory address if the argument is a constant, so that the location can be identified.

[0045] The program construction unit 22 receives input of the processing order list output from the processing order list construction unit 21. The program construction unit 22 also receives input of the constant memory output from the processing conversion unit 11A of the source code conversion unit 10A. The program construction unit 22 generates an execution program that uses only the common infrastructure, which is made up of the processing order list and the constant memory. The program construction unit 22 outputs an execution program that uses only the common infrastructure, which is made up of the processing order list and the constant memory.

[0046] (Specific Example) The processing performed by the execution program development tool 1A in the first embodiment will be described below using a specific example.

[0047] 3 is a diagram showing an example of application source code input to an execution program development tool 1A in the first embodiment of the present invention. As shown in FIG. 3, in this specific example, the application for which an execution program is to be developed by the execution program development tool 1A is an image compression application. Furthermore, the data size of the input data and output data of the image compression application is assumed to be 1280 x 720 pixels.

[0048] In this specific example, the common processing is assumed to be a matrix multiplication (arguments: a matrix of size 1000×1000 and a matrix of size 1000×1000). The result of this common processing is a 1000×1000 matrix.

[0049] FIG. 4 is a diagram showing an example of a table of basic data conversion processes referenced by the source code conversion unit 10A in the first embodiment of the present invention. As shown in FIG. 4, the table of basic data conversion processes included in the process information in this specific example is a table in which "process names" are associated with information indicating "input / output contents." The figure also shows an example of a table of advanced data conversion processes referenced by the source code conversion unit 10A in the first embodiment of the present invention. As shown in FIG. 5, the table of advanced data conversion processes included in the process information in this specific example is a table in which "process names" are associated with information on the corresponding "set of basic processes and common processes." Furthermore, the argument size value of the common process included in the process information in this specific example is "1000 x 1000," as described above.

[0050] The configuration of the execution program development tool 1A in this example will be described below with reference to FIG.

[0051] The processing conversion unit 11A of the source code conversion unit 10A converts the processing included in the acquired application source code to generate processing conversion source code. Fig. 6 is a diagram showing an example of the processing conversion source code generated by the processing conversion unit 11A in the first embodiment of the present invention. The processing conversion unit 11A outputs the generated processing conversion source code to the input variable division unit 12A.

[0052] The processing conversion unit 11A also generates a constant memory. Fig. 7 is a diagram showing an example of the constant memory generated by the processing conversion unit 11A in the first embodiment of the present invention. The processing conversion unit 11A outputs the generated constant memory to the processing order list construction unit 21 and the program construction unit 22 of the execution program construction unit 20.

[0053] The process conversion unit 11A reads the source code of the repeated basic process converted from the source code of the input application. The input variable division unit 12A determines whether each process included in the read source code corresponds to a data assignment process, a data read process, a conditional expression process, or a data conversion process.

[0054] Specifically, if the right-hand side consists only of a variable name, the processing conversion unit 11A determines that the processing corresponds to a data assignment processing. Furthermore, if the processing name is a conditional expression processing, the processing conversion unit 11A determines that the processing corresponds to a conditional expression processing. Furthermore, if the processing name is a data read processing, the processing conversion unit 11A determines that the processing corresponds to a data read processing. Furthermore, if the processing name exists in the table of basic data conversion processing, the processing conversion unit 11A determines that the processing corresponds to a basic data conversion processing. Note that in this specific example, since it is clear that the processing is something other than these, the processing conversion unit 11A determines that the processing corresponds to an advanced data conversion processing.

[0055] The processing conversion unit 11A searches a table of advanced data conversion processes for each of the process names "Fourier transform," "DCT transform," and "low-frequency component extraction" included in the application source code.The processing conversion unit 11A then converts the processes "Fourier transform," "DCT transform," and "low-frequency component extraction" into a set of corresponding advanced data conversion processes.The processing conversion unit 11A sequentially stores constants that appear in the converted processes in a constant memory and defines the process names of the advanced data conversion processes as constant names.The processing conversion unit 11A then adds the defined constant names to the last line of the constant definitions.

[0056] The input variable dividing unit 12A converts the acquired processing conversion source code so as to divide the input variables of the processing conversion source code in accordance with the argument size of the common process, thereby generating converted source code. Figure 8 is a diagram showing an example of converted source code generated by the input variable dividing unit 12A in the first embodiment of the present invention. The input variable dividing unit 12A then outputs the generated converted source code to the processing order list construction unit 21 of the execution program construction unit 20.

[0057] Specifically, the input variable splitting unit 12A first splits the input by the data size so that the output and intermediate variables are assigned to each input to be split and then split. To do this, the input variable splitting unit 12A calculates the ratio of the data size of each variable to the data size of the input variable. The input variable splitting unit 12A then calculates the largest integer equal to or greater than the calculated value. In this case, the value is 1, so the input variable splitting unit 12A converts the variable names by adding "-1" to them. Finally, the input variable splitting unit 12A replaces the variable names in each line of "#processing" in the converted source code shown in FIG. 8 with the converted variable names.

[0058] Next, the input variable splitting unit 12A splits the input according to the argument size of the common process. To do this, the input variable splitting unit 12A references the information about the common process and reads the argument size "1000 x 1000." The input variable splitting unit 12A splits the input variable into two using this argument size, converting them into variables called input (1) and input (2). Here, input (1) corresponds to 1000 x 720, and input (2) corresponds to 280 x 720.

[0059] Then, the input variable splitting unit 12A duplicates the outputs and intermediate variables by the number of input variables and assigns numbers to them, thereby enabling the input variable splitting unit 12A to assign the outputs and intermediate variables to the split inputs.

[0060] Finally, the input variable splitting unit 12A duplicates the processing of the processing conversion source code and assigns it to the divided inputs so that processing is executed for each divided input. Specifically, the input variable splitting unit 12A duplicates each line of "#processing" in the converted source code shown in Figure 8 by the number of input variables. Then, for each duplicated line of "#processing", the input variable splitting unit 12A converts the variable to variable name (1) or variable name (2).

[0061] The processing order list construction unit 21 of the execution program construction unit 20 reads the converted source code and constant memory output from the source code conversion unit 10A. The processing order list construction unit 21 then stores the processes included in the converted source code in the processing order list in the order in which they appear. However, if the result of a process is an output, the processing order list construction unit 21 stores the output variable in the line immediately following it.

[0062] The processing order list construction unit 21 describes the argument data for each process as follows: If it is a constant, the processing order list construction unit 21 searches for the constant name from the acquired constants and describes it as the constant for that line number. If it is the result of a past process, the processing order list construction unit 21 describes the processing order list number. FIG. 9 is a diagram showing an example of a processing order list generated by the processing order list construction unit 21 in the first embodiment of the present invention. Then, the processing order list construction unit 21 outputs the generated processing order list to the program construction unit 22.

[0063] The program construction unit 22 generates an execution program that uses only the common infrastructure, which is made up of the processing order list acquired from the processing order list construction unit 21 and the constant memory acquired from the processing conversion unit 11A of the source code conversion unit 10A.

[0064] FIG. 10 is a diagram illustrating how the application developed in the above specific example operates according to the source code. As shown in FIG. 10, the processing control unit of the common infrastructure reads the processing order list of the execution program and operates the common processes, etc., to execute the processes in ascending order. For example, the common process in the first row of the processing order list reads the input data, input (1), and a matrix of 1s in the execution program's constant memory, inputs each as an argument to the common process, and stores the result in the execution program's processing result register. In this way, the application developed in the above specific example can execute the same process as the process indicated by the source code of the original application by executing each step in the processing order list.

[0065] <Modification of First Embodiment> A modification of the first embodiment of the present invention will be described below. An execution program development tool 1B in the modification of the first embodiment described below has a different configuration of the source code conversion unit from the execution program development tool 1A in the first embodiment described above.

[0066] [Configuration of Execution Program Development Tool] The following describes the configuration of an execution program development tool 1B in a modified example of the first embodiment. The execution program development tool 1B is an example of an information processing device of the present invention.

[0067] 11 is a diagram showing the overall configuration of an execution program development tool 1B according to a modification of the first embodiment of the present invention. As shown in FIG. 11, the execution program development tool 1B includes a source code conversion unit 10B and an execution program construction unit 20. The source code conversion unit 10B also includes a process conversion unit 11B and an input variable division unit 12B. The configuration of the execution program construction unit 20 is the same as that of the execution program development tool 1A according to the first embodiment described above, and therefore the same reference numerals are used and detailed description thereof will be omitted.

[0068] The input variable splitting unit 12B accepts input of application source code. The input variable splitting unit 12B converts the input application source code so that the input variables are split, enabling common processing and the like to be applied, and generates input variable split source code. The input variable splitting unit 12B outputs the generated input variable split source code to the processing conversion unit 11B.

[0069] The processing conversion unit 11B accepts input of the input variable divided source code output from the input variable division unit 12B. The processing conversion unit 11B sequentially stores data defined as constants in the input input variable divided source code in a constant memory, and generates converted source code as a set of common processes, basic processes, and comparison processes that can be executed by the common infrastructure. The processing conversion unit 11B outputs the generated converted source code to the processing order list construction unit 21 of the execution program construction unit 20. The processing conversion unit 11B also outputs the generated constant memory to the processing order list construction unit 21 and the program construction unit 22 of the execution program construction unit 20.

[0070] The processing order list construction unit 21 receives input of the converted source code and constant memory output from the processing conversion unit 11B of the source code conversion unit 10B. The processing order list construction unit 21 generates a processing order list based on the converted source code and variable memory. The processing order list construction unit 21 outputs the generated processing order list to the program construction unit 22.

[0071] The processing order list construction unit 21 creates a processing order list by arranging each process included in the input converted source code so that they are executed in the order in which they appear. At this time, the processing order list construction unit 21 stores, as an argument to a process, a processing order list number if the argument is the result of a past process, or a data address such as a constant memory address if the argument is a constant, so that the location can be identified.

[0072] The program construction unit 22 receives input of the processing order list output from the processing order list construction unit 21. The program construction unit 22 also receives input of the constant memory output from the processing conversion unit 11B of the source code conversion unit 10A. The program construction unit 22 generates an execution program that uses only the common infrastructure, which is made up of the processing order list and the constant memory. The program construction unit 22 outputs an execution program that uses only the common infrastructure, which is made up of the processing order list and the constant memory.

[0073] (Specific Example) Hereinafter, a specific example of the processing performed by the execution program development tool 1B in the modified example of the first embodiment will be described.

[0074] In this specific example, the application for which an executable program is developed by the execution program development tool 1B is an image compression application, as in the specific example of the first embodiment, as shown in Fig. 4. The prerequisites in this specific example are the same as those in the specific example of the first embodiment.

[0075] The configuration of the execution program development tool 1B in this example will be described below with reference to FIG.

[0076] The input variable splitting unit 12B of the source code conversion unit 10B converts the source code of the application so as to split the input variables of the acquired application source code according to the argument size of the common process, and generates input variable split source code. Figure 12 is a diagram showing an example of input variable split source code generated by the input variable splitting unit 12B in a modified example of the first embodiment of the present invention. The input variable splitting unit 12B then outputs the generated input variable split source code to the processing conversion unit 11B. Note that the details of the operation of the input variable splitting unit 12B are the same as the details of the operation of the input variable splitting unit 12A in the first embodiment described above.

[0077] The processing conversion unit 11B converts the processing of the acquired input variable divided source code to generate converted source code. Then, the processing conversion unit 11B outputs the generated converted source code to the processing order list construction unit 21 of the execution program construction unit 20. Furthermore, the processing conversion unit 11B outputs the generated constant memory to the processing order list construction unit 21 and the program construction unit 22 of the execution program construction unit 20. Note that the details of the operation of the processing conversion unit 11B are the same as the details of the operation of the processing conversion unit 11A in the first embodiment described above.

[0078] The processing order list construction unit 21 of the execution program construction unit 20 reads the converted source code and constant memory output from the source code conversion unit 10A. The processing order list construction unit 21 then stores the processes included in the read converted source code in a processing order list in the order in which they appear. The processing order list construction unit 21 then outputs the generated processing order list to the program construction unit 22.

[0079] The program construction unit 22 generates an execution program that uses only the common infrastructure, which is made up of the processing order list acquired from the processing order list construction unit 21 and the constant memory acquired from the processing conversion unit 11A of the source code conversion unit 10A.

[0080] Second Embodiment A second embodiment of the present invention will now be described.

[0081] [Configuration of Execution Program Development Tool] The configuration of the execution program development tool 1C in the second embodiment will be described below. The execution program development tool 1C is an example of the information processing device of the present invention.

[0082] 13 is a diagram showing the overall configuration of an execution program development tool 1C according to a second embodiment of the present invention. As shown in FIG. 13, the execution program development tool 1C includes a source code conversion unit 10C and an execution program construction unit 20C. The source code conversion unit 10C also includes a process conversion unit 11C and an input variable division unit 12C. The execution program construction unit 20C includes a processing order list construction unit 21C, a program construction unit 22C, a unique process construction unit 23C, and a unique process conversion unit 24C.

[0083] The execution program development tool 1C in the second embodiment described below is obtained by adding functions (the functions of a unique processing configuration unit 23C and a unique processing conversion unit 24C) to the execution program development tool 1A in the second embodiment described above to improve application performance. These added functions are functions that can reduce processing time by reducing repetition of processing and connections between processing. In order to reduce repetition of processing, the execution program development tool 1C in the second embodiment sets a set of specific common processing and basic processing as unique processing, and adds the unique processing to the processing executed by the common infrastructure.

[0084] The following description will focus on the differences in configuration from the first embodiment.

[0085] The unique processing configuration unit 23C reads the processing order list output from the processing order list configuration unit 21C and generates an abstract syntax tree. The unique processing configuration unit 23C derives all consecutive processing patterns from the generated abstract syntax tree. Then, from the set of derived processing patterns, the unique processing configuration unit 23C sets a processing pattern output by a specific algorithm (for example, an algorithm that searches for a maximum length pattern or multiple patterns) as a unique processing. The unique processing configuration unit 23C then generates a processing execution unit for the unique processing and adds the generated processing execution unit for the unique processing to the common infrastructure.

[0086] The unique process conversion unit 24C searches for and converts a processing pattern of the unique process in the processing order list output from the processing order list configuration unit 21 based on the unique process set by the unique process configuration unit 23C.

[0087] (Specific Example) Hereinafter, the processing performed by the execution program development tool 1C in the second embodiment will be described using a specific example.

[0088] In this specific example, the application for which an executable program is developed by the execution program development tool 1C is an image compression application, as in the specific example of the first embodiment. Furthermore, the prerequisites in this specific example are the same as those in the specific example of the first embodiment.

[0089] The processing pattern search algorithm of the unique processing configuration unit 23C is an algorithm that lists a plurality of processing patterns and outputs the processing pattern with the longest length.

[0090] The configuration of the execution program development tool 1C in this example will be described below with reference to FIG.

[0091] The processing conversion unit 11C of the source code conversion unit 10C converts the processing of the acquired application source code to generate processing conversion source code. The processing conversion unit 11C outputs the generated processing conversion source code to the input variable division unit 12C. The processing conversion unit 11C also generates a constant memory. The processing conversion unit 11C outputs the generated constant memory to the processing order list construction unit 21C and program construction unit 22C of the execution program construction unit 20C.

[0092] The input variable dividing unit 12C converts the acquired processing conversion source code so as to divide the input variables of the processing conversion source code in accordance with the argument size of the common processing, thereby generating converted source code. The input variable dividing unit 12C then outputs the generated converted source code to the processing order list construction unit 21C of the execution program construction unit 20C.

[0093] The processing order list construction unit 21C of the execution program construction unit 20C reads the converted source code and constant memory output from the source code conversion unit 10C. The processing order list construction unit 21C then stores the processes included in the read converted source code in the processing order list in the order in which they appear. The processing order list construction unit 21C then outputs the generated processing order list to the unique processing construction unit 23C and the unique processing conversion unit 24C.

[0094] The unique processing configuration unit 23C reads the processing order list output from the processing order list configuration unit 21C and generates an abstract syntax tree. The unique processing configuration unit 23C derives three consecutive common processing operations from the generated abstract syntax tree as a pattern of multiple maximum-length processing operations. Figure 14 is a diagram showing the derivation of common processing operations from an abstract syntax tree by the unique processing configuration unit 23C in the second embodiment of the present invention. The unique processing configuration unit 23C then sets the derived series of operations as a unique processing operation. The unique processing configuration unit 23C generates a processing execution unit for the unique processing operation and adds the generated processing execution unit for the unique processing operation to the common infrastructure.

[0095] The unique process conversion unit 24C reads the unique processes set by the unique process configuration unit 23C. Based on the read unique processes, the unique process conversion unit 24C searches for three consecutive common processes included in the processing order list output from the processing order list configuration unit 21C. The unique process conversion unit 24C converts the set of processes found into unique processes and generates a processing order list'. Figure 15 is a diagram showing an example of the processing order list' generated by the unique process conversion unit 24C in the second embodiment of the present invention.

[0096] The program construction unit 22C generates an execution program that uses only the common infrastructure, which is made up of the processing order list' acquired from the specific processing conversion unit 24C and the constant memory acquired from the processing conversion unit 11C of the source code conversion unit 10C.

[0097] <Modification of Second Embodiment> The configuration of the source code conversion unit 10C of the execution program development tool 1C in the second embodiment described above may be replaced with the source code conversion unit 10B of the execution program development tool 1B in the first embodiment described above.

[0098] As described above, in each of the above-described embodiments and their variations, the minimum unit of function used by all applications is pre-implemented as a common infrastructure on the server side. The minimum unit of function here refers to, for example, a function that executes basic operations such as AND, addition, and assignment, as well as specific complex operations such as multiplication. The execution program development tool in each of the above-described embodiments and their variations is configured to generate an execution program by converting the input application source code so that it uses only the functions of the common infrastructure pre-implemented on the server side (i.e., only the minimum unit of function).

[0099] With this configuration, the execution program development tool according to each embodiment and its modified examples of the present invention can eliminate the need for IT infrastructure to be started when an application is started, thereby shortening the start-up time of all applications used.

[0100] According to the above-described embodiment, the information processing device includes a receiving unit and a program configuration unit. For example, the information processing device is an execution program development tool 1A-1C in the embodiment, the receiving unit is a source code conversion unit 10A-10C in the embodiment, and the program configuration unit is a program configuration unit 22 and 22C in the embodiment. The receiving unit receives a request to use a common infrastructure, which is an IT infrastructure shared by multiple different applications. The program configuration unit generates an execution program for the application using at least one common infrastructure that has been initialized in advance.

[0101] The information processing device further includes a process conversion unit. For example, the process conversion unit is one of the process conversion units 11A to 11C in the embodiment. The process conversion unit acquires source code of an application and converts the process included in the source code into a process that uses a common infrastructure.

[0102] In the above-mentioned information processing device, the IT infrastructure is a combination of hardware and software used to generate an execution program.

[0103] In the above information processing device, the hardware may include at least a processor, and the software may include at least one of an operating system and a software library.

[0104] In the information processing device, each of the plurality of common infrastructures may be an IT infrastructure that performs processing to realize a minimum unit of function in a plurality of applications.

[0105] In the information processing device, the processing conversion unit may replace variables included in the source code with constants, thereby eliminating data substitution processing.

[0106] In the information processing device, the processing conversion unit may convert the conditional expression processing into a comparison processing, and define information indicating the location of the processing to be executed next according to the comparison result.

[0107] The configuration of the executable program development tools 1A-1C in the above-described embodiment and its variations may be partially or entirely implemented by a computer. In this case, a program for implementing this function may be recorded on a computer-readable recording medium, and the program may be loaded into a computer system and executed. Note that the term "computer system" as used herein includes hardware such as an OS and peripheral devices. Furthermore, "computer-readable recording medium" refers to portable media such as flexible disks, optical magnetic disks, ROMs, and CD-ROMs, as well as storage devices such as hard disks built into computer systems. Furthermore, "computer-readable recording medium" may also include devices that dynamically store programs for a short period of time, such as communication lines used when transmitting programs over networks such as the Internet or telephone lines, or devices that store programs for a fixed period of time, such as volatile memory within the computer system serving as the server or client. The program may be designed to implement some of the aforementioned functions, or may be capable of implementing the aforementioned functions in combination with a program already stored in the computer system, or may be implemented using a programmable logic device such as an FPGA (Field Programmable Gate Array).

[0108] Although an embodiment of the present invention has been described in detail above with reference to the drawings, the specific configuration is not limited to this embodiment, and includes designs within the scope of the present invention that do not deviate from the gist of the present invention.

[0109] 1A to 1C Execution program development tool 10, 10A to 10C Source code conversion section 11, 11A to 11C Processing conversion section 12A to 12C Input variable division section 20, 20C Execution program configuration section 21, 21C Processing order list configuration section 22, 22C Program configuration section 23C Unique processing configuration section 24C Unique processing conversion section

Claims

1. An information processing device comprising: a reception unit that receives a request to use a common infrastructure, which is an IT infrastructure shared by multiple different applications; and a program configuration unit that generates an execution program for the application using at least one of the common infrastructures that has been initialized in advance.

2. The information processing device according to claim 1, further comprising a process conversion unit that acquires the source code of the application and converts the process included in the source code into a process that uses the common infrastructure.

3. The information processing device according to claim 1 or 2, wherein the IT infrastructure is a combination of hardware and software used to generate the execution program.

4. The information processing device according to claim 3, wherein the hardware includes at least a processor, and the software includes at least one of an operating system and a software library.

5. The information processing device according to claim 1 or 2, wherein each of the plurality of common infrastructures is the IT infrastructure that performs processing to realize a minimum unit of function in the plurality of applications.

6. The information processing device according to claim 2, wherein the processing conversion unit replaces variables included in the source code with constants, thereby eliminating data assignment processing.

7. The information processing device according to claim 2, wherein the processing conversion unit converts a conditional expression processing into a comparison processing, and defines information indicating the location of the processing to be executed next according to the comparison result.

8. An information processing method using a computer, comprising: a receiving step of receiving a request to use a common infrastructure, which is an IT infrastructure shared by a plurality of different applications, and which has been initialized in advance; and a program configuration step of generating an execution program for the application using the common infrastructure.

Images