Search

To better understand the pattern phase transition of both physical and biological systems, we investigate a two-dimensional spin particle lattice system using statistical mechanics methods together with XY model governed by Hamiltonian equations of motion. By tweaking the coupling strength and the intensity of the generalization field, we observe phase transitions among four patterns of spin particles, i.e., vortex, ferromagnet, worm and anti-ferromagnet. In addition, we analyze the effect of space boundaries on the formations of vortex and worm. Considering the inherent dynamics of individual particles, we revealed the forming mechanism of such phase transitions, which provides a new perspective for understanding the emergence of phase transition of spin particles systems. [ABSTRACT FROM AUTHOR]

Nearest-neighbor communication is one of the most important communication patterns appearing in many scientific applications. In this paper, we discuss the results of applying UPC++, a library-based partitioned global address space (PGAS) programming extension to C++, to an adaptive mesh framework (BoxLib), and a full scientific application GTC-P, whose communications are dominated by the nearest-neighbor communication. The results on a Cray XC40 system show that compared with the highly-tuned MPI two-sided implementations, UPC++ improves the communication performance up to 60% and 90% for BoxLib and GTC-P, respectively. We also implement the nearest-neighbor communication using MPI one-sided messages. The performance comparison demonstrates that the MPI one-sided implementation can also improve the communication performance over the two-sided version but not so significantly as UPC++ does.

Precise motion control is a challenging and important goal in the application of mobile robots. The mechanical structure of a novel mobile robot is presented. Using the support vector machine learning control method in statistical theory, the human control strategy is represented by the parametric model without knowledge of the actual robot mathematical model. Moreover, using the learning controller, the position motion control experiments of the robot are carried out. The results of the experiments show that this learning control method is feasible and valid for the precise position control of the mobile robot, and the maxim error is less than 32 cm in a 10 m linear movement.

Promoting the deployment and application of embedded systems in complex forest scenarios is an inevitable developmental trend in advanced intelligent forestry equipment. Unstructured roads, which lack effective artificial traffic signs and reference objects, pose significant challenges for driverless technology in forest scenarios, owing to their high nonlinearity and uncertainty. In this research, an unstructured road parameterization construction method, "DeepLab-Road", based on tight coupling of multisource information is proposed, which aims to provide a new segmented architecture scheme for the embedded deployment of a forestry engineering vehicle driving assistance system. DeepLab-Road utilizes MobileNetV2 as the backbone network that improves the completeness of feature extraction through the inverse residual strategy. Then, it integrates pluggable modules including DenseASPP and strip-pooling mechanisms. They can connect the dilated convolutions in a denser manner to improve feature resolution without significantly increasing the model size. The boundary pixel tensor expansion is then completed through a cascade of two-dimensional Lidar point cloud information. Combined with the coordinate transformation, a quasi-structured road parameterization model in the vehicle coordinate system is established. The strategy is trained on a self-built Unstructured Road Scene Dataset and transplanted into our intelligent experimental platform to verify its effectiveness. Experimental results show that the system can meet real-time data processing requirements (≥12 frames/s) under low-speed conditions (≤1.5 m/s). For the trackable road centerline, the average matching error between the image and the Lidar was 0.11 m. This study offers valuable technical support for the rejection of satellite signals and autonomous navigation in unstructured environments devoid of high-precision maps, such as forest product transportation, agricultural and forestry management, autonomous inspection and spraying, nursery stock harvesting, skidding, and transportation. [ABSTRACT FROM AUTHOR]

This research examines the potential of digital twin (DT) technology for reformation within China's traditional solid-wood-panel processing industry, which currently suffers from production inefficiencies and the slow adoption of digital technology. The research centers around developing a digital twin system, elucidating improvements in manufacturing efficiency, waste management, process simulation, and real-time monitoring. These capabilities facilitate immediate problem solving and offer transparency in the process. The digital twin system is comprised of physical, transport, virtual, and application layers, employing a MySQL database and using the Open Platform Communications Unified Architecture (OPC UA) protocol for communication. The application of this system has led to heightened production efficiency and better material use in the solid-wood-panel manufacturing line. Integrating the dynamic selection adaptive genetic algorithm (DSAGA) into the virtual layer drives the system's efficiency forward. This evolved approach has allowed for an enhancement of 8.93% in the scheduling efficiency of DSAGA compared to traditional genetic algorithms (GAs), thereby contributing to increased system productivity. Real-time mapping and an advanced simulation interface have strengthened the system's monitoring aspect. These additions enrich data visualization, leading to better comprehension and a holistic process view. This research has ignited improvements in solid-wood-panel production, illustrating the tangible benefits and representing progress in incorporating digital technology into traditional industries. This research sets a path for transforming these industries into smart manufacturing by effectively bridging the gap between physical production and digital monitoring. Furthermore, the adjustability of this approach extends beyond solid-wood-panel production, indicating the capability to expedite movement towards intelligent production in various other manufacturing sectors. [ABSTRACT FROM AUTHOR]

The leaf area index (LAI) is an essential indicator for assessing vegetation growth and understanding the dynamics of forest ecosystems and is defined as the ratio of the total leaf surface area in the plant canopy to the corresponding surface area below it. LAI has applications for obtaining information on plant health, carbon cycling, and forest ecosystems. Due to their price and portability, mobile devices are becoming an alternative to measuring LAI. In this research, a new method for estimating LAI using a smart device with a fisheye lens (SFL) is proposed. The traditional Otsu method was enhanced to improve the accuracy and efficiency of foreground segmentation. The experimental samples were located in Gansu Ziwuling National Forest Park in Qingyang. In the accuracy parameter improvement experiment, the variance of the average LAI value obtained by using both zenith angle segmentation and azimuth angle segmentation methods was reduced by 50%. The results show that the segmentation of the front and back scenes of the new Otsu method is more accurate, and the obtained LAI values are more reliable. In the efficiency parameter improvement experiment, the time spent is reduced by 17.85% when the enhanced Otsu method is used to ensure that the data anomaly rate does not exceed 10%, which improves the integration of the algorithm into mobile devices and the efficiency of obtaining LAI. This study provides a fast and effective method for the near-ground measurement of forest vegetation productivity and provides help for the calculation of forest carbon sequestration efficiency, oxygen release rate, and forest water and soil conservation ability. [ABSTRACT FROM AUTHOR]

The Hartree-Fock (HF) method is the fundamental first step for incorporating quantum mechanics into many-electron simulations of atoms and molecules, and it is an important component of computational chemistry toolkits like NWChem. The GTFock code is an HF implementation that, while it does not have all the features in NWChem, represents crucial algorithmic advances that reduce communication and improve load balance by doing an up-front static partitioning of tasks, followed by work stealing whenever necessary. To enable innovations in algorithms and exploit next generation exascale systems, it is crucial to support quantum chemistry codes using expressive and convenient programming models and runtime systems that are also efficient and scalable. This paper presents an HF implementation similar to GTFock using UPC++, a partitioned global address space model that includes flexible communication, asynchronous remote computation, and a powerful multidimensional array library. UPC++ offers runtime features that are useful for HF such as active messages, a rich calculus for array operations, hardware-supported fetch-and-add, and functions for ensuring asynchronous runtime progress. We present a new distributed array abstraction, DArray, that is convenient for the kinds of random-access array updates and linear algebra operations on block-distributed arrays with irregular data ownership. We analyze the performance of atomic fetch-and-add operations (relevant for load balancing) and runtime attentiveness, then compare various techniques and optimizations for each. Our optimized implementation of HF using UPC++ and the DArrays library shows up to 20% improvement over GTFock with Global Arrays at scales up to 24,000 cores.

We present the design and evaluation of a distributed matrix-assembly abstraction for large-scale inverse problems in HPC environments: namely, physics-based Hessian estimation in full-waveform seismic inversion at the scale of the entire globe. Our solution to this data-assimilation problem relies on UPC++, a new PGAS extension to the C++ language, to implement one-sided asynchronous updates to distributed matrix elements, and allows us to tackle inverse problems well beyond our previous capabilities. Our evaluation includes scaling results for Hessian estimation on up to 12, 288 cores, typical of current production scientific runs and next-generation inversions. We also present comparisons with an alternative implementation based on MPI-3 remote memory access (RMA) operations, focusing on performance and code complexity. Interoperability between UPC++ and other parallel programming tools (e.g. MPI, OpenMP) allowed for incremental adoption of the PGAS model where most beneficial. Further, we note that this model of asynchronous assembly can generalize to other data-assimilation applications that accumulate updates into shared global state.

Structured grid linear solvers often require manually packing and unpacking of communication data to achieve high performance.Orchestrating this process efficiently is challenging, labor-intensive, and potentially error-prone.In this paper, we explore an alternative approach that communicates the data with naturally grained messagesizes without manual packing and unpacking. This approach is the distributed analogue of shared-memory programming, taking advantage of the global addressspace in PGAS languages to provide substantial programming ease. However, its performance may suffer from the large number of small messages. We investigate theruntime support required in the UPC++ library for this naturally grained version to close the performance gap between the two approaches and attain comparable performance at scale using the High-Performance Geometric Multgrid (HPGMG-FV) benchmark as a driver.

Partitioned Global Address Space (PGAS) languages and one-sided communication enable application developers to select the communication paradigm that balances the performance needs of applications with the productivity desires of programmers. In this paper, we evaluate three different one-sided communication paradigms in the context of geometric multigrid using the miniGMG benchmark. Although miniGMG's static, regular,and predictable communication does not exploit the ultimate potential of PGAS models, multigrid solvers appear in many contemporary applications and represent one of the most important communication patterns. We use UPC++, a PGAS extension of C++, as the vehicle for our evaluation, though our work is applicable to any of the existing PGAS languages and models. We compare performance with the highly tuned MPI baseline, and the results indicate that the most promising approach towards achieving performance and ease of programming is to use high-level abstractions, such as the multidimensional arrays provided by UPC++, that hide data aggregation and messaging in the runtime library. (c) 2014 Association for Computing Machinery.

Multidimensional arrays are an important data structure in many scientific applications. Unfortunately, built-in support for such arrays is inadequate in C++, particularly in the distributed setting where bulk communication operations are required for good performance. In this paper, we present a multidimensional library for partitioned global address space (PGAS) programs, supporting the one-sided remote access and bulk operations of the PGAS model. The library is based on Titanium arrays, which have proven to provide good productivity and performance. These arrays provide a local view of data, where each rank constructs its own portion of a global data structure, matching the local view of execution common to PGAS programs and providing maximum flexibility in structuring global data. Unlike Titanium, which has its own compiler with array-specific analyses, optimizations, and code generation, we implement multidimensional arrays solely through a C++ library. The main goal of this effort is to provide a library-based implementation that can match the productivity and performance of a compiler-based approach. We implement the array library as an extension to UPC++, a C++ library for PGAS programs, and we extend Titanium arrays with specializations to improve performance. We evaluate the array library by porting four Titanium benchmarks to UPC++, demonstrating that it can achieve up to 25% better performance than Titanium without a significant increase in programmer effort..

Partitioned Global Address Space (PGAS) languages are convenient for expressing algorithms with large, random-access data, and they have proven to provide high performance and scalability through lightweight one-sided communication and locality control. While very convenient for moving data around the system, PGAS languages have taken different views on the model of computation, with the static Single Program Multiple Data (SPMD) model providing the best scalability. In this paper we present UPC++, a PGAS extension for C++ that has three main objectives: 1) to provide an object-oriented PGAS programming model in the context of the popular C++ language, 2) to add useful parallel programming idioms unavailable in UPC, such as asynchronous remote function invocation and multidimensional arrays, to support complex scientific applications, 3) to offer an easy on-ramp to PGAS programming through interoperability with other existing parallel programming systems (e.g., MPI, OpenMP, CUDA). We implement UPC++ with a 'compiler-free' approach using C++ templates and runtime libraries. We borrow heavily from previous PGAS languages and describe the design decisions that led to this particular set of language features, providing significantly more expressiveness than UPC with very similar performance characteristics. We evaluate the programmability and performance of UPC++ using five benchmarks on two representative supercomputers, demonstrating that UPC++ can deliver excellent performance at large scale up to 32K cores while offering PGAS productivity features to C++ applications. © 2014 IEEE.

Partitioned Global Address Space (PGAS) languages offer programmers the convenience of a shared memory programming style combined with locality control necessary to run on large-scale distributed memory systems. Even within a PGAS language programmers often need to perform global communication operations such as broadcasts or reductions, which are best performed as collective operations in which a group of threads work together to perform the operation. In this paper we consider the problem of implementing collective communication within PGAS languages and explore some of the design trade-offs in both the interface and implementation. In particular, PGAS collectives have semantic issues that are different than in send-receive style message passing programs, and different implementation approaches that take advantage of the one-sided communication style in these languages. We present an implementation framework for PGAS collectives as part of the GASNet communication layer, which supports shared memory, distributed memory and hybrids. The framework supports a broad set of algorithms for each collective, over which the implementation may be automatically tuned. Finally, we demonstrate the benefit of optimized GASNet collectives using application benchmarks written in UPC, and demonstrate that the GASNet collectives can deliver scalable performance on a variety of state-of-the-art parallel machines including a Cray XT4, an IBM BlueGene/P, and a Sun Constellation system with InfiniBand interconnect. © 2011 Elsevier B.V. All rights reserved.