JP2009116712A - Image forming apparatus - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To reduce a delay on heap memory allocation by reducing frequency of garbage collection. <P>SOLUTION: When two or more pages of a display list remain (S52), it can be estimated that a display list for one page may be soon released, and after the number of remaining pages is decreased and an event is generated (S53), the process returns to step S50. On the other hand, when the number of completion bands of the display list is less than a rasterization start condition (S54), rasterization is forcedly executed, and after releasing one page of the display list (S55), the process is returned to step S50. Before executing garbage collection (GC), the locking of semaphores corresponding to respective threads except a heap memory management part 126 using a heap memory 132 are acquired (S58). After executing the GC, the semaphores corresponding to the threads is released (5A). <P>COPYRIGHT: (C)2009,JPO&INPIT

Description

  The present invention relates to an image forming apparatus provided with a heap memory allocation program that performs garbage collection as needed in response to heap memory acquisition requests from a plurality of tasks, and in particular, secures a memory of a requested size when waiting for memory release. The present invention relates to an image forming apparatus provided with a heap memory allocation program that waits for memory release when it can be predicted.

  In an object-oriented programming language such as C ++ or Java (registered trademark), an area in the heap memory is dynamically secured and released on the system side (runtime library). When a memory area of the requested size cannot be secured, garbage collection is performed to release objects that are no longer referenced, and compaction is performed to generate continuous free areas.

  However, since the heap memory size is relatively large, it takes a relatively long time to copy objects in compaction, and the application cannot predict when garbage collection will occur, causing unexpected processing delays. .

Therefore, in Patent Document 1 described below, the garbage collection is performed during the standby time of print data from the outside in the image forming apparatus, thereby reducing the influence on the print processing.
JP 2006-344184 A

  However, when it is desired to process the print data without delay after receiving the print data, the memory is not allocated for execution of the process, and the garbage collection is executed, the process is delayed.

  In general, all other processes are stopped when garbage collection is executed. Therefore, particularly when a plurality of processes are efficiently executed in parallel, the effect of processing delay becomes relatively large when garbage collection is frequently executed.

  In view of such problems, an object of the present invention is to provide an image forming apparatus capable of suppressing a heap memory securing delay.

In a first aspect of the present invention, in an image forming apparatus including a processor and a storage unit coupled to the processor and storing a heap memory allocation program, the heap memory allocation program
(A) Determine whether it is possible to secure a storage area of the requested size, and if affirmative determination is made, secure a storage area of the requested size,
(B) If a negative determination is made in process (a), if it is the first state, the process waits for the second state to return to process (a),
(C) If the process (b) is not in the first state, a storage area of the requested size is secured after garbage collection is performed.

  In a second aspect of the image forming apparatus according to the present invention, in the first aspect, the first state is that the number of remaining pages in the display list in the memory including the processing is two or more, and the second state is that the processing is in progress. The number of remaining pages in the display list on the memory is 1 or less.

In a third aspect of the image forming apparatus according to the present invention, in the second aspect, the process (c)
(C1) If not in the first state, it is determined whether or not the number of remaining pages in the display list including the processing is 1 or less and the number of created bands of the processing display list is less than the rasterization start condition. Let
(C2) When an affirmative determination is made in process (c1), rasterization is started as an exception, and the process returns to process (a).
(C3) If a negative determination is made in step (c1), a storage area of the requested size is secured after the garbage collection is performed.

In a fourth aspect of the image forming apparatus according to the present invention, in the third aspect,
The process (c3)
(C31) If a negative determination is made in the process (c1), it is determined whether or not the storage area securing request is a request from a program that performs a process before the display list creation process. Release the font cache and return to process (a),
(C32) If a negative determination is made in step (c31), a storage area of the requested size is secured after the garbage collection is performed.

In a fifth aspect of the present invention, in an image forming apparatus comprising a processor, a plurality of processing programs coupled to the processor and executed as different tasks, and storage means storing a heap memory management program,
Each of the plurality of processing programs causes the processor to acquire the lock of the semaphore corresponding to its own task as the preprocessing of the main body processing, and to release the lock as the postprocessing of the main body processing,
The heap memory management program includes a heap memory allocation program that is executed as a task different from the task, and a heap memory release program that can be executed in parallel with the heap memory allocation program.
When the heap memory allocation program determines that the storage area of the requested size cannot be secured for the processor, the heap memory allocation program acquires a semaphore lock corresponding to each of the plurality of processing programs as preprocessing of the garbage collection, Let the garbage collection occur, let the lock on these semaphores be released as post-processing of the garbage collection,
The heap memory release program causes the processor to release a corresponding storage area of the heap memory in response to a release request from any one of the plurality of processing programs,
Any one of the plurality of processing programs causes the processor to release the lock of the semaphore corresponding to the invoking task before requesting heap memory allocation via the heap memory allocation program. Get this semaphore lock after returning.

  According to the configuration of the first aspect, after waiting for the second state to enter the second state, it is determined whether the storage area of the requested size can be secured, and if a negative determination is made, garbage collection is performed. Therefore, there is an effect that it is possible to suppress the heap memory securing delay by reducing the number of times of executing garbage collection.

  According to the configuration of the second aspect, the number of remaining pages in the display list in the memory including the processing in the first state is 2 or more, and the number of remaining pages in the display list in the memory including the processing in the second state is the second state. Since it includes 1 or less, there is an effect that it is possible to efficiently reduce the number of garbage collection executions and suppress a heap memory securing delay.

  According to the configuration of the third aspect, even if the state is not the first state, the number of remaining pages of the display list in the memory including the processing is 1 or less and the number of created bands of the processing display list is less than the rasterization start condition. If the value is determined to be a value, rasterization is started as an exception and waits until a storage area of the requested size can be secured, thus reducing the number of garbage collection executions more efficiently and suppressing the delay in securing heap memory. It is possible to do this.

  According to the configuration of the fourth aspect, if the storage area securing request is a request from a program that performs processing prior to the display list creation process, whether or not the storage area of the requested size can be secured by releasing the font cache. Therefore, it is possible to reduce the number of garbage collection executions more efficiently and suppress the heap memory allocation delay.

  According to the configuration of the fifth aspect, garbage is allocated in the heap memory allocation program until one page of the plurality of processing programs executed as different tasks other than the one calling the heap memory allocation program is completed. Since collection execution is awaited, the amount of data that is no longer referenced at the start of this execution is considered to be relatively large, and the continuous area that can be secured by executing garbage collection becomes relatively large, and garbage collection is performed efficiently. As a result, it is possible to reduce the number of garbage collection executions and suppress the delay in securing the heap memory.

  Other objects, configurations and effects of the present invention will become apparent from the following description.

  Embodiments of the present invention will be described below with reference to the drawings. The garbage collection will be described in the fourth embodiment.

  FIG. 21 is a schematic block diagram illustrating a hardware configuration of the image forming apparatus 10 according to the first embodiment of the invention.

  In this image forming apparatus 10, a CPU 11, an EEPROM 12, a RAM 13, a compression / decompression processor 14, a communication interface 15, a panel interface 16, an engine controller 17, and a transport controller 18 are connected by a bus 19, and an engine controller 17 including an interface 16 and an interface. In addition, an operation panel 20, a print engine 21, and a paper transport device 22 are coupled to the transport controller 18. A host computer (not shown) is coupled to the communication interface 15.

  The EEPROM 12 stores an OS (Operating System), a driver, and an application. The RAM 13 stores temporary data. This OS supports multi-threading of applications and has a semaphore function.

  The compression / decompression processor 14 is composed of, for example, an ASIC (Application Specific Integrated Circuit), and can perform compression processing and decompression processing simultaneously. The compression / decompression processor 14 includes a compression unit 141, an expansion unit 142 and an expansion unit 143 (see FIG. 1) that can be processed in parallel with each other, and a DMAC (Direct Memory Access Controller), and compresses data in the RAM 13 into a compression unit 141. The decompression unit 142 or the decompression unit 143 can perform block transfer by DMA to perform compression or decompression, and block the result to the RAM 13 or the engine controller 17 by DMA. The DMAC may be separate from the compression / decompression processor 14.

  The operation panel 20 includes keys and a display panel. The engine controller 17 includes a CPU, a memory that stores a print engine control program, and a buffer memory that stores received bitmap data.

  FIG. 1 is a functional block diagram of a part that develops a bitmap of print data received from a host computer.

  This print data is described in a page description language (PDL) and is stored in the buffer memory 131 via the communication interface 15. In FIG. 1, a buffer memory 131, a heap memory 132, and a shared memory 133 are storage areas in the RAM 13. The interpreter 121, the RIP 122, and the control unit 123 all correspond to a part of the application program and are executed by the CPU 11.

  In response to a print request from the host computer, the control unit 123 stores print data from the host computer in the buffer memory 131 via the communication interface 15. The control unit 123 activates the interpreter 121 to convert the print data into a display list (intermediate code) for each page and store the print data in the heap memory 132. The control unit 123 activates the RIP 122 and the compression / decompression processor 14 to perform the processes described later.

  10A to 10C are schematic diagrams for explaining the display list.

  As shown in FIG. 10A, the graphic objects 31 to 34 are described in PDL in this order in the print data 30 for one page, and by rasterizing them in the description order, The graphic object 33 is overwritten on the graphic object 31, and the graphic object 34 is overwritten on the graphic object 33, so that an image as shown in FIG. 10A is obtained. In order to reduce the required memory capacity, as shown in FIG. 10B, the print data 30 is divided into bands 40 to 43, and the divided objects are converted into intermediate codes for high-speed rasterization processing. To do. In general, objects include character objects and image objects in addition to graphic objects. In the intermediate coding of an object, a vector data character object is converted into image data.

  FIG. 10C conceptually shows a state in which each graphic object included in the print data 30 is converted into intermediate code data for each band. The intermediate code block Lij in the figure indicates that it is the jth block constituting the display list of band i. In order to properly combine the figures, the block description order in each band follows the description order of the graphic objects. For example, the block description order in the display list of the band 41 is intermediate code blocks L10, L11, L12, and L21.

  As the number of bands increases, the required memory capacity can be reduced. However, since the total processing time increases, the number of bands is determined according to the capacity of the RAM 13, and this value is, for example, 36. In order to facilitate memory management, the maximum storage capacity of one block is determined, and as many intermediate codes as possible are packed in each block Lij of this capacity.

  FIG. 2 shows the data structure of the display list stored in the heap memory 132. This data structure is a list structure.

  In the L band array 1320, the number of elements is equal to the number of bands, and the element i (i is one of 0 to n) is a pointer of the display list Li. The number of blocks in each display list Li is not constant. FIG. 1 shows a case where the number of blocks in each display list Li is 3 for simplification. In the case of image data, the intermediate code of the block Lij is a code including a pointer indicating the image data storage destination and the number of data bytes, and the image data itself is not included in the block Lij. When the image data includes a band boundary, the image data divided at the band boundary is similarly specified by the pointer and the number of bytes of data.

  On the other hand, a bitmap data area 133B and a compressed data area 133C are secured in the shared memory 133. The compression / decompression processor 14 includes a compression unit 141 and an expansion unit 142 that can perform parallel processing.

  Next, processing of band i by the RIP 122, the compression / decompression processor 14, and the control unit 123 that controls them will be described. The initial value of the block identification variable j is 0. The control unit 123 controls the start of the RIP 122 for each page, and controls the control compression / decompression processor 14 for each band.

  (1) If j = 0, go to step (2). When j> 0, the decompressing unit 142 calls the compressed data stored in the compressed band area Ci, decompresses the compressed data to the original bitmap data, and stores it in the sub-area BMPk.

  (2) The RIP 122 overwrites the bitmap data expanded in (1) by converting the intermediate code block Lij in the heap memory 132 into the bit map data and storing it in the sub-region BMPk.

  (3) The compression unit 141 compresses the bitmap data stored in the sub-region BMPk and stores it in the compressed band region Ci in the compressed data region 133C.

  (4) The RIP 122 increments j by 1, and if the intermediate code block Lij exists in the heap memory 132, returns to the above step (1).

  The compression unit 141 and the decompression unit 142 can be operated in parallel, and the processing by the compression / decompression processor 14 and the software processing for display list creation and rasterization can be performed in parallel. On the other hand, any two of compression processing, decompression processing, and software processing cannot be performed simultaneously for the same band. Therefore, as shown in FIG. 4, three band processing is performed simultaneously. For example, when band 0 is being expanded, band 1 is compressed, and band 2 display list creation and rasterization are serially processed. Since all of these compression, decompression, and rasterization handle bipmap data, as shown in FIG. 1, the bitmap data area 133B has an area for three bands divided into BMP0 to BMP2.

  When the average compression rate of the compression unit 141 is 1 / c (c = size after compression / size before compression) and the number of bands on one page is n + 1, the compressed data and the bits for three bands for the bitmap data for one page The total compression ratio with the map area is 3 / (n + 1) + 1 / c. For example, when n = 35 and c = 10, the compression ratio is 3/36 + 1/10 = 11/60.

  FIG. 3 shows the structure of data related to rasterization, compression, and expansion stored in the shared memory 133.

  In the C band array 1330, the number of elements is equal to the number of bands, and the element i (i is any one of 0 to n) is a pointer of the compression band region Ci. The block maximum number array 1331 has the same number of elements as the number of bands, and the element i stores the block number maximum value je (i) of the band i. The number of elements of the B band array 1332 is 3, and the element k (k is any of 0 to 2) is a pointer of the sub-region BMPk.

  In the band / block number variable group 1333, for the variables R, C, and D, pairs (i, j), (p, q), and (r, s) of the current band number and block number to be processed are respectively stored. Stored. The variables R, C, and D notify the completion of block processing between threads (step S5 in FIG. 5, step S16 in FIG. 6A, and step S24 in FIG. 6B), and processing of the next block In order to make the start point appropriate, that is, for the same band, the rasterization is performed after the expansion is completed, the rasterization is performed after the rasterization is completed, and the compression is performed after the compression is completed. In the example below, the band / block number variable group 1333 stores the band number and block number of the next or processing target being processed, but this data also means the completion of the processing of the previous processing target. is doing.

  FIG. 7 is a schematic timing chart showing parallel processing of the software, the compression unit 141, and the decompression unit 142. FIG. 7 shows a case where each of the bands 0 to 2 has a display list of 3 blocks. FIG. 8 shows a rearrangement of the processing of FIG. 7 for each of the bands BND0 to BND2.

  Lij, Rij, Cij, and Dij indicate display list creation, rasterization, compression, and decompression processing for band i and block j, respectively.

  In FIG. 1 and FIG. 7, in order to simplify the software configuration of the control unit 123, processing start control for the compression unit 141 and the decompression unit 142 is performed by threads Th <b> 1 and Th <b> 2 in the control unit 123, respectively. The processes of the interpreter 121 and the RIP 122 are processes in the thread Th0. That is, parallel processing by three threads is performed.

  The thread Th0 is generated and started by the control unit 123. In the thread Th0, an intermediate code block L00 creation process is performed, and then a rasterize R00 process is performed. When the rasterize R00 is completed, a thread Th1 is generated and started by the thread Th0. The process of compression C00 is performed by the thread Th1 via the compression unit 141, and when the process of compression C00 is completed, Th2 is generated and started by the thread Th1. The threads Th1 and Th2 perform compression C10 and decompression D00 via the compression unit 141 and the decompression unit 142, respectively.

  In general, in the thread Th0, the intermediate code block Lij creation and rasterization Rij processing are performed in the band sequential block order, and the rasterization Rij processing is usually completed at the time when compression Cij is started. Here, the band sequential block sequential means that the initial values of the block j and the band i0 are both 0, and the band i and the block j are changed as follows.

(A) With block j kept constant, band i is sequentially changed to i0, i0 + 1, i0 + 2,
(B) If j is smaller than the block number maximum value je (i), the block j is incremented by 1, and the process returns to (a). Otherwise, the process proceeds to (d).

  (D) If i0 + 2 is smaller than the band number maximum value n, j = 0 and i0 is incremented by 3, and the process returns to (a).

  In the thread Th1, the band p and the block q are updated so that the band sequential block sequential is made in response to the processing completion notification of the compression unit 141 for one block, and the processing of the corresponding rasterization Rpq is completed. Then, the compression unit 141 is caused to start the compression Cpq process. In the test example, as shown in FIG. 7, the compression Cpq could be continuously performed without interruption.

  In the thread Th2, the band r and the block s are updated so that the band sequential block sequential in response to the completion notification of the decompression unit 142 for one block, and the decompression unit 142 starts the process of decompression Drs. However, for each band r, the process of decompression Drs is not started for the last block je (r).

  FIG. 5 is a flowchart showing the processing of the thread Th0. The initial value of i0 is 0. In the following, the step identification codes in the figure are shown in parentheses.

  (S0) The value je (i) stored in the element i of the block maximum number array 1331 is read, and the processing of steps S1 to SA is sequentially repeated for the block j from 0 to je (i).

  (S1) The processes from step S2 to S9 are repeated sequentially for i = i0 to i0 + 2.

  (S2) An intermediate code block Lij is created in the heap memory 132.

  (S3, S4) If j = 0, the sub-region BMPk is cleared to zero. Here, k is a value satisfying i = i0 + k.

  (S5) Whether or not the process of expansion Di (j-1) is completed by looking at the content rs of variable D of band block number variable group 1333 (however, if j = 0, expansion D (i- 1) Whether or not the processing of j has been completed is determined, that is, whether or not r = i and s = j is determined. If the determination is affirmative, the process proceeds to step S6.

  (S6) The intermediate code block Lij is read from the heap memory 132, rasterized, and overwritten on the sub area BMPk of the bitmap data area 133B.

  (S7, S8) If i0 = 0 and j = 0, the thread Th1 is generated and started.

  (S9) The contents (i, j) of the variable R in the band / block number variable group 1333 are updated as described above. That is, (i, j) is set to the next value in band sequential block sequential.

  (SC) Increment i0 by 3.

  If (SD) i0> n, the process is terminated; otherwise, the process returns to step S0.

  FIG. 6A is a flowchart showing processing in the thread Th1.

  (S10) The contents (p, q) of the variable C in the band / block number variable group 1333 are read, and the compression unit 141 starts the process of compression Cpq. At this time, the compression unit 141 is supplied with the contents of the element i of the C band array 1330 as the compressed data storage destination start address and the contents of the element k of the B band array 1332 as the compression target data start address. Here, k is a remainder when p is divided by 3.

  (S11) Wait for the processing completion event of the compression unit 141 to occur. When this event occurs, the wait state is canceled and the process proceeds to step S12. Since the OS immediately switches to the next thread before the wait state is released, the processing delay of FIG. 5 is prevented.

  (S12, S13) If p = 0 and q = 0, a thread Th2 is generated and started.

  (S14) If p = n and q = je (n), the process ends. If not, the process proceeds to step S15.

  (S15) The contents (p, q) of the variable C in the band block number variable group 1333 are updated as described above.

  (S16) By looking at the contents ij of the variable R in the band block number variable group 1333, it is determined whether or not the processing of Rpq is completed. That is, if 0 ≦ q ≦ je (p) −1, i = It is determined whether or not p and j = q + 1. When q = je (p), it is determined whether i = p + 1 and j = 0. If the determination is affirmative, the process returns to step S10.

  FIG. 6B is a flowchart showing processing in the thread Th3.

  (S20) The contents (r, s) of the variable D in the band / block number variable group 1333 are read, and the decompression unit 142 starts the decompression Dpq process. At this time, the contents of the element i of the C band array 1330 are supplied to the decompression unit 142 as the decompression target start address, and the contents of the element k of the B band array 1332 are provided as the decompression data storage destination top address. Here, k is a remainder when r is divided by 3.

  (S21) Wait for the processing completion event of the decompression unit 142 to occur. When this event occurs, the wait state is canceled and the process proceeds to step S22. Before the wait state is canceled, the OS immediately switches to the next thread.

  (S22) If r = n and s = je (n) −1, the process is terminated; otherwise, the process proceeds to step S23.

  (S23) The contents (r, s) of the variable D of the band / block number variable group 1333 are updated as described above.

  (S24) The contents pq of the variable C in the band / block number variable group 1333 are viewed to determine whether or not the Crs processing has been completed. That is, when 0 ≦ s ≦ je (r) −1, p = It is determined whether r and q = s + 1. When s = je (r), it is determined whether p = r + 1 and q = 0. If the determination is affirmative, the process returns to step S20.

  Through the above processing, one page of compressed data (page data) is generated in the compressed data area 133C. In response to this, the control unit 123 generates and starts a thread ThP included in the control unit 123, which is different from the above three threads.

  In the thread ThP, it is confirmed that the data input of the engine controller 17 is in a ready state, and this page data is expanded in band order via the expansion unit 143 and transferred to the engine controller 17. At this time, for the band i, the contents of the element i of the C band array 1330 are supplied to the decompression unit 143 as the decompression target data start address, and the address of the engine controller 17 as the transfer destination address.

  The engine controller 17 receives the transferred bitmap data, stores it in its buffer memory, converts it into serial data, further converts it into a video signal, and supplies it to the print engine 21. Based on this signal and a control signal from the engine controller 17, the print engine 21 forms an electrostatic latent image on the photosensitive drum, develops it by attaching toner to the photosensitive drum, transfers the toner image to a sheet, and heats it. Then, the toner image is fixed on the paper by pressing. On the other hand, according to the program, the CPU 11 causes the paper transport device 22 to transport the paper to the print engine 21 via the transport controller 18, transports the printed paper, and discharges it onto the tray.

  FIG. 9 is a schematic time chart showing decompression / transfer processing of compressed page data and other processing.

  By such processing, the expansion / rasterization / compression processing of each band of the second page by the threads Th0 to Th2 and the page data expansion / transfer processing of the first page by the thread ThP are executed in parallel. Is the same.

  According to the first embodiment, since the bitmap data area 133B is sufficient for three bands, an increase in necessary memory capacity can be suppressed, and the three bands are shifted in parallel with respect to expansion, rasterization, and compression. Since it is processed, each of compression and decompression can be performed almost continuously, and the print data can be bitmap-developed at high speed. Furthermore, since decompression, rasterization, and compression are performed in parallel by different tasks, there is an effect that compression and decompression can be performed almost continuously relatively easily.

  Since the compression / decompression processor 14 uses the compression / decompression processor 14 and the compression / decompression processor 14 performs the decompression and compression start control by the threads Th1, Th2 and ThP as described above. The CPU load for this process is relatively small. For this reason, the processing delay of the thread Th0 due to these threads is relatively small, and high-speed processing as a whole can be efficiently performed by parallel processing. Further, since the program structure is simplified by the multi-threading, the development period can be shortened and the manufacturing cost can be reduced.

  Note that the page data transfer efficiency may be increased by providing the decompression unit 143 in the engine controller 17 and decompressing the decompression unit 143 on the engine controller 17 side.

  In the first embodiment, the display list creation and rasterization processing are performed in series. However, it is also possible to perform both processes in separate threads, which will be described below as a second embodiment of the present invention.

  As shown in FIG. 12, a thread Th3 for processing only the display list is generated and started before the thread Th0, and the intermediate code block Lij is created by updating (i, j) in the band sequential block order. Process.

  FIG. 11 is a flowchart showing processing in the thread Th0 in this case. A difference from the processing of FIG. 5 is that, in step S3a instead of steps S2 and S5, not only expansion Di (j−1) but also completion of creation of the intermediate code block Lij is awaited. In order to notify the completion of the creation of the intermediate code block Lij, a variable L is added to 1333, and the band number and the block number are updated every time one block of intermediate code creation processing is completed in the thread Th3.

  FIG. 13 is a diagram showing a rearranged process of FIG. 12 for each of the bands BND0 to BN2.

  The other points are the same as those in the first embodiment.

  According to the second embodiment, since display list creation and rasterization are processed in parallel, the respective processes are simplified, and the rasterization execution time is relatively small during the rasterization pause period. The overhead of switching between list creation and rasterization is relatively small and effective as a whole.

  In the first and second embodiments, the case where the decompression start control, rasterization, and compression start control are executed by different threads and three bands are sequentially processed by each thread has been described. It is also possible to execute the decompression start control, rasterization, and compression start control for the minute. In this case, each of the three threads can use the same function that is different only in the variable area.

  Since only one band can be processed at the same time for each of compression and decompression, it is necessary to synchronize between threads. Therefore, as shown in FIG. 15, the compression completion flag Fc (k) and the expansion completion flag Fd (k) are provided in the shared memory 133 for each of the sub-regions BMPk, k = 0 to 2. In the shared memory 133, a band block number variable 1333a indicating how far the creation of the intermediate code block has been completed is provided instead of the band block number variable group 1333 of FIG. Other points in FIG. 15 are the same as those in FIG.

  FIG. 16 is a schematic timing chart of the threads Th0A, Th1A, Th2A, and Th3 and the processing of the compression unit 141 and the expansion unit 142. In FIG. 16, in order to avoid complication, a dotted line indicating a relationship between compression and decompression and a thread describes only the thread Th0A.

  The thread Th3 is the same as that of FIG. 12, and is processed in parallel with the threads Th0A to Th2A. The threads Th0A, Th1A, and Th2A are generated and started at the timing when the creation of the intermediate code blocks L00, L10, and L20 is completed in the thread Th3, respectively. This generation and start may be performed by the thread Th3 or by another thread (not shown).

  In FIG. 12, the second index j of the compressed Cij and the expanded Dij represents the block number, but the corresponding second index in FIG. 16 indicates k of the sub-region BMPk. Therefore, in FIG. 14, these are represented as Cik and Dik. That is, the compression Cik means that the bitmap data of the sub-region BMPk is compressed and stored in the compressed data region of the band i, and the decompression Dik decompresses the data stored in the compressed data region of the band i. Storing in the sub-region BMPk.

  FIG. 14 is a flowchart showing processing executed by an arbitrary thread Thk among the threads Th0A to Th2A.

  (S30) k is substituted into the band identification variable i, and the initial value 0 is substituted into the block identification variable j of this band.

  (S31) The sub-region BMPk is cleared to zero.

  (S32) If the creation of the intermediate code block Lij is completed, the process proceeds to step S33.

  (S33) Rasterize Rij processing is performed.

  (S34) Wait for compression Ci (k-1) to complete. That is, when the processing completion event of the compression unit 141 controlled to start with the thread Th (k−1) A occurs, if the value of the compression completion flag Fc (k−1) in FIG. If this value is set to 0, the process proceeds to step S35. Otherwise, the event handler is exited, and the OS switches to the next thread. However, in Ci (k-1) and Fc (k-1), when k = 0, it is considered that k = 3. Since the OS immediately switches to the next thread before releasing the wait state in which the processing completion event of the compression unit 141 has not occurred, the processing delay in FIG. 14 is prevented. This also applies to other wait states.

  (S35) The compression unit 141 starts the compression Cik process. At this time, the compression unit 141 is supplied with the contents of the element i of the C band array 1330 as the compressed data storage destination start address and the contents of the element k of the B band array 1332 as the compression target data start address.

  (S36) When the processing completion event of the compression unit 141 whose start is controlled in step S35 occurs, the event handler sets the value of the compression completion flag Fc (k) in FIG. 15 to 1, and proceeds to step S37.

  (S37) (i, j) is set to the next value in the band sequential block sequence as described in the first embodiment.

  (S38) If j = je (i), the process proceeds to step S3C; otherwise, the process proceeds to step S39.

  (S39) Wait for the expansion Di (k-1) to be completed. That is, if the value of the expansion completion flag Fd (k−1) in FIG. 15 is 1, this value is set to 0 and the process proceeds to step S3A. However, in Di (k−1) and Fd (k−1), k = 3 is considered when k = 0.

  (S3A) The expansion unit 142 starts the expansion Dik process. At this time, the contents of the element i of the C band array 1330 are supplied to the decompression unit 142 as the decompression target start address, and the contents of the element k of the B band array 1332 are provided as the decompression data storage destination top address.

  (S3B) When the processing completion event of the decompression unit 142 controlled to start in step S3A occurs, the event handler sets the value of the decompression completion flag Fd (k) in FIG. 15 to 1 and proceeds to step S32.

  (S3C) Increment i by 3 and initialize j to 0.

  (S3D) If i> n, the process is terminated; otherwise, the process returns to step S31.

  The other points are the same as those in the first embodiment.

  According to the third embodiment, since compression and decompression can be performed almost continuously for the three bands, print data can be bitmap-developed at high speed.

  In addition, since a series of processing of expansion, rasterization, and compression is performed sequentially within one thread for one band, it is not necessary to synchronize between the threads.

  Further, since a common function can be used in the threads Th0A to Th2A, the memory usage can be reduced as compared with the cases of the first and second embodiments.

  Furthermore, since the display list creation is executed by a thread different from the threads Th0A to Th2A, the overhead is reduced and the processing efficiency is better than when the display list is created by each of the threads Th0A to Th2A.

  Similarly, the page data decompression / transfer control with another thread ThP reduces the overhead and the processing efficiency is better than the page data decompression / transfer control with each of the threads Th0A to Th2A.

  FIG. 17 is a functional block diagram of a part from receiving print data from the host computer to converting it into an intermediate language according to the fourth embodiment of the present invention. The processing after rasterization is the same as in FIG.

  In the fourth embodiment, when the control unit 123A receives a print request from the host computer via the communication interface 15, a thread for the print data preprocessing unit 124 is generated. In response to this, the print data preprocessing unit 124 stores the print data 1321 for one page received via the communication interface 15 in the heap memory 132. The control unit 123A generates a thread for the print data preprocessing unit 124 every time a page break command is received. The print data preprocessing unit 124 corresponds to a part of the control unit 123 in FIG. 1, and the control unit 123A in FIG. 17 corresponds to the control unit 123 in FIG. 1 excluding the print data preprocessing unit 124. .

  The font file 125 of a specific typeface is stored in the EEPROM 12 (FIG. 21), and the print data preprocessing unit 124 refers to the font file 125 when the print data uses this typeface, The character code string is converted into a character string image 1321a. At this time, if there is a character image of the character code in the font cache 1322, this is used, and if it does not exist, it is converted into a character image and stored in the font cache 1322. The print data preprocessing unit 124 may shorten the processing time in the RIP 122 of FIG. 1 by converting the graphic object into a basic graphic such as a trapezoid.

  The print data preprocessing unit 124 generates a thread of the interpreter 121 at the start of reception.

  In response to this, the interpreter 121 performs the processing described in the first embodiment in parallel with the processing by the print data preprocessing unit 124, and creates the display list 1323 for one page in the heap memory 132. The character string image 1321a is linked by a pointer in the display list 1323 similarly to the image object in the print data 1321 (see the first embodiment).

  Each of the print data preprocessing unit 124 and the interpreter 121 secures and releases an area in the heap memory 132 via the heap memory management unit 126.

  FIG. 18 is a schematic block diagram showing a configuration related to the heap memory management unit 126.

  The heap memory management unit 126 includes a memory allocation method 1260, a memory release method 1261, and a count method 1262. The memory allocation method 1260 and the memory release method 1261 are each executed by a thread different from the print data preprocessing unit 124 or the interpreter 121. On the other hand, in the static memory 134 which is a partial area of the RAM 13, the number of remaining print data pages 1340 on the heap memory and the number 1341 of remaining display lists on the heap memory used by the heap memory management unit 126 are secured. Here, the “number of remaining pages” is the number of pages including the page being processed.

  The initial value of the print data remaining page number 1340 is 0, and the print data preprocessing unit 124 increments the print data remaining page number 1340 by 1 every time the print data 1321 is read into the heap memory 132 via the count method 1262. In response to the release command from the interpreter 121, the print data 1321 of the corresponding page (the image linked from the display list 1323 is not a target) is released from the memory via the memory release method 1261, and the count method 1262 is set. Then, the print data remaining page number 1340 is decremented by one. This release command is supplied when the interpreter 121 finishes creating one page of display list.

  The initial value of the display list remaining page number 1341 is 0, and the interpreter 121 increments the display list remaining page number 1341 by 1 through the count method 1262 every time one page of the display list 1323 is created in the heap memory 132. In response to the release command from the RIP 122 in FIG. 1, the display list 1323 of the corresponding page is released from the memory via the memory release method 1261, and the display list remaining page number 1341 is decremented by 1 via the count method 1262. This release command is supplied when the RIP 122 completes rasterization for one page.

  The memory allocation method 1260 calls the garbage collector GC when it is determined that the storage area of the requested size cannot be secured even after waiting for the release by the memory release method 1261 because the predetermined condition described later is not satisfied. The memory release method 1261 is executed in parallel with the memory allocation method 1260. The garbage collector GC may be a system side (in a runtime library) or an application side program.

  Conventionally, the garbage collector GC is called when it is determined that the storage area of the requested size cannot be secured without determining whether or not the condition is satisfied, which causes a delay in processing. It was. However, according to the fourth embodiment, when the condition is satisfied, the memory securing process is performed after the memory is released, so that the probability that the garbage collector GC is called is reduced, and the process by the execution of the garbage collector GC is performed. There is an effect that the delay can be suppressed.

  If another thread is operating during execution of the garbage collector GC, the object reference changes and an error occurs in garbage collection. Further, if the copy source data changes during compaction, an error occurs in copying.

  Therefore, a thread outside the heap memory management unit 126 that uses the heap memory 132 using a binary semaphore that is a function of the OS, that is, a thread of the print data preprocessing unit 124 and a thread of the interpreter 121 in the fourth embodiment. After waiting for the operation to stop, execution of the garbage collector GC is started.

  FIG. 19 is a flowchart showing mainly semaphore lock acquisition and lock release in an arbitrary thread A outside the heap memory management unit 126 that uses the heap memory 132.

  As a pre-process of the main body process (process for one page) in step S41, a lock of the semaphore corresponding to the own thread A is acquired in step S40, and this lock is released as a post-process of step S41.

  As a result, when the thread of the memory allocation method 1260 (thread B) tries to acquire the lock of the semaphore before the garbage collector GC is called (step S58 in FIG. 20), the lock of the semaphore corresponding to the thread A is already acquired. If this happens, the thread B is queued by the OS and remains in a wait state until the processing in step S12 ends.

  In step S41, when the memory allocation method 1260 is called in step S411, as a pre-processing, the lock of the semaphore corresponding to the own thread A is released in step S410, and this lock is acquired as a post-processing in step S411. .

  Thus, when thread A creates a thread (thread B) of the memory allocation method 1260 and requests memory allocation, thread B acquires a semaphore corresponding to thread A before the garbage collector GC is called (step S58 in FIG. 20). As a result, deadlock between threads A and B is avoided.

  FIG. 20 is a flowchart showing the processing of the memory allocation method 1260. The thread B of this method is generated by the print data preprocessing unit 124 or the interpreter 121 when the print data preprocessing unit 124 or the interpreter 121 makes a heap memory allocation request.

  (S50) It is determined whether or not the storage area of the requested size can be secured, and if the determination is affirmative, the securing is executed.

  (S51) If it can be secured in step S50, the processing of FIG. 20 is terminated (thread B is automatically extinguished), otherwise, the process proceeds to step S52.

  (S52) If the value of the display list remaining page number 1341 is 2 or more, it can be estimated that the display list 1323 for one page is about to be released, so the process proceeds to step S53. Otherwise, the process proceeds to step S54.

  (S53) The display list remaining page number 1341 is decremented and an event is generated. In response to the occurrence of the decrement event, the process returns to step S50.

  (S54) If the number of completed bands i in the display list 1323 is less than it (less than the rasterization start condition), the process proceeds to step S55, and if not, the process proceeds to step S56. Here, in order to eliminate the waiting time in step S32 of FIG. 14, the process of FIG. 14 is started when i = it in principle.

  (S55) As an exception to this principle, by starting the process of FIG. 14, the process of FIG. 14 is completed and the display list 1323 is released for one page, and the process returns to step S50.

  (S56) If it is a memory allocation request from the print data preprocessing unit 124, the process proceeds to step S57; otherwise, the process proceeds to step S58.

  (S57) The font file 125 is released and the process returns to step S50. In this case, when a negative determination is made in step S51, the process proceeds from step S51 to step S58 (not shown).

  (S58) A semaphore lock corresponding to each thread outside the heap memory management unit 126 that uses the heap memory 132 is acquired. If it cannot be acquired, thread B is queued by the OS until it can be acquired. In the fourth embodiment, it is a memory allocation request from one thread of the print data pre-processing unit 124 and the interpreter 121, and for this one, the semaphore lock can be acquired immediately by the process of step S411. Thread B is queued by the OS until S42 is processed.

  (S59) Call the garbage collector GC.

  When the processing of the interpreter 121 is completed during the wait in step S58, the band in the display list 1323 that is no longer referred to after the rasterization is completed and the image data in the print data 1321 linked to the band are displayed by the garbage collector GC. Liberated, the amount is relatively large. For this reason, the continuous area that can be secured by executing garbage collection can be relatively large and garbage collection can be executed efficiently, and this can reduce the number of garbage collection execution times and suppress heap memory allocation delay. It becomes possible.

  (S5A) The semaphore lock corresponding to each thread outside the heap memory management unit 126 that uses the heap memory 132 is released.

  (S5B) Whether or not the storage area of the requested size can be secured is determined, and when the determination is affirmative, the securing is executed.

  (S5C, S5D) If it cannot be secured in step S5B, an abnormal display of memory full error is displayed on the operation panel 20 and the print job is terminated abnormally.

  The present invention includes various modifications in addition to the above.

  For example, the data update of the band / block number variable group 1333 may be performed before the start of the process such as rasterization.

  In the above-described embodiment, the case has been described in which the combination of two bitmap data is an overwrite of the other bitmap data with respect to one bitmap data. There may be.

  Furthermore, as a multitask, a multiprocess may be used instead of a multithread.

  Further, a double core CPU may be used as the CPU 11, and a combination of one core and a compression / decompression program may be used as a compression / decompression processor. In this case, the compression process and the decompression process are multitasked.

  Further, the memory allocation method 1260 is characterized by the processing of steps S50 to S57. Therefore, the operating thread of the print data preprocessing unit 124 and the interpreter 121 is stopped from the memory allocation method 1260 without using a semaphore. The garbage collector GC may be executed. In addition, a known method for correcting the error may be applied when an error occurs without stopping the operating thread.

  Further, since the memory allocation method 1260 is also characterized by the processing of steps S58 to S5A, in this case, the configuration may not include the processing of steps S52 to S57.

  Also, the main body process in step S411 in FIG. 19 is not limited to one page, and may be a predetermined amount such as a predetermined number of bands.

  Alternatively, the print data preprocessing unit 124 or the interpreter 121 may be divided into a plurality of functions and each may be executed by a thread.

FIG. 4 is a functional block diagram of a portion that develops a bitmap of print data received from a host computer according to Embodiments 1 to 3 of the present invention. It is data structure explanatory drawing of a display list. It is data structure explanatory drawing related to rasterization, compression, and expansion | extension. It is band processing order explanatory drawing. 12 is a flowchart showing display list creation and rasterization processing performed in a thread Th0. (A) is a flowchart of compression processing performed in the thread Th1, and (B) is a flowchart of decompression processing performed in the thread Th2. FIG. 7 is a schematic timing chart showing a part of the processing results in FIG. 5, FIG. 6 (A) and FIG. 6 (B). It is a figure which shows what rearranged the process of FIG. 7 for every band BND0-BN2. 10 is a schematic time chart showing decompression / transfer processing of compressed page data and other processing. (A)-(C) are display list schematic explanatory drawings. It is a flowchart which shows the display list preparation and rasterization process which concern on Example 2 of this invention. 12 is a schematic timing chart showing a part of the processing result in the second embodiment. It is a figure which shows what rearranged the process of FIG. 12 for every band BND0-BN2. It is a flowchart which shows the process performed by arbitrary one of thread | sled Th0A-Th2A which concerns on Example 3 of this invention. It is data structure explanatory drawing related to the rasterization based on Example 3 of this invention, compression, and expansion | extension. 10 is a schematic timing chart showing a part of the processing result in the third embodiment. FIG. 10 is a functional block diagram of a portion until print data is received from a host computer and converted to an intermediate language according to a fourth embodiment of the present invention. FIG. 18 is a schematic block diagram illustrating a configuration related to a heap memory management unit in FIG. 17. It is a flowchart which mainly shows acquisition and release of a semaphore lock in an arbitrary thread other than the garbage collector using heap memory. It is a flowchart which shows the process of the memory allocation method in FIG. 1 is a schematic block diagram illustrating a hardware configuration of an image forming apparatus according to Embodiments 1 to 4 of the present invention.

Explanation of symbols

10 Image forming apparatus 11 CPU
12 EEPROM
121 interpreter 122 RIP
123 Control Unit 124 Print Data Pre-Processing Unit 125 Font File 126 Heap Memory Management Unit 1260 Memory Allocation Method 1261 Memory Release Method 1262 Count Method 13 RAM
131 Buffer memory 132 Heap memory 1321 Print data 1321a Character string image 1322 Display list 133 Shared memory 134 Static memory 1340 Number of remaining print data pages 1341 Number of remaining display list pages 133C Compressed data area 133B Bitmap data area 1320 L band array 1330 C band array 1331 block maximum number array 1332 B band array 1333 band block number variable group 14 compression / decompression processor 141 compression unit 142, 143 expansion unit 15 communication interface 16 panel interface 17 engine controller 18 transport controller 19 bus 20 operation panel 21 Print Engine 22 Paper Transport Device 30 Print Data 31-34 Graphic object 40-43 Band Th0-Th3, Th0A, Th1A, Th2A, ThP Thread L0-Ln Display list Lij Intermediate code block Rij Rasterization Cpq Compression Drs decompression BND0-BND2 Band BMP0-BMP2 Base collector GC

Claims (10)

A processor;
Storage means coupled to the processor and storing a heap memory allocation program;
In an image forming apparatus having
The heap memory allocation program
(A) Determine whether it is possible to secure a storage area of the requested size, and if affirmative determination is made, secure a storage area of the requested size,
(B) If a negative determination is made in process (a), if it is the first state, the process waits for the second state to return to process (a),
(C) If the process (b) is not in the first state, a storage area of the requested size is secured after garbage collection is performed.
An image forming apparatus.   The first state includes that the number of remaining pages in the display list on the memory including the processing is two or more, and the second state includes that the number of remaining pages of the display list on the memory including the processing is one or less. The image forming apparatus according to claim 1. The process (c)
(C1) If not in the first state, it is determined whether or not the number of remaining pages in the display list including the processing is 1 or less and the number of created bands of the processing display list is less than the rasterization start condition. Let
(C2) When an affirmative determination is made in process (c1), rasterization is started as an exception, and the process returns to process (a).
(C3) If a negative determination is made in step (c1), a storage area of the requested size is secured after the garbage collection is performed.
The image forming apparatus according to claim 2. The process (c3)
(C31) If a negative determination is made in the process (c1), it is determined whether or not the storage area securing request is a request from a program that performs a process before the display list creation process. Release the font cache and return to process (a),
(C32) If a negative determination is made in step (c31), a storage area of the requested size is secured after the garbage collection is performed.
The image forming apparatus according to claim 3. A processor;
A plurality of processing programs coupled to the processor and executed as different tasks, and storage means storing a heap memory management program;
In an image forming apparatus having
Each of the plurality of processing programs causes the processor to acquire the lock of the semaphore corresponding to its own task as the preprocessing of the main body processing, and to release the lock as the postprocessing of the main body processing,
The heap memory management program includes a heap memory allocation program that is executed as a task different from the task, and a heap memory release program that can be executed in parallel with the heap memory allocation program.
When the heap memory allocation program determines that the storage area of the requested size cannot be secured for the processor, the heap memory allocation program acquires a semaphore lock corresponding to each of the plurality of processing programs as preprocessing of the garbage collection, Let the garbage collection occur, let the lock on these semaphores be released as post-processing of the garbage collection,
The heap memory release program causes the processor to release a corresponding storage area of the heap memory in response to a release request from any one of the plurality of processing programs,
Any one of the plurality of processing programs causes the processor to release the lock of the semaphore corresponding to the invoking task before requesting heap memory allocation via the heap memory allocation program. Get this semaphore lock after returning,
An image forming apparatus. The heap memory allocation program responds to an allocation request from any one of the plurality of processing programs to the processor,
(A) Whether to secure a storage area of the requested size is determined. If the determination is affirmative, the allocation request processing is terminated by executing the allocation,
(B) If a negative determination is made in the process (a), it is determined whether or not it is a first predetermined state in which it can be estimated that a storage area of the required size can be secured if the heap memory release program is executed,
(C) If an affirmative determination is made in process (b), the process waits for the second predetermined state to return to process (a);
(D) When a negative determination is made in the process (b), the garbage collection is performed.
(E) ensuring a storage area of the requested size after the garbage collection;
The image forming apparatus according to claim 5. In the first predetermined state of the process (b), the number of remaining display lists on the memory including unprocessed is 2 or more,
The second predetermined state of the processing (c) includes that the page is one page.
The image forming apparatus according to claim 6. Process (d)
(D1) If a negative determination is made in step (b), it is determined whether or not the number of remaining pages is 1 or less and the number of generated bands in the intermediate language is a value less than the rasterization start condition.
(D2) If an affirmative determination is made in process (d1), the rasterization process program is forcibly executed and then the process is returned to process (a).
(D3) If a negative determination is made in step (d2), the garbage collection is performed.
The image forming apparatus according to claim 7.   The plurality of processing programs store the received print data in the heap memory, convert the print data into an intermediate language, and store the stored print data in the heap memory into a plurality of functions. The image forming apparatus according to claim 6, wherein each of the plurality of functions is executed as a task. The plurality of processing programs are:
A processing program for causing the processor to store the received print data in the heap memory;
A processing program that causes the processor to convert the print data in the heap memory into an intermediate language and store the converted data in the heap memory;
The image forming apparatus according to claim 9, further comprising:

Images