Iterative Schedule Optimization for Parallelization in the Polyhedron Model

Loop optimization, made of a sequence of loop transformations, plays an important role in performance improvement in data centric applications. Programs using flash memory are no exception to this, but, under certain conditions careless applications of specific loop transformations might cause unexpected results, due to the characteristics of flash memory and underlying management systems. In this article, we analyze how loop transformations affect the performance in flash translation layers (FTLs). First, we choose four loop structures which have distinct reference patterns and propose a cost model for each structure, reflecting the properties of flash memory. Then, using these cost models, we investigate how loop transformations affect the block associative sector translation (BAST)'s and fully associative sector translation (FAST)'s internal operations and analyze the performance effect of loop transformations experimentally. As a result, we find that some of the major loop transformations cause unexpected performance effects in those major FTLs under certain conditions.

The polyhedral model provides powerful abstractions to optimize loop nests with regular accesses. Affine transformations in this model capture a complex sequence of execution-reordering loop transformations that can improve performance by parallelization as well as locality enhancement. Although a significant body of research has addressed affine scheduling and partitioning, the problem of automaticallyfinding good affine transforms forcommunication-optimized coarsegrained parallelization together with locality optimization for the general case of arbitrarily-nested loop sequences remains a challenging problem. We propose an automatic transformation framework to optimize arbitrarilynested loop sequences with affine dependences for parallelism and locality simultaneously. The approach finds good tiling hyperplanes by embedding a powerful and versatile cost function into an Integer Linear Programming formulation. These tiling hyperplanes are used for communication-minimized coarse-grained parallelization as well as for locality optimization. The approach enables the minimization of inter-tile communication volume in the processor space, and minimization of reuse distances for local execution at each node. Programs requiring one-dimensional versusmulti-dimensional time schedules (with scheduling-based approaches) are all handled with the same algorithm. Synchronization-free parallelism, permutable loops or pipelined parallelismat various levels can be detected. Preliminary studies of the framework show promising results.

Software pipelining is a loop optimization that overlaps the execution of several iterations of a loop to expose more instruction-level parallelism. It can result in first-class performance characteristics, but at the cost of significant obfuscation of the code, making this optimization difficult to test and debug. In this paper, we present a translation validation algorithm that uses symbolic evaluation to detect semantics discrepancies between a loop and its pipelined version. Our algorithm can be implemented simply and efficiently, is provably sound, and appears to be complete with respect to most modulo scheduling algorithms. A conclusion of this case study is that it is possible and effective to use symbolic evaluation to reason about loop transformations.

Caches have become increasingly important with the widening gap between main memory and processor speeds. Small and fast cache memories are designed to bridge this discrepancy. However, they are only effective when programs exhibit sufficient data locality.Performance of memory hierarchy can be improved by means of data and loop transformations. Tiling is a loop transformation that aims at reducing capacity misses by exploiting reuse at the lower levels of cache. Padding is a data transformation targeted to reduce conflict misses.This paper presents an accurate cost model which makes use of the Cache Miss Equations (CMEs) to guide tiling and padding transformations. It describes misses across different hierarchy levels and considers the effects of other hardware components such as branch predictors. We combine the cost model with a genetic algorithm (GA) to select the tile and pad factors that enhance the program.Our results show that this scheme is useful to optimize programs' performance. When compared to previous works, we observe that with a reasonable compile-time overhead, our approach obtains significant performance improvements for all studied kernels on a variety of architectures.

Runtime code optimization and speculative execution are becoming increasingly prominent to leverage performance in the current multi- and many-core era. However, a wider and more efficient use of such techniques is mainly hampered by the prohibitive time overhead induced by centralized data race detection, dynamic code behavior modeling, and code generation. Most of the existing Thread Level Speculation (TLS) systems rely on naively slicing the target loops into chunks and trying to execute the chunks in parallel with the help of a centralized performance-penalizing verification module that takes care of data races. Due to the lack of a data dependence model, these speculative systems are not capable of doing advanced transformations, and, more importantly, the chances of rollback are high. The polyhedral model is a well-known mathematical model to analyze and optimize loop nests. The current state-of-art tools limit the application of the polyhedral model to static control codes. Thus, none of these tools can generally handle codes with while loops, indirect memory accesses, or pointers. Apollo (Automatic POLyhedral Loop Optimizer) is a framework that goes one step beyond and applies the polyhedral model dynamically by using TLS. Apollo can predict, at runtime, whether the codes are behaving linearly or not, and it applies polyhedral transformations on-the-fly. This article presents a novel system that enables Apollo to handle codes whose memory accesses and loop bounds are not necessarily linear. More generally, this approach expands the applicability of the polyhedral model at runtime to a wider class of codes. Plugging together both linear and nonlinear accesses to the dependence prediction model enables the application of polyhedral loop optimizing transformations even for nonlinear code kernels while also allowing a low-cost speculation verification.

Well-known techniques for tiled code generation are based on the polyhedral model and affine transformations. An alternative approach to generation of tiled code is to correct original rectangular tiles defined for a loop nest by means of the transitive closure of a dependence graph instead of deriving and applying affine transformations. In this paper, we present results of an analysis of basic features of tiles generated due to correction of original rectangular tiles. We introduce procedures which allow us to recognize such features as target tile type (fixed, varied, parametric), dimensionality, size (the number of statement instances within a tile), and loop nest tileability (the percentage of statement instances that can be tiled with rectangular tiles). We consider differences between those features of tiles generated by means of affine transformations and transitive closure. We also discuss results of experiments with PolyBench benchmarks and show how differences in tiles generated with the examined approach and affine transformations affect serial tiled code performance.

Deep neural networks currently dominate many fields of the artificial intelligence landscape, achieving state-of-the-art results on numerous tasks while remaining hard to understand and exhibiting surprising weaknesses. An active area of research focuses on adversarial attacks, which aim to generate inputs that uncover these weaknesses. However, this proves challenging, especially in the black-box scenario where model details are inaccessible. This paper explores in detail the impact of such adversarial algorithms on ResNet-18, DenseNet-121, Swin Transformer V2, and Vision Transformer network architectures. Leveraging the Tiny ImageNet, Caltech-256, and Food-101 datasets, we benchmark two novel black-box iterative adversarial algorithms based on affine transformations and genetic algorithms: 1) Affine Transformation Attack (ATA), an iterative algorithm maximizing our attack score function using random affine transformations, and 2) Affine Genetic Attack (AGA), a genetic algorithm that involves random noise and affine transformations. We evaluate the performance of the models in the algorithm parameter variation, data augmentation, and global and targeted attack configurations. We also compare our algorithms with two black-box adversarial algorithms, Pixle and Square Attack. Our experiments yield better results on the image classification task than similar methods in the literature, achieving an accuracy improvement of up to 8.82%. We provide noteworthy insights into successful adversarial defenses and attacks at both global and targeted levels, and demonstrate adversarial robustness through algorithm parameter variation.

In data dominated applications, loop transformations have a huge impact on the lifetime of array data and therefore on memory footprint. Since a locally optimal loop transformation may have a detrimental effect somewhere else, many alternative loop transformations need to be explored. Therefore, estimation of the memory footprint is essential, and this estimation has to be fast. This paper presents a fast array based memory footprint estimation technique based on counting of iteration nodes in an iteration domain constrained by a maximal lifetime. The maximal lifetime is defined by the Maximal Dependency Vector (MDV) of the array for a given execution ordering. We further present for the first time two approaches for calculation of the MDV: a general approach based on an ILP formulation and a novel vertexes approach when iteration domains are approximated by bounding boxes. Experiments on practical test vehicles demonstrate that the estimation based on our vertexes approach is extremely fast, on average two orders of magnitude faster than the compared approaches, while still keeping the accuracy high. This enables system-level data memory footprint exploration of many different alternative transformed program codes, within interactive time limits, and on realistic complex applications.

The genetic algorithm (GA) is a metaheuristic inspired by the process of natural selection, and it is known for its iterative optimization capabilities in both constrained and unconstrained environments. In this paper, a novel method for GA-based dual-automatic guided vehicle (AGV)-ganged path planning is proposed to address the problem of frequent steering collisions in dual-AGV-ganged autonomous navigation. This method successfully plans global paths that are safe, collision-free, and efficient for both leader and follower AGVs. Firstly, a new ganged turning cost function was introduced based on the safe turning radius of dual-AGV-ganged systems to effectively search for selectable safe paths. Then, a dual-AGV-ganged fitness function was designed that incorporates the pose information of starting and goal points to guide the GA toward iterative optimization for smooth, efficient, and safe movement of dual AGVs. Finally, to verify the feasibility and effectiveness of the proposed algorithm, simulation experiments were conducted, and its performance was compared with traditional genetic algorithms, Astra algorithms, and Dijkstra algorithms. The results show that the proposed algorithm effectively solves the problem of frequent steering collisions, significantly shortens the path length, and improves the smoothness and safety stability of the path. Moreover, the planned paths were validated in real environments, ensuring safe paths while making more efficient use of map resources. Compared to the Dijkstra algorithm, the path length was reduced by 30.1%, further confirming the effectiveness of the method. This provides crucial technical support for the safe autonomous navigation of dual-AGV-ganged systems.

Structure damage identification in dams using sparse polynomial chaos expansion combined with hybrid K-means clustering optimizer and genetic algorithm

Lens matching is a trial assembly step in compact lens module manufacturing that can effectively improve the production yield and compensate for the manufacturing error to some degree. However, conventional lens matching (i.e., through trial and error (T&E)) is extremely time-consuming and has a low success rate. To address this issue, this paper proposes a novel Genetic Algorithm (GA) based solution to improve the assembly success rate and the efficiency of lens matching. The study first formalizes the lens matching problem into an optimization format. Then, a DNN based surrogate model is built to replace expensive optical simulators in the optimization iterations. The DNN is used because it demonstrates a great balance between prediction accuracy and computation efficiency compared to other alternatives, e.g., Linear Regression (LR), Kriging, and Polynomial Chaos Expansion (PCE). Next, a GA-based solver is developed to find optimal lens matching operations. The effectiveness of the proposed method and its superiority over conventional lens matching is validated in the real-world lens production line through collaboration with the industry. Compared with conventional lens matching, the proposed method can significantly improve the production yield and lens matching efficiency. Note to Practitioners—This paper is motivated by a practical need for lens matching in the manufacturing process of the image capturing compact lens modules. The conventional practice of lens matching is tedious, time-consuming, and easy to fail. To address this issue, we mathematically characterize the lens matching problem into an optimization format that can practically be solved by the Genetic Algorithm (GA) or other methods. We then demonstrate the workflow to search for optimal lens matching solutions based on a DNN surrogate model. Simulative studies and preliminary real-world experiments indicate the proposed method can effectively improve overall production yield and is much more efficient than conventional lens matching. The results in mass production further justified the superiority of the proposed method over conventional lens matching.

Optimizing Control of Bio-dissimilation Process of Glycerol to 1,3-Propanediol

Many advances in automatic parallelization and optimization have been achieved through the polyhedral model. It has been extensively shown that this computational model provides convenient abstractions to reason about and apply program transformations. Nevertheless, the complexity of code generation has long been a deterrent for using polyhedral representation in optimizing compilers. First, code generators have a hard time coping with generated code size and control overhead that may spoil theoretical benefits achieved by the transformations. Second, this step is usually time consuming, hampering the integration of the polyhedral framework in production compilers or feedback-directed, iterative optimization schemes. Moreover, current code generation algorithms only cover a restrictive set of possible transformation functions. This paper discusses a general transformation framework able to deal with non-unimodular, non-invertible, non-integral or even non-uniform functions. It presents several improvements to a state-of-the-art code generation algorithm. Two directions are explored: generated code size and code generator efficiency. Experimental evidence proves the ability of the improved method to handle real-life problems. 1.

With the increasing demand for key technologies in deepwater oil and gas exploration, the mooring system, a critical component for the positioning of deepwater floating platforms, plays a vital role in ensuring the stable operation of offshore oil and gas platforms under harsh working conditions. In this study, we propose an optimization method for mooring systems based on Enhanced Multi-task Genetic Optimization (EMGO). Taking a semi-submersible platform mooring engineering project in the South China Sea as an example, a multi-body coupled model of the semi-submersible platform and its mooring system was established in compliance with mooring system design specifications. A custom-developed program was utilized to generate 7,751 sets of dynamic mooring system data. Subsequently, an enhanced multi-task learning (MTL) neural network was designed to predict platform offsets and mooring line axial tensions under various working conditions with high accuracy. The optimal performance of the MTL model achieved a mean squared error (MSE) of approximately 0.044 and R-Square (R²) of 0.96. Combining the enhanced MTL model with a genetic algorithm, iterative optimization was performed to converge on an optimal mooring design parameter set tailored for the semi-submersible platform. The proposed method achieved a reduction of over 20% in maximum axial tension in mooring lines and a reduction of over 10% in maximum platform offset. The EMGO algorithm demonstrated excellent capability in high-dimensional nonlinear fitting and generalization. Validation of the optimized design was performed on taut mooring systems of three additional semi-submersible platforms, confirming the feasibility and effectiveness of the optimization method under extreme environmental conditions in the South China Sea. This study introduces an innovative intelligent design method for deepwater taut mooring systems, which significantly improves the safety and reliability of ultra-deepwater platforms. It provides valuable guidance for intelligent design in offshore and marine engineering fields.

Rigid manipulators are applicable for a very structured environment and standard applications. For real world applications, continuum manipulators are used which has required high degrees of freedom, and compliance. The current work focus on the trajectory optimization of continuum robot for a specified application to minimize energy usage. To achieve this task Lagrangian mechanics is used to develop the mathematical model of the continuum robot with the payload. In this case the trajectory optimization has been carried out by treating the problem as a nested optimization problem. The outer optimization task is to optimize the trajectory using minimization of input force as primary goal where initial and final configurations of the arm are already available. Here, Genetic Algorithm is used as the optimizer for the selected tasks. The purpose of inner optimization loop is to find the feasible inverse solution for the manipulator that is required to calculate input forces which is further required to optimize the trajectory of the arm. A constrained non-linear optimization algorithm is used for the task. The optimization results show 30-80 % decrease in the input force required for the specified trajectories of the arm. The current paper shows that various tasks can be optimized using the formulated strategy to save the energy required by the arm to execute specified task.