ABSTRACT
SITTIVIJAN, PEERAPOL. Modular Warehouse Control: Simultaneous Rectilinear Movement of Multiple Objects within a Limited Free Space Environment. (Under the direction of Dr. Michael G. Kay.)
A public logistics network (PLN) has been proposed as an alternative to private logistics
networks for the ground transport of parcels using the analogy between the packages
transported in the network and the packets transmitted through the Internet. An integral part
of such a network is a large number of fully automated modular warehouses functioning
similar to routers in the Internet. In this dissertation, the algorithms to control the movement
of packages in such a modular warehouse have been developed. Precisely, the main purpose
of this dissertation is to develop efficient algorithms to control the simultaneous movement
of objects of various sizes within an area with limited free space and to apply the developed
algorithms for modular warehouse control. The details of the developed algorithms are as
follows.
First, algorithms are developed for a simpler version of the control problem where all
objects (packages) are unit squares. The developed algorithm is a combination of centralized
and decentralized approaches and is based on a unique priority level assigned to each
individual object. The basic algorithm is comprised of three main parts, namely, main
control, route planning and the tagging process. The main control portion controls the
movement of all objects at each time step and detects deadlocks, which indicate that some
objects are blocked and cannot move to their destinations. Route planning is used by each
Next, the use of priority assignment to prevent or resolve deadlocks in the movement of
unit-size objects is explored. In addition, two extensions to the basic algorithm are
implemented to improve performance, where the objectives considered are either to minimize
the maximum traversal time or to minimize the total/weighted average traversal time of the
objects in the system.
Finally, various simulations and experiments for unit-size algorithm are conducted to
examine the efficiency of the algorithm and identify the relations among parameters in the
system. Based on experiments, the algorithm for unit-size objects works efficiently even at a
95% utilization level of the available space in the warehouse.
For future work, the algorithm designed for the movement of unit-size objects can be
extended to that of multi-size objects. The main difficulty here is that an object can occupy
multiple modules. Therefore, the relationship between object and module is not one-to-one as
in the case of square unit-size objects. Consequently, the tagging process can grow
exponentially. In order to cope with this difficulty, the tagging process has to be implemented
Modular Warehouse Control: Simultaneous Rectilinear Movement of Multiple Objects within a Limited Free Space Environment
by
Peerapol Sittivijan
A dissertation submitted to the Graduate Faculty of North CarolinaStateUniversity
in partial fulfillment of the requirements for the degree of
Doctor of Philosophy
Industrial Engineering
Raleigh, North Carolina
2015
APPROVED BY:
_______________________________ ______________________________
Anita Vila-Parrish Matthias F. Stallmann
_______________________________ ______________________________
DEDICATION
I would like to thank and dedicate this work to my father, mother, grandfather and
BIOGRAPHY
Peerapol Sittivijan received his bachelorβs degree in civil engineering from Mahidol
University in 1999. He worked as transportation planner and analyst for five years in
Thailand Ministry of Transportation and MVA Consultant Company. He came to the United
States in 2008 to study Industrial Engineering and work as research assistant at Oklahoma
State University. In 2010, he received the Royal Thai Government Scholarship and began his
ACKNOWLEDGMENTS
I would like to express sincere gratitude to my advisor, Dr. Michael G. Kay for his
supervision, thoughtful advice and continual support throughout my work on this Ph.D.
dissertation. I learned things, improved skills and thoughts from his advice. His guidance
toward being a professional is an invaluable asset which I will carry in the future. I also
would like to thank Dr. Russell E. King, Dr. Donald P. Warsing, Dr. Anita Vila-Parrish and
Dr. Matthias F. Stallmann for serving as my committee and I appreciate their help and
support.
I would like to thank to my father, Wicharn Sittivijan, mother Luxanee Sittivijan,
grandfather Roj Sittiosoth and grandmother Pannee Sittiosoth for never giving up on me.
I also would like to thank my best friends; Dr. Karin Limapornwanitch, Boonngam
Eiamsuppawat, Wirawan Asapa for staying with me whenever I want. I would like to thank
all of my Thai and foreign friends at NCSU for their support through all these difficult years.
Finally, I would like to thank Google and Google Scholar, the best search engine in the
TABLE OF CONTENTS
LIST OF TABLES ... vii
LIST OF FIGURES ... viii
Chapter 1 Introduction... 1
1.1. Motivation and Applications ... 1
1.2. Problem Statement, Objectives, Contributions and Scope of Study ... 8
1.3. Organization of the Dissertation ... 9
Chapter 2 Literature Review ... 11
2.1. Related Problems, Complexity and Solving Algorithms ... 12
2.2. Rectilinear Path Planning ... 16
2.3. Motion Coordination of Multiple Moving Objects ... 18
2.4. Deadlock and Its Prevention, Avoidance and Resolution ... 21
2.5. Summary of the Literature ... 34
Chapter 3 Algorithm for Square Unit-size Objects ... 35
3.1. Preliminaries and Overall Concept ... 36
3.2. Route Planning ... 38
3.3. Tagging Process ... 48
3.4. Main Control ... 54
3.5. Runtime Analysis of the Algorithms ... 66
Chapter 4 Deadlock and Priority Assignment for Unit-size ... 67
4.1. Deadlock Characteristics ... 68
4.2. Deadlock Detection ... 69
4.3. Priority Assignment for Deadlock Prevention ... 71
4.4. Priority Assignment for Deadlock Recovery ... 81
Chapter 5 Improvement of Algorithm for Unit-size Objects ... 89
5.1 Adaptive Priority ... 90
5.2 Movement of Inactive Objects ... 94
Chapter 6 Experimental Results for Unit-size Objects ... 100
6.1 Simulation Details ... 100
6.1.1 Modular Warehouse Layout and Operations ... 100
6.1.3 Performance Metrics ... 105
6.1.4 Simulation Runtime ... 107
6.2 Comparison of the Basic Algorithm and the Improved Algorithms ... 108
6.3 Algorithm Parameters and Performance Metrics ... 117
6.4 Performance of Improved Algorithm at Utilization Levels ... 123
Chapter 7 Conclusion and Future Work ... 126
7.1 Conclusion ... 126
7.2 Future Work ... 127
7.3 Main Difference between Multi-size and Square Unit-size Objects ... 128
7.4 Extension for Route Planning ... 129
7.5 Extension for Tagging Process ... 131
7.5.1 Simultaneous or Sequential Tagging Processes ... 133
7.5.2 Movement Direction ... 138
LIST OF TABLES
Table 1.1: Analogy between PLN and Internet. ... 2
Table 1.2: Gaps in the literature. ... 8
Table 6.1: Example of input data for modular warehouse operations. ... 103
Table 6.2: Results for simulation of algorithms at 80% utilization. ... 110
Table 6.3: Comparison of metric means between algorithms at 80% utilization. ... 111
Table 6.4: Results for simulation of algorithms at 20% utilization. ... 112
Table 6.5: Comparison of metric means between algorithms at 20% utilization. ... 114
Table 6.6: Comparison of basic algorithm and algorithm with inactive object movement at 60% utilization ... 117
Table 6.7: ANOVA between basic algorithm and algorithm with inactive object movement at 60% utilization ... 117
Table 6. 8: High and low values of each parameter ... 118
Table 6. 9: Results from full factorial experiment at 80% utilization. ... 120
Table 6.10: Results from full factorial experiment at 20% utilization. ... 121
Table 6. 11: Analysis of Variance at 95% confidence level for parameter settings at 80% utilization ... 122
Table 6.12: Analysis of Variance at 95% confidence level for parameter settings at 20% utilization ... 122
LIST OF FIGURES
Figure 1.1: Transshipment of packages through PLNs. ... 2
Figure 1.2: An example of PLN for home delivery logistics. ... 3
Figure 1.3: Module and container design. ... 4
Figure 1.4: Raising and lowering module wheels for container orthogonal movement. ... 5
Figure 1.5: Top view of a one-level four dock modular warehouse. ... 6
Figure 1.6: An illustration of package retrieval within a modular warehouse. ... 6
Figure 1.7: Three-layer control of a modular warehouse. ... 7
Figure 2.1: 15-puzzle problem. ... 12
Figure 2.2: Unobtainable final configuration from initial configuration. ... 13
Figure 2.3: Rush-Hour Puzzle... 14
Figure 2.4: Warehouseman problem. ... 15
Figure 2.5: A deadlock occurrence in a system with simultaneous resource utilization. ... 22
Figure 3.1: The problem of square unit-size objects. ... 37
Figure 3.2: Calculation of TCGNx, y, t based on neighbor occupation. ... 41
Figure 3.3: Rectilinear distance from a neighbor to destination. ... 42
Figure 3.4: Example of route planning process. ... 44
Figure 3.5: Example of searching process and result of route planning. ... 45
Figure 3.6: Illustration of tagging process ... 49
Figure 3.7: Decision Process in the main control algorithm. ... 56
Figure 3.8: A full example for the unit-size object algorithm. ... 58
Figure 4.1: An illustration of permanent deadlock. ... 69
Figure 4.2: An example of boundaries and classes. ... 72
Figure 4.3: Illustration of free, rigid and tight modules. ... 73
Figure 4.4: A simple path... 74
Figure 4.5: Two connected simple paths. ... 74
Figure 4.6: A circular path. ... 75
Figure 4.8: An example of Oi and its destination on a simple path with dead end. ... 79
Figure 4.9: A configuration with a simple path connecting two loose components. ... 80
Figure 4.10: Example of dynamic priority to resolve total deadlocks. ... 82
Figure 4.11: An Example of looping deadlock. ... 84
Figure 4.12: An example of looping deadlocks at edges. ... 86
Figure 4.13: How to resolve looping deadlocks at the edges. ... 87
Figure 5.1: An example of adaptive priority assignment ... 91
Figure 5.2: Packages adjusting priorities based on loading time and distance. ... 93
Figure 5.3: An example of inactive object movement to low utilized area ... 95
Figure 5.4: Tagging sequence of inactive objects ... 96
Figure 6.1: Illustration of modular warehouse operations at 80 % utilization. ... 101
Figure 6.2: Example of simulation input data at 80% utilization for five days (assuming a 5 sec. time step)... 104
Figure 6.3: Truck delay when loading packages. ... 106
Figure 6.4: Truck delay when unloading packages. ... 106
Figure 6.5: Mean of each metrics for algorithms at 80% utilization. ... 111
Figure 6.6: Mean of each metrics for algorithms at 20% utilization. ... 113
Figure 6.7: An example of inactive object movement at high utilization level. ... 115
Figure 6.8: An example of inactive object movement at low utilization level. ... 116
Figure 6.9: Mean values of loading performance metrics at various utilization levels ... 125
Figure 7.1: A multi-size object occupying multiple modules. ... 129
Figure 7. 2: Neighbors in case of unit-size and multi-size objects. ... 130
Figure 7.3: Calculation of ELBT for object 3. ... 131
Figure 7.4: An example of tagging process for multi-size objects. ... 132
Figure 7.5: Growth for tagging process of multi-size object. ... 133
Figure 7.6: Sequential tagging process to move object 11 from (1,1) to (1,2). ... 136
Figure 7.7: Illustration of first-tier module required by an object. ... 138
Figure 7.8: Possible moving direction for an object. ... 139
Chapter 1
Introduction
1.1.
Motivation and Applications
Jain [1], Kay [2], and Kay and Parlikad [3] proposed the concept of public logistics networks
(PLN) as an alternative to private logistics networks for the ground transport of parcels.
Currently, private company like UPS or FedEx commonly handle packages throughout its
own logistics network. Nevertheless, a private company is still limited in the scale of its
operation resulting in the use of a limited number of large-scale transshipment points which
causes packages to travel unnecessarily through those points before reaching their
destinations. In comparison, in a PLN, the different functions of the network can be
performed by multiple firms coordinating together. For instance, one company that owns one
or more distribution centers (DCs) can coordinate with another that owns one or more trucks.
This coordination would enable an economy of scale since each element of the network has
access to all of the networkβs demand. Figure 1.1 shows that the transshipments of a package
P1 from DC1 to DC4, P2 from DC2 and to DC5 and P3 from DC3 to DC6. All
transshipments have a common link from DC7 to DC8, therefore they could form a single
truckload depending on their arrival time at DC7. In this sense, the operations of a PLN are
Figure 1.1: Transshipment of packages through PLNs. (Source: Jain [1])
Table 1.1: Analogy between PLN and Internet.
(Source: Kay [2])
A package in a PLN, similar to a packet in the Internet, can be sent from a retail store and
then routed through a sequence of public distribution centers (PDCs) located throughout the
network, functioning similar to routers in the Internet, and then delivered to a customerβs
home in a very short time, e.g., a matter of hours (see Figure 1.2). A similar concept termed
the Physical Internet (PI) is also proposed by Montreuil [4]. Kay [5] identified two integral
parts to realize such a PLN, namely, driverless delivery vehicles (DDV) and fully automated
storage systems for loading and unloading packages. Together, they make it possible to
create PLNs capable of delivering goods to homes at a cost lower than the cost of in-store
Public Logistics Network Internet
Packages transported Packets transmitted Distribution centers (DCs) Routers
shopping. This dissertation focuses on the second technology, fully automated storage system
development.
Figure 1.2: An example of PLN for home delivery logistics. (Source: Kay [5])
To be feasible, the proposed storage system must be a fully automated storage system in
terms of loading/unloading, sortation and storage activities and be flexible enough to allow a
large range of container sizes to move to any location at any time. Furthermore, the storage
system must have small fixed-cost increments so that the cost of PDCs is proportional to its
size since a large number of small PDCs is a key requirement for PLN realization.
To meet the above requirements, Kay [5] proposed the use of a βmodular warehouse.β A
modular warehouse uses a small square module with orthogonal pop-up powered wheels as
planar surface to move loads in containers which have recessed tracks on their underside that
interlock with the module wheels (see Figure 1.3 (b) and (c)). A container whose size is
larger than a module occupies several contiguous modules. By raising and lowering module
wheels, they allow the orthogonal movement of containers on the array of modules without
rotating the containers (see Figure 1.4).
Figure 1.4: Raising and lowering module wheels for container orthogonal movement. (Source: Kay [5])
Figure 1.5 illustrates an example of operations within a modular warehouse. There are four
loading/unloading docks in the example. Activities such as storing and retrieving a package
in the warehouse can be implemented by orthogonal movement of the packages. For
example, Figure 1.6 illustrates the clear path construction by moving other packages out of
Figure 1.5: Top view of a one-level four dock modular warehouse. (Source: Kay [5])
For the control of a modular warehouse, a three-layer system control is proposed as shown in
Figure 1.7. At the top level of the control is load planning. When a delivery vehicle arrives at
the warehouse, a load, comprised of several packages, from the vehicle is unloaded into the
warehouse with its information. Load information, e.g., a packageβs destination and due date,
is used to identify a unique priority and storage location (destination) in the warehouse for
each package. Finally, the control algorithm plans a traversal path for each load to its
destination and then executes the movement. The control system reports the expected load
arrival time or any deadlocks occurring in the system.
1.2.
Problem Statement, Objectives, Contributions and Scope of Study
To properly design such a modular warehouse, various design issues must be addressed: how
to efficiently move packages with various sizes, locations and time requirement within the
warehouse; how many loading/unloading docks should there be and where should they be
located; what should be the size and shape of the warehouse; and what is the appropriate
density of packages in the warehouse. Experiments with various warehouse designs must be
conducted to answer these design issues.
To date, almost all previous work has focused on the movement of square unit-size
objects (see Chapter 2 and Table 1.2). Furthermore, these approaches are constrained by the
movement of only one object at a time and they assume that there is enough empty space in
the system. These assumptions are not appropriate for representing the movement of
packages in the proposed PLN modular warehouse where packages have various sizes and
free space is limited.
Table 1.2: Gaps in the literature.
This dissertation is aimed at developing an approach to handle the simultaneous
rectilinear movement of multiple multi-size objects within limited a free space environment.
It has been shown that finding even a feasible solution of this problem is already a PSPACE-sequential simultaneous sequential simultaneous
multi-size few none
unit-size many many many few
hard problem (Hopcroft et al. [6]). Therefore, the approach explored in this research is aimed
at heuristic rather than exact algorithm development. The heuristics developed here are tested
on various scenarios related to the primary design problems mention earlier.
In this work, the following assumptions are made:
1. Although the ultimate goal of this research is to apply the developed algorithms to test
the efficiency of the design a module-based warehouse, the algorithms developed are
mainly focused on solving only the abstract version of modular-based warehouse
operations called the βwarehouseman problemβ (see Hopcroft et al. [6] and Sharma and
Aloimonos [54]).
2. The initial configuration and the desired final configuration (location of loads in the
warehouse) are assumed to be given. (See Figure 2.4).
3. The movement of an object in the system is constrained by the physical and mechanical
limits of the modular warehouse. More precisely, an object can move across only one
module in a single direction in a time step.
1.3.
Organization of the Dissertation
The remainder of the dissertation is organized as follows. Chapter 2 reviews related areas of
research where similar problems, such as the n-puzzle, warehouseman, and rush hour problems are reviewed. Path planning algorithms, motion coordination of multiple unit-size
and multi-size objects, flocking algorithms and deadlock handling in computer operating and
flexible manufacturing systems as well as multi-robot path planning are also reviewed.
multiple square unit-size objects. Then Chapter 4 describes the deadlocks that are possibly
occurred in the system and their characteristics. The relationship between priority assignment
and the deadlocks and how to properly assign priority to prevent or resolve the deadlocks are
also studied in this chapter. Chapter 5 presents two potential improvements of the basic
algorithm described in Chapter 3, namely, adaptive priority and movement of inactive
objects. Application of the developed algorithm for the movement of unit-size objects on the
simulation of a modular warehouse operations is implemented in Chapter 6. Various
experiments to compare basic and improved algorithms and to consider the effects of
parameter setting at different utilization levels have been presented in this chapter. Chapter 7
concludes the whole work studied in this dissertation and propose some ideas about the
future work. The extension of the algorithm to control the movement of unit-size objects to
Chapter 2
Literature Review
As mentioned in Chapter 1, the algorithm to control the movement of packages in a modular
warehouse must be able to efficiently control the simultaneous movement of multiple
multi-size objects within the area with limited free space. To the extent of our knowledge, such an
algorithm does not exist in the literature (see Table 1.2). However, there is some related
literature that can be used in the development of our algorithm for the control of the
movement of packages in a modular warehouse. The relationship between the development
of the algorithms in this research and previous work in the literature can be described as
follows. Sliding puzzles such as 15-puzzle, Rush-Hour and Warehousemanβs problem
sequentially move objects from one point to another point within an area with limited free
space. These sliding puzzles are reviewed to gain more understanding of the complexity of
our problem and the algorithms designed to solve these related problems. Another related
area of research is the motion coordination of multiple moving objects. Algorithms
developed in this area are mainly focused on the control of simultaneous movement of
objects, commonly with unit-size, within a confined space. The main assumption normally
applied for algorithms in this area of research is that there is enough empty space so that
conflicts among objectsβ movement rarely occur. Rectilinear path planning is another related
area of research which mainly focuses on the path planning of a moving object among fixed
of our algorithm. Furthermore, the control of the movement of packages in a modular
warehouse can be considered as a system with simultaneous resource utilization. A deadlock
which is a common problem in this type of the system, can also occur in our system. Other
systems with simultaneous resource utilization are computer operating systems, flexible
manufacturing systems and multi-robot coordination planning. The deadlock problem in
these areas was reviewed to gain a better understanding of common deadlock characteristics
and how deadlocks in these systems are handled.
2.1.
Related Problems, Complexity and Solving Algorithms
A simple form of the problem where multiple objects are moved in a confined space is the
15-puzzle and its extension to (n2β1) problems. In this game, fifteen squared tiles numbered
from one to fifteen are located in a square tray of size 4 Γ 4; therefore, there is one empty
space left in the tray. Given an initial configuration, the objective of the game is to move tiles
orthogonally so that a desired final configuration can be achieved as shown in Figure 2.1.
Figure 2.1: 15-puzzle problem.
15 7 1 13
11 8 3 10
9 6 5
4 12 2 14
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15
(a) (b)
Ratner and Warmuth [7] showed that the decision question βIs there a solution for
transforming the initial configuration into the final configuration requiring at most k moves?β is NP-complete. Wilfong [8] also showed that even for an easier version of the problem,
where the objective is to move a square object from an initial position to a destination in the
presence of multiple moving square obstacles, the problem to find the minimum number of
moves is NP-hard. Spitznagel [9] proved that, for the 15-puzzle problem, only the final
configurations with even permutations from an initial configuration can be obtainable.
Figure 2.2 shows an unobtainable final configuration in (b) from the initial configuration
in (a) because configuration in (a) has to be permutated one time i.e. switching tiles 14
and 15 to obtain configuration in (b) and one is an odd number.
Figure 2.2: Unobtainable final configuration from initial configuration. (Source: Spitznagel [9])
Another related problem is the Rush-Hour problem (see Figure 2.3). Rush-Hour is a
module-based game that involves moving a target car to an exit located on the center of
either horizontally or vertically only. The other cars in the module are moved in such a
way to clear a path for the target car to the designated exit.
Figure 2.3: Rush-Hour Puzzle. (Source: Example Programs [10])
Tromp [12] showed that the version of Rush-Hour where all objects are 1Γ2 is
PSPACE-complete. Flake and Baum [11] showed that a further generalized version of Rush-Hour,
where cars can be a rectangular of any size, is PSPACE-complete.
An extension of the n-puzzle problem where the blocks are allowed to have different sizes is called the warehousemanβs problem as shown in Figure 2.4. Hopcroft et al. [13]
showed the decision question of the problem βDoes there exist βa feasible solutionβ to
6ob j_7
5 ob j_9
4ob j_4 ob j_2 ob j_3 3
2 ob j_1
1ob j_8 ob j_5 ob j_6
1 2 3 4 5 6 7
6 ob j_7
5ob j_4 ob j_9
4 ob j_2
3 ob j_3
2ob j_8
1 ob j_1 ob j_5 ob j_6
1 2 3 4 5 6 7
Figure 2.4: Warehouseman problem.
In terms of the algorithms to solve these problems, Drogoul and Dubreuil [14] proposed
an agent-based and distributed approach to solve the n-puzzle problem. In their algorithm, the overall goal to move all tiles to their desired final positions is divided into sub-goals for
each tile. Different, but not unique priorities are given to the tiles; therefore, looping caused
by a conflict of the movement of the objects with the same priority can occur. The looping
can be avoided by choosing one tile to move forward or to flee from other tiles at a time.
Culberson and Schaeffer [15] solved the 15-puzzle using the A* algorithm and improved the
lower bound of the route search by introducing reduction databases. Bauer [16] solved the
problem using the combination of Iterative Deepening A* (IDA*) and Manhattan Pair
Distance (MPD) to estimate a better lower bound of the distance to destination for each
move. Parberry [17] proposed a real-time algorithm to solve the puzzle by first moving tiles
which have a destination at the edges. This reduces the size of the problem from (nΓn) to ((nβ1) Γ (nβ1)) in the next iteration. Gue and Kim [18] developed an algorithm to identify
minimum movement of an object from one position to another position in a puzzle-based
storage system. However, the computational time for their exact algorithm grows
exponentially when the size of the problem becomes larger. In this case, they suggested a
good heuristic movement to control the movement of an object in puzzle-based storage
system.
2.2.
Rectilinear Path Planning
Algorithms to move an object from one point to another point in a confined area where that
object is restricted to move horizontally or vertically have been developed. Lee [19]
developed the algorithm to find the minimum rectilinear distance between a starting and a
target point in the presence of rectilinear obstacles. In this case, the system is comprised of
modules and the algorithm finds the path by considering neighbors of the current module as
candidates to be the next module to move based on pre-identified criteria. Hoel [20] extended
Leeβs algorithm by storing frontier modules instead of a single list, retracing modules
immediately when they are reached rather than when they are expanded and using an
encoding scheme with two bits per module. Hoel [20] claimed that these changes made the
algorithm more efficient in term of computational time. Hadlock [21] proposed a shortest
path algorithm for a grid graph, a simple class of planar graphs for which the vertices can be
assigned integer coordinates so that neighbors agree in one coordinate and differ by one in
the other coordinate. By applying stacks to store neighbors towards target and away from
Soukup [22] proposed an algorithm combining line search and expansion techniques similar
to that of Leeβs algorithm to generate a path between a starting and target points in the
presence of polygonal obstacles. The algorithm is claimed to be faster than Leeβs algorithm;
however, when the area becomes congested, the path found can be suboptimal. Wu et al. [23]
proposed the concept of a track graph, a subspace of the plane where obstacle areas are
subtracted, to find the shortest path and minimum spanning tree from one point to another
point in the plane in the presence of rectilinear obstacles. Clarkson et al. [24] proposed the
use of a visibility graph to find shortest path through polygonal obstacles where the vertices
represent starting and target points and 2n points, where n is the number of endpoints of obstacles.
Rezende et al. [25] proposed an algorithm to find the shortest path in the presence of
rectangular barriers. The algorithm consists of two phases: preprocessing and query phases.
Planar subdivision containing a source point and barriers is constructed, then a query point
can be located and a shortest path connecting it to the source point can be identified. The
worst-case computational time of preprocessing is π(πlogπ) and that of query is π(logπ + π), where k is the number of turns on the reported path. Mitchell [26] employed the continuous Dijkstra technique of propagating a wavefront to compute the rectilinear shortest
path among polygonal obstacles in the plane. More detailed review of rectilinear path
2.3.
Motion Coordination of Multiple Moving Objects
Algorithms for the simultaneous movement of objects within the area with unlimited free
space have been developed in the area of motion coordination. The literature on planning the
motion coordination of multiple moving objects can be classified into two main approaches:
centralized and decentralized/decoupled. The centralized approach plans the motion of all
objects using a centralized path planner. In this case, moving objects are treated as a
composite object. Schwartz and Sharir [28] proposed the module decomposition method to
solve the problem. Γ'DΓΊnlaing and Yap [29] proposed the retraction method. Gurewitz et al.
[30] combined the module decomposition approach with dynamic programming.
Tournassoud [31] and Barraquand et al. [32] used the potential field approach to solve the
problem. Svestka and Overmars [33] and Sanchez and Latombe [34] used probabilistic
roadmap (PRM) in this context. An important advantage of the centralized approach is the
possibility of completeness, i.e., the ability to find a feasible solution if one exists and global
optimality. However, the time complexity of the centralized approach increases exponentially
with the number of moving objects and their degree of freedom to move.
On the other hand, the decentralized or decoupled approach plans the motion of each
moving object separately. Because each moving object is planned separately, completeness
and global optimality are not guaranteed. However, the time complexity is also reduced for
solving sub-problems for each object. Another issue for the decentralized approach is how to
avoid collisions among moving objects because the motion of each object is planned
Lozano-Perez [35] proposed the method of assigning priorities to each moving object and planning
their motions sequentially based on their assigned priorities. Using a configuration
space-time, the lower priority objects consider, when planning their motions, constraints imposed
by the motion of higher priority and stationary objects. In this case, the assigned priorities are
static and not changed during the planning processes. Yeung and Bekey [36] mentioned that
by assigning static priorities to moving objects, it might be difficult to optimize performance
of tasks; therefore, assigning priorities, which is a way to resolve conflicts among paths of
moving objects, should not be fixed but should vary according to the conflicts that occur.
Another approach in solving conflicts among moving objects is to decompose the motion
coordination problem into two sub-problems (Kant and Zucker [37]). The first sub-problem
is to plan a collision-free path for each moving object without taking into account the
existence of other moving objects. The second sub-problem is to vary the velocities of the
moving objects along their planned paths so as to avoid collisions. The velocity varying can
be considered in space-time configuration. Yeung and Bekey [36] also proposed a method of
assigning priorities to moving objects to resolve conflicts. Priorities are assigned based on
domain-specific knowledge describing the objectsβ current situations such as their urgency to
reach goal locations and the degree to which they are free to modify their planned path.
Azarm and Schmidt [38] suggested assigning a dynamic priority when a conflict occurs.
They considered all possible permutations of priority order and the one which provides the
optimal set, in terms of minimum movement conflicts for the subsequent operation of path
hill-climbing to find the priority order when a conflict occurs, which minimizes the overall path
lengths.
Ferrari et al. [40], Guo and Parker [41], Clark et al. [42], Gayle et al. [43], Langerwisch and Wagner [44] and Krontiris and Bekris [45] proposed similar ideas for movement conflict
resolution by locally varying velocities or paths when conflicts occur. Recently, Basu et al.
[46] proposed a divide-and-solve technique to solve the problem. In this framework, the total
space is divided into sub-spaces and the movement of objects in each sub-space is planned.
The objects which have to cross from one sub-space to another sub-space first move to the
border of their own sub-space then move to the other sub-space. Ryan [47] proposed a
similar concept of dividing the total space into sub-spaces using a subgraph representation.
LaValle [48] proposed applying a game theoretic approach to solve the problem. In his work,
the coordination motion for moving objects can be formulated based on the concept of
non-cooperative game theory and stochastic optimal control. Liu et al. [49] proposed solving the
problem by applying a meta-heuristic ant colony algorithm where possible paths between
initial positions and goal positions are ant paths. Conflict resolution among moving objects is
solved based on a first-come first-serve strategy. Yu and LaValle [50] formulated the path
planning for multi-agent problem as an integer linear programming and solved the problem
to find collision free paths for agents. In the context of a warehouse, Hama et al. [51] applied
an artificial neural network (ANN) for planning motion coordination of moving objects in
cellular warehouse. In this case, each mobile agent is autonomous and trained to find a path
to its goal position using training sets. Conflict resolution among agents is implemented
of that agent. Stiefelhagen et al. [52] studied the effect of motion planning schemes on the
performance of cellular warehouse, i.e., the time required by delivery objects to reach their
goal positions. Surprisingly, based on their experiments, the results showed that the amount
of blocked modules increased when the intelligence and complexity of the motion planning
schemes were increased and when the filling rate increased. They also suggested that for
limited resource based systems such as automated warehouse, future research should focus
on the collision handling. Both Hama et al. [51] and Stiefelhagen et al. [52] considered only
unit-sized objects. Sarrafzadeh and Maddila [53] considered the movement of a square unit-size
object in the presence of movable and fixed square unit-size obstacles. They give the conditions
(namely, the number of empty modules) required to guarantee the movement of the object from
its initial to final positions under various conditions.
For non-unit sized objects, Sharma and Aloimonos [54] proposed solving the
warehousemanβs problem by imposing constraints on the sizes of objects and the distribution
of free space to make the problem, which is otherwise P-SPACE complete, able to be solved
in polynomial time. In their work, the free space for arranging objects is provided as a part of
the warehouse. The main issue remaining unsolved based on this previous work is
determining the lower bound or minimum requirement of the free space based on the sizes of
the objects.
2.4.
Deadlock and Its Prevention, Avoidance and Resolution
For a system with simultaneous resource utilization, deadlock is a common problem. As
needs resource 1 to finish the process while process 2 needs resource 2 and currently
occupies resource 1.
Figure 2.5: A deadlock occurrence in a system with simultaneous resource utilization.
According to the literature, the deadlock problem in the system with simultaneous resource
utilization has been studied within three main contexts, namely, computer operating systems,
flexible manufacturing system, and multi-robot planning systems. The details of how to deal
with deadlock problem in each context are described as follows.
In computer operating systems, Coffman et al. [55] gave the necessary and sufficient
conditions for deadlock occurrence as follows. The first condition is mutual exclusivity, i.e.,
tasks claim exclusive control of the resource they require. Secondly, there is no preemption
in the system, i.e., resources cannot be forcibly removed from the tasks holding them until
the resources are used to completion. Thirdly, processes hold resources allocated to them
while waiting for additional resources. The last condition is circular wait, i.e., a circular
claim of tasks exists such that each task holds one or more resources that are being requested Process 1
Resource 1
by the next task in the claim. Havender [56] described the deadlock problems in the context
of multitasking software design, i.e., the system that allows processing tasks to be performed
concurrently. He mentioned that all multitasking systems are subjected to deadlock and if one
occurs, there were no known general techniques to correct the situation. In this context, a
deadlock arises when a group of tasks becomes interlocked in such a way that all these tasks
require resources from each other and cannot be progressed and completed. He also proposed
approaches to avoid deadlock situations as follows. The first approach is to request a
resource for a task while another resource has been allocated to it only if it can be
demonstrated that no other group of interlocked tasks will exist concurrently that have been
allocated the required resource or will later require the resource allocated to the original task.
Secondly, required resources are requested collectively and a task does not proceed until all
required resources have been obtained. For the last approach, if holding a formerly obtained
resource may prevent acquisition of an additional resource, release the original resource
before obtaining the additional resource.
Holt [57] proposed deadlock detection algorithms for computer systems. In his work, a
computer system has three main components, namely, processes, reusable resources, and
consumable resources. A reusable resource represents physical objects such as tape drives or
disk tracks. A reusable resource can be acquired by a process and released to be available
again when the process finished its tasks. On the other hand, a consumable resource
represents logical objects such as messages and signals. A consumable resource can be
consumed by a process and a new consumable resource can be produced again by its
is blocked when it cannot acquire required resources to complete its tasks and if a process
will never be able to be unblocked again then the process is said to be deadlocked. A general
resource graph was used to represent a computer system where its nodes representing
processes and resources and edges representing interactions. A general resource graph can be
reduced by deleting edges of an unblocked process. Based on this representation, a sufficient
condition to show that there are no deadlocks in a computer system is that if a general
resource graph can be completely reducible then there is no deadlocks in the system.
However, the complexity of showing that a general resource graph is completely reducible is
n! where n is the number of nodes in the graph. For some special classes of computer systems such as systems with single unit request or systems with only consumable or reusable
resources, more efficient algorithms to detect deadlocks were proposed.
Obermarck [58] proposed an algorithm to detect deadlock among transactions running
concurrently in distributed processing network. In this context, a transaction is an abstraction
for the application processing performed to take a database from one state to another state.
When a transaction is suspended waiting for a second transaction and the second transaction
is waiting, either directly or indirectly, for the first transaction, it results a circular waiting
condition called deadlock. The deadlock detection algorithm is based on directed graph
called transaction-wait-for graph (TWFG) in which nodes represent transactions and directed
edges represent a transaction is waiting for another transaction. In this case, a deadlock is
defined as the relationship between transactions waiting for other transactions in such a
manner that none can proceed and is represented in TWFG as a cycle. Therefore, the
cannot be broken. Bracha and Toueg [59] also applied wait-for-graph (WFG), similar to that
proposed by Holt [57], to detect deadlocks in distributed computer operating system. In
WFG, nodes correspond to processes in the system and a directed edge (v,u) corresponds to a process v that issued a request to a process u for some services or resources that u is holding. An active process is one that is not waiting for any other process. When an active process
requires some processes to carry out an action on its behalf, it sends request messages to all
the processes able to perform the action then that active process becomes blocked and waits
until the requested action to be carried out. States in the system change from issuing and
granting of requests called transformations and a schedule is a sequence of transformations.
A process or node in WFG is identified as deadlocked if there is no schedule that can change
that process from blocked to active states. Briefly, the deadlock detection algorithm tries
every possible way to change the state of a suspected process or node from being blocked to
active. At the end of the algorithm, if the blocked process cannot become active, then it can
be concluded that the process is deadlocked.
ZΓΆbel [60] reviewed and classified studies related to deadlock problems in computer
operating system. Three main approaches were generally used to handle deadlocks in
computer operating system: detection/recovery, prevention, and avoidance. For the detection
and recovery approach, deadlocks are acceptable and can occur in the system. The reasons
are either deadlocks presume a low frequency of occurrence or recovery from deadlocks is
easy to implement. The deadlock prevention approach does not allow deadlocks to occur in
the system in the planning stage. Only processes or transactions which are ensured not lead to
not occur in the system must be followed. Generally, these restrictions reduce resource
utilization efficiency. Deadlock avoidance differs from deadlock prevention in that the
avoidance approaches are generally not complete, i.e., it is not guaranteed that deadlock will
not occur in the system. For each state transition in the system, the next transition state is
examined whether it can cause deadlock or not. If the next transition state can be deadlocked
then it will be avoided or other measures will be implemented to avoid the deadlock in the
next transition to occur. However, even if the next immediate state cannot cause a deadlock,
the state transition after the immediate state might cause deadlocks. Khonsari et al. [61]
compared deadlock recovery and avoidance algorithms used in wormhole-switched
networks. The deadlock avoidance algorithm studied was Duatoβs routing algorithm. The
algorithm uses two classes of virtual channels to avoid deadlocks. Three deadlock recovery
algorithms were considered, namely, compressionless routing, software-based routing, and
Disha routing. Compressionless and Disha routing algorithms use blocking time to detect a
deadlock, i.e., if blocking time exceeds a pre-specified value then it is presumed to be
deadlocked. All deadlock recovery algorithms use buffer channels to solve deadlocks when
detected. Based on the performance analysis implemented by analytical models, the results
reveal that in most cases deadlock recovery routing algorithms exhibit superior performance
characteristics over their deadlock avoidance counterparts.
In the context of flexible manufacturing system, based on Coffman et al. [55], the first
three necessary and sufficient conditions for deadlock always hold in this context; therefore,
preventing the last condition, avoiding circular wait, is the only means to avoid deadlock in
automated manufacturing systems. They mentioned that, in computer systems, it is normally
assumed that only bounds on the total number of resources required by each process is
known; however, in automated manufacturing systems, each job enters the system and
follows a specific working sequence, thus both the number and sequence of resources
required for each process are known in this case. Similar to computer operating system, three
main approaches can be applied to handle deadlocks, namely, prevention, detection/recovery
and avoidance. In the aspect of modeling, there were, at least, three modeling approaches
extensively deployed, namely, directed graph/digraph, automata, and Petri nets. The authors
mentioned that there was no conclusive evidence for the superiority of any one approach.
According to the authorsβ review, prevention strategies usually use information about process
resource requirements and each process has to specify all required resources before
transactions begin. An advantage of prevention approach is that it does not require the
knowledge of the system state to realize the control leading to a simple offline control law.
For detection and recovery approaches, a monitoring mechanism is used to detect the
deadlock occurrence and the usual recovery scheme is to pre-empt some deadlock resources
by using a buffer. The authors recommended utilizing deadlock detection and recovery when
deadlock is rare and detection and recovery process is not expensive and faster than deadlock
generation. For deadlock avoidance algorithm, the authors recommend that the algorithm
should consider not only deadlock states but also unsafe states, i.e., the states that are not
deadlocks but unavoidably lead to deadlock states. To ensure that a state transition is safe,
generally, all possible sequences of transitions must be considered. Araki et al. [63] showed
four properties that a useful deadlock avoidance policy should have are as follows. An
avoidance algorithm should guarantee deadlock-free situation in the system. It should also be
computationally tractable. It should still maintain flexibility of resource allocation in the
system.
Finally, correctness and scalability of an avoidance algorithm should be independent of
system configuration. From the modeling aspect, there are three main modeling approaches,
namely, graph theoretic, automata, and Petri nets. Wysk et al. [65] first applied a graph
theoretic approach to study deadlock in flexible manufacturing system. In their study, each
machine can perform only one operation at a time, i.e., the capacity of each machine is equal
to one. A directed graph, of which the nodes represent resources and the edges represent all
possible transitions based on the processes in a system, is deployed. The necessary and
sufficient conditions for deadlock in a system are that there is, at least, a cycle formed by the
part routing and the number of jobs occupying the nodes of the cycle must be equal to the
numbers of nodes and edges of the cycle.
Cho et al. [66], Kumaran [67], and Fanti et al. [68] proposed to utilize two directed
graphs instead of only one graph to describe dynamic behavior of the system. The first graph
represents static system where vertices represent all the resources pertaining to each working
procedure and edges represent sequence of working procedures based on resource utilization.
The other directed graph is a sub-graph of the first graph represent the dynamic behavior. In
the second graph, edges represent only the utilization of resources at the current time step and
those that will be used in the next immediate step. The necessary and sufficient condition of
dynamic behavior. However, for this type of deadlock avoidance algorithm, even the next
immediate state is safe; it can also inevitably lead to the deadlock situations. This type of
state is called impending flow deadlock state. In order to overcome this situation, Fanti et al.
([68], [69]) introduced the second level deadlock (SLD). For the deadlock avoidance policy
with one-step look-ahead, the authors showed that if there is no SLD in the next step then it
can guarantee that deadlock will not exist in the system. The next modeling approach is
automata. Reveliotis and Ferreira [70] pioneered the finite state automata to formulate
deadlock problems in automated manufacturing system. An automated manufacturing system
was modeled as a finite state automaton with static routing. Policies such as resource
upstream neighborhood deadlock prevention and resource order deadlock avoidance were
then derived from the automaton models.
The last modeling technique is Petri nets. Viswanadham el al. [71] proposed Petri net
models for deadlock avoidance and prevention algorithm. Their algorithm considers only a
total deadlock where no parts in the system can complete their routes but not a partial
deadlock where only some parts in the system are deadlocked. Both prevention and
avoidance policy use the exhaustive reachability analysis to enumerate all possible markings
according to an initial marking. This could be prohibitive if the state space is large. Banaszak
and Krogh [72] proposed a deadlock avoidance algorithm in flexible manufacturing systems
with concurrently competing process flows. Petri nets were used to model the system and
called production Petri net (PPN). A PPN, G, is five-tuple where πΊ = {π, π, πΌ, π, π0}. P is a place in a Petri net and represents production process sequence and resource availability in
transition and represents flow of jobs from one sequence to another sequence in the
production processes for each product. I and O are input and output arcs linking production sequence and resource availability places. π0 is the initial marking of the production system where all resources are still available. The authors showed the necessary conditions for
deadlock occurrence and define the restricted policies to ensure that these necessary
conditions cannot be satisfied under the restricted policies thus a deadlock cannot occur. Set
of resources are classified into two categories, unshared and shared resources. Unshared
resources are required only once in only one production sequence and shared resources are
vice versa. A zone is comprised of shared and unshared resources. The avoidance policy has
two rules. First, in case of unshared resources, a transition can be fired only if a job enters a
new zone and the capacity of unshared resources in that zone exceed the number of jobs
currently in that zone. Second, in case of shared resources, a transition can be fired only if all
the resources in the remainder of that zone must be available except the one held by the job.
It can be shown that if the processing of jobs in the system follows these rules then it can be
guaranteed that a deadlock will not occur. Ezpeleta et al. [73] proposed a particular class of
Petri net called systems of simple sequential processes (S3PR). For S3PR, a place represents a
resource and a transition represents a production process. The deadlock situations, in this
case, strongly connect to a substructure of the net called siphon. A siphon is a proper subset,
S, of places in Petri nets where its preset is also a proper subset of its post-set. The sufficient condition to guarantee a deadlock not arising in the system is that the number of markings in
authors suggest to add a buffer place into the siphons for which a deadlock could occur to
prevent the deadlock.
In the context of multi-robot planning, Rooker and Birk [74] studied multi-robot
exploration under the constraints of wireless networking. In their study, the deadlock
situations occur when the different robots want to move to different parts of the explored
environment but they are blocked in their movement by the communication maintenance
constraint. They tried to control the multi-robot pack to avoid the deadlock situation but all
strategies failed. Thus, they proposed another means to deal with the deadlock situation,
detecting and recover situation from the deadlocks. First, to detect deadlocks, the authors
proposed two criteria: no progress in the exploration and limited movement of the robots.
The detection of no progress can be implemented by checking if all the robots are not
updating their internal map and there are no new information received for a long period of
time. However, only the no-progress condition alone is not enough to conclude whether robot
pack are facing deadlock situation. For example, at the end of an exploration when almost the
entire environment is explored, it can happen that the robots have to travel a larger distance
and take a longer time until finding a new frontier. Thus the detection of robot movement is
an integral part of the deadlock detection. To check if a robot is moving significantly, the
minimum and maximum limits of the x and y coordinates of the robots are stored. For each time step, the new position of a robot is compared with the minimum and maximum
coordinates visited so far. If the new x or y coordinate is smaller than the minimum or larger than the maximum values then they are updated. After a certain number of time steps, the
is smaller than a certain pre-specified distance then the robot is considered to be stuck. For a
predetermined period of time steps, if these two conditions are satisfied, then we can
conclude that deadlocks occur for a pack of robots and the recovery scheme must be
implemented. To recover robots from the deadlocks, the main task of exploring frontier is
temporarily suspended. Then, one robot among the pack of robots confronting deadlocks is
assigned to be meeting point and other robots after suspending task for frontier exploration
try to travel and meet the meeting point robot. By doing this, deadlock situations can be
solved and robots are reassigned to main task of exploring frontier again. Qutub et al. [75]
studied planning deadlock situations for multi-robot cooperation with plan-merging
paradigm. In this case, temporal relations between robots plan-merging activities can create
waiting cycle and planning deadlocks. The planning dependency graphs were used to detect
such waiting cycles and deadlocks. When detected, deadlocks can be recovered by
master-slave approach where a robot becomes the master of the other robots in the deadlocks and
resolves conflicts.
Lin and Hsu [76] studied the cooperation and deadlock-handling in a multi-robot system
used for object movement. In this system, robots are cooperated to move an object. A
deadlock can occur when there is a waiting cycle in the system. For example, there are four
robots, π1, π2, π3 and π4 and two objects π1and π2 that need at least three robots to move each of them. π1 and π2 are trying to move π1 and waiting for π3or π4. At the same time, π3and π4
are trying to move π2 and waiting for π1or π2. In this case, both tasks are deadlock and cannot be completed. The authors proposed three schemes to handle with the deadlock situation in
condition for deadlock occurrence is that if any robots stays in waiting state for more than
2(Nβ1) MTT where N is the total number of robots in the system and MTT is the maximum travel time within the environment, then the system is deadlocked. If a deadlock is detected,
then it can be resolved by reassigning robots to do one task before the other tasks. The other
two schemes for dealing with deadlocks are to prevent deadlocks from occurring. This can be
implemented by assuring that the waiting cycle will not occur in the system. The first
deadlock prevention scheme is to assign priorities to the objects to be moved. Then if the
conflict occurs, the higher priority object always acquires enough of the required robots.
Another possible prevention scheme is to provide the feasible movement sequence to objects
such that the higher order objects in the sequence always acquire the required number of
robots and complete the task before other lower order objects are considered.
Yingying and Jingping [77] applied the ant colony algorithm for multi-robot
cooperation. In their study, the difficulty of the tasks to be implemented by robots was not
known in advance and task deadlock could occur. Task deadlock is the situation where robots
persist in trying a task beyond their capability so that they cannot complete that task and lose
chance to try other tasks. In order to avoid task deadlock, the authors introduce an adaptive
attenuation factor to the ant colony algorithm. The adaptive attenuation factor reduces the
pheromone level and probability to attract more robots to a task if that task has no progress
for some period of time. Regele and Levi [78] proposed heuristic priority adjustment for
multi-robot path planning cooperation. Basically, each robot tries to arrive at its destination
as soon as possible. In case of conflict, a higher priority robot can move before a lower
In principle, if a robot is blocked, then its priority is raised; if not, then its priority is lowered.
The authors mentioned that deadlocks can occur in the situations where there are a large
number of robots within a limited free space. In the scenario with more than fifty percent of
the space occupied by robots, the proposed algorithm was not able to complete the tasks by
navigating all robots to their destination and deadlocks occurred that could not be resolved.
2.5.
Summary of the Literature
In summary, the relationship between the developed algorithms in this research and the
previous work in the literature can be shown in Table 2.1.
Table 2.1: Relationship between the developed algorithms and previous in the literature.
Related research How to apply in this research
15-puzzle and its extension To reallize the complexity of the problem ([7],[13]) at hand and know how to properly design the algorithm e.g. exact or hueristic. In addtion, the ideas to control the sequential movement of objects within limited free space area ([15]-[18]), can be applied to the developed
algorithms.
Rectilinear route planning The ideas to control the movement of single object among fixed obstacle ([19],[21]) can be applied to the developed algorithms.
Motion coordination of multiple moving objects
The ideas of controlling the movement of multiple objects within the unlimited free space area
([35],[36],[37],[38],[52],[53]) can be applied to the developed algorithms.
How to handle deadlocks in the system with simultaneous resource utilization
Ideas for how to detect, prevent from, avoid and recover from the deadlocks in in the system with simultaneous resource utilization ([55],[57],[65],[66]-[68],[71],[74]-[78]) can be applied to handle the deadlocks in our system.
Chapter 3
Algorithm for Square Unit-size Objects
As reviewed in Chapter 2, the most basic case of object movement control is the movement
of a single object among fixed obstacles, e.g., rectilinear path planning, sliding puzzle
problems. In this case, only efficient route planning is necessary for the movement of that
single object to its destination. A more complicated case is when there are multiple objects
moving simultaneously, e.g., motion coordination among moving obstacles. In this case,
route planning alone is not enough to achieve the goal of bringing all moving objects to their
destinations because of the conflicts that might occur among the moving objects. Various
ideas in the literature have been proposed to resolve the movement conflicts assuming that
there is enough free space to maneuver the movement. However, the degree of complexity in
resolving the movement conflicts also increases as the number of objects increases and free
space for the movement decreases.
In this chapter, the algorithm for the simultaneous rectilinear movement of square
unit-size objects is introduced. The algorithm is designed to work efficiently, especially, when the
utilization or density (i.e., the number of the objects per free space area) is high. Section 3.1
describes some preliminaries and the overall concept of the algorithm. Sections 3.2 to 3.4
discuss the details of each main part of the algorithm, namely, route planning, the tagging
process, and overall control. Section 3.5 shows the worst-case runtime analysis of the
3.1.
Preliminaries and Overall Concept
The following preliminary concepts are needed to understand the operation of the system and
the algorithm:
1. The area W under consideration is denoted by a rectangular region comprised of m Γ n
unit square modules and all distances are restricted to be rectilinear.
2. At any instant, a module can be occupied by a single object or is empty.
3. There are two types of objects in the system, namely, active and inactive objects. An
active object has a specific destination that it is required to move to. An inactive object
has no specific destination; however, an inactive object can be changed to an active one if
system operators specify its destination. An inactive object would correspond to a
package that is being stored at the warehouse for an extended period of time which might
need to be moved out of the way of an active object.
4. Each object in the system has a unique priority.
5. An object can only move (push) lower priority objects.
According to the system defined above, given an initial configuration of square unit-size
objects in a confined rectangular space and a final configuration specifying destinations of
active objects as illustrated in Figure 3.1, the algorithm heuristically tries to move all active
objects to their destinations while minimizing traversal time. For example, the active object
number 15 (object 15) has its initial position at (1,4) in the initial configuration and its
destination at (6,1) in the final configuration, while object number 3 (object 3) is inactive
![Figure 1.2: An example of PLN for home delivery logistics. (Source: Kay [5])](https://thumb-us.123doks.com/thumbv2/123dok_us/1587693.1195672/15.612.97.535.158.374/figure-example-pln-home-delivery-logistics-source-kay.webp)
