Can your program run faster, compile faster, and adapt faster?
There is no limit of speed in the logic world.
Adapt faster through self-tuning
Quality requirements of a software system cannot be optimally met, especially
when it is running in an uncertain and changing environment. In principle, a
controller at runtime can monitor the change impact on quality requirements of
the system, update the expectations and priorities from the environment, and
take reasonable actions to improve the overall satisfaction. In practice,
however, existing controllers are mostly designed for tuning low- level
performance indicators rather than high-level requirements. By maintaining a
live goal model to represent the runtime requirements and linking the overall
satisfaction to an earned business value indicator as feedback, we propose a
control-theoretic self-tuning method that can dynamically tune the preferences
of different quality requirements, and can autonomously make the tradeoff
decisions among different quality requirements through our preference-based
goal reasoning. The reasoning result is involved to reconfigure the variation
points of the goal model, and accordingly mapped to the system architecture
reconfiguration. The effectiveness of our self-tuning method is evaluated by
comparing the earned business value with the static and ad-hoc methods and
analysing the self-tuning process.
Peng, Xin; Chen, Bihuan; Yu, Yijun and
Zhao, Wenyun (2012). Self-tuning of software systems through goal-based
feedback control loop. Journal of Systems and Software, 85(12) pp.
Compiler faster through precompilation
Large-scale legacy programs take long time to compile, thereby hampering
productivity. This paper presents algorithms that reduce compilation time by
analyzing syntactic dependencies in fine-grain program units, and by removing
redundancies as well as false dependencies. These algorithms are combined with
parallel compilation techniques (compiler farms, compiler caches), to further
reduce build time. We demonstrate through experiments their effectiveness in
achieving significant speedup for both fresh and incremental builds.
Yijun Yu, Homayoun Dayani-Fard, John Mylopoulos, and Periklis
Andritsos (2005). "Reducing Build Time through Precompilations for Evolving Large
Software". In: 21st IEEE International Conference on Software Maintenance, 26-29
Sep 2005, Budapest, Hungary.
Run faster through visualisation
Cache behavior of a program has an ever-growing strong impact on its execution
time. Characterizing the behavior by visible patterns is considered a way to
pinpoint the bottleneck against performance. This paper presents a framework of
visualization for trace distributions to extract the useful cache behavior
patterns. We focus on cache misses, reuse distances, temporal or spatial
localities, etc. The histograms of these distribution patterns measure the
behavior in quantity, revealing effective program optimizations. The
performance bottlenecks are exposed as hot spots highlighted in the source
code, showing the exact locations to apply suitable optimizations. The impact
of the source-level program optimizations, again, can be verified by the
Yijun Yu, Kristof Beyls, and Erik H. D'Hollander (2004). Visualizing the
Impact of the Cache on Program Execution. Journal for the Integrated Study of
AI, Cognitive Science and Applied Epistemology, 19(3-4), pp. 1-23.
Office: +44 (0) 1908 6 55562