KR100632403B1 - Method for software streaming and caching according to runtime coefficient among code modules - Google Patents

Abstract

1. TECHNICAL FIELD OF THE INVENTION

The present invention relates to a software streaming method based on correlation information between code modules and a caching method using correlation information between code modules.

2. The technical problem to be solved by the invention

According to the present invention, when streaming software through a wired / wireless communication network, for example, when streaming a multimedia program requiring real time, the correlation information (calling relationship, etc.) between code modules (code blocks) constituting the software is included. Streaming together or successively, and executing the software transmitted in a streaming method by determining whether to cache the code modules according to correlation information between the code modules while executing the software in a terminal (for example, a personal computer). An object of the present invention is to provide a software streaming method based on correlation information between code modules and a caching method using correlation information between code modules to reduce suspension time.

3. Summary of Solution to Invention

The present invention provides a software streaming method, comprising: generating a code module for dividing software into a plurality of code modules to give correlation information; A request receiving step of receiving a software streaming request from the outside; And a streaming step of streaming the code module of the corresponding software, according to correlation information between the code modules.

4. Important uses of the invention

The invention is used in software streaming methods and the like.

Correlation information between code modules, call relationships and their proportions, profiling, software streaming

Description

Software streaming method based on correlation information between code modules and caching method using correlation information between code modules {Method for software streaming and caching according to runtime coefficient among code modules}

1 is a diagram illustrating an embodiment of a connection relationship between a software streaming server and a terminal to which the present invention is applied;

2 is a flowchart illustrating a code module generation process in the software streaming server of FIG. 1;

3 is a flowchart illustrating a software streaming method according to correlation information between code modules according to the present invention;

4 is a flowchart illustrating a caching method using correlation information between code modules in the terminal of FIG. 1.

Explanation of symbols on the main parts of the drawings

10: software streaming server 20: terminal

The present invention relates to a software streaming method based on correlation information between code modules and a caching method using correlation information between code modules according to the present invention. More particularly, when streaming software via wired / wireless communication networks, for example, When streaming a multimedia program that requires real-time, streaming together or successively according to correlation information (calling relationship, etc.) between code modules (code blocks) constituting the corresponding software, and streaming the software from a terminal (for example, a personal computer). During execution, it is determined whether to cache the code module according to the correlation information between the code modules, and according to the correlation information between the code modules to reduce the suspension time of the software transmitted by the streaming method. Software streaming room And to a caching method using the correlation information between a code module thereof.

In the present invention, the correlation information refers to information including a call relationship between code modules (code blocks) constituting one piece of software and the ratio thereof, code execution time (execution time), and the ratio thereof. Created by the ring process. The software for the profiling process may include, for example, "intel V-Tune", "Rational Rose Quantify", and "Numega True Time".

Recently, due to the development of contents such as movies and games, and the improvement of transmission capability of wired / wireless communication networks, multimedia contents are frequently streamed and viewed from a server. In this case, streaming is a technology that allows users to start watching content without downloading all of the large content.

Similarly, software streaming is a technique for streaming software installed on a server (i.e., a software streaming server) to a client (e.g., a personal computer, Net PC), and has the following differences compared to a conventional software download.

That is, the software is not duplicated or installed on the client, and the executable code and the image of the software do not exist simultaneously in the client, and the executable code of the software is temporarily stored and executed for execution.

In addition, software streaming has the following advantages due to the above characteristics. In other words, you need to have software licenses for the maximum number of users at the same time instead of the total number of users, and software maintenance, upgrades, etc. are all performed on a single server, which greatly reduces the cost of purchasing and managing software. have. In addition, since no installation process is required on the client, storage space (hard disk) can be saved, and the user can stream and execute the software at any time using a terminal (for example, NetPC) having a proper performance. There is an advantage. In particular, software streaming is attracting more attention due to the emergence of ubiquitous.

On the other hand, such a software streaming technology is to transmit one piece of software divided into a plurality of sub-units, looking at the prior art for implementing this as follows.

First, the streaming technology may be implemented in such a manner that the software is divided into modules and transmitted for each module, but the corresponding module is transmitted as the execution range shifts from the client to the untransmitted module. For example, since a Java program is composed of a plurality of class files, the streaming technology may be implemented in such a manner that the corresponding class file is transmitted to the client when the execution of each class file is required. However, in the related art, the application thereof is limited to a programming language that can be easily divided into modules such as a Java program. In particular, in the case of a Java program, a Java virtual machine must be mounted on a client. there was. In addition, since the size is not constant for each module, there is a problem that can not predict the suspension time (suspension time) in the client.

As another conventional technology, software may be divided into basic units for transmitting through a wired / wireless communication network to be streamed for each transmission unit. Here, since the size of the transmission unit is constant, the client has an advantage of having a predictable suspension time. However, since keeping and minimizing the suspension time of the software is a separate matter, there is a problem that it may not be possible to guarantee the real time of the multimedia program such as a game program.

As another conventional technique, source code corresponding to executable code of software may be transmitted for software streaming. However, in this case, there is a high possibility that a security problem occurs due to the transmission of the source code, and there is a problem that a streaming service cannot be provided when the source code is not possessed. In addition to the transmission time through the communication network, the compilation time in the client is additionally included in the suspension time, and there is a problem in that a compiler should be mounted in the client.

In addition, looking at the common problems of the prior arts, since the information on how to perform the software is not provided in the prior arts, that is, the software streaming technology according to the prior art simply transmits the module at the request of the client In this case, the same code module may be repeatedly retransmitted if any two modules call each other.

In addition, the prior art has a problem that the execution environment (for example, a loaded program, memory size) and the network speed of the client on which the software is to be executed are not considered.

The present invention has been proposed to solve the above problems, and when streaming software (for example, a multimedia program requiring real time) through a wired / wireless communication network, correlation between code modules (code blocks) constituting the software Software according to the correlation information between code modules to reduce the suspension time in the terminal running the software by streaming the code module together or successively according to the relationship information (call relationship between the code modules, etc.). The purpose is to provide a streaming method.

That is, according to the present invention, the software is decomposed into a plurality of code modules (which may be different in size) and streamed, but by preferentially streaming a code module having a high probability correlation, the arbitrary code module is executed after An object of the present invention is to provide a software streaming method based on correlation information between code modules to improve user satisfaction by reducing suspension time due to transmission delay of a code module to be executed in turn.

In addition, the present invention not only preferentially streams and executes highly correlated code modules, but also may be re-executed by using correlation information between the code modules when determining whether to cache each cache (whether cache memory is stored). Another object of the present invention is to provide a caching method using correlation information between code modules to reduce the suspension time of software by allowing caching of high code modules.

That is, the present invention minimizes the suspension time of the software by not removing code modules that are likely to be re-executed in the future by using correlation information when it is necessary to remove an arbitrary code module due to insufficient capacity of the cache memory. Another object of the present invention is to provide a caching method using correlation information between code modules to provide a caching algorithm.

Further objects and advantages of the present invention can be understood by the following description, and will be more clearly understood by the embodiments of the present invention. It will also be readily apparent that the objects and advantages of the present invention can be realized by the means and combinations thereof indicated in the claims.

According to an aspect of the present invention, there is provided a software streaming method, comprising: generating a code module for providing correlation information by dividing software into a plurality of code modules; A request receiving step of receiving a software streaming request from the outside; And a streaming step of streaming the code module of the corresponding software, according to correlation information between the code modules.

On the other hand, the method of the present invention for achieving the above object, the caching method, the execution step of executing any code module to which the correlation information is given; A confirmation step of confirming that an existing loaded code module should be removed for loading a cache memory of a new code module; A caching determination step of selecting and removing some of the previously loaded code modules by using correlation information assigned to each code module; And a loading step of loading the new code module into the cache memory.

The above objects, features and advantages will become more apparent from the following detailed description taken in conjunction with the accompanying drawings, whereby those skilled in the art may easily implement the technical idea of the present invention. There will be. In addition, in describing the present invention, when it is determined that the detailed description of the known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description thereof will be omitted. Hereinafter, exemplary embodiments of the present invention will be described in detail with reference to the accompanying drawings.

According to the present invention, code modules having a high correlation are streamed sequentially or together according to correlation information (call relationship and ratio thereof) between code modules (code blocks) so that execution of software is stopped due to delay in transmission of code modules. Minimize the suspension time.

In addition, the present invention allows to determine whether to cache the code module according to the correlation information during the execution of the software, thereby minimizing the suspension time of the software due to the caching failure. That is, code modules that are more likely to run in the future are not removed from cache memory.

1 is a diagram illustrating an embodiment of a connection relationship between a software streaming server and a terminal to which the present invention is applied.

As shown in FIG. 1, the software streaming server 10 and the terminal 20 to which the present invention is applied are connected to each other through a wired / wireless communication network (for example, wired / wireless internet), and a request of the terminal 20. According to this, the code module (code block) is streamed in real time from the software streaming server 10 to the terminal 20. In this case, the terminal 20 may be a personal computer, a NetPC, or the like.

The software streaming server 10 divides the software for the software streaming service into a plurality of code modules (code blocks), and calculates correlation information between the code modules through a general profiling process. The code module generation process will be described later with reference to FIG. 2. The calculation process of correlation information will be described in more detail as follows.

Before the software streaming server 10 registers the software as a streaming service target, the software streaming server 10 executes the binary code of the software several times using a general profiling tool to calculate correlation information between the code modules, Grant. In this case, the correlation information between the code modules includes a call relationship and its ratio (call frequency), execution time, and its ratio. That is, the correlation information provided for each code module may include a probability of being called by another code module (probability of being transferred to oneself), its execution time, and a ratio thereof.

The correlation information between the code modules is transmitted together with the code module as the corresponding code module is streamed from the software streaming server 10 to the terminal 20. This allows the terminal 20 to request the software streaming server 10 to preferentially receive a code module that is likely to be performed next time using the correlation information given to the code module being executed.

Meanwhile, the terminal 20 executes the code module that has been streamed, and at the same time, requests the software streaming server 10 to execute the code module to be executed in the future. Here, the terminal 20 is a code module that is likely to be executed next time according to the correlation information given to the currently executing code module in order to minimize the suspension time due to the transmission delay of the code module. Requesting to send to the software streaming server 10 a code module that is likely to be executed again in time.

In addition, the terminal 20 determines whether to cache the code module according to the correlation information so that the code module that is likely to be executed next time is not removed from the cache memory. For example, as a result of analyzing correlation information of any first code module that has been executed once and stored in the cache memory, and ascertains that there is a high possibility of a call from a second code module that is currently being streamed and executed soon, Rather than removing the first code module to newly load the second code module into the cache memory, other code modules are removed. As another example, if the callability is not very high, but the execution time is long, it may be implemented not to be removed from the cache memory to reduce the reload time of the corresponding code module. The caching method according to the correlation information will be described later in more detail with reference to FIG. 5.

FIG. 2 is a flowchart illustrating a code module generation process in the software streaming server of FIG. 1.

First, the software streaming server 10 searches the binary code of the software in order and allocates it to the code module (code block) line by line (201). That is, they search sequentially from the line (the first code line) located at the beginning of binary code and include them one by one in the code module.

In operation 202, it is determined whether the next line of the binary code being searched is a line including a branch instruction (call, jump, ret, etc.). That is, it determines whether a branch instruction (call, jump, ret, etc.) is found in the next binary code line.

As a result of determining whether the branch instruction is found (202), if it is not the branch instruction, it is determined whether the code module reaches the preset maximum size of the code module (203). That is, as the binary code is gradually allocated to the code module line by line, it is determined whether the code module is over-allocated. Here, the maximum threshold of the code module (code block) is a predetermined state, which may be determined according to the use environment (eg, memory size) of the client.

As a result of determining whether the code module is over-allocated (203), if not over-allocated, the binary code lines are allocated to the same code module, searched sequentially from the next line, and assigned to the code module (code block) line by line. The process proceeds to step 201.

On the other hand, if it is determined that the code module is exceeded (203), if over-allocated, it is determined whether or not the number of currently generated code modules has reached the preset maximum number of code modules (204).

As a result of determining whether the maximum number of code modules is reached (204), when the maximum number is not reached, line allocation for the same code module is stopped and the binary code line is allocated to a new code module (205). That is, the generation of one code module is completed, and a new code module is started. Then, the process proceeds to the step 201 where each line is searched sequentially and assigned to the code module (code block) line by line.

On the other hand, as a result of determining whether the maximum number of code modules has been reached (204), when the maximum number has been reached, a binary code line that has not yet been allocated to any code module is allocated to an additionally generated code module (206). . In this case, the additionally generated code module may be one or more, and is generated to be equal to or less than a maximum size of a predetermined code module. After confirming that the code module allocation for all the lines of the binary code is completed, the generation process of the code module is terminated.

On the other hand, if it is determined that the branch instruction is found 202, in the case of the branch instruction, line allocation for the same code module is stopped and the process proceeds to step 205 of allocating the corresponding line to the new code module.

After performing the code module generation process as described above, the software streaming server 10 calculates correlation information between the code modules through a normal profiling process. That is, correlation information between code modules is calculated and assigned to each code module. The software divided into a plurality of code modules is registered for the streaming service to the terminal 20.

3 is a flowchart illustrating a software streaming method based on correlation information between code modules according to the present invention.

Currently, the software streaming server 10 registers software for streaming service according to correlation information between code modules (301). That is, software consisting of each code module to which correlation information is assigned is stored in an internal / external storage space.

First, the software streaming server 10 is requested to stream the software from the terminal 20 (302).

Accordingly, the software streaming server 10 streams the first code module (code module including the first code line) of the corresponding software to the terminal 20 (303). After retrieving a code module that is highly likely to be called by the code module using correlation information (call relationship and ratio thereof, etc.) assigned to the first code module, the code module is sequentially connected to the terminal 20. Stream 304.

At this time, the code module sequentially streamed according to the correlation information as described above is streamed according to the operation of the software streaming server 10 or the request from the terminal 20. In this case, when the code module is continuously streamed according to a request from the terminal 20, the terminal 20 analyzes the correlation information given to the code module already received. If requested.

Thereafter, the streaming of the software is terminated according to a request from the terminal 20 (305).

As described in the above embodiment, the software streaming server 10 streams an arbitrary code module and subsequently streams a code module that is likely to be performed within a predetermined time according to correlation information provided to the code module. Repeatedly provide software streaming service.

In another embodiment, the software server 10 may collectively stream the highly correlated code modules together using the correlation information provided to each code module.

4 is a flowchart illustrating a caching method using correlation information between code modules in the terminal of FIG. 1. Here, since the caching of the code module is performed for the execution of the software, it will be described including the streaming process of the software.

First, the terminal 20 requests the streaming of software to the software streaming server 10 (401).

Thereafter, upon receiving the code module from the software streaming server 10 (402), it is loaded into the cache memory and registered in the cache loading module list (403). Then, the code module is executed (404). Here, registration information about a code module currently loaded in the cache memory is recorded in the cache loading module list.

Subsequently, as it is confirmed that the existing code module should be removed from the cache memory for caching of the newly received code module (405), the correlation information of the first removal target code module is used to determine the removal of the first code removal target code module. It is determined whether or not to cache (exactly, whether to remove from the cache memory) (406). That is, it is determined whether the first removal target code module has a high correlation with the newly cached code module. In this case, the first removal target code module may be selected according to an existing caching algorithm. For example, a round robin may be selected as the first removal target code module, for example, the oldest code module loaded in the cache memory.

In the caching determination result 406, if there is no caching value, that is, when the probability of the first removal target code module being re-executed within a certain time after the execution of the newly received code module is low, the first removal target code module is removed. Remove from cache memory (407). At this time, the registration information of the cache loading module list is also deleted. The newly received code module is loaded into the cache memory, registered in the cache loading module list, and executed (408).

On the other hand, the caching determination result 406, if there is a caching value, instead of removing the first removal target code module from the cache memory, the second removal target code module (which may be selected according to an existing caching algorithm). A process of determining whether or not caching is performed is performed to remove the code module having the lowest correlation with the newly received code module (410). In operation 408, the newly received code module is loaded into the cache memory, registered in the cache loading module list, and executed.

Thereafter, the streaming and execution of the software is terminated according to a request from the user (409).

In the exemplary embodiment of FIG. 4, the process of determining whether to caching by using correlation information together with an existing caching algorithm (for example, round robin) has been described. However, a newly received code module using correlation information according to the present invention is described. The higher the correlation with, the higher the priority can be implemented so that it is not removed from the cache memory.

On the other hand, the present invention by giving the correlation information calculated through the profiling process to the code module (code block) generated by the software is divided into the priority streaming and / or to determine whether to cache the code module accordingly, This has the effect of minimizing the suspension time of the software at the side.

In particular, the present invention is more easily applied to a multimedia program (eg, a game program) that requires real time, thereby improving user satisfaction.

As described above, the method of the present invention may be implemented as a program and stored in a recording medium (CD-ROM, RAM, ROM, floppy disk, hard disk, magneto-optical disk, etc.) in a computer-readable form. Since this process can be easily implemented by those skilled in the art will not be described in more detail.

The present invention described above is capable of various substitutions, modifications, and changes without departing from the technical spirit of the present invention for those skilled in the art to which the present invention pertains. It is not limited by the drawings.

According to the present invention as described above, each code module generated by dividing the software is given correlation information with other code modules, and the stream is preferentially streamed according to the correlation information, thereby stopping execution at the client side due to transmission delay. This has the effect of minimizing time.

In addition, the present invention increases the priority of the newly executed code module according to the correlation information given to the code module so as not to be removed from the cache memory by reducing its priority, thereby reducing the execution time of software. It has the effect of making it possible.

Accordingly, the present invention can be easily applied to the streaming service of the multimedia software that requires real-time, it is possible to increase the user satisfaction by reducing the execution stop time of the software.

Claims (12)

In the software streaming method, A code module generation step of dividing software into a plurality of code modules to give correlation information; A request receiving step of receiving a software streaming request from the outside; And Streaming step of streaming the code module of the corresponding software, based on correlation information between the code modules Software streaming method according to the correlation information between the code module comprising a. The method of claim 1, The correlation information is Software streaming method according to the correlation information between the code module, characterized in that it comprises a call relationship between the code module and the ratio. The method according to claim 1 or 2, The correlation information is Software streaming method according to the correlation information between the code module, characterized in that it comprises the execution time and the ratio of the code module. The method of claim 3, wherein The streaming step, A software streaming method according to correlation information between code modules, characterized by successively streaming code modules having high correlation. The method of claim 3, wherein The streaming step, A software streaming method according to correlation information between code modules, characterized in that the highly correlated code modules are collectively streamed together. The method of claim 3, wherein The code module generation step, A software streaming method based on correlation information between code modules, wherein searching for binary code starts generating a new code module when a branch instruction is found. The method of claim 3, wherein The code module generation step, A software streaming method according to correlation information between code modules, characterized in that the correlation information between code modules is calculated through a profiling process. In the caching method, An execution step of executing any code module to which correlation information has been assigned; A confirmation step of confirming that an existing loaded code module should be removed for loading a cache memory of a new code module; A caching determination step of selecting and removing some of the previously loaded code modules by using correlation information assigned to each code module; And Loading step to load new code module into cache memory Caching method using correlation information between code modules including a. The method of claim 8, The correlation information is A caching method using correlation information between code modules, the call relationship among code modules and a ratio thereof. The method according to claim 8 or 9, The correlation information is Caching method using correlation information between code modules, characterized in that it comprises the execution time and the ratio of the code module. The method of claim 10, The caching determination step, The first method of selecting the removal target code module according to the existing caching algorithm, and the caching method using the correlation information between the code modules, characterized in that the final selection whether or not caching according to the correlation information of the selected removal target code module. The method of claim 10, The caching determination step, A caching method using correlation information between code modules, wherein any code module having the lowest correlation with a code module to be newly loaded is removed by using the correlation information of each previously assigned code module. .

Images