Adding existing project files to repo

Articles/My Collection.ris

@@ -0,0 +1,791 @@
+TY  - ICOMM
+T1  - ParMETIS - Parallel Graph Partitioning and Fill-reducing Matrix Ordering | Karypis Lab
+UR  - http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview
+ER  - 
+TY  - ICOMM
+T1  - An Overview of the Parallel Boost Graph Library - 1.75.0
+UR  - https://www.boost.org/doc/libs/1_75_0/libs/graph_parallel/doc/html/overview.html
+ER  - 
+TY  - JOUR
+T1  - THE GRADUATE SCHOOL by Ahmet Burak Cengiz A thesis submitted in partial fulfillment of the requirements for the degree of Master of Science in Engineering in the Discipline of Petroleum Engineering The Graduate School The University of Tulsa
+Y1  - 2018///
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/Will_Nichols_Thesis_FINAL_VER.pdf
+ER  - 
+TY  - ICOMM
+T1  - The Boost Graph Library - 1.75.0
+UR  - https://www.boost.org/doc/libs/1_75_0/libs/graph/doc/index.html
+ER  - 
+TY  - ICOMM
+T1  - Parallel BGL Parallel Boost Graph Library - 1.75.0
+UR  - https://www.boost.org/doc/libs/1_75_0/libs/graph_parallel/doc/html/index.html
+ER  - 
+TY  - ICOMM
+T1  - Boost Graph Library: Converting Existing Graphs to BGL - 1.75.0
+UR  - https://www.boost.org/doc/libs/1_75_0/libs/graph/doc/leda_conversion.html
+ER  - 
+TY  - ICOMM
+T1  - Graph Partitioning | Our Pattern Language
+UR  - https://patterns.eecs.berkeley.edu/?page_id=571
+ER  - 
+TY  - JOUR
+T1  - Predictive Cyber Security Analytics Framework : A Non-Homogenous Markov Model for Security Quantification
+A1  - Abraham, Subil
+A1  - Nair, Suku
+Y1  - 2014///
+IS  - January
+SP  - 195
+EP  - 209
+DO  - 10.5121/csit.2014.41316
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Predictive_Cyber_Security_Analytics_Framework_A_No.pdf
+N2  - Numerous security metrics have been proposed in the past for protecting computer networks. However we still lack effective techniques to accurately measure the predictive security risk of an enterprise taking into account the dynamic attributes associated with vulnerabilities that can change over time. In this paper we present a stochastic security framework for obtaining quantitative measures of security using attack graphs. Our model is novel as existing research in attack graph analysis do not consider the temporal aspects associated with the vulnerabilities, such as the availability of exploits and patches which can affect the overall network security based on how the vulnerabilities are interconnected and leveraged to compromise the system. Gaining a better understanding of the relationship between vulnerabilities and their lifecycle events can provide security practitioners a better understanding of their state of security. In order to have a more realistic representation of how the security state of the network would vary over time, a nonhomogeneous model is developed which incorporates a time dependent covariate, namely the vulnerability age. The daily transition-probability matrices are estimated using Frei's Vulnerability Lifecycle model. We also leverage the trusted CVSS metric domain to analyze how the total exploitability and impact measures evolve over a time period for a given network.
+ER  - 
+TY  - JOUR
+T1  - Graph prefetching using data structure knowledge
+A1  - Ainsworth, Sam
+A1  - Jones, Timothy M.
+Y1  - 2016///
+KW  - Graphs
+KW  - Prefetching
+JF  - Proceedings of the International Conference on Supercomputing
+VL  - 01-03-June
+SN  - 9781450343619
+DO  - 10.1145/2925426.2926254
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Graph Prefetching Using Data Structure Knowledge.pdf
+N2  - Searches on large graphs are heavily memory latency bound, as a result of many high latency DRAM accesses. Due to the highly irregular nature of the access patterns involved, caches and prefetchers, both hardware and software, perform poorly on graph workloads. This leads to CPU stalling for the majority of the time. However, in many cases the data access pattern is well defined and predictable in advance, many falling into a small set of simple patterns. Although existing implicit prefetchers cannot bring significant benefit, a prefetcher armed with knowledge of the data structures and access patterns could accurately anticipate applications' traversals to bring in the appropriate data. This paper presents a design of an explicitly configured prefetcher to improve performance for breadth-first searches and sequential iteration on the efficient and commonly-used compressed sparse row graph format. By snooping L1 cache accesses from the core and reacting to data returned from its own prefetches, the prefetcher can schedule timely loads of data in advance of the application needing it. For a range of applications and graph sizes, our prefetcher achieves average speedups of 2.3×, and up to 3.3×, with little impact on memory bandwidth requirements.
+ER  - 
+TY  - JOUR
+T1  - A Graphical Model to Assess the Impact of Multi-Step Attacks
+A1  - Albanese, Massimiliano
+A1  - Jajodia, Sushil
+Y1  - 2018/01//
+JF  - The Journal of Defense Modeling and Simulation: Applications, Methodology, Technology
+VL  - 15
+IS  - 1
+SP  - 79
+EP  - 93
+DO  - 10.1177/1548512917706043
+UR  - http://journals.sagepub.com/doi/10.1177/1548512917706043
+N2  - In the last several decades, networked systems have grown in complexity and sophistication, introducing complex interdependencies amongst their numerous and diverse components. Attackers can leverage such interdependencies to penetrate seemingly well-guarded networks through sophisticated multi-step attacks. Research has shown that explicit and implicit interdependencies exist at various layers of the hardware and software architecture. In particular, dependencies between vulnerabilities and dependencies between applications and services are critical for assessing the impact of multi-step attacks. These two classes of interdependencies have been traditionally studied using attack and dependency graphs respectively. Although significant work has been done in the area of both attack and dependency graphs, we demonstrate that neither of these models can provide an accurate assessment of an attack’s impact, when used in isolation. To address this limitation, we take a mission-centric approach and present a solution to integrate these two powerful models into a unified framework that enables us to accurately assess the impact of multi-step attacks and identify high-impact attack paths within a network. This analysis can ultimately generate effective hardening recommendations, and can be seen as one phase of a continuous process that iteratively cycles through impact analysis and vulnerability remediation stages.
+ER  - 
+TY  - JOUR
+T1  - Combining data duplication and graph reordering to accelerate parallel graph processing
+A1  - Balaji, Vignesh
+A1  - Lucia, Brandon
+Y1  - 2019///
+KW  - Atomics
+KW  - Data duplication
+KW  - Graph processing
+KW  - Locality
+KW  - Power-law
+JF  - HPDC 2019- Proceedings of the 28th International Symposium on High-Performance Parallel and Distributed Computing
+IS  - Llc
+SP  - 133
+EP  - 144
+SN  - 9781450366700
+DO  - 10.1145/3307681.3326609
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Combining Data Duplication and Graph Reordering to Accelerate Parallel Graph Processing.pdf
+N2  - Performance of single-machine, shared memory graph processing is affected by expensive atomic updates and poor cache locality. Data duplication, a popular approach to eliminate atomic updates by creating thread-local copies of shared data, incurs extreme memory overheads due to the large sizes of typical input graphs. Even memory-efficient duplication strategies that exploit the power-law structure common to many graphs (by duplicating only the highly-connected "hub" vertices) suffer from overheads for having to dynamically identify the hub vertices. Degree Sorting, a popular graph reordering technique that re-assigns hub vertices consecutive IDs in a bid to improve spatial locality, is effective for single-threaded graph applications but suffers from increased false sharing in parallel executions. The main insight of this work is that the combination of data duplication and Degree Sorting eliminates the overheads of each optimization. Degree Sorting improves the efficiency of data duplication by assigning hub vertices consecutive IDs which enables easy identification of the hub vertices. Additionally, duplicating the hub vertex data eliminates false sharing in Degree Sorting since each thread updates its local copy of the hub vertex data. We evaluate this mutually-enabling combination of power-law-specific data duplication and Degree Sorting in a system called RADAR. RADAR improves performance by eliminating atomic updates for hub vertices and improving the cache locality of graph applications, providing speedups of up to 165x (1.88x on average) across different graph applications and input graphs.
+ER  - 
+TY  - JOUR
+T1  - Graph Analysis with High Performance Computing.
+A1  - Berry, Jonathan
+A1  - Hendrickson, Bruce
+Y1  - 2007///
+JF  - Computing in Science and Engineering
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Graph Analysis With High-Performance Computing.pdf
+ER  - 
+TY  - JOUR
+T1  - High-performance parallel graph coloring with strong guarantees on work, depth, and quality
+A1  - Besta, Maciej
+A1  - Carigiet, Armon
+A1  - Vonarburg-Shmaria, Zur
+A1  - Janda, Kacper
+A1  - Gianinazzi, Lukas
+A1  - Hoefler, Torsten
+Y1  - 2020///
+JF  - arXiv
+SN  - 9781728199986
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/High-Performance Parallel Graph Coloring with Strong Guarantees on Work, Depth, and Quality.pdf
+N2  - We develop the first parallel graph coloring heuristics with strong theoretical guarantees on work and depth and coloring quality. The key idea is to design a relaxation of the vertex degeneracy order, a well-known graph theory concept, and to color vertices in the order dictated by this relaxation. This introduces a tunable amount of parallelism into the degeneracy ordering that is otherwise hard to parallelize. This simple idea enables significant benefits in several key aspects of graph coloring. For example, one of our algorithms ensures polylogarithmic depth and a bound on the number of used colors that is superior to all other parallelizable schemes, while maintaining work-efficiency. In addition to provable guarantees, the developed algorithms have competitive run-times for several real-world graphs, while almost always providing superior coloring quality. Our degeneracy ordering relaxation is of separate interest for algorithms outside the context of coloring.
+ER  - 
+TY  - JOUR
+T1  - Attack intent analysis method based on attack path graph
+A1  - Chen, Biqiong
+A1  - Liu, Yanhua
+A1  - Li, Shijin
+A1  - Gao, Xiaoling
+Y1  - 2019///
+KW  - Attack Intention
+KW  - Attack Path Graph
+KW  - Key Asset
+KW  - Vulnerability
+KW  - Vulnerability Exploitation
+JF  - ACM International Conference Proceeding Series
+SP  - 97
+EP  - 102
+SN  - 9781450376624
+DO  - 10.1145/3371676.3371680
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Attack Intent Analysis Method Based on Attack Path Graph.pdf
+N2  - With the rapid development of network technology, network security problems are gradually increasing, and the network attack situation is very severe. In a complex attack scenario, timely detection of potential attack behaviors and timely identification and pre-judgment of attack intentions are important components of security risks. However, the attack behavior in the network presents complexity, multi-step and uncertainty, which brings new technical challenges to attack intent analysis. Aiming at the problem that the attack intention of multi-step complex attack is difficult to identify, this paper proposes an attack intention analysis method based on attack path graph. Firstly, aiming at the multi-step complex attack behavior analysis problem, the key asset assessment technology is used to find out the key assets in the network system, and the hypothetical attack intention is generated according to the security protection requirements of the network system. Then, it is difficult to manually construct the attack path map in the large-scale network, and the automatic generation of the attack path map is realized. Finally, a method of network attack intent identification is proposed and a calculation method of attack intent probability is designed, which improves the efficiency and accuracy of attack intent recognition.
+ER  - 
+TY  - THES
+T1  - RAGE: The Rage Attack Graph Engine
+A1  - Cook, Kyle
+Y1  - 2018///
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/Kyle Cook Thesis.pdf
+ER  - 
+TY  - JOUR
+T1  - Scalable attack graph generation
+A1  - Cook, Kyle
+A1  - Shaw, Thomas
+A1  - Hale, John
+A1  - Hawrylak, Peter
+Y1  - 2016///
+KW  - Attack graphs
+KW  - Attack modeling
+KW  - Vulnerability analysis
+JF  - Proceedings of the 11th Annual Cyber and Information Security Research Conference, CISRC 2016
+SN  - 9781450337526
+DO  - 10.1145/2897795.2897821
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Scalable Attack Graph Generation
+N2  - Attack graphs are a powerful modeling technique with which to explore the attack surface of a system. However, they can be difficult to generate due to the exponential growth of the state space, often times making exhaustive search im- practical. This paper discusses an approach for generating large attack graphs with an emphasis on scalable generation over a distributed system. First, a serial algorithm is presented, highlighting bottlenecks and opportunities to exploit inherent concurrency in the generation process. Then a strategy to parallelize this process is presented. Finally, we discuss plans for future work to implement the parallel algorithm using a hybrid distributed/shared memory programming model on a heterogeneous compute node cluster.
+ER  - 
+TY  - JOUR
+T1  - FPGP: Graph processing framework on FPGA: A case study of breadth-first search
+A1  - Dai, Guohao
+A1  - Chi, Yuze
+A1  - Wang, Yu
+A1  - Yang, Huazhong
+Y1  - 2016///
+KW  - FPGA framework
+KW  - Large scale graph processing
+JF  - FPGA 2016 - Proceedings of the 2016 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays
+SP  - 105
+EP  - 110
+SN  - 9781450338561
+DO  - 10.1145/2847263.2847339
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/FPGP: Graph Processing Framework on FPGA.pdf
+N2  - Large-scale graph processing is gaining increasing attentions in many domains. Meanwhile, FPGA provides a power-efficient and highly parallel platform for many applications, and has been applied to custom computing in many domains. In this paper, we describe FPGP (FPGA Graph Processing), a streamlined vertex-centric graph processing framework on FPGA, based on the interval-shard structure. FPGP is adaptable to different graph algorithms and users do not need to change the whole implementation on the FPGA. In our implementation, an on-chip parallel graph processor is proposed to both maximize the off-chip bandwidth of graph data and fully utilize the parallelism of graph processing. Meanwhile, we analyze the performance of FPGP and show the scalability of FPGP when the bandwidth of data path increases. FPGP is more power-efficient than single machine systems and scalable to larger graphs compared with other FPGA-based graph systems.
+ER  - 
+TY  - THES
+T1  - Active messages as a spanning model for parallel graph computation
+A1  - Edmonds, N
+Y1  - 2013///
+ER  - 
+TY  - JOUR
+T1  - Design of a Large-Scale Hybrid-Parallel Graph Library
+A1  - Edmonds, N
+A1  - Willcock, Jeremiah
+A1  - Lumsdaine, Andrew
+A1  - Hoefler, Torsten
+Y1  - 20110///
+JF  - International Conference for High Performance Computing, Student Research Symposium
+ER  - 
+TY  - JOUR
+T1  - Expressing graph algorithms using generalized active messages
+A1  - Edmonds, Nicholas
+A1  - Willcock, Jeremiah
+A1  - Lumsdaine, Andrew
+Y1  - 2013///
+KW  - active messages
+KW  - parallel graph algorithms
+KW  - programming models
+JF  - Proceedings of the International Conference on Supercomputing
+SP  - 283
+EP  - 292
+SN  - 9781450321303
+DO  - 10.1145/2464996.2465441
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Expressing graph algorithms using generalized active messages.pdf
+N2  - Recently, graph computation has emerged as an important class of high-performance computing application whose characteristics differ markedly from those of traditional, compute-bound kernels. Libraries such as BLAS, LAPACK, and others have been successful in codifying best practices in numerical computing. The data-driven nature of graph applications necessitates a more complex application stack incorporating runtime optimization. In this paper, we present a method of phrasing graph algorithms as collections of asynchronous, concurrently executing, concise code fragments which may be invoked both locally and in remote address spaces. A runtime layer performs a number of dynamic optimizations, including message coalescing, message combining, and software routing. We identify a number of common patterns in these algorithms, and explore how this programming model can express those patterns. Algorithmic transformations are discussed which expose asyn- chrony that can be leveraged by the runtime to improve performance and reduce resource utilization. Practical implementations and performance results are provided for a number of representative algorithms. © 2013 ACM.
+ER  - 
+TY  - JOUR
+T1  - Many-core graph workload analysis
+A1  - Eyerman, Stijn
+A1  - Heirman, Wim
+A1  - Du Bois, Kristof
+A1  - Fryman, Joshua B.
+A1  - Hur, Ibrahim
+Y1  - 2019///
+KW  - Graph applications
+KW  - Many-core processors
+KW  - Workload analysis
+JF  - Proceedings - International Conference for High Performance Computing, Networking, Storage, and Analysis, SC 2018
+SP  - 282
+EP  - 292
+SN  - 9781538683842
+DO  - 10.1109/SC.2018.00025
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Many-Core Graph Workload Analysis.pdf
+N2  - Graph applications have specific characteristics that are not common in other application domains and therefore require thorough analysis to guide future graph processing hardware design. In this paper, we analyze multiple graph applications on current multi and many-core processors, and provide conclusions and recommendations for future designs. We restate well-known characteristics of graph applications, such as a low compute to memory ratio and irregular memory access patterns, but we also provide new important insights on executing graph applications on many-core processors. Our main novel observations are (i) some memory streams do show locality, while others show no locality, (ii) thread imbalance becomes a major problem with many threads, and (iii) many threads are required to saturate high-bandwidth memories. The first observation calls for a selective memory access policy, where accesses with locality are cached and prefetched, while accesses without locality can remain uncached to save cache capacity, and can fetch only one element from memory instead of a full cache line to save on memory bandwidth. The last two observations are contradicting: more threads are needed, but they are not used efficiently due to thread imbalance. Our recommendation is therefore to thoroughly revise the graph analysis algorithms to provide more scalable parallelism to be able to exploit the potential of many-core architectures with high-bandwidth memory. In addition, providing a few high-performance cores can speed up sections with low parallelism.
+ER  - 
+TY  - JOUR
+T1  - P REDICTIVE C YBER S ECURITY A NALYTICS F RAMEWORK : A NON - HOMOGENOUS M ARKOV
+A1  - For, M Odel
+A1  - Uantification, S Ecurity Q
+Y1  - 2013///
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Predictive Cyber Security Analytics Framework
+ER  - 
+TY  - JOUR
+T1  - A planner-based approach to generate and analyze minimal attack graph
+A1  - Ghosh, Nirnay
+A1  - Ghosh, S. K.
+Y1  - 2012///
+KW  - Attack graph
+KW  - Attack path
+KW  - Exploit
+KW  - Network security
+KW  - Planner
+JF  - Applied Intelligence
+VL  - 36
+IS  - 2
+SP  - 369
+EP  - 390
+DO  - 10.1007/s10489-010-0266-8
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Ghosh-Ghosh2012_Article_APlanner-basedApproachToGenera.pdf
+N2  - In the present scenario, even well administered networks are susceptible to sophisticated cyber attacks. Such attack combines vulnerabilities existing on different systems/ services and are potentially more harmful than single point attacks. One of the methods for analyzing such security vulnerabilities in an enterprise network is the use of attack graph. It is a complete graph which gives a succinct representation of different attack scenarios, depicted by attack paths. An attack path is a logical succession of exploits, where each exploit in the series satisfies the preconditions for subsequent exploits and makes a causal relationship among them. Thus analysis of the attack graph may help in assessing network security from hackers' perspective. One of the intrinsic problems with the generation and analysis of such a complete attack graph is its scalability. In this work, an approach based on Planner, a special purpose search algorithm from artificial intelligence domain, has been proposed for time-efficient, scalable representation of the attack graphs. Further, customized algorithms have been developed for automatic generation of attack paths (using Planner as a low-level module). The analysis shows that generation of attack graph using the customized algorithms can be done in polynomial time. A case study has also been presented to demonstrate the efficacy of the proposed methodology. © Springer Science+Business Media, LLC 2010.
+ER  - 
+TY  - JOUR
+T1  - Graph analysis
+A1  - Guzzi, Pietro Hiram
+A1  - Roy, Swarup
+Y1  - 2020///
+JF  - Biological Network Analysis
+SP  - 25
+EP  - 51
+SN  - 9781450321884
+DO  - 10.1016/b978-0-12-819350-1.00009-8
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Graph Analyysis Do we have to reinvent the wheel.pdf
+N2  - The problem of efficiently analyzing graphs of various shapes and sizes has been recently enjoying an increased level of attention both in the academia and in the industry. This trend prompted creation of specialized graph databases that have been rapidly gaining popularity of late. In this paper we argue that there exist alternatives to graph databases, providing competitive or superior performance, that do not require replacement of the entire existing storage infrastructure by the companies wishing to deploy them. Copyright © 2013 ACM.
+ER  - 
+TY  - JOUR
+T1  - Dependency graph analysis and moving target defense selection
+A1  - Hamlet, Jason R.
+A1  - Lamb, Christopher C.
+Y1  - 2016///
+KW  - Cybersecurity
+KW  - Dynamic defense
+KW  - Moving target defense
+JF  - MTD 2016 - Proceedings of the 2016 ACM Workshop on Moving Target Defense, co-located with CCS 2016
+SP  - 105
+EP  - 116
+SN  - 9781450345705
+DO  - 10.1145/2995272.2995277
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Dependency graph analysis and moving target defense selection.pdf
+N2  - Moving target defense (MTD) is an emerging paradigm in which system defenses dynamically mutate in order to decrease the overall system attack surface. Though the concept is promising, implementations have not been widely adopted. The field has been actively researched for over ten years, and has only produced a small amount of extensively adopted defenses, most notably, address space layout randomization (ASLR). This is despite the fact that there currently exist a variety of moving target implementations and proofs-of-concept. We suspect that this results from the moving target controls breaking critical system dependencies from the perspectives of users and administrators, as well as making things more difficult for attackers. As a result, the impact of the controls on overall system security is not sufficient to overcome the inconvenience imposed on legitimate system users. In this paper, we analyze a successful MTD approach. We study the control's dependency graphs, showing how we use graph theoretic and network properties to predict the effectiveness of the selected control.
+ER  - 
+TY  - JOUR
+T1  - Graph coarsening for path finding in cybersecurity graphs
+A1  - Hogan, Emilie
+A1  - Johnson, John R.
+A1  - Halappanavar, Mahantesh
+Y1  - 2013///
+JF  - ACM International Conference Proceeding Series
+SN  - 9781450316873
+DO  - 10.1145/2459976.2459984
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Graph Coarsening.pdf
+N2  - A network hacking attack in which hackers repeatedly steal password hashes and move through a computer network with the goal of reaching a computer with high level administrative privileges is known as a pass-the-hash attack. In this paper we apply graph coarsening on graphs obtained from computer network data for the purpose of (a) detecting hackers using this attack and (b) assessing the risk level of the network's current state. We repeatedly contract edges (obtaining a graph minor), which preserves the existence of paths in the graph, and take powers of the adjacency matrix to count the paths. This allows us to detect the existence of paths as well as find paths that have high risk of being exploited by adversaries. Copyright 2012 ACM.
+ER  - 
+TY  - JOUR
+T1  - Algorithm 447: Efficient algorithms for graph manipulation
+A1  - Hopcroft, John
+A1  - Tarjan, Robert
+Y1  - 1973///
+KW  - analysis of algorithms
+KW  - graph manipulation
+KW  - graphs
+JF  - Communications of the ACM
+VL  - 16
+IS  - 6
+SP  - 372
+EP  - 378
+DO  - 10.1145/362248.362272
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Algorithm 447: efficient algorithms for graph manipulation.pdf
+N2  - Efficient algorithms are presented for partitioning a graph into connected components, biconnected components and simple paths. The algorithm for partitioning of a graph into simple paths of iterative and each iteration produces a new path between two vertices already on paths. (The start vertex can be specified dynamically.) If V is the number of vertices and E is the number of edges, each algorithm requires time and space proportional to max (V, E) when executed on a random access computer. © 1973, ACM. All rights reserved.
+ER  - 
+TY  - PAT
+T1  - Compliance Method for a Cyber-Physical System
+A1  - J. Hale
+A1  - Hawrylak, P.
+A1  - Papa, M.
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Complaince_Graph_US_Patent_9471789.pdf
+ER  - 
+TY  - BOOK
+T1  - Topological Analysis of Network Attack Vulnerability
+A1  - Jajodia, S.
+A1  - Noel, S.
+A1  - O'Berry, B.
+ED  - Kumar, Vipin
+ED  - Srivastava, Jaideep
+ED  - Lazarevic, Aleksandar
+Y1  - 2005///
+PB  - Springer-Verlag
+VL  - 5
+T3  - Massive Computing
+CY  - New York
+SN  - 0-387-24226-0
+DO  - 10.1007/b104908
+UR  - http://link.springer.com/10.1007/b104908
+ER  - 
+TY  - GEN
+T1  - Minimization and reliability analyses of attack graphs
+A1  - Jha, S
+A1  - Wing, J
+A1  - Sheyner, O
+Y1  - 2002///
+JF  - Citeseer
+UR  - http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.61.1788&rep=rep1&type=pdf%5Cnpapers2://publication/uuid/BFFE4D66-6A9E-4144-B0E8-26AE7B3C0D81
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/CMU-CS-02-109.pdf
+N2  - In Section 5 we present a to help administrators decide what measures to deploy to thwart attacks. In Section 6 we present a over probabilistic based on the value iteration algorithm defined for Markov Decision Processes
+ER  - 
+TY  - JOUR
+T1  - Two formal analyses of attack graphs
+A1  - Jha, S.
+A1  - Sheyner, O.
+A1  - Wing, J.
+Y1  - 2002///
+KW  - Computer science
+KW  - Contracts
+KW  - Forensics
+KW  - Greedy algorithms
+KW  - Intrusion detection
+KW  - Performance analysis
+KW  - Polynomials
+KW  - Safety
+KW  - Security
+KW  - US Department of Defense
+JF  - Proceedings of the Computer Security Foundations Workshop
+VL  - 2002-Janua
+SP  - 49
+EP  - 63
+SN  - 0769516890
+DO  - 10.1109/CSFW.2002.1021806
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/jha-wing.pdf
+N2  - An attack graph is a succinct representation of all paths through a system that end in a state where an intruder has successfully achieved his goal. Today Red Teams determine the vulnerability of networked systems by drawing gigantic attack graphs by hand. Constructing attack graphs by hand is tedious, error-prone, and impractical for large systems. By viewing an attack as a violation of a safety property, we can use off-the-shelf model checking technology to produce attack graphs automatically: a successful path from the intruder's viewpoint is a counterexample produced by the model checker In this paper we present an algorithm for generating attack graphs using model checking as a subroutine. Security analysts use attack graphs for detection, defense and forensics. In this paper we present a minimization analysis technique that allows analysts to decide which minimal set of security measures would guarantee the safety of the system. We provide a formal characterization of this problem: we prove that it is polynomially equivalent to the minimum hitting set problem and we present a greedy algorithm with provable bounds. We also present a reliability analysis technique that allows analysts to perform a simple cost-benefit trade-off depending on the likelihoods of attacks. By interpreting attack graphs as Markov Decision Processes we can use the value iteration algorithm to compute the probabilities of intruder success for each attack the graph.
+ER  - 
+TY  - JOUR
+T1  - Distributed Attack Graph Generation
+A1  - Kaynar, Kerem
+A1  - Sivrikaya, Fikret
+Y1  - 2016///
+KW  - Attack graph
+KW  - distributed computing
+KW  - exploit
+KW  - reachability
+KW  - vulnerability
+KW  - weakness
+PB  - IEEE
+JF  - IEEE Transactions on Dependable and Secure Computing
+VL  - 13
+IS  - 5
+SP  - 519
+EP  - 532
+DO  - 10.1109/TDSC.2015.2423682
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/07087377.pdf
+N2  - Attack graphs show possible paths that an attacker can use to intrude into a target network and gain privileges through series of vulnerability exploits. The computation of attack graphs suffers from the state explosion problem occurring most notably when the number of vulnerabilities in the target network grows large. Parallel computation of attack graphs can be utilized to attenuate this problem. When employed in online network security evaluation, the computation of attack graphs can be triggered with the correlated intrusion alerts received from sensors scattered throughout the target network. In such cases, distributed computation of attack graphs becomes valuable. This article introduces a parallel and distributed memory-based algorithm that builds vulnerability-based attack graphs on a distributed multi-agent platform. A virtual shared memory abstraction is proposed to be used over such a platform, whose memory pages are initialized by partitioning the network reachability information. We demonstrate the feasibility of parallel distributed computation of attack graphs and show that even a small degree of parallelism can effectively speed up the generation process as the problem size grows. We also introduce a rich attack template and network model in order to form chains of vulnerability exploits in attack graphs more precisely.
+ER  - 
+TY  - JOUR
+T1  - Efficient parallel all-pairs shortest paths algorithm for complex graph analysis
+A1  - Kim, Jong Wook
+A1  - Choi, Hyoeun
+A1  - Bae, Seung Hee
+Y1  - 2018///
+KW  - All-pairs shortest paths
+KW  - Parallel algorithms
+KW  - Shared-memory parallelism
+JF  - ACM International Conference Proceeding Series
+SN  - 9781450365239
+DO  - 10.1145/3229710.3229730
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/(REWRITE ALG TO MAKE MORE PARALLEL)Efficient Parallel All-Pairs Shortest Paths Algorithm for Complex.pdf
+N2  - The all-pairs shortest path problem is a classic problem to study characteristics of the given graphs. Though many efficient all-pairs shortest path algorithms have been published, it is still a very expensive computing task, especially with large graph datasets. In this paper, we propose an efficient parallel all-pairs shortest path algorithm based on Peng et al.'s fast sequential algorithm on shared-memory parallel environments to achieve faster and more efficient calculation for large-scale real-world networks. Peng et al.'s algorithm needs to sort vertices with respect to their degrees. However, it turns out the original algorithm uses less efficient sorting method, which is a significant portion of parallel overhead. Therefore, we also propose an efficient parallel method to sort data within a fixed range, in order to minimize the parallel overhead in our parallel algorithm. The optimized efficient sorting method can be used for general sorting purposes. Our experimental analysis shows that our proposed parallel algorithm achieves very high parallel speedup, even hyper-linear speedup, with real-world test datasets on two different shared-memory multi-core systems.
+ER  - 
+TY  - JOUR
+T1  - Attack graph based evaluation of network security
+A1  - Kotenko, Igor
+A1  - Stepashkin, Mikhail
+Y1  - 2006///
+KW  - Network attacks
+KW  - Network security
+KW  - Risk assessment
+KW  - Security metrics
+KW  - Vulnerability assessment
+JF  - Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics)
+VL  - 4237 LNCS
+SP  - 216
+EP  - 227
+SN  - 3540478205
+DO  - 10.1007/11909033_20
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/KotenkoS06.pdf
+N2  - The perspective directions in evaluating network security are simulating possible malefactor's actions, building the representation of these actions as attack graphs (trees, nets), the subsequent checking of various properties of these graphs, and determining security metrics which can explain possible ways to increase security level. The paper suggests a new approach to security evaluation based on comprehensive simulation of malefactor's actions, construction of attack graphs and computation of different security metrics. The approach is intended for using both at design and exploitation stages of computer networks. The implemented software system is described, and the examples of experiments for analysis of network security level are considered. © IFIP International Federation for Information Processing 2006.
+ER  - 
+TY  - JOUR
+T1  - Combining OpenCL and MPI to support heterogeneous computing on a cluster
+A1  - Li, Ming
+A1  - Hawrylak, Peter
+A1  - Hale, John
+Y1  - 2019///
+KW  - HPC
+KW  - Heterogeneous computing
+KW  - MDP
+KW  - MPI
+KW  - OpenCL
+KW  - Parallelism
+JF  - ACM International Conference Proceeding Series
+SN  - 9781450372275
+DO  - 10.1145/3332186.3333059
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Combining OpenCL and MPI to Support Heterogeneous Computing on a Cluster.pdf
+N2  - This paper presents an implementation of a heterogeneous programming model which combines Open Computing Language (OpenCL) and Message Passing Interface (MPI). The model is applied to solving a Markov decision process (MDP) with value iteration method. The performance test is conducted on a high performance computing cluster. At peak performance, the model is able to achieve a 57X speedup over a serial implementation. For an extremely large input MDP, which has 1,000,000 states, the obtained speedup is still over 12X, showing that this heterogeneous programming model can solve MDPs more efficiently than the serial solver does.
+ER  - 
+TY  - JOUR
+T1  - Concurrency Strategies for Attack Graph Generation
+A1  - Li, Ming
+A1  - Hawrylak, Peter
+A1  - Hale, John
+Y1  - 2019///
+KW  - Attack Graph
+KW  - Multi-threaded Programming
+KW  - Network Security
+KW  - OpenMP
+JF  - Proceedings - 2019 2nd International Conference on Data Intelligence and Security, ICDIS 2019
+SP  - 174
+EP  - 179
+SN  - 9781728120805
+DO  - 10.1109/ICDIS.2019.00033
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/Ming_LI_Thesis.pdf
+N2  - The network attack graph is a powerful tool for analyzing network security, but the generation of a large-scale graph is non-trivial. The main challenge is from the explosion of network state space, which greatly increases time and storage costs. In this paper, three parallel algorithms are proposed to generate scalable attack graphs. An OpenMP-based programming implementation is used to test their performance. Compared with the serial algorithm, the best performance from the proposed algorithms provides a 10X speedup.
+ER  - 
+TY  - THES
+T1  - Hybrid Attack Graphs for Modeling Cyber-Physical Systems
+A1  - Louthan, G
+Y1  - 2011///
+KW  - icle
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/louthan_thesis.pdf
+ER  - 
+TY  - JOUR
+T1  - Hybrid extensions for stateful attack graphs
+A1  - Louthan, George
+A1  - Haney, Michael
+A1  - Hardwicke, Phoebe
+A1  - Hawrylak, Peter
+A1  - Hale, John
+Y1  - 2014///
+JF  - ACM International Conference Proceeding Series
+SP  - 101
+EP  - 104
+SN  - 9781450328128
+DO  - 10.1145/2602087.2602106
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/George Conf 2014.pdf
+N2  - Critical infrastructures and safety critical systems increasingly rely on the carefully orchestrated interactions between computers, networks and kinetic elements. The dominant formalisms for modeling such hybrid systems (those with discrete and continuous components) are geared towards simple reactive systems working in isolation. By contrast, modern cyber-physical systems depend on highly interconnected computational components and often function in potentially hostile environments. This paper describes linguistic and type extensions to the stateful attack graph, which models the functional nature of attacks on purely discrete infor-mation systems, to include continuous system elements and time evolution. The resulting formalism is called the hybrid attack graph, which captures an integrated view of the vulnerability space between information systems and a restricted but useful set of hybrid systems. Copyright is held by the owner/author(s).
+ER  - 
+TY  - JOUR
+T1  - Toward hybrid attack dependency graphs
+A1  - Louthan, George
+A1  - Hardwicke, Phoebe
+A1  - Hawrylak, Peter
+A1  - Hale, John
+Y1  - 2011///
+JF  - ACM International Conference Proceeding Series
+SN  - 9781450309455
+DO  - 10.1145/2179298.2179368
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/George Conf 2011.pdf
+N2  - This extended abstract presents a set of continuous-domain extensions to the attack graph, a formalism used to model the interactions of multiple exploits and assets in a network. These extensions result in a new modeling framework called the hybrid attack dependency graph, which provides the novel capability of modeling continuous state variables and their evolution over the execution of attacks with duration. Copyright 2011 ACM.
+ER  - 
+TY  - JOUR
+T1  - Game strategies in network security
+A1  - Lye, Kong Wei
+A1  - Wing, Jeannette M.
+Y1  - 2005///
+KW  - Network security
+KW  - Nonlinear programming
+KW  - Stochastic games
+JF  - International Journal of Information Security
+VL  - 4
+IS  - 1-2
+SP  - 71
+EP  - 86
+DO  - 10.1007/s10207-004-0060-x
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/LyeWing05.pdf
+N2  - This paper presents a game-theoretic method for analyzing the security of computer networks. We view the interactions between an attacker and the administrator as a two-player stochastic game and construct a model for the game. Using a nonlinear program, we compute Nash equilibria or best-response strategies for the players (attacker and administrator). We then explain why the strategies are realistic and how administrators can use these results to enhance the security of their network. © Springer-Verlag 2005.
+ER  - 
+TY  - JOUR
+T1  - Efficient attack graph analysis through approximate inference
+A1  - Muñoz-González, Luis
+A1  - Sgandurra, Daniele
+A1  - Paudice, Andrea
+A1  - Lupu, Emil C.
+Y1  - 2017///
+KW  - Approximate inference
+KW  - Bayesian networks
+KW  - Probabilistic graphical models
+JF  - ACM Transactions on Privacy and Security
+VL  - 20
+IS  - 3
+DO  - 10.1145/3105760
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/3105760.pdf
+N2  - Attack graphs provide compact representations of the attack paths an attacker can follow to compromise network resources from the analysis of network vulnerabilities and topology. These representations are a powerful tool for security risk assessment. Bayesian inference on attack graphs enables the estimation of the risk of compromise to the system's components given their vulnerabilities and interconnections and accounts for multi-step attacks spreading through the system. While static analysis considers the risk posture at rest, dynamic analysis also accounts for evidence of compromise, for example, from Security Information and Event Management software or forensic investigation. However, in this context, exact Bayesian inference techniques do not scale well. In this article, we show how Loopy Belief Propagation-an approximate inference technique-can be applied to attack graphs and that it scales linearly in the number of nodes for both static and dynamic analysis, making such analyses viable for larger networks. We experiment with different topologies and network clustering on synthetic Bayesian attack graphs with thousands of nodes to show that the algorithm's accuracy is acceptable and that it converges to a stable solution. We compare sequential and parallel versions of Loopy Belief Propagation with exact inference techniques for both static and dynamic analysis, showing the advantages and gains of approximate inference techniques when scaling to larger attack graphs. 2017 Copyright is held by the owner/author(s).
+ER  - 
+TY  - CONF
+T1  - NSDMiner: Automated discovery of Network Service Dependencies
+A1  - Natarajan, Arun
+A1  - Peng Ning
+A1  - Yao Liu
+A1  - Jajodia, Sushil
+A1  - Hutchinson, Steve E.
+Y1  - 2012/03//
+PB  - IEEE
+JF  - 2012 Proceedings IEEE INFOCOM
+SP  - 2507
+EP  - 2515
+SN  - 978-1-4673-0775-8
+DO  - 10.1109/INFCOM.2012.6195642
+UR  - http://ieeexplore.ieee.org/document/6195642/
+ER  - 
+TY  - CONF
+T1  - Managing attack graph complexity through visual hierarchical aggregation
+A1  - Noel, Steven
+A1  - Jajodia, Sushil
+Y1  - 2004///
+PB  - ACM Press
+JF  - Proceedings of the 2004 ACM workshop on Visualization and data mining for computer security - VizSEC/DMSEC '04
+SP  - 109
+EP  - 109
+CY  - New York, New York, USA
+SN  - 1581139748
+DO  - 10.1145/1029208.1029225
+UR  - http://portal.acm.org/citation.cfm?doid=1029208.1029225
+ER  - 
+TY  - JOUR
+T1  - A Scalable Approach to Attack Graph Generation
+A1  - Ou, Xinming
+A1  - Boyer, Wayne F
+A1  - Mcqueen, Miles A
+Y1  - 2006///
+KW  - attack graphs
+KW  - enterprise network security
+KW  - logic-programming
+SP  - 336
+EP  - 345
+SN  - 1595935185
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/1180405.1180446.pdf
+ER  - 
+TY  - JOUR
+T1  - A graph-based system for network-vulnerability analysis
+A1  - Phillips, Cynthia
+A1  - Swiler, Laura Painton
+Y1  - 1998///
+KW  - Attack graph
+KW  - Computer security
+KW  - Network vulnerability
+JF  - Proceedings New Security Paradigms Workshop
+VL  - Part F1292
+SP  - 71
+EP  - 79
+SN  - 1581131682
+DO  - 10.1145/310889.310919
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/310889.310919.pdf
+N2  - This paper presents a graph-based approach to network vulnerability analysis. The method is flexible, allowing analysis of attacks from both outside and inside the network. It can analyze risks to a specific network asset, or examine the universe of possible consequences following a successful attack. The graph-based tool can identify the set of attack paths that have a high probability of success (or a low "effort" cost) for the attacker. The system could be used to test the effectiveness of making configuration changes, implementing an intrusion detection system, etc. The analysis system requires as input a database of common attacks, broken into atomic steps, specific network configuration and topology information, and an attacker profile. The attack information is "matched" with the network configuration information and an attacker profile to create a superset attack graph. Nodes identify a stage of attack, for example the class of machines the attacker has accessed and the user privilege level he or she has compromised. The arcs in the attack graph represent attacks or stages of attacks. By assigning probabilities of success on the arcs or costs representing level-of-effort for the attacker, various graph algorithms such as shortest-path algorithms can identify the attack paths with the highest probability of success.
+ER  - 
+TY  - JOUR
+T1  - Dynamic security risk management using Bayesian attack graphs
+A1  - Poolsappasit, Nayot
+A1  - Dewri, Rinku
+A1  - Ray, Indrajit
+Y1  - 2012///
+KW  - Bayesian belief networks
+KW  - Security risk assessment
+KW  - attack graph
+KW  - mitigation analysis
+PB  - IEEE
+JF  - IEEE Transactions on Dependable and Secure Computing
+VL  - 9
+IS  - 1
+SP  - 61
+EP  - 74
+DO  - 10.1109/TDSC.2011.34
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/05936075.pdf
+N2  - Security risk assessment and mitigation are two vital processes that need to be executed to maintain a productive IT infrastructure. On one hand, models such as attack graphs and attack trees have been proposed to assess the cause-consequence relationships between various network states, while on the other hand, different decision problems have been explored to identify the minimum-cost hardening measures. However, these risk models do not help reason about the causal dependencies between network states. Further, the optimization formulations ignore the issue of resource availability while analyzing a risk model. In this paper, we propose a risk management framework using Bayesian networks that enable a system administrator to quantify the chances of network compromise at various levels. We show how to use this information to develop a security mitigation and management plan. In contrast to other similar models, this risk model lends itself to dynamic analysis during the deployed phase of the network. A multiobjective optimization platform provides the administrator with all trade-off information required to make decisions in a resource constrained environment. © 2011 IEEE.
+ER  - 
+TY  - JOUR
+T1  - Exploring accelerator and parallel graph algorithmic choices for temporal graphs
+A1  - Rehman, Akif
+A1  - Ahmad, Masab
+A1  - Khan, Omer
+Y1  - 2020///
+KW  - graph algorithms
+KW  - multicores
+KW  - performance scaling
+KW  - static graphs
+KW  - temporal graphs
+JF  - Proceedings of the 11th International Workshop on Programming Models and Applications for Multicores and Manycores, PMAM 2020
+SN  - 9781450375221
+DO  - 10.1145/3380536.3380540
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Exploring accelerator and parallel graph.pdf
+N2  - Many real-world systems utilize graphs that are time-varying in nature, where edges appear and disappear with respect to time. Moreover, the weights of different edges are also a function of time. Various conventional graph algorithms, such as single source shortest path (SSSP) have been developed for time-varying graphs. However, these algorithms are sequential in nature and their parallel counterparts are largely overlooked. On the other hand, parallel algorithms for static graphs are implemented as ordered and unordered variants. Unordered implementations do not enforce local or global order for processing tasks in parallel, but incur redundant task processing to converge their solutions. These implementations expose parallelism at the cost of high redundant work. Relax-ordered implementations maintain local order through per-core priority queues to reduce the amount of redundant work, while exposing parallelism. Finally, strict-ordered implementations achieve the work efficiency of sequential version by enforcing a global order at the expense of high thread synchronizations. These parallel implementations are adopted for temporal graphs to explore the choices that provide optimal performance on different parallel accelerators. This work shows that selecting the optimal parallel implementation extracts geometric performance gain of 46.38% on Intel Xeon-40 core and 20.30% on NVidia GTX-1080 GPU. It is also shown that optimal implementation choices for temporal graphs are not always the same as their respective static graphs.
+ER  - 
+TY  - JOUR
+T1  - Application of Improved Dijkstra Algorithm in Two-dimensional Path Planning Problem
+A1  - Ruifang, Zhang
+A1  - Tianyi, Ji
+A1  - Haitao, Zheng
+Y1  - 2019///
+KW  - Dijkstra algorithm
+KW  - Greedy Algorithm
+KW  - Shortest Path Planning
+JF  - ACM International Conference Proceeding Series
+SP  - 211
+EP  - 215
+SN  - 9781450361910
+DO  - 10.1145/3378065.3378106
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/Application of Improved Dijkstra Algorithm in.pdf
+N2  - The Dijkstra algorithm is a typical single-source shortest path algorithm for calculating the shortest path from one node to the other in a non-negative weight map, but its use of the roulette method greatly affects the node selection. Speed and efficiency. Therefore, on the basis of ensuring the search accuracy, this paper improves the initial Dijkstra algorithm to improve the efficiency of the algorithm and meet its needs in 2D or 3D path planning. In this paper, MATLAB2018a is used as the experimental platform to simulate the initial Dijkstra algorithm and the improved Dijkstra algorithm. The experimental results show that the improved algorithm greatly reduces the path planning vision and improves the operating efficiency.
+ER  - 
+TY  - ICOMM
+T1  - Modeling Security Threats
+A1  - Schneier, Bruce
+Y1  - 1999///
+JF  - Dr. Dobb's Journal
+UR  - https://www.schneier.com/academic/archives/1999/12/attack_trees.html
+ER  - 
+TY  - JOUR
+T1  - Automated Generation and Analysis of Attack Graphs
+A1  - Sheyner, O.
+A1  - Haines, J.
+A1  - Jha, S.
+A1  - Lippmann, R..
+A1  - Wing, J.
+Y1  - 2002///
+JF  - Proceeding of 2002 IEEE Symposium on Security and Privacy
+SP  - 254
+EP  - 265
+SN  - 9781787284395
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/sheyner-wing02.pdf
+ER  - 
+TY  - JOUR
+T1  - Scalable generation of graphs for benchmarking HPC community-detection algorithms
+A1  - Slota, George M.
+A1  - Berry, Jonathan W.
+A1  - Hammond, Simon D.
+A1  - Olivier, Stephen L.
+A1  - Phillips, Cynthia A.
+A1  - Rajamanickam, Sivasankaran
+Y1  - 2019///
+JF  - International Conference for High Performance Computing, Networking, Storage and Analysis, SC
+SN  - 9781450362290
+DO  - 10.1145/3295500.3356206
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Scalable Generation of Graphs for Benchmarking HPC Community-.pdf
+N2  - Community detection in graphs is a canonical social network analysis method. We consider the problem of generating suites of teras-cale synthetic social networks to compare the solution quality of parallel community-detection methods. The standard method, based on the graph generator of Lancichinetti, Fortunato, and Radicchi (LFR), has been used extensively for modest-scale graphs, but has inherent scalability limitations. We provide an alternative, based on the scalable Block Two-Level Erdos-Renyi (BTER) graph generator, that enables HPC-scale evaluation of solution quality in the style of LFR. Our approach varies community coherence, and retains other important properties. Our methods can scale real-world networks, e.g., to create a version of the Friendster network that is 512 times larger. With BTER's inherent scalability, we can generate a 15-terabyte graph (4.6B vertices, 925B edges) in just over one minute. We demonstrate our capability by showing that label-propagation community-detection algorithm can be strong-scaled with negligible solution-quality loss.
+ER  - 
+TY  - CONF
+T1  - Computer-attack graph generation tool
+A1  - Swiler, L.P.
+A1  - Phillips, Cynthia
+A1  - Ellis, D.
+A1  - Chakerian, S.
+Y1  - 2001///
+PB  - IEEE Comput. Soc
+JF  - Proceedings DARPA Information Survivability Conference and Exposition II. DISCEX'01
+VL  - 2
+SP  - 307
+EP  - 321
+CY  - Anaheim, CA
+SN  - 0-7695-1212-7
+DO  - 10.1109/DISCEX.2001.932182
+UR  - http://ieeexplore.ieee.org/document/932182/
+ER  - 
+TY  - JOUR
+T1  - Graph Stream Summarization
+A1  - Tang, Nan
+A1  - Chen, Qing
+A1  - Mitra, Prasenjit
+Y1  - 2016///
+KW  - all or part of
+KW  - classroom use is granted
+KW  - copies are not made
+KW  - data streams
+KW  - graph streams
+KW  - or
+KW  - or distributed
+KW  - or hard copies of
+KW  - permission to make digital
+KW  - sketch
+KW  - summarization
+KW  - this work for personal
+KW  - without fee provided that
+SP  - 1481
+EP  - 1496
+SN  - 9781450335317
+DO  - 10.1145/2882903.2915223
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Graph Stream Summarization.pdf
+N2  - A graph stream, which refers to the graph with edges be-ing updated sequentially in a form of a stream, has impor-tant applications in cyber security and social networks. Due to the sheer volume and highly dynamic nature of graph streams, the practical way of handling them is by summa-rization. Given a graph stream G, directed or undirected, the problem of graph stream summarization is to summarize G as SG with a much smaller (sublinear) space, linear con-struction time and constant maintenance cost for each edge update, such that SG allows many queries over G to be ap-proximately conducted e The widely used practice of summarizing data streams is to treat each stream element independently by e.g., hash-or sample-based methods, with-out maintaining the connections (or relationships) between elements. Hence, existing methods can only solve ad-hoc problems, without supporting diversified and complicated analytics over graph streams. We present TCM, a novel graph stream summary. Given an incoming edge, it sum-marizes both node and edge information in constant time. Consequently, the summary forms a graphical sketch where edges capture the connections inside elements, and nodes maintain relationships across elements. We discuss a wide range of supported queries and establish some error bounds. In addition, we experimentally show that TCM can e↵ec-tively and e support analytics over graph streams beyond the power of existing sketches, which demonstrates its potential to start a new line of research and applications in graph stream management.
+ER  - 
+TY  - THES
+T1  - Critical Digital Asset Identification and Attack Graph State Estimation for Nuclear Research Reactors
+A1  - West, J.C
+Y1  - 2019///
+L1  - file:///home/noah/Documents/School/Thesis Work/Documentation/Codi_West_Masters_Thesis_4_18_19_Final_Library_Ver.pdf
+ER  - 
+TY  - JOUR
+T1  - Exploiting fine-grained parallelism in graph traversal algorithms via lock virtualization on multi-core architecture
+A1  - Yan, Jie
+A1  - Tan, Guangming
+A1  - Sun, Ninghui
+Y1  - 2014/09//
+JF  - The Journal of Supercomputing
+VL  - 69
+IS  - 3
+SP  - 1462
+EP  - 1490
+DO  - 10.1007/s11227-014-1239-1
+UR  - http://link.springer.com/10.1007/s11227-014-1239-1
+ER  - 
+TY  - JOUR
+T1  - High performance graph analytics with productivity on hybrid CPU-GPU platforms
+A1  - Yang, Haoduo
+A1  - Su, Huayou
+A1  - Lan, Qiang
+A1  - Wen, Mei
+A1  - Zhang, Chunyuan
+Y1  - 2018///
+KW  - Graph analytics
+KW  - Hybrid CPU-GPU
+KW  - Parallel computing
+JF  - ACM International Conference Proceeding Series
+SP  - 17
+EP  - 21
+SN  - 9781450363372
+DO  - 10.1145/3195612.3195614
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/High Performance Graph Analytics with Productivity.pdf
+N2  - In recent years, the rapid-growing scales of graphs have sparked a lot of parallel graph analysis frameworks to leverage the massive hardware resources on CPUs or GPUs. Existing CPU implementations are time-consuming, while GPU implementations are restricted by the memory space and the complexity of programming. In this paper, we present a high performance hybrid CPU-GPU parallel graph analytics framework with good productivity based on GraphMat. We map vertex programs to generalized sparse matrix vector multiplication on GPUs to deliver high performance, and propose a high-level abstraction for developers to implement various graph algorithms with relatively little efforts. Meanwhile, several optimizations have been adopted for reducing the communication cost and leveraging hardware resources, especially the memory hierarchy. We evaluate the proposed framework on three graph primitives (PageRank, BFS and SSSP) with large-scale graphs. The experimental results show that, our implementation achieves an average speedup of 7.0X than GraphMat on two 6-core Intel Xeon CPUs. It also has the capability to process larger datasets but achieves comparable performance than MapGraph, a state-of-the-art GPU-based framework.
+ER  - 
+TY  - JOUR
+T1  - An efficient graph accelerator with parallel data conflict management
+A1  - Yao, Pengcheng
+A1  - Zheng, Long
+A1  - Liao, Xiaofei
+A1  - Jin, Hai
+A1  - He, Bingsheng
+Y1  - 2018///
+JF  - Parallel Architectures and Compilation Techniques - Conference Proceedings, PACT
+SN  - 9781450359863
+DO  - 10.1145/3243176.3243201
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/An efficient graph accelerator with parallel data conflict management.pdf
+N2  - Graph-specific computing with the support of dedicated accelerator has greatly boosted the graph processing in both efficiency and energy. Nevertheless, their data conflict management is still sequential when certain vertex needs a large number of conflicting updates at the same time, leading to prohibitive performance degradation. This is particularly true and serious for processing natural graphs. In this paper, we have the insight that the atomic operations for the vertex updating of many graph algorithms (e.g., BFS, PageRank, andWCC) are typically incremental and simplex. This hence allows us to parallelize the conflicting vertex updates in an accumulative manner.We architect AccuGraph, a novel graph-specific accelerator that can simultaneously process atomic vertex updates for massive parallelism while ensuring the correctness. A parallel accumulator is designed to remove the serialization in atomic protections for conflicting vertex updates through merging their results in parallel. Our implementation on Xilinx FPGA with a wide variety of typical graph algorithms shows that our accelerator achieves an average throughput by 2.36 GTEPS as well as up to 3.14x performance speedup in comparison with state-of-the-art ForeGraph (with its single-chip version).
+ER  - 
+TY  - JOUR
+T1  - Cyber Attack Analysis Based   on Markov Process Model
+A1  - Zeng, Keming
+Y1  - 2017///
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Analysis/keming_thesis.pdf
+ER  - 
+TY  - JOUR
+T1  - Boosting the performance of FPGA-based graph processor using hybrid memory cube: A case for breadth first search
+A1  - Zhang, Jialiang
+A1  - Khoram, Soroosh
+A1  - Li, Jing
+Y1  - 2017///
+JF  - FPGA 2017 - Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays
+SP  - 207
+EP  - 216
+SN  - 9781450343541
+DO  - 10.1145/3020078.3021737
+L1  - file:///home/noah/Documents/School/Other Research/HPC Book Chapter/Articles/Boosting the Performance of FPGA-based Graph Processor using Hybrdi Memory Cube.pdf
+N2  - Large graph processing has gained great attention in recent years due to its broad applicability from machine learning to social science. Large real-world graphs, however, are inherently difficult to process efficiently, not only due to their large memory footprint, but also that most graph algorithms entail memory access patterns with poor locality and a low compute-to-memory access ratio. In this work, we leverage the exceptional random access performance of emerging Hybrid Memory Cube (HMC) technology that stacks multiple DRAM dies on top of a logic layer, combined with the flexibility and efficiency of FPGA to address these challenges. To our best knowledge, this is the first work that implements a graph processing system on a FPGA-HMC platform based on software/hardware co-design and co-optimization. We first present the modifications of algorithm and a platform-aware graph processing architecture to perform level-synchronized breadth first search (BFS) on FPGA-HMC platform. To gain better insights into the potential bottlenecks of proposed implementation, we develop an analytical performance model to quantitatively evaluate the HMC access latency and corresponding BFS performance. Based on the analysis, we propose a two-level bitmap scheme to further reduce memory access and perform optimization on key design parameters (e.g. memory access granularity). Finally, we evaluate the performance of our BFS implementation using the AC-510 development kit from Micron. We achieved 166 million edges traversed per second (MTEPS) using GRAPH500 benchmark on a random graph with a scale of 25 and an edge factor of 16, which significantly outperforms CPU and other FPGA-based large graph processors.
+ER  - 

tmp/clean.py

@@ -0,0 +1,32 @@
+#!/usr/bin/python
+
+import glob, re, os, sys, zipfile
+
+for pattern in sys.argv[1:]:
+    for filepath in glob.glob(pattern):
+        dirname, basename = os.path.split(filepath)
+        root, ext = os.path.splitext(basename)
+        newname = '%s-clean%s' % (root, ext)
+        outpath = os.path.join(dirname, newname)
+        zin = zipfile.ZipFile (filepath, 'r')
+        zout = zipfile.ZipFile (outpath, 'w')
+        for item in zin.infolist():
+            if item.filename == 'mimetype':
+                zout.writestr(item, zin.read(item.filename))
+        for item in zin.infolist():
+            if item.filename == 'meta.xml':
+                data = zin.read(item.filename)
+                # Find the document creation timestamp.
+                timestamp = '2000-01-01T12:00:00.0'
+                #timestamp = re.search(r'<meta:creation-date>([^<]+)</meta:creation-date>', data).group(1)
+        for item in zin.infolist():
+            if item.filename == 'content.xml':
+                #data = pexpect.run('ls -l', encoding='utf-8')
+                data = zin.read(item.filename)
+                # Replace all occurrences of date in <dc:date>
+                data = re.sub(b'<dc:date>[^<]+</dc:date>', b'<dc:date>2000-01-01T12:00:00</dc:date>', data)
+                zout.writestr(item, data)
+            elif item.filename != 'mimetype':
+                zout.writestr(item, zin.read(item.filename))
+        zout.close()
+        zin.close()