kanban: 12/15/'94

Some kanban{controlled manufacturing systems: a rst stability analysis

Department of Mathematics and Statistics University of Maryland Baltimore County Baltimore, MD 21228, USA
(410)-455-2438 e-mail: hseidman@math.umbc.edui

Thomas I. Seidman

and Instituto de Matematica e Estatistica Universidade de S~ ao Paulo Departamento de Ci^ encia de Computac~ ao Universidade de S~ ao Paulo S~ ao Paulo, SP, Brasil
e-mail: hhumes@ime.usp.bri

Carlos Humes Jr.

ABSTRACT:

The blockage/starvation patterns of known instability examples suggest using local demand information | which is precisely what is provided by the widely advocated kanban approach to ow control in manufacturing systems. Therefore, we have re-analyzed for stability the examples described in the 1990 Kumar{Seidman paper when modi ed by introducing kanban control. It is found that this does not ensure stability and, in fact, some surprising new instability phenomena arise. manufacturing systems, instability, kanbans, decentralized, scheduling

control.

Key Words:

1.

The stability of various decentralized scheduling policies for manufacturing systems has been explored in numerous papers 10], 6], 8], 3], 9], 5], 12], 7], 11], 1]. We note that all of these analyses (except 12]) have concerned themselves with what we may call ow-driven systems in which the scheduling of each machine is dependent only on the contents of the product bu ers and such locally available information as might be carried by this product ow. In observing that the ow blockages occurring in known instability examples 6], 11], 1] might be alleviated by informing a supplier of impending `starvation', one is led to conjecture a likelihood of greater stability for demand-driven systems, with dual ows of product and of controlling orders. This conjecture is somewhat strengthened by the popularity of one such approach, the kanban, as a scheduling control mechanism. We note that kanban systems have been widely advocated and widely implemented although, to the best of our knowledge, there has been no mathematically rigorous analysis of their stability properties. Thus we are led to test the e cacy of the kanban structure as a possible stabilizing control mechanism speci cally against the challenge posed by the context of CAF policies within which were found the rst two known instability examples for ow-driven systems. The results of our investigation turn out to be interesting and somewhat unanticipated: they surprised us. For the rst example from 6] one nds that the kanban structure has little e ect on the instability mechanism: as for the ow-driven case analyzed in 6] and for the identical parameter range one develops a pattern of mutual blockage which repeats on an ever-increasing scale. What is new, here, is a threshhold e ect for the initiation of this pattern, with the threshhold increasing when the number of kanbans for the links, i.e., the speci ed reserve supply levels, would be increased. For the second example from 6], involving a single re-entrant line, one obtains with kanban operation a threshhold e ect again and also a new instability criterion: + > 1 with < 1. Here, although one does not always have stability, more of the parameter space now corresponds to the stable range; compare (3.1). Since depends on a ratio of kanban speci cations, we have the surprising fact that increasing the reserve supply level for some link may actually have the e ect of destabilizing the system as a whole. Further, for this example we see a previously unobserved instability mechanism in which operation is essentially time-periodic, except for a single unboundedly growing demand bu er, rather than repeating on an increasing scale. Finally, noting that it had been shown 10] that CAF policies are always stable for acyclic ow-driven systems, we attempted to obtain the corresponding result using
1 2

Introduction

This is taken in tems of the \slow" processing times ; | which in 6] determined the stability/instability according as + < 1 or > 1 when one normalizes to have unit demand rates. 2 This corresponds, roughly, to a protective indi erence to operational uctuations and limited burstiness of the input ow | here, demand rather than product arrivals. We have indicated this brie y | and suggest that this may explain why, with on-line tuning, instability is not observed in practice | but in this paper we have not attempted any formal analysis or proof of this e ect.
1

the kanban structure | and, instead, obtained our Example C, demonstrating the possibility of instability in this setting as well.

2.

We are considering a model for ow in a manufacturing system which, in many respects, follows the formulation of 10], etc. Thus, we have a nite set of tasks, indexed by i, with each task assigned to a machine Mm; we write m(i) for the machine index m associated with the task i and correspondingly write i 2 Mm, identifying the machine with the set of its assigned tasks. Further, each task i is associated with a product stream Pp corresponding to a material ow of (items of) some product indexed by p = p(i). We assume a xed (pre-speci ed) sequencing of tasks within each product stream so the set Pp has a linear order (i ; : : : ; iJ ). We write i? and i+ for the predecessor and the successor (within Pp) of a task i, where this is meaningful, and denote by i (p) and i (p) the initial and terminal tasks, respectively. It may be possible to index the machines in such a way that one always has m(i+) m(i). In this case we call the system geometry acyclic; if there is no such ordering of the machines (as is the case for our Examples A and B), we call the geometry non-acyclic or re-entrant. For our examples we index the tasks so i? = i ? 1, etc., but this is inessential.] The standard paradigm of queueing theory, followed in 10], etc., presumes a sequence of arrivals at the initial task of each product stream with the system `pushed' by the incoming ow to maintain production. Our present paradigm is to reverse this so processing will only be done `as ordered' | i.e., we presume a sequence of orders arriving to the terminal task of each product stream and view ourselves as processing orders which are transmitted in the product stream geometry in the direction opposite to our task sequencing and which `pull' the concommittant ow and processing of product. To specify the operation of the manufacturing system it is now necessary to specify both the protocol for transmitting orders within the system and also the scheduling protocol for processing products at each machine when there may be competing tasks. While this `pull' framework provides attractive alternatives to the `push systems' analyzed in 10], etc., it is clear that the analysis is now complicated by the necessity to provide two sets of protocols and to track two ows through the system: of orders and of products. We note also that the double ow can be expected to blur the distinction between acyclic geometries (which will no longer possess the inductive causality they have for `push' systems) and non-acyclic geometries. In general, for pull systems, one will have for each task both a `demand bu er' of as-yet-unful lled orders and a bu er of product available for processing. For present purposes we make no further di erentiation (e.g., as to `urgency') and it will be su cient for our analysis to note only the levels of these bu ers; thus, ki (t) will denote the number of orders awaiting (at time t) processing for task i, while xi(t) will denote the `supply level' of available product there. The kanban mechanism is a standard protocol for transmitting orders: it assumes speci cation of a reserve supply level Ki so that orders (kanbans) are transmitted from
1 3

Kanban systems: formulation and notation

Physically, one thinks of a xed number Ki of `tokens' (or `order cards', to take a somewhat more

i to i? as xi(t) drops below Ki . One might have some initial stock above the reserve supply level which would be utilized without replacement but, after that, one always has the identity (2.1) xi(t) + ki? (t) Ki (where we ignore any transit times for product or kanbans). This identity is to hold for all tasks which have internal suppliers, i.e., which are not the initial tasks for product streams. For an initial task, we will suppose that product is always available as needed | e ectively, that xi p (t) 1, although we do not count this as `work-in-process' (WIP). For a terminal task, the demand bu er does not consist of internally issued kanbans but of external demand and, without any equivalent of (2.1), we write
( )

(2.2)

ki p (t) =: zp(t):
( )

We denote by Xi (t) the total (cumulative) number of items of product processed at task i by time t and, similarly, we denote by Zp(t) the total number of orders received at i (p) by time t, including any unful lled demand present in the system at the initial time. Then, for t > s, simple bookkeeping gives (2.3) (2.4) (2.5)

Xi? (t) ? Xi? (s) = Xi(t) ? Xi (s)] + xi(t) ? xi(s)]: ki(t) ? ki (s)] + Xi (t) ? Xi (s)] = Xi (t) ? Xi (s)
+ +

for each intermediate task i or, equivalently for the task i+ in view of (2.1), For terminal tasks we have, instead,

zp(t) ? zp(s)] + Xi p (t) ? Xi p (s)] = Zp(t) ? Zp (s)]:

( ) ( )

In general, a processing protocol (scheduling policy) will schedule the activity of each machine Mm in terms of the values of fki ; xi : i 2 Mmg. For our present purposes, we will be considering scheduling policies in which a single task can be enabled at any time. We then distinguish three types of possible states !m(t) : Ai (task i is enabled and active) Ii (task i is enabled but inactive: the machine is `waiting') Sii0 (task i is `becoming enabled' in transition from the prior enabled task i0)
literal translation of the Japanese word `kanban') which would be attached to the stock of product at i when this is at its desired reserve level. When an item of this stock is utilized, the attached token is removed from the product item and transmitted as an order to the `supplier' (predecessor) i?, to be returned attached to the replacement item when that order is ful lled to resupply the reserve. See, e.g., Chapter 13 of 2] for a more detailed description; our model is there called a `one card' kanban system. An alternative interpretation occurs in the Queueing Theory literature as a discipline `with blocking': there one may assume that the supply bu er for task i has capacity Ki and that the prior server is `blocked' (from task i?) if this bu er is already full. One easily sees that this is precisely equivalent to the kanban mechanism for this link.

A task i 2 Mm can be active (!m = A i ) only if it is available (meaning that both 0 i ki(t) > 0 and xi(t) > 0). The state Si represents a setup period for the transition, which we assume has xed length (setup time) i0;i 0. We assume that the policy is non-idling, i.e., that no machine Mm will be idling (inactive: !m = Ii for some i) unless it is blocked (meaning that none of the tasks at Mm is currently available). We also assume that we will not make a transition from i0 to i unless the new task i is available. A clearing policy is one in which we further assume that we never make such a transition unless the previously enabled task i0 has become unavailable, i.e., once some task i 2 Mm is `enabled', the machine Mm is committed to continue working exclusively at the task i (one has !m = Ai) until one of the relevant bu ers (of orders or of available product) becomes exhausted. One principal motivation for clearing policies is that one may realistically have a substantial set-up time incurred when switching from one task to another and one then needs runs long enough to amortize the e ect of this enforced nonproductive interval. Associated with each task i is a processing time i so, for any time interval (r; s), one has (2.6) i (r; s) := meas ft 2 (r; s) : !m (t) = Ai g = i Xi (s) ? Xi (r)] and for each machine M = Mm one has X X (2.7) s?r i (r; s) = i Xi (s) ? Xi (r)] :
4

i2M

i2M

We assume a (constant) demand rate dp > 0 for each product stream (mean arrival rate of orders to i (p)) so (2.8) Zp(t) ? Zp(s) = dp (t ? s) (t > s) as closely as would be possible working with integers | or, more generally, that there is some `burstiness constant' M 1 for which (2.9) j Zp(t) ? Zp (s)] ? dp (t ? s)j M: For the system to be stable (each zp( ) uniformly bounded), each Xi ( ) must track Zp i ( ) with bounded lag so, for long time intervals, one must have Xi(s) ? Xi (r) dp i (s ? r). In view of (2.7), a corollary to this is the necessity for stability of the capacity condition X (2.10) dp i i < 1 (each m). m :=
( ) ( )

i2Mm

( )

What one would like, of course, is a stability result that | for any system using the protocols under consideration, any initial conditions, and any demand inputs Zp( )
The `minimum assured run length', starting at t, is thus min fki(t); xi(t)g, without assuming any further input. In any case, at the moment one of the bu ers empties some other task will be enabled, providing there is one available; otherwise the machine Mm necessarily idles until it does become possible to enable some other task. If several alternative tasks are available for enabling, one solution principle would be that the assured run length is at least some speci ed fraction > 0 of the largest assured run lengths among the alternatives; such a policy is referred to as CAF (Clear A Fraction). For our Examples A and B, there are only two tasks at each machine so all clearing policies are the same and there is no need to specify such a selection procedure.
4

satisfying (2.9), subject to (2.10) | one would have each zp( ) bounded (uniformly in time t > 0). The point of this paper is that there are quite simple and `natural' systems for which this is false when using a kanban mechanism to transmit orders with a clearing policy to schedule production.

3.

To study the question of stability of systems operating with kanbans we shall start by analysing systems that have already been shown to be unstable under ow-driven clearing policies. The earliest known examples were the two presented in 6]. Each
1 4

Three examples

a c

2 3

c a

1 4

a c

2 3

c a

Example A

Example B

example is a system with two machines, each with two tasks. In each machine there is a comparatively slower task (indicated by an open dot in the gure). In 6], it was shown that, under unit input rates, instability was obtained if the processing times satis ed an `instability condition' (3.1) + > 1: Those examples were themselves a response to the earlier general conjecture of stability of systems operating under CAF, presented in 10], where stability was proved for acyclic networks. For our present analysis | of systems under a clearing policy for production, much as in 6], and with order transmission now governed by a kanban mechanism | we assume the geometries, the demand rates, and the processing times for tasks are xed, the reserve supply levels (numbers of kanbans) for each link then chosen in some fashion. This speci es a well-de ned dynamical system. We then assume that the initial conditions (from which we begin tracking the scenarios) may be imposed arbitrarily. To simplify the exposition, we normalize to unit demand rates and assume negligible burstiness, i.e., each dp = 1 and M = 1 in (2.9). For the rst two examples we also neglect set-up times, taking each i0;i = 0. In this case we can use a simpli ed set of activity states: we write um = i rather than !m = Ai and write um = when Mm is blocked; the vector u = (u ; u ) then gives the complete activity state for the system as a whole.
1 2

3:A.

The rst example is a two product system with two machines, corresponding to Example A above. As in 6], we shall consider that \fast" tasks feed \slower" tasks, i.e., given = ( ; ; "; ), we have ; " ; . The idea of reserve supply level applies only to tasks 2 and 4 and the corresponding numbers of available kanbans are respectively K and K ; to avoid some expositional complications, we assume that K ; K > 2.
2 4 2 4

Two product streams

M
1

s f

M
k
1

2 3

f s

z 1

Example A We begin tracking this system at a moment t corresponding to the completion at M of a clearing run for task 4 due to exhaustion of the demand bu er there, i.e., z (t ) = 0. As initial condition, we assume that we have
0 1 2 0

(3:A.1)
0

x = K ; k = 0; for P and x = 0; k = K for P

4 4 3 2 2 1 2 1 0

at t = t with `large' unful lled demand z (t ) = A. At this initial moment M is necessarily idle (with task 2 starved for supplies and task 3 starved for demand), so the control state has just become u(t ) = (1; ). The now-enabled operation of task 1, with its rapid processing time, means that supply is quickly provided to task 2, enabling u = 2 at time t + . We are looking for a scenario in which the clearing run just initiated at M will end by exhaustion of the unful lled demand z . This run terminates at the time t + T and n new orders will have arrived for P by then: M will have processed A + n items, taking time T ? = (A + n) to make z = 0. To within an uncertainty of at most 1 order (corresponding to the uncertain relation of the times t and t + + T to the exact arrival times for the orders; compare (2.9) with d = 1, M = 1), we have n T so, for , one has (3:A.2) T A =(1 ? ): Of course, to have such a scenario requires that the product bu er at task 2 should never become exhausted during this interval (x > 0) and we must determine conditions ensuring this. It should be emphasized that we make no claim that these conditions are actually necessary for instability, only that we will have shown an instability example when they do hold. With task 1 enabled at M and , it is clear that the clearing run at task 1 ends long before t + T . Indeed, M will process (K + A + n) items in the interval t ; t + T ], taking total time (K + A + n) which will be much less than T ? = (A + n) if, say, A > K . Thus, since T will be large for A large, there must be (approximately) n arrivals at task 4 of orders for the P demand bu er so task 4 will certainly become enabled. To ensure that the scenario does proceed as we are describing it, it is only necessary to ensure that task 4 never has a clearing run long enough for processing at task 2 to empty its reserve supply bu er while task 1 is being temporarily blocked | i.e., since we necessarily have x = K at the beginning of such an `intermediate' run at
2 0 2 0 2 1 0 1 2 1 0 0 1 2 1 0 1 2 0 0 2 2 2 2 2

task 4, we must ensure that (3:A.3)

run length] + :
4

Since we are considering a period during which task 3 is blocked by task 2, the length of any run at task 4 is necessarily bounded by K ; however, this bound is inadequate for our purpose without imposing undesirable conditions on the choices of K ; K in relation to ; . Alternatively, the run length here can be bounded in terms of the length T of the preceding clearing run with u = (1; 2) which ends when the demand bu er at task 1 is exhausted. This will be longest for the rst run at task 1, since that commences with k having its maximum value K . M then processes the K items already (initially) ordered at task 1 but, meanwhile, new orders will have been received from M so this run corresponds to processing K + n0 items, taking time T := (K + n0). This requires, of course, that n0 kanbans are received to task 1 from M so (n0 ? 1) items must have been completed at task 2, taking time (n0 ? 1). Thus,
2 4 1 1 2 1 2 2 2 1 2 2

(3:A.4)
2

+ j (n0 ? 1) < (K + n0) =: jT k+ n0 k i.e., n0 = (K ? 1) ? ; T = K2?? K

2 1 2 1 2

Letting T be the time for which one then has u = (4; 2), we see that T = n00 where n00 is the number of orders arriving for P during the interval since task 4 was previously cleared. To within an uncertainty of 1 order, we have n00 T + T ( K +T) so T =(1 ? )] K . Comparing this to the requirement (3:A.3), we see that | essentially independently of the size of K | we need small enough to have
2 1 2 2 2 2 2 2

1? < to ensure that the scenario proceeds here as described. We now consider the situation at the time t = t + T when the demand bu er at task 2 is nally emptied. If A was initially large, making T proportionately large by (3:A.2), there will have been plenty of slack time at M to have not only kept x K but also to have, altogether, cleared the reserve supply at task 4 of its original K items | necessarily unreplenished because task 3 has been blocked throughout. As already noted, the number of orders arriving for P during this period will also have been approximately the same n T as for P so that the unful lled demand is then (3:A.5)
1 0 1 2 2 4 2 1

(3:A.6)
1

z (t ) =: A0 = n ? K
2 1

by (3:A.2). At t the state will thus be (3:A.7)

2 2 1 1 4

1? A?K
3

x = K ; k = 0; for P and x = 0; k = K for P

4

with z = (0; A0) and u = ( ; 3). This state is, of course, essentially a `mirror image' of the initial state and, assuming A0 is large enough, essentially the same argument mutatis mutandis shows that at a time 8

t we will again complete a clearing run at task 4 with the state given again by (3:A.1) and now with z = (A00; 0) where, as in obtaining (3:A.6), we now have
2

(3:A.8)
1 2 1 0

z (t ) =: A00
1 2

with

A0h? K i A? ? K +K := ? ? :
4 1 4 2 (1 )(1 ) 5

To have z (t ) > z (t ), we must then require that > 1 and that A is large enough that ( ? 1)A > 1 ? K + K : (3:A.9) Note that ? 1 = ( + ? 1)=(1 ? )(1 ? ) so (3:A.10) > 1 (giving instability) , + > 1: Asymptotically, we may eventually ignore the constant term =(1? )]K +K in (3:A.8) and see that each cycle repeats the same pattern with the unful lled demand multiplied repeatedly by the factor . Of course, the cycle time is also scaled proportionately, so the increase of unful lled demand will be approximately linear in time: the long-time average rate of increase of total WIP (z + z ) uctuates boundedly | although without a limit unless = > 1=2, in which case this is (2 ? 1= ). We observe that (3:A.10) is precisely the instability condition (3.1) of 6]. There is, however, an interesting di erence, which we term a threshhold e ect. If, rather than taking A large initially, we were to consider the system in operation subject to the burstiness condition (2.9), it is easy to see that a burst of demand permitted by (2.9) could also initiate the pattern described (if M is large enough) with the possibility that this might grow over some repetitions to the point where corresponding periods of reduced demand, also permitted by (2.9), could no longer interrupt the pattern. To the extent that the burstiness of (2.9) is random, one might expect this to occur (eventually) with probability 1 if possible at all. This possibility is essentially equivalent to having M larger than the minimal A described above, which increases with the Kj so, looking at the converse, the instability cannot occur if K ; K are large enough in comparison with a given M . This is consistent with the viewpoint of seeing kanbans as a stabilizing device to insulate the system from the e ect of sudden uctuations in demand.
4 2 4 2 1 2 2 4

3:B.

We next analyze stability under kanban control for the second example 6] under the assumption (3:B.1) + < ; which will be needed later to ensure that the scenario proceeds as described.
5
0

A single re-entrant line

We could think of this analysis as beginning at t1 and some simple algebra shows that the corresponding condition ( ? 1)A > 1 ? K2 + K4 : is precisely equivalent to (3:A.9).

M
1

s f

M
k
1

2 3

f s

$ %

Example B We begin tracking this system also at a moment t corresponding to the completion at M of a clearing run for task 4 | now due to exhaustion of the product bu er, i.e., x (t ) = 0. As initial condition, we assume that we have, then,
0 1 4 0

k = K ; x = 0; k = K ; x = 0; k = K ; x = 0 with `large' unful lled demand z(t ) = A. Note that at this initial moment M is necessarily idle (with both tasks starved for supplies), so the control state is u(t ) = (1; ), but the now-enabled operation of task 1, with its rapid processing time, means that supply is quickly provided to task 2, enabling u = 2, which we take as characterizing the rst phase of this scenario. Once task 1 is begun at M , it will clear the demand indicated by the initial condition k (t ) = K . Thus, noting that task 1 is assumed much faster than task 2, M will be adequately supplied to ensure that it will continue task 2 without interruption at least until completing minfK ; x (t ) = K g items | and, indeed, since task 3 is blocked during this and so cannot replenish the supply for task 4, M will continue to resupply the product bu er for task 2. Thus we continue to have u = 2 until the demand bu er for task 2 is cleared, ending this phase, precisely after M has processed K items. We note that at this point (time t = t = t + " + K ) we have (3:B.3) k = 0; x = K ; k = 0; x = K ; k = K ; x = 0 and that the combined number of items x + x at t is just K + K . The clearing of the demand bu er for task 2 enables task 3 at M (i.e., u = 3) so, much as above, product is rapidly supplied for task 4, which then permits u = 4 (at time t = t + ), which we take as characterizing the second phase of the scenario. ^ = minfK ; K g items are processed at task 3 while the same One has, rst, that K number of kanbans are sent to the demand bu er for the blocked task 2, after which ^ +K ~ by one has u = 2 while M clears at task 2 at the time t = t = t + K ~ = minfK; ^ x (t ) = K g = minfK ; K ; K g items without interruption. processing K The condition (3:B.1) was imposed just to ensure that there is now still su cient time for task 3 to recommence and begin resupplying the product bu er for task 4 before M ^ supplied earlier; thus (3:B.1) ensures the uninterrupted continuation clears the stock of K of task 4 at M . Continued tracking along the same lines easily shows that one has
(3:B.2)
3 4 4 2 3 3 1 2 2 0 2 0 2 1 1 0 2 2 2 2 0 3 1 2 2 3 1 0 3 1 2 2 2 3 3 3 4 4 2 3 1 2 3 2 2 1 1 3 4 2 2 1 2 1 2 2 3 4 1 1

10

u = 4 precisely until M has processed at task 4 a total of K + K items (i.e., one has processed all of the items which were in the product bu ers x ; x at time t ) since task 1 is necessarily blocked during this phase so no new product can be brought into the system. The second phase then ends at the time t = t given by t = t + + (K + K ) = t + + " + K + (K + 2 + K ) ; having processed, altogether, K + K items at task 4 to meet the initial unful lled demand. The `internal' state of the system is now again exacly as in (3:B.2), so | apart from the level z of the external demand bu er | the same cycle will repeat exactly so long as z remains positive. During each cycle one has (with unit demand rate) the arrival of new demand in the form of (approximately) t ? t ] = + " + K + (K + 2 + K ) new orders. Thus (to within this approximation and neglecting the comparatively small quantities ; "), one has z(t ) ? z(t ) (t ? t ) ? h(K + K ) i (3:B.4) (K + K ) + K2K3K3 ? 1 : This is positive precisely when one has 1 + >1 := 1 + K (3:B.5) =K and z then steadily increases with an average increase of K +K 1?K + (K + K ) per unit time. Note that this situation is rather di erent from that of 6] | and from any previously known example of instability | in that instability occurs with repetition on a xed scale, rather than an exponentially increasing scale. Since one always has < 1 in (3:B.5), this instability condition is favorably comparable to the instability condition (3.1) given for the `same' manufacturing system in 6] under ow-driven (`push') operation: the kanban mechanism helps, although it does not ensure stability. For xed processing times satisfying (2.10) one can always obtain stability by making K large enough (for xed K ). However, if + > 1, then increasing K su ciently (for xed K ) will actually make a stable situation unstable. Our earlier requirement of `large' initial unful lled demand indicates that, as for Example A, the kanban mechanism provides a threshhold e ect, insulating to some extent against occurrence of this instability.
1 1 2 3 2 3 1 2 2 1 2 3 0 3 3 2 3 2 0 3 3 2 0 2 0 2 3 2 3 + 2 3 2 3 3 2 3 2 3 3 2

3:C.

For acyclic ow-driven systems, we know (cf., e.g., 5]) that: if each machine is governed by a `usable policy' (i.e., stable for inputs of bounded burstiness in the singleserver context), then the system is stable globally. For demand-driven systems with 11

An `acyclic' instability example

M "
1 3

s f

M
k
1

x z
2

z 1

Example C kanbans this may fail, as may be seen by the following example, under a clearing policy with positive setup times. Here, rather than indexing as above, we refer to the tasks by their processing times (e.g., we say that `M services only task '). We will let K be the number of kanbans associated with the link between task " and task , which is the only link involving kanbans at all. The only relevant setup time will be occurring when switching from task to task " and we assume > 1. We will consider unit arrival rates for orders (d ; d = 1) and will neglect burstiness (e ectively, M = 1) in (2.9)). Finally, we will also assume that " is small enough and close enough to 1 to have
2 1 2

(3:C.1)

K + 1 < min " ; 1 ? : As we just have two tasks at M , operated by a clearing policy, this machine will alternate between production runs at task and task ". Let us consider a `cycle' of the scenario characterized by this. Such a cycle comprises three phases: a setup period of duration , a production run at task ", processing m items, a production run at task , processing n items; the cycle duration is thus T = + m" + n . Note that, neglecting burstiness, our rst assumption ( > 1) ensures that at least one order for P would arrive at z during the setup period and so ensures that task is always available at the conclusion of a production run at task " and n 1. We will also see that n will necessarily be large enough to ensure that k" = K at the end of the second phase so task " is available. Thus, the scenario will be as described. We next note that the rst part of our second assumption (3:C.1) implies that m K +1 items. To clear the order bu er k" , one need consider only the maximum K which could be at k" when the run begins, together with the additional order immediately returned by task when it begins work on the rst item sent: since the time necessary to process K + 1 orders at task " does not permit task actually to complete the processing of that rst item, it will be unable to return an additional kanban. If, as we
1 1 1

12

now assume, the initial state of the cycle has k" = K , then we have precisely m = K +1 and we will then have to show this state recurs at the next cycle. Since z = 0 both at the beginning and end of the cycle, n must be the number of orders for P arriving at z during the cycle, i.e., n = T (to within the uncertainty associated with working with discrete items). With m = K + 1, this gives 1)" + : T = + (K + 1)" + T so T = (K + 1? The second part of the assumption (3:C.1) then ensures (as > 1) that the duration n T of the third phase is at least K + 1. Since < 1, by (2.10), this means there is certainly time during this for task to empty its supply bu er (at most K items) so we will, indeed, have k" = K at the end of the cycle, i.e., as the initial state for the next cycle as asserted. Since d = 1 the result we have obtained, that n > K + 1, implies that we will have at least K + 1 orders for P arriving at z during this phase and, with at least one additional order arriving during the setup period > 1, there must be at least K + 2 orders arriving during each cycle. On the other hand, only m = K + 1 items of P are processed during the cycle so z must increase by at least one order per cycle: this unful lled demand increases unboundedly and the system is unstable. Reversing the arrows in the diagram here (so task supplies product P to task ") merely interchanges the roles of orders and products in this product stream so the system would follow essentially the identical scenario as above: again, z must increase by at least one order per cycle and this `reversed system' is also unstable. We have demonstrated instability for these `acyclic' settings | which could not have happened for a ow-driven policy. On the other hand, it should be noted that simply taking K large enough (for any xed values of "; ; ) to avoid (3:C.1) invalidates the scenario description here, presumably giving stability. A further comment is that it is somewhat inappropriate to think of this geometry as truly acyclic since the full `in uence graph', giving the ows both for product and also for information (orders), will never be acyclic for any system involving a kanban-controlled link so the inductive `logic of acyclicity' is inapplicable. We conclude this section by considering a single-machine, single-product system with two tasks (task supplying product to task ; necessarily, by (2.10), we must have + < 1) and setup delays ; . In this case, the system will alternate clearing K orders at task (taking time + K ) and processing the K items then in the supply bu er at task (taking time + K ). Thus, K items pass through the system for each such cycle which takes total time T = ( + ) + K ( + ) with an average of T orders entering the system each cycle. If the setup delays are large enough and the reserve supply level K small enough that + > 1 ? ( + ); (3:C.2) K then this system will also be unstable | with, of course, the simple remedy of increasing K enough to reverse (3:C.2).
2 2 2 1 1 1 1 1 1 1

13

References
1] M. Bramson, Instability of FIFO queueing networks, Ann. Appl. Prob., pp. 414-431, (1994). 2] J. Browne, J. Harhen, and J. Shivnan, Production Management Systems; a CIM perspective, Addison{Wesley, Reading, 1988. 3] C. J. Chase and P. J. Ramadge, On real time scheduling policies for exible manufacturing systems, IEEE Trans Autom. Control AC-37, pp. 491-496 (1992). 4] C. Chase, J. Serrano, and P. Ramadge, Periodicity and chaos from switched ow systems: Examples of the discrete control of continuous systems, IEEE Transactions on Automatic Control 38 1993, pp. 70{83. 5] C. Humes Jr., A regulator stabilization technique: Kumar-Seidman revisited, IEEE Trans Autom. Control AC-39, pp. 191-196 (1994). 6] P.R. Kumar and T.I. Seidman, Dynamic instabilities and stabilization methods in distributed real time scheduling of manufacturing systems, IEEE Trans Autom. Control 35, pp. 289{298 (1990) see also, pp. 2028{2031 in Proc. 28 IEEE CDC, IEEE (1989)]. 7] S. Lou, S. Sethi, and G. Sorger Analysis of a Class of Real-Time Multiproduct Lot Scheduling Policies, IEEE Trans Autom. Control AC-36, pp. 243-248 (1991). 8] S. H. Lu and P.R. Kumar, Distributed scheduling based on due dates and bu er priorities, IEEE Trans Autom. Control AC-36, pp. 1406-1416 (1991). 9] J.R. Perkins, C. Humes, and P.R. Kumar, Distributed control of exible manufacturing systems: stability and performance, IEEE Trans Rob. and Automation 10, pp. 133-141 (1994). 10] J.R. Perkins and P.R. Kumar, Stable distributed real-time scheduling of exible manufacturing/ assembly/ disassembly systems, IEEE Trans Autom. Control AC34, pp. 139{148 (1989). 11] T.I. Seidman, `First Come, First Served' can be unstable !, IEEE Trans. AC, (1994). 12] A. Sharifnia Stability and performance of distributed production control methods based on continuous ow models, pre-print, Boston Univ., (1993).
th

14