Dynamic Area Search with Shared Memory: A Meta-Framework to Improve Pathfinding Algorithms

Unmanned aerial vehicles (UAVs) are used in team for detecting targets and keeping them in its sensor range. There are various algorithms available for searching and monitoring targets. The complexity of the search algorithm increases if the number of nodes is increased. This paper focuses on multi UAVs path planning and Path Finding algorithms. Number of Path Finding and Search algorithms was applied to various environments, and their performance compared. The number of searches and also the computation time increases as the number of nodes increases. The various algorithms studied are Dijkstra's algorithm, Bellman Ford's algorithm, Floyd-Warshall's algorithm and the AStar algorithm. These search algorithms were compared. The results show that the AStar algorithm performed better than the other search algorithms. These path finding algorithms were compared so that a path for communication can be established and monitored.

In game Industry, the most trending research area is shortest path finding. There are many video games are present who are facing the problem of path finding and there is various algorithms are present to solve this problem. In this paper brief introduction is given in the most using algorithm for path finding and A* algorithm has been proved the best algorithm for resolving the problem of shortest path finding in games. It provides the optimal solution for path finding as compare to other search algorithm. At the start of the paper, brief introduction about the path finding is given. Then the reviews of different search algorithm are presented on the basis of path finding. After that information of A* algorithm and optimization techniques are described. In the last, application and examples how the path finding techniques are used in the game is addressed and future work and conclusion are drawn.

An energy-efficient reliable path finding algorithm for stochastic road networks with electric vehicles

Warehouse robots have been widely used by manufacturers and online retailer to automate good delivery process. One of the fundamental components when designing a warehouse robot is path finding algorithm. In the past, many path finding algorithms had been proposed to identify the optimal path and improve the efficiency in different conditions. For example, A* path finding algorithm is developed to obtain the shortest path, while D* obtains a complete coverage path from source to destination. Although these algorithms improved the efficiency in path finding, dynamic obstacle that may exist in warehouse environment was not considered. This paper presents AD* algorithm, a path finding algorithm that works in dynamic environment for warehouse robot. AD* algorithm is able to detect not only static obstacle but also dynamic obstacles while operating in warehouse environment. In dynamic obstacle path prediction, image of the warehouse environment is processed to identify and track obstacles in the path. The image is pre-processed using perspective transformation, dilation and erosion. Once obstacle has been identified using background subtraction, the server will track and predict future path of the dynamic object to avoid the obstacle.

Multicore processors usually communicate via shared memory, which is backed up by a shared level 2 cache and a cache coherence protocol. However, this solution is not a good fit for real-time systems, where we need to provide tight guarantees on execution and memory access times. In this paper, we propose a shared scratchpad memory as a time-predictable communication and synchronization structure, instead of the level 2 cache. The shared on-chip memory is accessed via a time division multiplexing arbiter, isolating the execution time of load and store instructions between processing cores. Furthermore, the arbiter supports an extended time slot where an atomic load and store instruction can be executed to implement synchronization primitives. In the evaluation we show that a shared scratchpad memory is an efficient communication structure for a small number of processors; in our setup, 9 cores. Furthermore, we evaluate the efficiency of the synchronization support for implementation of classic locks.

Graph-based approaches for simulating pedestrian dynamics in building models

On a distributed memory machine, hand-coded message passing leads to the most efficient execution, but it is difficult to use. Parallelizing compilers can approach the performance of hand-coded message passing by translating data-parallel programs into message passing programs, but efficient execution is limited to those programs for which precise analysis can be carried out. Shared memory is easier to program than message passing and its domain is not constrained by the limitations of parallelizing compilers, but it lags in performance. Our goal is to close that performance gap while retaining the benefits of shared memory. In other words, our goal is (1) to make shared memory as efficient as message passing, whether hand-coded or compiler-generated, (2) to retain its ease of programming, and (3) to retain the broader class of applications it supports.To this end we have designed and implemented an integrated compile-time and run-time software DSM system. The programming model remains identical to the original pure run-time DSM system. No user intervention is required to obtain the benefits of our system. The compiler computes data access patterns for the individual processors. It then performs a source-to-source transformation, inserting in the program calls to inform the run-time system of the computed data access patterns. The run-time system uses this information to aggregate communication, to aggregate data and synchronization into a single message, to eliminate consistency overhead, and to replace global synchronization with point-to-point synchronization wherever possible.We extended the Parascope programming environment to perform the required analysis, and we augmented the TreadMarks run-time DSM library to take advantage of the analysis. We used six Fortran programs to assess the performance benefits: Jacobi, 3D-FFT, Integer Sort, Shallow, Gauss, and Modified Gramm-Schmidt, each with two different data set sizes. The experiments were run on an 8-node IBM SP/2 using user-space communication. Compiler optimization in conjunction with the augmented run-time system achieves substantial execution time improvements in comparison to the base TreadMarks, ranging from 4% to 59% on 8 processors. Relative to message passing implementations of the same applications, the compile-time run-time system is 0-29% slower than message passing, while the base run-time system is 5-212% slower. For the five programs that XHPF could parallelize (all except IS), the execution times achieved by the compiler optimized shared memory programs are within 9% of XHPF.

Among many pathfinding algorithms, A* search algorithm is an algorithm that most commonly used in grid-based pathfinding. This is due to implementation of A* search which proven to be able to generate the optimal path in a relatively short time by combining two characteristics of Djikstra's and best-first search algorithm. In the implementation of A* search, the selection of heuristic function and data structure can affect the performance of the algorithm. The purpose of this research is to find the best heuristic function and data structure with regards of the performance in A* search implementation as a pathfinding algorithm in a 3D platform. In the experiment, some known heuristic functions and data structures will be tested on the various 3D platform with a different size and obstacle percentage. Based on experiment that have been done, euclidean squared distance is best heuristic function for 3D pathfinding problem, with regards of the implementation performance. In addition, we also found that binary heap is the best data structure to be implemented for 3D pathfinding problem, with regards of implementation performance.

In 2004, Botea et al. published the HPA* algorithm (Hierarchical Pathfinding A*), which is the first detailed study of hierarchical pathfinding in games. However, HPA* can be optimized. In this paper, we introduce the DHPA* and SHPA* hierarchical pathfinding algorithms, along with a metric for comparing the dynamic performance of pathfinding algorithms in games. We show that DHPA* searches up to an order of magnitude faster than HPA*, but consumes significantly more memory and produces slightly less optimal paths. The SHPA* algorithm searches up to five times faster than HPA* and consumes less memory, but it also produces slightly less optimal paths, and is only fit for static environments. When comparing the algorithms in dynamic environments, our results show that DHPA* often outperforms HPA*. Unlike many other hierarchical pathfinding algorithms, both solutions presented in this paper maintain a read-only terrain representation during search, which simplifies programming and debugging, and improves multithreaded performance.

Any obstacle-free path planning algorithm, in general, gives a sequence of waypoints that connect start and goal positions by a sequence of straight lines, which does not ensure the smoothness and the dynamic feasibility to maneuver the MAV. Kinodynamic-based motion planning is one of the ways to impose dynamic feasibility in planning. However, kinodynamic motion planning is not an optimal solution due to high computational demands for real-time applications. Thus, we explore path planning followed by kinodynamic smoothing while ensuring the dynamic feasibility of MAV. The main difference in the proposed technique is not to use kinodynamic planning when finding a feasible path, but rather to apply kinodynamic smoothing along the obtained feasible path. We have chosen a geometric-based path planning algorithm “RRT*” as the path finding algorithm. In the proposed technique, we modified the original RRT* introducing an adaptive search space and a steering function that helps to increase the consistency of the planner. Moreover, we propose a multiple RRT* that generates a set of desired paths. The optimal path from the generated paths is selected based on a cost function. Afterwards, we apply kinodynamic smoothing that will result in a dynamically feasible as well as obstacle-free path. Thereafter, a b-spline-based trajectory is generated to maneuver the vehicle autonomously in unknown environments. Finally, we have tested the proposed technique in various simulated environments. According to the experiment results, we were able to speed up the path planning task by 1.3 times when using the proposed multiple RRT* over the original RRT*.

This paper introduces a modified A* pathfinding algorithm that can be used in building Mechanical Electronic Plumbing (MEP) path design by revising nodes selection process and post-processing. The pathfinding algorithm is used when a computer calculates the optimal path in a given space by algorithmizing how humans intuitively calculate the optimal path. As construction technology is gradually advancing, buildings with large and complex internal structures are increasing, so there is a need to automatically optimize existing design methods that rely on human intuition for a more efficient design. In the case of building MEP design, it is time and money consuming to design paths since they are complexly arranged throughout the building, and designs are frequently changed in response to the nature of the construction industry, where construction errors are frequent. Therefore, an MEP path design optimization module, MEPAutoroute, was developed by implementing a modified A* pathfinding algorithm to solve these problems. Algorithm was applied to seven different exemplary structures with MEP equipment, and the results are analyzed to determine its efficiency.

Mobile robots have already made their way into warehouses, and significant effort has consequently been devoted to designing effective algorithms for the related multi-agent path finding (MAPF) problem. However, most of the proposed MAPF algorithms still rely on centralized planning as well as simplistic assumptions, such as that robots have full observability of the environment and move at equal and constant speeds. The resultant plans thus cannot be executed directly on physical robots where these assumptions generally do not hold. To mitigate these issues, we consider the decentralized partially observable multirobot setting where robots do not have access to the full state of the world. Instead, each robot coordinates with neighbors within a limited communication range. In the proposed approach, each robot independently plans its own path using A* without taking into account other robots, and the robots then solve potential conflicts locally as they occur. Experimental results obtained in various benchmark scenarios confirm that the proposed decentralized approach is effective and scales well to large numbers of robots.

Path planning is key research topic in the field of robotics research, transportation, bioinformatics, virtual prototype designing, gaming, computer aided designs, and virtual reality estimation. In optimal path planning, it is important to determine the collision free optimal and shortest path. There may be various aspects to determine the optimal path based on workspace environment and obstacle types. In this research work, optimal path is determined based on the workspace environment having static obstacles and unknown environment area. A hybrid approach of meta-heuristic algorithm of Bat Algorithm (BA) and Cuckoo Search (CS) is used to determine the optimal path from defined source to destination. For experimentation, case study area of Alwar region, Rajasthan is considered which consist of urban and vegetation area. The reason for the selection of BA and CS for the path planning is the wide application and success of implementation of these concepts in the field of robotics and path planning. The consideration of individual BA for path planning can lead to problem of trapping between local optima. This obligates us to hybridize the concept of BA with some other efficient problem solving concept like CS. The hybridized concept of BA and CS is initially tested with standard benchmarks functions, after that considered for the application of path planning. Results of hybrid path planning concept are compared with individual CS and BA concepts in terms of simulation time and minimum number of iteration required to achieve the optimal path from defined source to destination. The evaluated results comparison of hybrid approach with individual concepts indicates the dominance of proposed hybrid concept in terms of standard benchmarks functions and other parameters as well.

Shared memory is widely used for inter-process communication. The shared memory abstraction allows computation to be decoupled from communication, which offers benefits, including portability and ease of programming. To enable shared memory access by processes that are on different machines, distributed shared memory (DSM) can be employed. However, DSM systems can suffer from thrashing: while different processes update certain hot data items, the largest amount of effort is spent on data synchronization, and little progress is made by each process. To avoid interference between processes during data updating while providing shared memory at page granularity, more time is reserved for a writer to hold a page in a traditional manner. In this paper, we report on complex thrashing, which can explain why extending the time of holding a page might not be sufficient to control thrashing. To increase the throughput, we propose a thrashing control mechanism that allows each process to update a set of pages during a period of time, where the pages compose a logical area. Because of the isolation of areas, updates on different areas can be performed concurrently. To allow the areas to be fairly well used, each process is assigned with a random priority for thrashing control. The thrashing control mechanism is implemented on a Linux-based DSM system. Performance results show that the execution time of the applications that are apt to cause system thrashing can be significantly reduced by our approach.

This paper extends a state-based timing analysis for Synchronous Dataflow Applications on an MPSoC with shared memory. The existing approach transforms a mapped and timing annotated SDF graph into a timed automata representation for the analysis of timing properties. One major drawback of the existing timing annotation approach is the usage of best- and worst-case execution time intervals, resulting in an overestimation of the actual timing behavior. This paper proposes to replace the timing bound annotation with a probability density function. For the overall timing analysis we use a stochastic timed automata model. We demonstrate and evaluate our approach on a Sobel filter, which is used in many image and video processing algorithms. As a reference, we compare our stochastic execution time model against a fixed best-/worst-case execution time model and against the measured execution time on an FPGA prototype. The results are promising and clearly indicate that our probabilistic approach provides tighter timing analysis results in comparison to the best-/worst-case execution analysis model.