KR20250053420A - Method and apparatus for searching for optimal interpreter of high-level programming language - Google Patents

Abstract

A method and device for providing a code execution environment with an optimal interpreter are disclosed.
According to one aspect of the present disclosure, a method for providing a code execution environment with an optimal interpreter is provided, comprising: a process of receiving source code and user requirements; a process of separating the source code to obtain at least one partial source code; a process of determining an interpreter that meets the user requirements for each partial source code; and a process of building a virtual environment for executing the source code based on the determined interpreter for each partial source code.

Description

Method and apparatus for searching for optimal interpreter of high-level programming language

The present disclosure relates to a method and apparatus for searching for an optimal interpreter for a high-level programming language. More specifically, it relates to a technique for selecting an interpreter most suitable for a user's requirements among various interpreters for a programming language.

The content described below merely provides background information related to the present embodiment and does not constitute prior art.

An interpreter is a computer program or environment that directly executes the source code of a programming language. Interpreters are widely used because they are easy to develop.

Interpreters have different performances depending on the situation. For example, a particular interpreter may be optimized for numerical calculations, while another interpreter may be optimized for string processing or input/output operations. Therefore, in order for users to select the optimal interpreter, they need to have a deep understanding of the performance and characteristics of each interpreter.

Each interpreter may have compatibility issues. Choosing the wrong interpreter may result in problems executing your code, requiring additional debugging and modification.

However, there is no mechanism to manage the process of selecting the optimal interpreter for the code while satisfying the user's requirements (e.g., execution speed, memory usage, etc.). For example, although the optimal interpreter may vary depending on the project or code, the user is responsible for selecting and configuring the interpreter for a specific project, and for a new project or in a different environment, the user must select and configure the interpreter again.

Furthermore, if there are different interpreters for different methods or operation units within the code, there is no mechanism to separate the relevant parts and select and execute the optimal interpreter. This forces users to judge and select the interpreter based on the entire code, which can be a major problem that hinders detailed optimization.

The main purpose of the present disclosure is to provide a method and apparatus for searching for an optimal interpreter for a high-level programming language.

The purpose of this disclosure is to provide an environment in which an interpreter best suited to a user's requirements can be searched and codes can be executed with the searched interpreter.

The purpose of the present disclosure is to separate each partial code and execute each partial code with a corresponding optimal interpreter when the optimal interpreter is different for each partial code within the code.

The problems to be solved by the present invention are not limited to the problems mentioned above, and other problems not mentioned will be clearly understood by those skilled in the art from the description below.

According to one aspect of the present disclosure, a method for providing a code execution environment with an optimal interpreter is provided, comprising: a process of receiving source code and user requirements; a process of separating the source code to obtain at least one partial source code; a process of determining an interpreter that meets the user requirements for each partial source code; and a process of building a virtual environment for executing the source code based on the determined interpreter for each partial source code.

According to another aspect of the present disclosure, a device including one or more processors and a memory operably coupled with the one or more processors, the memory storing instructions for causing the one or more processors to perform operations in response to execution of instructions by the one or more processors, the operations including: a process of receiving source code and a user requirement; a process of separating the source code to obtain at least one partial source code; a process of determining an interpreter satisfying the user requirement for each partial source code; and a process of building a virtual environment for executing the source code based on the determined interpreter for each partial source code.

According to an embodiment of the present disclosure, the performance of the code is improved by executing each part of the code with an optimized interpreter.

According to an embodiment of the present disclosure, there is an effect of shortening the execution time of the code by executing several parts of the code in parallel with the corresponding optimal interpreter.

The effects of the present disclosure are not limited to the effects mentioned above, and other effects not mentioned will be clearly understood by those skilled in the art from the description below.

FIG. 1 is a block diagram of a device for providing a code execution environment with an optimal interpreter according to one embodiment of the present disclosure.
FIG. 2 is a flowchart of a method for providing a code execution environment with an optimal interpreter according to one embodiment of the present disclosure.
FIG. 3 is a diagram for explaining a process of separating code according to one embodiment of the present disclosure.
FIG. 4 is a block diagram illustrating an example of a computer device according to one embodiment of the present disclosure.

Hereinafter, some embodiments of the present disclosure will be described in detail using exemplary drawings. When adding reference numerals to components of each drawing, it should be noted that the same numerals are used for identical components as much as possible even if they are shown in different drawings. In addition, when describing the present disclosure, if it is determined that a specific description of a related known configuration or function may obscure the gist of the present disclosure, the detailed description thereof will be omitted.

In describing components of embodiments according to the present disclosure, symbols such as first, second, i), ii), a), b), etc. may be used. These symbols are only for distinguishing the components from other components, and the nature or order or sequence of the components is not limited by the symbols. When a part in the specification is said to "include" or "provide" a component, this does not mean that other components are excluded, but rather that other components can be further included, unless explicitly stated otherwise.

The detailed description set forth below, together with the accompanying drawings, is intended to explain exemplary embodiments of the present disclosure and is not intended to represent the only embodiments in which the present disclosure may be practiced.

The present disclosure relates to a technique for selecting, testing and comparing an interpreter that best suits a user's requirements among various interpreters for a programming language. This allows the user to select an interpreter that satisfies specific requirements (e.g., execution speed, memory usage, etc.). In addition, the user can automate execution with the selected interpreter for a specific file, code or program, thereby minimizing performance and compatibility issues.

To this end, a method and device for providing a code execution environment with an optimal interpreter are proposed, and in particular, when the optimal interpreter is different for each partial code within the code, each partial code is separated and managed to be executed with the corresponding optimal interpreter. This enables parallel processing, resource separation, memory optimization, etc., and thus improves the performance of the code. In addition, when only a specific partial code causes an error in a specific interpreter, only the corresponding partial code is executed with a different interpreter, thereby avoiding the problem, thereby providing advantages in terms of compatibility and stability.

In this specification, the term 'code' refers to source code or raw code written using a high-level programming language and can be executed by an interpreter, and the term 'code' may be used interchangeably with the term 'source code', the term 'raw code', or the term 'program'.

FIG. 1 is a configuration diagram of a device (hereinafter referred to as “device providing optimal execution environment”) for providing a code execution environment with an optimal interpreter according to one embodiment of the present disclosure.

The optimal execution environment providing device (100) can separate a code input by a user into at least one partial code, search for an optimal interpreter for each partial code, and set and provide a code execution environment based on the optimal interpreter for each partial code. To this end, the optimal execution environment providing device (100) includes all or part of a database (110), a user interface (120), an interpreter test unit (130), an interpreter optimization unit (140), and an execution environment construction unit (150).

FIG. 1 illustrates the optimal execution environment providing device (100) as a device for convenience of explanation. In other embodiments, the optimal execution environment providing device (100) and each component thereof may be implemented as hardware or software, or may be implemented as a combination of hardware and software. In addition, the function of each component may be implemented as software, and one or more processors may be implemented to execute the function of the software corresponding to each component.

The database (110) stores and manages information about various interpreters. The information includes performance data for each interpreter, compatibility information, etc. The information includes detailed information about each interpreter, such as preferred versions of each interpreter, update history, and supported language functions. In addition, the database (110) also stores and manages information about the characteristics, advantages, and optimized performance for specific situations of each interpreter. The information about the interpreter is used to recommend or select the optimal interpreter by matching it with user requirements.

The database (110) stores and manages interpreter test results. The test results are used to determine the optimal interpreter corresponding to the code or each partial code together with user requirements.

The database (110) stores and manages optimal interpreter information corresponding to each part of the code entered by the user. This is used to build an optimal virtual environment for code execution.

The user interface (120) receives a code written by a user. In addition, user requirements regarding optimization (e.g., execution speed, memory usage, etc.) can be input.

The user interface (120) can visually display the test results to the user. Here, the test results refer to the results of measuring performance indicators such as execution time and memory usage by executing each partial code with each interpreter by the interpreter test unit (130) and stored in the database (110). Here, each partial code refers to a unit of code that performs one function or operation and is obtained by performing code separation in the interpreter optimization unit (140).

The user interface (120) can visually display information to the user about the optimal interpreter determined for each partial code. The information is information about the optimal interpreter determined for each partial code by the interpreter optimization unit (140) based on user requirements and test results.

Through the user interface (120), the user can execute code in a virtual environment constructed by the execution environment construction unit (150) and check the execution results.

The user interface (120) may be provided integrated with the user interface of an integrated development environment (IDE), but is not limited thereto.

The interpreter test unit (130) tests the code entered by the user by executing it in a virtual environment with various interpreters. If the code entered by the user is divided into each partial code, the interpreter test unit (130) tests it by executing each partial code in a virtual environment with various interpreters. Here, the virtual environment is an execution environment having independent types and versions of interpreters, modules, libraries, etc., and different virtual environments do not affect each other.

The interpreter test unit (130) searches the database (110) for information on various interpreters. The interpreter test unit (130) obtains the code entered by the user or each partial code separated from the code entered by the user from the interpreter optimization unit (140).

The interpreter test unit (130) builds a virtual environment for each interpreter based on interpreter information retrieved from the database (110) and performs tests on the code and/or each partial code.

The interpreter test unit (130) can perform performance measurement and analysis of code or each part of code and derive results using a dynamic code analysis tool. For example, a profiling tool can be used to analyze which part of the code consumes a lot of time and which function is frequently called. The profiling tool is a type of dynamic code analysis tool and can utilize gprofiler, eBPF, etc., but is not limited thereto.

The interpreter test unit (130) controls the same environment when performing the test and performs the test a certain number of times to derive the test results. Here, the test results include performance indicators such as execution time and memory usage measured by executing each partial code with each interpreter. The interpreter test unit (130) stores the derived test results in the database (110). The stored test results are used by the interpreter optimization unit (140) to determine the optimal interpreter corresponding to the code or each partial code.

The interpreter test unit (130) can further perform a test to check whether the code extracted by the interpreter optimization unit (140) using a static code analysis tool or the modules or libraries used in each partial code are normally imported into each interpreter. Through this, the compatibility verification of modules and/or libraries through static code analysis can be additionally supplemented.

The interpreter optimization unit (140) receives user requirements (e.g., execution speed, memory usage, etc.) and code, tests the code with each interpreter, and determines the optimal interpreter based on the user requirements.

The interpreter optimization unit (140) performs separation on the input code. This is to separate the code into each partial code and select the optimal interpreter for each partial code. Here, the partial code refers to a unit of code that performs one function or operation. For example, the code may be separated by method, function, or class to obtain each partial code, but is not limited thereto.

By using the optimal interpreter for each partial code through code separation, the performance of the entire code can be improved. This is because by using the optimal interpreter for each partial code, execution time and memory usage can be reduced through parallel processing, resource separation, and memory optimization. In addition, if only a specific partial code causes an error in a specific interpreter, the problem can be avoided by executing only that partial code with a different interpreter, which also has advantages in terms of compatibility and stability.

An example of a process for separating code in the interpreter optimization unit (140) is illustrated in FIG. 3.

First, it is determined whether the code can be separated into units such as methods, classes, or operations (S221). If the code cannot be separated, the interpreter test unit (130) performs a test on the entire code (S240). If the code can be separated, a static code analysis tool is used to determine whether code separation is possible (S223). If the code cannot be separated, code separation can be performed through user input (S233). If the code is separated into each partial code through user input, the interpreter test unit (130) performs a test on each partial code and a test on the entire code (S240). If the code can be separated, the static code analysis tool is used to separate the code into each partial code (S231), and the interpreter test unit (130) performs a test on each partial code and a test on the entire code (S240).

The interpreter optimization unit (140) can analyze whether the code contains numerical operations, string operations, vector operations, data flow, call relationships, etc. using a static code analysis tool.

The interpreter optimization unit (140) can use a static code analysis tool to check whether a module, library, or programming language used in the code or each partial code is compatible with a specific interpreter. Information on modules, libraries, or programming languages compatible with each interpreter can be obtained by querying the database (110). Through this, interpreters that are not compatible with the code are excluded in the process of determining the optimal interpreter.

The interpreter optimization unit (140) determines the optimal interpreter for the code or each partial code based on the user requirements and the test results performed in the interpreter test unit (130). For example, if the user requirement is fast execution speed, the optimal interpreter for the code or each partial code may be used to execute the code, and the interpreter with the shortest measured execution time may be determined. For example, if the user requirement is minimizing memory usage, the optimal interpreter for the code or each partial code may be used to execute the code, and the interpreter with the lowest measured memory usage may be determined. For example, if the user requirement is fast execution speed and minimizing memory usage, the optimal interpreter for the code or each partial code may be determined by assigning weights to the measured execution time and memory usage of each interpreter for the code or each partial code.

The execution environment construction unit (150) constructs a virtual environment for executing the code or each partial code. The execution environment construction unit (150) constructs each virtual environment with an optimal interpreter for the code or each partial code determined by the interpreter optimization unit (140). At this time, efficient communication between partial codes can be supported by utilizing IPC (Inter-Process Communication) such as a message queue or shared memory, or by utilizing protocols such as RESTful API or gRPC.

According to one embodiment of the present disclosure, the advantages obtained by separating the code and executing it with an optimal interpreter for each separate partial code are as follows.

A particular interpreter may be optimized for numerical computations, while another may be optimized for string processing or input/output operations. Therefore, performance can be improved by running certain parts of your code with an interpreter optimized for that task. For example, Pypy3 optimizes numerical computations through JIT compilation (Just-In-Time Compilation).

By executing multiple parts of the code in parallel with different interpreters to process the work, the overall execution time can be shortened. For example, in the case of Python, there is a problem that when a program is executed with a single interpreter due to the GIL (global interpreter lock), it operates as a single thread, making parallel processing inefficient, but this can be improved.

Since each interpreter uses independent memory space and resources, memory leakage or overhead in one interpreter does not affect the performance of other interpreters.

If a particular piece of code causes a problem in one interpreter, you can work around the problem by running just that piece in a different interpreter.

Each interpreter has its own memory management strategy. Therefore, if a certain part of the code uses a lot of memory, it can be run with an interpreter with efficient memory management to reduce memory usage.

Figure 2 is a flow chart of a method for providing a code execution environment with an optimal interpreter according to one embodiment of the present disclosure (hereinafter referred to as the 'optimal execution environment providing method'). The optimal execution environment providing method can be performed by an optimal execution environment providing device (100).

Referring to Fig. 2, a user-written code and user requirements are input (S210). The user requirements are related to the execution speed and/or memory usage of the code.

It is possible to determine whether the user-written code can be separated into multiple partial codes (S220).

If separation is not possible, perform steps S240 to S270 for the entire code.

If separable, the code is separated into multiple partial codes (S230). This is to separate the code into each partial code and select the optimal interpreter for each partial code. Here, the partial code refers to a unit of code that performs one function or operation.

A group of interpreters compatible with each partial code can be selected using information about multiple interpreters stored in the database (110). This is to filter out interpreters that are not compatible with the partial code.

Based on the interpreter information retrieved from the database (110), a filtered interpreter-specific virtual environment is constructed, and a filtered interpreter-specific test for the code and/or each partial code is performed (S240). At this time, the test is performed a certain number of times under control with the same environment. The test results include performance indicators such as execution time and memory usage measured by executing each partial code with each interpreter, and are stored in the database (110).

Based on the test results and user requirements, the optimal interpreter for the code or each partial code is determined (S250). Using the test results for each interpreter for the code or each partial code, the interpreter that best meets the user requirements can be determined as the optimal interpreter for the code or each partial code.

A virtual environment is built for executing the code or each partial code (S260). Each virtual environment is built with the optimal interpreter determined for the code or each partial code.

You can execute code in the constructed virtual environment (S270). The code is executed by the optimal interpreter for each partial code. For efficient communication between partial codes, you can utilize inter-process communication or protocols such as RESTful or gRPC.

FIG. 4 is a block diagram illustrating an example of a computer device according to one embodiment of the present disclosure. A method for providing a code execution environment with an optimal interpreter according to embodiments of the present disclosure can be implemented by a computer device (400) illustrated in FIG. 4.

The computer device (400) may include at least one processor (410), memory (420), a network interface (430), and an input/output interface (440), as illustrated in FIG. 4. The bus (450) provides a mechanism for the components of the computer device (400) to communicate with each other as intended. While the bus (450) is schematically illustrated as a single bus, alternative implementations may use multiple buses.

The processor (410) may be configured to process instructions of a computer program by performing basic arithmetic, logic, and input/output operations. The instructions may be provided to the processor (410) by the memory (420) or the network interface (430). For example, the processor (410) may be configured to execute instructions received according to program code stored in a storage device such as the memory (420).

Memory (420) is a computer-readable recording medium and may include a random access memory (RAM), a read only memory (ROM), and a permanent mass storage device such as a disk drive. Here, the permanent mass storage device such as ROM and a disk drive may be included in the computer device (400) as a separate permanent storage device distinct from the memory (420).

Additionally, the memory (420) may store an operating system and at least one program code. These software components may be loaded into the memory (420) from a computer-readable recording medium separate from the memory (420). The separate computer-readable recording medium may include a computer-readable recording medium such as a floppy drive, a disk, a tape, a DVD/CD-ROM drive, a memory card, etc. In another embodiment, the software components may be loaded into the memory (420) via a network interface (430) rather than a computer-readable recording medium. For example, the software components may be loaded into the memory (420) of the computer device (400) based on a computer program installed by files received via the network interface (430).

The network interface (430) may provide a function for the computer device (400) to communicate with other external devices via a wired or wireless communication network. For example, requests, commands, data, files, etc. generated by the processor (410) of the computer device (400) according to program codes stored in a recording device such as a memory (420) may be transmitted to other external devices via a wired or wireless communication network under the control of the network interface (430). Conversely, signals, commands, data, files, etc. from other external devices may be received by the computer device (400) via the network interface (430) of the computer device (400) via a wired or wireless communication network. Signals, commands, data, etc. received via the network interface (430) may be transmitted to the processor (410) or the memory (420), and files, etc. may be stored in a storage medium (a permanent storage device described above) that the computer device (400) may further include.

The input/output interface (440) may be a means for interfacing with an input/output device. For example, the input device may include a device such as a microphone, a keyboard, or a mouse, and the output device may include a device such as a display, a speaker, etc. As another example, the input/output interface (440) may be a means for interfacing with a device that integrates input and output functions into one, such as a touch screen. The input/output device may be configured as a single device with the computer device (400).

Additionally, in other embodiments, the computer device (400) may include fewer or more components than the components of FIG. 4. For example, the computer device (400) may be implemented to include at least some of the input/output devices described above, or may further include other components such as a transceiver, a database, etc.

Each component of the device or method according to the present invention may be implemented as hardware or software, or as a combination of hardware and software. In addition, the function of each component may be implemented as software, and a microprocessor may be implemented to execute the function of the software corresponding to each component.

Various implementations of the systems and techniques described herein can be implemented as digital electronic circuits, integrated circuits, field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), computer hardware, firmware, software, and/or combinations thereof. These various implementations can include implementations of one or more computer programs executable on a programmable system. The programmable system includes at least one programmable processor (which may be a special purpose processor or a general purpose processor) coupled to receive data and instructions from, and transmit data and instructions to, a storage system, at least one input device, and at least one output device. Computer programs (also known as programs, software, software applications, or code) include instructions for the programmable processor and are stored on a "computer-readable medium."

A computer-readable recording medium includes any type of recording device that stores data that can be read by a computer system. Such a computer-readable recording medium can be a non-volatile or non-transitory medium, such as a ROM, a CD-ROM, a magnetic tape, a floppy disk, a memory card, a hard disk, a magneto-optical disk, a storage device, and may further include a transitory medium, such as a data transmission medium. In addition, the computer-readable recording medium can be distributed over a network-connected computer system, so that the computer-readable code can be stored and executed in a distributed manner.

Although the flowchart/timing diagram of this specification describes each process as being executed sequentially, this is only an illustrative description of the technical idea of one embodiment of the present disclosure. In other words, a person having ordinary skill in the art to which one embodiment of the present disclosure belongs may change and modify and apply various modifications and variations such as changing the order described in the flowchart/timing diagram and executing it or executing one or more of the processes in parallel without departing from the essential characteristics of one embodiment of the present disclosure. Therefore, the flowchart/timing diagram is not limited to a chronological order.

The above description is merely an illustrative description of the technical idea of the present embodiment, and those with ordinary skill in the art to which the present embodiment belongs may make various modifications and variations without departing from the essential characteristics of the present embodiment. Therefore, the present embodiments are not intended to limit the technical idea of the present embodiment, but to explain it, and the scope of the technical idea of the present embodiment is not limited by these embodiments. The protection scope of the present embodiment should be interpreted by the following claims, and all technical ideas within a scope equivalent thereto should be interpreted as being included in the scope of the rights of the present embodiment.

100: Device providing optimal execution environment
110: Database
120: User Interface
130: Interpreter Test Section
140: Interpreter Optimization Section
150: Execution environment construction department

Claims (10)

As a method to provide a code execution environment with an optimal interpreter,
The process of receiving source code and user requirements;
A process of separating the above source code to obtain at least one partial source code;
The process of determining an interpreter that meets the user requirements for each partial source code; and
A process of building a virtual environment for executing the source code based on an interpreter determined for each partial source code.
A method including: In the first paragraph,
The process of obtaining the above is,
A method for obtaining at least one partial source code by dividing the above source code into method, function or class units that perform one function or operation. In the first paragraph,
The above decision process is,
A process of selecting a compatible interpreter group for each partial source code by using information about multiple pre-stored interpreters;
The process of obtaining performance measurement results including execution time and memory usage by testing the corresponding partial source code with each interpreter included in the selected interpreter group by partial source code; and
A method including a process of determining an optimal interpreter for each partial source code based on the performance measurement results and the user requirements. In the first paragraph,
The above construction process is,
A method of building a virtual environment for each partial source code using an interpreter determined for each partial source code. In the first paragraph,
A method wherein the above user requirements relate to execution speed and memory usage of the above code. A device comprising one or more processors and memory operably coupled with the one or more processors,
The above memory stores instructions that cause one or more processors to perform operations in response to execution of instructions by one or more processors,
The above actions are,
The process of receiving source code and user requirements;
A process of separating the above source code to obtain at least one partial source code;
The process of determining an interpreter that meets the user requirements for each partial source code; and
A device comprising a process of constructing a virtual environment for executing the source code based on an interpreter determined for each partial source code. In Article 6,
The process of obtaining the above is,
A device for obtaining at least one partial source code by dividing the source code into method, function or class units that perform one function or operation. In Article 6,
The above decision process is,
A process of selecting a compatible interpreter group for each partial source code by using information about multiple pre-stored interpreters;
The process of obtaining performance measurement results including execution time and memory usage by testing the corresponding partial source code with each interpreter included in the selected interpreter group by partial source code; and
A device including a process for determining an optimal interpreter for each partial source code based on the performance measurement results and the user requirements. In Article 6,
The above construction process is,
A device that builds a virtual environment for each partial source code with an interpreter determined for each partial source code. In Article 6,
The above user requirements relate to the execution speed and memory usage of the above code, the device.

Images