JP3299294B2 - Memory block control method - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a memory allocation control method in an information processing apparatus having an operating system that supports multi-programming.

In an operating system (OS) that supports multi-programming, it is necessary to promptly search for an allocatable memory and perform allocation in response to a memory reservation request from a user program. In that case,
It is desired to efficiently use a memory area for a user managed by an OS and to allocate and release necessary memory blocks at high speed.

[0003]

2. Description of the Related Art FIG. 12 is an explanatory view of Conventional Example 1, and FIG. 13 is an explanatory view of Conventional Example 2. In the method of Conventional Example 1 shown in FIG. 12, the user area of the memory is divided into pages of a fixed size (for example, 4 KB: kilobytes) and managed as shown in (1). Each of these pages P0, P1, P2, P3 ...
Are assigned and stored as a0, a1, a2, a3,... As shown in (2), to provide a bit map. This bitmap stores “1” when the page is in use and “0” when the page is not used.
FIG. 12 (3) shows an example in which bit information indicating the actual use state is stored in the bit map. When there is a memory reservation request from the user, the OS detects an unused page by referring to the bitmap shown in (3), and
Assign that page.

Next, the method of the conventional example 2 shown in FIG. 13 will be described. A memory is divided into blocks having a size required by a user. For each block, the start address of the block to be linked next, information on the use state (used / unused), and information indicating the size of the block are stored in the management area of the block, and are subsequently used in that block. A data area is provided, and each block has the same configuration. The block associated with the link of the first address is in use at the beginning of the link, and there is an unused block at the end of the link.

[0005] The order of linking is independent of the physical address of the memory. In the case of the second conventional example, when there is a memory reservation request from the user, the OS searches for an unused block according to the link of the start address, finds an unused block, and allocates the unused block to the user.

[0006]

In the above-described method of managing by the bitmap of the first conventional example, the memory allocation unit is limited to the management unit of the OS, and a size larger or smaller than necessary is allocated. There is. Further, there is a problem that it takes time to search for a free memory because a bitmap is always searched.

In the conventional method of storing the address, size, and the like indicating the head of a linked block in the management area in the second conventional example, although there is a degree of freedom with respect to the memory allocation unit, free memory is used from the used memory area. Since the search is performed, there is a problem that it takes more time to search for a free memory than the management by the bitmap.

SUMMARY OF THE INVENTION It is an object of the present invention to provide a memory block control method which can allocate and release a memory block at a high speed while giving a degree of freedom to a memory allocation size.

[0009]

FIG. 1 is a basic configuration diagram of the present invention. In FIG. 1, reference numeral 1 denotes a processing unit, 2 denotes a bit map, 3 denotes a queue header (indicated by PQH) of a queue composed of a memory page being used, and 4 denotes a memory.

In the processing unit 1, reference numeral 10 denotes a bit map control unit (BMC), reference numeral 13 denotes a memory page control unit (MPC),
7 is a memory block control unit (MBC). The bitmap control unit 10 includes a free page search unit (BMC0) 11 for controlling acquisition of a free memory page and a page unused setting unit (BMC1) 12 for releasing a memory page. Memory page link unit (MPC0) 14, memory page unlink unit (MP
C1) 15 and a memory page checking unit (MPC2) 16, and the memory block control unit 17 includes a reservation request control unit (MBC0) 18 and a release request control unit (MBC1) 19.
And

The bit map 2 holds each memory page to be managed corresponding to each bit.
Each represents a memory page pointer. In an initial state, all bits b0 to bn are "0".

The memory 4 is composed of memory pages (MP) 5 having a fixed size. Each memory page 5 has a plurality of memory blocks (MB) having a size desired by the user.
Consists of six.

Each memory page (MP) 5 first has a bidirectional (forward and backward) link pointer (PQ) 5a for forming a queue based on the used memory pages, and thereafter a used memory block number counter (PQ). UCNT) 5b
And a queue header (BQH) 5c that indicates the head of a queue composed of unused memory blocks.

Each memory block (MB) 6 has a bidirectional link pointer (BQ) 6a for forming a queue with unused memory blocks (MB) at the head and a head of a memory page including its own memory block. Pointer (QP) 6b, and a data area (MBD) 6c of a memory block that can be used by the user program thereafter
Is arranged.

According to the present invention, there is provided a memory map for managing use / non-use of a memory in a memory management unit (memory page) of a fixed size, and a bidirectional link pointer and a memory page constituting a memory page queue in the memory page. A divided area (memory block) is provided, and a block number counter indicating the used amount, a bidirectional link pointer forming a memory block queue, and a pointer indicating a head of a memory page where the memory block exists are provided. In response to a memory reservation request from a user program, a memory that can be allocated is quickly searched for and allocated by means controlled by these units.

[0016]

In response to a reservation request or a release request from a program, the processing unit 1 of FIG.
Memory page controller 13 and memory block controller 17
It is realized by combining necessary components from the mechanisms provided for each of the components. Hereinafter, functions of each unit provided in each control unit will be described.

A free page search unit (BMC0) 11 of the bitmap control unit 10 searches the bitmap 2 upon request to detect a bit in a 0 state (unused), and a memory page (MP) corresponding to the bit. A memory page pointer (referred to as an MP pointer), which is the address of the head position of, is returned to the request source, and if there is no 0-state bit, the request source is notified that there is no unused memory page.

The page unused setting section (BMC1) 12 of the bitmap control section 10 sets a bit in the bitmap (BM) 2 corresponding to the memory page indicated by the memory pointer designated by the request source to "0". Set to "".

The memory page link unit (MPC0) 14 of the memory page control unit 13 performs the following processing upon request. The memory page specified by the requester by the MP pointer is stored in the page queue header (PQ) also specified by the requester.
H) and the link pointer (P
Q) links to the end of the used memory page queue.

The memory page 5 specified by the requester by the MP pointer is divided into memory blocks having the same size as specified by the requester, and a used memory block number counter (UCN) 5b is initialized to zero.

An unused memory block queue is constituted by an unused memory block queue header (BQH) 5c in a designated memory page and a bidirectional link pointer (BQ) 6a in each memory block for all divided memory blocks 6. .

A designated MP pointer is set to a pointer (QP) 6b indicating the head of a memory page including each memory block provided in all the memory blocks 6.
The memory page unlinking unit (MPC1) 15 of the memory page control unit 13 converts the memory page specified by the requester with the MP pointer by the request from the memory page queue in use by the memory page bidirectional link pointer (PQ) 5a. Unlink (unlink).

The memory page inspection unit (MPC2) 16 of the memory page control unit 13 calculates the total number of memory blocks of one memory page by using the memory block size specified by the request source in response to the request (size of one page / specified memory). The program size is calculated), the used memory page queue (bidirectional link pointer PQ) 5a is searched by the page queue header (PQH) 3 specified by the request source, and the used memory block number counter (UCNT) 5b is In this case, the MP pointer which is within the total number of memory blocks in the memory is returned to the request source, and if there is no such memory page, the fact is notified.

Next, the reservation request control unit (MBC0) 18 of the memory block control unit 17 performs the following processing upon request. A request is generated to the memory page checking unit (MPC2) 16 using the page queue header (PQH) 3 specified by the request source, and within the number of memory blocks specified by the request source using the used block number counter (UCN) 5b. Of the memory page (MP pointer).

If there is a memory page having a used memory block number counter (UCNT) within the total number of memory blocks in the memory page (all the memory blocks are not in use), the following processing is performed.

(1) Unlink the head memory block indicated by the queue header (BQH) 5c of the unused memory block in the returned memory page from the queue. (2) The used memory block number counter (UCN) 5b in the memory page indicated by the returned MP pointer is incremented by 1 and updated.

(3) A pointer (MB pointer) indicating the head of the unlinked memory block is returned to the request source. If there is no memory page having a used memory block number counter (UCNT) within the total number of memory blocks in the memory page, the following processing is performed.

(1) The empty page search section (BMC)
0) A request is issued to 11 to obtain the MP pointer of the memory page corresponding to the bit in the 0 state in the bit map.

(2) A request is issued to the MP unlink unit (MPC1) 15 using the obtained MP pointer and the page queue header (PQH) specified by the request source, and the obtained M
Link P to the end of the busy MP queue.

(3) A request is issued to the memory page inspection unit (MPC2) 16 using the PQH specified by the request source, and the used memory block number counter (UCN) 5b determines the memory block size specified by the request source. An MP pointer corresponding to a memory page having room to accommodate is acquired. Thereafter, the same processing as the above (1) to (3) is performed.

In the above (1), when it is notified that there is no bit in the 0 state in response to the issuance of the request to the empty page search unit (MBC0) 11, the request source is notified of the allocation failure.

The release request control unit (MBC1) 19 of the memory block control unit 17 performs the following processing according to the request. With the pointer (QP) 6b in the memory block 6 specified by the MB pointer by the request source, the MP pointer of the memory page in which the specified memory block exists is acquired.

The bidirectional link pointer (BQ) 6a in the designated memory block 6 and the queue header (BQ) in the memory page 5 indicated by the acquired MP pointer
H) 5c links the specified memory block to the unused MB queue.

The used memory block number counter (UC) in the memory page indicated by the acquired MP pointer
NT) 5b is decremented by one and updated. When UCNT is 0, a request is issued to the memory page unlink unit (MPC1) 15 using the acquired MP pointer, and the memory page indicated by the MP pointer is in use.
The link is unlinked from the P queue, and then a request is issued to the page unused setting section (BMC1) 12, and the bit in the bitmap 2 corresponding to the memory page indicated by the MP pointer is set to 0.

In FIG. 1, when a user program wants to secure a memory area of a desired size, a page queue header (PQH) and a size to be secured are provided to a securing request control unit (MBC0) 18 of a memory block control unit 17. Issue a request with

In response, the securing request control unit (MBC0)
The memory 18 controls the memory page link unit (MPC0) 14, the memory page check unit (MPC2) 16, and the empty page search unit (BMC0) 11, and finally the memory of the memory block that can be used for the user program. Returns the block pointer (address).

To release the memory area, the release request control unit (MBC1) 19 issues a request to the release request control unit (MBC1) 19 by designating the memory block pointer of the memory block to be released. It controls the page unlink section (MPC1) 15 and the page unused setting section (BMC1) 12 to release the specified memory block.

When a memory reservation request of the same size is issued from a program, the initial request and unused memory blocks are eliminated, and in most cases, except for the case where a new memory page is required, the queue can be operated quickly. Memory can be secured.

Similarly, when a memory release request of the same size is issued, all the memory blocks in the memory page including the released memory block become unused, and only when the memory page itself is released, the line is executed only by the queue operation. As a result, the memory can be quickly released.

Further, since the user block has a plurality of page queue headers (PQH), it is possible to secure and release memory blocks of different sizes for each page queue header.

[0041]

FIG. 2 is a diagram for explaining the relationship between each subroutine for securing and releasing control of a memory and a user program, and FIG. 3 is a diagram showing the configuration of a memory according to the present invention.

In FIG. 2, reference numeral 20 denotes an operating system (OS) of the processing device.
BC1 • 19 are subroutines in the OS, and correspond to the respective units of the same reference numerals in FIG. Reference numeral 21 denotes a user program (UP) of the processing device. PQH0 and PQH1 are different page queue headers, which are used when a user program requests to secure and release a memory.

BMC0 (free page search unit) 1 in OS
1, MPC0 (memory page link unit) 14 and MPC
2 (memory page checker) 16 is called by MBC0 (reservation request controller) 18, BMC1 (page unused setting unit) 12, MPC1 (memory page unlink unit)
15 is called from the MBC 1 (release request control unit) 19. MBC0 (secure request control unit) 18 and MBC1
(Release request control unit) 19 is a user program (UP) 2
Called from 1.

As shown in FIG. 3, a memory (indicated by MM)
Is divided into pages MP0 to MPn. Each page is composed of a plurality of memory blocks MB having a size requested by the user.
B00 to MB0m (example divided into m pieces). At the beginning of each page, taking memory page MP0 as an example, PQ0 (bidirectional link pointer of page queue), UCNT0 (used memory block number counter), and BQH0 (unused memory block) corresponding to 5a to 5c in FIG. The memory block MB00 has BQ00 (a bidirectional link pointer of an unused memory block queue), QP00 (a pointer indicating the head of a memory page) and MBD00 (a memory corresponding to 6a to 6c in FIG. 1). Block data area). The same information is stored in other memory blocks MB01 to MB0m, and the other memory pages MP1 to MPn have the same configuration as MP0 as shown in FIG.

Next, FIGS. 4 to 9 show flowcharts of subroutines provided in the OS 20 shown in FIG. 4 is a processing flow of the empty page search unit (BMC0), FIG. 5 is a processing flow of the page unused setting unit (BMC1), FIG. 6 is a processing flow of the memory page link unit (MPC0), and FIG. 8 is a process flow of the memory page checking unit (MPC2), FIG. 8 is a process flow of the reservation request control unit (MBC0), and FIG. 9 is a process flow of the release request control unit (MBC1).

In FIG. 4, a free page search unit (BMC)
0) starts without an input parameter, and an MP (memory page) start address is obtained as an output. When activated, the “0” bit of the bitmap BM is searched (S
1), the searched “0” bit (obtains a free memory page) is set to “1” (S2). From the bit position of the bit of the search result, the corresponding MP head address is calculated (S3), the calculated MP head address is set as an output parameter, and the process ends (S4).

In FIG. 5, a page unused setting section (BM
C1) is a process in which the MP start address is specified as an input parameter and there is no output generated. When activated, the bit position in the corresponding bitmap is calculated from the MP start address specified by the input parameter, and the bit located in the calculated bitmap is set to “0”.
Set to.

Next, the memory page link section (M
PC0) uses P as an input parameter at the time of a start request.
When a QH start address, a memory page (MP) start address, and a memory block (MB) size are specified, the corresponding memory pages are linked, and a plurality of memory blocks (unused) of the size specified in the page are formed. Each control information is set in each memory block.

When activated, a PQ address (a bidirectional link pointer of a page queue) is acquired from the memory using the MP head address specified as an input parameter (S1). The MP designated as an input parameter is linked to the page queue header (PQH) designated by the acquired PQ address (S2). As a result, the memory page having the specified MP start address is added to the used page queue (PQ).

Next, the MB specified by the input parameter
The number of memory blocks in one memory page is calculated according to the size (S3), and 0 is set to a used memory block number counter (UCNT) in the MP similarly designated (S3).
4). This is because the memory block of this page is unused at this time.

Thereafter, the designated memory page is divided into the calculated number of memory blocks (S5).
The bidirectional link pointer (BQ) of the unused memory block queue in each divided memory block is obtained (S
6). Based on the acquired BQ address (pointer), all memory blocks are linked to the queue header (BQH) of an unused memory block in the memory page (S7). By the processing of S5 to S7, all the memory blocks in the memory page are made empty.

Next, the QP in each divided memory block
An address at which (the top address of the memory page to which the own memory block belongs) is to be stored (S8), the memory page top address is set to the QP in all the memory blocks at each of the obtained addresses (S9), and the process ends.

The link configuration of the queue of the used memory page and the queue of the unused memory block and the like executed in the processing of the above memory page link unit is shown in FIG. 10 and FIG.
1 will be described.

FIG. 10 shows an example in which two queues, queue 1 and queue 2, are formed, and this state is referred to as a state before linking. At this time, a bidirectional pointer is formed in the link header by a forward link indicating the pointer of the first queue 1 of the queue and a backward link indicating the pointer of the last queue 2 of the queue. A queue 1 is provided at a position indicated by a forward link in the link header, and a bidirectional link is similarly stored therein. A queue 2 is provided at a position indicated by the forward link of the queue 1 as shown in FIG. ing. FIG. 11 shows a configuration in which another queue (for example, a used memory page or an unused memory block) is newly added as a link target queue in this state.

That is, as shown in FIG. 11, the address of the link target queue is set to the forward link of the current link header, and the contents of the forward link stored in the link header in the state before the link (FIG. 10). Is set as the forward link of the link target queue. Also, queue 1 before link
Set the contents of the back link (pointer of the link header) stored in the back link of the link target queue,
The address of the link target queue is set in the backward link of the queue 1.

Next, the memory page unlink section (MPC
The processing flow of 1) is shown in FIG. In this process, when a memory page (MP) head address to be unlinked is specified as an input parameter, the memory page is unlinked from the in-use memory page queue. The unlinking operation in this case is described in FIGS.
This corresponds to an operation reverse to the operation of the link described in FIG. 1 (operation for changing the state of FIG. 11 to the state of FIG. 10).

Upon activation, the PQ address (bidirectional link pointer) in the memory page is obtained from the specified MP start address (S1 in A of FIG. 7), and the obtained PQ
The MP specified based on the address is unlinked from the PQH (S2).

Next, the processing flow of the memory page inspection section (MPC2) will be described with reference to FIG. When the PQH start address (the address where the PQH is stored) and the required memory block size are specified as input parameters,
A search is made for a memory page to which a specified memory block size can be assigned, and if detected, an MP start address is output, and if not detected, a search result to that effect is output.

FIG. When the memory page inspection unit is activated, the size of one memory page is divided by the designated (requested) memory block size to calculate the total number of memory blocks (this is z) (S1 in FIG. 7B). ). Note that the specified memory block size may or may not match the size of one memory block (MB) provided in a memory page that has already been used. Determines if the memory size is specified in minutes.

Next, based on the specified PQH start address, the UCNT address in each memory page used sequentially is acquired (S2). UCNT in each memory page is determined based on the obtained UCNT address, and UC
A search is made for a memory page in which the value of NT does not match the calculated number of memory blocks (z) in one memory page (only when UCNT> z) (S3). As a result of this search, if the corresponding memory page cannot be searched, the search NG
(Failure) is set as an output parameter (S4, S
5) When the corresponding memory page is searched, the start address and search OK (success) are set as output parameters (S6, S7), and the process ends. The output parameter is notified to the requester.

The processing flow of the reservation request control unit (MBC0) shown in FIG. 8 is started by a memory reservation request from a user program. The PQH start address and the memory block size are specified as input parameters, and the start address of the secured memory page is output as a result of the processing of the reserve request control unit.

In FIG. 8, first, a memory page inspection unit (MPC2: see FIG. 7B) is activated to search for a memory page having a memory block of a requested size (S1). As a result of this search, if there is no corresponding memory page (NG), a free page search unit (MBC0: FIG.
) To secure a new free memory page (MP) (S3). Next, the MP link unit (MPC0: see FIG. 6) is activated to initialize the secured memory page (MP) with a memory block of the requested size to create a free memory block (S4). Thereafter, the memory page inspection unit (MPC2: see FIG. 7B) is started again to search for a memory page having an empty memory block (S
5). In this case, a free memory page having a memory block of the requested size is searched because a free MB has already been created.

Subsequent to the above steps (S2, S5), the address of the BQH (block queue header) in the memory page is obtained based on the MP start address which is the searched result (S6), and Unlink the linked top memory block from the unused link (S
7), the head address of the unlinked memory block is set as an output parameter (S8).

Next, the release request control unit (MBC) shown in FIG.
The processing flow of 1) is started by a memory release request from a user block, similarly to the above-mentioned reservation request control unit. The start address of the memory block to be released is specified as an input parameter.

When activated, the BQ address (the position where the bidirectional link pointer of the unused memory block queue is stored) in the memory block is acquired based on the first specified memory block start address (S1). The QP address in the memory block (the position where the pointer indicating the beginning of the memory page is stored) is obtained (S2). The head address of the memory page is obtained from the obtained QP (S3), and based on this, the BQH address in the memory page (storage position of the queue header of the unused memory block)
Is acquired (S4).

Next, the designated memory block is linked to the BQH based on the BQ address acquired in S1 (S5), and the UCNT address in the MP is acquired based on the MP head address acquired in S3 (S6). , That U
The content of the CNT is updated to −1 (S7). continue,
It is determined whether the updated UCNT is 0 (S8). If the updated UCNT is not 0, the process is terminated. If it is 0, the memory page unlink unit (MP
C1: start the memory page from the PQH (S9), and further activate the page unused setting section (BMC1: see FIG. 5) to release the memory page from the bitmap. (S10).

Now, the operation of the embodiment will be described with reference to a specific example. User program shown in FIG. 2 (hereinafter referred to as UP)
However, when a memory block of x1 bytes (x1 is sufficiently smaller than the MP size) is secured using PQH0, the following operation is performed. Refer to FIG. 3 for the memory page and the memory block code used in the description.

(1) UP is PQH0 as an input parameter
Is set and the numerical value x1 (request block size) is set, and the reservation request control unit (MBC0) is called. (2) MBC0 takes over the input parameters from UP as it is, and calls the memory page checking unit (MPC2).

(3) MPC2 calculates PQ, U from MP size.
After subtracting the sizes of CNT and BQH, the number is divided by x1 to calculate the total number z1 of memory blocks in the memory page. (4) MPC2 uses PQH0 as a queue header and
Search for an MP whose NT is not z1.

(5) In the initial state, since the used MP queue is empty, the search fails, and the MPC 2 returns 0. (6) Since 0 has been returned from the MPC 2, the reservation request control unit (MBC0) calls the empty page search unit (BMC0) to reserve a new MP.

(7) Since the bitmap is all 0 in the initial state, BMC0 selects b0 (the first bit of the bitmap), and as a result, the corresponding memory page 0 (MP
0) is returned.

(8) The MBC0 sets the input parameters from the UP and the start address of the MP0 returned from the BMC0 as input parameters, and sets the memory page link section (M
Call PC0).

(9) MPC0 links MP0 to PHQ0. (10) MPC0 has PQ,
After subtracting the size of UCNT and BQH (excluding the size of the control information) and dividing by x1, the total number z1 of memory blocks in the MP is calculated.

(11) MPC0 is BQH0 in MP0,
Memory block 00 with the start address following BQH0
(MB00, see FIG. 3). Hereinafter, all MBs up to MB0m are linked to form an unused MB queue.

(12) MPC0 sets the QP (QP0) in all MBs.
0 to QP0m), set the start address of MP0, and end the process. (13) MBC0 calls MPC2 as in (2) above.

(14) According to the above (6) to (12), MP0 having an unused MB is linked, so that MPC2
Returns the start address of (15) The MBC0 unlinks the head unused MB (MB00) linked to the BQH0 in the MP0 by the returned head address of the MP0.

(16) MBC0 returns the start address of MB00 to UP. Thereafter, when the UP further secures the second x1 byte memory block (MB) using PHQ0, after performing the above (1) to (4), the search succeeds in (5). (15) and (16) are performed.

The same operation as described above is performed when an MB having a memory block size of x2 bytes is secured by using PQH1. Next, x1 byte MB from the initial state
After securing (MB00), releasing the secured MB is performed as follows.

(1) The UP sets the start address of MB00 as an input parameter, and the release request control unit (MBC1)
Call. (2) MBC1 starts with MB00 from the start address of MB00.
BQ00 in MB00 and P from QP00 in MB00
Get the start address of Q0. Further, BQH0 is obtained from the head address of PQ0.

(3) MBC1 links MB00 to an unused MB queue in MP0 by BQ00 and BQH0. (4) MBC1 updates UCNT0 in MP0.

(5) Since only MB00 is currently reserved, UCNT0 becomes 0. (6) Since UCNT0 is 0, MBC1 sets the start address of MP0 as an input parameter to release MP0, and calls the MP unlink unit (MPC1).

(7) MPC1 sets the head address of MP0 as an input parameter and calls BMC1. (8) MBC1 sets the start address of MP0 as an input parameter and calls BMC1.

(9) The BMC 1 resets the bit b0 in the corresponding BM from the start address of MP0 to 0, and ends the processing. (10) The MBC 1 ends the processing and returns to the UP.

When the MB is released after securing two x1 byte MBs, after performing the above (1) to (4), UCNT0 does not become 0 in (5). U
Return to P.

[0085]

According to the present invention, it is possible to secure memories of different sizes, and in addition to the general requirement of securing memory for user blocks (securing a plurality of memory areas of the same size), In this case, high-speed processing can be realized because the allocation / release of the memory block is performed only by the queue operation.

In particular, in recent years, microprocessors have been enriched in memory management in units of size (generally several kilobytes) peculiar to each computer, and have been equipped with a queue operation function at a higher speed. It is considered that the effect of the present invention is further increased when a memory page is set in units of a size unique to a computer.

[Brief description of the drawings]

FIG. 1 is a basic configuration diagram of the present invention.

FIG. 2 is an explanatory diagram showing a relationship between each subroutine for memory allocation / release control and a user program.

FIG. 3 is a configuration diagram of a memory according to the present invention.

FIG. 4 is a processing flow of a free page search unit (BMC0).

FIG. 5 is a processing flow of a page unused setting section (BMC1).

FIG. 6 is a processing flow of a memory page link unit (MPC0).

FIG. 7 shows a processing flow of a memory page unlinking unit (MPC1) and a processing flow of a memory page checking unit (MPC2).

FIG. 8 is a processing flow of a reservation request control unit (MBC0).

FIG. 9 is a processing flow of a release request control unit (MBC1).

FIG. 10 is an explanatory diagram of a link configuration of a queue (before linking).

FIG. 11 is an explanatory diagram of a link configuration of a queue (after linking).

FIG. 12 is an explanatory diagram of Conventional Example 1.

FIG. 13 is an explanatory diagram of Conventional Example 2.

[Explanation of symbols]

DESCRIPTION OF SYMBOLS 1 Processing part 2 Bitmap 3 Queue header (PQH) of a queue composed of used memory pages 4 Memory 10 Bitmap control part (BMC) 11 Free page search part (BMC0) 12 Page unused setting part (BMC1) 13 Memory page control unit (MPC) 14 Memory page link unit (MPC0) 15 Memory page unlink unit (MPC1) 16 Memory page check unit (MPC2) 17 Memory block control unit (MBC) 18 Reserve request control unit (MBC0) 19 Release Request control unit (MBC1)

──────────────────────────────────────────────────続 き Continuation of the front page (72) Inventor Katsunori Hoshida 1-6, Uchisaiwaicho, Chiyoda-ku, Tokyo Nippon Telegraph and Telephone Corporation (56) References JP-A-3-34042 (JP, A) Hei 1-209546 (JP, A) (58) Fields investigated (Int. Cl. ⁷ , DB name) G06F 12/00-12/06

Claims (3)

(57) [Claims] In an information processing apparatus having a processing unit supporting multi-programming, a memory is divided into a plurality of memory pages of a predetermined size, and each memory page is divided into a plurality of memory blocks having a size required by a user. Each memory page is divided into a bidirectional link pointer (PQ) for configuring the memory page queue in use, a counter (UCNT) indicating the number of currently used memory blocks, and a queue header (BQH) of unused memory blocks. Each memory block includes information and a plurality of memory blocks. Each memory block includes information of a bidirectional link pointer (BQ) constituting a queue of unused memory blocks and a pointer (QP) of a memory page to which the memory block belongs. Data storage area (MB
D), wherein a bitmap representing the use state of each memory page by one bit is provided, and the processing unit generates a bitmap control unit for controlling the bitmap, a memory page control unit for controlling the memory page, and a user program. A memory block control unit that secures or releases a memory block requested by driving the bitmap control unit and a memory page control unit in response to a request for securing or releasing memory to be performed. control method. 2. A free page search unit according to claim 1, wherein the bit map control unit searches an unused memory page from the bit map upon request and outputs a memory page pointer. A page unused setting unit for setting a bit of a corresponding memory page to an unused state, wherein the memory page control unit links a designated memory page and a memory block size to a queue of used memory pages. A page link unit, a memory page unlink unit that unlinks a specified memory page from a busy memory page queue, and a memory page check unit that generates a memory page pointer that includes a memory block having a required condition A memory block control method, characterized in that: 3. The memory block control unit according to claim 2, wherein the memory block control unit is activated by a request specifying a size of a memory block and a page queue header by a user program. And a securing request control unit that drives a checking unit to secure and output a free memory block of a requested size, and activates the memory block by using a request in which the address of the memory block is specified by a user program. In addition to linking and releasing the block with the block queue, the counter indicating the number of used memory blocks is updated, and when the counter value is 0, the memory page unlink section and the page unused setting section are driven to release the specified memory block. A memory block control method, comprising: a release request control unit.