9,286 research outputs found
RoboTSP - A Fast Solution to the Robotic Task Sequencing Problem
In many industrial robotics applications, such as spot-welding,
spray-painting or drilling, the robot is required to visit successively
multiple targets. The robot travel time among the targets is a significant
component of the overall execution time. This travel time is in turn greatly
affected by the order of visit of the targets, and by the robot configurations
used to reach each target. Therefore, it is crucial to optimize these two
elements, a problem known in the literature as the Robotic Task Sequencing
Problem (RTSP). Our contribution in this paper is two-fold. First, we propose a
fast, near-optimal, algorithm to solve RTSP. The key to our approach is to
exploit the classical distinction between task space and configuration space,
which, surprisingly, has been so far overlooked in the RTSP literature. Second,
we provide an open-source implementation of the above algorithm, which has been
carefully benchmarked to yield an efficient, ready-to-use, software solution.
We discuss the relationship between RTSP and other Traveling Salesman Problem
(TSP) variants, such as the Generalized Traveling Salesman Problem (GTSP), and
show experimentally that our method finds motion sequences of the same quality
but using several orders of magnitude less computation time than existing
approaches.Comment: 6 pages, 7 figures, 1 tabl
Taking advantage of hybrid systems for sparse direct solvers via task-based runtimes
The ongoing hardware evolution exhibits an escalation in the number, as well
as in the heterogeneity, of computing resources. The pressure to maintain
reasonable levels of performance and portability forces application developers
to leave the traditional programming paradigms and explore alternative
solutions. PaStiX is a parallel sparse direct solver, based on a dynamic
scheduler for modern hierarchical manycore architectures. In this paper, we
study the benefits and limits of replacing the highly specialized internal
scheduler of the PaStiX solver with two generic runtime systems: PaRSEC and
StarPU. The tasks graph of the factorization step is made available to the two
runtimes, providing them the opportunity to process and optimize its traversal
in order to maximize the algorithm efficiency for the targeted hardware
platform. A comparative study of the performance of the PaStiX solver on top of
its native internal scheduler, PaRSEC, and StarPU frameworks, on different
execution environments, is performed. The analysis highlights that these
generic task-based runtimes achieve comparable results to the
application-optimized embedded scheduler on homogeneous platforms. Furthermore,
they are able to significantly speed up the solver on heterogeneous
environments by taking advantage of the accelerators while hiding the
complexity of their efficient manipulation from the programmer.Comment: Heterogeneity in Computing Workshop (2014
A linear programming-based method for job shop scheduling
We present a decomposition heuristic for a large class of job shop scheduling problems. This heuristic utilizes information from the linear programming formulation of the associated optimal timing problem to solve subproblems, can be used for any objective function whose associated optimal timing problem can be expressed as a linear program (LP), and is particularly effective for objectives that include a component that is a function of individual operation
completion times. Using the proposed heuristic framework, we address job shop scheduling problems with a variety of objectives where intermediate holding costs need to be explicitly considered. In computational testing, we demonstrate the performance of our proposed solution approach
TASKers: A Whole-System Generator for Benchmarking Real-Time-System Analyses
Implementation-based benchmarking of timing and schedulability analyses requires system code that can be executed on real hardware and has defined properties, for example, known worst-case execution times (WCETs) of tasks. Traditional approaches for creating benchmarks with such characteristics often result in implementations that do not resemble real-world systems, either due to work only being simulated by means of busy waiting, or because tasks have no control-flow dependencies between each other. In this paper, we address this problem with TASKers, a generator that constructs realistic benchmark systems with predefined properties. To achieve this, TASKers composes patterns of real-world programs to generate tasks that produce known outputs and exhibit preconfigured WCETs when being executed with certain inputs. Using this knowledge during the generation process, TASKers is able to specifically introduce inter-task control-flow dependencies by mapping the output of one task to the input of another
- …