Graph algorithms applied in many applications, including social networks, communication networks, VLSI design, graphics, and several others, require dynamic modifications -addition and removal of vertices and/or edges -in the graph. This paper presents a novel concurrent non-blocking algorithm to implement a dynamic unbounded directed graph in a shared-memory machine. The addition and removal operations of vertices and edges are lock-free. For a finite sized graph, the lookup operations are wait-free. Most significant component of the presented algorithm is the reachability query in a concurrent graph. The reachability queries in our algorithm are obstruction-free and thus impose minimal additional synchronization cost over other operations. We prove that each of the data structure operations are linearizable. We extensively evaluate a sample C/C++ implementation of the algorithm through a number of micro-benchmarks. The experimental results show that the proposed algorithm scales well with the number of threads and on an average provides 5 to 7x performance improvement over a concurrent graph implementation using coarse-grained locking.

Wireless Sensor networks (WSN) is a promising technology for current as well as future. There is vast use of WSN in different fields like military surveillance and target tracking, traffic management, weather forecasting, habitat monitoring, designing smart home, structural and seismic monitoring, etc. For success application of ubiquitous WSN it is important to maintain the basic security, both from external and internal attacks else entire network may collapse. Maintaining security in WSN network is not a simple job just like securing wireless networks because sensor nodes are deployed in randomize manner. Hence major challenges in WSNs are security. In this paper we have discussed different attacks in WSN and how these attacks were efficiently detected by using our agent based model. Our model identifies the abnormal event pattern sensor nodes in a largely deployed distributed sensor network under a common anomaly detection framework which will design by agent based learning and distributed data mining technique.

In this paper, we have developed two algorithms for maintaining acyclicity in a concurrent directed graph. The first algorithm is based on a wait-free reachability query and the second one is based on partial snapshot-based obstruction-free reachability query. Interestingly, we are able to achieve the acyclic property in the dynamic setting without the need of helping using descriptors by other threads or clean double collect mechanism. We present a proof to show that the graph remains acyclic at all times in the concurrent setting. We also prove that the acyclic graph data-structure operations are linearizable. We implement both the algorithms in C++ and test through a number of micro-benchmarks. Our experimental results show an average of 7x improvement over the sequential and global lock implementation.keywords: acyclic graph concurrent data structure linearizability lock-freedom.arXiv:1611.03947v6 [cs.DC] 12 May 20191. We describe an Abstract Data Type (ADT) that maintains an acyclic directed graph G = (V, E). It comprises of the following operations on the sets V and E: (1) Add Vertex:AcyAddV (2) Remove Vertex: AcyRemV, (3) Contains Vertex: AcyConV (4) Add Edge: AcyAddE (5) Remove Edge: AcyRemE and (6) Contains Edge: AcyConE. The ADT remains acyclic after completion of any of the above operations in G. The acyclic graph is represented as an adjacency list like in [4].2. We present an efficient concurrent non-blocking implementation of the ADT (Section 3). We present two approaches for maintaining acyclicity: the first one is based on a wait-free reachability query and the second one is based on obstruction-free reachability query similar to the GetPath operation of Chatterjee et al.[4] (Section 4).3. We prove the correctness by showing the operations of the concurrent acyclic graph datastructure are linearizable [10]. We also prove the non-blocking progress guarantee: (a) The operations AcyConV and AcyConE are wait-free, only if the vertex keys are finite; (b) Among the two algorithms for maintaining acyclicity, we show that the first algorithm based on searchability is wait-free, whereas the second algorithm based on reachability queries is obstruction-free and (c) The operations AcyAddV, AcyRemV, AcyConV, AcyAddE, AcyRemE, and AcyConE are lock-free. Section 5.4. We evaluated the non-blocking algorithms in C++ implementation and tested through a number of micro-benchmarks. Our experimental results depict on an average of 7x improvement over the sequential and global lock implementation (Section 6).

In this paper, we present an on-line fully dynamic algorithm for maintaining strongly connected component of a directed graph in a shared memory architecture. The edges and vertices are added or deleted concurrently by fixed number of threads. To the best of our knowledge, this is the first work to propose using linearizable concurrent directed graph and is build using both ordered and unordered list-based set. We provide an empirical comparison against sequential and coarse-grained. The results show our algorithm's throughput is increased between 3 to 6x depending on different workload distributions and applications. We believe that there are huge applications in the on-line graph. Finally, we show how the algorithm can be extended to community detection in on-line graph.

No abstract