The automation of a truck-trailer offers enormous potential for safe and efficient transportation. The optimal control approaches, e.g., MPC, have significantly improved the tracking accuracy and the smoothness of the lateral control of vehicles. MPC application for a truck-trailer is complex compared to a car as the system behavior is different for forwarding and reversing. In this paper, we propose a lateral MPC algorithm for a truck-trailer, where we linearize the system dynamics around a nominal trajectory computed using a control law. The control law formulated as cascade control computes the nominal trajectory, an initial guess to the optimization process. The nominal trajectory lies in the vicinity of the optimal trajectory. We linearize the system dynamics around the computed nominal trajectory, reducing the linearization errors. The region of validity of the linearized system dynamics is narrow due to the system’s instability during reverse driving. A quadratic optimization problem subjective to the linear dynamics of the truck-trailer and state and input constraints defines the optimal control problem. The nominal trajectory is stable over the prediction horizon while reversing, so is the linear prediction model, improving optimization feasibility. Further, the discretization errors are also reduced using a small discrete step and integrating the model multiple times between two prediction steps. We tested the developed MPC approach on a prototypical full-scale truck-trailer system and discussed results. The developed MPC is considerably fast and accurate for real-time application.

We consider practical methods for the problem of finding a minimum-weight triangulation (MWT) of a planar point set, a classic problem of computational geometry with many applications. While Mulzer and Rote proved in 2006 that computing an MWT is NP-hard, Beirouti and Snoeyink showed in 1998 that computing provably optimal solutions for MWT instances of up to 80,000 uniformly distributed points is possible, making use of clever heuristics that are based on geometric insights. We show that these techniques can be refined and extended to instances of much bigger size and different type, based on an array of modifications and parallelizations in combination with more efficient geometric encodings and data structures. As a result, we are able to solve MWT instances with up to 30,000,000 uniformly distributed points in less than 4 minutes to provable optimality. Moreover, we can compute optimal solutions for a vast array of other benchmark instances that are not uniformly distributed, including normally distributed instances (up to 30,000,000 points), all point sets in the TSPLIB (up to 85,900 points), and VLSI instances with up to 744,710 points. This demonstrates that from a practical point of view, MWT instances can be handled quite well, despite their theoretical difficulty.

Until upcoming autonomous vehicles can handle every scenario in all operation domains there will be situations, in which the human driver needs to retrieve control of the vehicle. This can lead to safety issues as literature shows impaired driving performance after taking over from highly automated driving. A discrete switch of control might be a valid option to hand over to an attentive human driver. However, it is questionable if this is a safe way for a transition of control to somebody who is distracted at the time of the takeover request. Instead, gradually shifting control via a period of haptic shared control can provide guidance during the process of establishing situation awareness. Here, we present different design concepts for handing over control from a controller to a human partner. To analyze these concepts, we designed an experiment, in which the participants need to take over a simplified steering task when requested by the automation. We conducted a study comparing two discrete switching transitions and three concepts in which the authority of the controller fades out slowly. The results show that in situations, needing a continuation of the control action of the automation, an early switch-off underperformed compared to the other concepts. If the situation demanded action during the transition the shared control approaches achieved the lowest tracking error. A survey of the participants revealed that gradually shifting transitions lead to a sense of better performance and are also regarded as more comfortable. The best overall results were obtained by a concept which models human behavior and considers it within the takeover process. This approach provides a systematic method for the design of authority transitions by finding the best trade-off between guidance and handover.

The maturation of the Web platform has given rise to sophisticated and demanding Web applications such as interactive 3D visualization, audio and video software, and games. With that, efficiency and security of code on the Web has become more important than ever. Yet JavaScript as the only built-in language of the Web is not well-equipped to meet these requirements, especially as a compilation target.

Priority queues with parallel access are an attractive data structure for applications like prioritized online scheduling, discrete event simulation, or greedy algorithms. However, a classical priority queue constitutes a severe bottleneck in this context, leading to very small throughput. Hence, there has been significant interest in concurrent priority queues with relaxed semantics. We investigate the complementary quality criteria rank error (how close are deleted elements to the global minimum) and delay (for each element x, how many elements with lower priority are deleted before x). In this paper, we introduce MultiQueues as a natural approach to relaxed priority queues based on multiple sequential priority queues. Their naturally high theoretical scalability is further enhanced by using three orthogonal ways of batching operations on the sequential queues. Experiments indicate that MultiQueues present a very good performance-quality tradeoff and considerably outperform competing approaches in at least one of these aspects. We employ a seemingly paradoxical technique of "wait-free locking" that might be of more general interest to convert sequential data structures to relaxed concurrent data structures.

Concurrent data-structures, such as stacks, queues, and deques, often implicitly enforce a total order over elements in their underlying memory layout. However, much of this order is unnecessary: linearizability only requires that elements are ordered if the insert methods ran in sequence. We propose a new approach which uses timestamping to avoid unnecessary ordering. Pairs of elements can be left unordered if their associated insert operations ran concurrently, and order imposed as necessary at the eventual removal.

We propose a new memory model called short-term memory for managing objects on the heap. In contrast to the traditional persistent memory model for heap management, objects in short-term memory expire after a finite amount of time, which makes deallocation unnecessary. Instead, expiration of objects may be extended, if necessary, by refreshing. We have developed a concurrent, incremental, and non-moving implementation of short-term memory for explicit refreshing called self-collecting mutators that is based on programmer-controlled time and integrated into state-of-the-art runtimes of three programming languages: C, Java, and Go. All memory management operations run in constant time without acquiring any locks modulo the underlying allocators. Our implementation does not require any additional heap management threads, hence the name. Expired objects may be collected anywhere between one at a time for maximal incrementality and all at once for maximal throughput and minimal memory consumption. The integrated systems are heap management hybrids with persistent memory as default and short-term memory as option. Our approach is fully backwards compatible. Legacy code runs without any modifications with negligible runtime overhead and constant per-object space overhead. Legacy code can be modified to take advantage of short-term memory by having some but not all objects allocated in short-term memory and managed by explicit refreshing. We study single- and multi-threaded use cases in all three languages macro-benchmarking C and Java and micro-benchmarking Go. Our results show that using short-term memory (1) simplifies heap management in a state-of-the-art H.264 encoder written in C without additional time and minor space overhead, and (2) improves, at the expense of safety, memory management throughput, latency, and space consumption by reducing the number of garbage collection runs, often even to zero, for a number of Java and Go programs.

Today's cluster and grid environments demand the usage of product-specific APIs and tools for developing distributed applications. We give an overview of the distributed resource management application API (DRMAA) specification, which defines a common interface for job submission, control, and monitoring. The DRMAA specification was developed by the authors at the open grid forum standardization body, and has meanwhile significant adoption in academic and commercial cluster systems. Within this paper, we describe the basic concepts of the finalized API, and explain issues and findings with the standardization of such an unified interface.