A Survey of Factory Control Algorithms which Can be ... - CiteSeerX

to appear in theJournal of Manufacturing Systems 1998 SME

A Survey of Factory Control Algorithms which Can be Implemented in a Multi-Agent Heterarchy: Dispatching, Scheduling, and Pull ALBERT D. BAKER Elec & Comp Eng and Comp Sci Dept University of Cincinnati Cincinnati, Ohio 45221

This paper describes various multi-agent architectures including the heterarchical architecture. It reviews the claimed advantages for multi-agent heterarchies and describes the types of factories which could use this architecture. It surveys the three common types of factory control algorithms: dispatching algorithms, scheduling algorithms, and pull algorithms. It then asks the question: which of these algorithms can be implemented in a multi-agent heterarchy? This paper describes how all common factory control algorithms used in industry can be implemented in an multi-agent heterarchy. It discusses how many of the algorithms which are popular in current research can be implemented in a multi-agent heterarchy, while others will require further research. KEYWORDS: Systems and Architectures, Heterarchy, Scheduling and Control, ERP, Discrete Optimization, Heuristics, Distributed Artificial Intelligence, Agent Technology, Multi-Agent Systems

1.

INTRODUCTION

This paper surveys the different types of factory control algorithms: dispatching, scheduling, and pull. It addresses which of these algorithms can be put in a multi-agent heterarchy. It describes why the ability to implement these algorithms in a multi-agent heterarchy is desirable. As a survey, the purpose of this paper is to provide a brief tutorial on these issues, to establish what we currently know, and to identify where there are research opportunities. This paper can also be used as a guide for implementors to know what has been done in the past and where information on past implementations can be found. This introductory section provides an overview to agent technology and multi-agent heterarchies. It provides a definition of factory control and discusses the importance of dispatching, scheduling, and pull algorithms to factory control. The introduction concludes with an overview to the rest of this survey.

1

Baker, Factory Control in Multi-Agent Heterarcies

2

May 8, 1998

CONTENTS

1.

INTRODUCTION 1.1. Introduction to Agents 1.2. Multi-Agent Architectures 1.3. Factory Control and Factory Control Algorithms 1.4. Survey Organization 2. DISPATCHING ALGORITHMS 2.1. Review of Dispatching Algorithms 2.2. Dispatching in a Multi-Agent Heterarchy 3. SCHEDULING ALGORITHMS 3.1. Optimal Scheduling 3.1.1. Simple Optimal Scheduling 3.1.2. Combinatorics 3.1.3. Mathematical Programming

1.1.

3.2. 3.3.

Nearly Optimal Scheduling Towards Optimal Scheduling 3.3.1. Simulated Annealing 3.3.2. Genetic Algorithms 3.3.3. Neuro-Scheduling 3.4. Heuristic Scheduling Methods 3.4.1. Forward/Backward Scheduling 3.4.2. Deterministic Simulation 3.4.3. Intelligent Scheduling 4. PULL ALGORITHMS 4.1. Review of Pull Algorithms 4.2. Pulling in a Multi-Agent Heterarchy 5. SUMMARY 6. REFERENCES

Introduction to Agents

The idea of agent-based manufacturing has received a great deal of recent attention. Much of this attention was caught in 1992 when the proposed 10 year, 1 billion dollar, Japanese Intelligent Manufacturing Systems program decided to make “holonic” manufacturing one of its 6 initial test case studies [1]. This interest was galvanized in the United States when in 1993 the National Center for Manufacturing Science decided to initiate a number of programs in agent-based manufacturing. Now, leading United States manufacturers and government agencies are claiming that agent-based manufacturing is the future for U.S. manufacturing. Some say [2] that agent technology is the foundational technology for implementing the agile manufacturing vision [3-5]. There has also been a great deal of recent interest in agent technology in general. There have been numerous articles about agent technology in the professional society magazines such as IEEE Spectrum [6] and Communications of the ACM [7], in the popular press such as the Wall Street Journal [8-11], Time Magazine [12], and U.S. News and World Report [13], and in most of the major Internet computing magazines [14-16]. Most of this interest is correlated with recent interest in Internet computing and the potential agents have for enabling electronic commerce and information dissemination and retrieval over the Internet. Agent technology builds on the object-oriented paradigm [17] (see Table 1). An agent is basically a self-directed software object. It is an object with its own value system and a means to communicate with other such objects. Unlike most software which must be specifically called upon to act, agent software continuously acts on its own initiative. The agent system is designed so that when an agent is meeting its goals, it is really meeting the goals it has been programmed to meet by its designer. A system of such agents, called a multi-agent system, consists of a group of


Trend

3

May 8, 1998

Information

Flow

binary data types (octal, hexadecimal, ...)

go to

basic data types (real, integer, character, ...)

for, while, repeat, subroutines...

structured data types (strings, functions arrays, records, ...) abstract data types (queues, sets, lists, trees, ...)

operations

objects (windows, palettes, tool bars, ...)

methods

agents (radar stations, military equipment, factory machinery, ...)

messages

Table 1: The Progression to Agent Technology identical or complimentary agents which act together. There are a number of possible architectures which can be used to build multi-agent systems.

1.2.

Multi-Agent Architectures

Three types of architectures which are commonly studied in the multi-agent systems research community are functional, blackboard, and heterarchical architectures. Hierarchical architectures have also received a great deal of attention in the manufacturing systems research community. These different multi-agent architectures are described here with a specific focus on the heterarchical architecture. In a functional architecture each agent represents a functional capability. Usually there is only one agent per function. Functions communicate directly with each other, usually through main memory or as if through main memory over a network. Sometimes functions communicate on a peer-to-peer basis, but usually in a master/slave relationship where one function calls another function and expects specific results. Most commercial software is functionally decomposed according to structured analysis and design techniques [18]. Such software can be agent enabled by making each function an agent. Example functional multi-agent architectures which have been developed for manufacturing problems are provided in the references [19-22]. In a blackboard architecture, each agent has expertise in a certain area and the agents share their expertise by posting partial solutions to a problem on a central blackboard [23, 24]. The blackboard provides a persistent channel of communication, where past communications persist on


4

May 8, 1998

the blackboard until modified by an agent. Example blackboard based multi-agent applications in manufacturing have included Maley’s CADENCE system [25-27], the OPIS system by Smith [28], and Boeing’s blackboard-based shop-floor control system [29]. In a hierarchical architecture, there are multiple levels of master/slave agent relationships where agents at one level of the hierarchy are slaves to a master agent at the next highest level of the hierarchy. In the Holonic manufacturing community, a hierarchy of agents (holons) is called a holarchy [30]. Early research in agent-based dispatching [31-33] and agent-based scheduling [3441] used hierarchical architectures as described later in this paper. In a heterarchical architecture [42-45] agents communicate as peers, there are no fixed master/slave relationships, each type of agent is usually replicated many times, and global information is eliminated. Heterarchical multi-agent architectures are the topic of this paper. Functional, blackboard, and hierarchical architectures differ from the heterarchical architecture in a number of important regards. Most functional architectures are not heterarchical because each functional agent is usually only replicated once, and functions often have fixed master relationships to slave functions. Blackboard architectures can not be considered heterarchical because of the use of a blackboard for global information storage. Though a heterarchical architecture may use global broadcast of information over a network, this information does not persist globally. Also, each agent in a blackboard architecture usually has a specific non-replicated function. Hierarchies differ from heterarchies in the use of fixed master/slave relationships. Also, some prominent hierarchical architectures [46] use global information repositories which violate the heterarchical goal of eliminating global information. Outside the manufacturing domain, a very active research field is to model as multi-agent heterarchies biological systems such as termite hills [47], ant colonies [48, 49], wasp nests [50], bird flocks [51, 52], fish schools [51, 52], and wolf packs [53]. Some inherent capabilities of these agent systems include self-configuration, scalability, fault-tolerance, and emergent behavior. That is, when termites are placed together, they self-configure to build termite hills. They scale up and down because if one adds more termites, they will join the hill-building process. These systems are fault-tolerant, if half the termites in the colony are destroyed, the remaining termites will continue building termite hills. These systems also exhibit what is called emergent behavior. That is, in simulations of termite colonies, it has been shown that individual termites can be identically programmed to follow a local behavior where when these termites are placed together they emergently perform a global result, a termite hill [47]. The complex behavior of building a termite hill emerges from the combination of termites into this heterarchical architecture, thus the term “emergent behavior.” Duffie claims other advantages of heterarchical architectures include reduced complexity, increased flexibility, and reduced costs [54]. The Holonic Manufacturing community views agent technology as allowing humans and manufacturing machinery to work together as colleagues. By


5

May 8, 1998

putting agents on machines they can be made to work with people on a human level. Thus augmenting the performance of both man and machine and helping humans focus and leverage their talents on the aspects of manufacturing that they do best [55]. This is consistent with current trends in industry towards local empowerment and reduced levels of management [56]. The heterarchical architecture also enables massive parallelism. If agents are widely dispersed across a network of computers, then when these agents work together to solve a problem, they are bringing together these widely distributed computing resources to solve the problem. Finally, a heterarchical agent architecture maps best onto the Internet structure because the Internet is heterarchical. These features of multi-agent heterarchies are especially attractive to those looking to create agile manufacturing systems. Fully operational computer-integrated-manufacturing systems may some day be installed by merely plugging together manufacturing resources which are each managed and controlled by their own individual agents. The functionality of this agent architecture could supersede and integrate the functionality currently in the islands of automation in ERP, DCS, MES, SFC, PLC, and CNC software. These agents can be in a single factory or spread across factories over the Internet to form a single self-configured virtual enterprise. Though the advantages of emergent behavior, local empowerment, and machine operation on a human level may be claimed for functional, blackboard or hierarchical multi-agent systems; heterarchical agent architectures show a greater promise in terms of self-configuration, scalability, fault-tolerance, reduced complexity, increased flexibility, reduced costs, massive parallelism, Internet compatibility, and virtual enterprise formation. Though the potential advantages of reduced costs, reduced complexity, and better scheduling would benefit any manufacturer, the heterarchical agent approach could provide the greatest benefits to manufacturers who often need to change the configuration of their factories by adding or removing machines, workers, or product lines; to groups of manufacturers who at different times wish to form different virtual enterprises consisting of different subsets of their resources; to manufacturers who can not predict the possible manufacturing scenarios in which they will need to manufacture in the future; to manufacturers whose operations are significantly growing or shrinking; to manufacturers who wish to distribute their operations over wide area networks or who wish to participate in Internet-based electronic commerce; and to manufacturers who wish to empower their workers and provide them with the information and decision aides they need to make and implement distributed intelligent decisions.

1.3. Factory Control and Factory Control Algorithms If multi-agent heterarchies provide such a promising basis for future manufacturing systems, this naturally leads us to the question of whether we can control a factory using such an architecture.


6

May 8, 1998

More specifically, what of the currently used factory control algorithms can be implemented in a multi-agent heterarchy? Also, what additional research is required to implement other commonly used algorithms in such an architecture? Additionally, we can ask the inverted question, are there any new factory control algorithms which the heterarchical agent architecture suggests? We define factory control as the actuation of a manufacturing plant to make products, using the present and past observed state of the manufacturing plant, and demand from the market. The ISO Generic Activity Model of a manufacturing system places control in the center of manufacturing system activity (see Figure 1). Factory control is the central nervous system of a factory, it coordinates the use of the factory’s resources, giving the system its purpose and meaning. Figure 2 shows the factory control problem in a form which is more recognizable from a classic controls perspective. This is what we are trying to perform in a multi-agent heterarchy. The factory control problem has been split into many different levels in the past [46]. For our purposes we will just consider two levels: low- and high-level control. At the low-level the individual manufacturing resources must be controlled to deliver the unitprocesses [58] expected by the higher-level control functions. At this level, time-based control techniques such as PID tuning, root locus, and Bode analysis are used to design and implement appropriate control algorithms on digital or analog devices. Low-level unit-process control in machining often means following an APT or NC program. Unit process control in the chemical industries often means tracking certain temperature, pressure, or flow set-points. In Robotics, unit-process control means to perform motion in certain prescribed procedures. These control algorithms are naturally associated with individual manufacturing resources. In a multi-agent

COMMANDS

INFO IN

INFO TRANSFORMATION

INFO STORAGE

INFO VERIFY

INFO OUT

CONTROL

MATERIAL

MATERIAL

MATERIAL, TEST

TRANSFORMATION

STORAGE

MEASURING, INSPECTION MATERIAL OUT

MATERIAL IN

SCRAP RESOURCES

Figure 1: The ISO Generic Activity Model of a Manufacturing System [57]


market information

7

market information

Manufacturing Controller

actuator signals

sensory information

raw materials

May 8, 1998

Manufacturing Plant

finished goods

Controlled Manufacturing System

Figure 2: Control Theoretic View of the Factory Control Problem heterarchy where each agent represents an individual resource, there is no issue of having each agent individually implement these low-level control algorithms for each of the resources they represent. That is, implementing these low-level control algorithms in a multi-agent heterarchy is generally not an issue and thus does not warrant further discussion in this paper. At an even lower-level, some manufacturers and research laboratories are considering using agents to configure individual machines [59, 60]. So for example, agents can be used to make a robot a modular piece of equipment which is self-configuring so the robot manufacturer’s technicians require limited effort to configure the robot for a given application. Agents offer exciting possibilities for reducing the engineering content in designing and building individual pieces of manufacturing equipment. But, this research is not discussed further in this survey because resolving these lower-level issues is not essential to our quest of developing self-configuring heterarchically structured factories. The remaining control issues are at the high-level. High-level factory control is concerned with coordinating the manufacturing resources to make desired products. Algorithms at this level are used to decide what to produce, how much to produce, when production is to be finished, what expendable resources to use, how and when to use them or make them available, when to release jobs into the factory, which jobs to release, job routing, and job/operation sequencing. This control is not necessarily easily implemented in a multi-agent heterarchy. Thus, this paper focuses on surveying the issues of using multi-agent heterarchies for high-level factory control. At this high level of factory control, three basic types of control algorithms can be employed: dispatching algorithms, scheduling algorithms, and pull algorithms. These algorithm types differ


8

May 8, 1998

in the performance they offer for different forms of manufacturing [61]. In order to achieve the potential of heterarchically controlled factories as outlined in the last section, we will need to execute these algorithms in a multi-agent heterarchy. If every algorithm used for factory control could be put in a multi-agent heterarchy then this would mean that all current factory control systems can be implemented in a multi-agent heterarchy. As we will see, this is not the case. But, this is the case in many situations and this new heterarchical agent paradigm opens up many new avenues for future research.

1.4.

Survey Organization

The rest of this survey is organized around each of these three basic types of factory control algorithms. For each type of algorithm, the algorithm is defined, its advantages and limitations are highlighted, and what is known about how to implement the algorithm in a multi-agent heterarchy is discussed. In this discussion, we look for how well the given type of algorithm can be implemented in a multi-agent heterarchy. Some of the qualitative features we are looking for in this distribution are as follows. • Balanced Distribution: We would prefer the factory control algorithms to be distributed across all agents in the system and that the amount of computation required at each agent be about the same as the amount of computation at other agents. • Physical Correspondence: We would prefer that agents correspond to physical entities in the system such as machines, jobs, or people. Thus, as the number of entities is increased the number of agents increases proportionately. Physical correspondence is also consistent with what some consider an essential advantage of agent technology— local empowerment and the ability to be a peer to human operators. •

Scalable Growth: We prefer algorithms which do not bring the system to a halt as more agents are added into the system. Preferably, as each agent is added, the amount of new computation required is equivalent to the amount of computational capability added with the agent. This is an ideal situation and in reality the best we can usually hope for is that the algorithms grow linearly or polynomially with the number of agents in the system.

This survey concludes by summarizing which of these factory control algorithms can be implemented in a multi-agent heterarchy and where there are future research opportunities.

2.

DISPATCHING ALGORITHMS

A dispatching algorithm decides how to use a factory resource only upon availability of the resource, other resources, or a job. These algorithms are more appropriate for factories where there is a wide variety of products or where advance planning is difficult. They are also commonly called “scheduling” algorithms,


9

May 8, 1998

though this terminology is unnecessarily confusing. That is, it is important to distinguish between dispatching and advance scheduling because the performance of systems controlled by dispatching rules can be substantially different from systems controlled by advance schedulers. Furthermore, factories which are best suited for dispatching control are substantially different from those which are best suited for scheduling control.

2.1.

Review of Dispatching Algorithms

Most dispatching rule research has been with dispatching which job a resource will work on next. This sequencing decision can be made based on a job’s due-date, its customer priority, similar setups, the shortest processing time remaining, or any of hundreds of other possible rules or heuristics. Wisner [62] and Melnyk [63] provide reviews of the most common sequencing rules in industry. Panwalker and Iskander [64], and Blackstone et. al. [65] provide often quoted survey articles about known research results with sequencing rules. Wisner also provides a summary of the most commonly used rules to determine when to release a job into a factory. These rules include releasing jobs as they arrive, releasing jobs when the total work in the shop or at some resource reduces to some threshold, and releasing jobs as backscheduled from job due-dates. Once the decision to release has been made, which job to release may not be obvious. Which job to release can be dispatched based on which job has the earliest due-date, which job arrived first, which job has the least or most processing time, which job will result in a minimum difference of workload between resources, etc.. Often jobs enter the system with a due-date already assigned. When the manufacturer has the leeway to assign due-dates, a number of different dispatching rules can be used. Conway performed some of the most definitive work on the performance of different due-date assignment rules [66]. Han and McGinnis have recently studied the performance of more complex due-date setting rules [67, 68]. Once a job is released into the factory, or once a job is finished at a resource, the next decision is which resource to route it to next. Often, the routing decision has been made long in advance by a process planner. This is especially common in assembly-line and flow-shop manufacturing facilities. By dispatching routing decisions better flexibility and factory performance can potentially be obtained. Common routing rules are to route to the resource with the least work sitting at it, to route to the resource which would finish the job the earliest, or to route to the resource which would take the least time (or energy or cost) to process the job.


10

May 8, 1998

The advantages of dispatching rules come from their simplicity. They are usually temporally local, They do not try to predict the future but make decisions based on the present. Thus, these rules are very useful in factories which are extremely unpredictable, such as some job-shops. Also, dispatching rules are usually spatially local, requiring only the information available at the location where the decision will be implemented. Dispatching rules are simple algorithmically and do not require significant computation. They are easy for novices to understand and implement. The expected behavior of the most common dispatching rules is well known. Also, dispatched factories can be easily analyzed using simulation tools and in some cases they can be analyzed mathematically using queuing theory or other stochastic models. Queuing models show the potential difficulties with dispatched factories. In particular many different queuing network models show that as resource utilization approaches 100%, inventories and lead-times in a dispatched factory geometrically approach infinity. This is a basic result from the randomness allowed in the system. So for example, Figure 3 shows theoretical results in a single machine factory where jobs arrive randomly and independent of each other according to an exponential distribution, jobs take a random amount of time to process also according to an exponential distribution, and jobs are sequenced using a first-come-first-serve (FCFS) dispatching rule (an M/ M/1 queue). If either arrivals or processing times were deterministic instead of random (D/M/1 or M/D/1 respectively), then inventories and lead-times would decrease, but they would still geometrically approach infinity as utilization goes to 100%. Only when arrivals are perfectly balanced with

Normalized Average Time-in-System

(average time-in-system / average processing time)

10

8

6

4

/1

M M/

2

1

D/

M/

1

M/

D/

balanced D/D/1 0 0.0

0.2

0.4

0.6

0.8

Utilization

Figure 3: Lead-Times at a FCFS Dispatched Machine

1.0


11

May 8, 1998

processing times (balanced D/D/1, as might be achieved with an advance scheduling system) will a FCFS dispatching rule not result in geometrically increasing inventories and lead-times. Similar results are achieved with all the standard dispatching rules using available queuing models.

2.2. Dispatching in a Multi-Agent Heterarchy Most dispatching rules use only local information specific to a given manufacturing resource or job in making their factory control decisions. Thus, they lend themselves to a heterarchical implementation. Indeed, the preponderance of agent research for manufacturing has developed agent architectures which merely implement dispatching rules. It is most common to dispatch the routing decision in these architectures, assuming sequencing can then be done at each resource, and that releasing and due-dates are determined somewhere else. Shaw was the first to propose using agents in factory control. In his 1984 Ph.D. thesis he proposed that a manufacturing cell could subcontract work to other cells through a bidding mechanism [69-75]. The cell which could finish the job with the earliest finish time was put forth as one criteria by which bids could be selected. He suggested that other dispatch rules could also be used to make this routing decision. Shaw’s architecture was heterarchical and the physical correspondence was to cells of machines instead of individual machines. The first implementation of a test-bed agent-based manufacturing system was a hierarchical instead of a heterarchical system. In this work reported in 1985, Parunak et. al. used a bidding mechanism as a means for an agent to find the most favorable agent to which work would be routed [31-33]. In 1986, Duffie and his associates reported a test-bed multi-agent heterarchy at the University of Wisconsin which they termed “part-oriented [54, 76-79].” They implemented not just resources (processing equipment, material handling equipment, and humans) being represented by agents but also parts being represented by agents. Here, when a part finishes processing on a manufacturing resource, the part requests bids from resources which might perform a subsequent processing operation, and it selects the resource to which it will be routed next [42-44] The first commercial use of agent-based dispatching systems was installed by Flavors Technology in 1991 at a General Motors Truck and Bus painting facility. Here a heterarchical distribution of paint booths are each represented by an agent. The agent decides what to paint next out of the next 100 jobs available to all booths using three dispatching rules, 1) do jobs of the same color, 2) do highest priority jobs, and 3) random selection. This dispatching rule is used to make both a routing and a sequencing decision. Other researchers have considered different features and extensions to dispatching in heterarchical agent architectures. Upton and Tilley have each provided complementary analyses of multi-agent


12

May 8, 1998

heterarchies which dispatch routings based on the earliest finish time rule. Upton provides detailed analysis of the utilization of competing machines having different processing speeds under such a scenario [80]. Tilley analyzes how bids can congest the system if the time to produce a bid becomes too large [81-83]. Lin has considered an agent heterarchy where part agents negotiate with machine agents in a currency (e.g. dollars) to dispatch a routing decision. The price a part agent pays or a resource agent charges varies depending on market conditions. She developed a simulation of this system showing that her dynamic price setting mechanisms were indeed stable [84-87]. Ting proposed a dispatched multi-agent heterarchy where agents represent part storage, production management, and network management [88]. In conclusion, we see that dispatching algorithms can easily be implemented in a multi-agent heterarchy. These rules usually only require local information for their decision making and thus are straight forward to distribute across the heterarchy. For most of these decisions, the system scales sublinearly as the addition of an agent does not effect dispatching decisions at other agents. In the case of the routing decision, a great deal of agent research has been with having the agents make this decision by collecting bids from potential machines to which the job can be routed. The contents of these bids are usually simple information such as cost, earliest start time, or earliest finish time. In these cases the number of bids in the system would grow linearly with the number of candidate machines in the system. This would be considered a graceful scaling in the architecture. If the number of machines grows so large that bid congestion occurs then practical filters can be put into the system to make sure only machines which are likely to win the bidding actually make bids.

3.

SCHEDULING ALGORITHMS

A scheduling algorithm determines in advance when, which jobs will use which factory resources. (The term “scheduling” is only used in this paper when indeed an advance schedule is formed.) For factories which are substantially deterministic, scheduling can provide a number of advantages over dispatching. The scheduling system can be used to reduce randomness in the factory, thus reducing inventories and lead-times (cf. discussion surrounding Figure 3). Scheduling can be used to search for globally (across resources and across time) optimal or close-to optimal results. Scheduling can be used to manage bottleneck resources, making all other machines subservient to the needs of the bottleneck. Schedules can be used to tell customers when orders will ship, to plan long-range equipment and inventory requirements, and to plan interactions with general management, purchasing, employee availability, maintenance, and tool inventory. Basically, a schedule adds a level of rigidity to a manufacturing system which has both advantages and disadvantages [61].


13

May 8, 1998

Scheduling algorithms can be differentiated by the degree of optimality sought by the algorithm. Following this ontology, this paper discusses scheduling algorithms in the following order: optimal scheduling (including simple problems, Combinatoric problems, and mathematical programming problems), nearly optimal scheduling, toward optimal scheduling, and heuristic scheduling.

3.1.

Optimal Scheduling

The optimal scheduling problem is often formulated as a general optimization problem with constraints. This problem is to select the right parameters x 1, x 2, …, x n such that some cost function J(x1, x2, …, xn) is either maximized or minimized, where each of the parameters xi are restricted to some set Ω i, subject to some constraints on the parameters which can usually be formulated as m boundary conditions aj(x1, x2, …, xn) ≤ bj. This is succinctly written Optimize

J(x1, x2, …, xn)

subject to

aj(x1, x2, …, xn) ≤ bj, j = 1…m

where

x i ∈ Ω i , i = 1…n

[1]

Many optimal scheduling problems can be shown to be NP-complete where every possible solution has to be evaluated to determined the best solution [89]. NP-completeness generally means the problem can not be solved in a reasonable amount of time, even using the fastest computers available. This is because of the combinatoric growth of the number of possible solutions as the number of jobs or manufacturing resources increases. These problems can not be solved in reasonable amounts of time no matter what the architecture. NP-complete optimal scheduling problems include the minimum makespan problem on m parallel machines without preemption [90], the minimum makespan m-machine flow-shop problem where m > 2 [91, 92], and the minimum makespan, minimum flow-time, and minimum tardiness problems for an mmachine job-shop where m > 2 [90]. Because many simple optimal scheduling problems are NPcomplete, it is generally believed that most realistically sized optimal scheduling problems are also NP-complete. The next section discusses the simple optimal scheduling problems which are known to be computationally tractable. 3.1.1. Simple Optimal Scheduling Problems There are some simple optimal scheduling problems which are computationally tractable, and many of these can be solved in a multi-agent heterarchy. Table 2 lists all the known tractable optimal scheduling problems which can be solved by a distributed sort algorithm. In these cases each of n jobs (parts) in the system can be given its own agent. These n agents then perform a distributed


14

May 8, 1998

Problem

Metric

References

single machine single machine single machine single machine identical* parallel machines, without preemption 2-machine flow shop 2 machine job shop

maximum lateness or tardiness number of tardy jobs average tardiness average flow-time weighted average flow time

[66, 97, 98] [99] [100] [66, 98, 101] [94]

makespan makespan

[102] [103]

Table 2: Simple Optimal Scheduling Problems which can be solved in a Multi-Agent Heterarchy where Each Job Has an Agent sort which can be done in O{ln2 n} time [93]. In this multi-agent heterarchy, there is a balanced distribution of computation across the n agents, there is a physical correspondence between agents and jobs in the system and the algorithm scales sublinearly, which is better than standard centralized sort algorithms which are superlinear and of order O{n ln n}. There are a few simple optimal scheduling problems which can be solved using distributed algorithms but where the distribution does not directly map onto a heterarchical agent architecture. For example, McNaughton’s rule is a centralized algorithm for solving the minimum makespan problem for n jobs and m parallel machines when preemption is allowed. The rule solves the problem in n processing steps (i.e. the algorithm is O{n} [94]). Dekel and Sahni [95, 96] have shown how McNaughton’s rule can be decomposed onto  n/ln n  processors making the distributed algorithm only O{ln n}. To put Dekel and Sahni’s algorithm into a multi-agent heterarchy, the n jobs would be clustered into groups of up to ln n jobs and each group would require an agent. This algorithm does not map directly onto a multi-agent heterarchy because the physical correspondence of this architecture is questionable. But, the distribution is balanced and the scalability is reasonable being only O{ln n}. A more problematic mapping comes when solving the minimum average flow-time problem on m parallel uniform** machines without preemption. This problem can be solved using a centralized algorithm which is O{n ln mn} [104] . The problem can be solved in O{ln2 nm} time [96] when

*

Machines j and k are identical if for all i jobs’, i = 1…n, these jobs’ processing times are the same at each machine, pi,j = pi,k for j,k ∈ {1, 2, …, m}.

**

Machines j and k are uniform if for all i jobs’, i = 1…n, these jobs’ processing times are proportional to each other at each machine, c jp i,j = c kp i,k for j,k ∈ {1, 2, …, m}. The proportionality constants c j and c k are only dependant on the machine and not on the job being processed.


15

May 8, 1998

mn processors are used. Thus, to solve this problem in an multi-agent heterarchy, an agent is needed for all mn relationships between the n jobs and the m machines. Such an architecture would lack the physical correspondence we desire in a multi-agent heterarchy. There is also at least one example where the simple optimal scheduling problem can be solved in polynomial time, but no distributed algorithm is known, so implementation in a multi-agent heterarchy would not be meaningful. This is Bruno’s O{max(mn2, n3)} algorithm for minimizing average flow-time on m parallel non-uniform machines [105]. 3.1.2. Combinatorics A number of combinatoric problems have relationships to scheduling problems and thus have implications on what scheduling problems can be solved in a multi-agent heterarchy. Roberts provides a simple example scheduling problem which can be posed as a shortest-path problem [106]. The shortest path problem is to find the shortest path in a graph of connected nodes where each connection has a weight associated with it. The problem of finding the shortest path between all pairs of nodes can be solved in O{m3} time using centralized algorithms, where m is the number of nodes (processes, machines, ...) in the graph [107-110]. It is a rather simple matter to arrive at a parallelized shortest path algorithm which can be solved in O{m2} time using m processors, one for each node. In this algorithm, each node iteratively tells all nodes to which it is directly connected what nodes it can reach and the cost to reach these nodes. After less than m iterations which each require up to m computations at each node, every node will know the shortest path to reach any another node and it will know which node it needs to send work in order to follow that path. Thus, the shortest path problem can be solved in a multi-agent heterarchy in O{m 2} time where each of m nodes have their own agent. The shortest-path problem can be solved in faster time using polynomial numbers of processors, usually m3 processors [111-117]. It is not clear how one of these m3 processor algorithms would be implemented in a multi-agent heterarchy as the number of agents needed grows cubicly with the number of machines in the system. An interesting variant on the shortest path problem is provided by Gallager [118]. He considers the case where the weight associated with a path increases convexly with the amount of traffic over that path (such as is the case when weights correspond to delays in a queuing network). Assuming the amount of traffic entering the system is stochastically stationary, in the limit his algorithm converges to every node knowing the shortest path to all other nodes. The algorithm was developed for implementation on m nodes and thus lends itself to an agent implementation. Other combinatoric problems which are similar to scheduling problems but which are NP-complete include the traveling salesman problem [89], the bin packing problem [119], and the knapsack problem [120]. Because these problems are NP-complete, agent implementations can not be


16

May 8, 1998

expected except in those restricted cases which result in polynomial formulations. More research is needed to see which of these polynomial formulations can indeed be implemented in a multi-agent heterarchy. 3.1.3. Mathematical Programming Mathematical programming problems are a class of decision problems where mathematical techniques can be used to make (“program”) a decision. Here programming is meant not in the sense of programming a computer what to do, but in the sense of programming a system what to do [121-123]. The general mathematical programming formulation was given in Equation 1. The most easily solved mathematical program is a linear program. Linear programming formulations can be solved using polynomial algorithms [124, 125]. In a linear program, decision variables are restricted to the real numbers, the cost function and the constraints are linear functions on the decision variables. The linear programming formulation can be written Optimize

c•x

subject to

Ax ≤ b and x ≥ 0

where

n m n n x ∈ R , b ∈ R , c ∈ R , and A ∈ R xR

m

[2]

Linear programs can be used to solve special cases of the general factory scheduling problem. For example, they can be used to determine what to produce and how much to produce assuming products are continuous quantities such as liquids (product mix problems). Linear programming can also be used to decide what expendable resources to use and how and when to use them in blending, covering, staffing, and cutting stock problems. Some routing decisions can also be formulated as network, distribution, or PERT/CPM problems which can be solved as linear programs. Multiperiod planning formulations can be used to decide for each period what should be produced, how much should be produced, and when expendable resources should be used (e.g. human workloads) given known demands in each period and inventory carrying costs from period to period [123]. Some of these solutions have direct implications on when to release jobs into the factory and which jobs to release. The general factory scheduling problem is often formulated as an integer program, which is named such because the decision variables are restricted to be integers. Optimize

J(x1, x2, …, xn)

subject to

aj(x1, x2, …, xn) ≤ bj, j = 1…m

where

x 1 , x 2 , …, x n ∈ I

[3]


17

May 8, 1998

In particular, decision variables are often restricted to being zero or one resulting in a 0/1 integer program. In the standard integer programming formulation of the factory scheduling problem, decision variables are the number of jobs on a given manufacturing resource in a given period, where periods are preferred to be in terms of hours but may need to be longer to reduce the size of the problem. For the solution to be feasible, there should be zero or one jobs on the resource at any given time. As discussed before, the general factory scheduling problem is generally considered to be NP-complete. So, we should not be surprised that integer programming is also NP-complete [120, 126, 127]. It is not clear whether an integer program can be decomposed in a way that it can be solved in a multi-agent heterarchy. One attempted decomposition was that used by Davis and Jones where the integer program was decomposed spatially into groups of resources, with a single centralized computer coordinating the results of subproblem solutions [128]. This was a hierarchical architecture with a decomposition at the second level by resource. Possibly, decompositions by job or by other entities could lend themselves to the general integer programming problem. Further research is needed in this regard. Others have recently attempted approximately solving integer programs in agent architectures as is discussed next.

3.2.

Nearly Optimal Scheduling

Since most realistically sized optimal scheduling problems are NP-complete, it makes sense to try and redefine the problem in a way that it can at least usually be solved. One such attempt at redefinition is to relax the requirement that the solution be optimal and only require that the solution be within some range of optimal. In these nearly optimal algorithms, this range of optimality has been defined by how close the solution is to the optimal solution, by how close the solution is to a bound on the optimal solution, or by probabilistic descriptions. These three types of nearly optimal algorithms are described as follows. First, nearly optimal algorithms which provide results which are close to optimal include: •

absolute approximation algorithms which find a solution which is within some absolute constant k to the optimal solution,

•

approximation schemes which take a given ε and find a solution which is within the fraction ε of the optimal solution,

•

ε-approximate algorithms which find a solution which is within some fixed fraction ε of the optimal solution, and f(n)-approximate algorithms which find a solution which is within some fraction f(n) of the optimal solution, depending on the size of the problem n .

•


18

May 8, 1998

Second, nearly optimal algorithms which provide results which are close to a bound on optimality will be distinguished in this paper as near optimal bounds algorithms. A near optimal bounds algorithm finds a solution to within an absolute constant c of a lower or upper bound on the optimal solution. Third, nearly optimal algorithms which are probabilistic in nature include [129]: •

• • •

numerical probabilistic algorithms, such as queuing network simulation algorithms, provide solutions described by probability distributions and complete in a known amount of time, Monte Carlo probabilistic algorithms provide with some probability p(n) an optimal solution, and complete in a known amount of time [130], Las Vegas probabilistic algorithms provide an optimal solution if they complete, and have a defined completion probability, and Sherwood probabilistic algorithms, which provide an optimal solution when they complete, and whose expected completion-time is described by a probability distribution.

Though nearly optimal scheduling seems like a very worthwhile concept, results in this area are not very extensive, and what is known has for the most part has not been very successful from both a theoretical and a practical perspective. For example, in many problems if the optimal problem is NP-complete, so is the nearly optimal problem [130-132]. In other cases, polynomial-time near optimal algorithms exist but the measure to nearness (be it ε, k, f(n), or 1/p(n)) is so large that it makes the algorithm relatively useless. For example, the weighted longest processing time sorting rule (LPT/w) provides a nearly optimal algorithm for the knapsack problem [130]. This allows for implementation using an agent-based O{ln2 n} sorting algorithm [93]. The problem is that what LPT/w provides is a 1-approximate algorithm, meaning that ε is 1 and the answer is only guaranteed to be no more than 100% off from the optimal answer. In most of the few cases where arguably useful approximations can be made, agent implementations are not obvious. For example, Horowitz and Sahni provide an O{n/ε 2 } approximation scheme for the NP-complete problem of minimizing the makespan of n jobs on 2 parallel uniform machines, when preemption is not allowed. They also provide an O{n 2/ε} 2m scheme for the case where the machines are unrelated, and an O{n /ε} scheme for minimizing weighted average flow-time [104]. Neither is a meaningful multi-agent heterarchy apparent for Christofides O{n3} 0.5-approximate algorithm for solving the NP-hard traveling salesperson problem with triangle inequality*** [133], for Sahni and Horowitz’s O{n1/ε} approximation scheme for the NP-complete knapsack problem [130], and for Coffman et. al.’s O{n ln n} 0.22-

***

The traveling salesperson problem with triangle inequality is the traveling salesperson problem where all distances between cities obey the triangle inequality. That is for any cities a, b, and c, where d(a,b) represents the distance between cities a and b, d(a,b) ≤ d(a,c) + d(b,c). The traveling salesperson problem remains NP-hard under this restriction, though ε-approximation is no longer NP-complete.


19

May 8, 1998

approximate algorithm for the NP-complete minimum makespan m parallel machine scheduling problem without preemption [119]. There are a few limited cases where nearly optimal algorithms show promising results and where there are obvious ways to implement these algorithms in a multi-agent heterarchy. For example, the LPT rule provides an ε-approximate algorithm for solving the NP-complete minimum makespan m parallel machine scheduling problem without preemption [134] where ε = 1/3-1/3m. In this case, since LPT is merely a sorting rule, it can easily and meaningfully be implemented in a heterarchical agent system. Also, Johnson’s 2/9-approximate algorithm for the NP-complete bin packing problem can be implemented in a multi-agent heterarchy. This algorithm sorts the jobs by decreasing size and allocates them in order to the first bin, and if bin i does not have enough room for the job then the job is allocated to bin i+1 [135, 136]. This algorithm only requires a distributed sort and can be implemented in O{ln2 n}-time in an agent architecture where agents represent both jobs and bins. One unique type of nearly optimal algorithm which has recently proven to be very useful for factory scheduling is the near optimal bounds Lagrangian relaxation technique [137-140]. Lagrange multipliers can be used to move constraints from a constrained optimization problem into the cost function. For example, in the integer programming formulation given in Equation 3, any k of the m constraints (where 0 ≤ k ≤ m) can be put in the cost function resulting in an optimization problem of the form: Optimize

J(x1, x2, …, xn) + Σλj[aj(x1, x2, …, xn) - bj], j = 1…k

subject to

aj(x1, x2, …, xn) ≤ bj, j = k+1…m

where

x1, x2, …, xn ∈ I

[4]

In this formulation, the Lagrange multipliers λj end up being functions of the decision variables and the decision variable x i end up being functions of the Lagrange multipliers λ j. So, the optimization problem has to be solved iteratively. The λj are solved by solving what is called the “dual problem” which is equivalent to solving the problem where the constraint that the decision variables be integral is relaxed (thus the term “Lagrangian relaxation”). The optimum value of J(x1, x2, …, xn) is bounded below by the optimal solution to the dual problem. Thus at any step of the iteration, we may not know how far we are from optimal but, we know how far we are from a lower bound on optimality. The algorithm will usually be allowed to continue iterating until this “duality gap” reaches a certain small size, or the number of iterations has reached some fixed number. Not only does the Lagrangian relaxation technique usually provide results which are to within some bound of optimality, it would seem to lend itself to implementation in a multi-agent heterarchy. In particular, in common formulations each subproblem of Equation 4 decomposes by


20

May 8, 1998

job and the Lagrange multipliers correspond to each type of machine. So it would appear that we could have a heterarchical architecture which solves the Lagrangian relaxation problem with a mixture of job and machine-type agents. Indeed, two recent projects to use Lagrangian relaxation techniques in an agent architecture use these two types of agents. In Gou, et. al.’s architecture there are 5 types of agents [141]. Machine-type agents, operation agents, product agents, part agents, and a coordinator agent. This system is used to develop a product’s process plans and then to schedule these products. The scheduling process is performed by an interaction between machine-type agents, product agents, and the coordinator agent. The coordinator agent performs the task of deciding a step size for the steepest ascent determination of the machine-type Lagrange multipliers λj. This agent violates the goals of distribution and physical correspondence outlined earlier. But, its function as a centralized construct is rather simple and could apparently be distributed if so desired. Ramaswamy and Joshi take a different approach [142]. They do not try to solve the integer program in an agent architecture. But, they supply the Lagrange multipliers which result from a centralized computation to machine-type agents and job agents. Based on changes which happen on the shop floor, machine-type agents modify their multipliers and job agents change job routings from those determined in the off-line Lagrangian relaxation. If no changes were to happen on the shop floor, job agents would end up following the schedule determined by the off-line Lagrangian relaxation. If changes do happen, we would expect the schedule they follow to be reasonably close to the original schedule. The Lagrangian relaxation technique is a very promising technique for factory scheduling in general and for heterarchical agent scheduling in particular. Current work in this area is only a beginning of the work which needs to be performed to pursue these concepts fully.

3.3.

Towards Optimal Scheduling

There are a number of scheduling algorithms which do not attempt to gain optimality, or guarantee any nearness to optimality but which still attempt to optimize a cost metric such as J(x1, x2, …, x n ). That is these algorithms look for ways to change the values of x 1 , x 2 , …, x n so as to improve the value of J(•). These towards optimal scheduling techniques include simulated annealing, genetic algorithms, and neuro scheduling. 3.3.1. Simulated Annealing In simulated annealing [143-145], the algorithm incrementally changes the values of the xi in ways that still meet the constraints aj(x1, x2, …, xn) ≤ bj. If J(x1, x2, …, xn) improves, the new values


21

May 8, 1998

of the xi are kept with a probability which exponentially approaches 1 depending on how long the algorithm has run (called the “temperature” of the system). These algorithms simulate annealing in that the system becomes more brittle as the temperature of the system decreases. At high temperatures, atomic portions of the schedule are allowed to jump around even into spots which are locally sub-optimal. The allowance of sub-optimal conclusions is done to prevent the system from immediately going to a local optimum, thus increasing the chances a global optimum will be found. There is nothing to imply a simulated annealing algorithm could not be put in a multi-agent heterarchy. For example, machine agents could be randomly assigned jobs on which to work. These agents could sell their jobs to other machines which can do the work more efficiently, and the two agents could split the savings. Early in the process, arrangements between agents can be made which have increased costs for both agents instead of decreased costs. As the annealing temperature drops, the probability of entering such an arrangement would decrease until finally the schedule solidifies. In this case, the agreed value of temperature is derived from the time which is considered a globally available value and not a centralized construct. The actual implementation of such a system would be an interesting research project. 3.3.2. Genetic Algorithms In genetic algorithm [146] based scheduling [147-152], a number of initial schedules are formed, each meeting the given constraints of the system. Each schedule is evaluated by J(•) giving a rank ordering of the schedules. The schedules are then mated. By mating we mean that portions of each schedule are joined to each other to form a new schedule. Good schedules are usually mated with good schedules and bad schedules are mated with bad schedules, though crossovers are allowed. New schedules are spawned with careful attention that the system constraints aj(x1, x2, …, xn) ≤ bj are still met (this is a tricky process). All schedules are again evaluated by J(•) and the worst schedules are thrown away. This algorithm repeats until a certain number of iterations have been completed, until results are no longer improving substantially, or until a time limit is reached. A genetic algorithm uses a multiplicity of schedules in its solution. Thus, if we were to let each schedule be an agent we could claim we have a multi-agent heterarchy which uses a genetic algorithm. There are a number of problems with such a claim. One problem is with the centralized mating and schedule-elimination algorithms which would have to be distributed. Another significant problem is the lack of a physical correspondence and scalable growth. Thus, it is not clear how to put a genetic algorithm in a multi-agent heterarchy of the form outlined in Section 1. 3.3.3. Neuro-Scheduling Neural networks have been proposed for two possible uses in factory scheduling. The first is to use a neural network to actually solve the scheduling problem. The second use is to have a neural


22

May 8, 1998

network learn what dispatching rules work best with different factory situations and use the neural network in combination with a deterministic simulator [153-159] (deterministic simulation is discussed in Section 3.4.2). (Neural networks have also been proposed in factory dispatching to learn under which situations which parameters work best for a complex dispatching rule [160]). Neural network approaches to solving the scheduling problem have generally suffered from a lack of scalability, difficulties finding good solutions in realistically sized problems, and the inability to meet the problem’s constraints in realistically sized problems [161-168]. The scaling problem arises in the standard Hopfield-Tank model [169, 170] where the network consists of o2+ o nodes where o is the number of operations needing to be scheduled. This formulation becomes unmanageable as the number of jobs in the system increases. This formulation would also be difficult to implement in a multi-agent heterarchy as there is no scalability based on real entities in a manufacturing system such as jobs or machines. One neural network formulation which may lend itself to a multi-agent heterarchy is that proposed by Zhou and Cherkassky [171-173]. Their formulation uses an analog neural network which has as many nodes as there are operations. Thus, the agent architecture would have one agent for each operation. Whereas the Hopfield-Tank model [169, 170] uses a quadratic energy cost function, Zhou and Cherkassky use linear cost functions and employ nonlinear processing in the feedback connections. The result is that the number of nodes and the number of interconnections grows linearly with the total number of operations. The approach has apparent potential, but requires more research. The formulation seems to grow gracefully from small problems of 2 machines and 4 jobs to larger problems having 10 machines and 10 jobs. But, attempts on realistically sized problems have not been reported. The network has only been used to solve minimum average flowtime problems. The formulation seems to be extensible to other scheduling problems (such as minimum makespan or tardiness), but these extensions have not been demonstrated. Also, parameters in the neural network’s energy function depend significantly on the size of the problem and there is no obvious way to obtain these parameters except by trial and error. Finally, an analog neural network is used in this formulation where continuous communication is provided within the nodes of the network. It is not clear whether communications limitations would prohibit actual implementation in a multi-agent heterarchy where the agents are connected together by a digital communications network.

3.4.

Heuristic Scheduling Methods

Heuristic scheduling uses techniques which seem like they will bring good performance, but which can not be proven to be within any range of optimal or even evolving towards an optimal solution. A cost metric is often embedded in the set of heuristics and serves to motivate their use. For example, the desire to reduce tardiness may motivate a heuristic which looks first at jobs which are


23

May 8, 1998

most likely to be late. The fact that the heuristic’s designer favors a specific cost metric still does not guarantee the heuristic will be in any range of optimal. Nor does it mean that the designer’s favorite cost metric is used to compare one decision against another within the heuristic. Heuristic methods are by far the most commonly used techniques in industry. This is probably because these methods guarantee a solution in a reasonable amount of time, no matter how large the problem. Forward/backward scheduling (Section 3.4.1) is the common form of scheduling used in most ERP and MES systems. Deterministic simulation (Section 3.4.2) is a recent innovation which has quickly gained a broad industrial following. Intelligent Scheduling (Section 3.4.3) is the use of Artificial Intelligence techniques for factory scheduling and has recently reported some level of industrial success. The first successful implementations of heterarchical multi-agent scheduling systems were reported with heuristic schedulers and in particular with forward/backward scheduling. 3.4.1. Forward/Backward Scheduling Forward/backward scheduling is the common form of scheduling used in most ERP and MES systems. As such, it is the most commonly used scheduling technique in manufacturing. The concepts of forward and backward scheduling [174] are best described with pictures. Figure 4 shows the bill of materials for a given product. This bill of materials can be listed according to the time required to create its different components in its time phased product structure (TPPS), Figure 5. To backwards schedule a job, the completion of the finished product on the TPPS is put at the product due date. Then, the time during which each component will be added to the product is given in the backwards portion of the TPPS. To forwards schedule jobs, the earliest branch on the TPPS is put at the release time of the job into the system. All other components of the product are added in to the schedule based on the relative location in the TPPS. Either the forward or backwards schedule as described above is called an infinite schedule, End A Item meaning it is a schedule which is developed assuming infinite SubSubcapacity. These infinite schedules I II Assembly Assembly are not necessarily feasible. With infinite scheduling it is possible for Q S P R a given manufacturing resource to be scheduled to do more hours of work than there are hours in a day. Z Z Z Z Infinite schedules are usually used for rough-cut analyses of when Figure 4: A Bill of Materials


different sub-assemblies and raw materials are needed during manufacturing.

24

May 8, 1998

Z Z

P Q

I A

If the manufacturer actually wants a Z R schedule which is feasible, meaning II Z S no manufacturing resources is expected to be over 100% utilized, then finite scheduling techniques are needed. Finite scheduling can be 1 2 3 4 5 6 7 0 done by “load leveling” [175] an Time infinite forward/backwards schedule, or by performing finite Figure 5: A Time Phased Product Structure forward/backwards scheduling in the first place. Finite backwards scheduling is like infinite backwards scheduling, except while working back in the TPPS if adding a component to the product would require a resource to be over utilized, then the addition of the component is slipped back in time until the resource is available. All previous operations in that branch of the TPPS are also slipped back in time. Finite forward scheduling is similar but this time component additions are slipped forward in time when over utilized resources are encountered. When finite scheduling is being performed, the order of the scheduling will result in different schedules. Finite scheduling can be done in • job order as discussed above, • operation order where all next operations in the TPPS are prioritized, the highest priority operation is scheduled, any operations before (in backwards scheduling) or after (in forwards scheduling) the now scheduled operation are added to the prioritized list and then the highest priority operation is scheduled from the new list, and so on, or • resource order, which is a variation on operations scheduling where the priority on the operation is determined by the resource where the operation will be scheduled. When resources priorities are ordered by expected utilization of the resources, the scheduler is called a “bottleneck scheduler.” This is the form of scheduling most often used to implement schedules which conform to Goldratt’s theory of constraints (TOC) [176-178]. Resources can be machines, people, tools, gages, fixtures, or pallets. The scheduler can consider when multiple resources are needed to add a specific component to the product and assure that none of the necessary resources are over utilized in the schedule. Finite scheduling can also be accomplished by “load leveling” an infinite schedule. Here heuristic methods are used to move jobs from time slots where resources are over 100% utilized. Forward/backward schedulers can also vary dependent on the size of the time slots which are scheduled. These time slots are usually called “time buckets” in scheduling jargon. Time buckets


25

May 8, 1998

can be as short as minutes, but are usually for hours, days, or weeks. The larger the time bucket, the less computational resource are needed to determine the schedule. The amount of time allowed to add a component to the product is usually determined by a multiple of the expected processing time, called the “allowance factor.” So, for example, if the allowance factor for the scheduling system is 10, then for each operation which is performed, 10 times the necessary processing time is allowed for completion of the given operation. Different forward/backward scheduling systems have different flexibilities with the allowance factors. Some allow each resource to have a different allowance factor, some have allowance factors which change based on shop conditions, some have different allowance factors for each type of job. Forward / backwards schedulers usually operate over a fixed planning horizon, usually of a month, but sometimes for a week or for a quarter. Schedules always have to be changed as real factories operate. Forward / backward scheduling systems differentiate themselves by how they change the schedule to accommodate these changes. Originally, forward / backwards scheduling systems were re-run on a periodic basis, often each weekend. So the schedule could totally change every Monday morning. Now net-change (also called network, dynamic, or threaded) scheduling systems are used, where only portions of the schedule which are effected by the change on the factory floor are modified. Changes can be performed in a batch mode, say overnight, or continuously. Baker’s Market-Driven Contract Net provided the first successful implementation of an heterarchical multi-agent scheduling system in 1991 [61, 179-181]. The system was first proposed in 1988 [182]. The implementation’s performance was studied using a simulation of a GE job shop. This agent architecture performs a type of forward / backward scheduling. It uses bids for the components each resource can provide to a finished product. The customer negotiates directly with these agents. The agent for the resource which performs the finishing touches to the product requests bids for components. Agents whose resources can make the components request bids for their components, and so on. Bids are in terms of actual dollar-costs versus delivery-time and lot-size. When the customer selects a cost at a desirable delivery-time and lot-size, purchase orders are issued throughout the network. When an agent receives a purchase-order, it reserves the necessary capacity to meet the production promises contained in its corresponding bid. Bids show the cost to deliver at any desired time. This includes the cost of delivering at the earliest possible time, which is the forward schedule, the last possible time before a due-date would be missed, which is the backwards schedule, and all times in between and after. Thus the MarketDriven Contract Net determines the cost of the continuum of schedules between the forward and the backwards schedule. Traditional forward or backwards scheduling could be accomplished using a degenerate form of the Market-Driven Contract Net. Here to forward schedule only the first available time-slot is quoted and for the backwards schedule only the last available time slot before the due-date is quoted. The Market-Driven Contract Net performs forward / backwards


26

May 8, 1998

scheduling by job on a first-come-first-serve basis. Time buckets are not used as the continuum of time is used instead. In its current implementation, allowance factors are not used nor is a netchange incorporated in the prototype. Though net-change capabilities would be consistent with the basic technology involved. A hierarchical forward/backward multi-agent scheduling system was proposed by Ow et. al. in 1988. They called their system the Cooperative Scheduling System (CSS) [36-40]. A variant on their original concept was eventually installed in a non-production development shop at Pratt & Witney Aircraft around 1992 [41]. In the CSS system work orders are scheduled one at a time by an agent called the “Work-Order Manager.” Successive operations in the work order are scheduled in a forward pass by requesting bids from agents representing the resources in the factory. As the Work-Order Manager awards tentative contracts for each operation to be performed it issues request for bids for the next operation in the work order. Once all the operations are tentatively scheduled, the Work-Order Manager knows the work-order’s planned completion time. The Work-Order Manager then uses a similar bidding scheme to backwards schedule from this completion time to minimize time-in-progress. As a hierarchically structured set of agents, balanced distribution, physical correspondence, and scalability are compromised in this architecture. 3.4.2. Deterministic Simulation Deterministic simulation is a scheduling technique originally developed by Pritsker and Associates in their FACTOR product [183]. The idea is to run a single simulation of the factory using dispatching rules. Whatever the simulation predicts will happen in the factory is then used as the schedule. The term “deterministic” is used to distinguish the simulation from the traditional stochastic simulation techniques where multiple simulations are run and statistics are collected to analyze expected system performance. Deterministic simulation scheduling is usually performed with a great deal of human oversight. The human scheduler will run the simulation using a number of different dispatching rules. He might take the best of these schedules and modify it by selecting one dispatching rule at one resource and another dispatching rule at another. He may also move jobs around and explicitly sequence operations on the shop floor. The human scheduler’s ability to adapt and change the deterministic simulation schedule is often referred to as a “what-if” capability. As an advance run of a dispatching algorithm, deterministic simulation lends itself to implementation in a multi-agent heterarchy. Duffie and Prabhu [45] are currently developing the first deterministic simulation scheduler implemented in a multi-agent heterarchy. A preponderance of their work has been with replacing the human / computer interaction with an automated tuning of the schedule. This agent-architecture is being installed at in test-bed at the University of Wisconsin.


27

May 8, 1998

3.4.3. Intelligent Scheduling Intelligent Scheduling uses Artificial Intelligence techniques to solve scheduling problems. The techniques and methods developed by the Artificial Intelligence community for scheduling are unique compared to the other algorithms already presented in this paper. They often use standard Artificial Intelligence concepts such as blackboard architectures, frame-based knowledge representation, case-based reasoning, and expert systems [184]. A number of techniques and methods have been developed in the Artificial Intelligence community specifically for solving scheduling problems. These include, among others, constraint propagation, conflict resolution, backtracking, iterative repair, constraint relaxation, micro-opportunism, and conflict partitioning [185]. The Artificial Intelligence community’s foray into scheduling was initiated with the ISIS project at Carnegie-Mellon in the fall of 1980. Since then, the field has seen numerous failures and few success. Now after more than 15 years, the field has reported enough success that a number of commercial products have been introduced using Intelligent Scheduling techniques. These standard techniques usually fit in the realm of heuristic algorithms as already defined. There have been a few attempts to use standard Intelligent Scheduling heuristics in an agent heterarchy. Because of limited success in Intelligent Scheduling in general, we can not expect substantial success when these techniques and methods are cast in a multi-agent heterarchy. One example attempt was made with the DAS (Distributed Asynchronous Scheduling) system by Burke and Prosser [34, 35]. DAS was first proposed in 1988 and its implementation was reported in 1990. The DAS architecture consists of three types of entities: knowledge sources, agents, and a constraint maintenance system. The knowledge sources contain frame-based knowledge for resources, aggregate resources, operations, process plans and what is called the “strategic unit.” The agents were originally developed as a multi-agent heterarchy using agents to represent only resources (O-agents). But the initial formulation had stability problems with the algorithms being implemented. The final formulation had agents for different aggregations of resources (T-agents) and an agent for overseeing the whole scheduling process (an S-agent). This final architecture was arranged hierarchically. The S-agent assigns operations to be performed by T-agents. T-agents assign these operations to their respective O-agents which schedule these operations on their respective resources. All agents operate asynchronously, assigning or scheduling operations from a list of available operations according to different possible heuristics. As scheduling assignments are made, these constraints are propagated throughout the system by the constraint maintenance system. If an O-agent determines that it has unscheduled operations which need to be scheduled in overlapping times it reports this conflict to its managing T-agent. The T-agent then backtracks by reassigning these or related operations to other O-agents, or it reports a conflict to the S-agent. The S-agent can resolve the conflict either by imposing an order by which operations need to be scheduled or by relaxing constraints (e.g. a job’s due-date).


28

May 8, 1998

DAS was a success in the aspect that it was able to make realistic schedules for a real factory with 18 machines. It was a disappointment in that to use the backtracking and constraint propagation techniques it required a hierarchy of agents. DAS also was only able to make a correct schedule, it had no method for optimizing that schedule. Another attempt at applying standard Intelligent Scheduling techniques in a multi-agent heterarchy was provided by Cortes [186]. Cortes used micro-opportunistic techniques for solving the scheduling problem in a 2-agent system. The implication being that if Cortes were a great success, these 2-agent algorithms would lead the way toward the development of multi-agent systems. In the Cortes architecture, each agent is responsible for scheduling a set of jobs and for “monitoring” a set of resources. Resources are shared in the architecture, but the sharing of a resource is coordinated by that resource’s monitor. Agents consider constraints on all operations being performed at each resource and derive a graph for how heavily demanded each resource is expected to be over time. To do this each agent sends a partial demand graph to the resource’s mother which produces a final demand graph for viewing by all agents. Operations which use the resource at high demand times are considered critical operations. An agent attempts to schedule its most critical operations first, nominally at times which the required resource has the lowest demand (though the authors leave open the possibility of scheduling at times most preferred by the agent). As operations are scheduled, demand graphs are modified and constraints are propagated to other related operations at the same agent and at the other agent. If a conflict is detected, the agent is only allowed to move its own scheduled operations around, it can not request that another agent move its operations. The Cortes system as described did work, but it was not pursued further. A special problem is that it has no way of resolving contention between agents. In particular, to minimize contention, the working version of Cortes requires agents to schedule when resources have the lowest expected demand. Such a policy results in poorer schedules than one where each agent schedules in times which are most preferable to it, no matter what the expected resource demand. A number of researchers have proposed blackboard agent architectures for solving the scheduling problem. Many of these systems would appropriately fall under the category of heuristically-based multi-agent scheduling systems. Interested readers are referred to the following papers [23-29].

4. PULL ALGORITHMS A pull algorithm uses the depletion of inventory to signal manufacturing production. That inventory is depleted can be deduced either by inventory reaching a certain level or by periodic reviews of inventory levels [187, 188]. The most common traditional pull algorithm is the (s,Q) policy where if inventory falls below s, the economic order quantity, Q, of the item is ordered from production. These algorithms are called pull algorithms because production is initiated only after the product is pulled out of inventory.


4.1.

29

May 8, 1998

Review of Pull Algorithms

Pull algorithms have been used for many years. In general they are thought of more as inventory management techniques than as factory control algorithms. Toyota Motor Company’s use of a pull algorithm for factory control changed the general perception. Toyota uses a pull algorithm based on kanbans. Kanban is Japanese for ‘ticket’ or ‘sign.’ In a simple one card kanban assembly line, every stage of production has inventory it has completed sitting after it. This inventory is batched in certain lot sizes. Each lot has a kanban on it. Each stage of production can only produce if there exists a kanban after that stage whose lot-size associated with the kanban is not yet filled. Once all lots in all stages are full, the assembly line stops. It will begin again only after a lot is pulled from final assembly. When this happens, the kanban on the final assembly lot is given back to final assembly. This kanban gives final assembly authority to produce another lot of the finished product. In order to make this final assembly, it pulls a lot from its previous stage, returning the kanban to that stage of production. This stage pulls a lot from its pervious stage and returns a kanban to that stage. This process continues on up the line until all stages are producing. The advantages of pull algorithms over scheduling or dispatching algorithms are significant and well documented [189-191]. Pull has an inherent inventory management advantage to it. Also, it can be used to identify problems in an assembly line so they can be fixed. The problem with pull algorithms is they require the availability of the inventory which is pulled out of the system. These algorithms are not appropriate for the large number of manufacturers who make diverse products in small batches. Toyota’s success with their kanban system caused a great deal of excitement about the use of pull algorithms in the 1980’s. The 1980’s were rift with claims from many scheduling vendors and their customers that their backwards scheduling algorithms were pull algorithms. The rationalization was that the scheduling algorithm worked backwards from the customers’ job due dates to determine a schedule. Yet, the reason for this common claim was marketing purposes, especially when there was a mismatch between the excitement over pull algorithms and the applicability of these algorithms. These marketing claims have diluted the meaning of the term “pull” in vernacular manufacturing terminology. In this paper, the term pull is used in its original restricted sense where the depletion of inventory signals production. The distinction is important because backwards scheduling and true pull algorithms have little in common algorithmically or from a performance perspective.

4.2. Pulling in a Multi-Agent Heterarchy Pull algorithms are essentially distributed, and thus lend themselves to implementation in a multiagent heterarchy. In particular, classic pull algorithms at Toyota are implemented manually by shop floor personnel. These personnel do not require any centralized system to tell them when to


30

May 8, 1998

or when not to produce. In a multi-agent heterarchy, it is straightforward to put an agent at each stage of production. The agent can hold a number of kanbans where each kanban has a specific lot size associated with it. When the number of units at a kanban is less than the lot size for the kanban, the agent actuates production at that stage. As a part of its bringing its stage into production, it will take inventory from its upstream supplier, which will then cause that agent to actuate production. Though pull algorithms are straightforward to implement in a multi-agent heterarchy, and though pull algorithms were very popular in the 1980s when some of the early work in multi-agent heterarchies was being performed, the first simulated use of agents executing a pull algorithm was not reported until 1992 by Flavors Technology [192]. Allied Signal implemented the first pull based agent architecture in one of their factories in 1993 [193].

5.

SUMMARY

This paper started by asking the questions: what of the currently used factory control algorithms can be implemented in a multi-agent heterarchy, what additional research is required to implement other commonly used algorithms in a multi-agent heterarchy, and are there any new factory control algorithms which multi-agent heterarchies suggest? We now have answers to some of these questions. We have seen that there is no major technical issue about whether dispatching or pull can be implemented in a multi-agent heterarchy. There is also no technical issue of implementing forward / backwards algorithms in this architecture. Thus, all the most common algorithms used in industry can be implemented in a multi-agent heterarchy. Very active areas of continuing research are considering how to make deterministic simulation algorithms, and near-optimal (Lagrangian relaxation) algorithms fit the heterarchical agent architecture. Little research has been done with fitting simulated annealing, or genetic algorithms in this architecture, though successful uses of these algorithms in centralized systems have been reported. Though agent-based scheduling may be considered a subfield of AI-based scheduling, little work has been reported on making some of the standard AI-scheduling techniques work in a multi-agent heterarchy, though use of blackboards and functionally heterogeneous agent architectures is normal in that community. Considerable technical issues continue with implementing neuro scheduling and optimal scheduling algorithms in general. So it makes sense that it remains an open issue of how to implement these algorithms in a heterarchical agent architecture. This does not say that these algorithms would


31

May 8, 1998

necessarily be better than algorithms which we already know can be implemented in a multi-agent heterarchy. It is just that heterarchical agent architecture development still lacks in these areas. This paper has not seriously addressed the question of what new algorithms are inspired by the multi-agent heterarchical paradigm, except in two cases. The Market-Driven Contract Net uses a new form of forward / backward scheduling called ‘cost-based forward / backwards continuum scheduling’ which was inspired by the common agent concept of bidding. Also, Duffie’s current work on developing agent-based deterministic simulation would be a new form of deterministic simulation as it attempts to automate the human interaction normally required for successful implementation of such systems. But in general we still have an open question of what new algorithms heterarchical agent architectures imply and what would be the performance of these new algorithms. Because a multi-agent heterarchy is a distributed computing paradigm, it would be worthwhile to investigate the communications overhead of these algorithms. Such evaluations are not generally reported. Such research would assure that not only can these algorithms be implemented in a multi-agent heterarchy, but that their implementation does not require excessive communications overhead.

6.

REFERENCES

[1] H. Hayashi, “The IMS International Collaborative Program,” in 24th ISIR, 1993, Japan Industrial Robot Association [2] National Center for Manufacturing Sciences, FOCUS: Exceeding Partner Expectations. Ann Arbor, MI: September, 1994. [3] S. Goldman and K. Preiss, Ed., 21st Century Manufacturing Enterprise Strategy: An Industry-Led View. Bethlehem, PA: Iacocca Institute, Lehigh University, 1991. [4] S. L. Goldman, R. N. Nagel and K. Preiss, Agile Competitors and Virtual Organizations: Strategies for Enriching the Customer. New York, NY: Van Nostrand Reinhold, 1995. [5] P. T. Kidd, Agile Manufacturing: Forging New Frontiers. Wokingham, England; Reading, MA: AddisonWesley, 1994. [6] R. Braham and R. Comerford, “Sharing Virtual Worlds: Avatars, Agents, and Social Computing,” IEEE Spectrum, vol. 34, no. 3, 1997, pp. 18-19. [7] M. R. Genesereth and S. P. Ketchpel, “Software Agents,” Communications of the ACM, vol. 37, no. 7, 1994, pp. 48-53, 147. [8] T. Petzinger, Ken Lang Thinks Prudence Will Pay in Marketing on Net, in The Wall Street Journal pp. B1, 1996. [9] B. Ziegler, On-Line Shops: Lots to See, Little to Buy, in The Wall Street Journal pp. B1, B6, 1995. [10] J. E. Rigdon, Blame Retailers for Web’s Slow Start as a Mall, in The Wall Street Journal pp. B1, B6, 1995. [11] G. C. Hill, Cyberslaves: New Software Allows Consumers to Send Out ‘Agents’ that Make the Web More Manageable— and Useful, in The Wall Street Journal pp. R20, R29, 1996. [12] J. Dibbell, The Race to Build Intelligent Machines, in Time pp. 57-58, 1996.


32

May 8, 1998

[13] J. Simons, Net Start-Ups: It’s a Dog’s Life: Gen X-ers at Agents Inc. Toil to Create a Web Winner, in U.S. News & World Report pp. 71-72, 1996. [14] M. Allen, Secret Agents, in Internet Advisor pp. 14-17, 1996. [15] M. Austin, Intelligent Agents: Private Investigations, in Internet pp. 36-42, 1996. [16] S. D. Griswold, Unleashing Agents: The First Wave of Agent-Enabled Products Hits the Market, in Internet World pp. 55-57, 1996. [17] J. Rumbaugh, Object-oriented modeling and design. Englewood Cliffs, NJ: Prentice Hall, 1991. [18] R. S. Pressman, Software Engineering: A Practitioner’s Approach. New York, NY: McGraw-Hill, 1992. [19] I. Berker and D. C. Brown, “Conflicts and Negotiations in Single Function Agent Based Design Systems,” Concurrent Engineering Research and Applications, vol. 1, no. 1, 1996, pp. 17-35. [20] S. Balasubramanian and D. H. Norrie, “A Multi-Agent Intelligent Design System Integrating Manufacturing and Shop-Floor Control,” in First International Conference on Multi-Agent Systems, San Francisco, CA, 1995, pp. 3-9. [21] H. Asama, M. K. Habib, I. Endo, et al., “Functional Distribution among Mobile Robots in an Autonomous and Decentralized Robot System,” in IEEE International Conference on Robotics and Automation, Sacramento, CA, 1991, pp. 1921-1926. [22] C. A. Kaskavelis and M. C. Caramanis, “Integration of the Production Planning and Control Decision Process in a Manufacturing Enterprise,” Working Paper, Department of Manufacturing Engineering, Boston University Technical Report, Boston, MA, 1995. [23] H. P. Nii, “Blackboard Systems Part One: The Blackboard Model of Problem Solving and the Evolution of Blackboard Architectures,” The AI Magazine, vol. 7, no. 2, Summer, 1986, pp. 38-53. [24] H. P. Nii, “Blackboard Systems Part Two: Blackboard Application Systems, Blackboard Systems from a Knowledge Engineering Perspective,” The AI Magazine, vol. 7, no. 3, August, 1986, pp. 82-106. [25] J. G. Maley, “Managing the Flow of Intelligent Parts,” in International Conference on the Manufacturing Science and Technology of the Future, Cambridge, MA, June 3-7 1987, [26] J. G. Maley, “Part Flow Orchestration in Distributed Manufacturing Processing,” West Lafayette, IN: Purdue University, August 1987. [27] J. G. Maley and J. J. Solberg, “Part Flow Orchestration in CIM,” in Proceedings of the 9th International Conference on Production Research, Cincinnati, OH, August 1987, pp. 2177-2184. [28] S. F. Smith, “OPIS: A Methodology and Architecture for Reactive Scheduling,” in Intelligent Scheduling, M. Zweben and M. S. Fox, Eds. San Francisco, CA: Morgan Kaufmann Publishers, pp. 29-66, 1994. [29] J. A. Richter, “Boeing Divisions Collaborate on Development, Implementation of Blackboard Technology on the Shop Floor,” FOCUS: Exceeding Partner Expectations. Ann Arbor, MI: National Center for Manufacturing Sciences, September 1994, pp. 2-3. [30] A. Koestler, The Ghost in the Machine. New York, NY: The Macmillan Company, 1967. [31] H. V. D. Parunak, J. F. White, P. W. Lozo, et al., “An Architecture for Heuristic Factory Control,” in Proceedings of the 1986 American Control Conference, Seattle, WA, June 18-20 pp. 548-558. [32] H. V. D. Parunak, “Manufacturing Experience with the Contract Net,” in Distributed Artificial Intelligence, M. N. Huhns, Ed. Los Altos, CA: Morgan Kaufmann Publishers, Inc., pp. 285-310, 1987. [33] H. V. D. Parunak, B. W. Irish, J. Kendrick, et al., “Fractal Actors for Distributed Manufacturing Control,” in Proceedings of the Second IEEE Conference on Artificial Intelligence Applications, Miami, FL, Dec 11-13, 1985, pp. 653. [34] P. Burke and P. Prosser, “A Distributed Asynchronous System for Predictive and Reactive Scheduling,” Artificial Intelligence in Engineering, vol. 6, no. 3, 1991, pp. 106-124. [35] P. Burke and P. Prosser, “The Distributed Asynchronous Scheduler,” in Intelligent Scheduling, M. Zweben and M. S. Fox, Eds. San Francisco, CA: Morgan Kaufmann, pp. 309-339, 1994. [36] P. Weisser, Jr. and S. Cochran, “Modeling Temporal Relations in Task Hierarchies for Job Shop Scheduling,” in Proceedings of the Second International Conference on Computer Integrated Manufacturing, Troy, NY, 1990, pp. 39-46.


33

May 8, 1998

[37] P. Weisser, Jr. and R. Howie, “Distributed Scheduling and Temporal Reasoning,” in AIAA Computers in Aerospace VII, Monterey, CA, October 1989, [38] P. Weisser and R. Howie, “A Cooperative Approach to Large Scale Production Planning,” in American Association of Artificial Intelligence Workshop in Production Planning and Scheduling, St. Paul, MN, August 25, 1988, [39] P. S. Ow and S. F. Smith, “Viewing Scheduling as an Opportunistic Problem-Solving Process,” Annals of Operations Research, vol. 12, 1988, pp. 85-108. [40] P. S. Ow, S. F. Smith and R. Howie, “A Cooperative Scheduling System,” in Proceedings of the 2nd International Conference on Expert Systems and the Leading Edge in Production Planning and Control, M. D. Oliff, Ed. Charleston, SC, May 3-5, 1988, North-Holland pp. 43-56. [41] K. Kane, “Cooperative Scheduling System,” in Principals of Autonomous Systems, H. V. D. Parunak, Ed. Ann Arbor, MI, September 21-22, 1992, National Center for Manufacturing Sciences Ann Arbor, MI, [42] J. Hatvany, “Intelligence and Cooperation in Heterarchical Manufacturing Systems,” in Proceedings of the 16th CIRP International Seminar on Manufacturing Systems, Tokyo, Japan, 1984, pp. 1-4. [43] J. Hatvany, “Intelligence and Cooperation in Heterarchic Manufacturing Systems,” Robotics & ComputerIntegrated Manufacturing, vol. 2, no. 2, 1985, pp. 101-104. [44] T. Vamos, “Cooperative Systems— an Evolutionary Approach,” IEEE Conrol Systems Magazine, vol. 3, no. 4, August 1983, pp. 9-14. [45] N. A. Duffie and V. V. Prabhu, “Real-Time Distributed Scheduling of Heterarchical Manufacturing Systems,” Journal of Manufacturing Systems, vol. 13, no. 2, 1994, pp. 94-107. [46] C. McLean, M. Mitchell and E. Barkmeyer, “A Computer Architecture for Small-Batch Manufacturing,” IEEE Spectrum, vol. 20, no. 5, 1983, pp. 59-64. [47] P. N. Kugler, R. E. Shaw, K. J. Vincente, et al., “Inquiry into Intentional Systems I: Issues in Ecological Physics,” Psychological Review, vol. 52, 1990, pp. 98-121. [48] S. Goss, S. Aron, J. L. Deneubourg, et al., “Self-organized Shortcuts in the Argentine Ant,” Naturwissenschaften, vol. 76, 1989, pp. 579-581. [49] J. L. Deneubourg, S. Goss, N. Franks, et al., “The Dynamics of Collective Sorting: Robot-Like Ants and Ant-Like Robots,” in First International Conference on Simulation of Adaptive Behavior, J. A. Meyer and S. W. Wilson, Eds., Paris, France, September 24-28 1990, MIT Press pp. 356-365. [50] G. Theraulaz, S. Goss, J. Gervet, et al., “Task Differentiation in Polistes Wasp Colonies: A Model for SelfOrganizing Groups of Robots,” in First International Conference on Simulation of Adaptive Behavior, J. A. Meyer and S. W. Wilson, Eds., Paris, France, September 24-28 1990, MIT Press pp. 346-355. [51] C. W. Reynolds, “Flocks, Herds, and Schools: A Distributed Behavioral Model,” Computer Graphics, vol. 21, no. 4, 1987, pp. 25-34. [52] F. Heppner, “Of Flocks and Chaos,” Bioscience, vol. 40, no. 6, 1990, pp. 429-430. [53] R. E. Korf, “A Simple Solution to Pursuit Games,” in Eleventh International Workshop on Distributed Artificial Intelligence, Glen Arbor, Michigan, February 1992, pp. 183-194. [54] N. A. Duffie, R. S. Piper, B. J. Humphrey, et al., “Hierarchical and Non-Hierarchical Manufacturing Cell Control with Dynamic Part-Oriented Scheduling,” in 14th NAMRC, North American Manufacturing Research Conference Proceedings, Minneapolis, MN, May 28-30, 1986, pp. 504-507. [55] S. Ricketts, Holonic Manufacturing Systems (HMS) Home Page, N. C. f. M. Science, Ed. , 1997. [56] H.-J. Warnecke, The Fractal Company: A Revolution in Corporate Culture. New York, NY: SpringerVerlag, 1993. [57] International Organization for Standards, “The Ottawa Report on Reference Models for Manufacturing Standards,” ISO TC184/SC5/WG1 N51, Version 1.1, 1986. [58] National Research Council (U.S.) Unit Manufacturing Process Research Committee, Unit Manufacturing Processes: Issues and Opportunities in Research. Washington, DC: National Academy Press, 1994. [59] J. Hoskins, “Personal Communication,” Personal Communication, May 9 1994. [60] L. Overgaard, H. G. Petersen and J. W. Perram, “Reactive Motion Planning: A Multiagent Approach,” Applied Artificial Intelligence, vol. 10, no. 1, 1996, pp. 35-51.


34

May 8, 1998

[61] A. D. Baker and M. E. Merchant, “Automatic Factories: How Will They Be Controlled,” IEEE Potentials, vol. 12, no. 4, December 1993, pp. 15-20. [62] J. D. Wisner, “How Does Your Shop Stack Up?,” Modern Machine Shop, vol. 66, no. 2, September 1993, pp. 86-90. [63] S. A. Melnyk, D. M. Lyth, P. L. Carter, et al., “Shop Floor Control at the Leading Edge: A Survey Analysis,” in American Institute for Decision Science 1984 Conference Proceedings, pp. 464-466. [64] S. S. Panwalkar and W. Iskander, “A Survey of Scheduling Rules,” Operations Research, vol. 25, no. 1, JanFeb 1977, pp. 45-61. [65] J. J.H. Blackstone, D. T. Phillips and G. L. Hogg, “A State-of-the-Art Survey of Dispatching Rules for Manufacturing Job Shop Operations,” International Journal of Production Research, vol. 20, no. 1, 1982, pp. 27-45. [66] R. W. Conway, W. L. Maxwell and L. W. Miller, Theory of Scheduling. Boston, MA: Addison-Wesley Publishing Co., 1967. [67] M.-H. Han and L. F. McGinnis, “Workflow Control for Maximum Throughput Rate in Manufacturing Cells,” Material Handling Research Center, Georgia Tech. Technical Report MHRC-TR-86-01, Atlanta, GA, February 24, 1989. [68] M.-H. Han and L. F. McGinnis, “Real Time Workflow Control for Integrated Multistage Manufacturing Cells,” Material Handling Research Center, Georgia Tech. Technical Report MHRC-TR-86-02, Atlanta, GA, February 24, 1989. [69] M. J. Shaw and A. B. Whinston, “Task Bidding and Distributed Planning in Flexible Manufacturing,” in Proceedings of the Second IEEE Conference on Artificial Intelligence Applications, Miami Beach, FL, Dec 11-13, pp. 184-189. [70] M. J. Shaw, “Dynamic Scheduling in Cellular Manufacturing Systems: A Framework for Networked Decision Making,” Journal of Manufacturing Systems, vol. 7, no. 2, 1988, pp. 83-94. [71] M. J. P. Shaw and A. B. Whinston, “Distributed Planning in Cellular Flexible Manufacturing Systems,” Management Information Research Center Technical Report, Purdue University, West Lafayette, IN, 1983. [72] J.-P. Shaw, “The Design of a Distributed Knowledge-based Approach for the Intelligent Manufacturing Information System,” Ph.D. Thesis, West Lafayette, IN: Purdue University, 1984. [73] M. Shaw, “A Two-Level Planning and Scheduling Approach for Computer Integrated Manufacturing,” in Proceedings of the NBS Symposium on Real-Time Optimization in Automated Manufacturing Facilities, Gaithersburg, MD, January 21-22, 1986, pp. 185-195. [74] M. J. Shaw, “A Distributed Scheduling Method for Computer Integrated Manufacturing: The Use of Local Area Networks in Cellular Systems,” International Journal of Production Research, vol. 25, no. 9, 1987, pp. 12851303. [75] M. J. Shaw and A. B. Whinston, “Learning and Adaptation in a Distributed Artificial Intelligence System,” in 1988 Workshop on Distributed Artificial Intelligence, Lake Arrowhead, CA, May 22-25, 1988, [76] N. A. Duffie and R. S. Piper, “Non-Hierarchical Control of a Flexible Manufacturing Cell,” in Proceedings of the International Conference on Intelligent Manufacturing Systems, Budapest, Hungary, June 16-19, 1986, pp. 5154. [77] N. A. Duffie and R. S. Piper, “Nonhierarchical Control of Manufacturing Systems,” Journal of Manufacturing Systems, vol. 5, no. 2, 1986, pp. 137-139. [78] N. A. Duffie and R. S. Piper, “Non-Hierarchical Control of a Flexible Manufacturing Cell,” Robotics & Computer-Integrated Manufacturing, vol. 3, no. 2, 1987, pp. 175-179. [79] N. A. Duffie, R. Chitturi and J.-I. Mou, “Fault-tolerant Heterarchical Control of Heterogeneous Manufacturing System Entities,” Journal of Manufacturing Systems, vol. 7, no. 4, 1988, pp. 315-327. [80] D. M. Upton, “The Operation of Large Computer Conrolled Manufacturing Systems,” Ph.D., West Lafayette, IN: Industrial Engineering Department, Purdue University, December 1988. [81] K. J. Tilley and D. J. Williams, “Modeling of Communications and Control in an Auction-based Manufacturing Control System,” in Proceedings of the 1992 IEEE International Conference on Robotics and Automation, Nice, France, May pp. 962-967. [82] K. J. Tilley, “Performance of Computer Communications for Manufacturing,” Ph.D., Cambridge, England: Cambridge University, August 1991.


35

May 8, 1998

[83] K. J. Tilley, “Machining Task Allocation in Discrete Manufacturing Systems,” in Market-Based Control: A Paradigm for Distributed Resource Allocation, S. H. Clearwater, Ed. Reading, MA: Addison-Wesley, 1996. [84] G. Y.-J. Lin and J. J. Solberg, “Flexible Routing Control and Scheduling,” in Proceedings of the Third ORSA/TIMS Conference on Flexible Manufacturing Systems, K. E. Stecke and R. Suri, Eds., July 1989, Elsevier, Amsterdam pp. 155-160. [85] G. Y.-J. Lin and J. J. Solberg, “Effectiveness of Flexible Routing Control,” International Journal of Flexible Manufacturing Systems, vol. 3, no. 3/4, June 1991, pp. 189-212. [86] G. Y.-J. Lin and J. J. Solberg, “Integrated Shop Floor Control Using Autonomous Agents,” I I E Transactions, vol. 24, no. 3, July 1992, pp. 57-71. [87] G. Y. Lin, “An Opportunistic Price-Based Multiple-resource and Part Scheduling,” Ph.D., West Lafayette, IN: School of Industrial Engineering, Purdue University, August 1992. [88] J. J. Ting, “A Cooperative Shop-Floor Control Model for Computer-Integrated Manufacturing,” in Proceedings of CIMCON ‘90, A. Jones, Ed. Gaithersburg, MD, May, NIST Special Publication 785, pp. 446-465. [89] M. R. Garey and D. S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness. New York, NY: W. H. Freeman and Company, 1979. [90] J. K. Lenstra and A. H. G. R. Kan, “Complexity of Scheduling Under Precedence Constraints,” Operations Research, vol. 26, no. 2, January-February 1978, pp. 22-35. [91] T. Gonzalez and S. Sahni, “Flowshop and Jobshop Schedules: Complexity and Approximation,” Operations Research, vol. 26, no. 1, January-February 1976, pp. 36-52. [92] M. R. Garey, D. S. Johnson and R. Sethi, “Complexity of Flow Shop and Job Shop Scheduling,” Mathematics of Operations Research, vol. 1, no. 2, May 1976, pp. 117-129. [93] K. E. Batcher, “Sorting Networks and Their Applications,” in AFIPS Spring Joint Computer Conference, vol. 32, 1968, Montvale, NJ: AFIPS Press pp. 307-314. [94] R. McNaughton, “Scheduling with Deadlines and Loss Functions,” Management Science, vol. 6, 1959, pp. 1-12. [95] E. Dekel and S. Sahni, “Binary Trees and Parallel Scheduling Algorithms,” IEEE Transactions on Computers, vol. C-32, no. 3, March 1983, pp. 307-315. [96] E. Dekel and S. Sahni, “Parallel Scheduling Algorithms,” Operations Research, vol. 31, no. 1, JanuaryFebruary 1983, pp. 24-49. [97] J. R. Jackson, “Scheduling a Production Line to Minimize Maximum Tardiness,” UCLA Technical Report Management Sciences Research Project Report 43, Los Angeles, CA, 1955. [98] L. Schrange, “Scheduling,” in Encyclopedia of Computer Science and Technology, vol. 13, J. Belzer, A. G. Holzman and A. Kent, Eds. New York, NY: Marcel Dekker, pp. 58-78, 1979. [99] J. M. Moore, “An N Job One Machine Sequencing Algorithm for Minimizing the Number of Late Jobs,” Management Science, vol. 15, 1968, pp. 102-109. [100] E. L. Lawler, “A ‘Pseudopolynomial’ Algorithm for Sequencing Jobs to Minimize Total Tardiness,” Annals of Discrete Mathematics, vol. 1, 1977, pp. 331-342. [101] W. E. Smith, “Various Optimizers for Single-Stage Production,” Naval Research Logistics Quarterly, vol. 3, 1956, pp. 59-66. [102] S. M. Johnson, “Optimal Two-and-Three Stage Production Schedules with Setup Times Included,” Naval Research Logistics Quarterly, vol. 1, 1954, pp. 61-68. [103] J. R. Jackson, “An Extension of Johnson’s Results on Job-Lot Scheduling,” Naval Research Logistics Quarterly, vol. 3, no. 3, September 1956, pp. 201-224. [104] E. Horowitz and S. Sahni, “Exact and Approximate Algorithms for Scheduling Nonidentical Processors,” Journal of the Association for Computing Machinery, vol. 23, no. 2, April 1976, pp. 317-327. [105] J. Bruno, E. G. Coffman, Jr. and R. Sethi, “Algorithms for Minimizing Mean Flow Time,” in IFIP Congress ‘74, 1974, North-Holland Publishing Company Amsterdam, pp. 504-510. [106] F. S. Roberts, Applied Combinatorics. Englewood Cliffs, NJ: Prentice-Hall, 1984. [107] Y. Tabourier, “All Shortest Distances in a Graph. An Improvement to Dantzig’s Inductive Algorithm,” Discrete Mathematics, vol. 4, 1973, pp. 83-87.


36

May 8, 1998

[108] R. W. Floyd, “Algorithm 97: Shortest Path,” Communications of the ACM, vol. 5, 1962, pp. 345. [109] G. B. Dantzig, “All Shortest Routes in a Graph,” in Symposium on Graph Theory, Rome, Italy, 1966, pp. 91-92. [110] E. W. Dijkstra, “A Note on Two Problems in Connection with Graphs,” Numerical Mathematics, vol. 1, 1959, pp. 269-271. [111] E. Dekel, D. Nassimi and S. Sahni, “Parallel Matrix Graph Algorithms,” SIAM Journal of Computing, vol. 10, no. 4, 1981, pp. 657-675. [112] R. K. Ghosh and G. P. Bhattacharjee, “Parallel Algorithm for Shortest Paths,” IEE Proceedings, vol. 133, Pt. E, no. 2, March 1986, pp. 87-93. [113] P. Mateti and N. Deo, “Parallel Algorithms for the Single Source Shortest Path Problem,” Computing, vol. 29, 1982, pp. 31-49. [114] S. E. Ritter and K. Soumyanath, “An Analog Parallel Distributed Soluon to the Shortest Path Problem,” in 1990 IEEE International Conference on Computer Design: VLSI in Computers & Processors, Cambridge, MA, September 17-19, pp. 130-134. [115] K. N. Levitt and W. T. Kautz, “Cellular Arrays for the Solution of Graph Problems,” Communications of the ACM, vol. 15, no. 9, 1972, pp. 789-801. [116] A. Moitra and S. S. Iyengar, “Discussion of Parallel Algorithms,” Department of Computer Science, Cornell University, Technical Report TR 86-759, Ithica, NY, 1986. [117] T. Mohr and C. Pasche, “A Parallel Shortest Path Algorithm,” Computing, vol. 40, 1988, pp. 281-292. [118] R. G. Gallager, “A Minimum Delay Routing Algorithm Using Distributed Computation,” IEEE Transactions on Communications, vol. COM-25, no. 1, January 1977, pp. 73-85. [119] E. G. Coffman, M. R. Garey and D. S. Johnson, “An Application of Bin-Packing to Multiprocessor Scheduling,” SIAM Journal of Computing, vol. 7, no. 1, February 1978, pp. 1-17. [120] R. M. Karp, “Reducibility Among Combinatorial Problems,” in Complexity of Computer Computations, R. E. Miller and J. W. Thatcher, Eds. New York, NY: Plenum Press, pp. 85-103, 1972. [121] K. D. Lawrence and S. H. Zanakis, Production Planning and Scheduling: Mathematical Programming Applications. Norcross, GA: Industrial Engineering and Management Press, 1984. [122] T. A. Ciriani and R. C. Leachman, Optimization in Industry: Mathematical Programming and Modeling Techniques in Practice. Chichiester, England: John Wiley & Sons Ltd., 1993. [123] L. Schrage, LINDO: An Optimization Modeling System. South San Francisco, CA: The Scientific Press, 1991. [124] L. G. Khachian, “A Polynomial Algorithm in Linear Programming,” Dokl. Akad. Nauk. SSSR, vol. 244, 1979, pp. 1093-1096 (in Russian). English translation in Soviet Math. Dokl. vol. 20, 1979, pp. 191-194. [125] N. Karmarkar, “A New Polynomial-Time Algorithm for Linear Programming,” Combinatorica, vol. 4, 1984, pp. 373-395. [126] I. Borosh and L. B. Treybig, “Bounds on Positive Integral Solutions of Linear Diophantine Equations,” Proceedings of the American Mathematical Society, vol. 55, 1976, pp. 299-304. [127] S. Sahni, “Computationally Related Problems,” SIAM Journal of Computation, vol. 3, 1974, pp. 262-279. [128] W. J. Davis and A. T. Jones, “A Real-Time Production Scheduler for a Stochastic Manufacturing Environment,” International Journal on Computer Integrated Manufacturing, vol. 1, no. 2, April-June 1988, pp. 101-112. [129] G. Brassard and P. Bratley, “Probabilistic Algorithms,” in Algorithmics: Theory and Practice, B. Brassard and P. Bratley, Eds. Englewood Cliffs, NJ: Prentice Hall, pp. 223-276, 341-351, 1988. [130] S. Sahni and E. Horowitz, “Combinatorial Problems: Reducibility and Approximation,” Operations Research, vol. 26, no. 5, September-October 1978, pp. 718-759. [131] C. Lund and M. Yannakakis, “On the Hardness of Approximating Minimization Problems,” Journal of the Association for Computing Machinery, vol. 41, no. 5, September 1994, pp. 960-981. [132] C. H. Papadimitriou and M. Yannakakis, “Optimization, Approximation, and Complexity Classes,” Journal of Computer and System Sciences, vol. 43, 1991, pp. 425-440.


37

May 8, 1998

[133] N. Christofides, “Worst-Case Analysis of a New Heuristic for the Traveling Salesman Problem,” in Algorithms and Complexity, J. Traub, Ed. New York, NY: Academic Press, 1976. [134] R. L. Graham, “Bounds for Certain Multiprocessing Anomalies,” The Bell System Technical Journal, vol. 45, no. 9, November 1966, pp. 1563-1581. [135] D. S. Johnson, A. Demers, J. D. Ullman, et al., “Worst-Case Performance Bounds for Simple OneDimensional Packing Algorithms,” SIAM Journal on Computing, vol. 3, 1974, pp. 299-325. [136] D. S. Johnson, “Near-Optimal Bin Packing Algorithms,” Doctoral Thesis, Cambridge, MA: Department of Mathematics, Massachusetts Institute of Technology, 1973. [137] J. F. Shapiro, “A Survey of Lagrangean Techniques for Discrete Optimization,” Annals of Discrete Mathematics, vol. 5, 1979, pp. 113-138. [138] M. L. Fisher, “The Lagrangian Relaxation Method for Solving Integer Programming Problems,” Management Science, vol. 27, no. 1, January 1981, pp. 1-18. [139] C. A. Kaskavelis and M. C. Caramanis, “Application of a Lagrangian Relaxation Based Scheduling Algorithm to a Semiconductor Testing Facility,” in Proceedings of the Fourth International Conference on Computer Integrated Manufacturing and Automation Technology, Troy, NY, October 10-12, 1994, pp. 106-112. [140] P. B. Luh and D. J. Hoitomt, “Scheduling of Manufacturing Systems Using the Lagrangian Relaxation Technique,” IEEE Transactions on Automatic Control, vol. 38, no. 7, July 1993, pp. 1066-1079. [141] L. Gou, T. Hasegawa, P. B. Luh, et al., “Holonic Planning and Scheduling for a Robotic Assembly Testbed,” in Proceedings of the Fourth International Conference on Computer Integrated Manufacturing and Automation Technology, Troy, NY, October 10-12, 1994, pp. 142-149. [142] S. E. Ramaswamy and S. Joshi, “Distributed Control of Automated Manufacturing Systems,” in Proceedings of 27th CIRP International Seminar on Manufacturing Systems, Ann Arbor, MI, May 21-23 1995, [143] D. S. Johnson, C. R. Aragon, L. A. McGeoch, et al., “Optimization by Simulated Annealing: An Experimental Evaluation, Part II (Graph Coloring and Number Partitioning),” Operations Research, vol. 39, no. 3, 1991, pp. 378-406. [144] D. S. Johnson, C. R. Aragon, L. A. McGeoch, et al., “Optimization By Simulated Annealing: An Experimental Evaluation, Part I (Graph Partitioning),” Operations Research, vol. 37, no. 6, 1989, pp. 865-892. [145] S. Kirkpatrick, J. C.D. Gelatt and M.P. Vecchi, “Optimization by Simulated Annealing,” Science, vol. 220, no. 4598, May 13, 1983, pp. 671-680. [146] D. E. Goldberg, “Genetic and Evolutionary Algorithms Come of Age,” Communications of the ACM, vol. 37, no. 3, March 1994, pp. 113-119. [147] A. J. Underbrink, Jr. and G. P. W. Williams, Jr., “Genetic Algorithms Applied to Assembly Operations,” in Proceedings of the 1994 SPIE Conference KB AI Systems in Aerospace and Industry, SPIE Code Number 2244-04, [148] J. Biegel and J. Davern, “Genetic Algorithms and Job Shop Scheduling,” Computers and Industrial Engineering, vol. 19, no. 1, 1990, pp. 81-91. [149] L. Davis, “Job Shop Scheduling with Genetic Algorithms,” in International Conference on Genetic Algorithms and Their Applications, Pittsburgh, PA, 1985, pp. 136-140. [150] E. Falkenauer and S. Bouffouix, “A Genetic Algorithm for Job Shop,” in IEEE International Conferernce on Robotics and Automation, Sacramento, CA, April 9-11, 1991, pp. 824-829. [151] J. Kanet and V. Sridharan, “PROGENITOR: A Genetic Algorithm for Production Scheduling,” Wirtschaftsinformatik, vol. 33, no. 4, August 1991, pp. 332-336. [152] D. Whitley, T. Starkweather and D. Fuquay, “Scheduling Problems and the Traveling Salesman: The Genetic Edge Recombination Operator,” in Third International Conference on Genetic Algorithms and Their Applications, San Mateo, CA, 1989, pp. 133-140. [153] L. Rabelo and S. Alptekin, “Synergy of Neural Networks and Expert Systems for FMS Scheduling,” in Third ORSA/TIMS Conference on Flexible Manufacturing Systems, K. E. Stecke and R. Suri, Eds., Cambridge, MA, 1989, pp. 361-366. [154] L. Rabelo, “A Hybrid Artificial Neural Networks and Knowledge-Based Expert System Approach to Flexible Manufacturing System Scheduling,” Ph. D. Thesis, Rolla, MO: University of Missouri-Rolla, 1990.


38

May 8, 1998

[155] L. Rabelo, Y. Yih, A. Jones, et al., “Intelligent Scheduling for Flexible Manufacturing Systems,” in IEEE Robotics and Automation Conference, Atlanta, GA, 1993, [156] C. H. Dagli, S. Lammers and M. Vellanki, “Intelligent Scheduling in Manufacturing Using Neural Networks,” Journal of Neural Network Computing, Spring 1991, pp. 4-10. [157] C. Dagli and S. Sittisathanchai, “Genetic Neuro-Scheduler for Job Shop Scheduling,” Computers and Industrial Engineering, vol. 25, no. 1-4, 1993, pp. 267-270. [158] A. Jones and L. Rabelo, “Integrating Neural Nets, Simulation, and Genetic Algorithms for Real-Time Scheduling,” in Operations Research in Production Planning and Control, G. Fandel, T. Gulledge and A. Jones, Eds. Berlin, Germany: Springer-Verlag, pp. 550-566, 1992. [159] S. Toure, L. Rabelo and T. Velasco, “Artificial Neural Networks for Flexible Manufacturing Systems Scheduling,” Computers and Industrial Engineering, vol. 25, no. 1-4, 1993, pp. 385-388. [160] Y.-H. Lee and S. Kim, “Neural Network Applications for Scheduling Jobs on Parallel Machines,” Computers and Industrial Engineering, vol. 25, no. 1-4, 1993, pp. 227-230. [161] G. A. Tagliarini and E. W. Page, “Solving Constraint Satisfaction Problems with Neural Networks,” in Proceedings of the 1st IEEE International Conference on Neural Networks, San Diego, CA, June 1987, [162] B. Angeniol, G. Vaubois and J. Texier, “Self-Organizing Feature Maps and the Traveling Salesman Problem,” Neural Networks, vol. 1, 1988, pp. 289-293. [163] G. V. Wilson and G. S. Pawley, “On the Stability of the Traveling Salesman Problem Algorithm of Hopfield and Tank,” Biological Cybernetics, vol. 58, 1988, pp. 63-70. [164] Y.-P. S. Foo and Y. Takefuji, “Stochastic Neural Networks for Solving Job-Shop Scheduling,” in Proceedings of the IEEE International Conference on Neural Networks, San Diego, CA, 1988, pp. 275-290. [165] Y.-P. S. Foo and Y. Takefuji, “Integer Linear Programming Neural Networks for Job-Shop Scheduling,” in Proceedings of the IEEE International Conference on Neural Networks, San Diego, CA, 1988, pp. 341-348. [166] X. Xu and W. T. Tsai, “Effective Neural Algorithms for the Traveling Salesman Problem,” Neural Networks, vol. 4, 1991, pp. 193-205. [167] J. Hertz, A. Krogh and R. G. Palmer, in Introduction to the Theory of Neural Computation, Redwood City, CA: Addison-Wesley Publishing Co., pp. 71-79, 1991. [168] I. Arizono, A. Yamamoto and H. Ohta, “Scheduling for Minimizing Total Actual Flow Time by Neural Networks,” International Journal of Production Research, vol. 30, no. 3, 1992, pp. 503-511. [169] J. J. Hopfield and D. W. Tank, “‘Neural’ Computation of Decisions in Optimization Problems,” Biological Cybernetics, vol. 55, 1985, pp. 141-152. [170] D. W. Tank and J. J. Hopfield, “Simple ‘Neural’ Optimization Networks: An A/D Converter, Signal Decision Circuit, and a Linear Programming Circuit,” IEEE Transactions on Circuits and Systems, vol. 33, no. 5, 1986, pp. 533-541. [171] D. N. Zhou, V. Cherkassky, T. R. Baldwin, et al., “Scaling Neural Network for Job-Shop Scheduling,” in Proceedings of the International Joint Conference on Neural Networks, vol. 3, 1990, pp. 889-894. [172] D. N. Zhou, V. Cherkassky, T. R. Baldwin, et al., “A Neural Network Approach to Job-Shop Scheduling,” IEEE Transactions on Neural Networks, vol. 2, no. 1, 1991, pp. 175-179. [173] V. Cherkassky and D. N. Zhou, “Comparison of Conventional and Neural Network Heuristics for Job Shop Scheduling,” SPIE Vol. 1710 Science of Artificial Neural Networks, 1992, pp. 815-820. [174] A. B. Wright, “Basic Scheduling Techniques,” in American Production & Inventory Control Society 1983 Conference Proceedings, pp. 200-204. [175] T. J. Green, L. M. Clive, S. de Lurgio, H. Grant, and K. J. Hunt, “Loading Principles,” in Production and Inventory Control Handbook, 2nd Ed., J. H. Greene, Ed. New York, NY: McGraw-Hill, 1987, pp. 17.11-14. [176] E. M. Goldratt and R. E. Fox, The Race. Croton-on-Hudson, NY: North River Press, 1986. [177] E. M. Goldratt, Theory of Constraints. Croton-on-Hudson, NY: North River Press, 1990. [178] E. M. Goldratt, The Goal: A Process of Ongoing Improvement. Great Barrington, MA: North River Press, 1992. [179] A. D. Baker, “Manufacturing Control with a Market-Driven Contract Net,” Electrical, Computer and Systems Engineering Department PhD Thesis, Troy, NY: Rensselaer Polytechnic Institute, May 1991.


39

May 8, 1998

[180] A. D. Baker, “Case Study Results with the Market-Driven Contract Net Manufacturing Computer-Control Architecture,” in AUTOFACT ‘92, Detroit, MI, November 8-12 1992, pp. 31.17-31.35. [181] A. D. Baker, “Metaphor or Reality: A Case Study where Agents Bid with Actual Costs to Schedule a Factory,” in Market-Based Control: A Paradigm for Distributed Resource Allocation, S. H. Clearwater, Ed. Reading, MA: Addison-Wesley, 1996. [182] A. D. Baker, “Complete Manufacturing Control Using a Contract Net: A Simulation Study,” in 1988 International Conference on Computer Integrated Manufacturing, troy, NY, pp. 100-109. [183] D. MacFarland and H. Grant, “Shop Floor Scheduling and Control Using Simulation Technology,” in Shop Control ‘87 Conference Proceedings, Cincinnati, OH, March 3-5 pp. 12-1 through 12-11. [184] A. Kusiak and M. Chen, “Expert Systems for Planning and Scheduling Manufacturing Systems,” European Journal of Operational Research, vol. 34, 1988, pp. 113-130. [185] M. Zweben and M. S. Fox, Intelligent Scheduling. San Francisco, CA: Morgan Kaufmann, 1994. [186] K. P. Sycara, S. F. Roth, N. Sadeh, et al., “Resource Allocation in Distributed Factory Scheduling,” IEEE Expert, vol. 6, no. 1, February 1991, pp. 29-40. [187] E. A. Silver, “Operations Research in Inventory Management: A Review and Critique,” Operations Research, vol. 29, no. 4, July-August 1981, pp. 628-645. [188] A. C. Hax and D. Candea, “Chapter 4: Inventory Management,” in Production and Inventory Management, Englewood Cliffs, NJ: Prentice Hall, pp. 125-255, 1984. [189] J. T. Black, The Design of the Factory with a Future. New York, NY: McGraw-Hill, Inc., 1991. [190] S. Shingo, A Study of the Toyota Production System from and Industrial Engineering Viewpoint, Revised Edition. Cambridge, MA: Productivity Press, 1989. [191] J. P. Womack, D. T. Jones and D. Roos, The Machine that Changed the World. New York, NY: HarperCollins Publishers, 1991. [192] C. Schelberg, Personal Communication, 1992. [193] G. Stafford, Personal Communication, 1993.

Albert D. Baker has worked in the field of agent-based factory control for over a decade. This has spanned work in the Factory Control and Scheduling Group at the General Motors Technical Center, in the Control Systems Laboratory at the GE Corporate Research and Development Center, as a Hewlett Packard/AEA Fellow in Rensselaer Polytechnic Institute’s (RPI’s) Center for Manufacturing Productivity, and as a faculty member in the Electrical & Computer Engineering and Computer Science Department at the University of Cincinnati. Dr. Baker developed the first successful implementation of a heterarchical multi-agent scheduling system as a part of his doctoral dissertation from RPI. He has co-led the development of the AARIA agent-architecture which demonstrates a heterarchical agent-based factory scheduling system at Rock Island Army Arsenal (a DARPA project funded through Intelligent Automation of Rockville, MD). He is continuing work in areas of multi-agent coordination, multi-agent implementation platforms, simulation of agent-based systems, use of agents for self-configuring robotic weld cells, and personal assistant agents. Dr. Baker has also worked as a summer faculty scholar in the United States Air Force Manufacturing Technology (ManTech) Directorate, in the Treasurer’s Office at Cincinnati Milacron, and as a design engineer, test engineer, and manufacturing engineer in the GE Major Appliance Business. He has earned degrees from Rensselaer Polytechnic Institute, Harvard University, The University of Michigan, and Rice University