JPH07104988A - Program generator - Google Patents

Abstract

PURPOSE:To generate a parallelized source code so as to equalize the load of each processor by properly adjusting processing granularity in the automatic generation of the source code of a page descriptive language having a parallel processing syntax as a language specification. CONSTITUTION:When a printer driver 11 calls each image operation, a calling side program refers to the branch table to an image processing procedure performing the service of an OS by a fixed procedure. An image processing procedure number acquisition means 49 counts the calling via this branch table. A granularity determination means 50 recognizes the number of processor which is possible to be used for a parallel processing and determines parallelized granularity by using the number of procedure acquired by the means 49. The printer driver 11 outputs a complex sentence to be processing unit by the granularity calculated by the granularity determination means 50 in accordance with the grammar of a parallel syntax. As a result of the processing, the source code including a parallel execution part is outputted in accordance with the grammar of a page descriptive language.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a technique (automatic generation of source code) of writing out the contents of a target process as a source code according to a grammar of a predetermined programming language. Particularly, in the print processing of a personal computer, it relates to a means for writing down the procedure of image operations such as characters and figures for each page of a document according to the grammar of a program language called a page description language.

[0002]

[Prior art]

1. Parallel processing One of the technologies to improve the processing speed is parallel processing. In order to perform parallel processing, the following two stages are necessary.

(1) A process of extracting a part that can be executed in parallel and a part that cannot be executed in parallel from the contents of a target process and transmitting it to a processing system by a distinguishable description.

(2) A process in which a plurality of processor resources are actually used and executed in parallel.

The automatic generation of the source code of the programming language according to the present invention is the technique used in (1).

2. Page description language There is a programming language called page description language. This program language inputs the source code of a program representing the description procedure for a figure or character and outputs pixel data. The output destination device may be a printer, a CRT or a facsimile machine.

For example, the page description language has a command word for creating a linear pixel, so that the user can say {command word of linear command, coordinate data of start position, coordinate data of end position}. Given the information, the page description language translation executive program performs the operation of creating pixels. To this end, for application programs,
In the display or printing process, the operation of outputting the source code of the page description language is easier than the operation of generating pixel data every time.

In the instruction word of the page description language, each operation is often accompanied by pixel generation. This indicates that the average completion time of instruction word processing is long. Such processing contents are also suitable for loosely coupled parallel processing in which overhead for parallelization is likely to occur. The loosely-coupled parallel processing can be configured by connecting a general-purpose workstation or the like with a communication means without using dedicated hardware, and is inexpensive, excellent in maintainability, portability, and portability. Developing a system that can be used in loosely coupled parallel processing will greatly contribute to the improvement of processing efficiency.

3. Equalization of load In parallel processing, the end of the target processing is the time when all the processing devices that share the individual processing parts have completed processing. In other words, if any one of the devices has a processing delay, the overall processing time is delayed. Therefore,
It can be said that the processing efficiency is highest when the processing contents are divided so that each device finishes the processing in substantially the same time.

By the way, when parallel processing is performed using "apparatuses having similar processing speeds" whose characteristics are known in advance, highly efficient parallel processing can be performed by giving processing contents of approximately the same scale to each processing apparatus. Can be done. When constructing loosely coupled parallel processing using a general-purpose workstation, etc., it is possible to know the performance and processing characteristics of each device in advance. Applicant's Japanese Patent Laid-Open No. 3-815831 discloses a coarsely coupled parallel processing system.

On the other hand, Japanese Unexamined Patent Publication No. 04-127284 is a well-known example in which image manipulation is performed by tightly coupled parallel processing. The division of processing for parallelization is performed each time a procedure involving pixel generation is called.

[0012]

In the technique disclosed in Japanese Patent Laid-Open No. 04-127284, each time a procedure involving pixel generation is called, the processor shares the processing and is parallelized. When this method is used in a coarsely coupled processing system, processing for parallelization and overhead due to communication between processors are large, and efficient parallelization cannot be achieved.

The present invention was devised in view of the above problems of the conventional invention, and its purpose is to suppress the occurrence of useless processing procedures when processing is parallelized, and evenly apply a load to a plurality of processors. Therefore, it is an object of the present invention to provide a printing apparatus that can more efficiently bring out the effect of parallel processing.

[0014]

An apparatus for writing an image operation procedure processed by an application program for printing into a source code according to a grammar of a program language when printing a document composed of figures and characters,
An image processing procedure number acquisition means for acquiring the number of procedures called by the series of image operations, and an image processing procedure number acquired by the image processing procedure number acquisition means by knowing the number of processors available for parallel processing. And a granularity determining means for determining an appropriate processing unit for parallel processing, and generate a constant syntax defined by the grammar of the programming language.

[0015]

[Action]

(1) In the individual image operation by the application or printer driver, the calling program is
The image processing procedure is called via the branch table serviced by the operating system.

(2) The image processing procedure number acquisition means counts the number of calls through this branch table.

(3) The granularity determining means knows the number of processors that can be used for parallel processing, and uses the number of image processing procedures and the number of processors acquired by each means to determine the granularity for parallelization. decide.

(4) The application or printer driver creates a syntax for performing parallel processing according to the granularity determined by the granularity determining means.

[0019]

EXAMPLES Examples suitable for explaining the present invention will now be described.

1. Operating environment The operating environment of the embodiment is an environment that satisfies the following conditions.

(1) A plurality of personal computers (hereinafter abbreviated as PC) or workstations (hereinafter W)
A local area network (hereinafter abbreviated as a network) is connected to each other. As a network, for example, the specifications defined by IEEE-802.x are currently widespread. In addition to the mechanical and electrical connections of the network, there are regulations related to transmission procedures called protocols. In this embodiment, TCP / IP is used as the transmission protocol. TCP / IP is a general term for multiple protocols, but it is widely used at present and explained in many publicly known materials.

(2) The user of at least one of the PC and WS included in the above conditions uses the application program. Further, the user performs print processing in this application program.

(3) On the PC and WS included in the above conditions, the operating system (hereinafter abbreviated as OS) is
Manages the execution and termination of application programs.
The OS may have its own specifications for each PC and WS. However, it is assumed that any OS handles the TCP / IP protocol on the network. In addition, in any OS, so-called multi-task processing causes a plurality of processing programs to execute CP.
It is premised that U resources are allowed to be used in a time-sharing manner.

(Supplement) Douglas Comer "INTERNETWORKING WITH TCP / IP: PRINCI"
PLES, PROTOCOLS, ANDARCHITECTURE ", Prentice-Hall, I
nc. 1988 2. Configuration of Embodiment, Outline of Processing Procedure FIG. 1 is a diagram showing an outline of the overall configuration of a parallel processing printing apparatus of the present invention. The configuration and processing procedure are as follows.

(1) The user uses application 1 to perform print processing. The application 1 outputs a source code 2 written in a parallel processing page description language (hereinafter abbreviated as parallel processing PDL). Some of recent OSs that place importance on the graphical user interface function are designed so as not to burden the application with the function related to printer control. In this case, the application 1 calls a function (function, procedure) of embedded software called a printer driver provided by the OS. The called function / procedure in the printer driver 11 outputs the source code 2 written in the parallel processing PDL.

(2) The parallel language compiler 3 inputs the source code 2 output by the application 1 (or the printer driver 11) and outputs the object code 4. The object code 4 is a data string composed of a machine language for the virtual machine and necessary parameters.

(3) The virtual machine 5 inputs the object code 4, interprets and executes the machine language instruction, and generates a pixel.

(4) The printing device 6 receives the pixel data generated by the virtual machine 5 and performs the printing process for each page.

In the above processing, (1) and (2) are sequentially executed. Therefore, the application 1 and the parallel language compiler 3 may be executed by the same computer. At this time, the communication 7 between the application 1 and the parallel language compiler 3 is performed by means called interprocess communication.

On the other hand, (3) is executed in parallel using a plurality of PCs and WSs. The same processor device may execute the parallel language compiler 3 and at least one virtual machine 5. In this case, the communication between the parallel language compiler 3 and the virtual machine 5 is also interprocess communication.

Alternatively, the parallel language compiler 3 and the virtual machine 5 may be executed by different processor devices. At this time, the communication 8 between the parallel language compiler 3 and the virtual machine 5 is performed using the network. Further, communication 9, 10 between the virtual machine 5 and another virtual machine 5 is also performed using the network.

(Supplementary) Public Information on Interprocess Communication and Network Communication W. Richard Stevens "UNIX NETWORK PROGRAMING", Pren
tice Hall, Inc. 1990 (Supplement) Description of Process A process is a unit of resource management such as CPU time and memory area allocated by the OS to a plurality of processing programs. A process is a management unit consisting of a process header that contains the process identifier and information for execution management and memory management, an area for saving the current processor register status at the time of suspension, an object area, and a stack area. Is. The OS based on this embodiment executes a plurality of programs at the same time. A program consists of one or more processes. Therefore, the execution of multiple programs is
It may be said that the process is a process of scheduling resources such as a processor and a memory in a plurality of processes by time division. Since the communication between programs is actually performed between any process that constitutes one program and another process, the term interprocess communication is used. This term is also used in known materials such as the above-mentioned documents.

3. Known part of the mounting technology of this embodiment The following technology is known.

(1) Technology for automatically generating PDL source code by application or printer driver (Lase Writer by known material Apple Computer, Inc.)
Printer driver program and others).

(2) Compiler for parallel language (known document M. Ben-Ari "PRINCIPLES OF CONCURRENT PROGRAMMIN
G ", Prentice-Hall International, Inc. Other textbooks on multiple parallel languages).

(3) A method for executing a page description language in parallel by a plurality of processor devices (known document: Japanese Patent Laid-Open No. 3-3003)
815831).

(4) Execution of program using virtual machine (publicly known material Ikuo Nakata "Compiler", Sangyo Tosho, 1981
Other textbooks about multiple compilers).

4. Features of this Embodiment Regarding the features of this embodiment, first, the same parts as in JP-A-03-815831 and JP-A-04-127284 will be mentioned, and then the different parts will be mentioned.

4A. JP 03-815831 A and JP 0
The same processing characteristics as the 4-127284 publication The process until a plurality of processor devices interpret the contents of a source code written in a page description language, generate pixels, and print using one printer Coordinate and execute in parallel.

4B. JP 03-815831 A and JP 0
Difference from JP-A-4-127284 (1) Difference from JP-A-04-127284 In the configuration of the present embodiment, since the processor is used in a coarsely coupled state using the network, it is necessary to transfer a plurality of processing contents. It takes 10 to a hundred tens of milliseconds. On the other hand, in a tightly coupled processing system using a system bus, this time is several hundred microseconds to several milliseconds. For this reason, the grain size must be increased in the coarse coupling processing system.

More specifically, when writing in a page description language, it is appropriate to select a processing unit consisting of a plurality of procedural statements and use it as a unit of parallel processing. Applicant is JP-A-3-81
Japanese Patent No. 5831 discloses a method of reading already generated source code and dividing it into a plurality of new source codes. However, a more appropriate method is to prepare a parallel processing page description language and specify the parallel processing part in advance in the source code given to it.

(2) Difference from Japanese Patent Laid-Open No. 03-815831 In other words, Japanese Laid-Open Patent Publication No. 03-8155831 does not presume a parallel processing page description language. On the other hand, this embodiment defines the language specification of the parallel processing PDL, and the application 1 outputs the source code 2 described in the parallel PDL. In the related art using the parallel PDL, the preprocessing of the PDL compiler analyzes the source code and extracts the executable parts in parallel. On the other hand, the parallel language compiler 3 of this embodiment generates one machine language code string according to the parallel description. That is, since the parts that can be executed in parallel are designated in advance in the source code, a plurality of special machine languages for parallelizing the processing are inserted into the object code according to this designation.

5. Technology for Implementing Features of the Present Embodiment As described in 4B, the feature of the present embodiment is that the application (or printer driver) has the granularity of the source code describing the contents of the image processing according to the grammar of the parallel processing PDL. The point is that they are generated evenly. The following three technologies are the main technologies for realizing this feature.

(1) Processor number acquisition means 48 (2) Image processing procedure number acquisition means 49 (3) Granularity determination means 50 The operation of the means 48, 49, 50 is 6B-2 using FIG.
I explain in a section.

6. Details of the technique for realizing the features of the present embodiment.

Next, the technique which characterizes this embodiment described in 5 will be described in detail.

6A. Language Specification of Parallel PDL (1) Description by Simple Example In the parallel processing PDL of this embodiment, a language in which parallel syntax and extension for image processing are added to a subset of the language Pascal is defined and used. To illustrate the extension of the grammar of this language, Figure 2 shows a simple source code example. The sentence enclosed by the predicate "begin" and the predicate "end" is called "complex sentence" for the sake of explanation. Targets for parallel execution in the source code of FIG. 2 are a plurality of statements surrounded by predicates “proceed” 21 and predicate 22. Statements starting with the predicate "//" 23 are distributed to other processor units if possible and executed in parallel. If no other processor device is available, it will run on the same processor device. The sentence following the predicate "//" 23 is a single sentence or a compound sentence. When using a compound sentence, describe as 24. Statements starting with the predicate "otherwise" 25 (which are also statements or compound statements) are always executed on the own processor device without being distributed. The predicate "otherwis
"e" 25 cannot be omitted, and if nothing is done, write an empty sentence (blank sentence).

(2) Description of the syntax analysis processing program The above-mentioned part is a specification regarding parallel syntax among the specifications of the language. A known technique for developing a processing program that analyzes a syntax is a technique called a compiler / compiler. Compiler-Compiler is the name of software that inputs text in which the syntax specifications of a language are written and outputs the source code of a syntax analysis program. The widely known one is YACC. YACC is often used as a standard tool in UNIX operating systems. Also in this embodiment, the syntactic analysis processing program of the parallel language compiler 3 was developed using YACC.
Regarding the syntax of the parallel description shown in (1), the description of the analysis rule given as the input of YACC is shown in FIG. However,
Here, the "//" statement is represented by a "when_stm" statement. This is because, as is well known, the restrictions on the symbols that can be used in YACC have been followed. The “proceed-end” sentence is shown as sentence 30. That is, the "proceed-end" statement starts with the reserved word PROCEED, ends with the reserved word END, and has when_body and opt_other as constituent elements. The component when_body starts with the reserved word WHEN and has statement as a component. Here, the character strings corresponding to the main reserved words are as follows.

Reserved word PROCEED = character string'proceed 'reserved word END = character string'end' reserved word WHEN = character string '//' (Note) UNIX operating system is UNIX System La
Developed and licensed by boratories, Inc.

6B. Operation of Application 1 and Printer Driver 11 The parallel language compiler 3
It is started by giving some input to. This input must be a source file described according to the "parallel PDL" grammar. The means for creating this source file is the application 1 or the printer driver 11. The known part (6B-1) and the devised part (6B-2) will be described below separately.

6B-1. Part of the Known Technology In this embodiment, a commercially available personal computer that is widely used is used as an apparatus that uses an application program. In the case of this device, it is not the application 1 that creates the PDL source code at the time of printing but an independent service program called the printer driver 11. From the viewpoint of the OS function of the personal computer, the printer driver 11 can be regarded as a lower layer program called a print manager 41 incorporated as a service program of the OS.

The printer driver 11 is software developed and supplied for each type of printer according to the structural characteristics of each printer. Therefore, in this embodiment, the printer driver 11 that meets the specifications of the parallel processing printing apparatus of this embodiment is developed and mounted on the commercially available personal computer.

FIG. 4 is a diagram for explaining the relationship among the application 1, the print manager 41, and the printer driver 11. The structure is as follows.

(A) OS of this personal computer
Of the components of, only the part related to printing and display is 4
2 shows.

(A) The image processing group 43 shows the means constituted by the procedure / function for actual pixel generation. The image processing group 43 includes a standard procedure 44 prepared in advance and a changeable procedure 45.

(C) The print manager 41 reads the program of the printer driver 11 from the auxiliary storage device such as a hard disk device into the main storage area of the processor and puts it in an executable state.

(D) The device driver 46 is a physical device 4 such as a serial interface control IC.
7 is a means for controlling.

The operation is as follows.

(1) When the application 1 creates pixels of figures and characters and displays them on the CRT device, the procedures / functions of the image processing group 43 are individually called and used.

(2) The application 1 calls up the function of the print manager 41 when producing pixels of figures and characters and printing them on the printing apparatus, and performs initialization of printer driver necessary for printing and other processing. (If necessary, make settings for the actual hardware such as the serial interface). The printer driver 11 replaces the changeable procedure 45 with its own processing procedure group as an initial setting.

(3) When performing printing, the application 1 individually calls the procedure / function of the image processing group 43 and prints following the procedure of (2) in the same procedure as the display of (1). At this time, the processing branch program of the image processing group 43 is
Instead of the standard procedure 44, the process branches to the changeable procedure 45. Since the above operation (2) has already been performed, the processing procedure prepared by the printer driver 11 is used as a result.

(4) Creating the spool file 40 is a widely used method for completing the printing process for the application 1 at a fast stage. When the spool file is created, the application is released from the input / output processing related to the print processing, and then the printer driver continues the processing according to the data in the spool file. The data saved in the spool file is
It may be a binary code string of an image processing procedure or a source code according to a specific language specification, and the data content differs depending on the processing system.

(5) The printer driver 11 uses the replaced procedure group as the changeable procedure 45 to generate the PDL source code for the command word of the image processing procedure output from the application program. Next, the device driver 46 is called to transfer data to the PDL processing means.

More specifically, for example, if the PDL processing means is incorporated in the printing apparatus, and this printing apparatus is connected to this personal computer through the serial interface, the device driver 46 will be serialized as the physical device 47. Specify the interface controller and transfer data.

Alternatively, when the virtual machine for PDL processing is installed in the WS as in the configuration of the present embodiment described in FIG. 1, the device driver 46 designates the network controller as the physical device 47, and Transfer. After receiving and executing this, the WS transfers the pixel data obtained as the processing result to the printing device 6 and performs the printing process.

6B-2. Part peculiar to this embodiment In this embodiment, a parallel PDL in which parallel execution becomes even
Printer driver 1 to output the source code of
3 means were incorporated into 1.

(1) Number of Processors Obtaining Unit 48 In the parallel processing system of the present embodiment, the process is executed by using as many processors as possible. The purpose of this means is to mount the virtual machine 5 that performs pixel generation processing and obtain the number of processors that can be used for parallel processing.
Available processors include computers within a networked computer or other information device, or processors within itself.

To obtain the processor, there is a method of recording the processor to be used in a file or the like in advance. With this method, it is easy to obtain the number of processors. In addition to the above-mentioned method, the processor number acquisition means of this embodiment confirms whether or not a process can be generated at the time of parallelization with respect to a processor connected by some means, and acquires the number of processors. Take the way.

The procedure will be described with reference to the flowchart of FIG.

(51) The processor number obtaining means 48 initializes the count of the number of processors to "1".

(52) Send a message to the connected processor to confirm whether the process of pixel generation processing can be generated. The processor that received the message
Examine the memory usage, determine if a new process can be created, and return the resulting message.

(53) The processor number acquisition means determines whether a process can be generated according to the content of the received message.

(54) If the process can be generated as a result of the determination, the count of the number of processors is incremented by 1. On the other hand, if the process cannot be generated, the counter is left unchanged.

(55) From steps (52) to (55) until confirmation is made for all connected processors.
The series of processing of is repeatedly executed. The count number obtained at the time when the processing is completed is used as the number of usable processors in the subsequent granularity determining means.

(2) Image processing procedure number acquisition unit 49 The purpose of this unit is to count the number of procedures executed in the printing process. In order to realize even parallelization, it is first necessary to grasp the number of procedures in the entire process. In this embodiment, a method of temporarily creating the spool file 40 on the auxiliary storage device is used before the printer driver creates the PDL source code.

The data structure of the spool file 40 is shown in FIG.
3 shows. The spool file is mainly composed of the following five fields.

(A) Area 131 for storing information for setting the printer such as resolution and paper size. (A) Area 132 for storing the number of print pages (c) Area 133 for storing the number of image processing procedures (d) Area 134 for storing an offset value to page data storage area 135 (e) Area 135 for storing page data The fields 133, 134, and 135 record information for each page. The page data stored in the field 135 is a code string of a procedure that the application outputs to actually draw the image of the document, and is recorded as binary data. The image processing procedure number acquisition means 49 counts the number of procedures and records it in the field 133 at the stage of creating the spool file in the previous term.

From the viewpoint of image generation in PDL, each procedure stored in page data can be roughly divided into two groups. One is an instruction that involves the generation of pixels. For example, filling, contour generation, etc. The other one is an instruction that does not actually generate pixels, for example, designation of a drawing pen size, designation of a region figure for filling, formation of a curved shape for stroke generation, and the like. The processing of the page description language is characterized by repeating the procedure of "definition of image → generation of pixel". Therefore, at least a process capable of detecting a procedure involving pixel generation is required. In this means 49, only the procedure involving pixel generation is the object of counting the number of procedures. The processing procedure of the image processing procedure number acquisition means 49 will be described with reference to FIG.

(61) Image processing procedure number acquisition means 49
Initializes the number of procedures with '0'.

(62) Each time a procedure is written in the spool file, the nature of the procedure is judged. (63) It is determined whether the procedure involves pixel generation.

(64) In the case of a procedure involving pixel generation,
Increase the number of procedures by '1'. On the contrary, if it is not accompanied, the processing is continued without doing anything.

(65) The number of procedures is counted page by page. A series of operations from steps (62) to (64) are repeated until the code string of the procedure for one page is completed.

(67) If it is determined that one page has been completed, the current number of procedures is recorded in the area assigned to each page in the field 133. The processing of the present means 49 ends when the number of procedures has been recorded for each page.

(3) Granularity determining means 50 The purpose of this means is to determine the granularity so that the units of processing executed in parallel are evenly allocated to the processors that can be used, and create the PDL source code. The processing flow will be described with reference to FIG.

(150) The granularity determining means 50 determines the granularity which is the execution unit of parallelization. The granularity is calculated by rounding off the value of m / n, where n is the value obtained by the processor number acquisition means 48 and m is the value obtained by the image processing procedure number acquisition means 49. However, when the value obtained as a result of the calculation is "0", the granularity is set to "1". When the granularity is determined, the process shifts to the process of creating the PDL source code.

In this embodiment, the page description language specification "all instruction words do not depend on the processing result of the preceding image" is used. In the language of this specification, the image processing result is
All the pixels are overwritten by ignoring the pixels of the preceding process. In this case, the following two points are necessary.

As will be described later in (3) of 6D, the consistency of the superposition order is maintained.-The insertion position of the parallel syntax is at least one procedure up to the pixel generation. Specifically, the procedure is as follows.

(151) Output the declaration part of the program.

(152) Predicate "pr" representing the start of parallel execution
output "oceed".

(153) A counter for counting the number of procedures in one unit to be executed in parallel is initialized to '0'.

(154) The predicate "//" representing the start of the parallelizable execution unit is output.

(155) In order to count the number of procedures, it is determined whether or not the procedure involves pixel generation.

(156) 1 is added to the number of procedures only when pixel generation is involved.

(157) Until the page data is completed,
Generates and outputs procedural statements used as source code.

(158) It is determined whether the page data is finished.

(159) It is determined whether the count of the number of procedures at the present time is equal to the granularity calculated in the granularity calculation (150).

(160) If the number of procedures is equal to the granularity as a result of the judgment (159), the predicate "end" is output, and the processes from steps (153) to (160) are performed again. The series of processes described above is repeatedly executed until the data of one page sentence is completed (158).

(161) When the page data is completed, the "end" statement is output even if the number of procedures is less than the granularity value.

(162), (163) A program termination procedure statement is output and the process is terminated.

By the above processing, the processing to be parallelized on the source code is explicitly indicated.

(4) Example of Output Source Code FIG. 7 shows an example of the source code generated according to the processing of the flowchart of FIG.

In the procedure (151) in FIG. 15, the program start portion of 7 and 1 is output. Until the count of the number of procedures becomes equal to the value obtained in the granularity calculation process (150), the procedural statements used in the source code are generated, and as in the description 72, "// begin --- end;" Output as a compound sentence. The particle size determination means 50 repeats this
The following statements 73, 74, etc., output the same number of compound statements in the format "// begin --- end;" equal to the number of processors. When all the descriptions per page are completed, the printer driver 11 outputs the syntax 76. Printing of multiple pages is a repetition of this.

In the range 75 surrounded by the “proceed--end;” format, the number of procedures involving pixel generation included in each of the reprints 72, 73, and 74 is equal. Therefore, when the processing of each sentence is assigned to each available processor, it is possible to execute the processing in parallel evenly.

6C. Implementation and Operation of Parallel Language Compiler 3 The compiler 3 is composed of lexical analysis processing, syntax analysis processing, and code generation processing. As described above, in this embodiment,
The source code of the parsing part was created using yacc, and the compiler was developed. The development of a compiler by this means is a widely known and well-known technique. Also, the lexical analysis processing and the code generation processing are similar to those of various known compiler programs, and have no special configuration.

The compiler 3 of this embodiment does not output the machine language of a specific processor but sets a virtual machine instead,
Output the machine language of the virtual machine. This method is also widely used. The compiler 3 outputs one virtual machine language object code even when N processor units are used and executed in parallel. The object code of one virtual machine language includes a virtual machine language specifically designed to multiplex processing at the execution stage. This will be described below with an example.

An example of the procedure used in this embodiment for image manipulation will be shown.

(A) Procedure that does not directly manipulate pixels newpath () ... area definition start command penSize () ... drawing pen size specification command penPat () ... drawing pattern specification command polygon () ... polygon, curve Definition command line ()… Line definition command oval ()… Oval contour definition command etc. (b) Procedure involving pixel operation strokepath ()… Contour and line pixel generation command fillpath ()… Region filling command invert ()… Instruction to invert the brightness of pixels in the area

FIG. 8 shows an example of source code including a simple parallel execution statement. This example is shown for the purpose of explaining the processing result of the compiler 3, and the granularity of parallel execution is smaller than the granularity set by the granularity determining means 49 of this embodiment. The diagram shown in the area 80 is a diagram showing a graphic obtained as a result of execution according to the list of FIG.

FIG. 9 shows a list in which the object code output when the compiler 3 processes it as an input is written in the assembler format. The compiler 3 translates, for example, the procedure statement 81 into a plurality of virtual machine code strings indicated by 91 when written in the assembler format.

(Supplement) The virtual machine language will be briefly described. PUSH
C (00) places the constant at the top of stack memory. NEG (17)
Inverts the sign of the top value in the stack memory. TRAP (2
In a), a software interrupt is used and a branch is generated by referring to the dispatch table of each procedure call. ADDSP
(30) adds a constant to the stack pointer value.

In order to multiplex the processing at the execution stage, the compiler 3 outputs the following three types of machine language.

(1) FORK (2f) // statement or // begin --end; This is a machine language generated by the compiler 3 at the position where the compound statement starts.

(2) EXIT (2d) // statement or // begin --end; Machine language generated by the compiler 3 at the position where the compound statement ends.

(3) WAIT (2e) proceed--end; This is a machine language generated by the compiler 3 at the position where the statement ends.

6D. Operation of Virtual Machine The virtual machine 5 is an interpreter that executes the instruction words of the virtual machine language "sequentially" with the object code 4 output by the compiler 3 as an input.

(A) Configuration of Virtual Machine and Its Operation (1) Startup FIG. 10 shows a configuration diagram of the virtual machine 5. Virtual machine 5 is OS
It is a process that runs under the control of. The virtual machine 5 communicates with an external program via the communication socket 101. After the compilation operation is completed, the compiler 3 records the object code 4 as a file and transmits the virtual machine language of the object code 4 to the virtual machine 5. Due to post-processing, all virtual machine languages are temporarily stored in the reception buffer 110.

In the virtual machine 5 having received this, the process duplicating means 102 performs the same process 103 as itself.
To duplicate. After this, the process 103 actually executes the virtual machine language object code 4. This method is the most commonly known technique for receiving multiple requests in a single process and multitasking.

(2) The execution process 103 sequentially reads the virtual machine language of the object code 4 via the communication socket 130 and passes it to the execution control means 104. The execution control unit 104 is a core unit for performing stack management and program pointer management of the virtual machine, and branches each machine language to actual processing.
The execution control means 104 interprets the meaning of each machine language,
In the case of a general control word (stack operation instruction, operator, jump instruction), the processing 105 is executed through the dispatcher. Further, an image operation command (command TRAP (2a) in this embodiment)
In the case of (starting with), each procedure included in the image processing library 106 is executed.

(A) Machine language for parallelizing processing and its operation The execution control means 104 uses 6C as an instruction word in a special case.
Execute FORK (2f), EXIT (2d), and WAIT (2e) described in. Each of these instructions corresponds to the corresponding P_FORK processing 107 and P_EX.
It is composed of an IT process 108 and a P_WAIT process 109.

(1) P_FORK Processing 107 The P_FORK processing 107 performs processing equivalent to process duplication at the virtual machine language level. That is, P_FORK processing 107
Refers to the reception buffer 110 and transfers a data string of a virtual machine instruction word from the beginning to the end to another virtual machine 5 installed on another processor. Using Figure 1,
This is indicated by communication 9.

As described above, since the virtual machine 5 is an interpreter, it can be easily mounted on other machines having different architectures. This is because the development language (for example, C
This is because it is sufficient to write an interpreter program in the language or Pascal language), compile it, and then implement it. Further, the communication between the virtual machine 5 and another virtual machine is communication between sockets using a network, and is only a technique widely used today.

Another virtual machine 5 mounted on another processor receives the virtual machine language, stores it in the reception buffer 110, and executes it. At this time, it is not possible to determine whether the partner who sent the virtual machine language is the compiler 3 or another virtual machine 5. The virtual machine 5 simply executes.

Returning to FIG. 9, the machine language will be described.

The execution control means 104, which has executed the processing of the P_FORK processing 107 (that is, the FORK (2c) virtual machine language), sets the value "0" as the processing result to the top of the stack when the transfer of the virtual machine language is completed correctly. Put. After instruction 92 in FIG.
If the processing is completed correctly, the value at the top of the stack = 0. The instruction 93 performs an address relative jump when the value 0 at the top of the stack. Here, the process branches to the address + 2a ahead in hexadecimal. Therefore, after the P_FORK process 107 is correctly completed, the execution control means 10 of this virtual machine 5
4 is a hexadecimal number display and continues processing from the address 0033.
As a result, the processing unit 94 (processing unit 82 in FIG. 8) is executed by another virtual machine 5, and this virtual machine 5 executes the next execution statement (0
Address 033) and the subsequent processing.

Due to a communication failure, a non-implementation of a virtual machine, etc.
When the P_FORK process 107 is not executed correctly, the value at the top of the stack is = 1. At this time, the branch of the instruction word 93 is not executed. Therefore, the machine words after the address 000a will be sequentially processed. Events such as communication failure and non-installation of virtual machines are detected as errors, and the P_EXIT processing 108 is ignored at the time of error. Therefore, P_FORK processing 1
If 07 fails, even a machine language string including parallel processing as shown in FIG. 9 is sequentially processed.

(2) P_EXIT processing 108 In another virtual machine 5 that received the virtual machine language in (1),
As the initial value, the value at the top of the stack is set to "1". In the example of FIG. 9, the branch of the instruction 93 does not occur. As a result,
This virtual machine 5 has a processing unit 94 (processing unit 82 in FIG. 8).
To execute.

The last instruction of the processing unit 94 is EXIT (2d). When this instruction is detected, the execution control means 104 causes P_EX
The IT process 108 is executed. As a result of this processing, all the contents of the image memory 111 are returned to the virtual machine 5 which is the source of the virtual machine language instruction. After that, the execution control unit 104 regards the processing as end, closes the communication socket, and ends the execution of the process.

(3) P_WAIT Processing 109 The virtual machine 5 that is the source of the virtual machine language instruction first
At the position of the command word 95, a synchronous waiting state is entered. That is, when the execution control unit 104 calls the P_WAIT processing 109, the P_WAIT processing 109 distributes the processing to other virtual machines 5
Waits for the processing result to be returned. When the processing result is returned, the P_WAIT processing 109 uses the contents of the image memory 111 returned as a result, as the image memory 111 in the own process.
Copy to.

At this time, the only limitation is the order of the superposition processing. When superimposing "independent figures" obtained by parallel processing, superimpose them according to the order in which the descriptions appear in the source code. In the example of FIG. 8, the image obtained from the first “// begin --end” sentence is displayed below, and the second “/
Put the image from the "/ begin--end" sentence on top. As a result, as shown in the image of the area 80, the curved line is overwritten on the shaded portion.

(C) Printing Operation The processing results of all the image operations in the program are recorded in the image memory 111 by the above processing procedure. As shown in the example of FIG. 8, the image operation command executed at the end of the page description is the “show page” statement 83. This sentence is the description 9 in FIG.
Translated into 6. When the virtual machine 5 detects this command, it transfers the contents of the image memory 111 to the printing device 6.
By this processing, the flow of the printing processing for one page is completed. 7. Second Embodiment The present invention will be described with reference to another embodiment. The overall configuration of the device is the same as that shown in FIG. The preconditions for processing are also the same.

At present, even in personal computers, the capacities of the main storage device and the auxiliary storage device such as a hard disk have been expanded. If it is temporary, the entire source code to be output can be recorded in the main storage device or the auxiliary storage device.

When the buffer 60 can be secured as a sufficiently large area as compared with the above embodiment, the processing procedure shown in FIGS. 11 and 12 can be considered. Processor number acquisition means 48
Acquires the number of processors in the same procedure as in the first embodiment.

(1) Image processing procedure number acquisition means 49, FIG. 11 (111) The printer driver 11 generates each procedural sentence in the page description language in the processing from the page start to the page end.

(112) The source code of the generation result is recorded in the buffer 60. At this time, the image processing procedure number obtaining unit 49 determines whether (the instruction word of) the procedure is a process involving pixel generation.

(113) When pixel generation is involved, the image processing procedure number acquisition means 49 adds 1 to the procedure number count.

(114) When pixel generation is involved, the procedure count used for the source code is generated with the procedure count kept unchanged.

(115) The source code for each procedure is stored in the buffer 60 until the page is completed.

(2) The granularity determining means 50 and FIG. 12 (122) The granularity determining means 48 sequentially reads the source code recorded in the buffer 60 until the end of the page.

(123) At this time, the number of procedures is sequentially counted.

(124) Similar to the first embodiment, the granularity determined from the number of processors and the number of procedures obtained above is used to compare with the current number of procedures.

(125) When the count of the number of procedures becomes equal to the granularity, the syntax of parallelization is added on the source code.

In this processing, the source code is generated once and then the writing is performed. However, when the buffer 60 is arranged in the main memory, it can be processed at a sufficiently high speed.

8. Extension of First Embodiment (1) Extension of Source Code Generation In most cases, the source code of the page description language is machine-generated by software such as a printer driver. The page description language compiler / interprinter receives the machine generated source code directly. From this point, it is not necessary that the source code be described by a character string.

There is a method of assigning an appropriate code to a reserved word and adopting a so-called binary code description rather than using a reserved word of a character string in the source code. The binary code is more advantageous in terms of shortening the code length, shortening the code transfer time, and hiding information. Even if the source code is described in a data format other than a character string, the compiler can deal with it by changing the lexical analysis processing. Also, the virtual machine is not subject to any changes. Therefore, it is easy to change the source code description means of this embodiment.

(2) Necessity of the granularity determining means 50 The granularity determining means 50 adjusts the granularity of parallel processing according to the number of processors. In a loosely coupled processing system, the processing distribution overhead cannot be ignored, so it may be more efficient not to subdivide it more than necessary. On the other hand, in an extremely large processing unit, the number of parallelizations decreases, and the effect of improving the processing speed decreases. Therefore, the balance with the processing content is important.

In the first embodiment, if the number of image manipulation procedures is smaller than the number of processors, the "granularity 1" is set, and each procedure becomes a unit of parallel execution. If the overall size of the processing is small, consider the overhead due to parallelization and perform sequential processing. In this case, a reference is set to the minimum value of the granularity, and if it is less than the reference value, parallelization is not performed. Alternatively, it is also possible to reduce the number of processors used and increase the granularity. In either case, realization is easy.

A method of parallelizing each procedure is also possible without using the granularity determining means shown in the first embodiment. This is a particularly fine-grained process. Fine-grained processing is
Suitable for tightly coupled devices with extremely short processing times for distributing processing to multiple processors. About this device, 1
A second embodiment will be given in Section 0.

9. Effect that occurs in the entire apparatus of the first embodiment In the printing apparatus of the present embodiment, the application (or printer driver) efficiently generates the source code describing the image as described above according to the grammar of the parallel processing PDL. The parallel processing PDL compiler inputs this description result as a source file and outputs the machine language of the virtual machine. With this as an input, the interpreter executes image generation in parallel. As a result, the following effects were produced throughout the printing process.

(1) Regarding a general page printer, the performance at the time of purchase remains unchanged with respect to the processing speed. However, the printer equipped with the parallel processing PDL becomes faster by mounting the virtual machine for parallel processing on the WS on the network. As the number of office WSs increases, the speed of individual printers can be improved.

(2) Even if the end user (consumer) purchases a new high-speed page printer, only one is fast. However, a user who uses a page printer that supports parallel processing PDL has a fast WS on the network.
If you implement a virtual machine on your system, you can benefit from the speedup of all parallel PDL printers.

(3) There is a general merit caused by parallel processing. Prevent the peak load from being concentrated on a specific device. The processing speed is improved.

10. Second Embodiment A preferred embodiment in which the present invention is applied to a fine-grain parallel processing system will be described with reference to FIG.

(1) Configuration The page printer 146 is a device having an electrophotographic print engine 145. The image processing device of the page printer 146 includes a plurality of microprocessor units 1
41 is a system that is bus-coupled via a system bus 142. Each microprocessor has a system bus 14
2 can access the common memory 147. Each microprocessor processes a virtual machine interpreter program similar to that of the first embodiment.
The personal computer 144 is connected to the image processing apparatus of the page printer 146 by the communication path 143.

(2) Operation The user of the personal computer 144 performs print processing from the application program. The application program uses an operating system service to call an image operation (function / procedure) for print processing prepared by the printer driver. The printer driver creates the source code of the page description language as a process in the procedure that received the call. This generation procedure is 6
This is the same as the processing described in B-1.

Next, the printer driver calls the function of the device driver and sends the generated source code to the page printer 146 via the communication path 143. The page printer 146 compiles the received source code and creates an object code in virtual machine language. This object code is executed by a virtual machine implemented using multiple microprocessors.

(3) Differences from the First Embodiment In the page printer 146, a plurality of microprocessors use the common memory 147 and the system bus 142,
Communicate with each other at extremely high speed. In this case, since the communication time for parallel processing is short, parallel processing may be performed for each instruction word involving image operation.

Therefore, the printer driver may generate a parallel syntax each time an image operation is performed. This is a special case where the grain size determining means 50 is executed with "grain size = 1". However, even in the tightly coupled multiprocessor device as in this embodiment, the processing time for parallelizing the processing is not zero. This is natural considering the processing time of the virtual machine language P_FORK (2f). The processing of P_FORK (2f) is the same as the processing of 6D (1) also in this embodiment. However, instead of the communication using the network, the communication using the system bus 142 is performed. The parallelization processing time is mainly determined by the number of running steps of the program and the bus arbitration time. This time is from a few hundred microseconds to a few milliseconds.

From this, it can be said that the grain size determining means 50 is still necessary, and the appropriate grain size must be determined depending on the system to be treated.

(4) Extension of the Second Embodiment In this embodiment, the architecture of the microprocessor unit 141 is uniform. In this case, there is no problem even if the virtual machine and the real machine are matched. No special machine language such as FORK (2f), EXIT (2d), or WAIT (2e) is built in the actual microprocessor. However, this can be implemented as a library function. The same applies to command words for various image processing procedures. This change can be realized by changing the compiler part of the embodiment. The code generation process itself of the present invention does not change.

[0160]

As is clear from the above embodiment, the following effects are brought about by the structural features of the present invention.

(1) Since the processing unit is divided into the number equal to the number of processors used for parallel processing, the time consumed by the processing for parallelization is minimized and the source code is efficiently generated. You can

(2) The number of predicates included in a series of operations, which is a unit of parallel processing, is adjusted to generate a parallelized source code with a uniform grain size. As a result, the processing time of each processor is not biased, and it is effective in improving the speed of the entire processing.

[Brief description of drawings]

FIG. 1 is an explanatory diagram of processing of an application and a printer driver.

FIG. 2 is an explanatory diagram of parallel syntax.

FIG. 3 is an explanatory diagram of syntax definition.

FIG. 4 is an explanatory diagram of the overall configuration of the printing apparatus.

FIG. 5 is a flowchart of the process of the processor number acquisition unit 48.

FIG. 6 is a flowchart of the processing of the image processing procedure number acquisition unit 49.

FIG. 7 is an explanatory diagram of a program generation result.

FIG. 8 is a diagram illustrating an example of a compiler operation.

FIG. 9 is a diagram illustrating an example of a compiler operation.

FIG. 10 is an explanatory diagram of a virtual machine.

FIG. 11 is a flowchart of the processing of the image processing procedure number acquisition unit 49.

FIG. 12 is a flowchart of the processing of the grain size determination means 50.

FIG. 13 is an explanatory diagram of a data structure of a spool file.

FIG. 14 is a configuration diagram of a second embodiment.

FIG. 15 is a flowchart of the processing of the grain size determination means 50.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 1 ... Application program 2 ... Source code written in parallel language 3 ... Parallel language compiler 4 ... Object code by virtual machine language 5 ... Virtual machine (process which comprises) 6 ... Printing device 11 ... Printer driver 40 ... Spool file 42 Operating system 43 ... Image processing procedure group 44 ... Standard procedure 45 ... Changeable procedure 46 ... Device driver 47 ... Physical device 48 ... Processor number acquisition means 49 ... Image processing procedure number acquisition means 50 ... Granularity determination means 60 ... Temporary buffer 141 Microprocessor unit 142 System bus 143 Communication path 144 Personal computer 145 Electrophotographic print engine 146 Page printer 147 Common memory

Claims (1)

[Claims] 1. An apparatus for writing an image operation procedure processed by an application program for printing into a source code according to a grammar of a program language when printing a document composed of graphics and characters, wherein By using the image processing procedure number obtaining means for obtaining the number of procedures called by the image operation and the number of processors available for parallel processing, and using the image processing procedure number obtained by the image processing procedure number obtaining means, A program generating device comprising: a granularity determining means for determining a processing unit suitable for parallel processing, and generating a constant syntax defined by a grammar of a programming language.