Heuristics and Lower Bounds for the Simple Assembly Line Balancing Problem Type 1: Overview, Computational Tests and Improvements

Assigning tasks to work stations is an essential problem which needs to be addressed in an assembly line design. The most basic model is called simple assembly line balancing problem type 1 (SALBP-1). We provide a survey on 12 heuristics and 9 lower bounds for this model and test them on a traditional and a lately-published benchmark dataset. The present paper focuses on algorithms published before 2011. We improve an already existing dynamic programming and a tabu search approach significantly. These two are also identified as the most effective heuristics; each with advantages for certain problem characteristics. Additionally we show that lower bounds for SALBP-1 can be distinctly sharpened when merging them and applying problem reduction techniques

Exact and heuristic methods for solving the Robotic Assembly Line Balancing Problem

[EN] In robotic assembly lines, the task times depend on the robots assigned to each station. Robots are considered an unlimited resource and multiple robots of the same type can be assigned to different stations. Thus, the Robotic Assembly Line Balancing Problem (RALBP) consists of assigning a set of tasks and a type of robot to each station, subject to precedence constraints between the tasks. This paper proposes a lower bound, and exact and heuristic algorithms for the RALBP. The lower bound uses chain decomposition to explore the graph dependencies. The exact approaches include a novel linear mixed-integer programming model and a branch-bound-and-remember algorithm with problem-specific dominance rules. The heuristic solution is an iterative beam search with the same rules. To fully explore the different characteristics of the problem, we also propose a new set of instances. The methods and algorithms are extensively tested in computational experiments showing that they are competitive with the current state of the art. (C) 2018 Elsevier B.V. All rights reserved.Borba, L.; Ritt, M.; Miralles Insa, CJ. (2018). Exact and heuristic methods for solving the Robotic Assembly Line Balancing Problem. European Journal of Operational Research. 270(1):146-156. https://doi.org/10.1016/j.ejor.2018.03.011S146156270

Solving the accessibility windows assembly line problem level 1 and variant 1 (AWALBP-L1-1) with precedence constraints

Assembly line balancing problems (ALBPs) are among the most studied combinatorial optimization problems due to their relevance in many production systems. In particular, the accessibility windows ALBP (AWALBP) may arise when the workpieces are larger than the workstations, which implies that at a given instant the workstations have access to only a portion of the workpieces. Thus, the cycle is split into forward steps and stationary stages. The workpieces advance during the forward steps and the tasks are processed during the stationary stages. Several studies have dealt with the AWALBP assuming that there are no precedence relationships between tasks. However, this assumption is not always appropriate. In this work we solve the first level of AWALBP (AWALBP-L1) considering the existence of precedence relationships. Specifically, this work deals with variant 1 (AWALBP-L1-1), in which each task can be performed at only one workstation and, therefore, only the stationary stages and the starting instants in which the tasks are performed have to be decided. We design a solution procedure that includes pre-processing procedures, a matheuristic and a mixed integer linear programming model. An extensive computational experiment is carried out to evaluate its performance.Peer ReviewedPostprint (author's final draft

Hybrid metaheuristics for the accessibility windows assembly line balancing problem level 2 (AWALBP-L2)

This paper addresses an assembly line balancing problem in which the length of the workpieces is larger than the width of the workstations. The problem differs from traditional variants of assembly line balancing in the sense that only a portion of the workpiece, or portions of two consecutive workpieces, can be reached from any workstation. Consequently, at any stationary stage of the cycle, each workstation can only process a portion of the tasks, namely, those which are inside the area of a workpiece that is reachable from the workstation. The objective is to find a (cyclic) movement scheme of the workpieces along the line and a task assignment to stationary stages of the production process, while minimizing the cycle time. We propose three hybrid approaches of metaheuristics and mathematical programming - one based on simulated annealing and the other two based on tabu search, relying on different neighborhood definitions. The two former approaches make use of a classical neighborhood, obtained by applying local changes to a current solution. The latter approach, in contrast, draws ideas from the corridor method to define a corridor around the current solution, via the imposition of exogenous constraints on the solution space of the problem. An extensive computational experiment is carried out to test the performance of the proposed approaches, improving the best results published to date.Postprint (author's final draft

A new model for supply chain network design with integrated assembly line balancing decisions

Supply chain network design aims at the integration of the different actors of a supply chain within a single framework in order to optimise the total profit of the system. In this paper, we consider the integration of line balancing issues within the tactical decisions of the supply chain, and we offer a novel model and a solution approach for the problem. The new approach decomposes the problem into multiple line balancing problems and a mixed integer linear model, which is easier to solve than the previously available non-linear mixed integer formulation. The results show that the new method is able to solve previously studied models within a fraction of the reported running times, and also allows us to solve larger instances than those reported in earlier works. Finally, we also provide some analysis on the influence of the cost structure, the demand and the structure of the assembly process on the final configuration of the assemblies and the distribution network.Postprint (author's final draft

Enhancing Productivity and Performance Portability of General-Purpose Parallel Programming

This work focuses on compiler and run-time techniques for improving the productivity and the performance portability of general-purpose parallel programming. More specifically, we focus on shared-memory task-parallel languages, where the programmer explicitly exposes parallelism in the form of short tasks that may outnumber the cores by orders of magnitude. The compiler, the run-time, and the platform (henceforth the system) are responsible for harnessing this unpredictable amount of parallelism, which can vary from none to excessive, towards efficient execution. The challenge arises from the aspiration to support fine-grained irregular computations and nested parallelism. This work is even more ambitious by also aspiring to lay the foundations to efficiently support declarative code, where the programmer exposes all available parallelism, using high-level language constructs such as parallel loops, reducers or futures. The appeal of declarative code is twofold for general-purpose programming: it is often easier for the programmer who does not have to worry about the granularity of the exposed parallelism, and it achieves better performance portability by avoiding overfitting to a small range of platforms and inputs for which the programmer is coarsening. Furthermore, PRAM algorithms, an important class of parallel algorithms, naturally lend themselves to declarative programming, so supporting it is a necessary condition for capitalizing on the wealth of the PRAM theory. Unfortunately, declarative codes often expose such an overwhelming number of fine-grained tasks that existing systems fail to deliver performance. Our contributions can be partitioned into three components. First, we tackle the issue of coarsening, which declarative code leaves to the system. We identify two goals of coarsening and advocate tackling them separately, using static compiler transformations for one and dynamic run-time approaches for the other. Additionally, we present evidence that the current practice of burdening the programmer with coarsening either leads to codes with poor performance-portability, or to a significantly increased programming effort. This is a ``show-stopper'' for general-purpose programming. To compare the performance portability among approaches, we define an experimental framework and two metrics, and we demonstrate that our approaches are preferable. We close the chapter on coarsening by presenting compiler transformations that automatically coarsen some types of very fine-grained codes. Second, we propose Lazy Scheduling, an innovative run-time scheduling technique that infers the platform load at run-time, using information already maintained. Based on the inferred load, Lazy Scheduling adapts the amount of available parallelism it exposes for parallel execution and, thus, saves parallelism overheads that existing approaches pay. We implement Lazy Scheduling and present experimental results on four different platforms. The results show that Lazy Scheduling is vastly superior for declarative codes and competitive, if not better, for coarsened codes. Moreover, Lazy Scheduling is also superior in terms of performance-portability, supporting our thesis that it is possible to achieve reasonable efficiency and performance portability with declarative codes. Finally, we also implement Lazy Scheduling on XMT, an experimental manycore platform developed at the University of Maryland, which was designed to support codes derived from PRAM algorithms. On XMT, we manage to harness the existing hardware support for scheduling flat parallelism to compose it with Lazy Scheduling, which supports nested parallelism. In the resulting hybrid scheduler, the hardware and software work in synergy to overcome each other's weaknesses. We show the performance composability of the hardware and software schedulers, both in an abstract cost model and experimentally, as the hybrid always performs better than the software scheduler alone. Furthermore, the cost model is validated by using it to predict if it is preferable to execute a code sequentially, with outer parallelism, or with nested parallelism, depending on the input, the available hardware parallelism and the calling context of the parallel code

Mathematical model and agent based solution approach for the simultaneous balancing and sequencing of mixed-model parallel two-sided assembly lines

Copyright © 2014 Elsevier. NOTICE: this is the author’s version of a work that was accepted for publication in International Journal of Production Economics. Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. A definitive version was subsequently published in International Journal of Production Economics, DOI: 10.1016/j.ijpe.2014.08.010One of the key factors of a successfully implemented mixed-model line system is considering model sequencing problem as well as the line balancing problem. In the literature, there are many studies, which consider these two tightly interrelated problems individually. However, we integrate the model sequencing problem in the line balancing procedure to obtain a more efficient solution for the problem of Simultaneous Balancing and Sequencing of Mixed-Model Parallel Two-Sided Assembly Lines. A mathematical model is developed to present the problem and a novel agent based ant colony optimisation approach is proposed as the solution method. Different agents interact with each other to find a near optimal solution for the problem. Each ant selects a random behaviour from a predefined list of heuristics and builds a solution using this behaviour as a local search rule along with the pheromone value. Different cycle times are allowed for different two-sided lines located in parallel to each other and this yields a complex problem where different production cycles need to be considered to build a feasible solution. The performance of the proposed approach is tested through a set of test cases. Experimental results indicate that considering model sequencing problem with the line balancing problem together helps minimise line length and total number of required workstations. Also, it is found that the proposed approach outperforms other three heuristics tested