JPH05261983A - Character data control device - Google Patents

Abstract

PURPOSE:To provide a character data control device of common memory type tight coupling multi-microprocessor system wherein contents of font caches in processors are made to be the same and excessive differences in processing speed among the processors are not generated. CONSTITUTION:Font caches are arranged in local memories 2 of a plurality of microprocessors 1 and a common RAM 4 is provided with a common font cache 315. When a character data acquisition request generates, at first a reading from the local font caches 2 is attempted. When it is impossible, secondly a reading from the common font cache 315 is attempted. Further, when it is impossible either, character is generated from an outline font source data and a generated character-shaped image data is written only in the common font cache 315. The local font caches 2 are renewed at switching of process.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a character data management device for outputting print data by performing parallel processing by a plurality of processors.

[0002]

2. Description of the Related Art Recently, in a printing apparatus used as a peripheral device such as a workstation, an outline in which a character contour which does not depend on the resolution of the output device is described as curve information from a bitmap type font which depends on the resolution of the output device. Fonts are being used. However, finally, since each output device performs a process of converting into pixel data suitable for the resolution, the conversion takes time. This is especially true for fonts with complex contours such as Kanji.

Therefore, regarding the converted character which has already been processed into pixel data by the processor, the pixel data is temporarily stored in a memory called a font cache connected to the processor via a bus and the character is output. A method is used in which the pixel data is used when the request is generated again. By doing so, the processing time at the time of printing can be shortened, but since there is a limit to the capacity that can be held as a font cache, it is important how to retain only certain frequently used characters. ..
As a management method of this font cache, Japanese Patent Laid-Open No.
-88660 and JP-A-2-233269 are disclosed. The former is to prevent the inconvenience that the character data registered in the font cache will be deleted as old data at the registration time by resetting the registration order when the character data registered in the font is recalled again. It is something to have.

However, even if the font cache is used with maximum efficiency, the speedup is still limited in a device with a single processor.

Therefore, a plurality of processors are connected to the bus,
Parallel processing by multiple processors gives rise to the idea of performing high-speed processing that cannot be achieved by a single processor. There are already some computer systems that perform parallel processing by a plurality of processors, and each processor executes an assigned process and transfers an instruction unit by transferring a part of the execution unit currently being processed to a cache memory. Achieves faster data access.

[0006]

On the other hand, in the printing apparatus, the process of converting the outline font into the character data is required as described above, and the program of the execution process as in the former computer system is simply stored in the cache memory. I can't say that I should transfer it,
The time spent writing to the font cache is much larger. Therefore, in the printing apparatus, it is necessary to perform conversion processing from outline fonts to character data as little as possible and to fill the contents of the font cache with frequently used data.

Further, when each processor independently manages the font cache, even if a character has already been converted into character pixel data by one processor, the character must be registered in the font cache of another processor. , And it is not efficient because the duplication process for converting the character pixel data again is performed. In particular, when an execution process with a large number of used character types is suddenly assigned to a processor that has been infrequently used, the utilization rate of the font cache is significantly reduced, which becomes a bottleneck in processing.

The present invention has been made in view of such a problem, and an object thereof is to make the contents of the font cache of each processor the same so as to improve the utilization efficiency of the font cache and perform high-speed document processing. It is to provide a character data management device for performing.

[0009]

A character data management apparatus according to the present invention includes a plurality of processors, a shared font cache commonly accessible from the processors, and an outline font supply unit commonly accessible from the processors. The processor has a local font cache accessible to each processor, and in response to a character acquisition request at the time of process execution, first tries to read from the local font cache. If it is read, if not, from the shared font cache. Attempt to read, and when there is no more,
The original data is read from the outline font supply unit to generate character pixel data and registered in the shared font cache.

It is characterized in that the contents of the shared font cache are transferred to the local font cache and the contents of the individual font caches are updated at the time of termination or suspension of the process at the time of execution.

[0011]

According to the present invention, writing of new character pixel data is performed in the shared cache. Since the data is transferred from the shared cache to the individual local caches when the process is terminated or paused, the local caches can be guaranteed to be identical.

[0012]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 is a block diagram of an electrophotographic printer as an embodiment of the present invention.

The printing device consists of three main parts. That is, the print engine 11, the engine control device 10, and the control circuit. The operation of the printing device is as follows. A control circuit receives a print control code from an interface 13 connected to an external device such as a personal computer. A control processing program executed by the microprocessor unit 1 interprets this to generate a print pixel and writes it in the image memory 9. The engine control device 10 transfers this pixel data to the engine side in synchronism with the operation of the print engine 11 to perform print processing.

This embodiment incorporates the means of the present invention in the character data management system of the control circuit in the series of processes described above.

The structure of the control circuit is as follows. Multiple (4 in FIG. 1) microprocessor units 1
The bus arbitration circuit 15 connects to the global bus 3.
The bus arbitration circuit 15 arbitrates the competition of the microprocessor unit 1 with respect to the global bus 3 according to the control signal of the bus arbitration control circuit 12. Shared RO for Global Bus 3
M5 and shared RAM4 are connected. A control program for the printing apparatus of this embodiment is written in the shared ROM 5. The shared RAM 4 is used as a work memory for the control program, a global font cache and a received data buffer described later.

In the printing apparatus of this embodiment, bitmap printing, character printing, and simple graphic printing can be performed by designating a control code. However, for the sake of simplicity in the description of the present embodiment, only the case of character printing will be described.

The printing apparatus of this embodiment prints characters using an outline font. The original data of the outline font to be used is recorded in the hard disk device 8 in advance. The hard disk device 8 is controlled by the I / O processor 6 via the disk control device 7. The interface 13 of the external computer is also controlled by the I / O processor 6. Since the I / O processor 6 is accessed by the communication port from the global bus 3, each microprocessor unit 1 can access the I / O processor 6 independently.

The print pixels generated by each microprocessor unit 1 are recorded in the image memory 9. Image memory 9 is composed of dual port memory,
The engine control circuit 10 reads pixel data and transfers it to the print engine 11 at a timing different from the arbitration of the global bus 3.

On the other hand, a local font cache 2 is connected to each microprocessor unit 1. The font cache 2 is connected to the local bus and, compared with the memory accessed via the global bus 3, does not require bus arbitration and thus can be accessed at high speed.

Next, the operation of the font cache management method used in this embodiment will be described with reference to FIG. A font management table 206 and a font data section 201 are arranged in the font cache 2 locally connected to each microprocessor unit 1. In the global font cache area 315 placed on the shared RAM 4, a font management table 206, a font data section 201 and an overflow area 205 are arranged. In this embodiment,
The font management table 206 has 6 kbytes, the font data portion 201 has 128 kbytes, and the overflow area 205 has 2 kbytes.

The data structure on each of these memories is the same both in the local font cache 2 and in the font cache 315 on the shared RAM 4. In FIG. 2, these data structures are represented by the address bus 215,
It is an explanatory diagram for accessing by the data bus 216. In these actual bus accesses, local memory access is performed by the local bus of the microprocessor unit 1 and global access is performed by the global bus 3.

Each of these data structures will be described below.

The font management table 206 has a structure of a 6-byte registration flag 207, a 12-byte character designation record 208, and a 2-byte key 209.
It is a one-dimensional array consisting of 0 pieces. This structure is shown in FIG. Here, the character designation record has a data structure including the following elements.

[0024] However, the typeface is a name used to specify a difference in character shape when a plurality of character designs are performed on a certain character. In the above data structure, a numerical value is assigned to this name for use. In addition, the character modification designation is a designation that the shape of the target character is the operation target such as italicized characters and white characters, regardless of the character typeface. The expressions are digitized.

The font data section 201 is a memory having a continuous address arrangement of finite length. The inside is a set of management unit memories 202 having a size of 128 bytes. The management unit memory 202 includes a data part 204 having a size of 126 bytes and an index part 203 having a size of 2 bytes. The content of the indicator section 203 is
It is an index to the next management unit memory. Since the management unit memory 202 has a fixed size, the value of the real address can be obtained from the index value by a simple calculation.
That is, when the index value is ix, the head address of the management unit memory 202 that should be continued next is obtained as the value addr of the following equation.

Needless to say, the value 128 comes from the size of the management unit memory, and this operation is only an example of conversion to a real address. The index unit 203 of the management unit memory 202 is one of modifications of so-called concatenated pointers.

Actual character image data is stored by using a sub-number of data units 204 of the management unit memory 202. The content of the stored data is the number of management unit memories 202 used by the first two bytes, and the data following this is image data. Further, all the image data consist of a run-length compressed data string.

As is well known, as a memory management method, there is a method of dynamically arranging a variable length data string on a continuous memory. When this method is used, after repeated registration / deletion to / from the cache, a plurality of empty areas having irregular sizes due to unnecessary data strings occur.
In order to reallocate such unnecessary fragmented memory resources and recreate a large continuous free area,
It is necessary to perform processing that takes a long time to execute, including memory block movement. On the other hand, the means for using a plurality of fixed-length management unit memories adopted in the present embodiment is inferior to the dynamic memory management in terms of memory utilization rate because an unused portion occurs in the last-end management unit memory. Is. However, since the management is simple, it can be easily implemented as hardware, and even if the management program is executed by software, high speed processing is excellent.

The overflow area 205 is a continuous one-dimensional array having a size of 2 kbytes.

The font data section 201, font management table 206 and overflow area 205 as described above are all managed by a series of processing groups called cache allocation processing 217. These processing groups include read processing 210, write processing 211, and connection cancellation processing 212.

Next, the cache allocation processing 217 will be described.

Regarding the characters registered in the cache,
The image data is divided and stored in a plurality of management unit memories 202 starting from any management unit memory 202 in the font data section 201. At this time, as for the management unit memory 202 at the beginning, 300 management unit memories 202 are continuously used from the beginning of the font data section 201. Data for one character is stored in multiple management unit memories 20
The first management unit memory 202 index when recording in 2 is specified by the key 209 in the structure of the font management table 206. As mentioned above, the font data part 201 is about 1
It has a size of 28k bytes, but this is a management unit memory.
It is a set of 1024 pieces of 202. Due to such a limitation of the size of the array, in the present embodiment, the average image data per character is about 430 bytes.

Next, the flow of processing for obtaining character data will be described with reference to FIG.

When a request for acquiring character data is made in a process, the character data acquisition process 501 is called. Here, the request is made by the character designation record as described above. Needless to say, this is because it is necessary to handle character designations having different sizes, character types, and character modifications even with the same character code.

The processing procedure of the character data acquisition processing 501 is as shown in the flowchart of FIG. First, the microprocessor unit 1 which is executing the process first has a local font management table 2
Search for 06 (S801). The character management record that is the same as the character management record given here is the font management table 20.
If it exists in 6, the character data (character shape image data) exists in the local font cache. Therefore, the local reading from the font cache is executed (S802).

However, the local font management table 20
When the data of the corresponding character cannot be detected in the search of 6, the global font management table 206 is searched subsequently (S803). When the same character designation record as the character designation record exists in the font management table 206, the value of the access counter 508 which is a global shared variable is incremented by 1 (S804). The access counter 508 is a 48-bit long counter and is cleared at system startup. Thereafter, if the search target is not detected and the font management table 206 detects a search target, the character data acquisition processing 501, and if there is an element newly registered in the font management table 206, the character data registration processing 502 adds +1 respectively. To be done. In the use state of this embodiment, no overflow occurs. The value of the access counter 508 is recorded in the registration flag 207 corresponding to the detected element in the shared font management table 206 (S805). Since the value of the access counter 508 counts the number of times registration and reading are performed, the larger this number is, the more recently accessed element can be determined.

Subsequently, the key 209 of the corresponding element of the font management table 206 is taken out (S806), and the character data is read from the global font cache (S80).
7). If the matching element of the character-specified record cannot be detected in the global font management table 206, the kernel is requested to read the character data from the hard disk device 8 (S808).

This involves I / O processing. In this embodiment, during the I / O processing, each microprocessor unit 1
Suspends the currently executing process without waiting for the processing result
(S809). At this time, the update process 304 shown in FIG. 3 is executed. The update process 304 first exclusively locks the access of the other microprocessor unit 1 to the font cache area of the shared RAM 4. Next, all contents of the global font management table 206 and the font data section 201 are stored in the local font management table 206 and the font data section 201.
Transfer to. In this embodiment, this processing time is about 40 m
Seconds. After this processing ends, exclusive control of access to the font cache area on the shared RAM 4 is released.

On the other hand, when the outline font data has been read from the hard disk device 8, I / O
I / O termination processing is performed by the processor 6. First, a flag indicating the kernel program operation on the shared memory is checked to detect whether there is a microprocessor unit executing the kernel program.

If the microprocessor unit 1 executing the kernel program exists, the I / O processor 6
Sets the I / O end flag on the shared memory to true,
Complete the process. If the microprocessor unit 1 that is executing the kernel program does not exist, the I / O processor 6 sets the I / O end flag on the shared memory to true, and then uses the interrupt control circuit 14 to wait for a wait. Send an interrupt signal to the microprocessor unit 1. Here, when there is no waiting microprocessor unit 1, the interrupt control circuit 14 suspends processing and waits for execution of any process to be suspended.

When the kernel program is executed and the end of the processing of the I / O processor 6 is detected, the kernel program prompts the waiting microprocessor unit 1 to start the process by an interrupt, and the process that was previously paused. Restart processing is performed (S810). However, the restarted process is not always executed by the same microprocessor unit 1 as before the suspension.

The restarted process acquires the character data of the outline font by the kernel service (S81
1), generation processing of image data representing the shape of the character is performed (S812). This processing depends on the complexity of the character shape, but in the present embodiment, it is an average of 100 for Chinese characters with a size of 40 × 40 pixels.
A processing time of about msec to 200 msec is required. After this,
The microprocessor unit 1 executing the process
Character data registration processing 502 for the generated character image
Is called to register only in the global font cache (S813).

As described above, in this embodiment, the local font cache 2 does not perform writing except for the updating process 304. The local font cache 2 is always a read target.

FIG. 9 is a flow chart of the processing of the character data registration processing 502.

The character data registration processing 502 is called and used from the character data acquisition processing 501 with the character image data and the character designation record 208 as arguments. Registration process 5
02 calls the table search processing 213 (S901), searches the registration flag 207 of the font management table 206, and extracts the element having the smallest value (S902). At this time, the registration flag 20
If the value of 7 is 0, it is determined that the element has not been the target of font registration until now, or has just been deleted. Therefore, the content of the registration flag 207 is rewritten to hexadecimal FFFFFFFFFFFF. This is a temporary flag indicating that it is currently in use. Then, the contents of the key 209 corresponding to this element are taken out, and the writing process 211 is executed with the image data of the key and the character as arguments (S903). If an overflow area error is returned as the return value of the processing result, nothing is done and the registration processing ends. In this case, when the registration process ends, the value of the registration flag 207 is restored to the value before the process.

When a write error is returned as a return value of the write processing 211, the registration processing 502 is a deletion processing 503.
Is called (S904). As a result of this processing, an empty area is created in the font data part 201 of the font cache system, so the registration processing 502 again calls the write processing 211 with the key and image data as arguments. Furthermore, when a write error is returned as the return value of the processing result, the same processing is repeated and the registration is completed. In this case, the contents of the access counter 508 will be
1 is performed (S905), and this value is written in the registration flag 207 of the shared font management table 206 (S906).

Registration flag 207 of the font management table 206
When the element with the smallest value is retrieved (S90
2) If this value is not 0, delete processing 503 is called (S9
07), secure an empty area, and perform the processing after S902.

FIG. 10 is a flow chart of processing of the character data deletion processing 503.

The character data deletion processing 503 calls the table search processing 213 (S1001), extracts the smallest non-zero element from the registration flag 207 of the shared font management table 206 (S1002), and the key 209 corresponding to this element. The value of is obtained (S1003). Next, using the value of this key as an argument, the connection release processing 212 is called (S1004) and the processing ends. As shown in FIG. 5, the processing group of the cache allocation processing 217 is called from the character data acquisition processing 501, the character data registration processing 502, and the character data deletion processing 503.

Next, of the cache allocation processing 217,
Read process 210, write process 211, and connection release process 21
Each of 2 will be explained.

The processing of the read processing 210 will be described with reference to the flowchart of FIG.

The read process 210 extracts the key received as an argument (S1101) and calls the address calculation unit 214 (S1101).
1102), the pointer to the management unit memory 202 of the font data part 201 is acquired (S1103). Then, according to this pointer, the management unit memory 202, which is the head of the character image data storage, is accessed (S1104). Thereafter, the image data of the character is sequentially read according to the index to the connected management unit memory 202 (S1105). As already mentioned, the contents of the stored data are the management unit memory used by the first 2 bytes.
Since it is the number of 202, the required number of management unit memory 202
Can be connected. Further, the content of the index portion 203 of the management unit memory 202 located at the end of the series of connections is -1 (1
Hexadecimal number FFFF).

The processing of the write processing 211 will be described with reference to the flowchart of FIG.

The write processing 211 extracts the key value from the received argument (S1201) and calls the address conversion processing 214 with this value as an argument (S1202). As a result of this processing,
Obtain a pointer to the start address of the first management unit memory 202 that can be used for writing image data (S120
3). Next, the writing process 211 is executed by the management unit memory 202.
Is accessed (S1204), and the contents of the integer value (2 bytes) obtained by dividing the total data size of the image data by "management unit memory size-2" are written. This corresponds to the total number of management unit memories 202 required for data storage. Next, image data up to the size of the data section 204 is written in succession to the 2-byte data (S1205). Further, if there is a remaining number of bytes of the image data, the writing process first writes this data in the overflow area 205 (S120
6), inside the font data section 201 of the cache memory,
The unused management unit memory 202 is searched (S1207). If an unused management unit memory 202 is found, the index for the current management unit memory 202 is written to the index unit 203 of the management unit memory 202 that was accessed first, and a new bond is generated (S1
208). Then 126 bytes from the overflow area 205 (this is the size of the data section 204 of the management unit memory 202)
Data is extracted and written in the data section 204 (S1205).
This is repeated until the contents of the overflow area 205 become empty or there is no unused management unit memory 202. When there is no remaining data in the overflow area 205, the writing process ends normally. In this case, the contents of the index part 203 of the last-used management unit memory 202 are rewritten to the value FFFF indicating the end of the connection, and the end of the connection is generated (S1209).

On the other hand, if the unused management unit memory 202 cannot be detected by the required number and the image data remains in the overflow area 205, the write processing 211 returns a write error to the processing of the calling side (S1210). ) Stop processing. In this case, it is necessary to remove unnecessary character data from the font data section 201 of the font cache memory, expand the free space, and call the write processing 211 again. This processing is performed by the calling side (character data registration It is determined and executed in process 502).

The overflow area 205 is a memory area of consecutive addresses having a sufficiently large capacity for one character data. However, if image data of a character having a size that does not fit in the overflow area 205 is passed, , Write process 211
Returns an overflow area error (S1211) and terminates processing. In this case, the image data of this character is not registered in the font cache. This is because the characters having particularly large image data have an extremely low occurrence frequency, and even if they are registered in the cache, they do not contribute to the improvement of the processing speed of the system.

The processing of the connection cancellation processing 212 will be described with reference to the flowchart of FIG.

Management unit memory 202 from which data has been deleted,
Alternatively, the management unit memory 202 in which the data is blank is the index unit 2
Since the value of 03 is 0, the other management unit memory 202
Distinguished from. The connection cancellation processing 212 acquires a key that is the value of the index to the management unit memory 202 from the argument, and further calls the address conversion processing 214 (S1301). The address conversion processing 214 converts the key value into a real address by calculation, and generates a pointer that points to the first management unit memory 202 in which the character data to be deleted is recorded.
(S1302). Hereinafter, the connection cancellation processing 212 calculates the real address of the head address of the next management unit memory 202 from the index unit 203 of the management unit memory 202 indicated by this pointer, and replaces the contents of the subsequent index unit 203 with 0000 one after another. (S1304). As long as the connection of the management unit memories 202 continues, this operation is repeated until the contents of the index portion 203 reach the management unit memory 202 (hexadecimal number) FFFF. After this, the contents of the index part 203 of the final management unit memory 202 of the connection are changed from FFFF (in hexadecimal notation).
Rewrite to 0000 (S1305).

This is the end of the description of the means for accessing the data in the font cache used in this embodiment.

As a font cache memory management method used by the font management mechanism, there are some known methods. The font cache memory is basically a memory allocation of a finite length, and when new image data of a character is to be registered and the free space in the memory cannot be secured, the current registration is updated. That is, unnecessary data (image data of any character here) is deleted from the cache area, and new data is registered. The important management method is to retain the necessary data and delete unnecessary data. However, since there is no ideal method for predicting what kind of character data will be requested in the future, unnecessary data will be determined according to some standard. If this determination is appropriate, the probability that the requested character data will exist in the cache area (hit rate) will improve, leading to an improvement in processing speed. There are the following four typical management methods for determining unnecessary data.

Method 1: It is determined that the earliest registered data in the current data group is unnecessary. So-called Firs
t In First Out (FIFO) method.

Method 2: It is judged that the data which has not been used for the longest period in the current data group is unnecessary. The so-called Least Recently Used (LRU) method.

Method 3: A method in which the data that has not been used for the longest period is used next rather than the data that has been used most recently in the current data group, and the recently used data is determined to be unnecessary.

Method 4: It is determined that the least frequently used data in the current data group is unnecessary. So-called Least
Frequently Used (LFU) method.

Among the conventional methods, for example, Japanese Patent Laid-Open No. 64-886.
The 60 "font cache control method" uses a method obtained by improving the method 3 with respect to the method 1. In addition, JP-A-2-
202464 "Printer" uses Method 1.

These management schemes are methods invented for configurations that use a single font cache memory for a single font management mechanism. In the tightly coupled multi-microprocessor system (by bus sharing) as in the present invention, in order to establish the data coincidence of each font cache, it is necessary to manage the local font cache and the shared font cache individually. is there.

In this embodiment, the Least Recently Used (LRU) method is used in the local management of the cache.

The parallel execution of each microprocessor unit 1 is controlled by an interrupt signal generated by the interrupt control circuit 14. This will be described below with reference to the explanatory diagram of FIG. 3 and the state transition diagram of FIG.

The program executed in the printing apparatus control circuit of this embodiment is executed in parallel by the plurality of microprocessor units 1. At this time, the execution unit of each processor is called a process. A process is composed of a process header, a program object, and a work area. The process header contains the program counter value, stack pointer value, processor register value, memory size, memory management information, and process-specific management information when the process is started (including restart after interruption). included. The object part of the process contains the executable program code. The work area of the process is assigned to variables, stacks, etc. in the process. At the time of execution, the substance of the process is placed in the main storage area. In this embodiment, the shared RAM 4 has a memory space 300 as shown in FIG. 3, and processes 303, 308, 309, etc. are arranged therein. The number of processes at the time of execution is indefinite because a process is created by a process creation request to the kernel during program execution and disappears upon termination.

Each microprocessor unit 1 used in this embodiment has a jump mechanism to a specific address called some "exception processing vector". These are, for example, "vector to jump to when interrupt processing is performed" or "vector to jump after reset". Immediately after the power is turned on, all the microprocessor units 1 execute the instruction word of the specific address designated by the vector after reset. In the case of this embodiment,
This instruction word creates an infinite loop, and the processing of each microprocessor unit is in a standby state. An area 301 arranged in the memory space 300 on the explanatory view of FIG. 3 is an area including this infinite loop. Hereinafter, this is called a standby routine 301.

Next, the interrupt control circuit 14 selects one of the microprocessor units 1 and generates an interrupt signal. The interrupt is performed by designating the jump destination address at the time of the interrupt. The interrupt causes the program counter of the microprocessor unit 1 to be rewritten to a value outside the infinite loop. Here, the address including the jump instruction to the kernel area of the interrupt dispatch table is specified first, and the dispatch routine
Jump to 302 occurs. As a result, one of the four microprocessor units 1 starts the kernel process 306.

The operation of kernel process 306 is shown in the flow chart of FIG. Immediately after the processing is started by the interrupt, the kernel processing 306 determines whether the request at the time of the interrupt is the I / O end processing (S701). If this determination is true, I / O termination processing (S702) is executed. S701
If the determination is not true and the process of S702 is finished, it is checked whether there is a processing request in the queue S703, and if there is a processing request, the request content is processed (S704). Next, the processing status of the I / O processor is acquired (S705), and if there is completed I / O processing, S701 and subsequent steps are repeated. When all the processing requests in the queue have been processed, the determination S703 becomes false, the processing ends, and the process returns to the waiting routine 301.

The microprocessor unit 1 for executing the kernel processing allocates the execution of the start process of the print processing program at the first time after starting. In particular,
The value of the process start address is written in the dispatch table, and the interrupt control circuit 14 is used to generate an interrupt to another microprocessor unit 1. The interrupt control circuit 14 has a flag 16 indicating the operating state of the microprocessor unit 1. For the microprocessor unit 1 in the standby routine 301, the value of the corresponding bit of this flag is 1. Therefore, the interrupt control circuit 14
Monitors the value of this flag to identify the waiting microprocessor unit 1 and sends an interrupt signal to it. Since the jump destination address has been written in the dispatch table by another microprocessor unit 1 that is already operating in the kernel, the program counter of the microprocessor unit 1 to which the interrupt signal is input is changed to the specified address. ..

As a result, when the first print processing program is started, thereafter, all the operations are performed according to the processing flow of this print processing program. The print processing program generates a process for receiving a print control code from an external computer via the interface 13, receives the print control code, and performs print processing. In the middle of this
Character shape generation, print pixel rearrangement, engine control device
The data completion signal is transferred to 10.

Since the control circuit of the present embodiment has a multi-microprocessor structure, each process as described here is assigned a process as an independent execution unit. In particular, regarding character generation, a process is generated each time a line feed code is input. On the other hand, this character generation process ends when all the character generation up to the line feed code is completed, and the process termination request is enqueued to the kernel request queue (when adding an element to the queue, Enkyu, when the element is removed is written as Dekyu). When the kernel makes this request, the target process is removed from the memory space 300 and discarded, so the number of processes is at most several tens. In the explanatory view of FIG. 3, an example of a memory space and a program execution state at a certain time is given. In the memory space 300, in this case, three processes 303, 308, 309 and a dispatch routine 30
2, request generation process 305 to kernel, kernel process 306,
There are I / O processing 307 and update processing 304. In addition to this, a global (shared) area 315 of a font cache and a buffer 316 for storing data received from the interface are arranged in the memory space. Further, in FIG. 3, the arrow pointing to the right indicates the transition of the execution time, and the arrow pointing downward indicates the direction of the upper address in the memory arrangement. Polyline 31
Reference numerals 1, 312 and 313 respectively represent changes in the value of the program counter during execution of the microprocessor unit 1.

The updating process 304 realizes the main operation of the present invention in this embodiment. This will be described below with an example. When the microprocessor unit 1 that is processing the process 303 that is already executing attempts to create a new process, it makes a process creation request to the kernel. This request is made by calling the request generation process 305. Line 312 indicates that this causes the program counter to temporarily rewrite to the request processing 305 location. A process generation request is made at the position of arrow A. This request is enqueued in the request queue for the kernel. The kernel process 306 is executed by another microprocessor unit 1. Kernel processing 306 (Line 31
(Indicated by 3) takes this request, creates a new process 308, and assigns its execution start address to the dispatch routine 302.
Write to the dispatch table inside.

The microprocessor unit 1 executing the kernel processing 306 next uses the interrupt control circuit 14,
Identify another microprocessor unit 1 that is currently waiting and send an interrupt signal. The polygonal line 311 shows the locus of the program counter of the microprocessor unit 1 which executes the resulting process 308. The microprocessor unit 1 does not receive an interrupt and jumps to the dispatch routine 302 and then to the execution start address of the process 308.

In the above processing, when there is no waiting microprocessor unit 1, the kernel processing allocates the process execution by generating an interrupt when the microprocessor unit 1 in the waiting state occurs.

On the other hand, the microprocessor unit 1 which has previously executed the processing indicated by the broken line 312, in this example, next issues an I / O processing request. As already described in the flowchart of FIG. 8, this processing is involved when reading character data from the hard disk device 8. Therefore, the polygonal line 312, which is the locus of the program counter, is temporarily rewritten by the request generation process 305 again.

In this embodiment, all processes are I /
When the O processing is started, the continuation of the processing of the process is once stopped and the processing returns to the standby state. This allows the kernel to allocate the waiting microprocessor unit 1 for execution of another process. Because I / O processing often waits in the order of a few milliseconds, it is more efficient to use the processor resources by transferring the execution to another process rather than continuing the processing within the process by one processor. This is because it is advantageous to

All processes execute the update process 304 when the process is interrupted as described above and when the process is completed. In the case of process interruption, the content of the update process 304 records the current state of the process, and the local font cache 2 of the microprocessor unit 1 is recorded.
Is to update the contents of. This is realized by reading the contents of the font management table 206 and the font data unit 201 from the font cache 315 on the shared memory and transferring them to the local font cache 2 as described above.

When the process ends, the update process 30
The processing content of 4 releases the memory used by the process,
The following is to similarly update the contents of the local font cache 2 of the microprocessor unit 1.

A polygonal line 31 which is the locus of the program counter
2 shows how the update process 304 is executed at the position of arrow B. The microprocessor unit 1 then pauses the process and returns to the execution of the waiting routine 301 (S in FIG. 8).
See 809). At this time, the flag 16 of the interrupt control circuit 14
The value of the bit corresponding to this microprocessor unit of 1 is set to 1 and the entry into the standby state is recorded.

On the other hand, when the I / O processing is completed by the I / O processor 6, the interrupt control circuit 14 sends an interrupt signal to the waiting microprocessor unit 1. As a result, the microprocessor unit 1 in which the locus of the program counter is shown by the polygonal line 312 starts execution of the kernel processing 306. In this case, the I / O end processing is first performed as already described in the flowchart of FIG. Therefore, the polygonal line 312 temporarily enters the area of the I / O processing 307. Here, the kernel process that has taken out the processing result of the I / O processor 6 restarts the process 303 that was paused. Here, since the microprocessor unit 1 indicated by the broken line 313 is in the standby state, the kernel processing 306 causes the interrupt control circuit 14 to interrupt the microprocessor unit 1. By this interrupt processing, the designated microprocessor unit 1 passes through the dispatch routine 302 and restarts the processing from the address of the process 303 which was suspended previously (see S810 in FIG. 8). This is the position indicated by arrow C.

The above is the flow of the operation of the parallel execution and update processing 304 in this embodiment.

Next, another example of the updating process 304 will be described.

In the above embodiment, the update process 304 is
All of the font management table 206 and all of the font data section 201 are transferred from the font cache 315 on the shared memory to the local font management table 206 and font data section 201 of the font cache 2. This is because in each process of font reading and registration, after incrementing the access counter 508 which is a shared variable, the registration flag 207 of the font management table 206
This is because only the global (shared) font management table 206 is operated when updating.

However, the font data section on the shared memory
The process of transferring the entire contents of 201 to the local memory makes it difficult to use a font cache of a certain size or larger in terms of processing speed. If you want to implement a font cache with an extremely large size (1 Mbytes or more), you should transfer more effectively. In order to realize this, the following part may be modified as another embodiment.

First, in the flow chart of the character data acquisition processing 501 of FIG. 8, the registration flag update (S805) is described as the font management table 206 and the local font cache 2 on the shared memory 4.
Change so that both of the above font management tables 206 are performed. Further, in the flow chart of the character data registration processing 502 of FIG. 9, the registration flag update (S906) is performed for both the font management table 206 on the shared memory 4 and the font management table 206 on the local font cache 2. To change.

As a result, the update process 304 can be performed as shown in the flowchart of FIG. That is, the contents of the font management table 206 on the shared memory and the contents of the font management table 206 on the font cache 2 are individually compared (S1
401). If the registration flag 207 of the font management table 206 in the shared memory is newer (larger in value) than the registration flag of the same position in the font management table 206 in the font cache 2, this element (of the font management table 206 in the shared memory ( 207,208,209 all), font cache 2
Transfer to the same position in the upper font management table 206 (S140
2). Next, take out the key at this position and put it in the font data section.
Management unit memory 202 for the start position of font data in 201
Calculates the first address of (S1403). Furthermore, from the font data section 201 on the shared memory 4, the management unit memory 20
The contents of 2 are sequentially read in accordance with the linked list for all the data of one character, and are overwritten in the same position of the font data portion 201 on the font cache 2 (S1404). At this time, the deletion process is unnecessary. Subsequently, it is determined whether the font management table 206 is finished (S1405), and (S140
1) The subsequent processing is repeated until the table ends. In this process, the processing time of the update process 304 is shortened as the contents of the font cache are stabilized and the frequency of registration of new characters decreases.

In the printing apparatus according to the present embodiment, the contents of the local font caches 2 of the plurality of microprocessor units 1 can be matched with each other by the process management involving the updating process 304 as described above. it can. On the other hand, during the process execution, the data reading from the font cache 2 can be performed at high speed by not accessing the shared memory space.

That is, the present embodiment shows a font management method in which font registration involving a writing operation is performed in the shared memory and reading is performed only from the local memory. When a font is registered in the font cache, it is not written to the local memory, so memory address management is simple, and there are few restrictions on the arrangement of the local memory and the shared memory, and the font is flexible.

In addition, in the configuration of the above embodiment, FIG.
It goes without saying that the engine controller 10 and the print engine 11 can be directly applied to devices such as a display device and a workstation by replacing the parts of the engine controller 10 and the print engine 11 with a graphic controller and a CRT device.

[0094]

As is apparent from the above embodiments,
In a processor having a multiprocessor structure, when a local font cache is arranged in each microprocessor, it is easy to maintain the data consistency in the cache by the character data management means of the present invention. In addition, the present invention is a solution for achieving matching of font caches without additional hardware, and is highly effective in terms of device cost.

Since the contents of the individual local font caches are substantially the same, there is an effect that a cache hit rate of a certain level or more can be secured no matter what process allocation is performed.

Even if there is no corresponding character data in the local font cache, the global font cache management table is first referenced, so that the characters already created and registered by other processes are registered. It can be used if there is data. This has an effect of preventing the duplication of the process in which a plurality of processes try to read the outline font original data of the same character from the hard disk device, and as a result, there is an effect that the I / O process becomes a bottleneck. ..

[Brief description of drawings]

FIG. 1 is a block diagram of an embodiment of the present invention.

FIG. 2 is an explanatory diagram of a font cache system.

FIG. 3 is an explanatory diagram of multiprocessor processing.

FIG. 4 is a state transition diagram of multiprocessor processing.

FIG. 5 is a schematic configuration diagram of character data acquisition processing.

FIG. 6 is an explanatory diagram of a data structure of one element in the font management table.

FIG. 7 is a flowchart of kernel processing.

FIG. 8 is a flowchart of character data acquisition processing.

FIG. 9 is a flowchart of character data registration processing.

FIG. 10 is a flowchart of character data deletion processing.

FIG. 11 is a flowchart of read processing.

FIG. 12 is a flowchart of a writing process.

FIG. 13 is a flowchart of connection cancellation processing.

FIG. 14 is a flowchart of another embodiment of update processing 304.

[Explanation of symbols]

1 ... Microprocessor unit 2 ... Font cache 3 ... Global bus 4 ... Shared RAM 5 ... Shared ROM 6 ... I / O processor 7 ... Disk controller 8 ... Hard disk device 9 ... Image memory 10 ... Engine controller 11 ... Print engine 12 ... bus arbitration control circuit 13 ... interface 14 ... interruption control circuit 15 ... bus arbitration circuit 16 ... flag indicating the operating state of the microprocessor unit 201 ... font data section 202 ... management unit memory 203 ... index section 204 ... data section 205 ... Overflow area 206 ... Font management table 207 ... Registration flag 208 ... Character designation record 209 ... Key value (index) 210 ... Read processing 211 ... Write processing 212 ... Delete processing 300 ... Memory space 301 ... Standby routine 30 2 ... Dispatch routine 303, 308, 309 ... Process 304 ... Update process 305 ... Request generation process 306 ... Kernel process 307 ... I / O process 315 ... Shared font cache area 501 ... Character data acquisition process 502 ... Character data registration process 503 ... Deconsolidation processing

─────────────────────────────────────────────────── ─── Continuation of the front page (51) Int.Cl. ⁵ Identification code Internal reference number FI technical display location G09G 5/22 9061-5G

Claims (1)

[Claims] 1. A plurality of processors, a shared font cache commonly accessible from the processors, an outline font supply unit commonly accessible from the processors, and a local font cache accessible to each of the processors. However, in response to the character acquisition request at the time of process execution, first try to read from the local font cache, read it if there is, if not, try to read from the shared font cache. The original data is read from and the character pixel data is generated and registered in the shared font cache. A character data management device characterized by transferring the contents of a shared font cache to a local font cache and updating the contents of individual font caches when a process is terminated or paused at the time of execution.