Analysing the Linux kernel feature model changes using FMDiff

Evolving a large scale, highly variable system is a challenging task. For such a system, evolution operations often require to update consistently both their implementation and its feature model. In this context, the evolution of the feature model closely follows the evolution of the system. The purpose of this work is to show that fine-grained feature changes can be used to guide the evolution of the highly variable system. In this paper, we present an approach to obtain fine-grained feature model changes with its supporting tool “FMDiff”. Our approach is tailored for Kconfig-based variability models and proposes a feature change classification detailing changes in features, their attributes and attribute values. We apply our approach to the Linux kernel feature model, extracting feature changes occurring in sixteen official releases. In contrast to previous studies, we found that feature modifications are responsible for most of the changes. Then, by taking advantage of the multi-platform aspect of the Linux kernel, we observe the effects of a feature change across the different architecture-specific feature models of the kernel. We found that between 10 and 50 % of feature changes impact all the architecture-specific feature models, offering a new perspective on studies of the evolution of the Linux feature model and development practices of its developers.     

FEVER: An approach to analyze feature-oriented changes and artefact co-evolution in highly configurable systems

The evolution of highly configurable systems is known to be a challenging task. Thorough understanding of configuration options their relationships, and their implementation in various types of artefacts (variability model, mapping, and implementation) is required to avoid compilation errors, invalid products, or dead code. Recent studies focusing on co-evolution of artefacts detailed feature-oriented change scenarios, describing how related artefacts might change over time. However, relying on manual analysis of commits, such work do not provide the means to obtain quantitative information on the frequency of described scenarios nor information on the exhaustiveness of the presented scenarios for the evolution of a large scale system. In this work, we propose FEVER and its instantiation for the Linux kernel. FEVER extracts detailed information on changes in variability models (KConfig files), assets (preprocessor based C code), and mappings (Makefiles). We apply this methodology to the Linux kernel and build a dataset comprised of 15 releases of the kernel history. We performed an evaluation of the FEVER approach by manually inspecting the data and compared it with commits in the system’s history. The evaluation shows that FEVER accurately captures feature related changes for more than 85% of the 810 manually inspected commits. We use the collected data to reflect on occurrences of co-evolution in practice. Our analysis shows that complex co-evolution scenarios occur in every studied release but are not among the most frequent change scenarios, as they only occur for 8 to 13% of the evolving features. Moreover, only a minority of developers working on a given release will make changes to all artefacts related to a feature (between 10% and 13% of authors). While our conclusions are derived from observations on the evolution of the Linux kernel, we believe that they may have implications for tool developers as well as guide further research in the field of co-evolution of artefacts.     

Challenges of working with artifacts in requirements engineering and software engineering

When developing or evolving software systems of non-trivial size, having the requirements properly documented is a crucial success factor. The time and effort required for creating and maintaining non-code artifacts are significantly influenced by the tools with which practitioners view, navigate and edit these artifacts. This is not only true for requirements, but for any artifacts used when developing or evolving systems. However, there is not much evidence about how practitioners actually work with artifacts and how well software tools support them. Therefore, we conducted an exploratory study based on 29 interviews with software practitioners to understand the current practice of presenting and manipulating artifacts in tools, how practitioners deal with the challenges encountered, and how these challenges affect the usability of the tools used. We found that practitioners typically work with several interrelated artifacts concurrently, less than half of these artifacts can be displayed entirely on a large screen, the artifact interrelationship information is often missing, and practitioners work collaboratively on artifacts without sufficient support. We identify the existing challenges of working with artifacts and discuss existing solutions proposed addressing them. Our results contribute to the body of knowledge about how practitioners work with artifacts when developing or evolving software, the challenges they are faced with, and the attempts to address these challenges.     

Structuring the modeling space and supporting evolution in software product line engineering

The scale and complexity of product lines means that it is practically infeasible to develop a single model of the entire system, regardless of the languages or notations used. The dynamic nature of real-world systems means that product line models need to evolve continuously to meet new customer requirements and to reflect changes of product line artifacts. To address these challenges, product line engineers need to apply different strategies for structuring the modeling space to ease the creation and maintenance of models. This paper presents an approach that aims at reducing the maintenance effort by organizing product lines as a set of interrelated model fragments defining the variability of particular parts of the system. We provide support to semi-automatically merge fragments into complete product line models. We also provide support to automatically detect inconsistencies between product line artifacts and the models representing these artifacts after changes. Furthermore, our approach supports the co-evolution of models and their respective meta-models. We discuss strategies for structuring the modeling space and show the usefulness of our approach using real-world examples from our ongoing industry collaboration.     

嵌入式Linux内核挂起案例调试与解析

Linux内核在向嵌入式硬件平台的移植过程中会遇到各种问题,有些是纯软件问题,有些是软件和硬件接口的问题。在开发过程中,后一类问题往往难以借助现有的调试工具来分析。本文结合一个由于时钟问题导致Linux内核挂起的实际案例,论述了如何通过实验数据的分析结合理论推导来解决问题的方法。     

Symmetric Preferential Attachment for New Vertices Attaching to Software Networks

The evolution of open-source software systems can be regarded as the process of self-organization. Most existing models for software network evolution are based on preferential attachment. However, our empirical studies on the attachment of new vertices show that preferential attachment is not completely suitable for the formation of software networks. In this paper, the attachment mechanism of new vertices is studied in a set of real-world software systems. Firstly, these software systems are treated as directed networks, then based on our empirical studies on the connecting direction between the new vertices and existing networks, a mechanism of symmetric preferential attachment in software network evolution is proposed. It is worth mentioning that the probabilities for a vertex to acquire new incoming and outgoing connections are proportional to its in-degree and out-degree, respectively. Furthermore, the probability density functions of in-degree and out-degree distributions deduced through theoretical computations show that symmetric preferential attachment can produce scale-free networks, and the value ranges of the given exponent expressions are proved to be in accordance with those of various real-world software networks. Finally, the relationship between the exponents of in-degree and out-degree distributions and existing code reuse in software design and development is revealed. This work could provide a different perspective to observe potential formation and integration of real-world software systems.     

Linux内核软件体系结构恢复的研究

Ｌｉｎｕｘ是由全球范围的系统软件设计专家在遵守通用公共许可证条款（ＧＰＬ）的前提下共同开发的符合ＰＯＳＩＸ标准的类ＵＮＩＸ操作系统,在开发过程中没有严格完整的文档化软件体系结构,因而不利于内核开发者对Ｌｉｎｕｘ内核的理解和维护。文章在综合分析Ｌｉｎｕｘ内核有关文档的基础上,利用软件工具并分析部分Ｌｉｎｕｘ内核源码,恢复了Ｌｉｎｕｘ内核文档化的软件体系结构,以提高其可靠性、可维护性和可扩展性。Ｌｉｎｕｘ代表了Ｉｎｔｅｒｎｅｔ时代一种新的软件开发模式,对Ｌｉｎｕｘ内核软件体系结构恢复的研究,是这种新的开发模式下进行软件工程学研究的一种尝试。     

Evolution and stability of Linux kernels based on complex networks

This paper presents a novel method to study Linux kernel evolution using complex networks.Having investigated the node degree distribution and average path length of the call graphs corresponding to the kernel modules of 223 different versions(V1.1.0 to V2.4.35),we found that the call graphs are scale-free and smallworld networks.Based on the relationship between average path length and nodes,we propose a method to find unusual points during Linux kernel evolution using the slope of the average path length.Using the unusual points we identify major structural changes in kernel modules.A stability coefficient is also proposed to describe quantitatively the stability of kernel modules during evolution.Finally,we verify our result through Vasa’s metrics method.     

Manipulating algebraic specifications with term-based and graph-based representations

In an environment of continuous and rapid evolution, software design methodologies must incorporate techniques and tools that support changes in software artifacts. In the project, we are developing a tool targeted at software designers that integrates a collection of operations on algebraic specifications written in the language. The scope of includes not only modification of existing specifications, but also creation or derivation of new specifications, as well as their proof and execution, which are realized through inter-operability with existing tools. As involves the manipulation of software specification and inter-operability with other tools, the question of choosing appropriate representation formats is important. In this paper, we discuss the advantages and limitations of as a manipulation and exchange format in the setting of . We also present a new, graph-like format, which offers complementary features to a term-based format. Moreover, we present visualization utilities for these formats.     

Timing analysis of the PREEMPT RT Linux kernel

In the theory of real‐time scheduling, tasks are described by mathematical variables, which are used in analytical models in order to prove schedulability of the system. On real‐time Linux, tasks are computer programs, and Linux developers try to lower the latencies caused by the Linux kernel, trying to achieve faster response for the highest‐priority task. Although both seek temporal correctness, they use different abstractions, which end up separating these efforts in two different worlds, making it hard for the Linux practitioners to understand and apply the formally proved models to the Linux kernel and for theoretical researchers to apply the restrictions imposed by Linux for the theoretical models. This paper traces a parallel between the theory of response‐time analysis and the abstractions used in the Linux kernel. The contribution of this paper is threefold. We first identify the PREEMPT RT Linux kernel mechanisms that impact the timing of real‐time tasks and map these impacts to the main abstractions used by the real‐time scheduling theory. Then, we describe a customized trace tool, based on the existing trace infrastructure of the Linux kernel, that allows the measurement of the delays associated with the main abstractions of the real‐time scheduling theory. Finally, we use this customized trace tool to characterize the timing lines resulting from the behavior of the PREEMPT RT Linux kernel. Copyright © 2015 John Wiley & Sons, Ltd.     

移植Linux内核至DSP平台方案研究

DSP操作系统是实现复杂DSP应用的关键技术。Linux是一种免费的操作系统,很适合嵌入式应用。文章针对DSP应用的特点,分析了如何将Linux内核加以裁减、改造,使其适合DSP应用,形成通用的DSP操作系统。移植后的Lin ux内核,大小可以控制在200kB以下,减小了DSP平台上应用软件的开发难度,大大降低了DSP系统的开发成本。     

A generic model for semantics-based versioning in projects

Large projects generally involve a number of phases and evolve over a period of time. Several revisions of the individual artifacts consisting of the project take place during the various phases. These revisions and refinements are normally captured as different versions using configuration/version management tools. But the semantics of these refinements with respect to the project are not captured by existing mechanisms. In addition to the above, a change in the semantics of a project artifact may require suitable changes in other related artifacts. Existing mechanisms for configuration management do not provide mechanisms for change propagation based on the change semantics. In this paper, we propose a generic model for semantics-based version management in projects, which can be built over existing tools. The model also provides support for capturing how changes propagate in a project. We then elucidate the generality of the model by applying it to a project involving a CAD framework and a software development project     

Studying software evolution using topic models

Topic models are generative probabilistic models which have been applied to information retrieval to automatically organize and provide structure to a text corpus. Topic models discover topics in the corpus, which represent real world concepts by frequently co-occurring words. Recently, researchers found topics to be effective tools for structuring various software artifacts, such as source code, requirements documents, and bug reports. This research also hypothesized that using topics to describe the evolution of software repositories could be useful for maintenance and understanding tasks. However, research has yet to determine whether these automatically discovered topic evolutions describe the evolution of source code in a way that is relevant or meaningful to project stakeholders, and thus it is not clear whether topic models are a suitable tool for this task.In this paper, we take a first step towards evaluating topic models in the analysis of software evolution by performing a detailed manual analysis on the source code histories of two well-known and well-documented systems, JHotDraw and jEdit. We define and compute various metrics on the discovered topic evolutions and manually investigate how and why the metrics evolve over time. We find that the large majority (87%–89%) of topic evolutions correspond well with actual code change activities by developers. We are thus encouraged to use topic models as tools for studying the evolution of a software system.     

检测Linux下的VFS型内核后门软件

近年来在Linux操作系统中出现了入侵Linux内核VFS（虚拟文件系统）驱动程序的后门技术。使用该技术的后门软件能逃脱所有现有的后门检测技术,给Linux系统的安全带来了极大危害。通过分析该后门技术和Linux内核,设计实现了对该类后门软件的检测技术,其效果好于现有的后门检测软件。     

基于Linux的XFRM框架下IPSec VPN的研究

针对现有 IPSec VPN 系统在效率和可靠性方面存在的问题,提出并改进了一种基于Linux最新内核平台的 IPSec VPN网关系统。给出Linux 的XFRM 框架结构和函数调用结构的表述,其中包括XFRM框架模块与内核中IPSec进入外出处理的交互结合和VPN 网关安全隧道的构建,利用 XFRM 框架实现 IP 层处理和IPSec 处理。对新系统进行了仿真实现与性能评价,结果表明,它是可行和有效的。     

基于软件故障注入的嵌入式系统鲁棒性测试

以研究对嵌入式系统鲁棒性进行评价和基于软件故障注入技术的嵌入式系统鲁棒性测试为目的。对嵌入式系统鲁棒性测试的相关概念以及软件故障注入技术原理进行了介绍,以Linux操作系统内核函数测试为例,通过对系统API参数的故障注入接口进行分析,提出基于GDB工具的软件故障注入方法来实现系统鲁棒性故障注入测试。完成了相应的Linux操作系统API接口故障注入测试实例并给出了测试结果。为嵌入式系统鲁棒性测试提供了更为直观、有效的方法。     

Self-organization process in open-source software: An empirical study

Software systems must continually evolve to adapt to new functional requirements or quality requirements to remain competitive in the marketplace. However, different software systems follow different strategies to evolve, affecting both the release plan and the quality of these systems. In this paper, software evolution is considered as a self-organization process and the difference between closed-source software and open-source software is discussed in terms of self-organization. In particular, an empirical study of the evolution of Linux from version 2.4.0 to version 2.6.13 is reported. The study shows how open-source software systems self-organize to adapt to functional requirements and quality requirements.     

Facilitating the evolution of products in product line engineering by capturing and replaying configuration decisions

Software product lines rely on developing reusable artifacts and defining their variability in models to support and accelerate the derivation of individual products. A major challenge in product lines is the continuous evolution of both the reusable artifacts and derived products. Products that have been derived from a product line have to be updated regularly, e.g., after bugfixes or the development of new features. Changes to reusable artifacts and variability models have to be propagated to derived products. The aim of our research is to provide automated support for the evolution of products derived from product lines by capturing and replaying configuration decisions. Our PUPLE (Product Updates in Product Line Engineering) approach supports updating derived products after changes to the product line they have been derived from. It exploits the structure of variability models and uses change-tracking data to minimize user intervention. The paper first explores how different types of product line changes influence the derived products. It then presents extensions to our decision-oriented product line approach DOPLER to support product line evolution. We evaluate the feasibility of the PUPLE approach with evolution tasks that were performed by engineers of an industry partner on a product line of an Eclipse-based tool suite with six derived products. We conclude with lessons learned and limitations of our approach.     

Continuously mining distributed version control systems: an empirical study of how Linux uses Git

Distributed version control systems (D-VCSs —such as git and mercurial) and their hosting services (such as Github and Bitbucket) have revolutionalized the way in which developers collaborate by allowing them to freely exchange and integrate code changes in a peer-to-peer fashion. However, this flexibility comes at a price: code changes are hard to track because of the proliferation of code repositories and because developers modify (“rebase”) and filter (“cherry-pick”) the history of these changes to streamline their integration into the repositories of other developers. As a consequence, researchers and practitioners, who typically only consider the (cleaned up) history in the official project repository, are unaware of important elements and activities in the collaborative software development process. In this paper, we present a method that continuously mines all known D-VCSs of a software project to uncover the complete development history of a project. We use this method to (1) show the divergence between the code history development in the official Linux kernel repository and the complete kernel development history, and (2) to investigate the characteristics of the ecosystem of git repositories of the Linux kernel. Finally, we discuss how continuous mining could be adopted by current D-VCS hosting services.