Search

The tractor–trailer wheeled robot (TTWR) is a typical modular mobile robot system. It is widely used in industry and agriculture transportation because of its simple structure, heavy load, high efficiency, strong adaptability, and flexibility. Because it is a nonlinear and underactuated system subjected to nonholonomic constraints, the complexity of the system and influence of the inner wheel difference pose great challenges to its trajectory prediction and path planning. To solve this problem, this paper proposes a trajectory prediction algorithm for an unpowered trailer for the TTWR system. In contrast to traditional single-path planning, the algorithm combines the motion characteristics of the Ackermann chassis tractor, analyzes the trailer motion law, and fully considers the lateral deviation of the trailer during the turning process. The algorithm can plan a reasonable cooperative path for the TTWR system. To verify the feasibility and effectiveness of the algorithm, the algorithm is transplanted to the TTWR intelligent experimental platform. A comparison of the simulation and experimental results shows that under the control of the preview tracking algorithm, the maximum error between the actual trajectory of the trailer and the trajectory predicted by the algorithm is generally no more than 9 cm, and the average error is 3.7 cm. This algorithm can provide an effective basis for TTWR system trajectory planning and path tracking. This algorithm is of great significance to TTWRs in warehousing logistics, freight forwarding, and skidding transportation.

Forestry mobile robots can effectively solve the problems of low efficiency and poor safety in the forestry operation process. To realize the autonomous navigation of forestry mobile robots, a vision system consisting of a monocular camera and two-dimensional LiDAR and its calibration method are investigated. First, the adaptive algorithm is used to synchronize the data captured by the two in time. Second, a calibration board with a convex checkerboard is designed for the spatial calibration of the devices. The nonlinear least squares algorithm is employed to solve and optimize the external parameters. The experimental results show that the time synchronization precision of this calibration method is 0.0082s, the communication rate is 23Hz, and the gradient tolerance of spatial calibration is 8.55e−07. The calibration results satisfy the requirements of real-time operation and accuracy of the forestry mobile robot vision system. Furthermore, the engineering applications of the vision system are discussed herein. This study lays the foundation for further forestry mobile robots research, which is relevant to intelligent forest machines.

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.

According to the existing multi-antenna relay forwarding protocol, the relay matrix can be split into two parts—relay nodes forward and backward filters direct concatenation, then in actual channel matrix design, relay’s forward and backward channel conditions are not ideal, which make system bit error rate (BER) performance is poor. Based on this problem, this paper proposes a modular algebraic precoding relay system model based on lattice reduction. At first, this method re-builds the relay’s forward and backward channel matrices, which can make the channel satisfy the orthogonality characteristics. Then, a modified equivalent relay channel matrix is precoding, which solves tradition algorithms’ poor performance problem when channel orthogonality is not good, and based on this idea, two improved algorithms are proposed. These two new algorithms can achieve better BER performance under poor relay channel conditions, make each user’s performance average, and satisfy system fairness requirements. Simulation results show that comparing with tradition algorithms, this paper proposes a relay channel model which is based on the lattice reduction precoding method, it gains a certain bit error performance. Finally, the improved algorithms are compared and analyzed with the sorting-based algorithm. The results show that the proposed algorithms have better performance. Therefore, in order to ensure users fairness, the optimization algorithm can be used instead of the high complexity sorting-based algorithm in the actual system.

The actuation of a forestry logging harvester is a complex task that requires long and costly training periods because the qualification of the operator has a significant impact on productivity and safety. Simulation-based training that makes use of virtual reality is becoming a competitive alternative to traditional training due to the reduced costs and risks in the instruction of the harvester operators. Aiming at the working process and operating environment of the logging harvester, an interactive real-time dynamic virtual driving system for forestry logging harvesters is developed. The harvester model is built by using 3dsMAX together with the 3D modeling software SolidWorks. The models of the harvester and trees are imported into Unity3D to create a virtual operating environment. Parent–child relationships for each logging harvester component is set in accordance with the simulation needs, and a corresponding mathematical model for the motion of the manipulator is established by analyzing the motion principle of the manipulator. A proposed cutting algorithm is used to perform the cutting of the model tree. The test results show that the virtual driving system can meet the training needs of logging harvester operators with realistic immersion and good interaction.

The detection and recognition of unstructured roads in forest environments are critical for smart forestry technology. Forest roads lack effective reference objects and manual signs and have high degrees of nonlinearity and uncertainty, which pose severe challenges to forest engineering vehicles. This research aims to improve the automation and intelligence of forestry engineering and proposes an unstructured road detection and recognition method based on a combination of image processing and 2D lidar detection. This method uses the “improved SEEDS + Support Vector Machine (SVM)” strategy to quickly classify and recognize the road area in the image. Combined with the remapping of 2D lidar point cloud data on the image, the actual navigation requirements of forest unmanned navigation vehicles were fully considered, and road model construction based on the vehicle coordinate system was achieved. The algorithm was transplanted to a self-built intelligent navigation platform to verify its feasibility and effectiveness. The experimental results show that under low-speed conditions, the system can meet the real-time requirements of processing data at an average of 10 frames/s. For the centerline of the road model, the matching error between the image and lidar is no more than 0.119 m. The algorithm can provide effective support for the identification of unstructured roads in forest areas. This technology has important application value for forestry engineering vehicles in autonomous inspection and spraying, nursery stock harvesting, skidding, and transportation.

The combination of blockchain technology and Internet of Things (IoT) technology has brought many significant advantages and new development directions. With the development of embedded technology and 5G communication technology, the performance limitations and network limitations that are traditionally believed to restrict the application of blockchain technology to IoT devices have been broken. The development of &ldquo, blockchain + 5G + IoT&rdquo, provides reliable data from the source for the blockchain, linking the credible mapping of physical assets and digital assets. However, at the beginning of the blockchain design, the application of the IoT was not fully considered, so there have been some obvious defects in applying the blockchain technology in the IoT. In the Byzantine fault tolerance (BFT) consensus algorithm of traditional blockchain, the entire blockchain network will become paralyzed when more than 1/3 of the nodes in the network are offline. However, in IoT applications, this situation is likely to occur and greatly limits the security and stability of the application of blockchain technology in the IoT. In order to solve this problem, we proposed an IoT adaptive dynamic blockchain networking method based on discrete heartbeat signals. The feature of the method is to set a different monitoring time for each group of nodes, that is, discrete heartbeat signals monitoring. When the number of nodes gradually decreases, the IoT adaptive dynamic blockchain network can dynamically adapt to this process. Even when more than 1/3 of the IoT are offline, the adaptive dynamic IoT blockchain network can maintain stable running. This method also has the advantages of a short network expectation recovery time and avoids instantaneous system paralysis caused by the thundering herd effect. This research improves the security and stability of the application of blockchain technology in the IoT, and provides the necessary technical foundation for the better combination of blockchain technology and IoT technology.

A motion planner based on artificial potential field for unmanned tractor is proposed in this paper. In order to get the effective environment model, the model for condition of terrain and impact of ground to tractor is analyzed and built. The tractor usually brings a trailer behind, so the kinematics of tractor with a trailer is presented. The motion planner based on artificial potential field is designed for the unmanned tractor working in farmland. According to the characteristics of the unmanned tractor, the control algorithm and motion planner is optimized. The simulation of the improved motion planner for unmanned tractor is presented and analyzed. And the simulation results are presented to show the effectiveness of the proposed method.

© 2016 IEEE. 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.

© 2016 IEEE. 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.

Logging harvesters represent a set of high-performance modern forestry machinery, which can finish a series of continuous operations such as felling, delimbing, peeling, bucking and so forth with human intervention. It is found by experiment that during the process of the alignment of the harvesting head to capture the trunk, the operator needs a lot of observation, judgment and repeated operations, which lead to the time and fuel losses. In order to improve the operation efficiency and reduce the operating costs, the point clouds for standing trees are collected with a low-cost 2D laser scanner. A cluster extracting algorithm and filtering algorithm are used to classify each trunk from the point cloud. On the assumption that every cross section of the target trunk is approximate a standard circle and combining the information of an Attitude and Heading Reference System, the radii and center locations of the trunks in the scanning range are calculated by the Fletcher-Reeves conjugate gradient algorithm. The method is validated through experiments in an aspen forest, and the optimized calculation time consumption is compared with the previous work of other researchers. Moreover, the implementation of the calculation result for automotive capturing trunks by the harvesting head during the logging operation is discussed in particular.

Space grippers are the key devices for accomplishing space non-cooperative target capture, which has a great significance for satellite services and space debris removal. This article proposes a novel mechanical gripper device for the capture of aluminum honeycomb panels of non-cooperative satellites. The gripper was modeled and assembled in the three-dimensional modeling platform UGNX. The model was imported into the simulation software ADAMS. ADAMS is capable of analyzing the kinematic feasibility of the gripper model. Collision and penetrating power analysis of the mechanical claws into an aluminum honeycomb plate were carried out in LS-DYNA. Through non-vertical piercing experiment, the maximum approaching angle tolerance is 10°. The established rigid connection can withstand a destructive force greater than 1000 N. A prototype of the mechanical gripper is built. A ground test was carried out with this prototype, in which a test-platform simulated the space microgravity environment. The results certified that the prototype could reach the target at a relative speed of 0.5 m/s and then quickly complete the grabbing motion and establish a rigid connection. The experiment shows that this mechanical gripper can accomplish the task of repeatedly capturing the surface of non-cooperative space satellites.

The Partitioned Global Address Space (PGAS) model of Unified Parallel C (UPC) can help users express and manage application data locality on non-uniform memory access (NUMA) multi-core shared-memory systems to get good performance. First, we describe several UPC program optimization techniques that are important to achieving good performance on NUMA multi-core computers with examples and quantitative performance results. Second, we use two numerical computing kernels, parallel matrix–matrix multiplication and parallel 3-D FFT, to demonstrate the end-to-end development and optimization for UPC applications. Our results show that the optimized UPC programs achieve very good and scalable performance on current multi-core systems and can even outperform vendor-optimized libraries in some cases.

A good benchmarking methodology can save a tremendous amount of resources in terms of human effort, machine cycles, and cost. Such a methodology must consider the relevance and openness of the chosen codes, well-defined rules for executing and reporting the benchmarks, a review process to enforce the rules, and a public repository for the obtained information. For the methodology to be feasible, it must also be supported by adequate tools that enable the user to consistently execute the benchmarks and gather the requisite metrics. At the very least, reliable benchmarking results can help people make decisions about HPC acquisitions and assist scientists and engineers in system advances. By saving resources and enabling balanced designs and configurations, realistic benchmarking ultimately leads to increased competitiveness in both industry and academia.

In single-particle cryo electron microscopy, many electron microscope images each of a single instance of a biological particle such as a virus or a ribosome are measured and the 3-D electron scattering intensity of the particle is reconstructed by computation. Because each instance of the particle is imaged separately, it should be possible to characterize the heterogeneity of the different instances of the particle as well as a nominal reconstruction of the particle. In this paper, such an algorithm is described and demonstrated on the bacteriophage Hong Kong 97. The algorithm is a statistical maximum likelihood estimator computed by an expectation maximization algorithm implemented in Matlab software.

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.

© 2015 IEEE. 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.

The storage needs of modern scientific applications are growing exponentially, and designing economical storage solutions for such applications – especially in Grid environments – is an important research topic. This work presents Kosha, a system that aims to harvest redundant storage space on cluster nodes and user desktops to provide a reliable, shared file system that acts as a large distributed storage. Kosha utilizes peer-to-peer (p2p) mechanisms to enhance the widely-used Network File System (NFS). P2P storage systems provide location transparency, mobility transparency, load balancing, and file replication – features that are not available in NFS. On the other hand, NFS provides hierarchical file organization, directory listings, and file permissions, which are missing from p2p storage systems. By blending the strengths of NFS and p2p storage systems, Kosha provides a low overhead storage solution. Our experiments show that compared to unmodified NFS, Kosha introduces a 3.3% fixed overhead and 4.5% additional overhead as nodes are increased from two to sixteen. For larger number of nodes, the additional overhead increases slowly. Kosha achieves load balancing in distributed directories, and guarantees $99.99\%$ or better file availability.

Copyright 2014 ACM 978-1-4503-3247-7/14/10$15.00. 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.

The Partitioned Global Address Space (PGAS) programming models combine shared and distributed memory features, providing the basis for high performance and high productivity parallel programming environments. UPC++ [39] is a very recent PGAS implementation that takes a library-based approach and avoids the complexities associated with compiler transformations. However, this implementation does not support dynamic task parallelism and only relies on other threading models (e.g., OpenMP or pthreads) for exploiting parallelism within a PGAS place.In this paper, we introduce a compiler-free PGAS library called HabaneroUPC++, which supports a tighter integration of intra-place and inter-place parallelism than standard hybrid programming approaches. The library makes heavy use of C++11 lambda functions in its APIs. C++11 lambdas avoid the need for compiler support while still retaining the syntactic convenience of language-based approaches. The HabaneroUPC++ library implementation is based on a tight integration of the UPC++ library and the Habanero-C++ library, with new extensions to support the integration. The UPC++ library is used to provide PGAS communication and function shipping support using GASNet, and the Habanero-C++ library is used to provide support for intra-place work-stealing integrated with function shipping. We demonstrate the programmability and performance of our implementation using two benchmarks, scaled up to 6K cores. The insights developed in this paper promise to further enhance the usability and popularity of PGAS programming models.

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.

An estimation problem for statistical reconstruction of heterogeneous three-dimensional objects from two-dimensional tomographic data (single-particle cryoelectron microscope images) is posed as the problem of estimating class probabilities, means, and covariances for a Gaussian mixture where both the mean and covariance are stochastically structured. Both discrete (i.e., classes) and continuous heterogeneity is included. A maximum likelihood solution computed by a generalized expectation-maximization algorithm is presented and demonstrated on experimental images of Flock House Virus.

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.

The analysis of Cosmic Microwave Background (CMB) observations is a long-standing computational challenge, driven by the exponential growth in the size of the data sets being gathered. Since this growth is projected to continue for at least the next decade, it will be critical to extend the analysis algorithms and their implementations to peta-scale high performance computing (HPC) systems and beyond. The most computationally intensive part of the analysis is generating and reducing Monte Carlo realizations of an experiment's data. In this work we take the current state-of-the-art simulation and mapping software and investigate its performance when pushed to tens of thousands of cores on a range of leading HPC systems, in particular focusing on the communication bottleneck that emerges at high concurrencies. We present a new communication strategy that removes this bottleneck, allowing for CMB analyses of unprecedented scale and hence fidelity. Experimental results show a communication speedup of up to 116x using our alternative strategy.

A statistical estimation problem for determining 3-D reconstructions from a single 2-D projection image of each of multiple objects when the objects are heterogeneous is described. The method is based on a Gaussian mixture description of the heterogeneity and is motivated by cryo electron microscopy of biological objects.

Existing multicore systems already provide deep levels of thread parallelism; hybrid programming models and composability of parallel libraries are very active areas of research within the scientific programming community. As more applications and libraries become parallel, scenarios where multiple threads compete for a core are unavoidable. In this paper we evaluate the impact of task oversubscription on the performance of MPI, OpenMP and UPC implementations of the NAS Parallel Benchmarks on UMA and NUMA multi-socket architectures. We evaluate explicit thread affinity management against the default Linux load balancing and discuss sharing and partitioning system management techniques. Our results indicate that oversubscription provides beneficial effects for applications running in competitive environments. Sharing all the available cores between applications provides better throughput than explicit partitioning. Modest levels of oversubscription improve system throughput by 27% and provide better performance isolation of applications from their co-runners: best overall throughput is always observed when applications share cores and each is executed with multiple threads per core. Rather than “resource” symbiosis, our results indicate that the determining behavioral factor when applications share a system is the granularity of the synchronization operations.

Two algorithms are described for electron microscopy tasks: (1) 3-D reconstruction of an infectious bacteriophage, including the tail, based on a set of single-particle cryo electron microscopy images of identical phage particles with one image per particle and (2) restoration, resolution enhancement, and classification of spherical viruses in a cell based on a tomographic reconstruction of the entire cell. While different tasks, the statistical algorithms, which are maximum likelihood estimators, have extensive commonality. In order to provide solutions for such tasks in a timely fashion, a software toolkit has been created, based on the commonality, for writing parallel software systems to solve these problems.

Maximum likelihood statistical algorithms are described for estimating the 3-D variation of the electron scattering intensity of biological objects from cryo electron microscopy images of multiple instances of the object. Three virus objects, two spherical and one helical, are considered. Solution of the maximum likelihood problem by expectation maximization algorithms or by direct maximization of the log likelihood requires large scale computing and end-to-end codesign of biological problem formulation, statistical models, algorithms, and software design and implementation have contributed to achieving practical results.

A statistical approach for computing 3-D reconstructions of virus particles from cryo electron microscope images and minimal prior information has been developed which can solve a range of specific problems. The statistical approach causes high computation and storage complexity in the software implementation. A parallel software toolkit is described which allows the construction of software targeted at commodity PC clusters which is modular, reusable, and user-transparent while at the same time delivering nearly linear speedup on practical problems.

BlueGene/L is currently the world's fastest supercomputer. It consists of a large number of low power dual-processor compute nodes interconnected by high speed torus and collective networks, Because compute nodes do not have shared memory, MPI is the the natural programming model for this machine. The BlueGene/L MPI library is a port of MPICH2.In this paper we discuss the implementation of MPI collectives on BlueGene/L. The MPICH2 implementation of MPI collectives is based on point-to-point communication primitives. This turns out to be suboptimal for a number of reasons. Machine-optimized MPI collectives are necessary to harness the performance of BlueGene/L. We discuss these optimized MPI collectives, describing the algorithms and presenting performance results measured with targeted micro-benchmarks on real BlueGene/L hardware with up to 4096 compute nodes.

A statistical method for computing 3-D reconstructions of virus particles from cryo electron microscope images and minimal prior information - particle symmetry and radii - is described. Two different approaches for parallel implementation of the algorithm are described based on parallel processing of different images and based on parallel numerical integration and numerical results showing nearly linear speedup are presented.

A rolling velocity control method for a spherical mobile robot is implemented.Nonlinear relationships between the control-input and state-output of the spherical mobile robot are hard to be described by exact mathematical model.With the radial basis function neural network,nonlinear mapping from the inputs to outputs of the robot are established by online training.Thereafter the velocity controller of the robot is designed by feedback linearization method,and it is composed of a feedback linearization controller and a compensation controller for reducing approximation errors of neural network.The implementation of the controller is given.Experiments show that the velocity control for the spherical mobile robot can be achieved stably by this method.