JPH10222381A - Data processing system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To enable host application to process a large data block by emulating a multiprocessing pipeline in single processing environment by forming a pipeline so as to obtain data from a data source. SOLUTION: The host application 50 when deciding that processed data from the data source 66 are necessary generates a data processing pipeline 80 and makes a call by a calling means 54. To generate this pipeline 80, an instance generating means 52 accesses a library means 10, and generates an instance-generated function or task from an uninitialized function and stores it in a block of a memory. This instance-generated task is linked with the host application means 50 or another task. Then the data processing pipeline 80 processes the raw data from the data source 66 into usable format and sends it to the host application 50.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

The present invention relates to the processing of images, including image headers and image data, by emulating a multiple processing environment in a single application environment. In particular, the present invention creates a stream-oriented data processing structure that is linked between a host application and a data source or between a host application and a data user to emulate a pipeline data structure such as UNIX. Object-oriented system using a library of predefined objects or data structures.

[0002]

BACKGROUND OF THE INVENTION The use of data processing pipelines in a real multiprocessing environment is well known. Examples of known multiprocessing environments include both multiprocessor systems and high-level systems in which a single processor can support actual multiprocessing. UNIX
The ® operating system is often used in such multi-processing systems.

In such a multiprocessing environment, processing large volumes of highly structured data blocks, such as those associated with image processing, database processing, or spreadsheet processing, requires a data processing pipe. The line is very effective. Such a data block typically includes one header and one or more data lines or data sets. The header indicates the type of data, its characteristics, and how many data sets are in the date block. When working on such data blocks, various data processing operations must be performed on each data set within the data block before the data can be used by the host application. No. Further, these various data processing operations are performed in a particular order.

[0004] In a multi-processing environment, data processing pipelines provide a very efficient way to process data blocks. In these data processing pipelines, each individual data processing operation is defined as a section of the pipeline. Each section is linked to one or both sections (upstream and downstream sections) adjacent to that section. Thus, the data processing pipeline forms a chain of pipeline sections linked between the host application and the data source or between the host application and the data user. In computers with many independent processors, each pipeline section corresponds to one of these processors. In this case, each processor works independently and the computer's operating system controls the data flow and memory allocation between the processors. This allows data to be processed efficiently, but the overhead required to control the processor and memory consumes most of the system resources.

Similarly, in a computer having a single processor capable of simultaneously executing many different and independent processing operations or processes, each pipeline section corresponds to one of the independently operating processes. I do. In this case, the operating system allocates the execution time of each process, the data flow between each process and the memory, and the memory allocation. In this case, each process and its data must be swapped in and out of the processor each time the process is executed, thus increasing the overhead required to control the computer. Consume part of the resource. Furthermore, as these processes communicate through the operating system, it is difficult, if not impossible, to change the pipeline dynamically.

Generally, data sources for pipelines include spreadsheets (spreadsheets) that provide financial information, records (records) in database files that provide database information, and original documents (original documents). Image data generated by the image scanner of
And computer generated images. The host application includes a graphics program for generating pie charts, bar charts, etc. from the processed financial data,
It may be an inventory survey, accounting, or combination program using data of the processed database, or an image forming apparatus for forming an image from the processed image data.

[0007] Regardless of the particular data source, or the underlying host application, the first or most upstream section of a data processing pipeline is often the data source for that pipeline. Alternatively, the data source of the first pipeline may be the second pipeline. In this case, using a specially branched or "fan-out" pipeline section of this second pipeline to feed data to both the first pipeline section and a section downstream of the second pipeline section. Can be. In either case, the first pipeline section gets the data element for that pipeline from the data source and makes this data element available to the second pipeline section immediately downstream. The second pipeline section receives the data element from the first pipeline section, processes the data element and passes it downstream to the next immediately downstream third pipeline section.

In an actual multiprocessing environment, the first pipeline section obtains the next data element from the data source and outputs it to the second pipeline section, and the second pipeline section receives from the first pipeline section. Process this data element and output it to the third pipeline section. Thus, as each data element is processed by one of the pipeline sections, this data element is output to the next downstream section and ultimately to the host application. In a multi-processing environment, data can be processed efficiently and quickly by associating one processing operation or processor with each section of the pipeline. This allows the pipeline to process data blocks with data processing capacity limited only by the least efficient pipeline section, resulting in overhead inefficiencies.

On the other hand, in a single processing environment, various methods for processing large blocks of data can be used, but each method is less efficient than multiple processing systems. For example, one method performs each data processing operation on every data element in a data block, and then performs another data processing operation on any of the data elements in that data block. That is, before performing a second data processing operation on any of these elements, a first data processing operation must be performed on all elements of the data block. The efficiency of data processing operations in a single processing environment is proportional to the efficiency of each data processing operation.

In a multiprocessing environment, data elements move continuously from one data processing section of one pipeline to another data processing section, and this data processing command is continuously transferred into and out of the active memory of the system. The system overhead required to manage a multi-processing system is large compared to the overhead required in a single processing environment.

[0011]

Accordingly, the present invention provides a system and method for processing large blocks of data by emulating a multiprocessing pipeline in a single processing environment. In the present invention, a library of image processing operations is provided. Each image processing operation or function in the library is a class or subclass in an object-oriented system. Each section of the pipeline is an instantiated function that includes one or more image processing functions, ie, tasks, and data structures sufficient to self-define the state of the task.

[0012]

SUMMARY OF THE INVENTION In a first embodiment of the present invention, a host application uses this pipeline to obtain data from a data source. This is called a pull system.

[0013] When the host application requires data processed from a raw data source (eg, image data from a scanner or image data file) in operation, a pipeline between the data source and the host application is required. Is formed. The data processing pipeline inputs raw data from a data source, processes the data into a format usable by the host application, and sends the processed data to the host application.

The image processing pipeline is formed by calling one of the functions in the image processing library and instantiating the called function to form a first task. This first task will be the most upstream section of the pipeline. This upstream pipeline section receives data elements to be processed from a data source. In an image processing system, a data element is a single scan line of a raster scan of an image. The data source is a scanner, facsimile machine, remote computer, or sensor, etc., which outputs serial or parallel data signals or blocks of data stored in a memory such as a ROM, RAM, or a disk in a disk drive. I do. Data elements can also be generated directly by the first pipeline section itself. In this case, the data element can be obtained from the value of the initialized variable or from the state of the first pipeline section or the like. When the first pipeline section is instantiated, the reverse or upstream link of the host application is set in the first pipeline section.

Next, the second pipeline section generally needs to process the data elements obtained by the first pipeline section. Thus, the host application creates another task by instantiating one of the functions in the library to form a second pipeline section. When the second pipeline section is created, the second pipeline section is automatically linked to the first pipeline section. Further, the link of the host application is reset to this second pipeline section. If no other image processing operations are required, the host application link remains between the portion of the host application that requires processed data and the second pipeline section.

Also, if the pipeline requires additional sections to further process the data, the host application makes additional calls to the function library to instantiate additional tasks, ie, pipeline sections. The newly created task becomes the third, fourth, etc. section of the data processing pipeline. As each additional pipeline section is created, a reverse link is formed between each additional pipeline section and the immediately upstream pipeline section, and the link from the host application is the last instantiated task. (Ie, pipeline section).

Access to each pipeline section is controlled and maintained by the pipeline section immediately downstream of the operating system, or by the host application in the case of the last pipeline section. Thus, the overhead required to maintain memory is minimized and there is no overhead required to schedule the execution of a task. Thus, the control system of the present invention avoids the disadvantages of multiple processing environments by combining the advantages of efficient processing with the benefits of minimal overhead in a single processing environment.

A host application using such a pipeline system can maintain a single processor / single tasking environment, a single processor / multitasking environment using automatic time sharing, or a real application while retaining the advantages described above. It can operate on a multi-processor / multi-tasking environment. This pipeline structure is independent of the type of processor running the host application, as the host application, not the operating system, creates, maintains, controls and terminates the pipeline. Thus, the host application may be one of many independent applications running on a single processor multitasking system. The host application uses this pipeline system to execute the pipeline from the scanner without having the operating system schedule the pipeline or allocate or deallocate memory for the pipeline. Can be. Thus, the overhead drawbacks typically associated with operating a pipeline with an operating system can be avoided.

In another embodiment of the pull system of the present invention, a header data channel is used to simplify data processing operations. In this embodiment, to start processing a data block, the host application requests a data block header from the last section of the pipeline. Each section of this pipeline requests a header from the upstream pipeline section to which it is linked. This is done by making a procedure call from the downstream pipeline section to call the upstream pipeline section. This is similar to pushing the downstream pipeline section onto the stack. When a header is requested from each upstream pipeline section, the processor stops processing the downstream pipeline section and starts processing the upstream pipeline section.

When a request reaches the first pipeline section, the first pipeline section obtains or generates a header for the data block and returns it to the second pipeline section via a header data channel.
When the first pipeline section returns the header, the CPU
Stops the operation of the first pipeline section and activates the second pipeline section. This is similar to popping off the downstream pipeline section from the stack. Each section of the pipeline processes the header data and indicates what the section does to the data lines in the data block. Each section returns the processed header data via the header data channel to the next downstream pipeline section. After the last pipeline section has processed the header, this last pipeline section returns the fully processed header data to the host application.

When the host application receives the processed header data, the host application knows how many data lines are in the data block. The host application requests the first line from the most downstream pipeline section. Until the request reaches the first pipeline section, each intermediate pipeline section requests one data line from the immediately upstream pipeline section to which it is linked. The first pipeline section receives the first data line from the data source or generates one data line and then sends this data to the section immediately downstream. Each intermediate section processes the data received from the upstream section and sends this processed data to the section immediately downstream, which is ultimately sent to the host application.

The above process is repeated until all of the data lines making up the data block have been processed and received by the host application. Thus, the efficiency of an image processing pipeline depends only on the least efficient sections of the pipeline.

In another embodiment of the pull system of the present invention, the header data processing channel is not used, and the header data is first processed during instantiation of the data processing pipeline. In this embodiment, when the host application instantiates a first pipeline section, the first section immediately obtains or generates header data representing a data block to be processed by the pipeline. When the second pipeline section is instantiated, the second pipeline section receives header data from the first pipeline section and processes the header data to reflect data processing operations to be performed by the second section. . Each instantiated pipeline section acquires and processes a header immediately after instantiation. When the pipeline is completed, the host application already has the processed header data, and the host application can immediately call the first data line from the data block.

In yet another embodiment of the present invention, a pipeline is used to provide data for further processing. This is called a push system. In operation, when a host application supplies data to a data user, data storage device, or output device, a data processing pipeline is formed between the host application and the data storage device or output device. The data processing pipeline inputs data from the host application, processes the data into a form usable by a storage device or an output device, and sends the data to the storage device / output device.

The push system pipeline is generated by instantiating an image processing function from the function library using the pull system. The first task in this pipeline is a software interface to storage / output devices. Other additional tasks may be added between the first task and the host application to form an intermediate task. The host application is linked to the last instantiated task.

As data flows from the host application to the storage / output device, the last instantiated task linked to the host application is considered the most upstream task in the pipeline and the storage / output The task linked to the device is considered the most downstream task.

In operation, the host application passes the data item to the most upstream task. This top-level task processes the data item and passes it to the next downstream task. This process is repeated until the last task in the pipeline has been performed on the data item and the data item has been passed to the storage / output device.

As with the pull system, in another embodiment of the push system of the present invention, a header data channel is used to simplify data processing operations. In this embodiment, to begin processing a data block, the host application supplies the header of the data block to the last pipeline section of the pipeline (the most upstream task). The final pipeline section processes the header to indicate what it does to the data lines of that data block.
The last pipeline section then puts the processed header of the data block from the last two through the header data channel.
Pass to the second pipeline section. When the final pipeline section passes the header, the CPU stops the operation of the final pipeline section and starts the operation of the penultimate pipeline section. Each section processes the header data and sends this processed header data to the next downstream pipeline section via the header data channel. After the first pipeline section (the most downstream task) processes the header, the first pipeline section provides fully processed header data to the output device. A response indicating that the header data has moved through the pipeline is returned upstream to the host application via the pipeline.

When the processed header data has been received by the output device, the pipeline section and the output device know how many data lines are in the data block. Next, the host application supplies the first data line to the final pipeline section. The final pipeline section processes the data provided by the host application and provides the processed data to the immediately downstream pipeline section. Each subsequent intermediate section processes the data received from the upstream pipeline section and passes the processed data to a section immediately downstream, which is ultimately provided to an output device.

The above process is repeated until all of the data lines that make up the data block are supplied by the host application, received by the pipeline, and received by the output device. Therefore,
The efficiency of an image processing pipeline depends only on the least efficient sections of the pipeline.

Other objects and advantages will become apparent with a full understanding of the present invention. Reference should also be made to the following description and claims in connection with the accompanying drawings.

[0032]

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS As shown in FIG. 1, a computer 100 has a single processing controller (CPU-central processing unit) 21. The computer 100 includes an input / output (I / O) interface 22, a ROM 24,
It also has AM26. The CPU 21 transmits a control signal via the control line 28 to the I / O interface 22 and the ROM 2
4 and to the RAM 26,
It sends data to the I / O interface, ROM 24, and RAM 26, and receives data from them.
The function library 10, the data source 12, the display 14, the keyboard 16, the mouse 18, and the disk drive 19 are connected to the CP via the I / O interface 22.
It is connected to U22. Mouse 18 refers to any secondary pointing device, such as a mouse, trackball, light pen, touch screen, or touch pad. Disk drive 19 may be any non-volatile storage such as analog or digital magnetic or optical tape, hard drive, hard card, floppy disk and floppy disk drive, CD-ROM and CD-ROM disk drive, or flash memory, etc. The device is shown.

The CPU 21 is a single processing processor.
That is, since the CPU can actively process data for one application at a time, it can operate and execute only one data processing operation at a time. The I / O interface 22 connects the CPU 21 to a serial or parallel data input or output source via a serial data port (not shown) or a parallel data port (not shown).
Connect. These data sources include not only the keyboard 16 and the data source 12 but also the disk drive 19.
And mouse 18. As mentioned above, data source 1
Reference numeral 2 includes a scanner, a facsimile machine, a remote computer, a sensor, and the like. The I / O interface 22
It also includes the necessary hardware to drive the display 14 and to input signals from the keyboard 16, mouse 18, and disk drive 19.

The ROM 24 stores all basic operating programs for the CPU 21, including the bootstrap and the like. RAM 26 comprises a large number of randomly accessible memory locations. RAM 26
Are the blocks 26a, 26b, 26c, 26d, 26e,
And 26f can be divided into blocks of assignable memory. Allocatable memories 26a-2
The 6f block has one host application,
One or more instantiations of the data processing functions (ie, sections of the data processing pipeline) that form the data processing task can be stored. Display 14
Outputs visual information, and the keyboard 16 is used to input information to the computer 100.

The function library 10 stores a library of uninitialized data processing structures or objects that form the data processing functions called by the CPU 21. The function library 10 is represented as an independent element accessed via the I / O interface 22.
It will be appreciated that it may be stored within or on a non-volatile memory device accessed via the disk drive 19. Further, newly written data processing functions not yet stored in the non-volatile memory device or function library 10 in the disk drive 19 can be stored in the RAM 26.

Similarly, data source 12 is shown external to computer 100 and accessed via I / O interface 22. However, the data source 12 may be stored in the ROM 24 or RAM 26, on a non-volatile memory device in the disk drive 19, or in the CPU 2
It may be one register counter or data stored in an internal memory. Data source 12 may also include data entered via keyboard 16. As noted above, ultimately, the first pipeline section may generate the data elements themselves, rather than obtaining the data elements from some external source.

As shown in FIG. 18, the data processing system 200 of the present invention includes a host application unit 50, a library unit 10, a memory management unit 56, and a data processing pipeline 80. The data processing pipeline 80 comprises one final task means 60 connected to the host application means 50, at least one
One intermediate task means 62 and one first task means 6
4 inclusive. Data processing system 200 may, but need not, include data source means 66. If the data source means 66 is not included, the first task means 6
4 also performs the function of the data source means 66. The plurality of links 70 connect the first task means 64, at least one intermediate task means 62, and the final task means 60. Of course, it should be understood that a simple pipeline 80 may include only the first task means 64 and the final task means 60. Data input link 72 connects data source means 66 to first task means 64.

The host application means 50 includes a data processing means 58 for further processing the data received from the data processing pipeline 80. First, the data processing system 200 includes the host application unit 50, the library unit 10, and the memory management unit 56.
Including only. The host application means 50 operates the processor according to the instructions included in the host application 50. The processor may be a single processor operating in a single tasking environment, a single processor operating in a multitasking environment, or a multiprocessor computer operating in a multitasking environment. In each case, the host application means 50 operates as if it were in a single tasking environment.

When the host application means 50 determines that data processed from the data source 66 is necessary, it creates and calls a data processing pipeline 80. Therefore, the host application means 50 includes the instance generating means 52 and the calling means 54.

To generate the pipeline 80, the instance generating means 52 accesses the library means 10 to obtain one of the uninitialized functions, and generates an instantiated function or task. Store in a block of memory. The function for which the instance is generated, that is, the task, is stored in the host application unit 50.
Or linked to other already created tasks. If the task is linked to a host application means, this task is the final task 60. If this task is linked to another task and the other task is linked to the host application means, the task is an intermediate task 62. This task is the first task 64 if the task is linked to another task and obtains data from the data source means 66 or generates the data itself.

When generating a task by instantiating a function, the instance generating means 52
6 and memory blocks 26a to 26 of the memory 26.
Assign one of f and store the task. After all of the desired tasks have been instantiated, the calling means 54 calls the pipeline 80 by requesting data from the final task means 60. Calling means 5
4 flows (ripples) toward the first task means 64 in the upstream direction of the pipeline 80. When the request reaches the first task means 64, the first task means obtains data from the data source 66 or generates the data itself. Next, the first task means 64 returns the data to the intermediate task means 62 in the downstream direction. The intermediate task means 62 processes the data and returns it to the final task means 60. Final task means 60
Processes the data received from the intermediate task means and returns the processed data to the host application means 50. Next, when the host application means 50 needs more data, the calling means 54 calls the pipeline 80 again.

Once the host application 50 has all the desired data, the calling means 54 calls the pipeline 80 to shut it down,
Clean up (delete) any errors caused by the operation of the pipeline 80. Calling means 5
4 calls an error code from the pipeline. As described above, this request ripples upstream. Each tasking means determines whether it generated an error code and returns this error code. Once these error codes are returned, the calling means 54 sends a signal to the memory management means 56 to release the memory allocated to the task means 60-64 of the pipeline 80.

FIG. 19 shows a generalized task means 68, which represents any of the task means 60-64.
This generalized task means 68 comprises link means 82,
At least one channel means 84a-84c, data processing means 86, data analysis means 88, task status means 9
0, error code generation means 92, external port means 94,
And reconstruction means 96. Of course, it will be appreciated that the actual task means 60-64 may have different combinations of these elements, missing one or more elements. Further, the first task means 64 includes the pipeline 8
Data acquisition / generation means 98 for receiving and generating data for zeros may also be included.

Link means 82 links generalized task means 68 to the next or upstream task means 68 when a reverse link is used, or generalized task means 68 when a forward link is used. To the previous or downstream task means 68. Both links can be used at once. The generalized task means 68 includes a channel means 84a
Receive data returned from upstream task means via one or more of .about.84c. This data is then processed using data processing means 86 before being returned to the downstream task means via corresponding channels 84a-84c.

The task state means 90 holds the state of the task means 68. Task state means 90 also controls all other means of generalized task means 68. The data analysis means 88 determines whether the data received from the next task means is suitable for the data processing means 86. If the data is not suitable, the data analysis means 88 has two different possible responses. In a first type of response, the simplified task means 68 simply returns the error code generated by the error code generation means 92 to downstream task means instead of data. When the host application means 50 receives an error code instead of data,
The application means 50 uses an error handling system to determine the nature (and cause) of the error. Next, the host application means 50 can attempt to recover from the error by exiting gracefully or by reconfiguring and / or reinitializing the pipeline 80.

In the second type of response, the complex task means 68 includes a reconfiguration means 96 that attempts to dynamically reconfigure the pipeline 80 to recover from an error. This reconfiguration means 96 does this by dynamically instantiating additional task means 68 from the library means 10 and inserting these additional task means into the pipeline 80. The reconfiguring means 96 does this by accessing one or more of the other task means via the external port means 94. This external port means 94 allows various access modes to other task means 68. These modes may include checking and / or changing other task means or the task state means 90 of the task means itself, checking the error code generating means 92, changing the link means 82, or changing other such means. including.

Of course, even if the task means 68 has the high-performance reconstructing means 96, an irrecoverable error or a hard error may occur. In this case, the task means generates an error code again using the error code generation means 92, and supplies the error code to the next downstream task means.

Finally, in the second embodiment, the link means 82 can link the individual channel means 84a-84c of the task means 68 instead of the generalized task means 68 itself. That is, the link means 82 can directly link one of the channel means 84a-84c to the corresponding channel means 84a-84c of any other task means. Thus, if task means 68 has many channel means 84a, 84b, and 84c, each channel means 84a-84c can be linked to a different upstream or downstream task means. On the other hand, in the first embodiment, the link means 82 is
, All channel means 84a-84c of task means 68 will be linked to the same next upstream / downstream task means.

As shown in FIG. 2, each instantiated function, or task, is associated with a pipeline 40 running between data source 12 and host application 120 running on computer 100. It can be visualized as sections 40a, 40b, and 40c. Host application 120
Is currently being executed by the CPU 21 (and RAM
26 (stored at 26). Each section 40a, 40b, and 40c of the pipeline 40
Comprises one or more data processing channels 42, a data structure 44 defining the state of the pipeline section,
And zero or more external ports 46. Each of the pipeline sections 40b and 40c and the host application 120
0 to the next upstream pipeline section 40a, 40b,
And 40c each have a reverse link 48. Alternatively, each pipeline section 40a, 4
0b and 40c are the immediately downstream pipeline sections 40b and 40c or the host application 120
Has a forward link 48 '. Finally, both a reverse link 48 and a forward link 48 'may be provided.

In the preferred embodiment of the data processing system, the pipeline has an "intelligent" pipeline section. These intelligent pipeline sections can dynamically reconfigure the pipeline when operated from the host computer without the need for any interrupts by the host application.

For example, the intermediate pipeline section 40
b can determine whether it is possible to process the data elements returned by the first pipeline section 40a. If the intermediate pipeline section 40b is unable to process the data element, the intermediate pipeline section 40b dynamically calls the function library 10 and a new pipeline section 40d
Instantiate. This new pipeline section 40d is linked to the first pipeline section 40a. Next, the pipeline section 40b changes its own link so that this new pipeline section 40
Indicates d.

Alternatively, the intermediate pipeline section 40
If b determines that it cannot process the data (even if it attempts to reconfigure the pipeline), the pipeline section 40b will send an error code indicating a hard error to the most downstream Return to pipeline section 40c. This lowest section 4
0c indicates an error code in the host application 120.
To provide. The error handling system in the host application 120 determines the nature of the error from the error code library. In one embodiment, host application 120 determines whether it can reconfigure or reinitialize the pipeline to recover from an error. If so, the host application reconfigures or reinitializes the pipeline. However, if the host application is unable to recover from the error or does not have this capability, the host application exits with room.

Such an unrecoverable error can occur, for example, when processing an image. There are 1000 scan lines in the image but the scan line image data element is
If the header indicates that the first call did not return to the first pipeline section, the system encounters a hard error. This error cannot be recovered despite the pipeline's ability to reconfigure itself, simply because there is no data to process. In this case, the first pipeline section is "E
RR "error code. The host application then uses the error handling system to determine a reason for the error code. After determining the nature of this error,
The host application exits gracefully because any reconfiguration or re-initialization of the system is meaningless.

When the pipeline is reconfigured, the intermediate pipeline section 40b requests data from a new pipeline section 40d. The new pipeline section 40d requests data from the first pipeline section 40a, and the first pipeline section 40a provides the obtained data elements to the new pipeline section 40d. Alternatively, when calling the function library 10, the intermediate pipeline section 40b can provide the data elements received from the first pipeline section 40a to the new pipeline section 40d, whereby the new pipeline section 40d will It has this data element as soon as it is created. Thus, when the intermediate pipeline section 40b requests data from the new pipeline section 40d, the new pipeline section 40d can immediately process and return its data elements.

In addition, if a forward link 48 'is provided, each intelligent pipeline section will:
Within the data structure, means for determining whether a data element needs to be processed by this pipeline section may be included. If it does not need to be processed, the pipeline section can dynamically reconfigure the pipeline and remove itself from the pipeline without any interruption to the host application. The intelligent pipeline section turns the downstream task to which the section is linked into its back link (reverse link), linking the downstream task to the upstream task of the intelligent pipeline section. This "shorts" the intelligent pipeline section from that pipeline section. A forward link is needed so that the intelligent pipeline section knows which downstream pipeline section to change and the downstream pipeline section is linked to the appropriate upstream pipeline section.

The external port 46 can be used to check the current state of a pipeline section, write data to the pipeline section data structure 44, change the current state of that pipeline section, or It is used to dynamically change the linkage to dynamically add sections and remove sections from the pipeline 40. Generally, external port 46 is used to control the pipeline independent of data channel 42, which merely processes data elements. That is, the data channel 42 is used to independently process data received from the upstream pipeline section and output the processed data to the downstream pipeline section. External port 46
Allows access to the data structure 44 of the pipeline section without affecting the operation of the data channel 42.

Therefore, in another embodiment, for example, after the pipeline 40 has been created, the first pipeline section 40a and the intermediate pipeline section 4
If it becomes necessary to add a new pipeline section 40d during 0b, this is achieved using the external port 46. In this example, final pipeline section 40c has a structure for testing data in a channel as part of its data structure. Even if the format of the data received in the final pipeline section 40c is not suitable for the format required for proper operation of the final pipeline section 40c, the data may be modified before the intermediate pipeline section 40b processes the data. If not, final pipeline section 4
0c dynamically instantiates a new pipeline section 40d and inserts it between the first pipeline section 40a and the intermediate pipeline section 40b. This final pipeline section 40c does this by accessing the data structure 44 of this intermediate pipeline section 40b via the external port 46 of the intermediate pipeline section 40b. The final pipeline section 40c changes the link 48 of the intermediate pipeline section 40b, thereby changing the link 48 from the first pipeline section 40a to a new pipeline section 40d. Similarly, the data structure 44 of the new pipeline section 40d contains the first pipeline section 4 when it is properly initialized.
0a is accessed to ensure linking.

In operation, when a host application 120, such as the application shown in FIG. 9, requests data from the data source 12, the host application first calls the function from the function library 10 to instantiate it by creating an instance. Line 4
0 is formed. In the embodiment shown in FIG. 9, the variables "i", "n", "add value", and "mul value" are initialized in the fifth line of the host application. In the sixth line, the first task 40a is defined as a “null” (null, blank) task. The first task can be connected to obtain a data element from the data source 12 and the first task 40
It can be shown that a acts as a data source 12. In the seventh line of FIG. 9, the number of tasks in the pipeline 40 is determined by the command line shown in FIG. 10 started by the host application. Generally, as the host application runs, the length and components of the pipeline 40 are determined dynamically. Alternatively, the length and components of pipeline 40 are explicitly stated in the host application.
Finally, even when the initial length and components of pipeline 40 are dynamically determined or explicitly stated, pipeline 40 moves itself with data received from data source 12. Can be reconstructed dynamically.

In the example shown in FIG. 9, the length of the pipeline 40 is explicitly stated in the command line that starts the program, as shown on the seventh line.
In this case, the length of the pipeline is 5, as shown in FIG. As shown in lines 8 and 9 of FIG. 9, each function is called and initialized, and is extended from the data source to the host application. In this case, as shown in the sixth line in FIG. 9, the first task 40a also operates as a data source. Further, as shown in line 9, each task in pipeline 40 is a different instantiation or task of the same function.
As shown in line 9 in FIG. 9 and line 17 in FIG.
When the function "Math Task" in this example is initialized, its data structure contains two channel data buffers, each set to the current value "i", and a pointer to the upstream task in the pipeline. . Furthermore, if there is no upstream task in the pipeline, the pointer is set to "null".

Since the functions in the function library 10 are defined as objects in an object-oriented language, each time the functions are initialized in the example shown in FIG.
Different instantiations of the same function are effectively performed. Thus, a single pipeline 40 may have multiple copies of any single function. Therefore, each copy of the function is a base function (base fun
ction) and operate as different tasks or sections of the pipeline 40.
This allows the functions in function library 10 to be recursive as they can be used more than once in any single pipeline.

After the tasks in the pipeline are generated in the eighth and ninth lines, the channels (two in this case) of the initialized tasks are executed in the tenth and eleventh lines. Once the host application shown in FIG. 9 receives the final data from the task via the multiple channels executed on lines 10 and 11, the output shown in FIG. Printed as described on lines 13 and 13.

In the host application shown in FIG.
As described above, in lines 8 and 9, the pipeline has many independent instantiations of the function "MathTask". FIGS. 5-8 illustrate the instantiations required by the host application in lines 8 and 9 of FIG. Called library object "M
athTask ".

The functions "MathTask" shown in FIG.
In the sixth line, the main data structure is defined. As shown in lines 1-6, the data structure includes two channels (ie, channel 1 and channel 2) and a reverse or upstream link. Next, in lines 7-12, the function defines specific data structures, "aval" and "mval", for each of the first and second channels.

Next, in the 17th line, the data request “avalue” for the channel 1 and the data request “m” for the channel 2
value ", and the upstream link" link ", the task" M
athTask "instance generation procedure is defined.
In the twentieth line, variables “avalue” and “mvalue” for each of channel 1 and channel 2 and a link are defined. Finally, on line 21, a procedure for creating a task of the function "MathTask" and allocating a memory block in the RAM 26 is defined as shown in FIG.

Next, as shown in lines 28 to 37 of FIG. 7, a data processing procedure and a data structure relating to channel 1 are defined. The data processing procedure for channel 1 is as follows:
Get the number from the task immediately upstream. Further, as shown in the sixth line of FIG. 9, the first task in the pipeline is a “null” task. "Nu" for the first task
The result from the "ll" state is defined in line 32, which defines the initial value of "val" to be zero. If there is a reverse link in line 33, then in line 34 the value "val" is the value of the upstream task The value "val" is then updated in line 35 by adding the channel 1 addend "aval" of the current pipeline section to that value. The addend value “aval” of channel 1 for each pipeline section was set in the state parameter “avalue” of the pipeline section set in line 9 of FIG. The data processing procedure ends by returning the new value "val" to the pipeline section immediately downstream.

Similarly, the data processing procedure for channel 2 is defined in lines 38 to 47 of FIGS. The only difference occurs at line 39, which uses the procedure for channel 2 initialized at line 23 in FIG. 6 instead of the procedure for channel 1 initialized at line 22 in FIG. Further, on line 42, the value "val" is preset to 1 to compensate for a "null" data source for the first pipeline section. In line 45, the new value "val" is set in line 9 in FIG. 9, and the state parameter "m" in line 26 in FIG.
Equal to the old value "val" multiplied by the channel 2 multiplicand set to "value".

In operation, the host application shown in the eighth and ninth lines in FIG. 9 calls the function "MathTask" a specified number of times. The first instantiation of the function "MathTask" is set up as a "null" task that is not connected to a data source. Again by looping lines 8 and 9, the second function "MathTask"
Is created using the reverse link to the previous instantiation of the task "MathTask". Thereafter, for each loop through lines 8 and 9 of FIG. 9, a further instantiation of the function "MathTask" is formed. When the final loop is completed via lines 8 and 9 of the host application shown in FIG. 9, the reverse link from the host application to the last one of the tasks "MathTask" remains set. Become. FIG. 4 shows a three-section pipeline initialized in this way.

Next, in the tenth and eleventh lines, the host application requests data from channels 1 and 2 of the last instantiation of the function "MathTask". The final task requests data from the task immediately upstream. This is the first of its "MathTask"
Continue until a request for data is received over channels 1 and 2. FIG. 3 shows an example of this type of data flow. After the host application calls the pipeline at lines 10 and 11 of FIG. 9, the final pipeline section calls each channel of the pipeline section to which it is linked, at lines 34 and 44 of FIG. . Next, each called pipeline section calls the upstream pipeline section to which it is linked. Upon reaching the first pipeline section, the first pipeline section receives a data element from the data source 12, or in this case, self-creates the data element. The first pipeline section then returns its data element to the pipeline section that called it as described above.

The first instantiation of the function "MathTask" then executes the data processing procedures defined for channels 1 and 2. The first instantiation is
Value 1 (= 0 + 1) and channel 2 for channel 1
Returns the value 1 (= 1 × 1) to the second instantiation of the function “MathTask”. Each instantiation of the function "MathTask" adds the first number to the value held in channel 1 and multiplies the number held in channel 2 by the second number.
In the example shown in FIGS. 5 to 8, the first and second numbers are the addend and the multiplicand initialized when the pipeline was generated in the ninth row of FIG. However, these numbers could also be generated dynamically. Thus, the data processed in channel 1 and channel 2 ripple downstream towards the host application. Thus, the lowest-level instantiation of the function "MathTask" provides the requested data to the host application.

When the CPU 21 executes the host application shown in FIG. 9, it stores the host application in the memory block 26a of the RAM 26. The host application is actually a data structure stored in the allocatable memory block 26a. The data structure itself has a designated memory template, and this template defines the flow of the control operation of the CPU 21. In the first part of the allocated memory block 26a, various memory locations are defined and / or allocated as variables. The data block 26a also includes various memory locations that define the state of the host application, and various memory locations that act as buffers for storing data requested by or processed by the host application.

Similarly, when the host application calls the function library 10 to instantiate the function “MathTask”, for example, the other data block 26 b
Is assigned to that task or pipeline section. Like a host application, this pipeline section is actually a data structure within the allocated memory block 26b that contains a template for the allocated memory block 26b.
The allocated memory blocks define buffers for storing the data to be processed, various memory locations for defining the type of data, a procedure pointer indicating where this task will receive its data, and defining the state of the task. It includes various memory locations for storing data to be processed, and one or more data buffers for storing processed data received from the immediately upstream pipeline section.

The allocated memory block 26b also includes a data structure defining data processing operations for channel 1 and channel 2. Alternatively, the data structure in the allocated memory block 26b may be a look-up table or a function library 10 for performing data processing.
May include pointers to other functions in. In general, each task is initialized when memory block 2
When assigned to one of 6a-26f, sufficient buffers are automatically allocated for data input, data output, task status, and various data processing procedures performed by the task.

FIGS. 11 to 13 show flowcharts that generalize a control routine for implementing this method. FIG.
As shown in the figure, after starting, step S
In 10, the single application CPU 21 executes the host application 120. In step S20, one data processing pipeline is connected to the computer 10
The controller 21 checks whether it is necessary in the current operation of 0. If not, the control routine returns to step S10.

However, if a pipeline is needed,
The control routine proceeds to step S30, and calls a function from the function library. Next, in step S40,
The called function is instantiated to form a first task or first pipeline. Next, in step S50, data processing system 20 checks whether additional pipeline sections are needed. If necessary, the control routine returns to step S30 to call the next function from the library. Thus, the control routine loops steps S30-S50 until no additional tasks are needed. When the additional task is no longer needed, the control routine proceeds to step S60.

At step S60, the pipeline is called. In step S70, the pipeline returns the processed data element to the host application. Next, in step S80, the data processing system 20 determines whether additional data is needed. If additional data is needed, the control routine returns to step 60 to invoke the pipeline again.

However, if no more data is needed, the control routine proceeds to step S90 and is removed by deallocating the memory allocated to the various pipeline sections. Step S100
Then, the next command of the host application is executed. Next, in step S110, data processing system 20 determines whether more pipelines are needed. If necessary, the control routine proceeds to step S30.
Return to

However, if no pipeline is required at this point, the control routine continues to step S120, where data processing system 20 determines whether host application 120 has been completed. If completed, the control routine stops. Otherwise (if not completed), the control routine returns to step S100.

FIG. 12 shows an instance generation step S40.
2 shows a flowchart for the following. After entering the instance creation routine of step S40, the control routine proceeds to step S200, where a primary data structure for the task is created. Next, step S210
Creates a part of the data structure that is unique to this task.
Next, a channel data structure is created in step S220, and a reverse link is created in step S230. If a forward link is required, its data structure is defined, but it is not terminated until the pipeline is called because the downstream task to which the forward link links has not yet been created. The link has a procedure pointer for calling the linked pipeline section. Next, in step S240, the control routine proceeds to step S40.
Return to

FIG. 13 shows a flowchart for the calling routine of step S60. Starting from step S60, the control routine proceeds to step S300,
Here, the host application 120 requests data from the last pipeline section. Next, in step S310, the current pipeline section requests data from the next upstream pipeline section. In step S320, the data processing system 20 determines whether the next pipeline section is the first pipeline section. If it is not the first pipeline section, the control routine returns to step S310.

However, if the next pipeline section is the first pipeline section, the control routine proceeds to step S330. In step S330, the data processing system 20 determines whether the first pipeline section is a “null” section. ”Nul
If not, the control routine proceeds to step S
Proceeding to 340, where the first pipeline section obtains data elements from an external source. If the first pipeline section is a "null" section, the control routine continues to step S350, where the first pipeline section self-creates the data element.

In either case, the control routine proceeds to step S360 via either step S340 or step S350, where the first pipeline section returns data to the immediately downstream pipeline section. In step S370, the next pipeline section processes the data. Next, in step S380, if the next pipeline section is the last pipeline section, the processed data is returned to the host application in step S390. However, if the next pipeline section is not the last pipeline section, the data is returned to the new immediately downstream pipeline section as indicated by the loopback to step S360, and the data element is processed. This "looping" is performed until the final pipeline section is reached and the data is returned to the host application in step S390. Next, the control routine returns to step S60.

In a first embodiment of the data processing pipeline of the present invention, a forward link is provided instead of or in addition to a predefined reverse link. In this case, after the reverse link is defined from the current lowest task, the forward link from the task immediately upstream to the lowest task is defined.

Alternatively, only the forward link need be provided. However, in this case, the pipeline section is initialized upstream from the host application towards the data source. Next, a pipeline is invoked downstream from the data source to the host application.

In a further embodiment, rather than providing a single forward link or a single reverse link between tasks, if each task has two or more data processing channels, The channels themselves are linked together by forward and / or reverse links. In this case, each channel can be linked backward or forward to any other corresponding channel in the task. Thus, one of the channels of the first pipeline section is linked to the corresponding channel of the second pipeline section, and the other channel of the first pipeline section is linked to the corresponding channel of the third pipeline section. You.

In yet another embodiment of the present invention, special "logical input (fan-in)" and "logical output (fan-out)" pipeline sections are provided. Is done. In these pipeline sections, two or more upstream pipeline sections are linked to one downstream pipeline section using a fan-in branch pipeline section. Similarly, a single upstream pipeline section may be connected to two or more downstream pipeline sections using a fan-out branch pipeline section.

As shown in FIGS. 14-17, in the application of this system, the system is a stream oriented Unix® pipeline that processes images very efficiently on a scan line by scan line basis. Created to emulate This Unix® pipeline has a number of advantages, including modularity and easy maintenance. However, the Unix pipeline requires multi-processors, lacks portability, lacks its own dynamic reconfiguration capabilities, and requires system overhead in task scheduling and data flow processing. It also has a number of drawbacks, including:

In the image processing pipeline of the present invention,
The image is divided into two main parts, a header and the image body. The header defines the state of the image, such as the color space (color space) and orientation displayed thereon, and the dimensions of the image, such as the length of the scan lines, the number of scan lines, the interlace factor, the pitch, and the like. The image body contains the actual scan line data, such as in the form of a raster output scanner, where each scan line is one data element that must pass through the pipeline. In this type of image processing pipeline, the image body includes the same scan line structure repeated multiple times.

The pipeline sections each have at least three channels. The first channel is used to process header information. The second channel is
Used to process the image body on a per scan line basis. One or more channels of the second channel type may be provided according to the type of image processing provided by the pipeline. The third channel is used to perform any necessary cleanup (delete) operations and release the memory allocated to the pipeline section once the image has been completely processed. Image processing is the third
Channel 3 is completed by the time it is called,
Only the data flow through the channel is the error processing information. The third channel causes each upstream pipeline section to return any error codes resulting from the image processing, and once this information is returned, dynamically transfers the upstream pipeline section to the receiving downstream pipeline section. Let me delete it. In addition, any necessary external port procedure pointers are included in the data structure of the pipeline section of the image processing pipeline.

That is, in the image processing system shown in FIGS. 14 to 17, the generalized task means 6 shown in FIG.
8 includes a first channel unit as a header channel, a second channel unit 84b as an image processing channel, and a third channel unit 84c as an end channel.

As described above, when the host application determines that processed image data is needed, a data processing pipeline is created. The pipeline is generated by instantiating various library functions from the function library 10. In image processing systems, these functions invert the color of the image. "
"invert", "colorize" to colorize black and white images, "filter" to apply a superposition filter to soften the edges in the image, "enlarge" to enlarge the image body, and "reduce" to reduce the image body This list is intended to be illustrative and not exhaustive: for example, "invert" can convert a black pixel to a white pixel and vice versa, and "invert"
Can convert color pixels, for example, from red to cyan, green to magenta, and blue to yellow.

An example of data processing performed by the data processing pipeline will be described below with reference to FIG. This example describes the data processing of a color image data block provided by a color image scanner.
In this example, the pipeline can dynamically reconfigure itself to overcome detected errors.

In this example, the host application instantiates a data processing function from the function library and receives and processes the four-color image.
As shown in FIG. 4, printing is performed by a host application on a four-color printer. The pipeline is then called by the host application to input image header data from the color scanner. The request for the header travels to channel 1 of that pipeline until it reaches the first pipeline section.
The first pipeline section gets the header data from the scanner and returns it downstream of channel one.

When each pipeline section receives a header, each pipeline section checks this header to see if it can correctly process the image body to be received, and then checks this pipeline section. Changes the header to reflect what should be done for the image body. The pipeline section then sends the modified header data to an adjacent downstream pipeline section. However, if the pipeline section determines that the image to be received cannot be properly processed, the pipeline section dynamically reconfigures the pipeline to correct the problem.

If the pipeline is created assuming that the color scanner is a four-color scanner, but the color scanner is a three-color scanner instead of a four-color scanner,
The header data for the color image received from the scanner indicates that the image is a three-color image. An error occurs because the pipeline was originally set assuming that the scanner and the printer use four-color data. In this case, a potential error is found when the pipeline section processes the header.

The pipeline section that detected the error automatically reconfigures the pipeline by instantiating and adding a new pipeline section immediately upstream of the pipeline. This new pipeline section changes the color space of the image data from three colors to four colors. At the same time, the pipeline section that detected the error changes the link to reflect the location of the new pipeline section. Then, the header data is returned. Now, after the new pipeline section changes the header to reflect that it changes the color space of the image to four-color image data, the pipeline section that detects the error will process the image data correctly. Decide that you can.

When the header has been completely processed and returned to the host application, the host application repeatedly calls the pipeline to enter the image body. Each time the pipeline is invoked, the image body is obtained, processed, and returned to the host application as a processed dataset. From this header, the host application knows how many scan lines are in the image body, and thus knows how many call cycles are required to input and process the entire image body. In all other respects, the pipeline operates generally as described above. Once the entire image body has been obtained, processed, and returned to the host application, the host application invokes a third channel to stop (shut down) the pipeline. FIG. 15 shows a flowchart showing the execution of this pipeline.

In the above pipeline system, when a task is instantiated, it is actually placed in a section of RAM memory and some variables and process parameters are preset. A task is not "instantiated" until the task has processed the header data. As mentioned above, the first information processed by the data pipeline is the header data, which ripples down channel 1 of the pipeline downstream.
When a task first receives header data from the immediately upstream task, it can complete its own instantiation procedure. At this time, all variable values and process parameters are finally set.

As described above, if the pipeline section analyzes the header data and determines that it does not need to process the data, the pipeline section can take steps to short itself from the pipeline. This shorting procedure can occur in at least two different ways. In the first case, the pipeline section can receive image data from the upstream task to which the section is linked and simply pass this image data on to the next unmodified downstream task. In the second case, if both the reverse link and the forward link are provided, the unnecessary tasks can use an external procedure to change the link in the pipeline, so that the task immediately upstream can Deliver the image data directly to the task immediately downstream. This is done by causing the unnecessary task to change the link pointer of the task immediately downstream that it is linked to, so that the link pointer points to the task immediately upstream of the unnecessary task.

In both of the short circuits described above, unnecessary processing time and computer resources are devoted to instantiating unnecessary tasks. Further, when the first short circuit method is used, unnecessary tasks remain in memory and are simply delivered without altering the image data,
Unnecessary processing steps occur, and processing time is further increased. Other embodiments of the present invention that overcome these disadvantages will be described below.

In another embodiment of the present invention, each task
That is, the pipeline section includes only the second and third processing channels. The header data is read by each task when it is first instantiated by the host application. If, after instance creation, the task determines that there is no need to process the data, the instance creation procedure is canceled and the host application proceeds to the next task. In this embodiment, unnecessary tasks are not instantiated first.
As a result, system resources are not wasted by instantiating unnecessary tasks or performing unnecessary processing steps.

A generalization 83 of the task means of this embodiment will be described below with reference to FIG. Generalized task means 83 may be any task means in the pipeline according to this embodiment.

The generalized task means 83 includes link means 82, data channel means 85 (which may include a plurality of separate data channels 85a, 85b, etc.), data processing means 86, data analysis means 88, error codes Generating means 92, task status means 90, reconstructing means 96,
External port means 94 and data acquisition / generation means 98 are included. Each of these means has been described above with reference to the generalized task means represented in FIG. The generalized task means 83 (shown in FIG. 20) includes a header data acquisition / generation means 87 for acquiring a header from a data source or generating a header, based on the acquired / generated header data. Means 89 for initializing a task, and header data analyzing means for analyzing the acquired / generated header data to determine whether the task can process data to be received from an upstream task. 93, reconfiguration means 95 for reconfiguring the pipeline, self-deletion means 99 for canceling the instance generation process when the task determines that there is no need to process data received from the upstream task, and generation End to collect the error codes and shut down the pipeline It may include Yaneru means 97. Also, this generalized task means 83 may be called by other tasks in the pipeline to provide access to the state or links of the task to facilitate reconfiguration of the pipeline. An external procedure generation means 91 for generating an external procedure that can perform the above-mentioned operations may be included. Of course, it should be understood that a particular instantiated task may include a combination of these basic features, and not all of the foregoing features may be required to practice the present invention.

A pipeline according to this embodiment will be described below with reference to FIGS. When the host application starts generating a pipeline, it instantiates a first pipeline section 40a, which reads header data from the data source 12 immediately or
Alternatively, header data is generated immediately. The first pipeline section 40a initializes all of its variables and process parameters according to the header data. Also, the first pipeline section 40a generates an external procedure using its external procedure generation means 91, whereby the other pipeline sections are separated from the first pipeline section 4a.
Header data can be read directly from 0a. After the first pipeline section 40a has processed the header data, initialized itself, and created the external procedure, the host application instantiates the second pipeline section 40b.

The second pipeline section 40b calls an external procedure set up by the first pipeline section 40a, and calls the first pipeline section 4
Obtain header data from 0a. The second pipeline section 40b analyzes the header data to determine if this data is needed in the data processing pipeline.
When the second pipeline section 40b determines that the image processing is necessary, all the variables and process parameters are initialized based on the header data, and the header data is processed to reflect the data processing to be performed.
Next, the second pipeline section 40b generates a new external procedure using the external procedure generation means 91, and causes the other pipeline sections to read the processed header data.

In this embodiment, if the pipeline section determines that the image processing step is not necessary for the image processing pipeline, the pipeline section deletes itself from memory and returns control to the host application. . Next, the host application proceeds to instantiate the next pipeline section. As a result, memory is not wasted by instantiating unnecessary pipeline sections, and unnecessary processing time such as passing image data through pipeline sections that do not perform data processing steps is eliminated.

For example, in order to receive image data from an upstream pipeline section and to reduce or enlarge this received image as needed to generate a 1000 × 1000 pixel image, a reduction / enlargement pipeline section is provided by the host application. Is instantiated. During instance creation of this pipeline section, this section obtains header data from the adjacent upstream pipeline section by calling an external procedure created by the adjacent upstream pipeline section. If the header data indicates that the image data to be supplied by the upstream pipeline section is already 1000 × 1000 pixels, the reduction / enlargement pipeline section is not needed. Thus, the shrink / expand pipeline section deletes itself from memory, and the host application proceeds to instantiate the next pipeline section.

When the final pipeline section 40c is instantiated, the final pipeline section 40c generates an external procedure, and the host application reads the processed header data from the final pipeline section 40c by the external procedure. Will be able to do so. The host application calls this external procedure to obtain the header data, and then makes the first data call to the final pipeline section 40c to start data processing. As described above for other embodiments of the invention, the request for data ripples upstream to the first pipeline section 40a, which routes the first line of image data from the data source 12 to the first pipeline section 40a. Acquiring (or generating a line of image data), the first pipeline section 40a returns the image data to an adjacent downstream pipeline section, and the processed image data is transferred to each of the pipeline sections until it reaches the host application. Ripple downstream.

After all of the image data for a particular image has been received by the host application, the host application collects any error codes using end channel means 97 and uses the error code for each of its pipeline sections. Shut down (stop) the pipeline by deallocating memory
I do.

In this embodiment, not only unnecessary pipeline sections are not instantiated, but also each pipeline section is initialized immediately after instantiation. This can further reduce the time required to set up a pipeline and process image data using the pipeline.

Further, in this embodiment, when the pipeline section analyzes the header data received from the upstream pipeline section and determines that it cannot process the header data received from the upstream pipeline section, The pipeline section instantiates a new pipeline section and inserts the new pipeline section between the pipeline section and the pipeline section that was originally upstream. This process is similar to the process described above for the other embodiments. However, in this embodiment, the newly inserted pipeline section is either directly from the immediately upstream pipeline section via an external procedure call to the immediately upstream pipeline section, or the pipeline section that created the new pipeline section. Must receive the header data. In either case, the newly created pipeline section analyzes the header data, initializes its variables and process parameters, processes the header data, and external procedures that allow other pipeline sections to obtain the processed header data. And then return control to the pipeline section that generated it. The pipeline section that created the new pipeline section obtains the processed header data from the new pipeline section and checks whether the image data supplied thereto can now be processed. If possible, the construction of the pipeline section proceeds as usual. If the pipeline section cannot process the image data yet, insert a newer pipeline section.

For example, assume that a rotating (circulating) pipeline section that requires four-color image data is instantiated from an adjacent upstream pipeline section. During instantiation, the rotating pipeline section obtains header data from the upstream pipeline section by calling an external procedure. If the header data indicates that the image data passed to the rotating pipeline section is three-color image data, it is known that the rotating pipeline section cannot process the image data. To solve this problem, the rotating pipeline section causes a new "color change" pipeline section to be instantiated that changes the three color image data into four color image data. This new color change pipeline section is linked to the upstream pipeline section, which gets the header data from the upstream pipeline section and processes it as part of its instantiation. Next, this new color change pipeline section
Create an external procedure to cause the other pipeline section to obtain the processed header data from this new color change pipeline section and return control to the rotating pipeline section. The rotating pipeline section then calls the header data from the new color change pipeline section and completes its own initialization.

The pipeline section that is being instantiated may have the ability to replace itself with another more efficient pipeline section. For example, the reduction / enlargement pipeline section receives image data of any size from the upstream pipeline section and stores the image data at 1000 × 1.
Assume that it is instantiated to convert to image data of 000 pixels. When the reduction / enlargement pipeline section gets header data from the upstream pipeline section, the image data to be received is already 50
You may find that it is image data of 0x500 pixels. The reduction / enlargement pipeline section also allows another data processing function in the function library, designed to multiply the image size by an integer, to process the image data more efficiently and process the image data of 1000 × 1000 pixels. You may find that it can be generated. In this case, the reduction / expansion pipeline section instantiates a multiplicand × integer function, links it to the upstream pipeline section, and deletes itself from memory. This results in a faster and more efficient data processing pipeline.

As shown in FIG. 21, another push-type embodiment 500 of the data processing system according to the present invention comprises a host application means 220, a library means 10, a memory management means 56, and a data processing pipe. Line 80 is included. Data processing pipeline 80
Is a final task means 60 connected to the host application means 220, at least one intermediate task means 6
2, and the first task means 64. Data processing system 500 also includes data source means 66. The data processing system 500 also includes an output device 166. In this case, the host application means 220 also performs the function of the data source means 66. Multiple links 70
Connects the first task means 64, at least one intermediate task means 62, and the final task means 60. Of course, the simple pipeline 80 may include only the first task means 64. Data input link 73 connects data source means 66 to host application means 220. The first task means 64 is a software interface to the output device 166. The first task means 64 provides data to the output device 166 via a data transfer means 172, for example, an electric cable.

The host application means 220 includes a data processing means 58 for pre-processing the data supplied to the data processing pipeline 80. Initially, the data processing system 500 is
0, only the library means 10, and the memory management means 56. The host application means 220 operates the process according to the instructions stored in the host application means 220. The processor may be a single processor operating in a single-tasking environment, a single processor operating in a multiple-tasking environment, or multiple processors operating in a multiple-tasking environment. In this case, the host application means 220 is as if in a single tasking environment,
Operate.

When the host application means 220 determines that the data needs to be passed to the storage / output device,
Generate and call data processing pipeline 80. Therefore, the host application means 220 includes the instance generating means 52 and the calling means 54.

To generate the pipeline 80, the instance generating means 52 accesses the library means 10 to obtain one of the uninitialized functions, generates an instantiated function or task, and Is stored in the block. This instantiated function, ie, the task, is linked to the host application means 220 or other previously created task. If the task is linked to a host application means, this is the final task 60. If a task is linked to another task and another task is linked to that task, this is an intermediate task 62. Task has no forward link,
This is the first task 64 when supplying data to the output device 166.

When generating a task by generating an instance of a function, the instance generating means 52
6 and is assigned to one of the memory blocks 26a to 26f of the RAM memory 26 (shown in FIG. 1) to store the task. When all desired tasks have been instantiated, the calling means 54 supplies the data to the final task means 60 and calls the pipeline 80. The final task means 60 processes the data and passes it to the intermediate task means 62. The intermediate task means processes the data and passes the processed data to the first task means 64. Then, if more data is provided by the host application means 220, the calling means 54 again returns to the pipeline 80
Call.

When the host application 220 has provided all the desired data, the calling means 54 calls the pipeline again, shuts it down, and deletes all errors caused by the operation of the pipeline 80.
The calling means 54 requests an error code from the pipeline. This request ripples down as before. Each task means determines whether an error code has been generated and returns them. When the error code is returned, the calling means 54 sends a signal to the memory management means 56 to release the memory allocated to the task means 60 to 64 of the pipeline 80.

FIG. 19 shows a generalized task means 68 that can also be used in the push system of the present invention.
(Represents one of the task means 60 to 64). Thus, the generalized task means 68 operates for a push system in a manner similar to a pull system, with the following exceptions.

When the forward link is used, link means 82 links this generalized task means 68 to the next or downstream task means 68, or when the reverse link is used, Generalized task means 68
Is linked to the preceding or upstream task means 68. Of course, both types of links can be used simultaneously. The generalized task means 68 comprises channel means 84a
Receive data supplied from upstream task means via one or more of .about.84c. The data is then processed using data processing means 86, after which the processed data is processed by the corresponding channel means 84a-84 of the downstream task means.
84c.

The generalized task means may include a data analysis means 88 for determining whether the data received from the upstream task means is suitable for the data processing means 86. If the data is not appropriate, the data analysis means
With two different possible responses. In a first type of response, the simplified task means 68 returns the error code generated by the error code generation means 92 to the upstream task means, which eventually reaches the host application means 220 I do. When the host application means 220 receives the error code, the application means 220 uses an error handling system to determine the nature (and cause) of the error. The host application means 220 can then escape with a margin or attempt to recover from the error by reconfiguring and / or reinitializing its pipeline 80.

If an unrecoverable or hard error occurs, the task means generates an error code using the error code generation means 92, and this error code is supplied to the upstream task means, and finally the host means. Reach the application.

As shown in FIG. 22, each of the instantiated functions or tasks is composed of a host application 220 running on the computer and an output device 166.
Can be visualized as sections 140a, 140b, and 140c of the pipeline 140 operating between. The host application 220 is an application currently being operated by the CPU 21 (and stored in the RAM 26). Each section 140a, 140b, and 140c of the pipeline 140 includes one or more data processing channels 42, a data structure 44 that defines the state of the pipeline section,
And zero or more external ports 46. Each of the pipeline sections 140b and 140c has a forward link 1
48, which forward link 148 connects the pipeline section 140b, 140c or the host application to the next downstream pipeline section 140a, 14c.
0b and 140c. Further, each pipeline section 140a, 140b, and 140
c is the immediately upstream pipeline section 140b and 1
40c or a reverse link 148 'to the host application 220. Both forward link 148 and reverse link 148 'can be provided simultaneously in one pipeline.

In the preferred embodiment of the data processing system, the pipeline includes "intelligent" pipeline sections. These intelligent pipeline sections can dynamically reconfigure the pipeline when it is run from the host application without intervention by the host application.

For example, the intermediate pipeline section 14
0b indicates that the additional task is
It is possible to determine whether the data elements provided by the POS need to be completely processed. As shown in FIG. 23, if the intermediate pipeline section 140b needs a new operation (operation), the intermediate pipeline section 140b dynamically calls the function library 10 and
Instantiate a new pipeline section 140d. The new pipeline section 140d is linked (added) to the pipeline section 140b. Pipeline section 140b then changes its forward link to point to new pipeline section 140d instead of pipeline section 140c. New pipeline section 140d establishes a forward link with pipeline section 140a. If a reverse pipeline link exists, pipeline section 140a changes the reverse link from pipeline section 140b to a new pipeline section 140d, which replaces the reverse link with pipeline section 140b. Establish.

Alternatively, the intermediate pipeline section 14
0b determines that it cannot process the data (even when reconfiguring its pipeline), this intermediate pipeline section 140b sends an error code indicating a hard error to the upstream pipeline section 140c.
Return to The pipeline section 140c supplies the error code to the host application 220. The error code processing system in the host application 220 determines the nature of the error from the error code library. In one embodiment, the host application 220 determines whether its pipeline can be reconfigured or reinitialized to recover from the error. If possible, reconfigure or reinitialize the pipeline. However, if the host application cannot recover from the error, this function is not provided and the host application exits with a margin.

When the pipeline is reconfigured, the pipeline section 140a receives data from the new pipeline section 140d. The new pipeline section 140d is replaced by the pipeline section 140b
Receive data from Alternatively, the pipeline section 140b can provide the data elements received from the pipeline section 140c to the new pipeline section 140d when calling the function library 10, so that the new pipeline section 140d can be provided.
0d has a data element as soon as it is generated.

In addition, if a reverse link 148 'is provided, each intelligent pipeline section can determine in its data structure whether the data element needs to be processed by the pipeline section. Means can be included. If it does not need to be processed, the pipeline section can dynamically reconfigure the pipeline and remove itself from the pipeline without host application intervention. Intelligent pipeline section
Causes the forward link of the upstream task to which it is linked to change, linking this upstream task to a downstream task in the intelligent pipeline section. This "shorts" the intelligent pipeline section from the pipeline. A reverse link is required for the intelligent pipeline section to know which upstream pipeline section to modify, and for that upstream pipeline section to be linked to the appropriate downstream pipeline section. The intelligent pipeline section may then be entirely removed from the pipeline.

In other embodiments, for example, after the pipeline 140 has been created, if it becomes necessary to add a new pipeline section 140d between the final pipeline section 140c and the pipeline section 140b, This may be performed using the external port 46. In this example, the pipeline section 140
a has, as part of its data structure, a structure for testing the data in the channel. If the data received by the pipeline section 140a is not in the format required for the proper operation of the pipeline section 140a and the data must be modified before the intermediate pipeline section 140b processes the data, Line section 140a dynamically instantiates a new pipeline section 140d and inserts it between pipeline section 140c and pipeline section 140b. Reverse link 148 'provides a means to perform this process. In a preferred embodiment, the pipeline section 140
a does this by using the reverse link 148 'to access the data structure 44 of the pipeline section 140b via the external port 46 of the pipeline section 140b. Pipeline section 140
a is the forward link 1 of the pipeline section 140c
48 and change the forward link 148 from pipeline section 140c to the new pipeline section 14
Turn to 0d. Similarly, the data structure 44 of the new pipeline section 140d is accessed and properly initialized and linked to the pipeline section 140b. In embodiments where only the forward link is provided, a new pipeline section may be inserted into this pipeline, which may require additional pipeline sections to process data in the following manner. It is upstream of the line section. This new pipeline section is added as described above with reference to FIG. Next, pipeline sections that require additional pipeline sections are added to this new pipeline section in the same manner. Finally, the original pipeline section that needs the additional pipeline section is set to a "no-op" state. In other words, the original pipeline section functions as a mere conduit that directs data from the upstream pipeline section to the new pipeline section.

FIGS. 24 to 26 show flowcharts in which a control routine for performing the push method is generalized. FIG.
After the start, the host application 2
20 is operated by the single processing CPU 21 (step S510). In step S520, the controller 21
Allows the data processing pipeline to run on computer 10
It is checked whether it is necessary for the current operation of 0. If not, the control routine proceeds to step S51.
Return to 0.

However, if a pipeline is required, the control routine proceeds to step S530, where a function is called from the function library. Next, step S540
In, the called function is instantiated to form a first task, a first pipeline section.
Next, in step S550, the data processing system 500 checks whether additional pipeline sections are needed. If necessary, the control routine proceeds to step S53.
Return to 0 and call the next function from the library. Thus, the control routine repeats steps S530 to S550 until the task is no longer needed. When the task is no longer needed, the control routine proceeds to step S560.

At step S560, the pipeline is called. The pipeline receives data from the host application and continues processing tasks called from the pipeline. The processed data is then provided to an output device 166. Next, in step S580, it is determined whether the data processing system 500 needs to process further data. If so, the control routine returns to step S560 to call the pipeline again.

However, if no further data is needed,
The control routine continues to step S590 where the various pipeline sections are removed by deallocating the memory that has been allocated to them. In step S600, the next command of the host application operates. Next, in step S610, the data processing system 500
Determines if more pipeline is needed. If necessary, the control routine returns to step S530.

However, if no pipeline is required at this point, the control routine continues to step S620, where data processing system 500 determines whether host application 220 has been terminated. If so, the control routine stops. If not, the control routine returns to step S600.

FIG. 25 shows an instance generation step S54.
5 shows a flowchart for 0. After entering the instance creation routine of step S540, the control routine proceeds to step S700, where the main data structure of the task is created. In other words, memory is allocated to the task and an uncoupled link is established. Next, in step S710, a portion of the data structure unique to each task is generated. In other words, memory locations are filled with zeros. Next, a channel data structure is generated in step S720. In other words, the memory location is defaulted. Next, in step S730, the forward link and the reverse link (if any) are linked to a particular task. If a reverse link is required, its data structure is defined, but this is not completed until the pipeline is called, since the upstream task to which the reverse link is linked has not yet been created. This link is a pointer to a collection of procedures. Next, in step S740, the control routine returns to step S540.

FIG. 26 shows a flowchart for the calling routine of step S560. Step S560
, The control routine continues to step S800, where the host application 220 supplies data to the final pipeline section. Next, in step S810, the data is processed by the current pipeline section. In step S820, data processing system 20 determines whether the current task has a forward link. If so, data is provided to the next downstream pipeline section in step S830, which is processed again in step S810. This loop continues until data is supplied to the pipeline section having no link (first pipeline section) and processed. When the data is supplied to the first pipeline section and processed, the processed data is supplied to the output device (step S84).
0). Next, the control routine returns to step S560.

In another application of this system, FIG.
7, a stream-oriented UNIX that processes images very efficiently on a scan line-by-scan line basis, as shown in FIG.
A system is created for emulating a pipeline. This UNIX pipeline has many advantages, as described above.

In the image processing pipeline according to the present invention, an image is divided into two main parts (header and image body). The header defines the state of the image, such as the color space displayed therein, the orientation of the image, and the dimensions of the image, such as the length of the scan lines, the number of scan lines, the interlace factor, the pitch, etc. The image body contains the actual scan line data, such as in the form of a raster output scanner, where each scan line is one data element that must pass through that pipeline. In this type of image processing pipeline, the image body includes the same scan line structure repeated multiple times.

Each pipeline section has at least three channels. The first channel is used to process header information. The second channel is
Used to process the image body on a per scan line basis. One or more channels of the second channel type may be provided according to the type of image processing provided by the pipeline. The third channel is used to perform the requested clear-up (erase) operation and release the memory allocated to the pipeline section once the image has been completely processed. Since the image processing is completed by the time this third channel is called,
Only data passing through the third channel becomes error processing information. With the third channel, each upstream pipeline section returns any error codes resulting from the image processing, and once this information is returned, the receiving upstream pipeline section dynamically deletes the downstream pipeline section. . In addition, any necessary external port procedure pointers are included in the data structure of the pipeline section of the image processing pipeline.

In the image processing system shown in FIGS. 27 and 28, the generalized task means 68 in FIG.
A first channel unit 84a is provided as a header channel, a second channel unit 84b is provided as an image processing channel, and a third channel unit 84c is provided as an end channel. As described above, a data processing pipeline is created when the host application determines that data must be processed. The pipeline is generated by instantiating various library functions from the function library 10. In image processing systems, these functions invert the color of the image.
t ”,“ colorize ”to colorize a black and white image, eg“ filter ”to apply a superposition filter to soften the edges in the image,“ enlarge ”to enlarge the image body, and“ reduce ”to reduce the image body This list is for illustrative purposes only and is not exhaustive: for example, "invert" converts black pixels to white pixels and vice versa, and "invert" uses color Convert pixels, for example, from red to cyan, green to magenta, and blue to yellow.

An example of data processing performed by the data processing pipeline will be described below with reference to FIG. This example describes the data processing of a color image data block provided by a color image scanner.
In this example, the pipeline can dynamically reconfigure itself to overcome detected errors.

In this example, the host application instantiates a data processing function from the function library to generate a data processing pipeline for receiving and processing the four-color image, which is then represented in FIG. The image is printed by the four-color printer 221 as described above. The pipeline is then called by the host application to enter image header data. Until the header data reaches the first pipeline section,
Move through channel 1 of the pipeline. When each pipeline section receives a header, each pipeline section checks this header to see if it can correctly process the image data it will receive, and this pipeline section does on the image data Modify the header to reflect what should be done. The pipeline section then sends the modified header data to an adjacent downstream pipeline section. However, if the pipeline section determines that the image to be received cannot be properly processed, it dynamically reconfigures the pipeline to overcome the problem .

If a pipeline is generated on the assumption that the color image to be processed is a four-color image, but the color image is not a four-color image but a three-color image, the color image received from the host application Indicates that the image is a three-color image. An error occurs because the printer was assumed to use 4-color data. In this case, a potential error is found when the pipeline section processes the header data.

The pipeline section that detects an error automatically reconfigures the pipeline by instantiating and adding a new pipeline section immediately upstream of the pipeline. The pipeline reconfigures itself as described above based on the type of link and the required location of the new pipeline section in relation to the pipeline section detecting the error. This new pipeline section changes the color space of the image data from three colors to four colors. At the same time, the pipeline section that detects the error changes the link to reflect the location of the new pipeline section. Next, the header data is returned. Now, after the new pipeline section has changed the header to reflect changing the color space of the image to four-color image data, the pipeline section that detected the error will be able to process the image data correctly. Judge that you can do.

When the header is completely processed and reaches the first pipeline section, the host application repeatedly calls the pipeline to enter the image body. Each time the pipeline is invoked, the host application supplies one scan line of the image through the pipeline, one pipeline processing the scan line and supplying it to the printer. From this header, the host application knows how many scan lines are in the image body, and thus knows how many call cycles are required to input and process the entire image body. In all other respects, the pipeline operates generally as described above. Once the entire image body has been obtained, processed, and sent to the printer, the host application calls a third channel to shut down the pipeline. FIG.
FIG. 8 shows a flowchart showing the execution of this pipeline.

Although the present invention has been described with reference to the preferred embodiments, the present invention is not limited to the embodiments described in this specification. Various changes, modifications, or improvements may be made without departing from the spirit of the invention and without exceeding the scope of the invention as set forth in the claims.

[Brief description of the drawings]

FIG. 1 shows a block diagram of the system of the present invention.

FIG. 2 is a diagram showing a block diagram of a pipeline of the present invention.

FIG. 3 is a block diagram showing the flow of data in the pipeline of the present invention.

FIG. 4 illustrates a linked pipeline for an exemplary data processing program.

FIG. 5 illustrates an example code list for a sample task.

FIG. 6 illustrates an example code list for a sample task.

FIG. 7 illustrates an example code list for a sample task.

FIG. 8 illustrates an example code list for a sample task.

FIG. 9 illustrates a code listing for an exemplary host application that calls tasks from a library to form a pipeline.

FIG. 10 shows the output list of the pipeline shown in FIG. 4 and listed in FIGS. 5, 6, 7, 8 and 9;

FIG. 11 is a diagram showing a flowchart of a routine for carrying out the present invention.

FIG. 12 is a diagram showing a flowchart of a function initialization routine.

FIG. 13 is a diagram showing a flowchart of a calling and processing routine.

FIG. 14 is a diagram showing a data processing pipeline.

FIG. 15 illustrates a flowchart for forming and executing the pipeline of FIG. 14;

FIG. 16 is a diagram showing a second embodiment of the data processing pipeline.

FIG. 17 shows a flowchart for forming and executing the data processing pipeline of FIG. 16;

FIG. 18 shows a block diagram of a data processing system of the present invention.

FIG. 19 is a block diagram illustrating a generalized task of the present invention.

FIG. 20 is a block diagram illustrating a second generalized task of the present invention.

FIG. 21 is a block diagram illustrating another embodiment of the data processing system of the present invention.

FIG. 22 is a block diagram illustrating another embodiment of the pipeline of the present invention.

FIG. 23 is a block diagram showing another embodiment of the pipeline of the present invention.

FIG. 24 is a flowchart showing a routine for carrying out another embodiment of the present invention.

FIG. 25 is a flowchart showing a function initialization routine according to another embodiment of the present invention.

FIG. 26 is a flowchart showing a calling and processing routine according to another embodiment of the present invention.

FIG. 27 shows a data processing pipeline according to another embodiment of the present invention.

FIG. 28 is a diagram illustrating a flowchart for forming and executing the pipeline of FIG. 27;

[Explanation of symbols]

28 control line 30 data bus 40a, 40b, 40c, 40d pipeline section 42 data processing channel 44 data structure 46 external port 48 reverse link 48 'forward link 84a, 84b, 84c, 84d channel means 100 computer 140a, 140b, 140c, 140d Pipeline section 148 Forward link 148 'Reverse link 172 Data transfer means

Claims (1)

[Claims] 1. A data processing system for pipelined data processing on a data basis, the data processing system comprising: a single tasking processor; a memory; and a memory management means for allocating blocks of the memory. Library means for storing a data processing function, and host application means for generating a data processing pipeline and supplying data to the pipeline, wherein the host application means comprises at least one data processing An instance generating means for generating a data processing pipeline consisting of tasks, wherein each of the at least one tasks is stored in a memory block of the memory, and wherein each of the at least one tasks is a function of a data processing function from a library means. Instantiation, And calling means for supplying data to the data processing pipeline, wherein at least one task of the data processing pipeline comprises at least one of another task in the pipeline, an output device, and a host application means. Linking means for linking the tasks into one; a data set between the at least one task and at least one of other tasks, output devices, and host application means in the pipeline. And data acquisition means for obtaining a data set from one of the host application means and one of the other tasks. Including, data processing system.