Fast and scalable algorithm for product large data on multicore system

In any organization and business, efficient scheduling cause increased efficiency, reducing the time required to complete jobs and increasing an organization’s profitability in a competitive environment. Also, the flow-shop scheduling problem is a vital type of scheduling problem with many real-world applications. Flow-shop scheduling has numerous exciting applications in various manufacturing and industrial domains. During the past eras, the growing interests in the arrangement of flow shops with diverse objective functions (for example, minimizing the makespan and flow-time) were observed. The permutation flow-shop is formulated as mixed-integer programming, and it is an NP-Hard problem. Therefore, in this paper, a novel method is provided to decrease the makespan and completion time. Since parallel algorithms use some computing elements to accelerate the search and present a new exploration pattern that is frequently suitable to enhance the quality of the results, in this research, a parallel ant colony optimization algorithm is employed to solve the mentioned problem. The Matlab simulation setting in Net Beans IDE 8.0.2 and Java to simulate the introduced method is applied. According to the obtained results, the suggested procedure has more efficiency than the previous methods. The Matlab simulator outcomes have indicated that the average response time has been improved compared to the PSO-SA and HBC algorithms. Also, the makespan is improved in comparison to GA and MOACSA.

We study scheduling algorithms in WDM optical interconnects with recirculating buffering. The interconnect we consider has wavelength conversion capabilities. We focus on limited range wavelength conversion while considering full range wavelength conversion as a special case. We formalize the problem of maximizing throughput and minimizing packet delay in such an interconnect as a matching problem in a bipartite graph and give an optimal parallel algorithm that runs in O(Bk/sup 2/), as compared to O((N+B)/sup 3/k/sup 3/) time if directly applying other existing matching algorithms, where N is the number of input/output fibers, B is the number of fiber delay lines and k is the number of wavelengths per fiber.

The sine cosine algorithm’s main idea is the sine and cosine-based vacillation outwards or towards the best solution. The first main contribution of this paper proposes an enhanced version of the SCA algorithm called as ESCA algorithm. The supremacy of the proposed algorithm over a set of state-of-the-art algorithms in terms of solution accuracy and convergence speed will be demonstrated by experimental tests. When these algorithms are transferred to the business sector, they must meet time requirements dependent on the industrial process. If these temporal requirements are not met, an efficient solution is to speed them up by designing parallel algorithms. The second major contribution of this work is the design of several parallel algorithms for efficiently exploiting current multicore processor architectures. First, one-level synchronous and asynchronous parallel ESCA algorithms are designed. They have two favors; retain the proposed algorithm’s behavior and provide excellent parallel performance by combining coarse-grained parallelism with fine-grained parallelism. Moreover, the parallel scalability of the proposed algorithms is further improved by employing a two-level parallel strategy. Indeed, the experimental results suggest that the one-level parallel ESCA algorithms reduce the computing time, on average, by 87.4% and 90.8%, respectively, using 12 physical processing cores. The two-level parallel algorithms provide extra reductions of the computing time by 91.4%, 93.1%, and 94.5% with 16, 20, and 24 processing cores, including physical and logical cores. Comparison analysis is carried out on 30 unconstrained benchmark functions and three challenging engineering design problems. The experimental outcomes show that the proposed ESCA algorithm behaves outstandingly well in terms of exploration and exploitation behaviors, local optima avoidance, and convergence speed toward the optimum. The overall performance of the proposed algorithm is statistically validated using three non-parametric statistical tests, namely Friedman, Friedman aligned, and Quade tests.

We present StochasticPrograms.jl, a user-friendly and powerful open-source framework for stochastic programming written in the Julia language. The framework includes both modeling tools and structure-exploiting optimization algorithms. Stochastic programming models can be efficiently formulated using an expressive syntax, and models can be instantiated, inspected, and analyzed interactively. The framework scales seamlessly to distributed environments. Small instances of a model can be run locally to ensure correctness, whereas larger instances are automatically distributed in a memory-efficient way onto supercomputers or clouds and solved using parallel optimization algorithms. These structure-exploiting solvers are based on variations of the classical L-shaped, progressive-hedging, and quasi-gradient algorithms. We provide a concise mathematical background for the various tools and constructs available in the framework along with code listings exemplifying their usage. Both software innovations related to the implementation of the framework and algorithmic innovations related to the structured solvers are highlighted. We conclude by demonstrating strong scaling properties of the distributed algorithms on numerical benchmarks in a multinode setup. Summary of Contribution: This paper presents StochasticPrograms.jl, an open-source framework for stochastic programming implemented in the Julia programming language. The framework includes an expressive syntax for formulating stochastic programming models as well as versatile analysis tools and parallel optimization algorithms. The framework will prove useful to researchers, educators, and industrial users alike. Researchers will benefit from the readily extensible open-source framework, in which they can formulate complex stochastic models or quickly typeset and test novel optimization algorithms. Educators of stochastic programming will benefit from the clean and expressive syntax. Moreover, the framework supports analysis tools and stochastic programming constructs from classical theory and leading textbooks. We strongly believe that the StochasticPrograms.jl framework can reduce the barrier to entry for incoming practitioners of stochastic programming. Industrial practitioners can make use of StochasticPrograms.jl to rapidly formulate complex models, analyze small instances locally, and then run large-scale instances in production. In doing so, they get distributed capabilities for free without changing the code and access to well-tested state-of-the-art implementations of parallel structure-exploiting solvers. As the framework is open-source, anyone from these target audiences can contribute with new functionality to the framework. In conclusion, by providing both an intuitive interface for new users and an extensive development environment for expert users, StochasticPrograms.jl has strong potential to further the field of stochastic programming.

Data partitioning algorithms aiming to minimize the execution time and the energy of computations in self-adaptable data-parallel applications on modern extreme-scale multicore platforms must address two critical challenges. First, they must take into account the new complexities inherent in these platforms such as severe resource contention and non-uniform memory access. Second, they must have low practical runtime and memory costs. The sequential data partitioning algorithms addressing the first challenge have a theoretical time complexity of O( $m * m * p * p$ ) where $m$ is the number of points in the discrete speed/energy function and $p$ is the number of available processors. They, however, exhibit high practical runtime cost and excessive memory footprint, therefore, rendering them impracticable for employment in self-adaptable applications executing on extreme-scale multicore platforms. We present, in this paper, the parallel data partitioning algorithms that address both the challenges. They take as input the functional models of performance and energy consumption against problem size and output workload distributions, which are globally optimal solutions. They have a low time complexity of O( $m * m * p$ ) thereby providing a linear speedup of O( $p$ ) and low memory complexity of O( $n$ ) where $n$ is the workload size expressed as a multiple of granularity. They employ dynamic programming approach, which also facilitates the easier integration of performance and energy models of communications. We experimentally study the practical cost of application of our algorithms in two data-parallel applications, matrix multiplication and fast Fourier transform, on a cluster in Grid’5000 platform. We demonstrate that their practical runtime and memory costs are low making them ideal for employment in self-adaptable applications. We also show that the parallel algorithms exhibit tremendous speedups over the sequential algorithms. Finally, using theoretical analysis for a forecast exascale platform, we demonstrate that the parallel algorithms have negligible execution times compared to the matrix multiplication application executing on the platform.

In this article, an optimal parallel algorithm is suggested for fast computation of a crucial yet fundamental numerical problem in science named ‘prefix sum’ on a popular three-dimensional torus network. The proposed parallel algorithm demands total ‘4n + 2’ communication moves for mapping prefix sum problem on odd network sizes of n × n×n three-dimensional torus network, whereas total ‘4n’ communication moves is required for parallel mapping of same on even network sizes. In fact, a unit increase in each dimension from odd to even and even to odd network sizes resulted in the constant increase of 2 and 6 units, respectively, in the required communication moves for mapping prefix sum. The algorithmic performance of the proposed parallel algorithm can be compared to counter-part parallel prefix sum approaches on grid-based networks.

A parallel numerical simulation algorithm is presented for fractional-order systems involving Caputo-type derivatives, based on the Adams–Bashforth–Moulton predictor–corrector scheme. The parallel algorithm is implemented using several different approaches: a pure MPI version, a combination of MPI with OpenMP optimization and a memory saving speedup approach. All tests run on a BlueGene/P cluster, and comparative improvement results for the running time are provided. As an applied experiment, the solutions of a fractional-order version of a system describing a forced series LCR circuit are numerically computed, depicting cascades of period-doubling bifurcations which lead to the onset of chaotic behavior.

We consider the following force field computation problem: given a cluster of n particles in 3-dimensional space, compute the force exerted on each particle by the other particles. Depending on different applications, the pairwise interaction could be either gravitational or Lennard-Jones. In both cases, the force between two particles vanishes as the distance between them approaches to infinity. Since there are n(n−1)/2 pairs, direct method requires Θ(n 2) time for force-evaluation, which is very expensive for astronomical simulations. In 1985 and 1986, two famous Θ(n log n) time hierarchical tree algorithms were published by Appel [3] and by Barnes and Hut [4] respectively. In a recent paper, we presented a linear time algorithm which builds the oct tree bottom-up and showed that Appel’s algorithm can be implemented in Θ(n) sequential time. In this paper, we present an algorithm which computes the force field in Θ(log n) time using an lognn processor CREWPR AM. A key to this optimal parallel algorithm is replacing a recursive top-down force calculation procedure of Appel by an equivalent non-recursive bottom-up procedure. Our parallel algorithm also yields a new Θ(n) time sequential algorithm for force field computation.KeywordsParalle algorithmsspatial tree data structuresforce field evaluationN-body simulationsPRAMcost optimal algorithms

Parallel chaos optimization algorithm with migration and merging operation

This paper proposes a parallel optimization algorithm PDF/IHS for the minimum execution‐time multiprocessor scheduling problem which is a strong NP‐hard optimization problem. PDF/IHS is a parallelization and efficient implementation of the only practical optimization algorithm DF/IHS among those which have been proposed for this scheduling problem. In PDF/IHS, processors perform depth‐first search in parallel on a heuristically generated search tree in such a way that it is searched hierarchically from the left‐ and right‐hand sides.The effectiveness of PDF/IHS has been verified by simulation and practical parallel processing on Alliant FX4. As a result, it has been recognized that most of the problems which required a long time by DF/IHS can be solved approximately in time 1/m by PDF/IHS using m processors. Moreover, even for a problem which required a very long time or could not be solved in a practical time by DF/IHS, it has been verified that PDF/IHS can give solutions in time less than 1/m.

Approximate parallel scheduling. II. Applications to logarithmic-time optimal parallel graph algorithms

Ant Colony Optimization is computationally expensive when it comes to complex problems. The Jacket toolbox allows implementation of MATLAB programs in Graphics Processing Unit (GPU). This paper presents and implements a parallel MAX-MIN Ant System (MMAS) based on a GPU+CPU hardware platform under the MATLAB environment with Jacket toolbox to solve Traveling Salesman Problem (TSP). The key idea is to let all ants share only one pseudorandom number matrix, one pheromone matrix, one taboo matrix, and one probability matrix. We also use a new selection approach based on those matrices, named AIR (All-In-Roulette). The main contribution of this paper is the description of how to design parallel MMAS based on those ideas and the comparison to the relevant sequential version. The computational results show that our parallel algorithm is much more efficient than the sequential version.

Increasing the core count of CPUs to increase computational performance has been a significant trend for the better part of a decade. This has led to an unprecedented availability of large shared memory machines. Programming paradigms and systems are shifting to take advantage of this architectural change, so that intra-node parallelism can be fully utilized. Algorithms designed for parallel execution on distributed systems will also need to be modified to scale in these new shared and hybrid memory systems. In this paper, we reinvestigate parallel rendering algorithms with the goal of finding one that achieves favorable performance in this new environment. We test and analyze various methods, including sort-first, sort-last, and a hybrid scheme, to find an optimal parallel algorithm that maximizes shared memory performance.

We discuss techniques for constructing parallel image identification algorithms: cutting images into small factors, and compressing images by a parallel reduction of large number of such independent factors into smaller objects. A version of Kedem Landau Palem algorithm for parallel one-dimensional and two-dimensional rectangular image recognition on a CRCW PRAM is presented. The crucial part in KLP algorithm is a suffix-prefix matching subprocedure. In our algorithm such a subprocedure is omitted. A novel algorithm for pattern-matching is proposed, more directly designed for two-dimensional objects. It does not use the multi-text/multi-pattern approach as in KLP algorithm. The importance of five types of factors in strings and images is emphasized A new useful type of two-dimensional factors is introduced: thin factors.

The all-pairs shortest path problem is a classic problem to study characteristics of the given graphs. Though many efficient all-pairs shortest path algorithms have been published, it is still a very expensive computing task, especially with large graph datasets. In this paper, we propose an efficient parallel all-pairs shortest path algorithm based on Peng et al.'s fast sequential algorithm on shared-memory parallel environments to achieve faster and more efficient calculation for large-scale real-world networks. Peng et al.'s algorithm needs to sort vertices with respect to their degrees. However, it turns out the original algorithm uses less efficient sorting method, which is a significant portion of parallel overhead. Therefore, we also propose an efficient parallel method to sort data within a fixed range, in order to minimize the parallel overhead in our parallel algorithm. The optimized efficient sorting method can be used for general sorting purposes. Our experimental analysis shows that our proposed parallel algorithm achieves very high parallel speedup, even hyper-linear speedup, with real-world test datasets on two different shared-memory multi-core systems.