Hot Paths Research Articles

Hot paths and sectors of the energy metabolic process in the Jing-Jin-Ji urban agglomeration

China's Jing-Jin-Ji urban agglomeration shows exceptionally high urbanization and resource utilization problems that require to identify hot paths and sectors of energy metabolism, thus recognizing key links of cleaner production, and supporting energy conservation and emission reduction. In this paper, an energy metabolic network model was built for the urban agglomeration to simulate energy transfers between sectors using ecological network analysis, and path analysis was performed starting from initial production to identify critical paths and sectors. The chain of paths through 0–3 intermediate nodes dominated the energy metabolic processes, becoming the key to diagnosing problems. The critical paths in the urban agglomeration evolved from joint dominance by intra- and inter-city paths to inter-city paths, indicating increasingly coordinated development. Intra-city paths from Beijing's and Tianjin's Industry were always critical, whereas inter-city paths mainly started from Shijiazhuang's, Handan's, Tangshan's or Baoding's Industry; Beijing's, Tianjin's, Shijiazhuang's, Tangshan's and Handan's Industry played export roles, with Beijing's, Tianjin's, and Shijiazhuang's Industry also playing transfer roles and the other sectors (especially Construction) playing import roles. Above results will serve for the agglomeration's cleaner, more sustainable and more coordinated development.

Energy Balance Multihop Clustering Routing Protocol for Large-Scale Water Quality Monitoring

Due to the influence of the environment on the water quality wireless sensor network, it is difficult to replace the node energy at any time, so it must make the most of the little energy available. This work provides a technique that combines cluster head selection, cluster structure creation, and data transmission into one optimal scheme. Firstly, we optimize the cluster head election probability threshold formula on the basis of LEACH and introduce overlap ratio in the competitive mechanism, to avoid excessive overlap between cluster heads. Subsequently, to alleviate the “hot spot” problem caused by multihop, the competitive mechanism of I-LEACH is optimized, which is based on the nonuniform competitive mechanism in the EEUC algorithm when electing the cluster head. Meanwhile, in the structural planning between cluster heads, the optimal path is searched based on the parallelism of genetic algorithm (variable path coding strategy); the combination of I-LEACH and EEUC-IGA, named Energy Balance Multihop Clustering Routing Protocol (BEBMCR), can avoid the emergence of “hot paths” and reduce running time. The simulation results show that BEBMCR still has a longer stable period and higher energy utilization rate under large-scale networks, and node energy consumption is more balanced.

Spatial–temporal travel pattern mining using massive taxi trajectory data

Deep understanding of residents’ travel patterns would provide helpful insights into the mechanisms of many socioeconomic phenomena. With the rapid development of location-aware computing technologies, researchers have easy access to large quantities of travel data. As an important data source, taxi trajectory data are featured by their high quality, good continuity and wide distribution, making it suitable for travel pattern mining. In this paper, we use taxi trajectory data to study spatial–temporal characterization of urban residents’ travel patterns from two aspects: attractive areas and hot paths. Firstly, a framework of trajectory preprocessing, including data cleaning and extracting the taxi passenger pick-up/drop-off points, is presented to reduce the noise and redundancy in raw trajectory data. Then, a grid density based clustering algorithm is proposed to discover travel attractive areas in different periods of a day. On this basis, we put forward a spatial–temporal trajectory clustering method to discover hot paths among travel attractive areas. Compared with previous algorithms, which only consider the spatial constraint between trajectories, temporal constraint is also considered in our method. Through the experiments, we discuss how to determine the optimal parameters of the two clustering algorithms and verify the effectiveness of the algorithms using real data. Furthermore, we analyze spatial–temporal characterization of Chongqing residents’ travel pattern.

An Abstract Interpretation-Based Model of Tracing Just-in-Time Compilation

Tracing just-in-time compilation is a popular compilation technique for the efficient implementation of dynamic languages, which is commonly used for JavaScript, Python, and PHP. It relies on two key ideas. First, it monitors program execution in order to detect so-called hot paths, that is, the most frequently executed program paths. Then, hot paths are optimized by exploiting some information on program stores that is available and therefore gathered at runtime. The result is a residual program where the optimized hot paths are guarded by sufficient conditions ensuring some form of equivalence with the original program. The residual program is persistently mutated during its execution, for example, to add new optimized hot paths or to merge existing paths. Tracing compilation is thus fundamentally different from traditional static compilation. Nevertheless, despite the practical success of tracing compilation, very little is known about its theoretical foundations. We provide a formal model of tracing compilation of programs using abstract interpretation. The monitoring phase (viz., hot path detection) corresponds to an abstraction of the trace semantics of the program that captures the most frequent occurrences of sequences of program points together with an abstraction of their corresponding stores, for example, a type environment. The optimization phase (viz., residual program generation) corresponds to a transform of the original program that preserves its trace semantics up to a given observation as modeled by some abstraction. We provide a generic framework to express dynamic optimizations along hot paths and to prove them correct. We instantiate it to prove the correctness of dynamic type specialization and constant variable folding. We show that our framework is more general than the model of tracing compilation introduced by Guo and Palsberg [2011], which is based on operational bisimulations. In our model, we can naturally express hot path reentrance and common optimizations like dead-store elimination, which are either excluded or unsound in Guo and Palsberg’s framework.

Zirconium dioxide thermal insulation coatings obtained by highly energized plasma spray

This paper presents the results of studying the structure, physical, and mechanical properties, and heat resistance of Ni-Co-Cr-Al-Y + ZrO2 thermal insulation coatings obtained by highly energized plasma spray on modified equipment using a PNK-50 plasmatron of an original design, involving the linear and circular injection of a powder blend. As a result of optimizing the working process, coatings with the following characteristics were produced: density ρ = 7.6 g/cm3, overall porosity P = 4.3%, open porosity Po = 1%, HV hardness = 980 kgf/mm2, and increased heat resistance. The developed coating is intended for protection against high-temperature gas corrosion and the thermal insulation of the working surfaces of parts of hot gas turbine paths.

Code mapping algorithm for custom instructions on reconfigurable instruction set processors

Instruction set extension with custom instructions has become common to speed up execution of applications. And it is crucial of the problem to generate new optimised code with custom instructions through retargetable tool suites. This article proposes a code mapping algorithm, which maps static code of programs to dynamic hot paths corresponding to custom instructions. The algorithm uses parameterised polynomial representations and invokes some string matching method. It can play both fine-grained mapping and coarse-grained mapping and find nested matching optimisation in representations. Correctness of the algorithm is formally proved, and time complexity is also analysed from it. Furthermore, some experiments are designed with some programs of NetBench and MiBench. The results show that the algorithm can achieve high accuracy and have notable performance improvement.

Tracing compilation by abstract interpretation

Tracing just-in-time compilation is a popular compilation schema for the efficient implementation of dynamic languages, which is commonly used for JavaScript, Python, and PHP. It relies on two key ideas. First, it monitors the execution of the program to detect so-called hot paths, i.e., the most frequently executed paths. Then, it uses some store information available at runtime to optimize hot paths. The result is a residual program where the optimized hot paths are guarded by sufficient conditions ensuring the equivalence of the optimized path and the original program. The residual program is persistently mutated during its execution, e.g., to add new optimized paths or to merge existing paths. Tracing compilation is thus fundamentally different than traditional static compilation. Nevertheless, despite the remarkable practical success of tracing compilation, very little is known about its theoretical foundations. We formalize tracing compilation of programs using abstract interpretation. The monitoring (viz., hot path detection) phase corresponds to an abstraction of the trace semantics that captures the most frequent occurrences of sequences of program points together with an abstraction of their corresponding stores, e.g., a type environment. The optimization (viz., residual program generation) phase corresponds to a transform of the original program that preserves its trace semantics up to a given observation as modeled by some abstraction. We provide a generic framework to express dynamic optimizations and to prove them correct. We instantiate it to prove the correctness of dynamic type specialization. We show that our framework is more general than a recent model of tracing compilation introduced in POPL~2011 by Guo and Palsberg (based on operational bisimulations). In our model we can naturally express hot path reentrance and common optimizations like dead-store elimination, which are either excluded or unsound in Guo and Palsberg's framework.

VALORISATION OF STAINLESS STEEL SLAGS AS A HYDRAULIC BINDER

This work is focused on exploring various cold and hot stage treatment paths of stainless steel slag as a tool to improve its hydraulic properties. At a cold stage, mechanical and chemical activation was applied on industrial stainless steel slag; and it was found that both activation methods effectively improve the reactivity of the studied slag. In addition, the detailed investigation of hydration on two major phases, γ – C2S and merwinite, revealed that their hydration resulted in the formation of C – S – H gel, typically formed during the hydration of OPC. Regarding the hot stage treatment, the combination of the chemistry modification with the addition of fly ash at 30 wt. % and fast cooling by means of water quenching resulted in a complete amorphisation of the material. Ultimately, the produced material possessing similar properties to granulated blast furnace slag could be used as a latent hydraulic material in blended cements.

Thermal–petrological controls on the location of earthquakes within subducting plates

We find that in young and warm subducting plates, earthquakes occur just below the Moho. In older plates, earthquakes occur throughout the subducting oceanic crust, as well as the subducting mantle. We document this behavior in several subduction zones where there are independent constraints on earthquake locations and slab structure, specifically for northern and southern Japan, Alaska, and Cascadia. The differences in earthquake depth relative to subducting crust may reflect large differences in temperature and thus locations of major dehydration reactions. In colder slabs, the crust passes through blueschist-facies dehydration reactions, while in Cascadia and Nankai the major dehydration reactions in crust may be due to zoisite- and amphibole-breakdown or associated melting. The cold paths allow more mineral-bound H2O to be retained within the crust at shallow depths, eventually released upon dehydration over shorter time intervals than warm paths. The cold path dehydration reactions also result in net positive volume changes of solid+fluid, with solid volume decreasing less than the volume of H2O produced. On hot paths the net volume changes are negative, with solid volumes decreasing more than the volume of H2O produced. The difference in behavior could drive a net increase in pore pressure upon dehydration for the cold but not the hot crustal paths. The difference in rate of release in H2O, and difference in sign of net system volume change may promote seismogenesis in cold subduction zones but inhibit it in the crust of warm slabs. Within the mantle of the downgoing plate earthquakes mostly occur where serpentine is stable or breaks down, in both settings.

Numerical Analysis of Heat Transfer in the Concentric Heat Exchanger

The computational fluid dynamics (CFD) software is used to compute three-dimensional concentric heat exchanger in this research. In order to reduce the burden of the computational time, the concentric heat exchanger is simplified sector of 5° for the regular arrangement of internal shape. The working fluids for hot flow and cold flow are helium and molten salt individually. The arrangements for hot and cold flow paths within a heat exchanger is opposite. This study is mainly focused on the distribution of field for the two layers of concentric heat exchanger. The width of the flow channel as well as the length, pitch, thickness and angle of fin have been changing to analyze the effectiveness-NTU method. The results showed that the best heat transfer of fin thickness, angle, space, length, and flow channel are under 5mm, 5°, 8mm, 44mm, and 12mm, respectively.

Adaptive multi-level compilation in a trace-based Java JIT compiler

This paper describes our multi-level compilation techniques implemented in a trace-based Java JIT compiler (trace-JIT). Like existing multi-level compilation for method-based compilers, we start JIT compilation with a small compilation scope and a low optimization level so the program can start running quickly. Then we identify hot paths with a timer-based sampling profiler, generate long traces that capture the hot paths, and recompile them with a high optimization level to improve the peak performance. A key to high performance is selecting long traces that effectively capture the entire hot paths for upgrade recompilations. To do this, we introduce a new technique to generate a directed graph representing the control flow, a TTgraph, and use the TTgraph in the trace selection engine to efficiently select long traces. We show that our multi-level compilation improves the peak performance of programs by up to 58.5% and 22.2% on average compared to compiling all of the traces only at a low optimization level. Comparing the performance with our multi-level compilation to the performance when compiling all of the traces at a high optimization level, our technique can reduce the startup times of programs by up to 61.1% and 31.3% on average without significant reduction in the peak performance. Our results show that our adaptive multi-level compilation can balance the peak performance and startup time by taking advantage of different optimization levels.

K-Calling context profiling

Calling context trees are one of the most fundamental data structures for representing the interprocedural control flow of a program, providing valuable information for program understanding and optimization. Nodes of a calling context tree associate performance metrics to whole distinct paths in the call graph starting from the root function. However, no explicit information is provided for detecting short hot sequences of activations, which may be a better optimization target in large modular programs where groups of related functions are reused in many different parts of the code. Furthermore, calling context trees can grow prohibitively large in some scenarios. Another classical approach, called edge profiling, collects performance metrics for caller-callee pairs in the call graph, allowing it to detect hot paths of fixed length one. We study a generalization of edge and context-sensitive profiles by introducing a novel data structure called k-calling context forest (k-CCF). Nodes in a k-CCF associate performance metrics to paths of length at most k that lead to each distinct routine of the program, providing edge profiles for k=1, full context-sensitive profiles for k equal to infinity, as well as any other intermediate point in the spectrum. We study the properties of the k-CCF both theoretically and experimentally on a large suite of prominent Linux applications, showing how to construct it efficiently and discussing its relationships with the calling context tree. Our experiments show that the k-CCF can provide effective space-accuracy tradeoffs for interprocedural contextual profiling, yielding useful clues to the hot spots of a program that may be hidden in a calling context tree and using less space for small values of k, which appear to be the most interesting in practice.

SPUR

Tracing just-in-time compilers (TJITs) determine frequently executed traces (hot paths and loops) in running programs and focus their optimization effort by emitting optimized machine code specialized to these traces. Prior work has established this strategy to be especially beneficial for dynamic languages such as JavaScript, where the TJIT interfaces with the interpreter and produces machine code from the JavaScript trace. This direct coupling with a JavaScript interpreter makes it difficult to harness the power of a TJIT for other components that are not written in JavaScript, e.g., the DOM implementation or the layout engine inside a browser. Furthermore, if a TJIT is tied to a particular high-level language interpreter, it is difficult to reuse it for other input languages as the optimizations are likely targeted at specific idioms of the source language. To address these issues, we designed and implemented a TJIT for Microsoft's Common Intermediate Language CIL (the target language of C#, VisualBasic, F#, and many other languages). Working on CIL enables TJIT optimizations for any program compiled to this platform. In addition, to validate that the performance gains of a TJIT for JavaScript do not depend on specific idioms of JavaScript that are lost in the translation to CIL, we provide a performance evaluation of our JavaScript runtime which translates JavaScript to CIL and then runs on top of our CIL TJIT.

Microstructural characterisation related to hot tearing of Al-Cu sand mould castings

In this paper, the hot tearing behaviour in Al-(4.8?6)%Cu sand mould castings was preliminary investigated by means of microstructural examination and image analysis. A dog-bone pattern was employed for the realisation of the castings and three Al-Cu alloys with different Cu and Si contents were used. The effects of the alloy composition and of different pouring temperatures on the hot tearing behaviour of the castings were evaluated. The quantity of the eutectic phase available during solidification is considered a very important parameter for the crack healing phenomenon, in fact the eutectic liquid flows into the hot tear areas and covers parts of the cracks. The hot tear paths and surfaces were observed by means of optical and scanning electron microscopes, which showed that the fracture surfaces were dominated by bridged grain boundaries and the presence of a liquid film, in particular at higher copper concentrations. Several samples were also drawn from the zones characterised by the maximum cross-section variation and the micrographs from the optical microscope were statistically analysed by means of commercially available image analysis software. The quantitative microstructural parameters of percentage, mean area and distribution of the eutectic phase were evaluated and correlated to the capacity of the eutectic liquid to heal open fractures caused by hot tearing for the examined alloys.

DYNAMICAL DIPOLE MODE IN FUSION HEAVY-ION REACTIONS

The prompt γ-ray emission, associated with the dynamical dipole mode decay, was investigated in the 32,36 S + 100,96 Mo and 36,40 Ar + 96,92 Zr fusion-evaporation reactions in the energy range E lab= 6 - 16 MeV / nucleon . The above reaction pairs populate, through entrance channels having different charge asymmetries, a compound nucleus in the 132 Ce mass region at excitation energies of 117, 174 and 284 MeV with identical spin distribution. By studying the differential γ-ray multiplicity spectra of the considered systems, the features of the dynamical dipole mode as a function of the beam energy were extracted while the γ-ray angular distributions were used to prove its pre-equilibrium character. The experimental findings were compared with theoretical predictions performed within a BNV transport model and based on a collective bremsstrahlung analysis of the entrance channel reaction dynamics. As a fast cooling mechanism on the fusion path, the prompt dipole radiation could be of interest for the synthesis of super heavy elements through hot fusion reactions providing a way to cool down the hot fusion paths, so ending up with a larger survival probability. To shed light on this hypothesis, the dynamical dipole mode investigation was extended to a heavier compound nucleus, 192 Pb , by means of the 40 Ca + 152 Sm and 48 Ca + 144 Sm reactions at E lab= 11 and 10.1 MeV/nucleon, respectively. Preliminary results of this measurement, concerning both fusion-evaporation and fission events are presented.

A study of potential parallelism among traces in Java programs

The exploitation of parallelism among traces, i.e. hot paths of execution in programs, is a novel approach to the automatic parallelization of Java programs and it has many advantages. However, to date, the extent to which parallelism exists among traces in programs has not been made clear. The goal of this study is to measure the amount of trace-level parallelism in several Java programs. We extend the Jupiter Java Virtual Machine with a simulator that models an abstract parallel system. We use this simulator to measure trace-level parallelism. We further use it to examine the effects of the number of processors, trace window size, and communication type and cost on performance. We also analyze the dependence characteristics of the benchmarks and see how they relate to parallelism. The results indicate that enough trace-level parallelism exists for a modest number of processors. Thus, we conclude that trace-based parallelization is a potentially viable approach to improve the performance of Java programs.

Dealing with data dependent conditions to enable general global source code transformations

Global source code transformations, such as Global Loop Transformations (GLT), are usually performed on a Geometrical Model (GM) which is very effective in dealing with complex transformations. However, this model imposes strict limitations on the input code, and it is not capable to deal with data dependent conditions. The technique presented in this paper can deal with data dependent conditions at any loop level. At the outermost loop level hot code paths are grouped together into limited number of clusters called scenarios to maximise the GLT benefit for a given code size growth. On the middle and innermost loop level we manipulate the abstract syntax tree to move the data dependent conditions out of the GLT optimisation scope. Results show up to 45.8% improvement compared to state-of-the-art.

Optimizing software cache performance of packet processing applications

Network processors (NPs) are widely used in many types of networking equipment due to their high performance and flexibility. For most NPs, software cache is used instead of hardware cache due to the chip area, cost and power constraints. Therefore, programmers should take full responsibility for software cache management which is neither intuitive nor easy to most of them. Actually, without an effective use of it, long memory access latency will be a critical limiting factor to overall applications. Prior researches like hardware multi-threading, wide-word accesses and packet access combination for caching have already been applied to help programmers to overcome this bottleneck. However, most of them do not make enough use of the characteristics of packet processing applications and often perform intraprocedural optimizations only. As a result, the binary codes generated by those techniques often get lower performance than that comes from hand-tuned assembly programming for some applications. In this paper, we propose an algorithm including two techniques - Critical Path Based Analysis (CPBA) and Global Adaptive Localization (GAL), to optimize the software cache performance of packet processing applications. Packet processing applications usually have several hot paths and CPBA tries to insert localization instructions according to their execution frequencies. For further optimizations, GAL eliminates some redundant localization instructions by interprocedural analysis and optimizations. Our algorithm is applied on some representative applications. Experiment results show that it leads to an average speedup by a factor of 1.974.

Improving data-flow analysis with path profiles

Data-flow analysis computes its solutions over the paths in a control-flow graph. These paths---whether feasible or infeasible, heavily or rarely executed---contribute equally to a solution. However, programs execute only a small fraction of their potential paths and, moreover, programs' execution time and cost is concentrated in a far smaller subset of hot paths. This paper describes a new approach to analyzing and optimizing programs, which improves the precision of data flow analysis along hot paths. Our technique identifies and duplicates hot paths, creating a hot path graph in which these paths are isolated. After flow analysis, the graph is reduced to eliminate unnecessary duplicates of unprofitable paths. In experiments on SPEC95 benchmarks, path qualification identified 2--112 times more non-local constants (weighted dynamically) than the Wegman-Zadek conditional constant algorithm, which translated into 1--7% more dynamic instructions with constant results.

Calculation of the temperature dependence of hot electron scattering in heavily p-doped GaAs using a high-temperature approximation to the dielectric function

Using a high-temperature approximation to the dielectric function within the random phase approximation, we calculate hot electron scattering rates, as a function of temperature and doping density, in p-doped GaAs. The dielectric function of the holes contains contributions from intraband excitations and interband excitations. The former reduces to an analytic form within the two pole approximation (which used Boltzmann statistics), whereas the latter was calculated numerically. The collective excitation mode of the holes was defined by intraband excitations, since at very small wavevectors, the interband excitations vanish. However, at low temperature the interband excitations were found to be the dominant Landau damping mechanism, which strongly suppressed the plasmon at moderate doping levels. At high temperature the excitations from the heavy to light band were partially suppressed, and the plasmon was not overwhelmingly Landau damped by either interband or intraband excitations. At room temperature, an analytic dielectric function where the interband excitations have been neglected, may be used to accurately calculate hot electron mean free paths. This approximation was found to become more accurate with lower doping levels, but was not appropriate at low temperature.