KR101950484B1 - Task Management Device for Providing Real-time Performance to Android - Google Patents

Abstract

According to the present invention, disclosed is a device for managing a task of Android in real time capable of processing a task of Android in real time. The device comprises: an application processing unit processing an operation at an application level related to at least one application performing user operation; an operating system processing unit including an Android operating system for executing the application and performing an operation at an operating system level; and a middleware mediating the application processing unit and operating system processing unit and controlling garbage collection for time required for a real-time operation.

Description

[Background Art] [0002] A task management device for providing real-time performance to Android [

The present invention relates to a real-time task management apparatus for Android, and more particularly, to a real-time task management apparatus for Android that controls execution of garbage collection.

Systems such as military inspection equipment where it is important to acquire and evaluate data in real time should be capable of real-time processing at the operating system level.

There are many ways to improve the real-time performance of windows in the conventional Windows operating system, but there is no technology using the same method in Android.

In addition, RTAndroid has the disadvantage of extensively modifying the existing Linux kernel to apply the RT_PREEMPT patch, because the latest Android kernel patches have not yet been integrated into the mainline kernel, and RTDroid has been able to rebuild all of Android's systems from scratch , The maintenance of the Android version may be difficult due to the continuous development.

The present invention relates to an application processing unit for processing an application level operation related to at least one application for performing a user task using a real-time task management apparatus and a management method of the Android, and an Android operating system for executing an application, An application processing unit, and an operating system processing unit, and middleware mediates garbage collection during a time required for real time operation, thereby enabling real time task processing of Android.

Another purpose is to design and implement a structure that controls the execution of garbage collection of Android, thereby controlling garbage collection during the time required for real-time operation.

Other and further objects, which are not to be described, may be further considered within the scope of the following detailed description and easily deduced from the effects thereof.

According to an aspect of the present invention, there is provided an apparatus for real-time task management of Android according to an embodiment of the present invention, comprising: an application processing unit for processing an application level operation related to at least one application performing a user task; An operating system processing unit including the Android operating system and performing an operation at the operating system level; the application processing unit; and middleware mediating the operating system processing unit. The middleware controls garbage collection during a time required for real time operation.

Here, the middleware includes an application framework processing unit for accessing an application programming interface (API) written in Java necessary for executing the application, an application framework processing unit for performing an operation at a library level that is modified at the top of the operating system processing unit, And a runtime processing unit for performing memory management and multithreading using a library processing unit and a Dalvik virtual machine (Dalvik VM).

Here, the operating system processing unit provides an environment in which the application can be executed through the Dalvik VM and the application framework processing unit based on the Linux kernel.

Here, the operating system processing unit includes a real-time implant kernel (RTiK) module used for real-time control of the Linux kernel, and the real-time processing module provides a real-time timer function in the area of the Linux kernel do.

Here, the Dalvik VM includes a garbage collection controller for controlling the execution of the garbage collection, and the garbage collection operation method is implemented using a Concurrent Mark Sweep (CMS) algorithm , The garbage collection control unit determines whether to execute the garbage collection according to a specific flag value at the time when the garbage collection should be executed in order to secure available memory in the Dalbig virtual machine.

Here, the library processing unit includes a real-time API layer (RTiK-API's layer) that provides the real-time timer function provided by the real-time processing kernel (RTiK) module to the application, The layer (RTiK-API's layer) controls the real-time processing module (Real-Time implant Kernel, RTiK) module using a module control function.

The module control function includes a task control function for controlling the task of the Android through the real-time implant kernel (RTiK) module and the real-time processing module (Real-Time implant Kernel, RTiK) And a timer control function for commanding the start or end of the module.

Here, the application processing unit further includes a real-time API class (RTiK-APIs Class) written in Java that controls the real-time processing module (Real-Time Implant Kernel, RTiK) , And accesses the real-time processing kernel (RTiK) module through the real-time API layer (RTiK-API's layer).

Here, the real-time API layer (RTiK-API's Layer) includes a native library for accessing the real-time processing kernel (RTiK) module, and the real-time API class (RTiK-APIs Class) And a function capable of accessing the real-time processing module through a native library, wherein the function capable of accessing the real-time processing module includes a function for accessing the RTiK-API's layer, (Java Native Interface) function.

Here, the library processing unit creates a task in the native library area using a Pthread library for real-time task execution.

Here, the runtime processing unit may further include a Linux file processing unit including a save file for storing whether the garbage collection execution of the Dalvik VM is executed, and the Dalbik virtual machine is capable of accessing the save file on the code .

Here, the garbage collection control unit may include a read unit for reading the data of the storage file in the process of initializing the Dalvik VM, a value read from the read unit to the flag variable A flag variable checking unit for checking the flag variable value set at a time when the garbage collection is required, and a garbage collection execution determiner for determining the garbage collection performance according to the flag variable value.

Here, the garbage collection execution determination unit does not execute the garbage collection when the flag variable value is 1, and executes the garbage collection when the flag variable value is 0.

As described above, according to the embodiments of the present invention, an application processing unit for processing an application level operation related to at least one application performing a user task, and an Android operating system for executing an application, An application processing unit, and middleware that mediates the operating system processing unit. The middleware can control the garbage collection during the time required for the real time operation, thereby enabling real time task processing of the Android.

In addition, by designing and implementing a structure that controls Android's garbage collection execution, it is possible to control garbage collection during the time required for real-time operation.

Therefore, through the development of a localized real-time portable kernel capable of verifying the performance, it is possible to reduce equipment development, maintenance and repair costs used for the development of a dedicated terminal, and secure IPR for a real-time operating system.

Even if the effects are not expressly mentioned here, the effects described in the following specification which are expected by the technical characteristics of the present invention and their potential effects are handled as described in the specification of the present invention.

1 and 2 are views showing a real-time task management apparatus for Android according to an embodiment of the present invention.
3 is a block diagram showing a runtime processing unit of the real-time task management apparatus of the Android according to an embodiment of the present invention.
4 is a diagram illustrating a garbage collection control unit of the real-time task management apparatus of the Android according to an embodiment of the present invention.
5 is a flowchart illustrating a method for managing a real-time task of the Android according to an embodiment of the present invention.
FIG. 6 is a diagram illustrating a method for managing a real-time task of the Android according to an embodiment of the present invention.
FIG. 7 is a graph illustrating a change in a paging cycle according to an exemplary embodiment of the present invention. Referring to FIG.
8 and 9 are graphs illustrating changes in heap size according to an embodiment of the present invention.

Hereinafter, a real-time task management apparatus for Android according to the present invention will be described in detail with reference to the drawings. However, the present invention can be implemented in various different forms, and is not limited to the embodiments described. In order to clearly describe the present invention, parts that are not related to the description are omitted, and the same reference numerals in the drawings denote the same members.

It is to be understood that when an element is referred to as being "connected" or "connected" to another element, it may be directly connected or connected to the other element, .

The suffix " module " and " part " for the components used in the following description are given or mixed in consideration of ease of specification, and do not have their own meaning or role.

The terms first, second, etc. may be used to describe various elements, but the elements should not be limited by terms. The terms are used only for the purpose of distinguishing one component from another.

The present invention relates to a real-time task management apparatus for Android.

1 and 2 are views showing a real-time task management apparatus for Android according to an embodiment of the present invention.

Android is a mobile platform, defined as a software stack that includes the operating system, middleware, and core applications. The Android platform has a stack structure as shown in FIG.

Although the processing unit of the present invention is illustrated as being performed independently, it may be implemented in different processors, or may be implemented in a single process.

1, the real-time task management apparatus 10 of the Android according to an embodiment of the present invention includes an application processing unit 100, an application framework processing unit 200, a library processing unit 300, a runtime processing unit 400, And an operating system processing unit 500.

The real-time task management device 10 of the Android is a management device capable of real-time processing for acquiring and evaluating data in real time at the operating system level.

It can be used in portable terminals using the Android operating system, which requires real-time fire control or monitoring equipment available on the battlefield.

Systems such as military inspection equipment where it is important to acquire and evaluate data in real time should be capable of real-time processing at the operating system level. Although there is a demand for replacing existing devices with portable terminals due to the development of technology, portable terminals employing Android are not suitable for systems requiring real-time properties. On Android, garbage collection ensures free memory, while other tasks are interrupted while this task is being performed, which can not guarantee the periodicity of a particular task. The real-time task management apparatus 10 of the Android according to an embodiment of the present invention controls real-time performance by controlling garbage collection for a time required for real-time work, and real time implant kernel (RTiK) To be applied.

The application processing unit 100 processes application level operations related to at least one application that performs a user task.

The operating system processing unit 500 includes an Android operating system for executing an application and performs the operation at the operating system level.

The operating system processing unit 500 is located at the bottom of the stack structure and is a Linux kernel, which is the basis of the Android platform. The Linux kernel provides system functions such as process and memory management and security features. It also manages the network interface and the device driver to facilitate interface with peripheral hardware.

An application processing unit, and middleware that mediates an operating system processing unit. The middleware includes an application framework processing unit 200, a library processing unit 300, and a runtime processing unit 400.

The middleware controls garbage collection during the time required for real-time operation.

The application framework processor 200 accesses an API (Application Programming Interface) written in Java necessary for executing an application.

The application framework is accessible as an API written in Java and provides a variety of high-level services to Android applications.

The library processing unit 300 exists at the top of the operating system processing unit 500 and performs a modified library level operation according to the Android environment.

The library processing unit 300 is located at the top of the Linux kernel and includes a set of C / C ++ libraries. The library includes Bionic, a C library (libc) modified for the Android environment, audio and video, graphics, browser, and SQLite.

The runtime processing unit 400 performs memory management and multithreading using the Dalvik VM.

The runtime processing unit 400 is a Dalvik virtual machine, and is designed to be optimized for Android on behalf of the Java virtual machine. The Dalvik virtual machine takes full advantage of Linux for memory management and multithreading.

The Dalvik virtual machine is a runtime system used up to the Android KitKat (API 19) version. Garbage collection also occurs independently because each application runs in a separate virtual machine. The Dalvik virtual machine resides in a process managed by the Linux kernel.

The Dalvik VM includes a garbage collection control unit for controlling the execution of garbage collection. The garbage collection operation method is implemented using a concurrent mark sweep (CMS) algorithm, Determines whether to execute the garbage collection according to a specific flag value when the garbage collection is to be executed in order to obtain available memory in the Dalbig virtual machine.

Concurrent Mark Sweep (CMS) algorithm is as follows. First, all the mutator threads are stopped at the beginning of the collection cycle, and then the reachable objects referenced in the heap root stack are found and marked (Initial Mark). After restarting the suspended mutator threads, mark the objects marked in the previous step by following the objects they refer to and mark them as Concurrent Marks. At the end of this phase, the garbage collector again stops all mutator threads.

The concurrent marking in the previous step was done with the mutator thread's actions, so Remark checks again for newly added or dropped references. It then restarts the mutator threads and performs garbage collection of the unmarked objects (Concurrent Sweep).

Android applications written in the Java language run on the Dalvik virtual machine, and the Dalbig virtual machine manages the memory using the Garbage Collection (GC) to obtain available memory.

The real-time task management apparatus 10 of the Android according to the embodiment of the present invention designs and implements a structure for controlling the execution of garbage collection on the Android, thereby executing garbage collection so as to minimize the interruption time of the real- Is used. In addition, RTiK is improved and applied to provide real-time performance in Android environment.

The operating system processing unit 500 provides an environment in which applications can be executed through the Dalvik virtual machine (Dalvik VM) and the application framework processing unit 200 based on the Linux kernel.

2 illustrates an RT stack structure added to the real-time task management apparatus of the Android according to an embodiment of the present invention.

The Android operating system uses the Linux kernel and has a stack structure for running the Android framework. Accordingly, although RTiK-AL developed for real-time control in embedded Linux can be used, an interface and a control structure for using RTiK-AL module in Android operating in a virtual machine are required.

As shown in FIG. 2, the real-time task management apparatus of the Android according to an embodiment of the present invention adds RTiK-API's Layer and RTiK-APIs Class as a method for providing real-time performance in the stack structure of Android.

Referring to FIG. 2, the operating system processing unit 500 includes a real-time implant kernel (RTiK) module 510 used for real-time control of the Linux kernel.

The real-time processing module 510 provides a real-time timer function in the area of the Linux kernel.

The library processing unit 300 is a library area for controlling the real-time processing kernel (RTiK) module 510.

And a real-time API layer (RTiK-API's Layer) 310 that provides the real-time timer function provided by the real-time implant kernel (RTiK) module 510 to the application.

The real-time API layer (RTiK-API's layer) 310 controls the real-time processing kernel (RTiK) module using a module control function.

The module control function operates the task control function and the real-time timer for controlling the task of the Android through the real-time implant kernel (RTiK) module to start the real-time implant kernel (RTiK) module And a timer control function for commanding termination.

The RTiK-Module, used for real-time control in the Linux kernel, provides real-time timer functionality in the kernel domain. The RTiK-APIs layer is provided as an intermediate interface to provide this to Android applications. Provides module control functions for accessing the kernel via ioctl for RTiK-Module control provided as a Linux kernel module. Table 1 lists the module control functions of the RTiK-APIs layer for module control functions.

Three module control functions for task control are provided to provide real-time performance of tasks through a real-time implant kernel (RTiK) module 510. Provides task response checking function to reduce the overhead of real-time task registration and deactivation function and system.

In addition, it provides two functions that enable the real-time processing (Real-Time Implant Kernel, RTiK) module 510 to be started and terminated by operating a real-time timer after task registration. This provides an interface function that can provide real-time properties to the user area. The Android operating system registers the RTiK-APIs layer in the Native C / C ++ Library area through the NDK (Native Development Kit) to use the interface function written in the cpp language in the user application so that it can be accessed from the Android user area.

The library processing unit 300 generates a task in a native library area using a Pthread library for real-time task execution.

Existing Android Java threads provide priorities, but Linux uses the dynamic priority method with Nice values, which limits the limitations of real-time tasks. To solve this problem, the real-time task management apparatus 10 of the Android according to an embodiment of the present invention creates a task in a native library area using a Pthread library. Specifically, thread is created through pthread through rtik_task_create () function. At this time, the priority is adjusted to perform setting for the real-time task. In addition, it provides arguments through which functions can be registered for calls to various user functions.

The data structure for user function registration allows the user to specify a function type with two parameters arbitrarily so that various functions created by the user can be executed. This enables real-time tasks to be provided to the user area.

The application framework processor 200 accesses an API (Application Programming Interface) written in Java necessary for executing an application.

The application processing unit 100 includes a real-time API class (RTiK-APIs Class) 110 written in Java that controls a real-time implant kernel (RTiK) module.

A real-time API class (RTiK-APIs class) 110 accesses the real-time implant kernel (RTiK) module through a real-time API layer (RTiK-API's layer)

A real-time API layer (RTiK-API's Layer) 310 includes a native library for accessing real-time processing kernel (RTiK) modules.

A real-time API class (RTiK-APIs class) 110 provides a function for accessing the real-time processing module via a native library, and a function capable of accessing the real- A JNI protocol 210 using a Java Native Interface (JNI) function is used for accessing a real-time API layer (RTiK-API's Layer).

The Android operating system provides services to users through applications running on virtual machines. Accordingly, in order to control a real-time module, a class written in Java is required. Specifically, the library is read into memory through a System.loadLibrary () function for information transmission between Java and cpp for accessing a real-time API layer (RTiK-API's Layer) 310 written in the cpp language, and four The functions are shown in Table 2.

Initialize the basic data structure inside the Native Library function provided by JNI using initialization function. It also provides a command function for timer management, and provides a response wait function for real-time task execution synchronization.

This makes it possible to connect the Java realm to the cpp realm and control the module in the Android application.

3 is a block diagram showing a runtime processing unit of the real-time task management apparatus of the Android according to an embodiment of the present invention.

If garbage collection is not performed through execution control to minimize downtime due to garbage collection, garbage will remain in the heap memory and the memory space can not be used by other objects. Thus, whenever memory allocation is requested, the available memory becomes insufficient frequently, and the size of the heap memory continuously increases. Therefore, the time at which garbage collection execution is deactivated should be limited to the specific time at which the real-time task is executed. In other situations, it is necessary to allow garbage collection to be executed.

The garbage collection execution control structure of the real-time task management apparatus of the Android according to an embodiment of the present invention is a modified version of the Dalvik virtual machine of the Android. In the case of the execution of the garbage collection, The value is determined according to the value.

The Android application is compatible with Linux processes and runs on its own Dalvik virtual machine instance. The Dalvik virtual machine is created and initialized and run by the Zygote process. The Zygote process loads the code and memory information necessary for the execution of the application into the memory in advance, and quickly executes the new application when it is executed.

Referring to FIG. 3, the runtime processing unit 400 includes a Linux file processing unit 410 and a Dalvik VM 430.

The runtime processing unit 400 performs memory management and multithreading using the Dalvik VM 430. [

The Dalvik virtual machine (Dalvik VM) includes a garbage collection control unit 600 that controls the execution of garbage collection.

The behavior of garbage collection is implemented using a Concurrent Mark Sweep (CMS) algorithm.

The garbage collection control unit 600 determines whether to execute the garbage collection according to a specific flag value at the time when the garbage collection should be executed in order to secure available memory in the Dalvik virtual machine.

The Linux file processing unit 410 includes a storage file for storing whether or not the Dalvik VM (Garbage Collection Execution) is executed.

The Dalvik VM 430 is accessible to the storage file on the code.

4 is a diagram illustrating a garbage collection control unit of the real-time task management apparatus of the Android according to an embodiment of the present invention.

The Dalvik virtual machine (Dalvik VM) includes a garbage collection control unit 600 that controls the execution of garbage collection.

The garbage collection control unit 600 determines whether to execute the garbage collection according to a specific flag value at the time when the garbage collection should be executed in order to secure available memory in the Dalvik virtual machine.

Referring to FIG. 4, the garbage collection control unit 600 includes a read unit 610, a flag variable setting unit 620, a flag variable verifying unit 630, and a garbage collection execution determining unit 640.

The read unit 610 reads data of the storage file in the process of initializing the Dalvik VM.

The flag variable setting unit 620 sets the value read from the read unit to the flag variable.

The flag variable verifying unit 630 checks the flag variable value set at a time when garbage collection is required.

The garbage collection execution determination unit 640 determines whether the garbage collection execution is performed according to the flag variable value. More specifically, if the flag variable value is 1, the garbage collection is not executed. If the flag variable value is 0, the garbage collection is executed.

5 is a flowchart illustrating a method for managing a real-time task of the Android according to an embodiment of the present invention.

Referring to FIG. 5, a real-time task management method for Android that performs memory management and multithreading using a virtual machine

The Linux file processing section starts with a step S100 in which a storage file for storing whether or not the virtual machine executes garbage collection is included.

In step S200, the garbage collection control unit determines whether to execute the garbage collection according to the specific flag value at the time when the garbage collection should be executed for securing available memory in the virtual machine.

More specifically, the step S200 of determining whether to execute according to the specific flag value,

In step S210, the read unit reads data of the storage file in the process of initializing the virtual machine.

In step S220, the flag variable setting unit sets the value read from the read unit to the flag variable.

In step S230, the flag variable confirmation unit checks the flag variable value set at the time when the garbage collection is required.

In step S240, the garbage collection execution determination unit determines the execution of the garbage collection according to the flag variable value.

In step S240, the garbage collection is executed if the flag variable is 1, and the garbage collection is executed if the flag variable is 0, and the real-time task management method of the Android is ended.

6 is a diagram illustrating a method for managing a real-time task of the Android according to an exemplary embodiment of the present invention.

Zygote The Dalbig virtual machine creates and initializes the Dalbig virtual machine instances of all the processes in the system, and determines whether garbage collection is executed or not. To do this, I put a file that stores the execution status of the garbage collection and put it in the Linux file system so that I can access the files on the Dalvik virtual machine code. During the initialization of the Dalvik virtual machine, the value is read from the file and set to the flag variable GC_DISABLED. This process controls the execution of garbage collection of all Dalvik virtual machines in the Android system.

FIG. 6 shows a process of determining whether to execute garbage collection after setting a flag value for whether garbage collection is executed when the Dalvik virtual machine is initialized. When garbage collection is required, execution depends on the value of the GC_DISABLED variable. The variable GC_DISABLED indicates whether the garbage collection of the Dalvik virtual machine is executed. If the value is 1, it means that garbage collection is not executed. If the value is 0, it is executed.

The Dalvik virtual machine calls the dvmCollectGarbageInternal function when garbage collection is needed to identify garbage objects that can not be reached, and reclaim memory space occupied by garbage.

In the existing Dalvik virtual machine code, a function for controlling the execution of the garbage collection is implemented. Table 3 shows a list of functions for controlling the execution of the garbage collection.

Here, the getGCstatus () function is a getter function for the GC_DISABLED variable and returns a variable value, and the setGCstatus () function is a setter function of the GC_DISABLED variable. Since the value of the variable is set by reading the value from the file, the dvmGcExecSetup function is called to write the value received as argument to the file.

The dvmGcExecSetup function sets whether to execute garbage collection on a file, and writes the value received as an argument to a file.

The dvmExecGetValue function reads a value from a file and sets the value to the GC_DISABLED variable.

FIG. 7 is a graph illustrating a change in a paging cycle according to an exemplary embodiment of the present invention. Referring to FIG.

FIG. 7 illustrates a real-time performance difference according to the garbage collection execution control of the real-time task management apparatus and method of the Android according to the embodiment of the present invention. FIG. 7 (a) And FIG. 7 (b) shows a situation in which garbage collection is applied, and the results are shown through experiments in two situations.

The experiment compares the value of the task call cycle with the deactivation through the garbage collection execution control and the activation in order to confirm the periodicity satisfaction of the task having the 5 ms cycle.

7A is an experimental result of measuring a call period of a task when the garbage collector is not activated because the garbage collection control is not performed.

Before the control of garbage collection, the number of times that the data exceeded 10ms is 386 times 7.72%, and the number of calls that are less than 4.5ms is 2120 times, 42.41%. On the other hand, the cycle range of 4.5 ms to 5.5 ms within the 10% error range represents 3415%, which is 1715 times. These experiments show that if you enable garbage collection, you will not be able to satisfy real-time performance at all.

FIG. 7 (b) is an experimental result of measuring a task call period when the garbage collector is inactivated during the time required for real-time through garbage collection control.

When the garbage collection is deactivated, the task call interval exceeding 10 ms has been reduced by one. In addition, when the data showing the call interval is also expressed in the range of 4.5 ms to 5.5 ms within the error range of 10% of the data, The validity frequency was 4908, which was 98.18%. This means that the garbage collector can be controlled by controlling the garbage collector much more than when the existing garbage collector is activated.

8 and 9 are graphs illustrating changes in heap size according to an embodiment of the present invention.

FIG. 8 and FIG. 9 illustrate the real-time performance difference according to the garbage collection execution control of the real-time task management apparatus and method of the Android according to the embodiment of the present invention. When the UDP socket communication of 10 ms cycle is performed for 30 minutes It measures the heap memory size over time.

FIGS. 8A and 8B are graphs showing measured data when an ArrayList is used, and FIGS. 9A and 9B are graphs when a silver array is used. The measured data x axis represents the point at which the heap memory is increased, and the y axis is the heap memory size in MB.

In the case of using ArrayList and array for data reception, the size of the heap continuously increases because there is not enough available memory in a situation where garbage collection does not occur through execution control. However, we confirmed that no memory-related errors were caused by the garbage collection not being executed during 30 minutes of communication. In a situation where garbage collection is executed, garbage collection occurs to obtain available memory required for allocation, and heap memory does not increase relatively large.

In this way, it is possible to satisfy real-time task cycle by using garbage collection control to provide real-time property to Android, and it can be confirmed that memory access time can be reduced so that there is no influence on real-time task performance.

It will be apparent to those skilled in the art that various modifications and variations can be made in the present invention without departing from the spirit or scope of the invention. Therefore, the scope of the present invention is not limited to the above-described embodiments, but should be construed to include various embodiments within the scope of the claims.

10: Android real-time task management device
100: Application processor
200: Application framework processor
300: Library processor
400: Runtime processor
500: Operating system processor
600: Garbage collection control unit

Claims (13)

An application processing unit for processing an application level operation related to at least one application performing a user operation; An operating system processing unit including an Android operating system for executing the application, the operating system processing unit performing an operating system level operation; Middleware for mediating the application processor and the operating system processor; Wherein the middleware controls garbage collection for a time required for real time operation,
Wherein the middleware comprises: an application framework processing unit accessing an API (Application Programming Interface) written in Java necessary for executing the application; And a runtime processing unit for performing memory management and multithreading using a Dalvik VM,
The operating system processing unit provides an environment in which an application can be executed through the Dalvik VM and the application framework processing unit based on a Linux kernel and performs real-time processing Real-Time implant Kernel, RTiK) modules,
Wherein the real-time processing module provides a real-time timer function in an area of the Linux kernel. The method according to claim 1,
The middleware comprises:
And a library processing unit which is located at the top of the operating system processing unit and performs a library level operation modified according to the Android environment. delete delete 3. The method of claim 2,
The Dalvik VM includes a garbage collection controller for controlling the execution of the garbage collection,
The garbage collection operation method is implemented using a Concurrent Mark Sweep (CMS) algorithm,
The garbage collection control unit,
And determines whether to execute the garbage collection according to a specific flag value when the garbage collection is to be executed in order to secure available memory in the Dalbig virtual machine. 3. The method of claim 2,
The library processing unit,
And a real-time API layer (RTiK-API's Layer) that provides the real-time timer function provided by the real-time processing kernel (RTiK) module to the application,
The real-time API layer (RTiK-API's Layer)
Real-time processing module (RTiK) module is controlled using the module control function. The method according to claim 6,
Wherein the module control function comprises:
A task control function for controlling the task of the Android through the real-time processing kernel (RTiK) module; And
And a timer control function for operating the real-time timer to command start or end of the real-time processing kernel (RTiK) module. The method according to claim 6,
The application processing unit,
And a real-time API class (RTiK-APIs Class) written in Java for controlling the real-time processing kernel (RTiK) module,
Wherein the real-time API class (RTiK-APIs class) accesses the real-time processing kernel (RTiK) module through the real-time API layer (RTiK-API's layer) . 9. The method of claim 8,
The real-time API layer (RTiK-API's layer) includes a native library for accessing the real-time processing kernel module (RTiK)
The real-time API class (RTiK-APIs Class) provides a function capable of accessing the real-time processing module through a native library,
Wherein the function capable of accessing the real-
Wherein the JNI protocol using a Java Native Interface (JNI) function is used for accessing the real-time API layer (RTiK-API's Layer). 10. The method of claim 9,
The library processing unit,
Wherein a task is created in the native library area using a Pthread library for real-time task execution. 6. The method of claim 5,
The run-
And a Linux file processing unit including a save file for storing whether the garbage collection of the Dalvik VM is executed or not,
Wherein the Dalvik virtual machine is accessible on the code in the storage file. 12. The method of claim 11,
The garbage collection control unit,
A read unit for reading data of the storage file in the process of initializing the Dalvik VM;
A flag variable setting unit for setting a value read by the read unit as a flag variable value according to the specific flag value;
A flag variable verifying unit for verifying the flag variable value set at a time when the garbage collection is required; And
And a garbage collection execution determiner for determining execution of the garbage collection according to the flag variable value. 13. The method of claim 12,
Wherein the garbage collection execution determination unit determines,
Wherein the controller executes the garbage collection when the flag variable value is 1 and executes the garbage collection when the flag variable value is 0.

Images