KR20110032278A - A method for managing memory in an embedded system - Google Patents

A method for managing memory in an embedded system Download PDF

Info

Publication number
KR20110032278A
KR20110032278A KR1020090089683A KR20090089683A KR20110032278A KR 20110032278 A KR20110032278 A KR 20110032278A KR 1020090089683 A KR1020090089683 A KR 1020090089683A KR 20090089683 A KR20090089683 A KR 20090089683A KR 20110032278 A KR20110032278 A KR 20110032278A
Authority
KR
South Korea
Prior art keywords
font
memory
embedded system
application
executed
Prior art date
Application number
KR1020090089683A
Other languages
Korean (ko)
Inventor
황희선
Original Assignee
엘지전자 주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 엘지전자 주식회사 filed Critical 엘지전자 주식회사
Priority to KR1020090089683A priority Critical patent/KR20110032278A/en
Publication of KR20110032278A publication Critical patent/KR20110032278A/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F12/00—Accessing, addressing or allocating within memory systems or architectures
    • G06F12/02—Addressing or allocation; Relocation
    • G06F12/08—Addressing or allocation; Relocation in hierarchically structured memory systems, e.g. virtual memory systems
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • G06F13/14—Handling requests for interconnection or transfer
    • G06F13/16—Handling requests for interconnection or transfer for access to memory bus
    • G06F13/1605—Handling requests for interconnection or transfer for access to memory bus based on arbitration
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • G06F13/14—Handling requests for interconnection or transfer
    • G06F13/16—Handling requests for interconnection or transfer for access to memory bus
    • G06F13/1605—Handling requests for interconnection or transfer for access to memory bus based on arbitration
    • G06F13/1652—Handling requests for interconnection or transfer for access to memory bus based on arbitration in a multiprocessor architecture
    • G06F13/1663—Access to shared memory
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2453—Query optimisation

Abstract

The present invention relates to a memory management method of an embedded system, and more particularly, to a method of managing memory allocated for a font when an application uses a downloadable font in an embedded system, such as a digital TV. According to the present invention, in an embedded system, an application may release and allocate a font memory on its own without being interfered with by an operating system.

Embedded System, Font, Memory, MHP, Allocation, Free, Application, FontFactory

Description

A METHOD FOR MANAGING MEMORY IN AN EMBEDDED SYSTEM

The present invention relates to a method of managing an embedded system.

More particularly, the present invention relates to a memory management method of an embedded system, and more particularly, to a method of managing memory allocated for a font when an application uses a downloadable font in a system such as a digital TV. .

In general, an embedded system refers to a system for processing a specific purpose task using limited resources. For example, a mobile phone, which is a typical embedded system, limited resources mean size, memory and battery capacity, and specific purpose work means call processing for communication.

As the embedded system uses limited resources, it is essential to manage and operate it efficiently. Efficient management is especially important for memory resources, which are used for almost all of the limited resources.

The Multimedia Home Platform (MHP) is a standard that standardizes the home platform elements that provide interactive multimedia services. MHP is used as a basis in various interactive systems such as Advanced Common Application Platform (ACAP), Blu-ray Disc Java (BDJ), Open Cable Application Platform (OCAP), and Internet Protocol TV (IPTV).

The embedded system including the MHP provides only a method of executing the memory for the font used in the application, but does not provide a method of releasing the font, and thus there is a problem in that the application cannot efficiently use the memory.

Font instances use the system's font resources in addition to the Java heap resources. Embedded systems have limited memory resources, and fonts are objects that use a lot of these resources.

An object of the present invention is to provide a memory management method for an application of an embedded system.

The present invention provides a means for releasing memory in a memory-related class for applications of an embedded system.

An object of the present invention is to provide a means for releasing memory in an application of an embedded system, so that various fonts can be efficiently used in terms of system resource management.

According to an embodiment of the present disclosure, a memory management method of an embedded system in which a font memory is limited may include: detecting a font execution request during application execution; Checking the memory capacity allocated for the font; Releasing the memory allocated to the font which is already executed when the memory capacity is exceeded when the font is executed; And executing the font requested to be executed.

According to an embodiment of the present invention, a computer-readable storage medium for managing a memory of an embedded system having a limited font memory includes: font instance generating means for generating a font instance; Font positioning means on which the font instance to be created is based; Font execution means for executing the font instance; And font memory releasing means for releasing memory allocated to the executed font instance.

According to an embodiment of the present invention, a computer-readable storage medium for managing a memory of an embedded system in which a font memory is defined may include: font execution means; And font memory releasing means.

According to the present invention, by providing a means for releasing the memory to the application running in the embedded system, the application can efficiently use the system resources of various fonts without interference from the operating system.

According to the present invention, it is possible to solve the problem that the font memory is arbitrarily released by the operating system when the application uses the additional font.

Embodiments of the present invention will now be described in more detail with reference to the drawings.

1 is a block diagram of an embedded system according to an exemplary embodiment of the present invention.

As shown in FIG. 1, the embedded system according to an embodiment of the present invention stores a control unit 11, an operating system (OS), middleware, an application, etc. for controlling the overall operation, or an execution space (RAM space) when an application is executed. A memory 13 for providing a memory, a mass storage system 12 for storing middleware, an application or data, an I / O device 14 for receiving a command from a user and outputting data, and a network such as the Internet. It may include a network module 15 for downloading data such as an application from a server or the like through.

The embedded system according to an embodiment of the present invention may be a digital TV equipped with a network module to enable bidirectional communication.

The control unit 11 controls the overall operation of the embedded system according to an embodiment of the present invention, executes a program running in the memory 13, loads an application program or data stored in the mass storage medium 12, and executes a network The module 15 is controlled to download data, an application program, firmware, and the like from an external server. The controller 11 may be a general-purpose processor or a processor in which an instruction set (IS) is built in.

The memory 13 is a storage medium that provides a working space when an application program is executed or stores data or an application program. The memory 13 includes a flash memory type, a hard disk type, and a multimedia card micro type ( multimedia card micro type), card type memory (e.g. SD or XD memory, etc.), random access memory (RAM), random random access memory (SRAM), read-only memory (ROM), electrically (EPROM) Erasable Programmable Read-Only Memory (PROM), PROM (Programmable Read-Only Memory) may include at least one type of storage medium of a magnetic memory, a magnetic disk, an optical disk.

The mass storage medium 12 is a storage medium having a relatively larger capacity than the memory 13, and a hard disk type storage medium is preferable. According to an embodiment, when the capacity of the memory 13 is large, the mass storage medium 12 may be omitted.

When the mass storage medium 12 is omitted, an area of the memory 13 may be divided into a work area (RAM area) and a storage area as shown in FIG. 2.

The I / O device 14 provides a means (output device) for the user to input a command (input device) or output information to the user in the embedded system according to the present invention. The input device may include any input device such as a keyboard, a mouse, a remote controller, a trackball, a joystick, a touch screen, and the like. The output device may include any output device such as a display such as a monitor and a speaker. The display includes a liquid crystal display (LCD), a plasma display panel (PDP), an electro luminescent display (ELD), a vacuum fluorescent display (VFD), especially when the embedded system is a broadcast receiving device such as a TV, and the input device includes a remote control. The output device may include a display and a speaker.

The network module 15 provides a means for the embedded system to perform bidirectional communication such as receiving data from the outside and transmitting a query. The network module 15 provides a TCP / IP connection means through the Internet when the embedded system is a network TV capable of an internet network such as an IP TV or a broadband TV. According to an embodiment of the present invention, the embedded system may download an application program or necessary font data through the network module 15.

The digital TV equipped with the network module 15 may be manufactured according to various international standard standards to provide bidirectional communication. For example, MHP (Multimedia Home Platform) is a standard for standardizing home platform elements for providing interactive multimedia services in digital TV.

MHP is used as a basis in various interactive systems such as Advanced Common Application Platform (ACAP), Blu-ray Disc Java (BDJ), Open Cable Application Platform (OCAP), and Internet Protocol TV (IPTV).

These interactive systems are typically embedded systems that limit system resources such as memory by usage. For example, the BDJ specification defines the minimum requirements for the amount of memory that must be provided by middleware for graphics resources for efficient use of memory, so that applications must manage and use memory so that it does not go beyond that range. A typical case is memory for an image, and the application implements the function properly using APIs for creating and releasing the image so that it does not exceed the minimum amount defined in the specification for the image.

The standards described above limit the size of memory that can be used as memory for fonts, similar to images, and running additional fonts limits the execution of fonts in the system's operating system or removes fonts that are already running. This will limit the memory allocated to the font. That is, memory management cannot be performed at the application level, and the operating system only limits the memory based on the allocated memory limit.

MHP-based systems can download applications when the network is connected. In addition to the basic fonts provided by the system, the application may download and use fonts through a network. The font instance created by the downloaded font uses the system's font related resources in addition to the java heap resources.

Embedded systems have limited memory resources, and fonts use these limited memory resources. In addition, memory is a resource that affects the price of a TV or the like configured as an embedded system.

Thus, the standards underlying the embedded system provide several means for managing the memory used by applications. These means can be mounted on top of each system's operating system in the form of middleware.

For example, in an MHP-based system, Org.dvb.ui is a package that defines the extended functionality of graphics in the MHP package. The FontFactory provides a means for applications to install and use fonts that are not built into the system, that is, the operating system.

FontFactory is defined by two constructors and one function. The two constructors are distinguished by the way they give information about the font file to be installed when creating a font instance. One is to tell the location of the font file directly, and the other is to tell the File including the location and information of the font file. One function takes the parameters of the actual font file's style, size, and logical name, and creates a font instance.

The application creates a FontFactory instance using the constructor above, and then obtains a font instance through one of its functions. We use this object to display text on the screen. Conventionally, the application may execute additional fonts using the above means.

When the additional font is executed using the above means, the memory is allocated through the method as shown in FIG.

Referring to FIG. 3, when an application requests memory allocation to use an additional font in addition to a font currently used, the middleware receives the request and delivers the request to an operating system (OS). If the operating system determines that the memory allocated to the font is exceeded when the memory used for the font is checked and the requested memory is allocated, the operating system forcibly releases the memory allocated to the previously executed font and then releases the requested memory. Assign it. In some cases, memory allocation may be denied if the specified memory capacity is exceeded.

However, since the conventional FontFactory does not provide a means for releasing the memory for the font, when the memory capacity is exceeded, the operating system intervenes to release the memory of any font already executed.

4 illustrates a font memory allocation method according to an embodiment of the present invention.

Referring to FIG. 4, when an application wants to execute an additional font, it is determined whether the memory capacity is exceeded when the additional font is executed. If it is determined that the limit is exceeded, first, a font to be used which is not to be used or a font which is less used is selected and the memory allocated to the font is released. The middleware passes the release request to the operating system, which releases the memory allocated for that font. Then, when requesting additional memory allocation for the font to be used, the middleware passes it to the operating system to allocate memory for the additional font. As described above, in the font memory allocation method according to the present invention, the application may manage any font memory by itself without being interfered with by the operating system. This avoids the problem of the operating system forcibly freeing memory allocated to fonts that are already running.

The method according to the invention can be applied to the FontFactory of an MHP package.

To do this, define a function that can selectively release the memory of the font already running in the FontFactory as follows to allow the application to request the release of memory on its own.

Frees the memory resources used by the font passed in as a parameter, and returns true if the font is freed correctly. If the font is not a downloaded font and is a system font, do nothing and return false.

According to an embodiment of the present invention, a flushFont method for releasing a font memory may be added to a FontFactory Class of org.dvb.ui as follows.

public class FontFactory

{

Public FontFactory (); // constructor function

Public FontFactory ( java . Net . URL u); // constructor function containing the location of the font to create

Public java . awt . Font createFont ( String font name , int style , int size ); // font instantiation function

Public boolean flushFont (java.awt. Font font ); // font memory release function

}

The following is an example of a program in which an application obtains a list of downloadable fonts existing on the server side and installs one of the font lists when needed. According to the program below, two fonts are executed in sequence, and when the third font is called, the memory allocated to one of the previously executed fonts is freed and then executed. You can code in the following programming languages.

// install and use the first font

FontFactory fontfactory = new  FontFactory (availableFonts [5]);

// availableFonts [5] indicates the font file location.

Font font1  = fontfactory . createFont (“ Mystyle ”, Font . PLAIN , 10);

// Function to install font. Mystyle is the font name, Font.PLAIN is the font style, and 10 is the Font size

Graphcis  g = hscene . getGraphics ();

// function to get an object for drawing on the screen, an object that represents the screen abstractly

g. drawString (“ FontFactory test example … … ”, 100, 100);

// FontFactory test example… … Function to write

// install and use the second Font

fontfactory = new  FontFactory (availableFonts [2]);

Font font2  = Fontfactory . createFont (“ Mystyle2 ”, Font . PLAIN , 15);

g. drawString (“ FontFactory test example2 … … ”);

fontfactory . flushFont ( font1 ); // Release the memory allocated to the first installed font for installing and using the third font.

// install and use the third Font

fontfactory  = new  FontFactory (availableFonts [7]);

Font font3  = Fontfactory . createFont (“ Mystyle3 ”, Font . PLAIN , 15);

g. drawString (“ FontFactory test example3 … … ”);

Through the above method, in an embedded system where only two fonts are available, the application determines whether the memory will be exceeded if additional fonts are used by itself, and selectively releases the less frequently used fonts. After that, you can run additional fonts.

5 illustrates a memory allocation method for fonts in an embedded system according to an exemplary embodiment of the present invention.

In step S51, the application is executed in the embedded system. The application may be any application such as a game, and is an application using at least one font.

In step S52, the application detects a memory allocation request for additional fonts. In step S53, when executing a font to be additionally executed in the application itself, it is checked whether the memory capacity allocated to the font is exceeded. If it is determined in step S54 that the memory capacity is exceeded, then in step S55, the memory of one of the fonts already being executed is released. In step S56, the additional font is executed and ends. If it is determined in step S54 that no additional memory is executed even if the additional font is executed, the font is immediately executed and terminated in step S56.

1 is a block diagram of an embedded system according to an exemplary embodiment of the present invention.

2 illustrates a memory divided into a work area (RAM area) and a storage area according to an exemplary embodiment of the present invention.

3 illustrates a font memory allocation method in an embedded system according to the related art.

4 illustrates a font memory allocation method in an embedded system according to an embodiment of the present invention.

** Description of the main parts of the drawing **

11: control unit

12: mass storage media

13: memory

14: I / O Device

15: network module

Claims (10)

In the memory management method of an embedded system with limited font memory, Detecting a font execution request during application execution; Checking the memory capacity allocated for the font; Releasing the memory allocated to the font which is already executed when the memory capacity is exceeded when the font is executed; And And executing the font requested to be executed. The method of claim 1, And the font of which the memory is to be released is a font detachable from the embedded system. The method of claim 1, The step of releasing the memory, Calling a font memory release function. The method of claim 1, The font memory release function uses an ID of the font to be released as an input value. A computer-readable storage medium for managing memory of an embedded system in which font memory is limited,  Font instance generating means for generating a font instance; Font positioning means on which the font instance to be created is based; Font execution means for executing the font instance; And Font memory releasing means for releasing memory allocated to the executed font instance; Computer-readable storage medium comprising a. The method of claim 5, And the font memory release function uses as input an ID of a font to be released. The method of claim 5, And the font from which the memory is to be released is a font detachable from the embedded system. A computer-readable storage medium for managing memory of an embedded system in which font memory is limited, Font execution means; And A computer readable storage medium comprising font memory releasing means. The method of claim 8, And the font memory releasing means is a function of using, as an input value, an ID of a font to be released. The method of claim 8, And the font from which the memory is to be released is a font detachable from the embedded system.
KR1020090089683A 2009-09-22 2009-09-22 A method for managing memory in an embedded system KR20110032278A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1020090089683A KR20110032278A (en) 2009-09-22 2009-09-22 A method for managing memory in an embedded system

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020090089683A KR20110032278A (en) 2009-09-22 2009-09-22 A method for managing memory in an embedded system

Publications (1)

Publication Number Publication Date
KR20110032278A true KR20110032278A (en) 2011-03-30

Family

ID=43937050

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020090089683A KR20110032278A (en) 2009-09-22 2009-09-22 A method for managing memory in an embedded system

Country Status (1)

Country Link
KR (1) KR20110032278A (en)

Similar Documents

Publication Publication Date Title
KR101116615B1 (en) Resource management system and method for applications and threads in JAVA Virtual Machine
JP7018463B2 (en) Managing the delivery of code and dependent data using the application container
US8732287B2 (en) System for managing a virtualization solution and management server and method for managing the same
JP5147728B2 (en) Qualitatively annotated code
US7840967B1 (en) Sharing data among isolated applications
US20150195272A1 (en) Extension point application and onfiguration of a login module
JP2008524686A (en) Method for maintaining an application in a computer device
US8332759B2 (en) Apparatus and method for converting the visual appearance of a Java application program in real time
US8191041B2 (en) Javascript pre-processing framework
CN112702647B (en) Play control method, intelligent television and computer readable storage medium
CN105404522A (en) Method for building intelligent terminal application program, device for building intelligent terminal application program and intelligent terminal
JP5013999B2 (en) Image forming apparatus, program control method, and control program
JP2009037589A (en) Program determining apparatus, program determining method and program
JP6070423B2 (en) Information processing apparatus, information processing method, and program
KR101950485B1 (en) Task Management Method for Providing Real-time Performance to Android
US9571687B2 (en) Image forming apparatus and resource management method
US20150286474A1 (en) Information processing apparatus capable of controlling installation of application, method of controlling the same, and storage medium
KR20110032278A (en) A method for managing memory in an embedded system
CN102819443B (en) Method and device for compatible operation of PCI (peripheral component interconnection) hardware applications
KR101095426B1 (en) Method for execurting xlet application and recording medium
JP4976329B2 (en) Device capable of executing additional program, failure analysis support method, and failure analysis support program
KR101950484B1 (en) Task Management Device for Providing Real-time Performance to Android
JP2004334679A (en) Information processor, program execution method of information processor, and storage medium recording the program execution method of information processor
KR101103795B1 (en) Method for providing software virtualization system using portable medium
JP5798973B2 (en) Apparatus and method for executing a plurality of programs whose processing states change

Legal Events

Date Code Title Description
A201 Request for examination
E902 Notification of reason for refusal
AMND Amendment
E601 Decision to refuse application
AMND Amendment