Rajib Mall

Load balanced routing in mobile ad hoc networks

We present a new protocol called Load Aware Routing in Ad hoc (LARA) networks protocol for efficient data transmission in mobile ad hoc networks. We also define a new metric for routing called traffic density to represent the degree of contention at the medium access control layer. During the route setup, this metric is used to select the route with the minimum traffic load. We have carried out extensive simulation studies to evaluate the performance of our proposed protocol vis-a-vis the existing protocols. Performance results show that our LARA protocol outperforms existing routing protocols in terms of end-to-end delay, throughput, packet delivery fraction, and battery power consumption at the nodes.

Quality of Service (QoS) Provisions in Wireless Sensor Networks and Related Challenges

Wireless sensor networks (WSNs) are required to provide different levels of Quality of Services (QoS) based on the type of applications. Providing QoS support in wireless sensor networks is an emerging area of research. Due to resource constraints like processing power, memory, bandwidth and power sources in sensor networks, QoS support in WSNs is a challenging task. In this paper, we discuss the QoS requirements in WSNs and present a survey of some of the QoS aware routing techniques in WSNs. We also explore the middleware approaches for QoS support in WSNs and finally, highlight some open issues and future direction of research for providing QoS in WSNs.

Application of elitist multi-objective genetic algorithm for classification rule generation

We present an elitist multi-objective genetic algorithm (EMOGA) for mining classification rules from large databases. We emphasize on predictive accuracy, comprehensibility and interestingness of the rules. However, predictive accuracy, comprehensibility and interestingness of the rules often conflict with each other. This makes it a multi-objective optimization problem that is very difficult to solve efficiently. We have proposed a multi-objective genetic algorithm with a hybrid crossover operator for optimizing these objectives simultaneously. We have compared our rule discovery procedure with simple genetic algorithm with a weighted sum of all these objectives. The experimental result confirms that our rule discovery algorithm has a clear edge over simple genetic algorithm.

Predictive and comprehensible rule discovery using a multi-objective genetic algorithm

We present a multi-objective genetic algorithm for mining highly predictive and comprehensible classification rules from large databases. We emphasize predictive accuracy and comprehensibility of the rules. However, accuracy and comprehensibility of the rules often conflict with each other. This makes it an optimization problem that is very difficult to solve efficiently. We have proposed a multi-objective evolutionary algorithm called improved niched Pareto genetic algorithm (INPGA) for this purpose. We have compared the rule generation by INPGA with that by simple genetic algorithm (SGA) and basic niched Pareto genetic algorithm (NPGA). The experimental result confirms that our rule generation has a clear edge over SGA and NPGA.

Automatic test case generation using unified modeling language (UML) state diagrams

UML is widely accepted and used by industry for modelling and design of software systems. A novel method to automatically generate test cases based on UML state models is presented. In the present approach, the control and data flow logic available in the UML state diagram to generate test data are exploited. The state machine graph is traversed and the conditional predicates on every transition are selected. Then these conditional predicates are transformed and function minimisation technique is applied to generate test cases. The present test data generation scheme is fully automatic and the generated test cases satisfy transition path coverage criteria. The generated test cases can be used to test class as well as cluster-level state-dependent behaviours.

An efficient dynamic program slicing technique

Abstract An important application of the dynamic program slicing technique is program debugging. In applications such as interactive debugging, the dynamic slicing algorithm needs to be efficient. In this context, we propose a new dynamic program slicing technique that is more efficient than the related algorithms reported in the literature. We use the program dependence graph as an intermediate program representation, and modify it by introducing the concepts of stable and unstable edges . Our algorithm is based on marking and unmarking the unstable edges as and when the dependences arise and cease during run-time. We call this algorithm edge-marking algorithm . After an execution of a node x , an unstable edge ( x , y ) is marked if the node x uses the value of the variable defined at node y . A marked unstable edge ( x , y ) is unmarked after an execution of a node z if the nodes y and z define the same variable var , and the value of var computed at the node y does not affect the present value of var defined at the node z . We show that our algorithm is more time and space efficient than the existing ones. The worst case space complexity of our algorithm is O ( n 2 ), where n is the number of statements in the program. We also briefly discuss an implementation of our algorithm.

Automatic test case generation from UML communication diagrams

We present a method to generate cluster level test cases based on UML communication diagrams. In our approach, we first construct a tree representation of communication diagrams. We then carry out a post-order traversal of the constructed tree for selecting conditional predicates from the communication diagram. We transform the conditional predicates on the communication diagram and apply function minimization technique to generate the test data. The generated test cases achieve message paths coverage as well as boundary coverage. We have implemented our technique and tested it on several example problems.

An efficient interprocedural dynamic slicing method

We present an efficient interprocedural dynamic slicing algorithm for structured programs. We first propose an intraprocedural dynamic slicing algorithm, and subsequently extend it to handle interprocedural calls. Our intraprocedural dynamic slicing algorithm uses control dependence graph as the intermediate program representation, and computes precise dynamic slices. The interprocedural dynamic slicing algorithm uses a collection of control dependence graphs (one for each procedure) as the intermediate program representation, and computes precise dynamic slices. We show that our proposed interprocedural dynamic slicing algorithm is more efficient than the existing dynamic slicing algorithms. We also discuss how our algorithm can be extended to efficiently handle recursion, composite data structures and pointers.

Computation of intraprocedural dynamic program slices

Abstract Dynamic slicing algorithms are used in interactive applications such as program debugging and testing. Therefore, these algorithms need to be very efficient. In this context, we propose three intraprocedural dynamic slicing algorithms which are more space and time efficient than the existing algorithms. Two of the proposed algorithms compute precise dynamic slices of structured programs using Program Dependence Graph as an intermediate representation. To compute precise dynamic slices of unstructured programs, we introduce the concepts of jump dependence and Unstructured Program Dependence Graph. The third algorithm uses Unstructured Program Dependence Graph as the intermediate program representation, and computes precise dynamic slices of unstructured programs. We show that each of our proposed algorithms is more space and time efficient than the existing algorithms.

Slicing-based test case generation from UML activity diagrams

UML diagrams are important design and modeling artifacts. These diagrams can also be used to generate test cases. We present a novel test case generation method that is based on dynamic slicing of UML activity diagrams. We use flow dependence graph (FDG) of an activity diagram to generate dynamic slices. Dynamic slices are created using an edge marking method. Slices are constructed corresponding to each conditional predicate on activity edges and test cases are automatically generated with respect to each slice. Our generated test cases satisfy path coverage criterion. Our test data generation scheme is automatic and the test data is generated considering the slice condition. We have implemented our approach to realize a prototype tool.