Image processing system and information processing system

An image processing system 1 (information processing system) includes a plurality of input interfaces 11, 12, and 13 for inputting image data output from a plurality of host systems C, PC1, and PC2, an input buffer 41 for storing the image data input through the input interfaces, determination mechanism for determining the upper limit value of the storage amount of the image data stored in the input buffer 41 for at least one of the input interfaces 11-13, and mechanism for storing image data in the input buffer in a scattering manner so as not to exceed the upper limit value determined by the determination mechanism.

BACKGROUND OF THE INVENTION 
1. Field of the Invention 
This invention relates to an image processing system and an information 
processing system for receiving data from a number of host systems via a 
number of input interfaces and processing the received data. 
2. Description of the Related Art 
Hitherto, several arts of sharing an input buffer to handle data input 
through a number of input interfaces have been disclosed. For example, an 
art of dividing a large memory area into small blocks for management, 
thereby changing the input buffer capacity of a printer without again 
turning on power is disclosed in Japanese Patent Unexamined Publication 
No. Hei 7-144442. 
Further, an input method of data through a number of interfaces is 
described. In this method, however, if data input through one interface 
occupies all the input buffer, data cannot be input through any other 
interface, causing an increase in the load of a host system and a busy 
state leading to an inoperative state. 
Generally, the input buffer capacity is increased as means for shortening 
the duration of a problem such as the inoperative state caused by the busy 
state. For example, an art of changing the input buffer capacity in 
response to the input interface selection condition for improving the use 
efficiency is disclosed in Japanese Patent Unexamined Publication No. Hei 
6-305204 and a method of analyzing the contents of input data and changing 
the input buffer capacity depending on whether the data is code or bit map 
data is disclosed in Japanese Patent Unexamined Publication No. Hei 
6-44014. 
However, if a time slice function of a multitask operating system is used 
to execute simultaneous input of data into an input buffer shared among 
input interfaces, the input buffer size needs to be changed during the 
data input. The "simultaneous input" mentioned here is defined as data 
input through more than one interface within a minute time interval like 
0.1 seconds. 
To share an input buffer at the simultaneous input time, an art of enabling 
host systems to specify how an input buffer of a printer having a number 
of input interfaces is shared is available as disclosed in Japanese Patent 
Unexamined Publication No. Hei 5-100803. In this art, while one of the 
host systems connected to the printer is outputting data, if another host 
system starts outputting data, it becomes necessary for the host systems 
to conduct input buffer capacity negotiations with each other. This causes 
the printer function to depend on the host systems, impairing the general 
versatility of the printer itself. 
Also, an art of enlarging the buffer size when that an input buffer is full 
is sensed is disclosed in Japanese Patent Unexamined Publication No. Hei 
7-210365. However, when simultaneous input into the input buffer is 
executed through input interfaces, if the input buffer size is enlarged 
for each input interface, the buffer size required for another process is 
limited, thus causing a problem of lowering the performance. 
Further, an art of changing the allocation amount of a reception buffer 
having a fixed capacity to each of input interfaces is disclosed in 
Japanese Patent Unexamined Publication No. Hei 6-305204. However, in such 
an art, if the allocation amount is changed freely, a specific input 
interface monopolizes the reception buffer, making it impossible to input 
data from any other input interface. 
SUMMARY OF THE INVENTION 
It is therefore an object of the invention to provide an image processing 
system and an information processing system for decreasing the loads of 
host systems by sharing an input buffer among input interfaces 
efficiently. 
According to the invention, there is provided an image processing system 
comprising a plurality of input interfaces for inputting image data output 
from a plurality of host systems, an input buffer being divided into a 
plurality of blocks for storing the image data input through the input 
interfaces, means for determining the upper limit value of the storage 
amount of the image data stored in the input buffer for at least one of 
the input interfaces, and means for storing image data of one job in 
blocks of the input buffer in a scattering manner so as not to exceed the 
upper limit value determined by the determination means. 
According to the invention, there is provided an image processing system 
comprising a plurality of input interfaces for inputting image data output 
from a plurality of host systems, an input buffer for storing the image 
data input through the input interfaces, means for recognizing a capacity 
of an area of the input buffer not allocated to the input interfaces, 
means for allocating an input buffer area to the input interface to which 
image data is input based on the capacity recognized by the recognition 
means, and means for storing the image data in the area allocated by the 
allocation means. 
According to the invention, there is provided an image processing system 
comprising a plurality of input interfaces for inputting image data output 
from a plurality of host systems, an input buffer for storing the image 
data input through the input interfaces, means for measuring an image data 
processing capability of the image processing system or each of the host 
systems for each input interface, means for allocating an area of the 
input buffer for storing image data to each input interface based on the 
image data processing capability measured by the measurement means, and 
means for storing the image data in the area allocated by the allocation 
means. 
According to the invention, there is provided an information processing 
system comprising a plurality of input interfaces for inputting data 
output from a plurality of host systems, an input buffer being divided 
into a plurality of blocks for storing the data input through the input 
interfaces, means for determining the upper limit value of the storage 
amount of the data stored in the input buffer for at least one of the 
input interfaces, and means for storing data of one job in blocks of the 
input buffer in a scattering manner so as not to exceed the upper limit 
value determined by the determination means. 
In the invention, data input through a number of input interfaces is stored 
in blocks of the input buffer in a scattering manner so that the upper 
limit value determined by the determination means is not exceeded, thus 
the input buffer can be shared among the input interfaces without being 
monopolized by any one of the input interfaces. 
The capacity of an area of the input buffer not allocated to the input 
interfaces is recognized by the recognition means and an input buffer area 
is allocated to the input interface by the allocation means based on the 
recognized capacity, whereby an unused area of the input buffer can be 
allocated to the input interface effectively. 
The measurement means measures the image data processing capability for 
each input interface, whereby the allocation means can allocate an input 
buffer area to each input interface based on the image data processing 
capability.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
Referring now to the accompanying drawings, there are shown preferred 
embodiments of the invention. FIG. 1 is a block diagram to explain the 
hardware configuration of an image processing system in an embodiment of 
the invention. An image processing system 1 in the embodiment comprises a 
CPU 2 for controlling the sections of the image processing system 1, a 
timer 3, a memory 4 used as an image data buffer, a storage unit 5, a 
print section 6 for outputting image data, an operation section 7, and a 
number of interfaces including a LAN connection section 11, which is an 
interface for receiving image data from a file server S and a client C via 
a network N, a serial interface 12 for receiving image data from a 
personal computer PC1, and a parallel interface 13 for receiving image 
data from a personal-computer PC2. 
FIG. 2 is a block diagram to explain the software configuration in the 
embodiment of the invention. The image processing system in the embodiment 
adopts a multitask configuration in which a number of tasks operate in a 
coordinated fashion. In FIG. 2, the arrow indicated by a solid line 
denotes a data flow and the arrow indicated by a broken line denotes a 
message flow. Message queues are used to exchange messages between tasks. 
As is well known in the processing art, the term task used herein denotes 
a section, circuit, component or the like of a processing system. 
When an input section control task 21 senses reception of data, it notifies 
a data control task 25 of the data reception and stores the input data in 
an input buffer 41. At this time, the input buffer 41 is managed by an 
input buffer control task 26. Upon reception of the notification, the data 
control task 25 assigns an identifier to the data and sends a notification 
to a decomposer task 22. 
The decomposer task 22 reads the data (print language) from the input 
buffer 41, converts the data into a printable image, and records the image 
in a page buffer 42. Upon completion of preparation of a 1-page image, the 
decomposer task 22 notifies an output section control task 23 of the 
event. The output section control task 23 transfers the image recorded in 
the page buffer 42 to the print section 6 (see FIG. 1) for outputting the 
image data to predetermined paper. 
A system control task 24 controls initiating each task, etc. A UI control 
task 27 handles commands entered through an operation panel attached to 
the print section 6 (see FIG. 1) and produces display on a liquid crystal 
panel. 
FIG. 3 is an illustration to show how the input buffer is shared among the 
input interfaces. For example, the input buffer 41 temporarily stores 
image data input through three input interfaces I/F (A) to I/F (C), and 
outputs the image data to a decomposer 20. 
FIG. 4 is a schematic diagram to explain sharing the input buffer in block 
units. That is, the input buffer 41 is divided, for example, into eight 
blocks of block 1 to block 8 each consisting of 8 KB, and image data sent 
from the input interfaces I/F (A)-I/F (C) is assigned to the blocks 
appropriately for storage. 
The embodiment is characterized by the fact that the allocation amounts of 
the input buffer 41 to the input interfaces I/F (A)-I/F (C) are determined 
in various manners. In the example shown in FIG. 4, the allocation amount 
to the input interface I/F (A) is set to the upper limit value of three 
blocks (24 KB) and that to each of the input interfaces I/F (B) and I/F 
(C) is set to an unlimited value. 
FIG. 5 is a schematic diagram to explain block management of the input 
buffer. In the figure, entry i corresponds to block i and holds a flag and 
a block pointer. The flag is used to judge whether or not the entry i is 
used. The block pointer is an identifier indicating the block area in 
which data is stored. If there is a block already reserved and not yet 
read, reserved block is linked following unread block and the data 
reception order is stored. 
FIG. 6 is a schematic diagram to show how the blocks are linked in the 
state shown in FIG. 4. For example, entry 1 holds the upper limit value of 
the input interface I/F (A) and a pointer to the block in which data 1 is 
stored. In the example shown in FIG. 6, entries 1-4 are used and entries 
5-8 are unused. The block read order is stored as a list structure. 
Next, the operation of the image processing system in first embodiment will 
be discussed. FIG. 7 is a flowchart to explain the operation of the input 
section control task and input buffer control task when data is written 
into the input buffer in the first embodiment. FIG. 8 is a flowchart to 
explain the operation of the decomposer task. 
For reference numerals not shown in FIG. 7 or 8 in the description that 
follows, see FIGS. 1 and 2. To clarify the description of the operation, 
assume that a fault such as a delay of data input does not occur. 
When the input section control task 21 senses reception of data at steps 
S101 and S102, it sends an input buffer allocation request to the input 
buffer control task 26 at step S103. Upon reception of the input buffer 
allocation request from the input section control task 21, the input 
buffer control task 26 reserves an unused block shown in FIG. 6. Whether 
or not each entry is used can be determined by providing flag; in the 
embodiment, the upper limit value is used as the flag as follows: 
Upper limit value=0: Indicates that the entry is used for data N. 
Positive integer: Indicates that the entry is used for data N with a 
limited number of blocks. 
Positive infinity: Indicates that the entry is used for data N with an 
unlimited number of blocks. 
The input buffer control task 26 retrieves the entries shown in FIG. 6 and 
records the maximum number of blocks for each data calculated by an upper 
limit value calculation section in an unused entry. For example, assuming 
that the block size is 8 Kbytes and that the maximum number of blocks is 
4, the capacity of the input buffer that can be used for the data becomes 
32 Kbytes. Based on the capacity, data is input and stored in the input 
buffer at steps S104 and S105. It is stored until the end of the data is 
reached at step S106. 
Here, reservation of the input buffer and data storage will be discussed. 
When the input section control task 21 requests the input buffer control 
task 26 to write the input data into the input buffer, the input buffer 
control task 26 compares the upper limit value with the number of blocks 
held in the current list (steps S107-S109). 
If the upper limit value is greater than the current value in the 
comparison, a block with flag=unused is retrieved and if it is found, the 
block reserved with the flag set to unused is linked. Then, the write data 
from the input section control task 21 is copied into the reserved block 
and a response indicating normal storage of the data is returned (steps 
S110-S113). 
On the other hand, if the upper limit value is less than or equal to the 
current value or all blocks are used (an unused block does not exist), a 
retry is made until block reservation results in success at steps S111 and 
S112. When the input section control task 21 senses the end of the data, 
it notifies the input buffer control task 26 of the termination of the 
reception. 
Next, data read will be discussed. When the data control task 25 receives a 
data reception start notification from one of the input interfaces, a data 
read request is sent to the input buffer control task 26 (steps S201 and 
S202) and the data stored in blocks in accordance with the storage order 
held as a list structure as shown in FIG. 6 is transmitted to the data 
control task 25 (steps S203 and S204). 
Next, whether or not the end of the data is read is determined at step 
S205. If the end of the data is read, a read success notification is sent 
at step S206; otherwise, the reserved area is released at steps S207 and 
S208. 
When all blocks registered in the list are deleted after the data control 
task 25 receives a reception termination notification from the input 
section control task 21, it indicates that all data has been read. Then, 
the entry is released for the next data reception and the decomposer task 
22 executes an analysis and image generation process until the end of data 
is reached at steps S209 and S210. 
To set the upper limit value, the user may set the upper limit value of the 
number of blocks for each interface through the operation panel. In this 
case, the input buffer control task 26 reserves the buffer, it references 
the upper limit value for each input interface held by the UI control task 
27. That is, the input buffer control task 26 references the priority for 
each host system (user) set by the user through the operation panel and an 
upper limit value calculation table for obtaining the upper limit value 
responsive to the priority, thereby determining the upper limit value. 
Alternatively, to set the upper limit value, the data processing capability 
or throughput for each input interface is calculated and the upper limit 
value may be determined in response to the data throughput. 
Alternatively, to set the upper limit value, the data throughput value for 
each input interface is calculated from the past use history and the upper 
limit value may be set based on the calculated value. 
For example, the use history may contain an average value found from the 
total data size and the total number of data pieces received for each 
interface counted by the input buffer control task 26 or an average value 
according to the time band that can be calculated by using the timer 3. 
For example, to calculate the input buffer capacity based on the average 
data amount for each interface obtained from the total number of data 
pieces and the total data amount input in the past, the following 
calculation expression is used: 
EQU Input buffer amount for interface P=P.multidot.foo (x) 
when 
basic input buffer amount for interface P=BUFp 
total number of data pieces for interface A=Np 
total data amount for interface A=Mp 
weight calculation function foo (x) 
where average data amount per data piece, x,=Mp/Np 
.SIGMA.(BUFp.multidot.foo (x))=total input buffer capacity for all P 
As alternative setting of the upper limit value, the time taken for storing 
image data per unit amount is stored in the input buffer is recognized for 
each input interface and the upper limit value can be set based on the 
recognized time. 
For example, if the storage time of the image data per unit amount is long, 
the upper limit value of the input buffer for the input interface is set 
large; if the storage time is short, the upper limit value of the input 
buffer for the input interface is set small, whereby the input buffer can 
be allocated to the input interfaces effectively. 
As alternative setting of the upper limit value, the interrupt time per 
unit time for which image data input through each input interface is 
interrupted during execution of one job is recognized and a predetermined 
upper limit value can also be set for the input interface corresponding to 
the shortest interrupt time recognized. 
The input buffer capacity can also be calculated based on the ratio between 
the data storage time from the storage start time to the storage end time 
for each input interface and the buffer full condition duration for each 
data piece obtained from the data input interrupt time because data is 
stored in all the available input buffer area, namely, the buffer full 
condition duration. 
An example of the calculation expression used by an allocation amount 
calculation section is given below: 
Input buffer amount for interface P=P.multidot.foo (x) 
when 
basic input buffer amount for interface P=BUFp 
total data input time for interface P=Tp 
total buffer full condition duration for interface P=Tp 
weight calculation function foo (x) 
where average buffer full condition duration per data piece, x,=Tfull/Tp 
.SIGMA.(P.multidot.foo (x))=total input buffer capacity for all P 
If the input interfaces are of the type wherein two-way communication can 
be executed, the upper limit value can also be determined by referencing a 
throughput inspection table listing the host system capability determined 
from information of the CPU type, memory installation amount, operating 
system type, etc., returned from the host system in response to an inquiry 
(level a-d from high to low) and the printer capability determined from 
the CPU and installation memory amount of the printer returned from the 
system control task 24 in response to an inquiry made by the print section 
6 (level A-D from high to low), as shown in FIG. 9A. 
If the input interfaces are of the type wherein only one-way communication 
can be executed, the upper limit value may be determined by referencing a 
throughput inspection table as shown in FIG. 9B in response to the input 
interface capability. 
If the host system comprises a spooler, the upper limit value may be 
determined from the data storage speed and the data read speed because a 
relationship exists between the input buffer amount and the throughput 
value when data passes through the input buffer. On the other hand, if the 
host system does not comprise a spooler, no limit is placed on the upper 
limit value of the input buffer to minimize the client release time. 
The upper limit value for each input interface may be set in response to 
the priority levels added to the host systems, may be set in response to 
the priority levels previously added to the users of the host systems, or 
may be set based on the priority levels added to the image data to be 
transferred. 
The upper limit value may be set in response to the priority level set for 
each input interface, in which case a predetermined upper limit value is 
set for the input interface of low priority and an upper limit value 
higher than that set for the input interface of low priority is set for 
the input interface of high priority or the input buffer is allocated 
unlimitedly to the input interface of high priority without setting the 
upper limit value, whereby the image data input through the input 
interface of high priority can be stored preferentially. 
As alternative setting of the upper limit value, the number of unused 
blocks is compared with the remaining data amount and if the amount of 
data that can be stored in the unused blocks is greater than the remaining 
data amount, the input buffer control task can also temporarily set the 
upper limit value to an unlimited value. In the embodiment, the 
application condition of no limit is effective only for the data. At this 
time, the input buffer control task 26 needs to be notified of the total 
amount of the data when an input buffer allocation request is made, etc. 
As alternative setting of the upper limit value, the data amount of image 
data input through each input interface in job units is measured and the 
upper limit value may be set for the input interface with a large data 
amount measured. 
As alternative setting of the upper limit value, the capacity of blocks in 
which no image data is stored is recognized and if the recognized capacity 
is greater than a predetermined amount, the upper limit value may be set 
high. 
A weighted value may be adopted for the number of unused blocks. For 
example, assuming that a weight coefficient=50% (constant), if the number 
of unused blocks is 4, the maximum number of blocks=2 is adopted as the 
upper limit value. 
As alternative setting of the upper limit value, the input buffer control 
task 26 can also dynamically change the upper limit value by referencing 
an upper limit value setting table responsive to the number of data pieces 
being input as shown in FIG. 10. For example, the upper limit value of 
data n with the number of data input pieces=3 and the data order=2 is 2 
and if processing of the data with the data order 1 is complete in this 
state, the data order of the data n becomes 1 and the number of input data 
pieces becomes 2, thus the upper limit value is changed to 4. 
If an amount of image data less than the upper limit value set so as to 
prevent specific image data from monopolizing the input buffer is input 
through a specific input interface, the upper limit value for the specific 
input interface may be again set. 
As alternative setting of the upper limit value, the number of data pieces 
of image data stored in the input buffer in job units is recognized and 
the fewer the number of data pieces, the higher the setup upper limit 
value. 
In the first embodiment, the upper limit value of the input buffer for each 
input interface is determined in various manners, whereby the input buffer 
can be shared among the input interfaces without being allocated only to 
one input interface. 
Next, a second embodiment of the invention will be discussed. FIG. 11 is a 
schematic diagram to explain ring buffers applied in the second 
embodiment. FIGS. 12A and 12B are schematic diagrams to explain an 
organization example of a binary tree. FIGS. 13A to 13G are schematic 
diagrams to explain input buffer management in the second embodiment. 
FIGS. 14A to 14D are schematic diagrams to explain binary tree reduction 
rules applied in the second embodiment. 
In the second embodiment, an input buffer allocated to each input interface 
by an input buffer control task 26 is installed as ring buffers as shown 
in FIG. 11. The ring buffers are provided to manage data stored in an 
input buffer 41 like a ring. If a contiguous area of the input buffer 41 
is used for data (1) as shown in FIG. 11, ring buffer (1) is formed 
according to the top and end addresses of the contiguous area; if split 
areas in the input buffer 41 are used for data (2) as shown in the figure, 
ring buffer (2) is formed according to the top and end addresses of the 
split areas as if a contiguous area were used. 
For example, an area of the input buffer can be reserved from all the 
remaining capacity, the maximum unused contiguous fragment capacity, etc. 
Here, a procedure of recognizing the maximum unused contiguous fragment 
capacity will be discussed. A binary tree of an organization as shown in 
FIG. 12A is used as an input buffer management method. To insert or delete 
a node, the used or unused input buffer amount is calculated from the 
fragment capacity and is stored in a determined region of the root, 
whereby it is made possible to recognize the total empty area capacity of 
the input buffer. 
A pointer to the node of the maximum unused fragment is set from the 
reserved fragment capacity at the same time. Thus, the maximum unused 
fragment capacity can be obtained. 
By the way, empty areas need to be merged depending on the release order of 
used input buffer areas as seen in FIGS. 13C to 13D. In such a case, a 
binary tree reduction process is executed according to the merge rules as 
shown in FIGS. 14A to 14D. 
The area for data (5) may be reserved as FIG. 13F wherein it is reserved 
from the side of data (3) or FIG. 13G wherein it is reserved from the side 
of data (4) as seen in FIGS. 13E to 13G. Which of FIGS. 13F and 13G is to 
be adopted depends on the time until the storage area of data (3) is 
released and the time until the storage area of data (4) is released. 
That is, if the time until the storage area of data (3) is released is 
shorter than the time until the storage area of data (4) is released, FIG. 
13F is adopted; otherwise, FIG. 13G is adopted. This algorithm enables 
suppression of fragmentation occurrence in the input buffer. The selection 
criterion is not limited to it. 
Next, a procedure of reserving an area of the input buffer from all the 
remaining capacity will be discussed. To insert or delete a node, the 
comparison result between the input buffer capacity to be reserved and the 
maximum unused fragment capacity is stored in a determined region of the 
root and is updated, whereby a pointer to the node of the maximum unused 
fragment can be obtained. 
Unlike formation of a ring buffer only within each fragment as described 
above, an amount of the input buffer calculated from the remaining 
capacity recognized must be reserved. Thus, a list connecting the 
fragments as shown in FIG. 12B is used. To hold the list structure, 
regions for storing pointers to the preceding and following nodes are 
provided in the structure of each node. 
Then, the operation will be discussed along a flowchart shown in FIG. 15. 
In the embodiment, 50% of the remaining amount is always allocated, but 
the calculation method is not limited to it. For reference numerals not 
shown in FIG. 15, see FIGS. 1 and 2. 
First, when the input buffer control task 26 makes an allocation request of 
the input buffer 41 from an input interface (steps S301-S303), an input 
buffer area is reserved in the amount of 50% of the remaining memory 
capacity recognized according to the above-described procedure (steps 
S304-S305) and a notification is sent to the input interface. As in the 
first embodiment, an input section control task 21 detects the end of data 
and notifies the input buffer control task 26 of the storage completion 
(steps S306-S310). At the completion of read of a decomposer task 22 
(steps S311-S318), the input buffer control task 26 releases the reserved 
area. 
According to the second embodiment, the capacity of the input buffer to be 
reserved can be determined based on the remaining capacity of the input 
buffer and the input buffer having a small memory amount can be allocated 
to a number of input interfaces effectively. 
Next, a third embodiment of the invention will be discussed. FIG. 16 is a 
flowchart to show the operation of referencing a use history and 
calculating the input buffer capacity in the third embodiment. 
First, when an input buffer control task 26 makes an input buffer 
allocation request from an input interface at step S401, an input buffer 
area as large as the calculated capacity is reserved (steps S402-S406). In 
the calculation method shown in FIG. 16, statistical information 
representing the past use history is referenced and the input buffer 
amount allocated to each input interface is calculated. 
After this, an input interface control task is notified that the input 
buffer area has been reserved. As in the first and second embodiments, 
when an input section control task 21 notifies the input buffer control 
task 26 of the reception termination, the input buffer control task 26 
releases the reserved area. 
In addition to the input buffer reservation method using a use history, an 
input buffer capacity may be calculated based on the average throughput 
value for each interface calculated from the reception time and expansion 
timer per unit data amount measured with a timer 3 by the input buffer 
control task 26 for reserving an input buffer area based on the calculated 
input buffer capacity. 
An example of the calculation expression used by an allocation amount 
calculation section is given below: 
Storage speed of input interface control task THin=data amount/(storage end 
tim-storage start time) 
[bytes/second] 
Processing speed of decomposer task THdcmp=data amount/(read end time-read 
start time) [bytes/second] 
Throughput value=THin/THdcmp 
Assuming that new average throughput value is THn, that current throughput 
value is THc, and that throughput value of present data is THd, 
THn=(THc+THd)/2 [no units] 
BUF.sub.p .multidot.foo (THn)=total capacity 
It is possible that the smaller the throughput value calculated according 
to the expression, the shorter the connection duration to the host system. 
Thus, the input buffer capacity may be calculated simply based on the 
connection time to the host system. 
The input buffer capacity can also be calculated based on the average data 
amount for each interface obtained from the total number of data pieces 
and the total data amount input in the past. 
An example of the calculation expression used by the allocation amount 
calculation section is given below: 
Input buffer amount for interface P=P.multidot.foo (x) 
when 
basic input buffer amount for interface P=BUFp 
total number of data pieces for interface A=Np 
total data amount for interface A=Mp 
weight calculation function foo (x) 
where average data amount per data piece, x,=Mp/Np -(BUF.sub.p 
.multidot.foo (x))=total input buffer capacity for all 
p 
Further, the input buffer capacity can also be calculated based on the 
ratio between the data storage time from the storage start time to the 
storage end time for each input interface and the buffer full condition 
duration for each data piece obtained from the buffer full condition 
duration. 
An example of the calculation expression used by the allocation amount 
calculation section is given below: 
Input buffer amount for interface P=P.multidot.foo (x) 
when 
basic input buffer amount for interface P=BUFp 
total data input time for interface P=Tp 
total buffer full condition duration for interface P=Tp 
weight calculation function foo (x) 
where average buffer full condition duration per data piece, x,=Tfull/Tp 
.SIGMA.(P.multidot.foo (x))=total input buffer capacity for all P 
In the third embodiment, the capacity of the input buffer to be reserved 
can be determined in response to the input interface use condition, so 
that the input buffer having a small memory amount can be allocated to a 
number of input interfaces effectively. 
In the embodiments we have discussed, the image processing systems are 
mainly taken as an example. However, the invention can also be applied to 
information processing systems for processing text data, etc., other than 
image data. 
As we have discussed, according to the image processing system and 
information processing system of the invention, if data is input through a 
number of input interfaces, the input buffer can be shared efficiently 
among the input interfaces for reducing the loads of the host systems. 
The foregoing description of a preferred embodiment of the invention has 
been presented for purposes of illustration and description. It is not 
intended to be exhaustive or to limit the invention to the precise form 
disclosed, and modifications and variations are possible in light of the 
above teachings or may be acquired from practice of the invention. The 
embodiment was chosen and described in order to explain the principles of 
the invention and its practical application to enable one skilled in the 
art to utilize the invention in various embodiments and with various 
modifications as are suited to the particular use contemplated. It is 
intended that the scope of the invention be defined by the claims appended 
hereto, and their equivalents.