JPH08249377A - Method and device for calculating required amount of material - Google Patents

Abstract

PURPOSE: To shorten the processing time of required material amount calculation by performing component expansion calculating processes of respective items in parallel. CONSTITUTION: This device is provided with at least one MPS read part 1 which reads in MPS. Component calculation parts 4 which perform the component expansion calculating processes of the respective items are provided by as many as the items. The respective component calculation parts 4 are connected in the same relation with the component constitution of the items. The respective component calculation parts 4 advance the component expansion calculations of the respective items in parallel according to the progress state of the component expansion calculation of their master item. Thus, since the processes are advanced in parallel, a calculation result similar to that of conventional sequential necessary material amount expansion calculation can be obtained in a short time.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a material requirement calculation method and apparatus for obtaining various parts and raw materials necessary for producing a product produced by a production plan when the production plan is input.

[0002]

2. Description of the Related Art When one product such as a motor is specified, one of the methods for automatically calculating the types of parts and the number of parts required to make this product is a material requirement plan (Material Requirements Plannning, "MRP"
Is called). The material requirement calculation method and apparatus refer to the calculation method and apparatus for this MRP. Hereinafter, the material requirement calculation will be referred to as “MRP calculation”.

The MRP and the conventional MRP calculation method are, for example, "500 illustrated MRP terms" (Nikkan Kogyo Shimbun: Showa).
(Published in 1983), etc., but the conventional MRP calculation method will be briefly described below.

In the MRP calculation, a product-level production plan (Master Production Schedule, hereinafter referred to as “MP”) is planned.
Based on "S"), for items such as parts and raw materials, "necessary items (items), when needed (delivery date), as much as necessary (required amount)" for purchasing or manufacturing Calculate the arrangement plan, which requires the following three pieces of information.

(1) MPS Generally, a production plan of an item (product) at the top level in a parts development view. Also called standard production plan.

(2) Parts table Data unique to an item called "item data" and products and parts, parts and parts, called "product configuration data"
A table consisting of two master data items, such as parts and raw materials, and data showing the relationship between items.

The item data includes, for example, the time (hereinafter referred to as "lead time") required when manufacturing or purchasing the part. Also, depending on the product composition data, for example, what are the sub-items required to manufacture a certain item, and how many sub-items are required for one item to be manufactured (this is the "number of each sub-item") Called) can be obtained.

(3) Inventory / remaining quantity For each item, the current inventory, the number of work in progress, or the delivery time and the planned quantity of the item that has already been ordered and is scheduled to be delivered in the future (remaining order information).

Based on such information, in the MRP calculation, the following five calculations are performed for each item.

(1) Calculation of total required amount The required amount data of the item is read, the required amounts are summarized in a certain period, and the total required amount for each period is calculated.
Hereinafter, in order to simplify the explanation, the period is set to one day, and the daily planning will be described.

(2) Calculation of Net Requirement Based on the calculated total requirement, inventory and backorder are allocated, and the net requirement required for each day is calculated.

(3) Lot Summary Based on the calculated daily net requirement, the lot size set for the item is used to summarize the quantity most suitable for arrangement.

(4) Lead time calculation The lead time is subtracted from the delivery date of the lot-collected quantity, the order date or the start date is calculated, and the order is created.

(5) Expansion of required quantity The created order is expanded to lower order items using the parts table. Specifically, the required amount of each child item is calculated based on the child item and the number of members of the product configuration data, using the day before the start date of the order as the request date, and written in the required amount data of each item.

The above calculations (1) to (5) will be collectively referred to as "parts expansion calculation" below. MRP
The calculation is performed for all products set by MPS, and the component expansion calculation for all the items required when manufacturing the product is performed.

At this time, it is necessary to pay attention to the timing of performing the component expansion calculation for each item. For example, in the case of a product having the configuration shown in the exploded view of FIG. 2, item C
L is a child item of item HC and item RC. Therefore, the total required amount of the item CL is the sum of the required amounts from the item HC and the item RC, and the component development calculation of the item CL must be performed after the component development calculation of the item HC and the item RC is completed.

In this example, a relatively simple component structure of only one product is used, but in reality, calculation is performed in a state where hundreds to thousands of products are complicatedly composed of tens of thousands of items. There is a need to do. Therefore, in the conventional MRP calculation, a low-level code is introduced and a queue is used to control the component development calculation of each item. Although it is common to use a pointer called an activity chain instead of the queue, the control method is essentially the same, so the conventional MRP calculation will be described below using the queue method as an example. do.

As shown in FIG. 2, a level code can be given to each item based on the component development view of a certain product, depending on which hierarchy in the component structure it belongs to. Depending on the item,
A product may belong to multiple hierarchies, or multiple products may belong to different hierarchies, and an item may have multiple level codes. Therefore, the lowest level code among them is the low level code. Here, the lower order refers to the direction of moving to a more basic item level on the exploded view. Normally, the level code has the product level as 0 level, and the number of level codes increases as the hierarchy progresses toward the basic item. Therefore,
The low level code is the highest level code among the level codes of the item. This also means that, unlike the level code, only one low level code is set for each item. The low level code of each item is set by searching all the items in the parts table before the MRP calculation is started, and is written in the item data as item-specific information.

In the conventional MRP calculation, the low-level code is used to determine the order of parts development calculation for each item on a level-by-level basis. Specifically, the process proceeds in the following procedure.

(1) Reading of MPS The requested amount read from the MPS is written to the product level item in the MPS. At this time, the item name is put in the level 0 queue.

(2) Calculation start from level 0 queue When all MPS readings are completed, one item name is taken out from the level 0 queue and the part development calculation for that item is performed. When finished, the next item name is retrieved from the queue. Here, when expanding the required amount in the parts expansion calculation,
Queue the child item name in the child item's low-level code queue. However, if it is already in the queue, nothing is done.

(3) Level-by-level expansion When a queue of a certain level becomes empty, one item name is taken out from the queue of the next lower level and the parts expansion calculation for that item is performed. It will keep picking up from that level's queue until it is empty. When the required amount of component expansion calculation is expanded, the child item name is put in the queue of the low level code of the child item. However, if it is already in the queue, nothing is done.

(4) Completion of MRP calculation Completion is completed when the queues of all levels are empty.

[0024]

DISCLOSURE OF THE INVENTION Problems to be Solved by the Invention As already explained,
The conventional MRP calculation is controlled by using a low-level code and a queue so that the component development calculation of each item is always performed after all the component development calculation of the parent item is completed. However, as a result of this control method, the parts development calculation for each item is performed one by one, and if the number of products, the number of parts, and the planning period are large, a huge processing time is required. . For this reason, this MRP calculation cannot be performed frequently, and it is not possible to respond in detail even when, for example, it is necessary to re-create the production plan according to market trends, or when inventory, backorder, etc. are changed. There was a problem.

An object of the present invention is to reduce the processing time of MRP calculation by processing the parts development calculation of each item in parallel and to make a production plan at high speed in response to various variations. .

[0026]

In order to achieve the above object, the MRP calculation method and apparatus according to the present invention does not have one MPS reading unit (1-3) for reading MPS as shown in FIG. In addition, a plurality of parts calculators (4 to 10) for performing parts expansion calculation for each item are provided for the same number as the items, and the parts calculator for each item is connected in the same manner as the parts configuration. Then, in the parts calculation unit of each item, the deployable date is calculated based on the requested date of the requested amount to be stacked from the parent item, and the component expansion calculation up to the deployable date is performed to calculate each item. The feature is that the parts development calculation of is advanced in parallel.

The configuration of the present invention will be described in more detail below.

According to a first aspect of the present invention, at least one MP is loaded with a separately defined production plan for a product.
An S reading unit and a component provided for each component of the product and connected to each other with the same structure as the parent-child relationship between components (hereinafter referred to as "component configuration") for performing component expansion calculation. And a component calculation unit located at the top of the component structure, each of which is based on the read production plan according to the read status of the production plan by the MPS reading unit corresponding to itself. By proceeding with its own component expansion calculation, and the component calculation units not located at the top of the above-mentioned component configuration, respectively, corresponding to their parents, according to the progress of the component development calculation of the component calculation unit, There is provided a material requirement calculation device characterized by processing parts development calculation in parallel with each other by advancing its own parts development calculation.

According to a second aspect of the present invention, at least one MP is loaded with a separately defined production plan for the product.
Each of the S reading unit, the component calculation unit for performing the component expansion calculation, and the component calculation unit is associated with each of the components constituting the product, and the parent-child relationship between the components (hereinafter, “component configuration”). And a network forming means that forms a network by connecting each other with a similar structure to each other. Each of the component calculation units located at the highest position in the component configuration is the MPS reading unit corresponding to itself. Depending on the read-in status of the production plan according to the above-mentioned production plan, the component development calculation is performed based on the read production plan. The component development calculation is performed in parallel with each other by advancing its own component development calculation according to the progress of the component development calculation of the component calculation unit corresponding to It's a is, material requirements computing device is provided, wherein.

A storage means for storing a component configuration table describing the component configuration is provided, and the network forming means refers to the component configuration table when forming the network to confirm the parent-child relationship between the component calculation units. It may be one.

It is preferable to provide a network formation end judging means for judging whether or not the network formation is completed.

The network forming means uses a low-level code to connect the parts calculation units in a level-by-level manner.
The network formation completion determination means may determine that the network formation is completed when the connection is completed to the lowest level.

When the component calculation unit is connected to the component calculation unit corresponding to the child, the component calculation unit sends a message to the component expansion unit corresponding to the child, and the network formation end determination means generates the message. The situation may be monitored, and it may be determined that the network formation is completed when the above message does not occur.

In forming the network, the component calculation unit located at the end of the component structure sends a message to the component calculation unit corresponding to the parent when it is connected to the component calculation unit corresponding to its parent. The component calculation unit that is not located at the end of the component structure sends a message to the component calculation unit corresponding to its parent when it receives the message from all the component calculation units corresponding to its own children. The network formation end determination means may determine that the network formation is completed when the message reaches all the component calculation units located at the highest position in the component configuration.

According to a third aspect of the present invention, at least one MP for reading a separately defined production plan for a product is read.
The S reading unit and the component calculation unit for performing the component expansion calculation are generated for each component constituting the product, and further, with the same structure as the parent-child relationship between each component (hereinafter referred to as “component configuration”). And a component calculation unit generating unit that forms a network of the component calculation units by connecting the component calculation units to each other, and the component calculation units located at the top in the component configuration respectively correspond to the MPS corresponding to themselves. Depending on the read status of the production plan by the reading unit, the component development calculation of itself is performed based on the read production plan, and the component calculation units not located at the top in the above-mentioned component configuration are themselves Depending on the progress status of the component expansion calculation of the component calculation unit corresponding to the parent of Rukoto, material requirements computing device is provided, wherein.

In this case, a storage means for storing a component configuration table describing the component configuration is provided, and the component calculation unit generation unit refers to the component configuration table at the time of forming the network so that the component calculation units are connected to each other. It may be to confirm the parent-child relationship.

It is preferable to provide a network formation end judging means for judging whether or not the network formation is completed.

The component calculation unit generating means advances the connection between the component calculation units on a level-by-level basis using a low level code, and the network formation end determining means determines that the connection is the lowest. It may be determined that the network formation is completed when the level is completed.

The component calculation section sends a message to the component calculation section corresponding to the child when it is connected to the component calculation section corresponding to its own child, and the network formation end determination means is the message forming section. May be monitored, and the network formation may be determined to be completed when the above message no longer occurs.

When forming the network, the component calculation unit located at the end of the component structure sends a message to the component calculation unit corresponding to the parent when it is connected to the component calculation unit corresponding to its parent. The component calculation unit that is not located at the end of the component structure sends a message to the component calculation unit corresponding to its parent when it receives the message from all the component calculation units corresponding to its own children. The network formation end determination means may determine that the network formation is completed when the message reaches all the component calculation units located at the highest position in the component configuration.

The component calculation section may start the component development calculation after the network formation end determination means determines that the network formation is completed.

The component calculation unit sequentially starts the component development calculation during the period in which the result of the component development calculation is delivered from all of the component calculation units corresponding to its parent, and the component development is performed. It is preferable that the calculation result is sequentially sent to the component calculation unit corresponding to its own child.

According to a fourth aspect of the present invention, a component calculation unit for performing a component expansion calculation is provided for each component constituting a product, and the component calculation unit is provided with a parent-child relationship between the components (hereinafter, "component configuration"). By connecting to each other with the same structure as (), a network between parts calculation units is formed,
After that, each of the component calculation units processes the component development calculation in parallel with each other by advancing the component development calculation of itself according to the progress of the component development calculation of the component calculation unit corresponding to its parent. A material requirement calculation method is provided.

[0044]

Operation: One or a plurality of MPS reading units (1 to
According to 3), MPS is read. The demanded amount of the read product is sent to the parts calculation unit (4 to 6) of the product as a heap message.

Each component calculation unit (4 to 10) calculates the deployable date based on the requested amount and the requested date sent from its parent item or MPS, and performs the component deployment calculation up to the deployable date. . In particular, in the required amount expansion calculation, the result of expansion up to the applicable development date is sent to the parts calculation unit which calculates the parts expansion of the child item.

When each component calculation unit (4 to 10) receives all the end reports from its parent item or MPS, it sends an end report to its child items and ends itself.
The MRP calculation is completed when all the component calculation units are completed.

Next, a more detailed description will be given along with the configuration of each of the above-mentioned aspects. In order to simplify the description, the component calculation unit corresponding to its own parent may be simply referred to as “parent”, and the component calculation unit corresponding to the child may be simply referred to as “child”.

The network forming means (or the parts calculating section generating means) associates the parts calculating section with each of the parts constituting the product, and further establishes a parent-child relationship between the parts (hereinafter referred to as "parts structure"). A network is formed by connecting each other with a similar structure. The network forming unit (or the component calculating unit generating unit) refers to the component configuration table to acquire the information regarding the parent-child relationship between the component calculating units. The component calculation unit generating means in the third aspect also generates the component calculation unit by itself.
On the other hand, the network forming means in the second aspect performs the association and connection with the above-described components, targeting the component calculation unit that is facilitated in advance.

The network formation end judging means judges whether or not the network is completed. There are various concrete methods for the determination. For example, if the network formation means (or the component calculation part generation means) advances the connection with another component calculation part on a level-by-level basis using a low-level code, the network formation end determination means is When the connection is completed to the lowest level, it can be determined that the network formation is completed.

Alternatively, when the component expanding unit sends a message to the component expanding unit corresponding to its own child when connecting with another component expanding unit, the network formation end judging means generates this message. When it is no longer possible, it can be determined that the network formation is completed.

Furthermore, the component development calculation unit located at the end of the component structure sends a message to the parent when it is connected to its own parent. On the other hand, the component expansion calculation unit not located at the end sends the message to its parent when it receives the message from all of its children. In such a case, the network formation end determination means may determine that the network formation is completed when the message reaches all of the component development calculation units located at the top in the component configuration. it can.

After the network is completed, the parts calculator starts the parts expansion calculation. In the first aspect, since the network is formed from the beginning, the component expansion calculation described below is immediately started without performing the above-described network forming process.

The MPS reading section reads the production plan. The parts calculator advances its own parts development calculation based on the production plan (or the result obtained by another parts calculator).

According to the present invention, the respective component calculators aim to shorten the processing time by advancing the component expansion calculation in parallel with each other. That is, the highest-ranked component calculation unit in the component configuration advances its own component expansion calculation according to the read status of the production plan by the MPS reading unit corresponding to itself. Similarly, the component calculation unit that is not located at the top of the component configuration advances its own component development calculation according to the progress status of its parent's component development calculation.

Each component development calculation unit can start the component development calculation even if the result of the component development calculation for the entire period in the production plan has not been sent from the parent. That is, the component calculation unit performs the component development calculation by dividing the component into predetermined periods. And as soon as the results for each period are obtained,
Sequentially send the results to your child.
As a result, the child sequentially starts the component development calculation for the period in which the results of the component development calculation are delivered from all the parents at that time (Note: the period does not have to be the entire period in the production plan). .

[0056]

EXAMPLE An example of the present invention will be described with reference to FIGS.

First, the basic idea of these embodiments will be described. As an example, consider MRP calculation with a component configuration as shown in FIG. In this component structure, only three types of product A, product B, and product C have shared components, and the lowest low-level code is 6.
The MRP calculation is to perform the component expansion calculation for all the items shown by boxes in this figure. However, the calculation of a certain item must be performed after the calculation of all of its parent items is completed. In the conventional sequential calculation, component expansion calculation is performed in the order of arrows as shown in FIG. That is, the level
The whole goes on at the bi-level, and at each level, the parts development calculation of the items belonging to that level is sequentially advanced.

On the other hand, in this embodiment, the low level code is not used. As shown in FIG. 5, the basic idea of the present embodiment is to calculate the deployable date of each individual item based on the request date and the end report from the parent item of the individual item, until the deployable date. By advancing the calculation, the parallelism of the component development calculation for each item is maximized. After that, this method will be referred to as "part development day parallel method"
Will be called. In the parts development date parallel method, there are the same number of parts calculation units as the items for calculating the parts expansion of each item. Then, the respective component calculation units are connected by a network similar to the network between the items according to the component configuration. That is, each component calculation unit is connected to the parent item and child component component calculation units of the item that it calculates, and exchanges information only between them. The progress of the calculation of the parent item can be known from the request date of the demand amount transmitted to the child items through this network, and the total requirement will not change from the progress of all the parent items of oneself. Therefore, the fixed period can be calculated. When the final date of the fixed period is the deployable date, the component deployment calculation can be performed until the deployable date, and the deployment result is further sent to the child items through the network. This makes it possible to obtain the same result for each item as the calculation method performed after the completion of all the component expansion calculations for the parent item as in the conventional MRP calculation, and in some cases, all items are simultaneously calculated. The more parallel the component expansion calculation is, the more parallel calculation becomes possible.

The overall configuration of the system constructed based on the above concept is as shown in FIG.

Next, common matters will be described before entering the details of the present embodiment.

Although the present embodiment is an example of a loosely coupled file non-shared parallel computer as shown in FIG. 6, a tightly coupled parallel computer or a loosely coupled file shared computer as shown in FIG. Alternatively, it is possible in a distributed environment in which these parallel computers and conventional sequential computers are connected by a network. In addition, in FIG. 6, each PE (Proce
ssing Element) is a single CPU. This is also a setting for convenience of explanation, and the present invention can be implemented even if each PE is a memory-tightly coupled multi-CPU.

In this embodiment, as shown in FIG. 8 (a), a database management system is distributedly arranged in loosely coupled PEs, but as shown in FIG. 8 (b). It is possible even in a situation where the database system is centrally managed by a specific PE. It is also possible to use a normal file system without using the database system.

In the following description, one group of calculation is called a process. A set of processes is also a process. In a multitasking operating system, multiple processes can run in parallel on one PE. In this embodiment, on such a multitasking operating system,
Although an explanation will be given using an example of a model in which processes communicate with each other, for example, a single task system in which one process always moves on one PE by providing a mechanism that queues executable processes and sequentially executes them. But it can be easily realized.

Here, the terms "parallel" and "parallel" used in the following description will be defined. "Parallel"
Means that multiple processes can be processed independently at the same time. This means that it is possible to move them at the same time logically, and whether or not the processes are physically progressing at the same time is not particularly mentioned. For example, when multiple processes are running in a time-sharing manner on one PE like multitasking, it can be said that they are running "in parallel". However, considering a certain moment, when the PE is a single CPU, only one process is actually running. On the other hand, “parallel” refers to a state in which a plurality of processes are physically processing at the same time.
If each process is running on multiple PEs,
It can be said that they are operating in "parallel".
"Parallel" is a larger concept than "parallel". Processes running in “parallel” always run in “parallel”, but processes running in “parallel” do not necessarily run in “parallel”. The present embodiment describes a model in which a plurality of processes move in parallel while exchanging messages. All these processes in one P
It is also possible to allocate it on E and proceed with the processing,
Processing proceeds in parallel by allocating on a plurality of PEs. As described above, the plurality of processes assigned to each PE may be sliced into smaller pieces and moved in a multitasking manner. The whole process may be moved sequentially.

The present embodiment will be described by using a calculation model in which a message sent from one process to another process reaches the process in the order in which they are sent. When this is also implemented in a calculation model in which the order is not saved, for example, a message to a certain process is sent with a serial number when sending, and the receiving side processes the message in the order of the serial number. By providing, it can be carried out in the same manner as this embodiment.

When a process sends a message to another process, it needs to know on which PE it is. Therefore, it is possible to construct a system simply by centrally managing which process is on which PE and performing communication between processes based on that. There are several methods of communication between processes, including a method of using general software called middleware for distributed environment. In the present embodiment, there are "methods" as shown in FIG. The explanation will proceed using a communication system called the "post office system". This tells which process is on which PE.
Mail process between PEs that is centrally managed in 11 locations (11)
Is to put one. Upon receiving a message addressed to a certain process, the PE-to-PE mail process (11) transfers it to the PE in which the process exists. Each PE has one in-PE mail process (12 to 14), and transfers the message transferred from the PE-to-PE mail process (11) to the destination process. When sending a message to a process in a PE, write the process name of the destination and send it to the PE mail process (12 to 14) of the PE in which the process is located. The in-PE mail process (12 to 14) immediately transfers to the destination process if the destination process exists in its own PE, and otherwise transfers to the PE-to-PE mail process (11). . By this mechanism,
Each process can proceed with exchanging messages without knowing in which PE the process to which the message is sent exists. Especially in MRP calculation,
The PE-to-PE mail process (11) keeps track of which PE is used to calculate the component expansion for each item, and each PE mail process (12 to 14) knows only the item name calculated by its own PE. are doing. Mail process in each PE (12
Even if 14 to 14) know nothing, the message always arrives via the PE mail process (11), but in that case, the time required for communication increases. The communication method between processes by the post office method is merely an example, and the present invention can be implemented by another method.

There may be a plurality of methods for assigning which process to which PE. This embodiment is an example of the allocation method, and other allocation methods are possible.

Based on the above matters, an embodiment of the parts deployment date parallel system will be described below.

First, the overall structure will be described with reference to FIG.

The explanation here is that N PEs (PE ₀ , ...
., PE _i , ..., PE _(N-1) ), which is a loosely coupled file non-shared parallel computer. In such a system, a database management system and a database (21) exist on each PE.

The process arranged on PE _{1 to} PE _n will be described.

Each of PE _{1 to} PE _n has an MPS reading process (15) and a component development calculation process (1
9), an in-PE monitoring process (24), and an in-PE mail process (25), respectively.

The MPS reading process (15) is shown in FIG.
It corresponds to the MPS reading unit (1 to 3 ...) in.

The component development calculation process (19) includes a plurality of component processes (16) and a component generation process (20) for generating component processes.

The parts process (16) corresponds to the parts calculator (4-10 ...) In FIG. Each component process (16) includes a component calculation process (17) for performing component expansion calculation for an item, and a component pile reception process (1) for receiving a pile message for the item.
8) and two.

The component generation process (20) is for generating the component process (16). In the parts development calculation process (19), a plurality of items to be calculated are defined in advance. Therefore, the part generation process (2
0) always generates one parts process (16) for each item to be calculated on the parts development calculation process (19).

Although not shown in FIG. 10, the parts development calculation process (19) also has a function for managing a plurality of parts processes (16) included therein.

The in-PE mail process (25) uses the P
This is to facilitate the exchange of mail between the processes provided in E. Therefore, the in-PE mail process (25) communicates with the MPS reading process (15), the component development calculation process 17, and the like. In addition, the in-PE mail process (25) is
In order to exchange mails between the internal process and the process on another PE, communication is also performed with the inter-PE mail process (23) arranged in PE ₀ .

The PE monitoring process (24)
It monitors the state of sending and receiving e-mails inside.
Therefore, the PE monitoring process (24) can communicate with the PE mail process (25). Note that P
The state of mail exchange between Es is performed by the PE-to-PE monitoring process (22) provided in PE ₀ .

Next, the process arranged on PE ₀ will be described.

The PE ₀ is for controlling communication between the PEs, and the PE ₀ monitoring process (22) and the PE
And an inter-mail process (23).

The PE-to-PE mail process (23) uses a certain P
From the mail process (25) in PE of E to P of another PE
This is for mediating the transmission of mail to the E-mail process (25).

The PE-to-PE monitoring process (22) is a process for monitoring how much the mail processes 23 and 25 have transferred mail during a certain period. Therefore, the PE-to-PE monitoring process (22) can communicate with the PE-to-PE mail process (23). In addition, in this embodiment, the PE-to-PE monitoring process (22) also controls the first activation.

The "network formation end judging means" referred to in the claims is realized by the inter-PE monitoring process (22), the intra-PE monitoring process (24) and the like operating in cooperation with each other. . The "network forming means" is mainly realized by the component generation process (20). The “parts structure table” corresponds to the parts table data stored in the database 21.

This is the end of the description of the outline of the present embodiment.

Next, the structure of the parts process (16) is shown in FIG.
1 will be used to explain in more detail.

As described above, the parts process (16)
Is composed of two parts stacking acceptance process (18) and part calculation process (17).

The component pile acceptance process (18) comprises a request amount time bucket management process (26) and a total required amount calculation process (27).

Request quantity time bucket management process (2
In 6), the requested amount time bucket is provided for each parent item. Then, when receiving the piled-up message sent from the parent item parts process (16), the request amount time bucket in charge of the parent item is used to determine the request amount from which parent on which request date. Manage and calculate deployable dates. Further, the requirement management process (31) is requested to update the requirement data. The "stacked message" is configured to include the parent part name, the requested amount, and the requested date.

The total required amount calculation process (27) receives the deployable date calculated by the required amount time bucket management process (26) and calculates the total required amount up to the deployable date for each time bucket. Hereinafter, in order to simplify the description, one time bucket will be described as one day.

The parts calculation process (17) includes a net requirement calculation process (28) and a lot summary process (29).
And a requirement amount development process (30).

The net requirement calculation process (28) uses the inventory requirement process (32) based on the total requirement information for each time bucket (here, 1 day) calculated by the total requirement calculation process (27). ) And the allocation process, and calculate the daily net amount. Then, based on the calculation result, the net requirement management process (33) is requested to update the net requirement data.

The lot summary process (29) receives the daily net requirement information from the net requirement calculation process (28) and summarizes the lot.

In the requirement development process (30), the lead time is subtracted from the request date for the lot, based on the net requirement amount collected in the lot, to set the start date.
Further, the requested amount for each child item is calculated by using the number of each child item as the request date for the child item on the day before the start date. Then, the requested amount and the requested date thus obtained are sent together with the name of the item (Note: this is the parent part name for the item child item) to the parts process of each child item.

As described above, the process of the component process (16) is composed of a plurality of processes, and the output of each process becomes the input of the process of the next calculation. In each process, processing always progresses from the past to the future. Here, if each process has a separate CP
When processed in U, pipeline parallel processing is possible, and high speed processing can be expected.

Next, the operation of the entire embodiment will be described with reference to FIGS. 10 and 12 to 17 in accordance with the progress order of MRP calculation.

The behavior of each process is shown in FIG.
It is shown in FIG. Figure 12 PE monitoring process (22)
13 shows the behavior of the PE monitoring process (24), FIG. 14 shows the behavior of the MPS reading process (15), and FIG. 15 shows the behavior of the component generation process (20).
6 shows the behavior of the parts pile acceptance process (18) as shown in FIG.
Is a flowchart showing the behavior of the component calculation process (17). These flowcharts show what kind of processing each process proceeds when receiving a specific message. The processes operate in cooperation with each other while exchanging messages with each other. Therefore, in the following description, these flow charts will be described with reference to each other as needed.

This MRP calculation can be roughly divided into two processes. The first is a process for creating a network similar to the component structure of an item between component processes. Hereinafter, this processing will be referred to as "network generation processing". The second is a process of performing component expansion calculation in each component calculation unit using the generated network. Since the requested amount information flows through this network and the calculation proceeds, this process will be referred to as "data flow expansion process" hereinafter.

The network generation process is a pre-process of the data flow expansion process. When there is almost no change in the type of product defined by the MPS, there is no change in the structure of the component structure of all items, so the network generation process may be performed once in advance. The MRP calculation every time is only the data flow expansion processing. Every time MRP calculation is performed, MP
When the types of products defined by S are different, the number of parent items of a certain item may be different depending on the case, and the structure of the component structure of all items may change every time. In such cases,
It is necessary to perform network generation processing before entering data flow expansion processing. The flow of processing below is for such a case. However, as described above, it is easy to separate the network generation processing.

Hereinafter, [I] network generation processing, [I
I] Details of the data flow expansion process will be described.

[I] Network Generation Process Upon receiving a message, each process is configured to read the content of the message and execute a process according to its type (FIG. 1).
2 steps 1202 and 1204, FIG. 13 step 1
302, 1304, steps 1402, 140 in FIG.
4, steps 1502 and 1504 in FIG. 15, steps 1602 and 1604 in FIG. 16, and step 170 in FIG.
2, 1704). Although not shown in the figure, each process executes steps according to the message and then executes steps 1202, 1302, 1402, 1502, 160.
The process returns to 2,1702, and stands by until the next message arrives.

Upon receiving the start message from the operator or another device, the PE-PE monitoring process (22) starts the network generation process. First, the PE monitoring process (22) sends an MPS create start message "create_mps_parts" to each MPS reading process (15) (step 1206 in FIG. 12). The message is sent to the other party through the PE-to-PE mail process (23) and PE-to-PE mail process (25).

Upon receiving the MPS create start message, the MPS read process (15) sends an MPS start message "create_mps_started (the number of products in MPS to be read)" to the PE monitoring process (22) (Fig. 14 steps 1406). After transmitting the MPS start message, the product name of MPS for each product is started to be read from the database 21 (step 1410). Then, the MPS reading process (1
5) sends a create message "create (mps, product name)" to the part generation process (20) for calculating the part development of the product (step 1412). The first argument of this message represents the originator of the message. In this case, since the transmission source is the MPS reading process (15), it is "mps". The second argument is the item name of the component process to be created. The MPS reading process (15) sends a create end message "create_mps_finished (product name)" to the PE monitoring process (22) at the time of sending this create message (step 1414). Repeat this for each product. In FIG. 14, step 14
MP that did not issue create message in 08
Whether or not S is present is checked, and while such MPS is present, the processes of steps 1408 to 1414 are repeated. If there is no MPS that has not issued the create message in step 1408, then the MPS reading process (15) returns to step 1402 and waits for the next message.

The component development process (20) of the component development calculation process (19) is the MPS read process (15).
When the create message ("create (parent item name, item name)") sent from is received, it is judged whether or not the part process of the item already exists (step 15).
06).

As a result of the judgment, the parts process (1
If 6) does not exist, steps 1508, 1
Proceed to 510 to create a parts process (16) for the item. As described above, the generated component process (16) includes the component calculation process (17) and the component pile reception process (18). First, the component pile reception process (18) is performed. Then, a parts calculation process (17) is generated. At this time, the requested component time bucket of the parent item in the message is held in the component pile acceptance process (18). Further, when the parts calculation process (17) is generated, the parts generation process (20) reads the parts table data from the database 21 via the database management system, so that the lead time, low level code, child item name, Information necessary for the component expansion calculation such as the number of members is obtained, and the information is held in the component calculation process (17). If the information obtained here includes a child item, the part generation process (2
0) sends a create message "create (own item name, child item name)" to the part creating process (20) that creates the part process (16) for the child item.
(Step 1512) If the parts process (16) for the item has already been generated in step 1506, the "add_parent (create message)" is added to the parts pile reception process (18) included in the parts process (16). A parent item addition message of "parent item name in") is sent (step 1514). Upon receiving this message, the parts stacking acceptance process (18) creates a requested quantity time bucket for the parent item in the message (step 1606 in FIG. 16).

Thus, the MPS reading process (1
The MPS create start message to 5) triggers the chain of create messages between the component generation processes (20). The parts process (16) generated by this chain can know what is its parent item and what is its child item. This creates a network between the component processes (16).

There are several methods for determining the end of the network generation processing started in this way. Here, four kinds of judgment methods (end judgment method ,,
-1, -2) will be described.

End Determination Method This end determination method is the simplest determination method. In the system of the present embodiment, the component generation process (20) receives the create message and immediately after the component process (1
6) was generated or the parent item name was added. This is a method of controlling the processing of the component generation process (20) on a level-by-level basis using a low level code like the conventional MRP expansion calculation. In this way, it is possible to know that the network between the component processes (16) has been completely created when the development of the lowest level in the level-by-level is completed.

However, in order to use this method, a synchronization mechanism process for managing the low level code is required.

Termination Judgment Method An item having no child item does not generate a new create message and is present at the end of the parts structure. Therefore,
The parts process (16) of the item located at the end is
Immediately after it is created, the parent item parts process (16)
Send a generation complete message to. The part process (16) of each item sends a generation completion message to the part process (16) of the parent item when the generation completion message is received from all the part processes (16) of its child items. Here, after the generation completion message has already been sent to the parent item part process (16), if a parent item addition message is received, the process immediately returns and the generation completion message is sent to the parent item part process (16). I shall. Thus, when the component processes (16) of all the products read by the MPS receive the generation completion message, it can be known that the networks between the component processes (16) have all been generated.

-End judgment method-1 It is confirmed by some means that all the messages that occur in a chain have disappeared, that is, that the create message has stopped, and with that, the network between the component processes (16) Is a method of determining that all are generated.

The short circuit method can be used as a method for confirming that all the messages generated in a chain have disappeared. When a variable for short circuit is attached to a create message and a create message is newly sent to a child item, a new variable is added to the new message and sent. Basically, the variables at the first level are made the same by making the variables the same in the item having no child item. Therefore, it can be determined that the message has disappeared at this point (when the variables at the very first level are equalized). However, in this create message chain, not only the variables in the create message that reach the item that has no child items are equalized, but also the create message that arrives at a part process that has already been created for an item that has multiple parent items. It is also necessary to identify the variables of.

Regarding the short circuit method,
For example, page 67 of "" Introduction to KL1 programming / Basic / Intermediate "Kazuo Taki ICOT TM-0897, 1990" is described.

-End judgment method-2 As in the end judgment method-1, a method is used to confirm that the create message is no longer generated and to detect that all networks between component processes have been generated. Is. However, end determination method-1
Unlike the above, as a method of confirming that the messages that occur in a chain have disappeared, a method of monitoring the state of the message where the message is mediated is used.

In the present embodiment, description will be made below on the premise of this determination method-2. However, there is no problem in using the other termination determination method described above. Judgment methods other than the end judgment method using the low-level code (here, the end judgment method, −
In 1 and -2), neither the network generation process nor the data flow expansion process need use any low-level code. Conventionally, it took a lot of time to calculate the low-level code of each item from the parent-child relationship of a huge number of items. The determination method that does not use the low-level code has a great advantage in that such processing is unnecessary.

The details of the termination judgment of the network generation processing when the above-mentioned termination judgment method-2 is adopted will be described below.

As described above, the PE-to-PE monitoring process (22) sends an MP to each MPS reading process (15).
After sending the SCreate start message, the MPS start message ("create_mps_started (M
The number of products in PS) ") for each MPS reading process (1
Start receiving from 5). Upon receiving the MPS start message, the PE monitoring process (22) counts the number of products in the MPS start message (step 1208 in FIG. 12). After this, the number of messages is counted (step 1210).

Before and after this, the MPS reading process (1
From 5), further create end message ("creat
e_mps_finished (product name) "). When the create end message is received, the PE monitoring process (22) counts the total number of messages (step 1212), and the create end message is equal to the total number of products. Whether it arrives or not, all M
It is determined whether the MPS start message is received from the PS reading process (15) (step 12).
14, 1216). If both conditions are satisfied, the create message is sent and the PE-to-PE monitoring process (22) is sent to all the parts development processes (19) of all the items located at the top of the parts configuration network. ) Judge. After that, only the create message generated by the component generation process (20) or the parent item addition message is generated except for the monitoring message. Therefore, PE monitoring process (22)
Requests the PE-to-PE mail process (23) to count the number of mails to be transferred in the future (step 1218). Also, an inter-PE monitoring message "check_outside" is transmitted to each PE monitoring process (24) (step 1220).

If neither of the conditions is satisfied, or if only one of the conditions is satisfied, the process directly returns to step 1202 to enter the standby state.

Upon receiving this PE-PE monitoring message, each PE monitoring process (24) instructs the PE mail process (25) to count the number of mails to be transferred in the future (step 1306 in FIG. 13). At the same time, toward the parts generation process (20), "check_inside"
The PE monitoring message is sent via the PE mail process (step 1308). The component generation process (20) that has received the PE monitoring message immediately returns the PE monitoring message to the PE monitoring process (24) via the PE mail process (FIG. 1).
5 steps 1516). PE monitoring process (24)
Upon receiving the PE monitoring message sent back, instructs the PE mail process (25) to end counting and obtains the count number (step 131 in FIG. 13).
0). Then, during the period from the start to the end of counting the number of messages (specifically, from the time when step 1306 was executed last time to the time when step 1310 is executed), P
Based on this count number, it is determined whether the E-mail process (25) has transferred a message other than the PE monitoring message (step 1312).

As a result of the judgment, when the count number is 2 (that is, when the PE internal mail process (25) has not transferred any message other than the PE internal monitoring message), the PE internal monitoring process (24 ) Sends an inter-PE monitoring message "check_outside" to the inter-PE monitoring process (22) (step 131).
4). On the other hand, when the count number is 3 or more (that is, when the PE mail process (25) is transferring another message), the PE monitoring process (24)
PE to count the number of emails to be forwarded in the future
The internal mail process (25) is instructed again (step 1306). In addition, PE for the part generation process (20)
The internal monitoring message ("check_inside") is transmitted again (step 1308).

Step 1308 or step 131
After 4, the process returns to step 1302 to enter the standby state.

As described above, in the case where the PE monitoring process (24) has to send the PE monitoring message again (the route corresponding to step 1312 →→ step 1306 →→ step 1308 →→ ...), For example, the component generation process (20) receives the create message before receiving the PE monitoring message, and the generated component process (16) is a child item for which another component development calculation process (19) is in charge. If you have. In such a case, the component generation process (2
0) generates a new create message, and uses this to develop the component development calculation process (1
After sending to the component generation process (20) in 9) via the in-PE mail process (see steps 1506, 1508, 1510 and 1512 in FIG. 15), the PE monitoring message is sent to the PE monitoring process (24). Reply via internal mail process (see step 1516)
Will be. According to this order, the in-PE mail process (25) also transfers the in-PE monitoring message after the create message transfer process. Therefore, when the PE monitoring process (24) asks the number of transferred messages, the PE mail process (2)
In 5), a number as many as the transferred create message will be returned.

According to such a method, P after the PE monitoring process (24) receives the PE monitoring message.
If no mail has been received from the E-to-E monitoring process (22) (step 1312 to step 1314)
If the PE monitoring process (24)
At the time of returning the inter-monitoring message to the PE-to-PE monitoring process (22), it can be seen that no create message or parent item addition message has occurred in the PE.

Upon receiving the PE monitoring message from each PE monitoring process (24), the PE monitoring process (22) counts the PE monitoring messages (step 1222 in FIG. 12). Then, the count value (that is, the number of PE monitoring messages received) is PE
It is determined whether or not the number of internal monitoring processes (24) has reached the same number, that is, whether or not PE monitoring messages have been received from all PE internal monitoring processes (24) (step 1224). If the message has not been received from all PE monitoring processes (24), the process returns to step 1202 and enters a standby state. Meanwhile, all PE
When the PE monitoring message is received from the internal monitoring process (24), the PE PE mail process (23)
Is instructed to end counting, and the counted number is obtained (step 1226 in FIG. 12). Then, based on this count number, it is determined whether or not the PE-to-PE mail process (23) has transferred a message other than the PE-to-PE monitoring message from the start to the end (step 1228). When the number of counts is the same as the number of PE monitoring processes (24) (that is, when no transfer other than PE monitoring messages is performed).
Means that, since the PE-to-PE monitoring message was transmitted in step 1220 last time, there is no message extending between PEs, and no create message or the like has occurred in each PE. In other words, it is possible to determine that all the messages have not occurred and a network between component processes (16) has been created. So after this,
Proceeding to step 1230, an MPS read start message is sent to each MPS read process (15).
Further, the end message is transmitted to each PE monitoring process (24) (step 1232), and the end message is transmitted to the component generation process (17) in each component development process (19) (step 1234). Then, the process ends.

On the other hand, in step 1228, when the count number is larger than the number of PE monitoring processes (24) (that is, when the transfer is being performed), the process proceeds to step 1218, and the PE-to-PE mail process (23). ), And instruct again to count the number of mails to be forwarded. Further, the inter-PE monitoring message is transmitted again to each PE internal monitoring process (24) (step 1220). After this, mail process between PEs (2
The same processing is repeated until the count number according to 3) becomes 2.

This is the end of the description of the network generation processing.

[II] Data Flow Expansion Processing When the PE monitoring process (22) determines that the network generation processing has been completed (that is, when “NO” in step 1228 of FIG. 12), the data flow expansion processing is performed. To start.

First, the PE-to-PE monitoring process (22) sends an MPS read start message "read_mps" to each MPS read process (15) (step 1230). Furthermore, monitoring process in each PE (24)
And an end message is sent to the component generation process (20) (steps 1232 and 1234). After that, it ends itself.

The MPS reading process (15)
When the S read start message is received, it is determined whether there is an MPS for which the requested amount has not been read yet (step 1416). The determination in step 1416 is a process provided to repeat the processes in steps 1418 to 1422 for the number of products to be produced. Therefore, when the processing is performed for the first time, the result of the determination is always "Yes".

As a result of the judgment, the request amount is not read M
If PS exists, the M
The reading of PS is started (step 1418). Then, a pile-up message including the requested amount of the relevant component defined in the MPS is sent to the component pile-up receiving process (18) of the read product component process (16) (step 1420).

The pile-up message is a message for transmitting the demanded quantity of a certain item for each predetermined period, and the sender, the demanded quantity, and the demanded day of the piled-up message are used as arguments. The specific form is "set (source, requested amount, requested date)". In step 1420, since the sender is the MPS, the heap message sent in this case is "set (mps, requested amount, requested date)". As the pile-up message, the contents of the entire planning period may be sent in one message. Alternatively, the entire planned period may be divided into predetermined periods, and may be sent in plural times for each predetermined period. In this embodiment, the pile-up message is sent minutely by day, with the minimum unit of the plan being one day. The order of sending the pile-up message is from the past side to the future with respect to the request date. In the present specification, the terms “past” and “past side” simply mean directions on the time axis, and have a general meaning (“when the past has already passed on the basis of the present”). )) Is not shown. The first argument of this heap message represents the sender of this message. In this case, since it is the request amount from MPS, "
mps ".

After the step 1420, the MPS reading process (15) calls "set_finished (mps)" toward the parts pile-up acceptance process (18) of the product when all the MPSs of a product have been read. A pile-up completion message is sent (step 1422).
After this, the process returns to step 1416.

If "NO" in step 1416, that is, if the requested amounts have been read for all MPSs, the MPS reading unit (15) ends.

The request amount time bucket management process (26) of the component stacking reception process (18) that has received the above-mentioned stacking message (see step 1420 in FIG. 14).
Stores the required amount included in the message in the required amount time bucket of the parent item name that is the sender of the message, and then updates the required amount data in the database 21 (step 1608). The request amount is stored in the request time bucket by dividing the request amount contained in the piled-up messages sent up to that time into each day. However, it does not need to be stored separately for each parent item. The update of the required amount data is a process of rewriting by adding the required amount included in the piled-up message sent at that time to the required amount already written for each day. This processing is performed by accessing the required quantity management process 31 in the database 21 via the database management system (in this case).

As shown in FIG. 11, the request amount time bucket management process (26) confirms, for each parent item, the request date that includes the latest pile-up message that has arrived from the parent item. Then, the piled-up dates confirmed for each parent item are compared with each other, and the earliest (closest future) piled-up date among these is set as the deployable date (step 1610). As is clear from FIG. 1, MP
As for the item set in S, the MPS read process (15) is the only sender of the heap message. When there is only one parent item in this way, the pile-up date included in the latest pile-up message becomes the deployable date without making such a comparison.

From the present to this development possible date, the required quantity for all parent items is known. Therefore, the required amount of the component can be determined at least for the period from the present to the deployable date. Therefore, the total requirement calculation process (27) uses the request amount for each day as a requirement message for the period from the deployable date until then to the new deployable date as the component calculation process (17).
(Step 1612). The request amount for each day can be obtained by referring to the request amount time bucket. Note that the transmission of the required amount message is a communication within the component process (19) and does not pass through the PE internal mail process (25).

Request Quantity Time Bucket Management Process 26
Receives the pile-up completion message (see step 1422) of "set_finished (parent item name)" from all of the parents (MPS reading unit 15 in this case), the latest requested date of the item is set to the end of the planning period. As the day, the deployable date is calculated (step 1614). In response to the deployable date, the total requirement calculation process (27) transmits a requirement message (step 1616).

Thereafter, it is judged whether or not the pile-up completion message received by the requested quantity time bucket management process (26) is the last pile-up completion message from all the parent items (step 1618).

As a result of the judgment, when there is a parent item which has not yet transmitted the pile-up completion message, the process returns to step 1602 to enter the standby state. On the other hand, if it is the last pile-up completion message, step 162.
Go to 0.

In step 1620, the request amount time bucket management process (26) sends an end message to the total required amount calculation process (27) and ends itself.
Further, when the total requirement calculation process (27) receives the end message, the total requirement calculation process (27) transfers the message to the component calculation process (17) and ends itself (step 162).
0).

In this case, the possible development days are calculated on a daily basis, but it is also possible to make this calculation for each certain period.
For example, the deployable dates may be set only in units of three days, and the days of every three days may be set as deployable candidate days. In this case, for each parent item, the request date sent in the latest piled-up message from the parent item is confirmed. Then, of the confirmed request dates, the closest future request date may be obtained and the immediately preceding deployable candidate date may be set as the deployable date. In particular, if you set the deployable candidate date as the last day of the planning period, the deployable date is set to the last day of the planning period when the parts deployment calculation for all parent items of the item is completely completed. The parts development calculation of will start.

The component calculation process (17) receives the data of the total required amount from the component pile reception process (18) as a required amount message for each day in order from the past side to the future. Progress from day to day from the past to the future (steps 1706, 170)
8, 1710). However, since the total requirement calculation has been completed, the calculation is performed from the net requirement calculation. In particular, when developing the required amount in the required amount developing process (30), a pile-up message of "set (own item name, requested date, requested amount)" is directed to the parts pile-up acceptance process (18) for the child item. Is sent (step 1712). in this case,
The parts process (16) corresponds to the parent of the child item.

Then, the parts stacking acceptance process (1
When the required amount end message is sent from 8), each process constituting the component calculation process (17) sequentially transfers the end message between them and ends each process. (Step 1714 to Step 17
20). Of these, especially the required quantity development process (30)
Sends a pile-up completion message "set_finished (own item name)" to the child pile-up component acceptance process (18) (step 1718), and then terminates its own processing (step 1720).

When the all-parts process is completed in this way, the MRP calculation is completed.

As described above, according to the present invention, the required material amount calculation can be executed in parallel, so that the required time can be dramatically reduced.

The component generation process (2
0) was also to generate the component processes (16) and to connect the component processes. However, a large number of component processes (16) may be prepared in advance and only the connection relationship between them may be changed. The component generation process (20) in the case where only the connection relationship of the component process (16) is changed in this way corresponds to the "network forming means" in the claims.

If it is not necessary to consider the change of the network, a fixed network may be built in from the beginning.

[0149]

EFFECTS OF THE INVENTION The parts development calculation for each item is carried out in parallel by the plurality of parts calculation units, and the parts development calculation for each item is carried out according to the progress of the calculation of the parent item. The calculation result equivalent to the sequential MRP calculation is
It can be obtained in a short time.

If a method that does not use a low-level code is used in the generation of a network between the component calculation units, the MRP calculation of the present invention can be performed without using a low-level code at all. Become. As a result, it is possible to eliminate the low-level code setting processing which has conventionally required a great deal of time.

[Brief description of drawings]

FIG. 1 is an overall block diagram.

FIG. 2 is an exploded view of parts and an explanatory diagram of a low-level code.

FIG. 3 is an explanatory diagram of a component configuration.

FIG. 4 is a diagram showing a concept of conventional calculation (prior art).

FIG. 5 is a diagram showing a concept (invention) of component deployment date parallel.

FIG. 6 is a diagram showing an outline of a loosely coupled file non-shared parallel computer.

FIG. 7 is a diagram showing an outline of another parallel / distributed computer environment.

FIG. 8 is a diagram showing a data storage method.

FIG. 9 is a diagram showing a post office system.

FIG. 10 is a diagram showing a process model of paralleling the component deployment dates.

FIG. 11 is a diagram showing a parts process (16).

FIG. 12 is a flowchart of a PE-PE monitoring process (22).

FIG. 13 is a flow chart of an in-PE monitoring process (24).

FIG. 14 is a flowchart of the MPS read process (15).

FIG. 15 is a flowchart of a component generation process (20).

FIG. 16 is a flowchart of a parts pile acceptance process (18).

FIG. 17 is a flowchart of a parts calculation process (17).

[Explanation of symbols]

1-3 ... MPS reading section 4-10 ... parts calculation section 11 ... PE-to-PE mail process 12 to 14 ... PE internal mail process 15 ... MPS reading process 16 ... parts process 17 ... parts calculation process 18 ... parts pile acceptance process 19 ... Component development calculation process 20 ... Component generation process 21 ... Database and database management system 22 ... PE PE monitoring process 23 ... PE PE mail process 24 ... PE PE monitoring process 25 ... PE PE mail process

 ─────────────────────────────────────────────────── ─── Continuation of the front page (72) Inventor Mitsuharu Hayakawa 12 Hitachi, Ltd. Information Systems Division, 890 Kashimada, Sachi-ku, Kawasaki-shi, Kanagawa

Claims (16)

[Claims] 1. At least one MPS reading unit for reading a separately-specified production plan of a product, and a parent-child relationship (hereinafter referred to as a "component structure") provided for each component of the product and for each component. And a component calculation unit for performing a component expansion calculation, which is connected to each other with the same structure as the above-mentioned), and the component calculation unit located at the highest position in the component configuration respectively reads the MPS corresponding to itself. Depending on the read status of the production plan by the department, by proceeding with its own parts development calculation based on the read production plan,
In addition, each of the above-mentioned component calculation units not located at the highest level in the component structure, by performing its own component expansion calculation according to the progress status of the component expansion calculation of the component calculation unit corresponding to its own parent, A material requirement calculation device characterized in that the expansion calculations are processed in parallel with each other. 2. At least one MPS reading unit for reading a separately determined production plan of a product, a component calculation unit for performing a component expansion calculation, and each of the component calculation units, each of which is a component of the product. And a network forming means for forming a network by connecting each other with a structure similar to the parent-child relationship between parts (hereinafter referred to as “part structure”). Each of the higher-order parts calculation units advances its own parts development calculation based on the read production plan in accordance with the read status of the production plan by the MPS reading unit corresponding to itself.
In addition, each component calculation unit that is not located at the top of the above-mentioned component structure progresses its own component development calculation according to the progress status of the component development calculation of the component calculation unit corresponding to its parent. A material requirement calculation device characterized in that calculations are processed in parallel with each other. 3. A storage means for storing a parts configuration table describing the parts configuration, wherein the network forming means refers to the parts configuration table when forming the network to establish a parent-child relationship between the parts calculation units. The material requirement calculation device according to claim 2, characterized in that it is confirmed. 4. The material requirement calculation apparatus according to claim 2, further comprising a network formation end determination means for determining whether or not the network formation is completed. 5. The network forming means uses a low-level code for level-by-level connection between the component calculation units.
5. The level is to be advanced, and the network formation end judging means judges that the network formation is completed when the connection is completed to the lowest level. Material requirement calculator. 6. The component calculation unit, when connected to a component calculation unit corresponding to a child, sends a message to a component development unit corresponding to the child, and the network formation end determination means is the message. The material requirement calculation device according to claim 4, wherein the generation condition is monitored and it is determined that the network formation is completed when the message is not generated. 7. When forming the network, the component calculating unit located at the upper end of the component structure sends a message to the component calculating unit corresponding to the parent when connected to the component calculating unit corresponding to its parent. The component calculation unit that is not located at the end of the component configuration sends a message to the component calculation unit corresponding to its parent when it receives the message from all the component calculation units corresponding to its own children. The network formation end determination means determines that the network formation is completed when the message reaches all the component calculation units located at the highest level in the component configuration. The material requirement calculation device according to claim 4. 8. An at least one MPS reading unit for reading a separately determined production plan of a product and a parts calculation unit for performing a parts development calculation are generated for each of the parts constituting the product, and each part is further formed. And a component calculation unit generating means that forms a network of the component calculation units by connecting the component calculation units to each other with a structure similar to a parent-child relationship (hereinafter referred to as “component configuration”). Each of the uppermost uppermost component calculation units advances its own component development calculation based on the read production plan in accordance with the read status of the production plan by the MPS reading unit corresponding to itself.
In addition, each component calculation unit that is not located at the top of the above-mentioned component structure progresses its own component development calculation according to the progress status of the component development calculation of the component calculation unit corresponding to its parent. A material requirement calculation device characterized in that calculations are processed in parallel with each other. 9. A storage means for storing a parts configuration table in which the parts configuration is described, wherein the parts calculation part generation means refers to the parts configuration table when forming the network so that the parent and child between the part calculation parts. 9. The material requirement calculation device according to claim 8, wherein the relationship is confirmed. 10. The material requirement calculation apparatus according to claim 8, further comprising a network formation end determination means for determining whether or not the network formation is completed. 11. The component calculation unit generation means advances the connection between the component calculation units on a level-by-level basis using a low-level code, and the network formation end determination means determines that the connection is The material requirement calculation device according to claim 10, wherein it is determined that the network formation is completed when the process reaches the lowest level. 12. The component calculation unit sends a message to the component calculation unit corresponding to the child when connected to the component calculation unit corresponding to the child, and the network formation end determination means, The material requirement calculation device according to claim 10, wherein the generation status of the message is monitored, and when the generation of the message is stopped, it is determined that the network formation is completed. 13. When forming the network, the component calculation unit located at the upper end of the component structure sends a message to the component calculation unit corresponding to the parent when connected to the component calculation unit corresponding to its parent. The component calculation unit that is not located at the end of the component configuration sends a message to the component calculation unit corresponding to its parent when it receives the message from all the component calculation units corresponding to its own children. The network formation end determination means determines that the network formation is completed when the message reaches all the component calculation units located at the highest level in the component configuration. The material requirement calculation device according to claim 10. 14. The component calculation unit starts the component expansion calculation after the network formation end determination unit determines that the network formation is completed. Material requirement calculator. 15. The component calculation section sequentially starts the component development calculation during a period in which the result of the component development calculation is delivered from all of the component calculation sections corresponding to its parent, and The material requirement calculation device according to claim 1, wherein the result of the component development calculation is sequentially sent to a component calculation unit corresponding to its own child. 16. A component calculation unit for performing a component development calculation is provided for each component constituting a product, and the component calculation unit has the same structure as the parent-child relationship between the components (hereinafter referred to as "component configuration"). By connecting each other with each other, a network between the component calculation units is formed, and thereafter, each of the above-mentioned component calculation units determines its own component according to the progress of the component development calculation of the component calculation unit corresponding to its parent. A material requirement calculation method, characterized in that, by advancing the expansion calculation, the parts expansion calculation is processed in parallel with each other.