Wireless multihop networks (WMHNs) have to strike a trade-off among diverse and often conflicting quality-of-service requirements. The resultant solutions may be included by the Pareto front under the concept of Pareto optimality. However, the problem of finding all the Pareto-optimal routes in WMHNs is classified as non-deterministic polynomial-hard, since the number of legitimate routes increases exponentially, as the nodes proliferate. Quantum computing offers an attractive framework of rendering the Pareto-optimal routing problem tractable. In this context, a pair of quantum-assisted algorithms has been proposed, namely the non-dominated quantum optimization and the non-dominated quantum iterative optimization. However, their complexity is proportional to √N, where N corresponds to the total number of legitimate routes, thus still failing to find the solutions in “polynomial time.” As a remedy, we devise a dynamic programming framework and propose the so-called evolutionary quantum pareto optimization (EQPO) algorithm. We analytically characterize the complexity imposed by the EQPO algorithm and demonstrate that it succeeds in solving the Pareto-optimal routing problem in polynomial time. Finally, we demonstrate by simulations that the EQPO algorithm achieves a complexity reduction, which is at least an order of magnitude when compared to its predecessors, albeit at the cost of a modest heuristic accuracy reduction.

An ideal visible light communication (VLC) system should facilitate reliable data transmission at high throughputs, while also providing flicker-free illumination at the user-defined dimming level. In this spirit, we conceive a unary code aided dimming scheme for ON-OFF keying (OOK) modulated VLC systems. The proposed unary-coded scheme facilitates joint dimming and throughput control, while relying on iterative decoding. It is demonstrated that the proposed unary-coded dimming scheme provides attractive throughput gains over its contemporaries and it is also capable of approaching the theoretical throughput limit. Furthermore, we design novel joint dimming-forward error correction coding schemes, which significantly outperform their compensation time dimming-based counterparts in terms of the attainable bit error rate performance as well as the throughput. Finally, in the quest for approaching the capacity, we also optimize our system using EXTRINSIC information transfer charts and demonstrate an SNR-gain of upto 6 dB over the compensation time dimming-based classic benchmarker.

After changes are made to a system, developers typically perform regression testing to uncover the regression faults in previously existing functionality of the system. However, during software evolution, the program entities (i.e., classes/methods) realizing such functionality might be modified/replaced by other entities. Thus, in the new version, existing test cases containing obsolete class references or method calls might be broken or might not test the intended functionality. To repair the broken method calls in those test cases, for each obsolete class/method, a tester needs to find the corresponding entity that provides the same/similar function or has the same role in the new version. To automate that task, we present ITRACK, a novel tool for matching program entities across versions, which mainly relies on their interactions in the code. The key idea is that the role and functionality of an entity correlate with its interactions with other entities (e.g., how it uses or is used by others). Two entities in two versions are matched based on the similarity of their interactions with other entities in the respective versions via our novel iterative matching algorithm. Our empirical evaluation shows that ITRACK achieves from 84-99% accuracy in identifying the calls in previous test cases that need to be adapted in accordance with the replacements of entities and provide such matching to support repairing broken method calls.

An uplink transmission for Adaptive Dynamic Network Coding(ADNC) assisted Cooperative Cognitive Radio(CCR) system is proposed for facilitating the recovery of the source information received from the Primary Users (PUs) at the BS. The Cognitive Users (CUs) acting as Relay Nodes invoke the ADNC technique, where the CCR- based control information is exchanged between the CUs and the BS. % The network encoder may be activated in its adaptive mode for the sake of supporting the CUs, depending on the Boolean value of the feedback flags generated by the receiver based on the success/failure of the Adaptive Turbo Trellis Coded Modulation (ATTCM) channel decoder and of the network decoder. As a result, our novel ATTCM-ADNC-CCR system constructed based on a holistic approach is capable of providing an increased throughput, despite reducing the transmission-period of the PU. This reduced transmission-period can also be directly translated into an increased time-duration for the secondary communications of the CUs.

Configurable software systems enable developers to configure at compile time a single variant of the system to tailor it towards specific environments and features. Although traditional static analysis tools can assist developers in software development and maintenance, they can only run on a concrete configuration of a configurable software system. Thus, it is necessary to derive many configurations so that the configuration-specific parts of the source code can be checked. To avoid this tedious and error-prone process, we propose an approach to automatically derive a set of configurations that cover as many combinations of configuration-specific blocks of code or source files as possible. We represent a C program with CPP directives (e.g., #ifdef) with a CPP control-flow graph (CPP-CFG) in which CPP expressions are condition nodes and #ifdef blocks are statement nodes. We then explore possible paths on CPP-CFG with dynamic symbolic execution and depth-first search algorithms, and correspondingly, producing possible combinations of concrete blocks of C code, on which an existing static analysis tool can run. Our preliminary evaluation on a benchmark of configuration-dependent bugs on Linux shows that our approach can detect more bugs than a state-of-the-art tool.

In software development, IDE services are used to assist developers in programming tasks. In dynamic web applications, however, since the client-side code is embedded in the server-side program as string literals, providing IDE services for such embedded code is challenging. We introduce Varis, a tool that provides services on the embedded client-side code. We perform symbolic execution on a PHP program to approximate its output and parse it into a VarDOM that compactly represents all its DOM variations. Using the VarDOM, we implement various types of IDE services for embedded client code including syntax highlighting, code completion, and 'find declaration'.

During software maintenance, program slicing is a useful technique to assist developers in understanding the impact of their changes. While different program-slicing techniques have been proposed for traditional software systems, program slicing for dynamic web applications is challenging since the client-side code is generated from the server-side code and data entities are referenced across different languages and are often embedded in string literals in the server-side program. To address those challenges, we introduce WebSlice, an approach to compute program slices across different languages for web applications. We first identify data-flow dependencies among data entities for PHP code based on symbolic execution. We also compute SQL queries and a conditional DOM that represents client-code variations and construct the data flows for embedded languages: SQL, HTML, and JavaScript. Next, we connect the data flows across different languages and across PHP pages. Finally, we compute a program slice for a given entity based on the established data flows. Running WebSlice on five real-world, open-source PHP systems, we found that, out of 40,670 program slices, 10% cross languages, 38% cross files, and 13% cross string fragments, demonstrating the potential benefit of tool support for cross-language program slicing in dynamic web applications.

In collaborative software development, changes made in parallel by multiple developers may conflict. Previous research has shown that conflicts are common and occur as textual conflicts or semantic conflicts, which manifest as build or test failures. With many parallel changes, it is desirable to identify conflicts early and pinpoint the (minimum) set of changes involved. However, the costs of identifying semantic conflicts can be high because tests need to be executed on many merge scenarios. We propose Semex, a novel approach to detect semantic conflicts using variability-aware execution. We encode all parallel changes into a single program, in which "if" statements guard the alternative code fragments. Then, we run the test cases using variability-aware execution, exploring all possible concrete executions of the combined program with regard to all possible merge scenarios, while exploiting similarities among the executions to speed up the process. Variability-aware execution returns a formula describing all failing merge scenarios. In our preliminary experimental study on seven PHP programs with a total of 50 test cases and 19 semantic conflicts, Semex correctly detected all 19 conflicts.

In plugin-based systems, plugin conflicts may occur when two or more plugins interfere with one another, changing their expected behaviors. It is highly challenging to detect plugin conflicts due to the exponential explosion of the combinations of plugins (i.e., configurations). In this paper, we address the challenge of executing a test case over many configurations. Leveraging the fact that many executions of a test are similar, our variability-aware execution runs common code once. Only when encountering values that are different depending on specific configurations will the execution split to run for each of them. To evaluate the scalability of variability-aware execution on a large real-world setting, we built a prototype PHP interpreter called Varex and ran it on the popular WordPress blogging Web application. The results show that while plugin interactions exist, there is a significant amount of sharing that allows variability-aware execution to scale to 2^50 configurations within seven minutes of running time. During our study, with Varex, we were able to detect two plugin conflicts: one was recently reported on WordPress forum and another one was not previously discovered.

A frequently occurring usage of program elements in a programming language and software libraries is called a usage pattern. In JavaScript (JS) Web applications, JS usage patterns in their source code have special characteristics that pose challenges in pattern mining. They involve nested data objects with no corresponding names or types. JS functions can be also used as data objects. JS usages are often cross-language, inter-procedural, and involve control and data flow dependencies among JS program entities and data objects whose data types are revealed only at run time due to dynamic typing in JS. This paper presents JSModel, a novel graph-based representation for JS usages, and JSMiner, a scalable approach to mine inter-procedural, data-oriented JS usage patterns. Our empirical evaluation on several Web programs shows that JSMiner efficiently detects more JS patterns with higher accuracy than a state-of-the-art approach. We conducted experiments to show JSModel's usefulness in two applications: detecting anti-patterns (buggy patterns) and documenting JS APIs via pattern skeletons. Our controlled experiment shows that the mined patterns are useful as JS documentation and code templates.

In large-scale software projects, build code has a high level of complexity, churn rate, and defect proneness. While it is desirable to have automated tools to help developers in localizing faults in build code, it is challenging to build such tools due to the dynamic nature of build code. Existing automatic fault localization methods focus on traditional code and none of them has such support for build code. This paper introduces MkFault, a novel automatic tool/method to localize faults in build code that cause run-time build failures. Given a test case that causes a run-time crash in the execution of a Make file, it returns a ranked list of statements in the Make file with their suspiciousness scores. MkFault records the evaluation traces from Make code to identify the corresponding concrete build rules and the execution traces of those rules. It then uses those traces and its novel Bayesian-like rating algorithm to give suspiciousness scores to the original statements in the Make file. Our empirical evaluation on real faults in several open-source projects has shown that MkFault can achieve high accuracy and help reduce a large percentage of the lines of code that developers need to examine.

When developing and maintaining a software system, programmers often rely on IDEs to provide editor services such as syntax highlighting, auto-completion, and "jump to declaration". In dynamic web applications, such tool support is currently limited to either the server-side code or to hand-written or generated client-side code. Our goal is to build a call graph for providing editor services on client-side code while it is still embedded as string literals within server-side code. First, we symbolically execute the server-side code to identify all possible client-side code variations. Subsequently, we parse the generated client-side code with all its variations into a VarDOM that compactly represents all DOM variations for further analysis. Based on the VarDOM, we build conditional call graphs for embedded HTML, CSS, and JS. Our empirical evaluation on real-world web applications show that our analysis achieves 100% precision in identifying call-graph edges. 62% of the edges cross PHP strings, and 17% of them cross files - in both situations, navigation without tool support is tedious and error prone.

Most of the nodes in ad hoc networks rely on batteries, which requires energy saving. Hence, numerous energy-efficient routing algorithms have been proposed for solving this problem. In this paper, we exploit the benefits of cross-layer information exchange, such as the knowledge of the Frame Error Rate (FER) in the physical layer, the maximum number of retransmissions in the Medium Access Control (MAC) layer and the number of relays in the network layer. Energy-consumption-based Objective Functions (OF) are invoked for calculating the end-to-end energy consumption of each potentially available route for both Traditional Routing (TR) and for our novel Opportunistic Routing (OR), respectively. We also improve the TR and the OR with the aid of efficient Power Allocation (PA) for further reducing the energy consumption. For the TR, we take into account the dependencies amongst the links of a multi-hop route, which facilitates a more accurate performance evaluation than upon assuming the links that are independent. Moreover, two energy-efficient routing algorithms are designed based on Dijkstra's algorithm. The algorithms based on the energy OF provide the theoretical bounds, which are shown to be close to the bound found from exhaustive search, despite the significantly reduced complexity of the former. Finally, the end-to-end throughput and the end-to-end delay of this system are analyzed theoretically and a new technique of characterizing the delay distribution of OR is proposed. The simulation results show that our energy-efficient OR outperforms the TR and that their theoretical analysis accurately matches the simulation results.

PHP is a server-side language that is widely used for creating dynamic Web applications. However, as a dynamic language, PHP may induce certain programming errors that reveal themselves only at run time. A common type of error is dangling references, which occur if the referred program entities have not been declared in the current program execution. To prevent the run-time errors caused by such dangling references, we introduce Dangling Reference Checker (DRC), a novel tool to statically detect those references in the source code of PHP-based Web applications. DRC first identifies the path constraints of the program executions in which a program entity appears and then matches the path constraints of the entity's declarations and references to detect dangling ones. DRC is able to detect dangling reference errors in several real-world PHP systems with high accuracy. The video demonstration for DRC is available at http://www.youtube.com/watch?v=3Dy_AKZYhLlU4.

Refactoring is crucial in the development process of traditional programs as well as advanced Web applications. In a dynamic Web application, multiple versions of client code in HTML and JavaScript are dynamically generated from server-side code at run time for different usage scenarios. Toward understanding refactoring for dynamic Web code, we conducted an empirical study on several PHP-based Web applications. We found that Web developers perform a new type of refactoring that is specific to PHP-based dynamic Web code and pertain to output client-side code. After such a refactoring, the server-side code is more compact and modular with less amount of embedded and inline client-side HTML/JS code, or produces more standard-conforming client-side code. However, the corresponding output client-side code of the server code before and after the refactoring provides the same external behavior. We call it output-oriented refactoring. Our finding in the study motivates us to build WebDyn, an automatic tool for dynamicalizing refactorings. When performing on a portion of server-side code (which might contain both PHP and embedded/inline HTML/JS code), WebDyn detects the repeated and varied parts in that code portion and produces dynamic PHP code that creates the same client-side code. Our empirical evaluation on several projects showed WebDyn's accuracy in such automated refactorings.

Localizing and fixing software faults is an important maintenance task. In a dynamic Web application, localizing the faults is challenging due to its dynamic nature and the interactions between the application and databases. The faults could occur in the statements in the host program or inside the queries that are sent from the application to be executed in the database engines. This paper presents SQLook, a novel database- aware fault localization method that is able to locate output faults in PHP statements of a dynamic Web application as well as in SQL queries. In SQLook, a PHP interpreter is instrumented to execute an SQL query and to monitor the evaluation of those SQL predicates to determine if they affect the output process of individual data records. It performs row-based slicing across PHP statements and SQL queries to record the entities that are involved in the output of each data row. Our empirical evaluation shows that SQLook can achieve higher accuracy than the state- of-the-art database-aware fault localization approach.

PHP is a dynamic language popularly used in Web development for writing server-side code to dynamically create multiple versions of client-side pages at run time for different configurations. A PHP program contains code to be executed or produced for multiple configurations/versions. That dynamism and multi-configuration nature leads to dangling references. Specifically, in the execution for a configuration, a reference to a variable or a call to a function is dangling if its corresponding declaration cannot be found. We conducted an exploratory study to confirm the existence of such dangling reference errors including dangling cross-language and embedded references in the client-side HTML/JavaScript code and in data-accessing SQL code that are embedded in scattered PHP code. Dangling references have caused run-time fatal failures and security vulnerabilities. We developed DRC, a static analysis method to detect such dangling references. DRC uses symbolic execution to collect PHP declarations/references and to approximate all versions of the generated output, and then extracts embedded declarations/references. It associates each detected declaration/reference with a conditional constraint that represents the execution paths (i.e. configurations/versions) containing that declaration/reference. It then validates references against declarations via a novel dangling reference detection algorithm. Our empirical evaluation shows that DRC detects dangling references with high accuracy. It revealed 83 yet undiscovered defects caused by dangling references.

Near-Capacity Multi-user Network-coding (NCMN) based systems operating in multiple modes and relying on an amalgamated Irregular Convolutional Code, a Unity-Rate Code and M-ary Phase-Shift Keying are proposed. We consider a multiuser network in which the users cooperatively transmit their independent information to a common base station (BS). Extrinsic Information Transfer (EXIT) charts were used for designing the proposed NCMN scheme for the sake of approaching the Discrete-input Continuous-output Memoryless Channel's (DCMC) capacity. The NCMN systems are capable of simultaneously exploiting the advantages of all the new modes we designed for our system and those of the conventional mode. The design principles presented in this contribution can be extended to a vast range of NCMN based systems using arbitrary channel coding schemes.

In a dynamic web application, client-side code is often dynamically generated from server-side code. Client-side program entities such as HTML presentation elements and Javascript functions/variables are embedded within server-side string literals or variables' values. However, existing tools for code maintenance such as automatic renaming support only work for program entities in a single language on either the server side or the client side. In this paper, we introduce BabelRef, a novel tool that is able to automatically identify and rename client-side program entities and their references that are embedded within server-side code.

Code completion helps improve developers' programming productivity. However, the current support for code completion is limited to context-free code templates or a single method call of the variable on focus. Using software libraries for development, developers often repeat API usages for certain tasks. Thus, a code completion tool could make use of API usage patterns. In this paper, we introduce GraPacc, a graph-based, pattern-oriented, context-sensitive code completion approach that is based on a database of such patterns. GraPacc represents and manages the API usage patterns of multiple variables, methods, and control structures via graph-based models. It extracts the context-sensitive features from the code under editing, e.g. the API elements on focus and their relations to other code elements. Those features are used to search and rank the patterns that are most fitted with the current code. When a pattern is selected, the current code will be completed via a novel graph-based code completion algorithm. Empirical evaluation on several real-world systems shows that GraPacc has a high level of accuracy in code completion.

Build process is crucial in software development. However, the analysis support for build code is still limited. In this paper, we present SYMake, an infrastructure and tool for the analysis of build code in make. Due to the dynamic nature of make language, it is challenging to understand and maintain complex Makefiles. SYMake provides a symbolic evaluation algorithm that processes Makefiles and produces a symbolic dependency graph (SDG), which represents the build dependencies (i.e. rules) among files via commands. During the symbolic evaluation, for each resulting string value in an SDG that represents a part of a file name or a command in a rule, SYMake provides also an acyclic graph (called T-model) to represent its symbolic evaluation trace. We have used SYMake to develop algorithms and a tool 1) to detect several types of code smells and errors in Makefiles, and 2) to support build code refactoring, e.g. renaming a variable/target even if its name is fragmented and built from multiple substrings. Our empirical evaluation for SYMake's renaming on several real-world systems showed its high accuracy in entity renaming. Our controlled experiment showed that with SYMake, developers were able to understand Makefiles better and to detect more code smells as well as to perform refactoring more accurately.

Build code in a Makefile represents the build rules with the dependencies among the files, and how they must be built together to produce a software system. As software evolves, its build code evolves as well to accommodate necessary changes in the build process. As part of software maintenance, it is crucial to understand how the build code is changed (e.g. changes in build rules or dependencies), and to verify and validate the correctness of the build process with different build configurations. Due to Make's dynamic nature, understanding and managing the changes to Makefiles is not trivial. In this paper, we introduce a set of semantic changes to build code in Makefiles. We also develop MkDiff, a tool to detect the changes to a Makefile at the semantic level. MkDiff uses symbolic dependency graphs (SDG) to find all possible concrete rules from a Makefile, and the dependencies among them. For two SDGs built from a Makefile at two versions, it first detects changed and unchanged nodes via its SDG matching algorithm. Then, from those results, it derives the semantic changes to the Makefile. Our empirical evaluation for MkDiff showed that it can accurately detect semantic changes in Makefiles.

In dynamic Web applications, there often exists a type of code smells, called embedded code smells, that violate important principles in software development such as software modularity and separation of concerns, resulting in much maintenance effort. Detecting and fixing those code smells is crucial yet challenging since the code with smells is embedded and generated from the server-side code.

Software building is an important task during software development. However, program analysis support for build code is still limited, especially for build code written in a dynamic language such as Make. We introduce SYMake, a novel program analysis and refactoring tool for build code in Makefiles. SYMake is capable of detecting several types of code smells and errors such as cyclic dependencies, rule inclusion, duplicate prerequisites, recursive variable loops, etc. It also supports automatic build code refactoring, e.g. rule extraction/removal, target creation, target/variable renaming, prerequisite extraction, etc. In addition, SYMake provides the analysis on defined rules, targets, prerequisites, and associated information to help developers better understand build code in a Makefile and its included files.

Near-capacity Non-coherent Cooperative Network-coding aided Multi-user (NNCNM) systems are designed with the aid of Extrinsic Information Transfer (EXIT) charts for the sake of approaching the Differential Discrete-input Continuous-output Memoryless Channel's (D-DCMC) system capacity1. The upper and lower Frame Error Ratio (FER) performance bounds are derived for aiding our network coding design. The outage capacity of the D-DCMC channel is also calculated and used for computing the best-case performance bounds of both the corresponding single-link scheme and of the proposed NNCNM system. Moreover, a new technique referred to as the Pragmatic Algebraic Linear Equation Method (PALEM) was proposed for determining the exact number of information sources that may be recovered from the composite NNCNM stream, which constitutes a lower-complexity evaluation of the attainable FER performance of the NNCNM systems without resorting to high-complexity Monte-Carlo simulations. The NNCNM systems advocated are capable of operating within 0.3-0.5 dB from the corresponding D-DCMC capacity. A joint treatment of channel and network coding is considered in our system2. The design principles presented in this contribution may be extended to a vast range of NNCNM based systems using arbitrary channel coding schemes.

Cross-cutting concerns are unavoidable and create difficulties in the development and maintenance of large-scale systems. In this paper, we present a novel approach that identifies certain groups of code units that potentially share some cross-cutting concerns and recommends them for creating and updating aspects. Those code units, called concern peers, are detected based on their similar interactions (similar calling relations in similar contexts, either internally or externally). The recommendation is applicable to both the aspectization of non-aspect-oriented programs (i.e. for aspect creation), and the evolution of aspect-oriented programs (i.e. for aspect updating). The empirical evaluation on several real-world software systems shows that our approach is scalable and provides useful recommendations.

Locating buggy code is a time-consuming task in software development. Given a new bug report, developers must search through a large number of files in a project to locate buggy code. We propose BugScout, an automated approach to help developers reduce such efforts by narrowing the search space of buggy files when they are assigned to address a bug report. BugScout assumes that the textual contents of a bug report and that of its corresponding source code share some technical aspects of the system which can be used for locating buggy source files given a new bug report. We develop a specialized topic model that represents those technical aspects as topics in the textual contents of bug reports and source files, and correlates bug reports and corresponding buggy files via their shared topics. Our evaluation shows that BugScout can recommend buggy files correctly up to 45% of the cases with a recommended ranked list of 10 files.

Checking/correcting HTML validation errors in Web pages is helpful for Web developers in finding/fixing bugs. However, existing validating/fixing tools work well only on static HTML pages and do not help fix the corresponding server code if validation errors are found in HTML pages, due to several challenges with dynamically generated pages in Web development. We propose PhpSync, a novel automatic locating/fixing tool for HTML validation errors in PHP-based Web applications. Given an HTML page produced by a server-side PHP program, PhpSync uses Tidy, an HTML validating/correcting tool to find the validation errors in that HTML page. If errors are detected, it leverages the fixes from Tidy in the given HTML page and propagates them to the corresponding location(s) in PHP code. Our core solutions include 1) a symbolic execution algorithm on the given PHP program to produce a single tree-based model, called D-model, which approximately represents its possible client page outputs, 2) an algorithm mapping any text in the given HTML page to the text(s) in the node(s) of the D-model and then to the PHP code, and 3) a fix-propagating algorithm from the fixes in the HTML page to the PHP code via the D-model and the mapping algorithm. Our empirical evaluation shows that on average, PhpSync achieves 96.7% accuracy in locating the corresponding locations in PHP code from client pages, and 95% accuracy in propagating the fixes to the server-side code.

When a software system evolves, its program entities such as classes/methods are also changed. System comprehension, maintenance, and other tasks require the detection of the changed entities between two versions. However, existing differencing tools are file-based and cannot handle well the common cases in which the methods/classes are reordered/moved or even renamed/modified. Moreover, many tools show the program changes at the text line level. In this demo, we present iDiff, a program differencing tool that is able to display the changes to classes/methods between two versions and to track the corresponding classes/methods even they were reordered/moved/renamed and/or modified. The key idea is that during software evolution, an entity could change its location, name, order, and even its internal implementation. However, its interaction with other entities would be more stable. iDiff represents a system at a version as an attributed graph, in which the nodes represent program entities, the edges represent the interactions between the nodes. Entities between two versions are matched via an incremental matching algorithm, which takes into account the similarity of interactions for matching. The differences of two versions of the entire system including its program entities are detected based on the matched entities.

In this contribution, we investigate Near-Capacity Multi-user Network-coding (NCMN) based systems using an Irregular Convolutional Code, a Unity-Rate Code and M-ary Phase-Shift Keying. In the NCMN based systems, we consider a multiuser network in which the users cooperatively transmit independent information to a common base station (BS). Extrinsic Information Transfer (EXIT) charts were used for designing the proposed NCMN scheme. The design principles presented in this contribution can be extended to a vast range of NCMN based systems using arbitrary channel coding schemes.

In this contribution, Near-capacity Non-coherent Cooperative Network-coding aided Multi-user (NNCNM) systems are designed with the aid of Extrinsic Information Transfer (EXIT) charts for the sake of approaching the Differential Discrete-input Continuous-output Memoryless Channel (D-DCMC)-based capacity. The proposed sub-frame-based network coding solution allows the system to significantly mitigate the effects of large-scale fading on each frame. Hence, NNCNM systems operating in large-scale fading environments are capable of approaching the D-DCMC capacity of the less hostile single link channel incurring the small-scale fading, but no shadow fading.

The nodes of ad hoc networks are typically battery-powered, hence requiring the employment of energy-efficient schemes. Near-capacity coding schemes allow a single link to communicate using the lowest possible transmit power, while achieving a low Frame Error Ratio (FER). With the same motivation of conserving battery energy, numerous power-aware routing algorithms have been proposed for improving the overall multiuser network's energy-efficiency instead of improving a single link. Taking both these design factors into consideration, we employ Multi-Antenna aided Relays (MA-Rs) in the context of ad hoc networks, which use a three-stage concatenated transceiver constituted by an Irregular Convolutional Code, Unity-Rate Code and Space-Time Trellis Code (IrCC-URC-STTC) equipped with two antennas. All other mobiles are single-antenna assisted nodes and refrain from relaying, hence they dispense with STTC schemes and use a two-stage concatenated IrCC-URC coding scheme. It is confirmed that as expected, in a high-node-density scenario the average energy consumption per information bit and per node becomes about a factor two lower than that in the equivalent Single-Antenna Relay (SA-R) aided networks.

In this contribution, we derive the upper and lower Frame Error Ratio (FER) performance bounds of cooperative multiuser communications systems using network coding. Our Monte Carlo simulation based results confirm the accuracy of our derivation.

In this contribution, we propose a Distributed Concatenated Irregular Convolutional Coded Unity Rate Coded and Space Time Trellis Coded (DC-IrCC-URC-STTC) scheme for cooperative communications employing multiple single-antenna relays. Each coding arrangement is designed for efficient decoding convergence by employing non-binary Extrinsic Information Transfer (EXIT) charts. The source node transmits two-stage IrCC-URC encoded symbols to two relays during the first transmission period. Then each relay performs two-stage URC-IrCC decoding and re-encodes the information bits using the three-stage concatenated coding scheme IrCC-URC-STTC. However, only the signals of one predefined STTC output are transmitted from each relay to the destination node during the second transmission period. At the destination, the received signals are treated as if they arrived from one transmitter employing STTC using two co-located transmit antennas. The simulation results show that the Monte-Carlo based performance of the DC-IrCC-URC-STTC scheme exactly matches the EXIT-chart analysis. It also performs closely to its idealised counterpart that assumes perfect decoding at the relays when an EXIT-chart based optimal algorithm is applied for selecting relays.