Figure renaming

TPDS_Submission/Bibliography.bib

@@ -0,0 +1,382 @@
+
+@misc{noauthor_parmetis_nodate,
+	title = {ParMETIS - Parallel Graph Partitioning and Fill-reducing Matrix Ordering},
+	author = {Karypis Lab},
+	note = {http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview},
+}
+
+@ARTICLE{7087377,  
+	author={Kaynar, Kerem and Sivrikaya, Fikret},  
+	journal={IEEE Transactions on Dependable and Secure Computing},   
+	title={Distributed Attack Graph Generation},   
+	year={2016},  
+	volume={13},  
+	number={5},  
+	pages={519-532},  
+	doi={10.1109/TDSC.2015.2423682}
+}
+
+@misc{noauthor_boost_nodate,
+	title = {The Boost Graph Library, vers. 1.75.0},
+	author = {Siek, Jeremy and Lee, Lie-Quan and Lumsdaine, Andrew},
+	note = {https://www.boost.org/doc/libs/1$\_$75$\_$0/libs/graph/doc/index.html},
+}
+
+@article{ainsworth_graph_2016,
+	title = {Graph prefetching using data structure knowledge},
+	volume = {01-03-June},
+	issn = {9781450343619},
+	doi = {10.1145/2925426.2926254},
+	abstract = {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.},
+	journal = {Proceedings of the International Conference on Supercomputing},
+	author = {Ainsworth, Sam and Jones, Timothy M.},
+	year = {2016},
+	keywords = {Graphs, Prefetching},
+	file = {Graph Prefetching Using Data Structure Knowledge:/home/noah/Zotero/storage/UUVEP42L/Graph Prefetching Using Data Structure Knowledge.pdf:application/pdf},
+}
+
+@mastersthesis{cook_rage_2018,
+	title = {{RAGE}: {The} {Rage} {Attack} {Graph} {Engine}},
+	author = {Cook, Kyle},
+	school = {The {University} of {Tulsa}},
+	year = {2018},
+	file = {Kyle Cook Thesis:/home/noah/Zotero/storage/2SR28HM2/Kyle Cook Thesis.pdf:application/pdf},
+}
+
+@article{cook_scalable_2016,
+	title = {Scalable attack graph generation},
+	issn = {9781450337526},
+	doi = {10.1145/2897795.2897821},
+	abstract = {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.},
+	journal = {Proceedings of the 11th Annual Cyber and Information Security Research Conference, CISRC 2016},
+	author = {Cook, Kyle and Shaw, Thomas and Hale, John and Hawrylak, Peter},
+	year = {2016},
+	keywords = {Attack graphs, Attack modeling, Vulnerability analysis},
+	file = {Attachment:/home/noah/Zotero/storage/2YNSLTQH/Scalable Attack Graph Generation:application/pdf},
+}
+
+@article{dai_fpgp_2016,
+	title = {{FPGP}: {Graph} processing framework on {FPGA}: {A} case study of breadth-first search},
+	issn = {9781450338561},
+	doi = {10.1145/2847263.2847339},
+	abstract = {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.},
+	journal = {FPGA 2016 - Proceedings of the 2016 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays},
+	author = {Dai, Guohao and Chi, Yuze and Wang, Yu and Yang, Huazhong},
+	year = {2016},
+	keywords = {FPGA framework, Large scale graph processing},
+	pages = {105--110},
+	file = {FPGP\: Graph Processing Framework on FPGA:/home/noah/Zotero/storage/QJUQ3SDZ/FPGP Graph Processing Framework on FPGA.pdf:application/pdf},
+}
+
+@misc{j_hale_compliance_nodate,
+	title = {Compliance {Method} for a {Cyber}-{Physical} {System}},
+	author = {{J. Hale} and Hawrylak, P. and Papa, M.},
+	note = {U.S. Patent Number 9,471,789, Oct. 18, 2016.},
+	number = {9471789},
+	file = {Complaince_Graph_US_Patent_9471789:/home/noah/Zotero/storage/55BZN4U7/Complaince_Graph_US_Patent_9471789.pdf:application/pdf},
+}
+
+@article{li_combining_2019,
+	title = {Combining {OpenCL} and {MPI} to support heterogeneous computing on a cluster},
+	issn = {9781450372275},
+	doi = {10.1145/3332186.3333059},
+	abstract = {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.},
+	journal = {ACM International Conference Proceeding Series},
+	author = {Li, Ming and Hawrylak, Peter and Hale, John},
+	year = {2019},
+	keywords = {Heterogeneous computing, HPC, MDP, MPI, OpenCL, Parallelism},
+	file = {Combining OpenCL and MPI to Support Heterogeneous Computing on a Cluster:/home/noah/Zotero/storage/TXHCQ5S8/Combining OpenCL and MPI to Support Heterogeneous Computing on a Cluster.pdf:application/pdf},
+}
+
+@article{li_concurrency_2019,
+	title = {Concurrency {Strategies} for {Attack} {Graph} {Generation}},
+	issn = {9781728120805},
+	doi = {10.1109/ICDIS.2019.00033},
+	abstract = {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.},
+	journal = {Proceedings - 2019 2nd International Conference on Data Intelligence and Security, ICDIS 2019},
+	author = {Li, Ming and Hawrylak, Peter and Hale, John},
+	year = {2019},
+	keywords = {Attack Graph, Multi-threaded Programming, Network Security, OpenMP},
+	pages = {174--179},
+	file = {Ming_LI_Thesis:/home/noah/Zotero/storage/CLSLS335/Ming_LI_Thesis.pdf:application/pdf},
+}
+
+@article{ou_scalable_2006,
+	title = {A {Scalable} {Approach} to {Attack} {Graph} {Generation}},
+	issn = {1595935185},
+	author = {Ou, Xinming and Boyer, Wayne F and Mcqueen, Miles A},
+	year = {2006},
+	journal = {CCS '06: Proceedings of the 13th ACM conference on Computer and communications security},
+	keywords = {attack graphs, enterprise network security, logic-programming},
+	pages = {336--345},
+	file = {1180405.1180446:/home/noah/Zotero/storage/TJKHVC4R/1180405.1180446.pdf:application/pdf},
+}
+
+@article{yao_efficient_2018,
+	title = {An efficient graph accelerator with parallel data conflict management},
+	issn = {9781450359863},
+	doi = {10.1145/3243176.3243201},
+	abstract = {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).},
+	journal = {Parallel Architectures and Compilation Techniques - Conference Proceedings, PACT},
+	author = {Yao, Pengcheng and Zheng, Long and Liao, Xiaofei and Jin, Hai and He, Bingsheng},
+	year = {2018},
+	file = {An efficient graph accelerator with parallel data conflict management:/home/noah/Zotero/storage/NMA7DQ5B/An efficient graph accelerator with parallel data conflict management.pdf:application/pdf},
+}
+
+@article{zhang_boosting_2017,
+	title = {Boosting the performance of {FPGA}-based graph processor using hybrid memory cube: {A} case for breadth first search},
+	issn = {9781450343541},
+	doi = {10.1145/3020078.3021737},
+	abstract = {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.},
+	journal = {FPGA 2017 - Proceedings of the 2017 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays},
+	author = {Zhang, Jialiang and Khoram, Soroosh and Li, Jing},
+	year = {2017},
+	pages = {207--216},
+	file = {Boosting the Performance of FPGA-based Graph Processor using Hybrdi Memory Cube:/home/noah/Zotero/storage/CDKPUXYF/Boosting the Performance of FPGA-based Graph Processor using Hybrdi Memory Cube.pdf:application/pdf},
+}
+
+@book{pacheco_introduction_2011,
+	edition = {Print},
+	title = {An {Introduction} to {Parallel} {Programming}},
+	isbn = {978-0-12-374260-5},
+	publisher = {Morgan Kaufmann},
+	author = {Pacheco, Peter},
+	year = {2011}
+}
+
+@article{ammar_experimental_2018,
+	title = {Experimental {Analysis} of {Distributed} {Graph} {Systems}},
+	volume = {11},
+	doi = {10.14778/3231751.3231764},
+	abstract = {This paper evaluates eight parallel graph processing systems: Hadoop, HaLoop, Vertica, Giraph, GraphLab (PowerGraph), Blogel, Flink Gelly, and GraphX (SPARK) over four very large datasets (Twitter, World Road Network, UK 200705, and ClueWeb) using four workloads (PageRank, WCC, SSSP and K-hop). The main objective is to perform an independent scale-out study by experimentally analyzing the performance, usability, and scalability (using up to 128 machines) of these systems. In addition to performance results, we discuss our experiences in using these systems and suggest some system tuning heuristics that lead to better performance.},
+	number = {10},
+	urldate = {2021-04-02},
+	journal = {Proceedings of the VLDB Endowment},
+	author = {Ammar, Khaled and Ozsu, Tamer},
+	month = jun,
+	year = {2018},
+	keywords = {Computer Science - Distributed, Parallel, and Cluster Computing},
+	annote = {Comment: Volume 11 of Proc. VLDB Endowment},
+	file = {arXiv Fulltext PDF:/home/noah/Zotero/storage/QJA73MYR/Ammar and Ozsu - 2018 - Experimental Analysis of Distributed Graph Systems.pdf:application/pdf;arXiv.org Snapshot:/home/noah/Zotero/storage/TTUFSAHW/1806.html:text/html},
+}
+
+@article{mccune_thinking_2015,
+	title = {Thinking {Like} a {Vertex}: {A} {Survey} of {Vertex}-{Centric} {Frameworks} for {Large}-{Scale} {Distributed} {Graph} {Processing}},
+	volume = {48},
+	doi = {10.1145/2818185},
+	number = {2},
+	journal = {ACM Computing Surveys},
+	author = {McCune, Robert and Weninger, Tim and Madey, Greg},
+	year = {2015},
+}
+
+@inproceedings{dimov_pass--hash_2017,
+	title = {Pass-the-{Hash}: {One} of the {Most} {Prevalent} {Yet} {Underrated} {Attacks} for {Credentials} {Theft} and {Reuse}},
+	doi = {10.1145/3134302.3134338},
+	booktitle = {18th {International} {Conference} on {Computer} {Systems} and {Technologies}},
+	author = {Dimov, Dimo and Tzonev, Yulian},
+	year = {2017},
+	pages = {149--154},
+}
+
+@inproceedings{baloyi_guidelines_2019,
+	address = {Skukuza South Africa},
+	title = {Guidelines for {Data} {Privacy} {Compliance}: {A} {Focus} on {Cyberphysical} {Systems} and {Internet} of {Things}},
+	doi = {10.1145/3351108.3351143},
+	booktitle = {{SAICSIT} '19: {Proceedings} of the {South} {African} {Institute} of {Computer} {Scientists} and {Information} {Technologists} 2019},
+	publisher = {Association for Computing Machinery},
+	author = {Baloyi, Ntsako and Kotzé, Paula},
+	year = {2019},
+}
+
+@article{allman_complying_2006,
+	title = {Complying with {Compliance}: {Blowing} it off is not an option.},
+	volume = {4},
+	number = {7},
+	journal = {ACM Queue},
+	author = {Allman, Eric},
+	year = {2006},
+}
+
+@inproceedings{arifuzzaman_fast_2015,
+	title = {Fast parallel conversion of edge list to adjacency list for large-scale graphs},
+	booktitle = {{HPC} '15: {Proceedings} of the {Symposium} on {High} {Performance} {Computing}},
+	author = {Arifuzzaman, Shaikh and Khan, Maleq},
+	month = apr,
+	year = {2015},
+	pages = {17--24},
+}
+
+@inproceedings{yu_construction_2018,
+	title = {The {Construction} of {Large} {Graph} {Data} {Structures} in a {Scalable} {Distributed} {Message} {System}},
+	doi = {10.1145/3234664.3234682},
+	booktitle = {{HPCCT} 2018: {Proceedings} of the 2018 2nd {High} {Performance} {Computing} and {Cluster} {Technologies} {Conference}},
+	author = {Yu, Xinjie and Chen, Wentao and Miao, Jiajia and Chen, Jian and Mao, Handong and Luo, Qiong and Gu, Lin},
+	month = jun,
+	year = {2018},
+	pages = {6--10},
+}
+
+@inproceedings{liakos_memory-optimized_2016,
+	title = {Memory-{Optimized} {Distributed} {Graph} {Processing} through {Novel} {Compression} {Techniques}},
+	doi = {10.1145/2983323.2983687},
+	booktitle = {{CIKM} '16: {Proceedings} of the 25th {ACM} {International} {Conference} on {Information} and {Knowledge} {Management}},
+	author = {Liakos, Panagiotis and Papakonstantinopoulou, Katia and Delis, Alex},
+	month = oct,
+	year = {2016},
+	pages = {2317--2322},
+}
+
+@software{noauthor_parallel_nodate-1,
+	author = {{Nick Edmonds}, {Douglas Gregor}, {Andrew Lumsdaine}},
+	title = {Parallel {BGL} {Distributed} {Adjacency} {List}},
+	url = {https://www.boost.org/doc/libs/1_73_0/libs/graph_parallel/doc/html/distributed_adjacency_list.html},
+	version = {1.73.0},
+	urldate = {2021-04-11},
+}
+
+@misc{Slurm,
+	author = {SchedMD},
+	title = {Slurm {Workload} {Manager}},
+	howpublished = {https://slurm.schedmd.com/overview.html},
+	month = apr,
+	note = {Version 23.02},
+	year = {2023}
+}
+
+@inproceedings{balaji_graph_2016,
+	title = {Graph {Topology} {Abstraction} for {Distributed} {Path} {Queries}},
+	doi = {10.1145/2915516.2915520},
+	booktitle = {{HPGP} '16: {Proceedings} of the {ACM} {Workshop} on {High} {Performance} {Graph} {Processing}},
+	author = {Balaji, Janani and Sunderraman, Rajshekhar},
+	month = may,
+	year = {2016},
+	pages = {27--34},
+}
+
+
+@INPROCEEDINGS{9150145,
+  author={Li, Ming and Hawrylak, Peter J. and Hale, John},
+  booktitle={2020 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW)}, 
+  title={Implementing an Attack Graph Generator in CUDA}, 
+  year={2020},
+  volume={},
+  number={},
+  pages={730-738},
+  doi={10.1109/IPDPSW50202.2020.00128}}
+
+
+@INPROCEEDINGS{9678822,
+  author={Dakhno, Natalia and Leshchenko, Olga and Kravchenko, Yurii and Dudnik, Andriy and Trush, Olexandr and Khankishiev, Victor},
+  booktitle={2021 IEEE 3rd International Conference on Advanced Trends in Information Theory (ATIT)}, 
+  title={Dynamic Model of the Spread of Viruses in a Computer Network Using Differential Equations}, 
+  year={2021},
+  volume={},
+  number={},
+  pages={111-115},
+  doi={10.1109/ATIT54053.2021.9678822}}
+
+@INPROCEEDINGS{7993827,
+  author={Kwon, Minhae and Kwon, Jungmin and Park, Byungchul and Park, Hyunggon},
+  booktitle={2017 Ninth International Conference on Ubiquitous and Future Networks (ICUFN)}, 
+  title={An architecture of IPTV networks based on network coding}, 
+  year={2017},
+  volume={},
+  number={},
+  pages={462-464},
+  doi={10.1109/ICUFN.2017.7993827}}
+
+@INPROCEEDINGS{8652334,
+  author={Bai, Xiaodan and Liang, Mangui and Zhu, Senpeng},
+  booktitle={2018 14th IEEE International Conference on Signal Processing (ICSP)}, 
+  title={A New Routing Scheme for Large-scale Computer Network}, 
+  year={2018},
+  volume={},
+  number={},
+  pages={1019-1023},
+  doi={10.1109/ICSP.2018.8652334}}
+
+@inproceedings{CPSIOT,
+author = {Al Ghazo, Alaa T. and Ibrahim, Mariam and Ren, Hao and Kumar, Ratnesh},
+title = {A2G2V: Automated Attack Graph Generator and Visualizer},
+year = {2018},
+isbn = {9781450358606},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+url = {https://doi.org/10.1145/3215466.3215468},
+doi = {10.1145/3215466.3215468},
+booktitle = {Proceedings of the 1st ACM MobiHoc Workshop on Mobile IoT Sensing, Security, and Privacy},
+articleno = {3},
+numpages = {6},
+keywords = {Model Checking, Security, Enumerating Counterexamples, Internet of Things, Attack Graph, Cyber-Physical Systems},
+location = {Los Angeles, CA, USA},
+series = {Mobile IoT SSP'18}
+}
+
+@article{ming_jo,
+author = {Li, Ming and Hawrylak, Peter and Hale, John},
+title = {Strategies for Practical Hybrid Attack Graph Generation and Analysis},
+year = {2021},
+publisher = {Association for Computing Machinery},
+address = {New York, NY, USA},
+issn = {2692-1626},
+url = {https://doi.org/10.1145/3491257},
+doi = {10.1145/3491257},
+abstract = {As an analytical tool in cyber-security, an attack graph (AG) is capable of discovering multi-stage attack vectors on target computer networks. Cyber-physical systems (CPSs) comprise a special type of network that not only contains computing devices but also integrates components that operate in the continuous domain, such as sensors and actuators. Using AGs on CPSs requires that the system models and exploit patterns capture both token- and real-valued information. In this paper, we describe a hybrid AG model for security analysis of CPSs and computer networks. Specifically, we focus on two issues related to applying the model in practice: efficient hybrid AG generation and techniques for information extraction from them. To address the first issue, we present an accelerated hybrid AG generator that employs parallel programming and high performance computing (HPC). We conduct performance tests on CPU and GPU platforms to characterize the efficiency of our parallel algorithms. To address the second issue, we introduce an analytical regimen based on centrality analysis and apply it to a hybrid AG generated for a target CPS system to discover effective vulnerability remediation solutions.},
+journal = {Digital Threats},
+month = {oct},
+keywords = {cyber-physical system, high performance computing, attack graph, breadth-first search}
+}
+
+@article{Gust,
+	author = {Gustafson, John L.},
+	title = {Reevaluating Amdahl's Law},
+	year = {1988},
+	issue_date = {May 1988},
+	publisher = {Association for Computing Machinery},
+	address = {New York, NY, USA},
+	volume = {31},
+	number = {5},
+	issn = {0001-0782},
+	url = {https://doi.org/10.1145/42411.42415},
+	doi = {10.1145/42411.42415},
+	journal = {Commun. ACM},
+	month = {may},
+	pages = {532–533},
+	numpages = {2}
+}
+
+@inproceedings{sun,
+  title={Another view on parallel speedup},
+  author={Sun, Xian-He and Ni, Lionel M},
+  booktitle={Proceedings of the 1990 ACM/IEEE conference on Supercomputing},
+  pages={324--333},
+  year={1990}
+}
+
+@inproceedings{Amdahl,
+	author = {Amdahl, Gene M.},
+	title = {Validity of the Single Processor Approach to Achieving Large Scale Computing Capabilities},
+	year = {1967},
+	isbn = {9781450378956},
+	publisher = {Association for Computing Machinery},
+	address = {New York, NY, USA},
+	url = {https://doi.org/10.1145/1465482.1465560},
+	doi = {10.1145/1465482.1465560},
+	booktitle = {Proceedings of the April 18-20, 1967, Spring Joint Computer Conference},
+	pages = {483–485},
+	numpages = {3},
+	location = {Atlantic City, New Jersey},
+	series = {AFIPS '67 (Spring)}
+	}
+
+@ARTICLE{10124989,
+  author={Schrick, Noah L. and Hawrylak, Peter J.},
+  journal={IEEE Open Journal of the Computer Society}, 
+  title={State Space Explosion Mitigation for Large-Scale Attack and Compliance Graphs Using Synchronous Exploit Firing}, 
+  year={2023},
+  volume={4},
+  number={},
+  pages={147-157},
+  doi={10.1109/OJCS.2023.3276370}
+}

TPDS_Submission/Data/acquire_data.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+#
+scp hammer:~/RAGE/projects/tasking_performance/slurm_reports/mpitasking/sync_data.csv .
+mv sync_data.csv para_data.csv
+scp hammer:~/RAGE/projects/tasking_performance/slurm_reports/serial/sync_data.csv .
+mv sync_data.csv serial_data.csv
+
+# No header, so not worried about copying headers
+cat header.txt para_data.csv serial_data.csv > timing.csv
+

TPDS_Submission/Data/header.txt

@@ -0,0 +1 @@
+load,exploit,appl,nodes,runtime,task0,task1,task2,task3,task4,task5

TPDS_Submission/Data/para_data.csv

@@ -0,0 +1,811 @@
+395,6,0,2,1345.023000,0,202.585,271.173,98.4515,0,0
+395,6,0,3,1753.742000,0,203.613,19.966,91.0985,0,0
+395,6,0,4,2168.114000,0,211.21,26.232,117.512,0,0
+395,6,0,5,1755.362000,0,202.993,20.585,89.884,0,0
+395,6,0,6,2125.772000,0,208.668,25.811,112.805,0,0
+395,6,0,7,1969.016000,0,279.401,20.407,100.743,0,0
+395,6,0,8,1627.819000,0,168.995,255.474,90.7445,0,0
+395,6,0,9,2119.303000,0,332.761,232.937,114.57,0,0
+395,6,0,10,1888.811000,0,153.595,389.827,110.996,0,0
+395,6,0,11,2246.655000,0,297.274,330.961,117.38,0,0
+395,6,0,12,1614.087000,0,141.651,314.245,91.072,0,0
+395,6,25,2,1358.991000,0,202.525,273.299,100.713,0,0
+395,6,25,3,2243.092000,0,212.773,28.241,117.468,0,0
+395,6,25,4,1745.402000,0,202.637,20.0945,90.533,0,0
+395,6,25,5,2150.073000,0,208.975,26.11,116.733,0,0
+395,6,25,6,1874.124000,0,201.836,20.1915,115.683,0,0
+395,6,25,7,2197.299000,0,320.107,20.3105,116.736,0,0
+395,6,25,8,1874.740000,0,169.439,273.463,115.393,0,0
+395,6,25,9,1800.494000,0,286.907,207.546,91.752,0,0
+395,6,25,10,2062.456000,0,171.823,369.409,116.871,0,0
+395,6,25,11,2094.266000,0,288.113,314.761,116.597,0,0
+395,6,25,12,1621.195000,0,142.197,311.018,91.068,0,0
+395,6,50,2,1350.909000,0,203.326,272.78,98.027,0,0
+395,6,50,3,2124.760000,0,209.196,25.4635,111.555,0,0
+395,6,50,4,2137.857000,0,212.747,25.4855,115.766,0,0
+395,6,50,5,1739.711000,0,202.653,20.169,90.6985,0,0
+395,6,50,6,2227.316000,0,212.291,28.401,117.737,0,0
+395,6,50,7,1976.772000,0,282.14,20.2575,101.45,0,0
+395,6,50,8,1963.044000,0,170.618,293.566,116.48,0,0
+395,6,50,9,2165.618000,0,322.922,261.868,116.678,0,0
+395,6,50,10,1949.472000,0,152.686,382.245,115.002,0,0
+395,6,50,11,2276.553000,0,315.105,314.741,117.215,0,0
+395,6,50,12,1955.101000,0,141.803,378.732,116.056,0,0
+395,6,75,2,1346.670000,0,203.429,270.659,98.0795,0,0
+395,6,75,3,1747.437000,0,202.597,19.9695,90.4655,0,0
+395,6,75,4,1742.203000,0,201.253,20.054,91.1335,0,0
+395,6,75,5,1730.250000,0,201.376,20.157,90.4905,0,0
+395,6,75,6,1734.936000,0,200.357,20.2025,90.947,0,0
+395,6,75,7,1877.662000,0,259.433,20.2445,91.433,0,0
+395,6,75,8,1632.848000,0,170.694,254.632,90.804,0,0
+395,6,75,9,2142.006000,0,332.026,235.69,117.002,0,0
+395,6,75,10,1764.884000,0,152.321,341.581,91.932,0,0
+395,6,75,11,1771.415000,0,247.91,289.915,93.298,0,0
+395,6,75,12,1948.118000,0,142.015,378.803,116.114,0,0
+395,6,100,2,1353.227000,0,202.975,273.389,98.5045,0,0
+395,6,100,3,1943.074000,0,206.391,22.603,105.864,0,0
+395,6,100,4,1750.669000,0,202.196,20.072,90.8585,0,0
+395,6,100,5,1741.931000,0,202.938,20.2425,90.7695,0,0
+395,6,100,6,2320.943000,0,236.828,26.407,116.434,0,0
+395,6,100,7,2169.722000,0,332.258,20.7225,115.994,0,0
+395,6,100,8,1883.336000,0,169.9,275.065,116.151,0,0
+395,6,100,9,2262.878000,0,321.533,269.454,116.687,0,0
+395,6,100,10,2089.755000,0,174.817,396.923,116.327,0,0
+395,6,100,11,2072.984000,0,284.653,307.649,115.929,0,0
+395,6,100,12,1933.103000,0,141.931,396.071,115.296,0,0
+395,12,0,2,1459.816000,0,256.55,270.888,100.083,0,0
+395,12,0,3,1855.136000,0,255.11,19.942,91.0025,0,0
+395,12,0,4,1856.482000,0,257.083,19.9715,91.4165,0,0
+395,12,0,5,1842.013000,0,254.205,20.0645,91.7935,0,0
+395,12,0,6,2119.404000,0,261.396,20.4175,115.755,0,0
+395,12,0,7,2071.853000,0,305.62,20.3225,92.664,0,0
+395,12,0,8,2091.085000,0,239.699,308.85,110.613,0,0
+395,12,0,9,2313.498000,0,346.951,270.045,116.869,0,0
+395,12,0,10,2118.630000,0,200.645,408.819,107.953,0,0
+395,12,0,11,2193.711000,0,367.302,306.431,115.568,0,0
+395,12,0,12,1971.534000,0,164.029,387.061,115.01,0,0
+395,12,25,2,1575.580000,0,280.287,311.332,98.4815,0,0
+395,12,25,3,1911.666000,0,280.776,53.9105,91.1425,0,0
+395,12,25,4,2309.115000,0,289.176,63.4615,118.216,0,0
+395,12,25,5,2392.366000,0,295.926,67.044,117.675,0,0
+395,12,25,6,1901.884000,0,279.655,53.6755,90.836,0,0
+395,12,25,7,2490.346000,0,401.991,57.094,116.903,0,0
+395,12,25,8,2000.497000,0,220.075,311.813,116.262,0,0
+395,12,25,9,2117.957000,0,346.028,247.361,114.8,0,0
+395,12,25,10,2083.278000,0,189.492,404.057,115.927,0,0
+395,12,25,11,2178.739000,0,357.125,315.398,117.589,0,0
+395,12,25,12,2113.941000,0,172.639,412.838,116.718,0,0
+395,12,50,2,1831.881000,0,336.504,377.716,100.564,0,0
+395,12,50,3,2618.202000,0,362.998,153.403,118.133,0,0
+395,12,50,4,2638.342000,0,367.927,153.945,118.601,0,0
+395,12,50,5,2189.668000,0,338.558,115.245,116.657,0,0
+395,12,50,6,2828.621000,0,438.284,153.238,119.006,0,0
+395,12,50,7,2564.292000,0,474.558,119.538,117.775,0,0
+395,12,50,8,1749.003000,0,246.536,322.999,90.5255,0,0
+395,12,50,9,2229.410000,0,414.233,264.009,116.862,0,0
+395,12,50,10,1947.524000,0,210.022,451.354,111.487,0,0
+395,12,50,11,1892.300000,0,356.357,342.917,90.8285,0,0
+395,12,50,12,2043.720000,0,189.188,458.22,115.434,0,0
+395,12,75,2,1934.387000,0,359.569,406.311,99.3245,0,0
+395,12,75,3,2196.645000,0,365.16,149.712,94.4875,0,0
+395,12,75,4,2148.053000,0,359.089,145.446,91.9305,0,0
+395,12,75,5,2843.611000,0,394.076,197.897,118.239,0,0
+395,12,75,6,2240.015000,0,360.029,145.29,115.017,0,0
+395,12,75,7,2544.315000,0,451.839,148.829,115.883,0,0
+395,12,75,8,2010.329000,0,264.64,371.928,109.544,0,0
+395,12,75,9,2384.461000,0,426.098,369.991,117.764,0,0
+395,12,75,10,2044.359000,0,220.811,449.402,115.651,0,0
+395,12,75,11,2257.906000,0,404.955,377.139,116.907,0,0
+395,12,75,12,2050.492000,0,209.268,465.545,114.226,0,0
+395,12,100,2,2183.960000,0,413.747,471.578,99.828,0,0
+395,12,100,3,2384.107000,0,414.24,207.152,92.1115,0,0
+395,12,100,4,2390.608000,0,414.932,208.192,92.178,0,0
+395,12,100,5,2371.224000,0,413.609,205.725,91.5325,0,0
+395,12,100,6,2430.153000,0,413.137,206.739,110.08,0,0
+395,12,100,7,2950.801000,0,619.575,210.355,119.503,0,0
+395,12,100,8,2110.008000,0,316.819,419.015,99.909,0,0
+395,12,100,9,2084.115000,0,446.287,316.394,91.3055,0,0
+395,12,100,10,1991.115000,0,242.015,471.864,110.037,0,0
+395,12,100,11,2234.590000,0,484.443,388.117,108.035,0,0
+395,12,100,12,1725.536000,0,214.17,403.38,90.7875,0,0
+395,24,0,2,1639.989000,0,361.32,261.448,96.1615,0,0
+395,24,0,3,2103.166000,0,361.404,20.5875,95.8795,0,0
+395,24,0,4,2552.327000,0,368.114,28.1075,117.957,0,0
+395,24,0,5,2092.099000,0,360.619,20.7075,92.7235,0,0
+395,24,0,6,2441.577000,0,364.633,25.1985,117.599,0,0
+395,24,0,7,2192.649000,0,371.917,20.7245,114.137,0,0
+395,24,0,8,1806.898000,0,274.921,257.5,93.3315,0,0
+395,24,0,9,2269.505000,0,396.648,264.187,117.551,0,0
+395,24,0,10,2094.279000,0,232.62,408.463,116.891,0,0
+395,24,0,11,2238.497000,0,340.524,304.963,109.248,0,0
+395,24,0,12,2205.452000,0,239.805,495.966,117.336,0,0
+395,24,25,2,2155.785000,0,466.01,409.369,99.792,0,0
+395,24,25,3,2564.785000,0,472.307,163.425,106.711,0,0
+395,24,25,4,2352.598000,0,462.248,145.54,90.8185,0,0
+395,24,25,5,2691.712000,0,541.11,145.546,116.161,0,0
+395,24,25,6,2349.938000,0,465.716,145.136,91.518,0,0
+395,24,25,7,2516.958000,0,513.955,150.137,92.705,0,0
+395,24,25,8,2228.725000,0,337.289,390.245,117.193,0,0
+395,24,25,9,2536.317000,0,483.204,401.781,117.116,0,0
+395,24,25,10,1853.631000,0,273.091,409.64,91.0685,0,0
+395,24,25,11,2305.174000,0,449.946,364.938,117.185,0,0
+395,24,25,12,2133.613000,0,266.577,436.579,117.654,0,0
+395,24,50,2,2788.651000,0,622.232,560.378,100.781,0,0
+395,24,50,3,3002.032000,0,616.279,304.106,94.465,0,0
+395,24,50,4,2979.269000,0,619.744,298.183,86.167,0,0
+395,24,50,5,3911.775000,0,744.535,422.398,119.721,0,0
+395,24,50,6,3734.809000,0,663.143,424.494,119.205,0,0
+395,24,50,7,3207.107000,0,694.677,304.169,92.934,0,0
+395,24,50,8,2341.337000,0,422.753,465.513,116.27,0,0
+395,24,50,9,2583.974000,0,606.853,385.032,117.368,0,0
+395,24,50,10,1921.594000,0,328.551,493.656,90.1475,0,0
+395,24,50,11,2423.060000,0,524.351,442.365,116.548,0,0
+395,24,50,12,1954.706000,0,280.921,451.563,105.714,0,0
+395,24,75,2,3216.203000,0,705.956,684.863,100.554,0,0
+395,24,75,3,3486.686000,0,707.48,442.225,95.992,0,0
+395,24,75,4,3461.625000,0,712.72,427.823,93.5945,0,0
+395,24,75,5,3491.883000,0,710.457,419.631,115.398,0,0
+395,24,75,6,3414.774000,0,709.226,418.217,93.8745,0,0
+395,24,75,7,3940.430000,0,831.238,453.488,118.057,0,0
+395,24,75,8,2523.119000,0,486.478,545.73,115.263,0,0
+395,24,75,9,2598.430000,0,672.334,467.318,91.473,0,0
+395,24,75,10,2022.882000,0,385.558,548.338,91.7565,0,0
+395,24,75,11,2669.803000,0,616.729,551.766,117.411,0,0
+395,24,75,12,1869.334000,0,316.055,485.743,90.991,0,0
+395,24,100,2,3901.148000,0,880.812,845.36,100.38,0,0
+395,24,100,3,4209.905000,0,878.051,612.71,100.392,0,0
+395,24,100,4,4091.569000,0,880.901,573.893,93.173,0,0
+395,24,100,5,4723.892000,0,886.93,748.231,121.987,0,0
+395,24,100,6,4483.694000,0,947.258,589.345,117.085,0,0
+395,24,100,7,4913.337000,0,1118.15,625.77,98.1235,0,0
+395,24,100,8,2698.333000,0,598.168,646.053,92.0685,0,0
+395,24,100,9,3057.743000,0,826.737,561.307,93.2605,0,0
+395,24,100,10,2833.499000,0,543.723,864.376,117.304,0,0
+395,24,100,11,2505.900000,0,708.572,549.437,92.18,0,0
+395,24,100,12,2344.725000,0,404.533,611.834,117.076,0,0
+395,48,0,2,2095.854000,0,569.083,276.4,100.256,0,0
+395,48,0,3,2799.754000,0,577.141,22.8845,114.755,0,0
+395,48,0,4,2468.906000,0,570.944,20.086,87.2395,0,0
+395,48,0,5,2718.553000,0,620.623,20.2595,93.9965,0,0
+395,48,0,6,2616.546000,0,572.371,20.2305,116.056,0,0
+395,48,0,7,2424.077000,0,516.08,20.3585,117.131,0,0
+395,48,0,8,2317.988000,0,422.206,283.664,116.859,0,0
+395,48,0,9,2339.575000,0,499.439,223.398,116.187,0,0
+395,48,0,10,1889.101000,0,336.449,337.611,91.3935,0,0
+395,48,0,11,2339.764000,0,456.289,326.211,117.239,0,0
+395,48,0,12,2122.507000,0,290.271,370.542,115.793,0,0
+395,48,25,2,3334.013000,0,850.559,600.955,103.394,0,0
+395,48,25,3,4056.468000,0,850.09,454.216,119.842,0,0
+395,48,25,4,3583.026000,0,851.181,348.187,97.13,0,0
+395,48,25,5,3516.397000,0,850.199,329.606,93.896,0,0
+395,48,25,6,3520.944000,0,860.391,326.797,92.342,0,0
+395,48,25,7,3662.449000,0,892.643,331.145,118.259,0,0
+395,48,25,8,2414.906000,0,578.94,468.45,91.445,0,0
+395,48,25,9,2880.284000,0,772.026,418.939,118.479,0,0
+395,48,25,10,2478.415000,0,514.51,553.351,117.592,0,0
+395,48,25,11,2608.551000,0,717.288,471.554,108.591,0,0
+395,48,25,12,2242.610000,0,406.579,502.916,111.28,0,0
+395,48,50,2,4718.826000,0,1178.64,945.099,106.523,0,0
+395,48,50,3,4869.194000,0,1179.43,661.726,93.0195,0,0
+395,48,50,4,4854.372000,0,1168.9,663.651,93.034,0,0
+395,48,50,5,5211.637000,0,1312.9,664.113,118.883,0,0
+395,48,50,6,4935.758000,0,1175.9,665.232,119.071,0,0
+395,48,50,7,5465.009000,0,1411.53,674.034,120.706,0,0
+395,48,50,8,3704.790000,0,841.562,874.001,119.146,0,0
+395,48,50,9,3711.243000,0,1056.57,646.897,114.284,0,0
+395,48,50,10,2431.106000,0,593.548,680.9,92.6725,0,0
+395,48,50,11,3096.803000,0,866.481,674.768,120.611,0,0
+395,48,50,12,2714.194000,0,519.764,721.637,117.479,0,0
+395,48,75,2,5831.213000,0,1414.72,1252.62,104.49,0,0
+395,48,75,3,6007.522000,0,1410.08,973.007,94.277,0,0
+395,48,75,4,5995.464000,0,1402.98,975.814,93.239,0,0
+395,48,75,5,5923.885000,0,1392.01,965.23,94.557,0,0
+395,48,75,6,6945.668000,0,1504.28,1165.11,123.726,0,0
+395,48,75,7,6628.007000,0,1598.12,979.968,96.6,0,0
+395,48,75,8,4161.409000,0,1082.63,1052.27,120.784,0,0
+395,48,75,9,4010.764000,0,1231.08,833.879,92.873,0,0
+395,48,75,10,3116.232000,0,810.367,876.663,118.367,0,0
+395,48,75,11,3518.998000,0,1095.8,803.587,118.507,0,0
+395,48,75,12,2966.497000,0,649.131,1012.66,118.755,0,0
+395,48,100,2,7367.644000,0,1825.74,1590.42,107.839,0,0
+395,48,100,3,8523.819000,0,1813.74,1684.32,124.695,0,0
+395,48,100,4,8137.964000,0,1819.21,1498.72,124.676,0,0
+395,48,100,5,7476.306000,0,1810.84,1302.84,94.522,0,0
+395,48,100,6,7482.702000,0,1818.31,1299.53,95.0575,0,0
+395,48,100,7,8480.694000,0,2178.84,1305.82,109.695,0,0
+395,48,100,8,4962.832000,0,1350.59,1305.33,120.866,0,0
+395,48,100,9,5033.703000,0,1587.41,1039.1,121.368,0,0
+395,48,100,10,3222.417000,0,885.538,1005.15,92.569,0,0
+395,48,100,11,4153.083000,0,1432.2,948.491,119.647,0,0
+395,48,100,12,2867.038000,0,746.542,890.177,111.131,0,0
+395,96,0,2,2934.745000,0,975.82,285.393,104.292,0,0
+395,96,0,3,3722.875000,0,997.675,24.7425,119.143,0,0
+395,96,0,4,3579.717000,0,989.104,21.2705,114.276,0,0
+395,96,0,5,3749.775000,0,1087.94,23.4485,110.116,0,0
+395,96,0,6,3289.465000,0,976.597,20.331,91.163,0,0
+395,96,0,7,2666.939000,0,780.658,20.322,91.1425,0,0
+395,96,0,8,2430.340000,0,692.896,253.249,92.6575,0,0
+395,96,0,9,2256.126000,0,676.825,205.872,84.4955,0,0
+395,96,0,10,2804.789000,0,662.666,473.934,117.751,0,0
+395,96,0,11,2689.338000,0,767.384,320.339,115.798,0,0
+395,96,0,12,2620.871000,0,493.445,487.959,118.457,0,0
+395,96,25,2,5681.418000,0,1619.13,985.733,105.814,0,0
+395,96,25,3,5936.851000,0,1628.06,729.106,99.6185,0,0
+395,96,25,4,6092.729000,0,1702.94,728.648,98.1,0,0
+395,96,25,5,6682.354000,0,1652.77,936.677,123.528,0,0
+395,96,25,6,6061.286000,0,1622.04,710.711,119.574,0,0
+395,96,25,7,5771.986000,0,1625.24,694.465,98.238,0,0
+395,96,25,8,3698.008000,0,1094.15,734.408,117.299,0,0
+395,96,25,9,3715.480000,0,1243.47,646.895,97.0015,0,0
+395,96,25,10,3316.532000,0,922.786,800.075,116.087,0,0
+395,96,25,11,3379.941000,0,1080.65,645.708,118.818,0,0
+395,96,25,12,2993.694000,0,727.395,832.92,118.329,0,0
+395,96,50,2,8546.823000,0,2299.91,1701.66,107.222,0,0
+395,96,50,3,8691.978000,0,2320.72,1391.84,95.862,0,0
+395,96,50,4,9646.260000,0,2294.95,1758.44,124.619,0,0
+395,96,50,5,8677.801000,0,2307.15,1398.02,96.4925,0,0
+395,96,50,6,8623.420000,0,2290.06,1398.73,90.4865,0,0
+395,96,50,7,9642.915000,0,2613.73,1469.37,98.7875,0,0
+395,96,50,8,5231.026000,0,1588.51,1257.85,121.783,0,0
+395,96,50,9,5966.407000,0,1857.12,1368.71,123.636,0,0
+395,96,50,10,3935.490000,0,1135.16,1208.73,119.569,0,0
+395,96,50,11,4568.302000,0,1716.08,983.73,120.531,0,0
+395,96,50,12,3161.044000,0,951.611,916.064,113.859,0,0
+395,96,75,2,10957.959000,0,2802.3,2367.62,110.266,0,0
+395,96,75,3,13082.870000,0,2924,2751.26,125.164,0,0
+395,96,75,4,11736.979000,0,2796.85,2281.6,125.851,0,0
+395,96,75,5,11779.672000,0,2805.4,2296.31,125.707,0,0
+395,96,75,6,11093.473000,0,2791.91,2057.25,95.8365,0,0
+395,96,75,7,12037.270000,0,3164.48,2062.49,97.085,0,0
+395,96,75,8,6330.420000,0,1893.59,1711.58,99.46,0,0
+395,96,75,9,7219.510000,0,2430.49,1632.79,95.293,0,0
+395,96,75,10,4595.736000,0,1500.76,1402.25,93.9005,0,0
+395,96,75,11,5611.921000,0,2033.72,1357.71,104.916,0,0
+395,96,75,12,3946.947000,0,1161.53,1351.73,120.96,0,0
+395,96,100,2,14113.085000,0,3640.97,3071.81,110.729,0,0
+395,96,100,3,15384.242000,0,3663.38,3185.66,123.681,0,0
+395,96,100,4,14522.191000,0,3636.32,2871.47,111.871,0,0
+395,96,100,5,14259.050000,0,3654.59,2778.91,95.846,0,0
+395,96,100,6,14187.626000,0,3627.87,2768.18,93.4515,0,0
+395,96,100,7,16143.299000,0,4306.59,2791.55,124.136,0,0
+395,96,100,8,8072.724000,0,2506.24,2199.15,123.359,0,0
+395,96,100,9,8850.024000,0,3050.45,2004.91,96.4985,0,0
+395,96,100,10,5526.483000,0,1744.21,1786.22,121.115,0,0
+395,96,100,11,6853.540000,0,2626.69,1684.11,123.132,0,0
+395,96,100,12,4654.352000,0,1483.24,1618.67,122.095,0,0
+395,192,0,2,4601.707000,0,1801.37,292.285,104.803,0,0
+395,192,0,3,5321.093000,0,1820.99,21.536,120.045,0,0
+395,192,0,4,5314.946000,0,1821.8,21.6505,121.508,0,0
+395,192,0,5,5365.572000,0,1810.46,24.2765,121.07,0,0
+395,192,0,6,4971.515000,0,1817.99,20.398,88.2525,0,0
+395,192,0,7,3699.609000,0,1351.45,20.675,117.685,0,0
+395,192,0,8,3614.425000,0,1252.83,292.637,109.877,0,0
+395,192,0,9,2890.936000,0,1099.59,207.927,91.78,0,0
+395,192,0,10,2915.832000,0,962.074,374.621,108.655,0,0
+395,192,0,11,2984.722000,0,938.975,311.515,115.098,0,0
+395,192,0,12,3074.387000,0,871.105,525.565,117.826,0,0
+395,192,25,2,10310.054000,0,3146.94,1731.36,109.915,0,0
+395,192,25,3,10431.343000,0,3148.35,1431.63,95.9595,0,0
+395,192,25,4,10380.849000,0,3115.73,1432.58,95.642,0,0
+395,192,25,5,10437.363000,0,3148.89,1415.83,121.573,0,0
+395,192,25,6,10401.804000,0,3154.39,1417.57,95.769,0,0
+395,192,25,7,10329.309000,0,3163.93,1421.29,124.156,0,0
+395,192,25,8,6017.192000,0,2122.61,1240.61,120.941,0,0
+395,192,25,9,6023.373000,0,2269.01,1133.72,95.715,0,0
+395,192,25,10,4596.630000,0,1701.62,1118.73,120.495,0,0
+395,192,25,11,5434.874000,0,2289.48,1033.8,118.976,0,0
+395,192,25,12,3398.469000,0,1288.57,896.524,93.0195,0,0
+395,192,50,2,16083.744000,0,4541.35,3154.44,110.42,0,0
+395,192,50,3,16147.581000,0,4533.83,2836.89,96.1765,0,0
+395,192,50,4,16304.141000,0,4550.91,2888.24,97.1435,0,0
+395,192,50,5,16393.503000,0,4535.63,2942.93,101.126,0,0
+395,192,50,6,16223.645000,0,4534.02,2853.15,119.499,0,0
+395,192,50,7,17292.386000,0,4922.3,2879.12,123.915,0,0
+395,192,50,8,9076.206000,0,3053.94,2264.77,118.421,0,0
+395,192,50,9,10186.754000,0,3534.76,2382.7,115.68,0,0
+395,192,50,10,6666.921000,0,2206.08,2170.19,123.888,0,0
+395,192,50,11,7055.462000,0,2751.42,1737.25,123.412,0,0
+395,192,50,12,5239.035000,0,1848.13,1708.4,121.861,0,0
+395,192,75,2,21072.768000,0,5574.28,4553.35,109.61,0,0
+395,192,75,3,21858.414000,0,5581.22,4457.48,126.793,0,0
+395,192,75,4,21961.759000,0,5587.23,4493.41,125.997,0,0
+395,192,75,5,21158.076000,0,5561.34,4252.21,94.257,0,0
+395,192,75,6,21249.052000,0,5574.58,4248.29,121.756,0,0
+395,192,75,7,23362.033000,0,6341.21,4282.8,124.719,0,0
+395,192,75,8,11380.231000,0,3735.49,3182.02,97.0275,0,0
+395,192,75,9,12998.198000,0,4720.18,3022.06,96.343,0,0
+395,192,75,10,8245.965000,0,2969.44,2552.22,122.941,0,0
+395,192,75,11,9877.774000,0,3950.98,2459.71,123.393,0,0
+395,192,75,12,6515.535000,0,2260.25,2301.27,124.161,0,0
+395,192,100,2,27529.643000,0,7262.41,6010.27,109.576,0,0
+395,192,100,3,27598.985000,0,7279.7,5674.37,97.3525,0,0
+395,192,100,4,27498.321000,0,7266.98,5648.89,96.0555,0,0
+395,192,100,5,27741.426000,0,7243.2,5782.25,95.7735,0,0
+395,192,100,6,27540.738000,0,7269.04,5665.75,96.0405,0,0
+395,192,100,7,31607.270000,0,8637.63,5775.18,121.668,0,0
+395,192,100,8,14780.799000,0,4910.25,4170.31,121.134,0,0
+395,192,100,9,16914.990000,0,6017.62,4022.35,123.05,0,0
+395,192,100,10,9951.033000,0,3479.85,3313.68,126.08,0,0
+395,192,100,11,11870.378000,0,4636.75,3236.94,120.245,0,0
+395,192,100,12,7733.293000,0,2947.75,2646.85,96.5,0,0
+395,384,0,2,7977.679000,0,3464.34,311.764,109.026,0,0
+395,384,0,3,8339.067000,0,3474.68,20.217,94.0095,0,0
+395,384,0,4,8277.756000,0,3445.4,20.414,93.475,0,0
+395,384,0,5,8681.634000,0,3487.37,23.1455,123.548,0,0
+395,384,0,6,8621.840000,0,3458.18,23.384,123.874,0,0
+395,384,0,7,5217.864000,0,2464.76,20.5815,94.472,0,0
+395,384,0,8,5214.191000,0,2345.16,278.082,120.206,0,0
+395,384,0,9,3997.911000,0,1925.18,209.298,92.6855,0,0
+395,384,0,10,4153.470000,0,1791.09,401.018,116.309,0,0
+395,384,0,11,3444.276000,0,1548.7,295.14,95.257,0,0
+395,384,0,12,3284.650000,0,1460.86,312.315,91.4355,0,0
+395,384,25,2,19503.331000,0,6205.31,3198.11,109.01,0,0
+395,384,25,3,19698.786000,0,6244.68,2891.12,94.8075,0,0
+395,384,25,4,20886.600000,0,6264.46,3334.97,125.154,0,0
+395,384,25,5,19653.173000,0,6238.55,2884.92,95.2715,0,0
+395,384,25,6,19692.151000,0,6233.69,2891,96.1435,0,0
+395,384,25,7,18988.804000,0,6066.75,2864.48,120.948,0,0
+395,384,25,8,11088.169000,0,4197.45,2479.72,124.771,0,0
+395,384,25,9,10852.805000,0,4371.07,2132.31,97.6375,0,0
+395,384,25,10,7897.380000,0,3057.26,2211.17,124.561,0,0
+395,384,25,11,7996.507000,0,3458.41,1760.77,122.872,0,0
+395,384,25,12,6195.100000,0,2600.54,1710.63,122.435,0,0
+395,384,50,2,31138.416000,0,9016.73,6067.99,111.642,0,0
+395,384,50,3,31854.640000,0,9109.63,5924.08,110.382,0,0
+395,384,50,4,31347.939000,0,9022.97,5793.02,96.989,0,0
+395,384,50,5,31208.401000,0,9006.88,5749.44,96.547,0,0
+395,384,50,6,31246.669000,0,9020.24,5768.51,96.093,0,0
+395,384,50,7,33444.245000,0,9756.6,5850.53,125.698,0,0
+395,384,50,8,16527.071000,0,6062.47,4231.59,96.1005,0,0
+395,384,50,9,18055.540000,0,6887.93,4032.04,96.302,0,0
+395,384,50,10,11517.792000,0,4425.08,3529.46,120.802,0,0
+395,384,50,11,12742.611000,0,5328.13,3228.8,118.555,0,0
+395,384,50,12,8685.851000,0,3646.53,2707.65,96.393,0,0
+395,384,75,2,41332.158000,0,11124.9,8918.13,109.91,0,0
+395,384,75,3,41451.130000,0,11124.2,8617.51,96.884,0,0
+395,384,75,4,41411.856000,0,11097,8627.32,96.1485,0,0
+395,384,75,5,41664.967000,0,11139.1,8712.31,95.816,0,0
+395,384,75,6,41500.083000,0,11116,8639.95,97.386,0,0
+395,384,75,7,45426.090000,0,12595.9,8607.51,123.94,0,0
+395,384,75,8,21577.843000,0,7428.11,6157.51,95.867,0,0
+395,384,75,9,25006.736000,0,9283.46,5983.08,123.75,0,0
+395,384,75,10,15211.662000,0,5921.36,4775.06,98.68,0,0
+395,384,75,11,18509.026000,0,7732.51,4835.4,124.387,0,0
+395,384,75,12,11515.651000,0,4498.16,3942.92,128.605,0,0
+395,384,100,2,54497.060000,0,14693.5,11802.2,114.299,0,0
+395,384,100,3,56747.048000,0,14732.5,12351.3,127.398,0,0
+395,384,100,4,54319.104000,0,14544.4,11511.4,97.0645,0,0
+395,384,100,5,54301.686000,0,14554.2,11498.3,96.32,0,0
+395,384,100,6,54588.808000,0,14590.7,11582.3,96.499,0,0
+395,384,100,7,61856.814000,0,17190.4,11624,96.9515,0,0
+395,384,100,8,28082.903000,0,9753.81,8078.04,96.376,0,0
+395,384,100,9,32531.092000,0,11863.3,7850.66,96.3605,0,0
+395,384,100,10,18727.190000,0,6925.67,6305.58,122.722,0,0
+395,384,100,11,22264.157000,0,9110.15,6139.31,97.583,0,0
+395,384,100,12,14471.432000,0,5835.11,5034.71,94.472,0,0
+395,768,0,2,14729.729000,0,6832.49,317.39,110.245,0,0
+395,768,0,3,14858.224000,0,6738.95,19.8745,95.414,0,0
+395,768,0,4,15345.196000,0,6827.16,21.742,125.978,0,0
+395,768,0,5,15359.475000,0,6906.74,20.5795,121.593,0,0
+395,768,0,6,15424.268000,0,6834.73,24.805,122.937,0,0
+395,768,0,7,8709.976000,0,4671.07,20.4865,120.051,0,0
+395,768,0,8,9736.867000,0,4944.69,653.924,121.894,0,0
+395,768,0,9,6249.027000,0,3585.09,211.376,94.6675,0,0
+395,768,0,10,6696.952000,0,3497.27,539.475,120.954,0,0
+395,768,0,11,5095.723000,0,2885.07,296.362,92.9885,0,0
+395,768,0,12,5338.446000,0,2771.04,407.579,124.701,0,0
+395,768,25,2,38004.471000,0,12401.7,6113.03,108.151,0,0
+395,768,25,3,38473.200000,0,12414.5,5908.53,118.004,0,0
+395,768,25,4,37848.694000,0,12257.6,5822.64,95.579,0,0
+395,768,25,5,38190.741000,0,12394.4,5857.93,96.9145,0,0
+395,768,25,6,38042.486000,0,12353.5,5812.18,121.19,0,0
+395,768,25,7,36751.255000,0,12065.6,5806.57,98.063,0,0
+395,768,25,8,19672.997000,0,8198.52,4198.16,97.6015,0,0
+395,768,25,9,20433.719000,0,8576.06,4073.24,123.155,0,0
+395,768,25,10,13287.304000,0,6028.48,3302.9,98.0465,0,0
+395,768,25,11,14408.981000,0,6688.02,3220.73,109.568,0,0
+395,768,25,12,10314.660000,0,4967.2,2690.04,96.783,0,0
+395,768,50,2,61267.000000,0,18012.3,11854.6,111.52,0,0
+395,768,50,3,62860.217000,0,18044.3,12186.2,110.748,0,0
+395,768,50,4,62170.511000,0,17994,11841.6,124.942,0,0
+395,768,50,5,61765.899000,0,18013.4,11720.8,121.394,0,0
+395,768,50,6,61488.155000,0,17975.5,11628.3,122.871,0,0
+395,768,50,7,65788.404000,0,19500.8,11816.9,96.9035,0,0
+395,768,50,8,31649.420000,0,12007.9,8200.4,97.3045,0,0
+395,768,50,9,34863.549000,0,13559,7934.7,121.1,0,0
+395,768,50,10,20921.693000,0,8613.69,6310.58,97.7115,0,0
+395,768,50,11,24045.746000,0,10416.9,6244.46,97.4555,0,0
+395,768,50,12,17321.339000,0,7230.12,5856.24,126.095,0,0
+395,768,75,2,81787.781000,0,22218.4,17639.6,110.86,0,0
+395,768,75,3,81835.384000,0,22177.2,17344.8,96.3895,0,0
+395,768,75,4,81827.735000,0,22146.8,17360.1,95.992,0,0
+395,768,75,5,83221.466000,0,22428.5,17674.9,125.844,0,0
+395,768,75,6,81784.946000,0,22150.4,17334.2,118.951,0,0
+395,768,75,7,89503.710000,0,24983.8,17379.2,122.589,0,0
+395,768,75,8,42480.337000,0,14921.5,12266.9,126.948,0,0
+395,768,75,9,49848.334000,0,18453.1,12475.6,127.254,0,0
+395,768,75,10,29302.443000,0,11761.7,9318.21,95.694,0,0
+395,768,75,11,36296.353000,0,15090.2,10097.9,128.278,0,0
+395,768,75,12,22136.128000,0,8917.77,7951.38,125.95,0,0
+395,768,100,2,107661.626000,0,29122.3,23377.6,109.939,0,0
+395,768,100,3,107611.139000,0,29053.6,23099.5,95.9655,0,0
+395,768,100,4,112820.109000,0,29508.3,25021.5,121.273,0,0
+395,768,100,5,107493.551000,0,29030.8,23056.7,96.4985,0,0
+395,768,100,6,108587.512000,0,29172.7,23334.1,126.186,0,0
+395,768,100,7,122685.637000,0,34394.4,23289,95.3195,0,0
+395,768,100,8,54880.282000,0,19414.3,15942.1,93.1575,0,0
+395,768,100,9,64392.251000,0,23675.9,15921.2,96.4135,0,0
+395,768,100,10,36444.141000,0,13890.1,12405.1,96.7545,0,0
+395,768,100,11,43617.494000,0,17961,12320.6,98.1945,0,0
+395,768,100,12,27992.085000,0,11674.8,9766.62,119.654,0,0
+395,1536,0,2,28050.279000,0,13485.1,319.073,113.756,0,0
+395,1536,0,3,28189.627000,0,13399.2,20.3855,93.6465,0,0
+395,1536,0,4,28567.375000,0,13589.3,20.106,96.287,0,0
+395,1536,0,5,28790.115000,0,13700.8,20.1985,96.2975,0,0
+395,1536,0,6,27878.632000,0,13249.3,20.302,96.1905,0,0
+395,1536,0,7,15917.209000,0,9460.31,20.881,123.598,0,0
+395,1536,0,8,15312.786000,0,9010.46,332.103,123.014,0,0
+395,1536,0,9,10711.672000,0,6889.3,215.259,95.1135,0,0
+395,1536,0,10,10440.211000,0,6693.92,343.196,96.7705,0,0
+395,1536,0,11,8434.146000,0,5538.5,299.306,95.0475,0,0
+395,1536,0,12,8991.850000,0,5519.83,558.562,124.358,0,0
+395,1536,25,2,74586.110000,0,24610,11912.4,111.775,0,0
+395,1536,25,3,75803.693000,0,24673.4,12045,109.584,0,0
+395,1536,25,4,74600.770000,0,24573.6,11611.1,96.335,0,0
+395,1536,25,5,74293.834000,0,24441.3,11591.1,96.0755,0,0
+395,1536,25,6,74971.748000,0,24669,11606.6,122.607,0,0
+395,1536,25,7,72373.453000,0,23952.1,11684.7,122.656,0,0
+395,1536,25,8,38239.344000,0,16375.8,8191.14,123,0,0
+395,1536,25,9,39384.121000,0,16942.3,7954.93,96.6445,0,0
+395,1536,25,10,25501.891000,0,11920.3,6430.88,96.3195,0,0
+395,1536,25,11,28578.887000,0,13120,7018.9,127.593,0,0
+395,1536,25,12,20351.560000,0,9967.86,5505.24,121.156,0,0
+395,1536,50,2,121028.051000,0,35651.6,23526.5,110.813,0,0
+395,1536,50,3,121224.517000,0,35725.4,23213,96.1635,0,0
+395,1536,50,4,121530.989000,0,35846.8,23238.9,95.9605,0,0
+395,1536,50,5,121123.624000,0,35536.4,23338.5,95.288,0,0
+395,1536,50,6,122491.259000,0,35934.2,23505.6,126.905,0,0
+395,1536,50,7,129777.289000,0,39035.8,23247.1,95.235,0,0
+395,1536,50,8,61928.987000,0,23850.2,16185.6,97.8385,0,0
+395,1536,50,9,68454.114000,0,26918.9,15774.2,103.217,0,0
+395,1536,50,10,40835.146000,0,17141.2,12448.7,95.5335,0,0
+395,1536,50,11,48177.829000,0,20610.4,13158.8,124.296,0,0
+395,1536,50,12,31545.433000,0,14334.5,9922.14,96.1915,0,0
+395,1536,75,2,163533.789000,0,44567.1,35334.6,110.728,0,0
+395,1536,75,3,163343.185000,0,44426.2,34954,119.015,0,0
+395,1536,75,4,163685.559000,0,44602.9,34900.2,126.303,0,0
+395,1536,75,5,164795.224000,0,44603.2,35406.4,126.968,0,0
+395,1536,75,6,162652.510000,0,44297.8,34802.4,97.315,0,0
+395,1536,75,7,178779.516000,0,50161.7,35114.9,126.595,0,0
+395,1536,75,8,83756.372000,0,29947.9,24256.7,98.2155,0,0
+395,1536,75,9,96398.197000,0,36712,23590,97.127,0,0
+395,1536,75,10,57988.175000,0,23654.1,18428.2,125.07,0,0
+395,1536,75,11,68818.150000,0,29991.1,18188.2,96.9635,0,0
+395,1536,75,12,42003.151000,0,17775,14694,96.405,0,0
+395,1536,100,2,215707.623000,0,58136.8,47241.7,112.882,0,0
+395,1536,100,3,215701.805000,0,58649.7,46469.2,96.498,0,0
+395,1536,100,4,215631.200000,0,58273.1,46651.6,127.144,0,0
+395,1536,100,5,214957.871000,0,58228.6,46443.9,95.4615,0,0
+395,1536,100,6,214753.653000,0,58099.9,46515.6,121.511,0,0
+395,1536,100,7,244373.639000,0,68436.5,46902.6,96.337,0,0
+395,1536,100,8,109519.192000,0,38696.7,32281.3,122.995,0,0
+395,1536,100,9,127115.161000,0,47292,31244.6,97.4015,0,0
+395,1536,100,10,71945.522000,0,27533.3,24778.6,126.504,0,0
+395,1536,100,11,85353.700000,0,35672.4,24044.6,95.6895,0,0
+395,1536,100,12,55111.842000,0,23291.1,19433.3,94.121,0,0
+395,3072,0,2,26872.547000,0,13162.3,166.284,56.1735,0,0
+395,3072,0,3,26564.217000,0,12928.8,8.181,47.486,0,0
+395,3072,0,4,26487.477000,0,12888,8.535,48.0445,0,0
+395,3072,0,5,26973.539000,0,13134.6,8.309,46.293,0,0
+395,3072,0,6,26394.665000,0,12848.8,8.2415,47.061,0,0
+395,3072,0,7,14022.548000,0,8768.32,8.4775,60.5085,0,0
+395,3072,0,8,13697.947000,0,8621.57,153.849,46.9325,0,0
+395,3072,0,9,9707.221000,0,6609.54,105.757,60.517,0,0
+395,3072,0,10,9503.312000,0,6526.6,184.97,47.666,0,0
+395,3072,0,11,7617.231000,0,5271.83,162.958,60.5485,0,0
+395,3072,0,12,7628.278000,0,5256,274.984,60.51,0,0
+395,3072,25,2,71211.859000,0,23604.8,11355.3,56.1995,0,0
+395,3072,25,3,71920.774000,0,23859.3,11250.6,46.728,0,0
+395,3072,25,4,72020.497000,0,23762.3,11406.8,46.956,0,0
+395,3072,25,5,72368.342000,0,23831.1,11429.8,61.774,0,0
+395,3072,25,6,71797.628000,0,23917.7,11149.9,47.525,0,0
+395,3072,25,7,69125.895000,0,23188.4,11231.9,47.0405,0,0
+395,3072,25,8,36810.900000,0,15997.1,7896.6,61.3075,0,0
+395,3072,25,9,38135.158000,0,16335.9,7955.77,62.2975,0,0
+395,3072,25,10,24029.467000,0,11536.7,5962.69,47.545,0,0
+395,3072,25,11,26649.585000,0,12634.6,6360.27,61.7525,0,0
+395,3072,25,12,18694.162000,0,9575.75,4888,60.9195,0,0
+395,3072,50,2,116883.848000,0,34764.7,22503.3,55.8935,0,0
+395,3072,50,3,116886.218000,0,34470.3,22598.6,47.2245,0,0
+395,3072,50,4,116995.432000,0,34644,22482.7,47.9805,0,0
+395,3072,50,5,116973.326000,0,34709.8,22413.2,47.886,0,0
+395,3072,50,6,117144.959000,0,34615.5,22476.2,60.538,0,0
+395,3072,50,7,125945.148000,0,37792.8,22862,46.798,0,0
+395,3072,50,8,59091.993000,0,23128.9,15273.2,61.0265,0,0
+395,3072,50,9,66065.443000,0,26182.6,15248.1,47.4025,0,0
+395,3072,50,10,39322.208000,0,16746.3,11933.9,61.8925,0,0
+395,3072,50,11,44526.376000,0,19889.5,11440.8,60.3665,0,0
+395,3072,50,12,30244.211000,0,13878.4,9623.59,47.534,0,0
+395,3072,75,2,157327.800000,0,43123.7,33845.2,54.6955,0,0
+395,3072,75,3,165011.828000,0,43593.5,36747.6,62.47,0,0
+395,3072,75,4,157142.458000,0,42987.6,33612.5,62.4215,0,0
+395,3072,75,5,158664.773000,0,43048.7,34261.2,62.1855,0,0
+395,3072,75,6,157026.916000,0,42962.5,33645.9,47.453,0,0
+395,3072,75,7,171824.043000,0,48493.4,33591.1,47.635,0,0
+395,3072,75,8,79405.198000,0,28806.5,22773,47.215,0,0
+395,3072,75,9,92588.816000,0,35591.6,22559.9,47.1035,0,0
+395,3072,75,10,55016.598000,0,22849,17367.4,47.9025,0,0
+395,3072,75,11,65758.861000,0,28843.9,17252,60.8035,0,0
+395,3072,75,12,39894.922000,0,17221.5,13800.9,47.218,0,0
+395,3072,100,2,207184.106000,0,56160.3,45161,54.8125,0,0
+395,3072,100,3,207340.315000,0,56390.7,44823,54.621,0,0
+395,3072,100,4,207230.268000,0,56311.9,44794.5,62.06,0,0
+395,3072,100,5,208577.492000,0,56347.9,45306.3,48.174,0,0
+395,3072,100,6,210477.151000,0,56238.5,46406.6,61.7365,0,0
+395,3072,100,7,234721.764000,0,66388.5,44737.5,46.878,0,0
+395,3072,100,8,107391.687000,0,37861.8,31965.7,61.868,0,0
+395,3072,100,9,122777.291000,0,45750.6,30344.8,61.0135,0,0
+395,3072,100,10,68505.599000,0,26834.7,23190.4,47.6525,0,0
+395,3072,100,11,81923.968000,0,34563.4,22943.9,47.6005,0,0
+395,3072,100,12,52686.818000,0,22561.4,18458.5,61.7225,0,0
+395,6144,0,2,52646.173000,0,26055.8,162.622,53.7855,0,0
+395,6144,0,3,51865.699000,0,25586.9,8.1235,47.26,0,0
+395,6144,0,4,52719.289000,0,26007.5,8.4525,48.8345,0,0
+395,6144,0,5,52824.576000,0,26001.4,8.412,60.6405,0,0
+395,6144,0,6,52159.810000,0,25733.1,8.3835,47.47,0,0
+395,6144,0,7,27195.013000,0,17511.8,8.3365,60.428,0,0
+395,6144,0,8,26960.570000,0,17362.8,175.717,60.9345,0,0
+395,6144,0,9,18220.886000,0,13071.8,108.053,46.904,0,0
+395,6144,0,10,18473.349000,0,13118.3,205.686,61.282,0,0
+395,6144,0,11,14162.633000,0,10575.7,161.231,60.863,0,0
+395,6144,0,12,14251.578000,0,10432,357.43,59.271,0,0
+395,6144,25,2,143234.640000,0,47576.2,22816.9,54.612,0,0
+395,6144,25,3,142700.374000,0,47549,22427.9,54.131,0,0
+395,6144,25,4,144093.301000,0,47766,22894.1,47.2235,0,0
+395,6144,25,5,142568.144000,0,47468.7,22456.2,47.3005,0,0
+395,6144,25,6,142883.159000,0,47693.2,22359.2,48.0195,0,0
+395,6144,25,7,137259.479000,0,46025.7,22459.1,47.592,0,0
+395,6144,25,8,72914.816000,0,31737.7,15831.6,61.532,0,0
+395,6144,25,9,74231.822000,0,32429.4,15145.8,61.732,0,0
+395,6144,25,10,47633.143000,0,23075.4,11812.5,62.9725,0,0
+395,6144,25,11,51415.062000,0,25182.4,11555.7,62.3525,0,0
+395,6144,25,12,36392.771000,0,18977.3,9442.9,63.0235,0,0
+395,6144,50,2,233519.663000,0,69502.4,45023.6,54.4095,0,0
+395,6144,50,3,237842.940000,0,70316.9,46050.8,60.5825,0,0
+395,6144,50,4,233899.059000,0,69671.1,44800.2,47.7005,0,0
+395,6144,50,5,233930.987000,0,69678.5,44787.7,61.253,0,0
+395,6144,50,6,234587.807000,0,69947.5,44873,60.4625,0,0
+395,6144,50,7,248829.998000,0,75437.4,44873.1,61.3355,0,0
+395,6144,50,8,117801.006000,0,46371,30419,47.6565,0,0
+395,6144,50,9,130824.120000,0,52059.1,30181.6,47.1975,0,0
+395,6144,50,10,77157.924000,0,33326.8,23168.8,46.9605,0,0
+395,6144,50,11,89486.626000,0,39728.7,23671.6,61.1265,0,0
+395,6144,50,12,58907.682000,0,27600,18393.3,46.784,0,0
+395,6144,75,2,313490.290000,0,85936.8,67457.3,54.4225,0,0
+395,6144,75,3,313433.715000,0,86014.5,67222.9,47.097,0,0
+395,6144,75,4,314087.787000,0,85942.4,67567.6,62.1975,0,0
+395,6144,75,5,313537.377000,0,86216.3,67077.4,47.503,0,0
+395,6144,75,6,312888.875000,0,86003.2,66893.3,62.8505,0,0
+395,6144,75,7,345363.778000,0,97298.8,68111.6,46.5335,0,0
+395,6144,75,8,158294.241000,0,57476.7,45587.4,47.8705,0,0
+395,6144,75,9,185655.887000,0,71854.9,45039.2,60.393,0,0
+395,6144,75,10,109428.414000,0,45720.7,34470.7,46.95,0,0
+395,6144,75,11,130927.219000,0,57798.9,34477.1,59.6395,0,0
+395,6144,75,12,79913.556000,0,34445.8,27893.8,47.243,0,0
+395,6144,100,2,413164.963000,0,112767,89372.1,56.2135,0,0
+395,6144,100,3,413604.145000,0,112415,89828.9,48.997,0,0
+395,6144,100,4,416246.279000,0,112969,90463.5,62.5615,0,0
+395,6144,100,5,413932.216000,0,112771,89613.7,48.4495,0,0
+395,6144,100,6,415350.281000,0,113553,89561.9,58.7405,0,0
+395,6144,100,7,469647.367000,0,132644,89843,59.0625,0,0
+395,6144,100,8,209013.667000,0,75375.5,60801.5,50.1125,0,0
+395,6144,100,9,244350.339000,0,91738.8,59953,49.2285,0,0
+395,6144,100,10,136801.526000,0,53672.1,46479.6,61.5315,0,0
+395,6144,100,11,162888.572000,0,68900.4,45662.3,47.541,0,0
+395,6144,100,12,105252.654000,0,45188,37002.4,47.4885,0,0
+296,6,0,4,2167.595000,0,208.433,23.9605,143.827,21.082,0
+296,6,0,5,2439.423000,0,213.586,28.311,149.557,21.372,0
+296,6,0,6,1942.576000,0,203.084,20.349,137.555,21.0825,0
+296,6,0,7,2022.726000,0,259.771,20.432,123.043,21.253,0
+296,6,0,8,2142.746000,0,196.189,323.928,144.499,21.119,0
+296,6,0,9,2321.999000,0,335.419,259.803,148.952,30.836,0
+296,6,0,10,2169.289000,0,173.462,396.98,150.678,21.054,0
+296,6,0,11,2307.424000,0,316.123,332.906,149.622,21.134,0
+296,6,0,12,1795.157000,0,142.024,355.307,123.204,21.1055,0
+296,6,25,4,2285.629000,0,209.739,26.846,149.883,21.1025,0
+296,6,25,5,1866.052000,0,202.623,19.993,124.285,21.1025,0
+296,6,25,6,2274.594000,0,209.708,27.1155,148.783,21.105,0
+296,6,25,7,2224.541000,0,270.062,20.649,148.469,25.6425,0
+296,6,25,8,2390.197000,0,212.454,379.956,149.514,20.981,0
+296,6,25,9,2074.641000,0,298.575,235.705,130.153,21.202,0
+296,6,25,10,1818.748000,0,152.556,384.849,123.459,21.1415,0
+296,6,25,11,2316.539000,0,287.975,364.043,149.601,21.4105,0
+296,6,25,12,1781.043000,0,142.006,342.45,122.001,20.7535,0
+296,6,50,4,2014.602000,0,206.159,21.901,133.551,20.978,0
+296,6,50,5,1870.134000,0,201.521,20.149,123.578,20.986,0
+296,6,50,6,1992.582000,0,201.507,20.228,144.994,21.043,0
+296,6,50,7,2383.376000,0,321.192,20.489,160.692,20.9555,0
+296,6,50,8,2467.223000,0,214.118,422.809,162.688,29.6395,0
+296,6,50,9,2550.127000,0,349.226,269.951,156.342,21.576,0
+296,6,50,10,1817.832000,0,152.696,383.949,122.969,20.9005,0
+296,6,50,11,1924.726000,0,243.749,325.453,123.378,21.0875,0
+296,6,50,12,2147.280000,0,141.815,413.119,157.448,21.9565,0
+296,6,75,4,1911.029000,0,203.679,20.685,126.033,21.195,0
+296,6,75,5,2033.206000,0,201.807,20.3065,148.335,26.5855,0
+296,6,75,6,1870.558000,0,202.026,20.296,123.306,21.1345,0
+296,6,75,7,2252.442000,0,298.933,20.392,155.126,21.123,0
+296,6,75,8,2059.660000,0,169.905,297.424,148.617,20.997,0
+296,6,75,9,1964.024000,0,289.172,240.342,123.493,20.857,0
+296,6,75,10,1812.677000,0,152.443,385.419,122.712,35.532,0
+296,6,75,11,2664.906000,0,301.445,455.671,166.872,21.3785,0
+296,6,75,12,2186.124000,0,163.497,402.61,151.497,20.9935,0
+296,6,100,4,1875.456000,0,203.897,20.082,123.093,21.0815,0
+296,6,100,5,2088.430000,0,263.147,20.0535,139.697,27.8635,0
+296,6,100,6,2025.772000,0,202.41,20.246,147.042,20.834,0
+296,6,100,7,2101.731000,0,263.643,20.754,130.333,21.0475,0
+296,6,100,8,2165.377000,0,206.664,336.814,146.707,21.477,0
+296,6,100,9,2339.735000,0,316.249,286.008,150.048,21.7535,0
+296,6,100,10,1792.557000,0,152.737,380.99,121.489,25.008,0
+296,6,100,11,2125.411000,0,253.808,347.264,127.794,21.0575,0
+296,6,100,12,1786.521000,0,141.905,356.929,123.145,20.956,0
+296,12,0,4,2377.574000,0,262.837,26.289,149.966,21.1275,0
+296,12,0,5,1976.330000,0,256.156,20.1315,123.143,21.182,0
+296,12,0,6,1911.162000,0,255.359,20.3255,118.811,20.965,0
+296,12,0,7,2068.891000,0,296.223,20.475,122.727,21.007,0
+296,12,0,8,2175.988000,0,206.296,309.623,149.792,24.926,0
+296,12,0,9,2001.385000,0,315.808,232.198,123.266,20.9945,0
+296,12,0,12,2230.622000,0,176.501,437.939,149.371,21.2705,0
+296,12,25,4,2041.169000,0,279.898,53.523,123.978,21.046,0
+296,12,25,5,2258.942000,0,310.271,57.1845,129.802,25.942,0
+296,12,25,6,2030.038000,0,279.575,53.6455,123.298,21.074,0
+296,12,25,7,2471.144000,0,390.53,54.4355,149.488,21.2595,0
+296,12,25,8,2285.957000,0,277.457,330.193,133.712,21,0
+296,12,25,9,2436.092000,0,364.712,276.821,148.623,20.9265,0
+296,12,25,10,1857.518000,0,191.264,403.375,122.992,21.0525,0
+296,12,25,11,2055.139000,0,285.7,336.471,125.976,22.1315,0
+296,12,25,12,2345.056000,0,171.837,411.184,158.916,21.3675,0
+296,12,50,4,2729.816000,0,365.191,149.908,163.809,21.1965,0
+296,12,50,5,2646.531000,0,359.433,147.76,149.76,20.965,0
+296,12,50,6,2661.120000,0,360.836,148.569,150.639,24.2325,0
+296,12,50,7,2945.635000,0,510.713,136.766,150.927,22.146,0
+296,12,50,8,2169.633000,0,246.062,353.43,148.399,20.7055,0
+296,12,50,9,2468.638000,0,407.314,344.552,150.472,27.5755,0
+296,12,50,10,2272.241000,0,212.792,513.991,150.326,21.1465,0
+296,12,50,11,2417.994000,0,397.976,391.617,149.091,26.3915,0
+296,12,50,12,2237.434000,0,189.726,472.588,149.952,20.949,0
+296,12,75,4,2663.116000,0,376.285,185.513,150.965,21.0705,0
+296,12,75,5,2687.907000,0,380.646,186.207,157.409,21.046,0
+296,12,75,6,2378.039000,0,361.985,146.247,146.111,35.67,0
+296,12,75,7,2497.705000,0,441.783,149.619,122.78,20.98,0
+296,12,75,8,2474.300000,0,314.077,434.726,149.267,20.742,0
+296,12,75,9,2168.580000,0,388.855,318.248,124.974,21.123,0
+296,12,75,10,2412.775000,0,249.298,503.934,149.609,21.3125,0
+296,12,75,11,2413.592000,0,403.581,393.718,146.419,24.9895,0
+296,12,75,12,1931.671000,0,200.037,405.75,125.792,21.04,0
+296,12,100,4,3108.467000,0,509.651,270.945,149.188,21.1095,0
+296,12,100,5,2455.797000,0,412.478,207.038,124.709,21.083,0
+296,12,100,6,2585.722000,0,414.991,214.117,148.209,21.109,0
+296,12,100,7,2943.929000,0,536.915,221.796,139.368,24.3075,0
+296,12,100,8,2047.510000,0,297.619,392.037,123.075,20.938,0
+296,12,100,10,2464.423000,0,261.636,568.241,162.742,21.039,0
+296,12,100,11,2607.742000,0,532.264,407.797,154.05,21.047,0
+296,12,100,12,2399.687000,0,246.952,577.759,150.234,21.211,0
+296,24,0,4,2612.382000,0,378.723,25.9225,151.471,20.972,0
+296,24,0,5,2572.117000,0,366.172,26.1675,150.196,21.098,0
+296,24,0,6,2179.630000,0,357.509,20.2545,122.99,21.1885,0
+296,24,0,7,2478.815000,0,378.84,20.717,146.57,21.2895,0
+296,24,0,8,2286.277000,0,275.952,310.388,150.682,20.9585,0
+296,24,0,9,2572.142000,0,421.617,261.918,148.605,26.444,0
+296,24,0,10,2255.053000,0,261.964,393.177,150.385,21.1835,0
+296,24,0,11,2215.493000,0,337.088,327.862,130.406,21.0575,0
+296,24,25,4,2458.544000,0,464.728,147.089,123.479,24.206,0
+296,24,25,5,2444.523000,0,465.065,145.324,122.942,21.3555,0
+296,24,25,6,2457.530000,0,465.2,146.365,124.316,21.311,0
+296,24,25,7,2784.142000,0,521.917,148.248,148.584,25.191,0
+296,24,25,8,2464.267000,0,340.027,432.039,157.346,20.936,0
+296,24,25,9,2691.947000,0,516.38,327.22,146.886,50.6415,0
+296,24,25,10,2099.760000,0,273.626,453.781,124.344,21.254,0
+296,24,25,11,2595.309000,0,472.84,433.349,149.4,22.2885,0
+296,24,25,12,2289.281000,0,240.969,514.527,149.629,21.1195,0
+296,24,50,4,3496.782000,0,628.423,382.375,151.405,79.782,0
+296,24,50,5,3274.552000,0,618.444,297.431,165.314,21.238,0
+296,24,50,6,3150.460000,0,618.594,297.709,150.232,21.007,0
+296,24,50,7,3527.156000,0,704.101,302.496,143.94,27.936,0
+296,24,50,8,2578.362000,0,431.698,519.166,149.42,36.1215,0
+296,24,50,9,2870.876000,0,613.847,486.164,150.933,21.111,0
+296,24,50,10,2297.944000,0,332.506,540.166,124.566,20.9665,0
+296,24,50,11,2655.259000,0,528.508,495.89,149.053,21.5805,0
+296,24,50,12,1972.248000,0,280.94,466.997,123.725,21.154,0
+296,24,75,4,3520.288000,0,707.76,427.021,126.173,21.003,0
+296,24,75,5,3484.365000,0,705.032,420.515,125.311,21.169,0
+296,24,75,6,3696.821000,0,716.06,449.276,128.873,21.1385,0
+296,24,75,7,3944.884000,0,828.902,424.154,164.206,28,0
+296,24,75,8,2754.628000,0,524.252,610.071,140.056,20.8265,0
+296,24,75,10,2300.420000,0,397.573,600.317,135.604,25.8515,0
+296,24,75,12,2518.863000,0,344.578,654.145,148.561,21.299,0
+296,24,100,4,4163.042000,0,880.243,570.833,126.361,20.7205,0
+296,24,100,5,4790.938000,0,885.802,757.38,152.158,21.134,0
+296,24,100,6,4794.262000,0,883.966,755.001,153.935,21.1545,0
+296,24,100,7,5235.464000,0,1136.55,657.147,134.085,22.2385,0
+296,24,100,8,2763.382000,0,598.348,648.629,119.129,21.012,0
+296,24,100,9,3071.402000,0,820.487,587.534,124.422,21.2185,0
+296,24,100,10,2733.417000,0,463.302,799.485,150.754,21.142,0
+296,24,100,11,2647.591000,0,701.148,594.99,124.484,20.94,0
+296,24,100,12,2766.333000,0,399.155,713.945,150.336,21.24,0
+296,48,0,4,2928.987000,0,569.589,24.344,149.525,27.2415,0
+296,48,0,5,2772.513000,0,620.377,21.4675,127.181,20.8865,0
+296,48,0,6,2613.040000,0,567.212,20.415,123.625,21.065,0
+296,48,0,7,2501.607000,0,513.561,20.341,141.375,24.9745,0
+296,48,0,8,2482.947000,0,416.829,312.927,148.322,21.3475,0
+296,48,0,9,2242.243000,0,484.791,233.081,124.788,20.8685,0
+296,48,0,10,2370.583000,0,336.01,407.907,149.638,21.36,0
+296,48,0,11,2546.219000,0,444.547,371.653,161.449,22.59,0
+296,48,0,12,2426.315000,0,323.855,472.452,150.144,21.1485,0
+296,48,25,4,3875.660000,0,849.037,384.248,143.697,20.954,0
+296,48,25,5,3796.574000,0,894.511,328.192,160.457,21.153,0
+296,48,25,6,3729.665000,0,869.215,329.31,125.837,20.6905,0
+296,48,25,7,4027.759000,0,1065.83,330.626,149.946,21.4615,0
+296,48,25,9,3127.632000,0,831.382,453.934,149.599,23.8855,0
+296,48,25,10,2584.322000,0,455.558,642.798,151.88,21.122,0
+296,48,25,11,2602.869000,0,638.221,481.307,132.059,21.1555,0
+296,48,25,12,2578.430000,0,406.504,641.79,145.517,20.927,0
+296,48,50,4,4936.827000,0,1170.37,663.071,127.876,24.1735,0
+296,48,50,5,4978.724000,0,1188.34,667.3,125.529,24.6475,0
+296,48,50,6,4980.711000,0,1177.91,665.42,127.532,21.01,0
+296,48,50,7,5490.194000,0,1318.17,670.45,152.841,24.2385,0
+296,48,50,8,3189.222000,0,802.358,725.923,124.672,44.7875,0
+296,48,50,9,3591.576000,0,1035.28,635.447,150.814,22.003,0
+296,48,50,10,2830.721000,0,592.641,762.766,160.635,21.0195,0
+296,48,50,11,3131.171000,0,857.455,655.783,149.838,34.232,0
+296,48,50,12,2630.519000,0,488.729,677.125,162.625,21.36,0
+296,48,75,2,,,,,,,
+296,48,75,4,6472.297000,0,1519.23,1037.57,132.116,21.043,0
+296,48,75,5,7079.681000,0,1416.14,1330.76,158.523,21.219,0
+296,48,75,6,6987.616000,0,1439.46,1216.01,158.691,21.065,0
+296,48,75,7,6662.871000,0,1618.55,981.86,129.414,20.952,0
+296,48,75,8,3733.239000,0,950.744,911.158,126.18,21.065,0
+296,48,75,9,4223.094000,0,1254.77,860.717,149.961,21.7985,0
+296,48,75,10,3319.058000,0,773.842,1016.62,151.116,22.236,0
+296,48,75,11,3524.400000,0,1071.28,830.104,143.725,23.225,0
+296,48,75,12,2474.143000,0,588.644,760.817,124.145,21.087,0
+296,48,100,4,8247.039000,0,1816.95,1522.27,160.268,20.9525,0
+296,48,100,5,7792.519000,0,1830.16,1315.67,154.669,21.2735,0
+296,48,100,6,8218.423000,0,1816.93,1515.1,158.361,21.157,0
+296,48,100,7,8595.983000,0,2167.6,1316.78,147.582,23.004,0
+296,48,100,8,5144.602000,0,1251.75,1378.85,154.194,29.5815,0
+296,48,100,9,5139.506000,0,1595.82,1058.36,154.463,20.9765,0
+296,48,100,10,3481.670000,0,885.771,1071.07,150.617,20.7685,0
+296,48,100,11,3819.668000,0,1251.99,955.032,126.272,21.849,0
+296,96,0,4,3916.890000,0,988.384,28.161,164.136,21.111,0
+296,96,0,5,3473.807000,0,987.515,20.386,127.833,20.829,0
+296,96,0,6,3420.958000,0,966.232,20.6155,123.75,20.9995,0
+296,96,0,7,3068.482000,0,824.084,20.52,147.325,23.3985,0
+296,96,0,8,2802.799000,0,695.052,272.028,145.048,29.022,0
+296,96,0,9,2764.720000,0,702.697,274.656,144.776,21.179,0
+296,96,0,11,2679.470000,0,607.657,323.153,149.09,21.208,0
+296,96,0,12,2595.854000,0,454.584,391.021,148.308,20.8145,0
+296,96,25,4,6050.414000,0,1668.57,710.961,129.457,22.176,0
+296,96,25,5,6102.034000,0,1668.76,710.426,129.181,21.2145,0
+296,96,25,6,5890.289000,0,1609.53,698.372,127.407,21.0745,0
+296,96,25,7,6307.057000,0,1701.17,762.371,149.841,21.1245,0
+296,96,25,8,3826.138000,0,1095.43,748.59,151.473,20.735,0
+296,96,25,9,3744.576000,0,1224.4,667.883,125.02,21.1885,0
+296,96,25,11,3450.899000,0,1069.48,679.522,151.481,21.4345,0
+296,96,25,12,3072.175000,0,679.92,763.91,149.459,20.99,0
+296,96,50,4,8754.022000,0,2293.21,1408.8,130.277,21.071,0
+296,96,50,5,8779.815000,0,2316.02,1401.69,129.975,21.3245,0
+296,96,50,6,8800.482000,0,2297.21,1389.85,157.856,21.225,0
+296,96,50,7,9360.361000,0,2527.39,1400.04,147.625,23.6675,0
+296,96,50,8,5606.278000,0,1580.93,1428.16,170.665,21.127,0
+296,96,50,9,5489.518000,0,1844.08,1127.59,128.146,21.252,0
+296,96,50,10,4138.844000,0,1152.43,1277.25,153.444,21.0785,0
+296,96,50,11,4392.435000,0,1586.15,999.139,137.342,22.1155,0
+296,96,50,12,3555.583000,0,995.244,1102.84,151.234,21.25,0
+296,96,75,4,11766.566000,0,2789.73,2273.06,159.567,21.2405,0
+296,96,75,5,12720.538000,0,2933.6,2542.11,164.493,38.9685,0
+296,96,75,6,11237.223000,0,2790.98,2073.67,133.588,20.949,0
+296,96,75,7,12222.427000,0,3170.72,2085.8,150.446,22.38,0
+296,96,75,8,6686.717000,0,1962.27,1764.11,158.473,20.845,0
+296,96,75,9,7283.240000,0,2431.39,1584.26,157.697,24.05,0
+296,96,75,10,5082.715000,0,1512.42,1633.22,155.946,21.2195,0
+296,96,75,12,4143.521000,0,1231.85,1387.65,154.032,30.1835,0

TPDS_Submission/Data/serial_data.csv

@@ -0,0 +1,350 @@
+395,6,0,1,549.759000,0,198.494,179.04,44.75,0,5.646
+395,6,25,1,539.196000,0,192.308,174.378,44.006,0,5.7
+395,6,50,1,545.386000,0,194.225,175.032,44.278,0,5.927
+395,6,75,1,538.549000,0,192.113,174.572,44.31,0,5.81
+395,6,100,1,534.157000,0,190.598,173.702,43.868,0,5.602
+395,12,0,1,650.557000,0,299.869,175.52,43.862,0,5.714
+395,12,25,1,716.742000,0,298.586,240.301,43.899,0,5.618
+395,12,50,1,849.290000,0,307.962,358.582,44.223,0,5.542
+395,12,75,1,920.849000,0,310.502,420.083,43.979,0,5.738
+395,12,100,1,1054.387000,0,315.848,536.545,43.719,0,5.646
+395,24,0,1,856.342000,0,509.837,175.68,44.306,0,5.651
+395,24,25,1,1126.995000,0,519.368,417.692,43.949,0,5.609
+395,24,50,1,1484.150000,0,540.539,721.214,44.514,0,5.697
+395,24,75,1,1739.532000,0,546.198,948.77,43.965,0,5.934
+395,24,100,1,2082.455000,0,572.68,1242.61,43.545,0,5.583
+395,48,0,1,1276.894000,0,931.671,175.357,43.495,0,5.582
+395,48,25,1,1956.367000,0,959.247,770.052,43.913,0,5.817
+395,48,50,1,2697.496000,0,999.041,1420.5,43.797,0,5.542
+395,48,75,1,3390.911000,0,1031.05,2000.94,43.021,0,5.242
+395,48,100,1,4136.318000,0,1075.75,2659.19,43.631,0,5.49
+395,96,0,1,2139.228000,0,1765.26,176.071,44.43,0,5.713
+395,96,25,1,3628.631000,0,1859.72,1475.51,43.099,0,5.36
+395,96,50,1,5177.524000,0,1911.78,2849.03,43.327,0,5.479
+395,96,75,1,6682.658000,0,2024.98,4125.85,43.24,0,5.318
+395,96,100,1,8198.569000,0,2073.83,5471.32,43.511,0,5.385
+395,192,0,1,3847.869000,0,3492.82,175.951,44.422,0,5.743
+395,192,25,1,6906.472000,0,3597.19,2888.98,43.429,0,5.455
+395,192,50,1,10144.337000,0,3748.11,5716.55,43.066,0,5.315
+395,192,75,1,13237.425000,0,3974.05,8345.36,43.151,0,5.268
+395,192,100,1,16347.043000,0,4078.72,11107.3,42.765,0,5.274
+395,384,0,1,7120.758000,0,6766.8,175.718,43.86,0,5.581
+395,384,25,1,13375.503000,0,6976.33,5723.54,42.71,0,5.186
+395,384,50,1,19967.603000,0,7444.26,11334,43.624,0,5.334
+395,384,75,1,26376.554000,0,7886.18,16809.7,43.222,0,5.304
+395,384,100,1,32577.355000,0,8053.7,22353.8,42.574,0,5.224
+395,768,0,1,13901.559000,0,13545.2,176.331,44.174,0,5.889
+395,768,25,1,26675.829000,0,14140.2,11360.2,42.565,0,5.181
+395,768,50,1,39531.541000,0,14799.1,22534.3,43.083,0,5.233
+395,768,75,1,53427.566000,0,15832.7,34341.4,43.407,0,5.299
+395,768,100,1,65238.720000,0,15970.5,45062.9,42.751,0,5.325
+395,1536,0,1,27389.534000,0,26994.6,181.102,45.325,0,6.374
+395,1536,25,1,53023.014000,0,28211.6,22604.6,43.69,0,5.518
+395,1536,50,1,78662.469000,0,29400.7,45048.5,42.449,0,5.455
+395,1536,75,1,105705.000000,0,31277.1,68149.6,43.251,0,5.336
+395,1536,100,1,130351.834000,0,31837.4,90227.8,42.608,0,5.289
+395,3072,0,1,26108.282000,0,25928.4,90.142,21.552,0,2.923
+395,3072,25,1,51052.296000,0,27237.6,21774.2,20.862,0,2.634
+395,3072,50,1,75797.875000,0,28424.5,43377.2,20.751,0,2.677
+395,3072,75,1,100778.411000,0,29895.3,64948.5,20.661,0,2.665
+395,3072,100,1,125369.237000,0,30816.9,86686.7,20.828,0,2.644
+395,6144,0,1,51601.931000,0,51423.3,89.516,21.341,0,2.831
+395,6144,25,1,101723.033000,0,54382.4,43360.8,20.898,0,2.637
+395,6144,50,1,151128.302000,0,56093.5,87120.6,20.673,0,2.587
+395,6144,75,1,201902.363000,0,60077.1,130069,20.617,0,2.717
+395,6144,100,1,250345.872000,0,61134.3,173470,21.036,0,2.75
+395,12288,0,1,210229.234000,0,209855,180.033,44.287,0,5.822
+395,12288,25,1,419751.795000,0,223668,179743,43.816,0,5.547
+395,12288,50,1,626642.153000,0,234890,359220,44.121,0,5.59
+395,12288,75,1,834582.246000,0,247474,538499,44.078,0,5.464
+395,12288,100,1,1037064.212000,0,254443,718016,45.52,0,6.031
+395,24576,0,1,426136.132000,0,425732,183.552,45.022,0,6.581
+395,24576,25,1,842067.721000,0,450599,358969,44.721,0,6.373
+395,24576,50,1,1257499.045000,0,469033,723130,45.858,0,6.576
+395,24576,75,1,1671219.441000,0,493617,1.08067e+06,45.895,0,6.878
+395,24576,100,1,2074083.201000,0,505791,1.43844e+06,46.023,0,6.675
+395,49152,0,1,857378.614000,0,856919,188.561,45.083,0,6.554
+395,49152,25,1,1687641.660000,0,902920,720023,46.387,0,6.498
+395,49152,50,1,2548534.595000,0,947686,1.47017e+06,46.128,0,6.661
+395,49152,75,1,3347869.256000,0,989910,2.16169e+06,45.746,0,6.557
+395,49152,100,1,4145488.776000,0,1.00892e+06,2.87524e+06,45.874,0,6.835
+296,6,0,1,1240.696000,0,195.042,175.846,43.328,684.729,5.895
+296,6,25,1,945.627000,0,194.563,176.221,44.039,388.328,5.988
+296,6,50,1,912.854000,0,191.391,175.688,44.023,337.619,6.029
+296,6,75,1,1224.518000,0,194.847,175.928,43.76,664.276,6.079
+296,6,100,1,917.804000,0,194.953,176.225,44.125,358.756,6.055
+296,12,0,1,1111.275000,0,302.633,177.483,43.797,439.377,6.187
+296,12,25,1,1016.338000,0,299.803,245.165,43.847,278.859,5.956
+296,12,50,1,1243.907000,0,307.459,366.917,44.565,356.951,6.273
+296,12,75,1,1261.648000,0,309.223,422.364,44.343,315.94,6.001
+296,12,100,1,1413.922000,0,316.506,544.621,44.124,325.045,6.383
+296,24,0,1,1205.358000,0,511.577,176.086,43.462,326.323,6.04
+296,24,25,1,1485.729000,0,521.891,427.064,44.457,319.656,6.185
+296,24,50,1,1912.777000,0,578.01,759.039,46.866,325.694,6.794
+296,24,75,1,2169.033000,0,548.904,952.092,44.06,401.292,6.033
+296,24,100,1,2524.188000,0,572.867,1247.89,43.296,410.756,6.036
+296,48,0,1,1627.356000,0,930.865,177.048,43.933,324.268,6.146
+296,48,25,1,2373.341000,0,962.331,775.89,44.001,378.835,6.086
+296,48,50,1,3333.177000,0,1003.66,1424.47,44.256,582.146,6.286
+296,48,75,1,3742.655000,0,1048.08,2013.32,43.726,310.913,6.306
+296,48,100,1,4614.081000,0,1074.99,2655.03,43.543,465.212,5.983
+296,96,0,1,2509.616000,0,1779.31,177.491,44.501,349.161,6.201
+296,96,25,1,3931.619000,0,1838.52,1480.49,44.043,288.195,6.088
+296,96,50,1,5531.521000,0,1925.07,2838.57,44.429,320.341,6.294
+296,96,75,1,7136.812000,0,2039.59,4189.8,43.829,335.822,6.163
+296,96,100,1,8600.817000,0,2080.75,5496.69,44.301,336.964,6.304
+296,192,0,1,4208.253000,0,3457.66,178.47,44.14,368.72,6.152
+296,192,25,1,7300.590000,0,3594.2,2892.4,43.983,363.751,6.207
+296,192,50,1,10531.867000,0,3746.62,5658.32,43.613,428.869,6.001
+296,192,75,1,13663.381000,0,3979.17,8374.42,44.223,360.123,6.416
+296,192,100,1,16823.409000,0,4088.57,11125.4,43.203,407.023,6.039
+296,384,0,1,7657.729000,0,6816.58,178.957,44.354,454.317,6.198
+296,384,25,1,13912.028000,0,7102.5,5734.69,44.011,366.621,6.074
+296,384,50,1,20259.343000,0,7427.34,11317.8,43.952,309.228,6.003
+296,384,75,1,26751.699000,0,7870.18,16834.8,43.896,341.006,6.482
+296,384,100,1,32859.560000,0,8020.26,22336.1,44.226,302.425,6.457
+296,768,0,1,14133.986000,0,13449.2,179.064,43.875,297.146,6.293
+296,768,25,1,27070.149000,0,14181.9,11337,43.663,335.312,6.396
+296,768,50,1,40111.353000,0,14829.7,22695,43.848,363.84,6.248
+296,768,75,1,52765.075000,0,15572.8,33687.5,42.915,288.055,6.044
+296,768,100,1,65444.760000,0,15956,44922.7,43.726,320.591,6.176
+296,1536,0,1,28125.389000,0,27328.4,181.191,44.565,395.397,6.492
+296,1536,25,1,53234.085000,0,28096.7,22592.6,43.84,323.192,6.461
+296,1536,50,1,78985.605000,0,29232.1,45060.8,43.802,429.752,6.241
+296,1536,75,1,106183.830000,0,31169.5,68334.2,44.142,392.498,6.382
+296,1536,100,1,130293.700000,0,31731.2,89995.7,43.721,309.517,6.371
+296,3072,0,1,26120.494000,0,25920.6,92.816,21.784,0,3.294
+296,3072,25,1,50766.809000,0,27003.3,21707.7,21.429,0,3.187
+296,3072,50,1,75827.963000,0,28466.4,43355.3,21.373,0,2.978
+296,3072,75,1,101158.697000,0,30087.9,65066.2,21.524,0,3.055
+296,3072,100,1,124950.090000,0,30606.9,86466.2,20.975,0,2.928
+296,6144,0,1,51742.205000,0,51545.8,91.818,21.364,0,3.076
+296,6144,25,1,101788.022000,0,54296.1,43476.2,21.269,0,3.01
+296,6144,50,1,150967.332000,0,56557.5,86512.5,21.531,0,3.036
+296,6144,75,1,201744.807000,0,59847.5,130119,21.183,0,3.036
+296,6144,100,1,253771.376000,0,61199.4,176861,21.528,0,3.043
+296,12288,0,1,215948.332000,0,215064,182.747,44.631,479.983,6.515
+296,12288,25,1,422436.080000,0,224615,181142,43.556,311.463,6.075
+296,12288,50,1,625400.506000,0,233893,358816,44.968,354.616,6.517
+296,12288,75,1,835434.772000,0,247583,539012,45.354,335.571,6.56
+296,12288,100,1,1038212.702000,0,254358,718865,45.216,382.794,6.73
+296,24576,0,1,426780.121000,0,425911,183.976,44.99,459.404,6.937
+296,24576,25,1,839216.733000,0,446750,359628,44.371,479.778,6.448
+296,24576,50,1,1249819.104000,0,466507,718476,44.859,364.402,6.772
+296,24576,75,1,1672521.366000,0,493129,1.08195e+06,45.25,327.505,6.473
+296,24576,100,1,2095464.840000,0,511544,1.45361e+06,46.275,357.715,6.683
+296,49152,0,1,861155.653000,0,860225,185.748,44.727,469.301,6.832
+296,49152,25,1,1688411.868000,0,902616,720603,45.485,584.024,6.819
+296,49152,50,1,2508479.305000,0,940183,1.4385e+06,44.742,411.592,5.986
+296,49152,75,1,3323433.665000,0,974547,2.15223e+06,45.183,390.435,6.152
+296,49152,100,1,4143260.358000,0,1.00758e+06,2.87437e+06,45.27,387.559,5.959
+197,6,0,1,1158.270000,0,193.083,174.378,42.41,623.772,5.607
+197,6,25,1,1022.917000,0,193.562,174.815,42.141,482.519,5.511
+197,6,50,1,1011.356000,0,192.734,174.369,42.408,478.065,5.558
+197,6,75,1,1012.512000,0,193.33,174.032,42.471,479.888,5.562
+197,6,100,1,1031.362000,0,192.542,174.186,42.521,501.048,5.544
+197,12,0,1,1168.918000,0,298.631,174.609,42.324,531.009,5.558
+197,12,25,1,1132.923000,0,300.144,241.89,42.969,418.922,5.506
+197,12,50,1,1691.795000,0,307.677,359.491,42.658,840.559,5.43
+197,12,75,1,1492.798000,0,308.857,418.179,42.17,567.593,5.611
+197,12,100,1,1716.853000,0,316.157,537.056,42.646,661.114,5.647
+197,24,0,1,1313.217000,0,509.942,174.425,42.433,462.045,5.477
+197,24,25,1,1621.874000,0,523.261,420.064,42.878,483.652,5.541
+197,24,50,1,1899.804000,0,539.247,715.045,42.608,425.084,5.68
+197,24,75,1,2188.831000,0,547.781,947.696,41.894,452.533,5.479
+197,24,100,1,2524.449000,0,572.437,1243.57,42.366,440.107,5.536
+197,48,0,1,1883.239000,0,933.575,175.768,42.67,603.449,5.533
+197,48,25,1,2543.959000,0,961.018,771.664,43.098,584.544,5.687
+197,48,50,1,3234.345000,0,998.316,1414.87,42.341,531.277,5.516
+197,48,75,1,3810.669000,0,1048.75,2021.92,42.252,399.573,5.386
+197,48,100,1,4636.258000,0,1071.46,2649.85,42.259,501.602,5.299
+197,96,0,1,2840.101000,0,1778.04,175.682,42.475,699.186,5.532
+197,96,25,1,4101.629000,0,1838.91,1475.94,42.02,494.396,5.362
+197,96,50,1,5607.492000,0,1916.8,2838.06,43.479,402.362,6.224
+197,96,75,1,7279.049000,0,2026.96,4134.08,42.563,562.241,5.723
+197,96,100,1,8796.255000,0,2069.24,5474.69,42.186,598.815,5.362
+197,192,0,1,4407.770000,0,3446.69,175.702,42.424,604.901,5.562
+197,192,25,1,7330.506000,0,3591.11,2895.09,41.84,421.358,5.378
+197,192,50,1,10608.158000,0,3763.44,5663.54,42.412,512.06,5.315
+197,192,75,1,13717.809000,0,3966.65,8338.47,42.034,502.421,5.257
+197,192,100,1,16866.589000,0,4049.12,11099.1,41.308,559.624,5.247
+197,384,0,1,7592.897000,0,6800.49,176.615,42.86,438.478,5.436
+197,384,25,1,13778.477000,0,6949.12,5693.09,41.533,454.421,5.187
+197,384,50,1,20316.785000,0,7419.26,11281.5,41.654,439.427,5.277
+197,384,75,1,26943.478000,0,7828.38,16940.4,41.809,502.951,5.213
+197,384,100,1,33258.387000,0,8046.79,22381.2,41.481,659.451,5.266
+197,768,0,1,14268.971000,0,13474.1,176.2,42.288,426.044,5.668
+197,768,25,1,27091.679000,0,14063.8,11322.9,41.907,522.053,5.434
+197,768,50,1,39935.372000,0,14699.2,22509.9,41.848,544.411,5.37
+197,768,75,1,53113.172000,0,15613.9,33830.4,41.745,472.646,5.273
+197,768,100,1,65647.539000,0,16024.9,44912,41.557,518.615,5.238
+197,1536,0,1,27861.314000,0,27041,176.948,42.568,465.928,5.435
+197,1536,25,1,53503.847000,0,28238.4,22623.1,41.25,451.554,5.232
+197,1536,50,1,79155.524000,0,29378.2,45031.4,41.956,542.208,5.507
+197,1536,75,1,105412.642000,0,31143.3,67466.9,41.952,591.699,5.569
+197,1536,100,1,131870.092000,0,32088.9,90994,41.713,510.461,5.255
+197,3072,0,1,26202.058000,0,26025.3,88.64,21.339,0,2.653
+197,3072,25,1,50982.251000,0,27216,21729.5,20.843,0,2.577
+197,3072,50,1,75702.112000,0,28327.5,43367.3,20.801,0,2.571
+197,3072,75,1,101018.060000,0,30124,64918.5,21.528,0,3.224
+197,3072,100,1,126091.166000,0,30722.9,87438.4,20.812,0,2.659
+197,6144,0,1,52525.299000,0,52344.8,90.742,21.619,0,2.756
+197,6144,25,1,101631.778000,0,54215.1,43416.5,20.42,0,2.631
+197,6144,50,1,151388.486000,0,56755.6,86736.8,20.505,0,2.502
+197,6144,75,1,202016.307000,0,60071.5,130182,20.785,0,2.576
+197,6144,100,1,250583.529000,0,61536,173391,21.034,0,2.683
+197,12288,0,1,217196.134000,0,216295,180.333,42.762,537.027,5.662
+197,12288,25,1,423240.526000,0,223963,182096,43.277,661.904,6.399
+197,12288,50,1,633761.330000,0,234981,365681,43.425,584.242,6.259
+197,12288,75,1,835415.690000,0,247605,538964,43.859,476.41,6.385
+197,12288,100,1,1039466.525000,0,254324,720025,44.547,570.53,6.518
+197,24576,0,1,432889.849000,0,431952,182.879,43.881,529.434,6.551
+197,24576,25,1,841158.788000,0,447861,360282,43.971,590.23,6.443
+197,24576,50,1,1252051.175000,0,467592,719073,45.186,631.905,6.697
+197,24576,75,1,1672329.335000,0,494668,1.07992e+06,44.933,478.766,6.504
+197,24576,100,1,2072071.784000,0,504153,1.43789e+06,44.83,502.232,6.668
+197,49152,0,1,869412.542000,0,868382,186.468,44.207,619.687,6.629
+197,49152,25,1,1671120.764000,0,889869,716060,44.575,557.79,6.527
+197,49152,50,1,2578503.596000,0,954478,1.49082e+06,45.329,477.917,6.642
+197,49152,75,1,3350827.584000,0,989318,2.16426e+06,45.96,549.902,6.964
+197,49152,100,1,4156784.062000,0,1.01649e+06,2.87876e+06,45.263,569.831,6.688
+79,6,0,1,954.621000,0,195.021,175.375,43.045,397.151,5.788
+79,6,25,1,986.139000,0,194.37,175.852,43.041,419.059,5.63
+79,6,50,1,1049.826000,0,191.014,175.426,43.229,497.341,5.687
+79,6,75,1,957.070000,0,195.252,175.534,43.562,398.887,5.778
+79,6,100,1,1168.750000,0,196.283,175.125,42.611,612.101,5.721
+79,12,0,1,1282.062000,0,302.453,177.247,43.094,611.206,5.823
+79,12,25,1,1541.268000,0,302.278,247.129,43.701,796.089,5.914
+79,12,50,1,1644.890000,0,308.978,367.694,44.37,747.233,6.302
+79,12,75,1,1710.352000,0,309.95,422.585,42.999,764.632,5.763
+79,12,100,1,1768.156000,0,315.556,540.979,43.632,640.576,5.929
+79,24,0,1,1412.867000,0,509.867,177.106,43.474,528.506,5.873
+79,24,25,1,1565.289000,0,521.434,427.384,44.497,400.161,5.83
+79,24,50,1,1885.181000,0,540.731,717.208,43.164,382.951,5.917
+79,24,75,1,2125.131000,0,546.044,954.697,43.491,353.36,6.156
+79,24,100,1,2563.905000,0,571.496,1247.74,43.734,447.152,6.126
+79,48,0,1,1851.570000,0,935.287,177.828,44.043,537.775,6.115
+79,48,25,1,2671.030000,0,959.089,775.906,42.871,682.696,5.788
+79,48,50,1,3078.177000,0,996.438,1423.01,43.538,343.754,6.081
+79,48,75,1,3875.301000,0,1048.82,2014.91,43.892,441.024,5.974
+79,48,100,1,4663.215000,0,1070.52,2658.07,43.81,503.825,6.223
+79,96,0,1,2651.857000,0,1779.21,179.589,44.616,466.833,6.42
+79,96,25,1,3955.775000,0,1839.48,1482.02,43.352,313.901,5.976
+79,96,50,1,5820.368000,0,1939.29,2888.13,44.414,537.539,6.187
+79,96,75,1,7201.880000,0,2021.41,4127.3,43.834,475.97,6.236
+79,96,100,1,8696.059000,0,2073.91,5494.38,44.566,428.411,6.428
+79,192,0,1,4618.325000,0,3458.72,181.074,44.712,770.406,6.109
+79,192,25,1,7461.042000,0,3585.4,2895.36,43.315,511.273,5.927
+79,192,50,1,10662.619000,0,3741.28,5655.59,43.607,568.143,5.908
+79,192,75,1,13602.903000,0,3976.36,8363.03,43.595,315.653,6.224
+79,192,100,1,16836.039000,0,4065,11105.5,43.346,467.994,6.447
+79,384,0,1,7748.748000,0,6920.36,180.515,44.363,435.113,6.331
+79,384,25,1,14179.497000,0,7095.2,5722.21,43.681,653.935,6.26
+79,384,50,1,20399.235000,0,7437.3,11284.7,43.471,470.247,6.064
+79,384,75,1,26718.546000,0,7837.14,16802.7,43.13,374.862,6.133
+79,384,100,1,33086.828000,0,8055.08,22444.1,43.515,381.043,6.046
+79,768,0,1,14276.801000,0,13469.7,178.326,43.756,417.679,6.073
+79,768,25,1,27270.953000,0,14060.8,11378.7,44.86,602.094,6.402
+79,768,50,1,39943.471000,0,14757.5,22575,43.189,393.292,6.187
+79,768,75,1,53089.973000,0,15632,33878.5,43.848,323.695,6.236
+79,768,100,1,65557.400000,0,15959.3,45046.8,44.14,318.546,6.283
+79,1536,0,1,27934.186000,0,27048,181.314,44.164,489.685,6.271
+79,1536,25,1,53694.104000,0,28216.4,22832.2,44.12,417.35,6.636
+79,1536,50,1,81322.427000,0,29996.2,46556.6,44.43,418.342,6.297
+79,1536,75,1,105249.704000,0,31042.3,67547.4,43.562,405.312,6.022
+79,1536,100,1,130758.278000,0,31966.3,90099.1,44.082,436.85,6.447
+79,3072,0,1,26335.411000,0,25976.7,92.041,22.147,162.425,2.953
+79,3072,25,1,51019.044000,0,27076.7,21718.2,21.98,171.155,3.065
+79,3072,50,1,75831.915000,0,28271.5,43332.3,21.698,213.99,2.997
+79,3072,75,1,101578.557000,0,30006.2,65373.7,22.15,197.455,3.141
+79,3072,100,1,125180.912000,0,30608.3,86454.2,21.687,239.311,3.035
+79,6144,0,1,52443.692000,0,52058.1,91.449,21.767,189.802,2.93
+79,6144,25,1,100648.883000,0,53260.6,43119.4,21.506,212.411,3.006
+79,6144,50,1,151374.271000,0,56671.7,86639,21.746,170.608,3.069
+79,6144,75,1,201462.440000,0,59630.6,129829,21.89,230.732,3.071
+79,6144,100,1,250675.615000,0,61282.1,173556,21.6,162.883,2.911
+79,12288,0,1,217113.553000,0,216224,183.279,44.456,484.044,6.526
+79,12288,25,1,424187.099000,0,224835,182289,44.145,475.797,6.307
+79,12288,50,1,629091.103000,0,233955,361540,43.546,396.724,6.312
+79,12288,75,1,844097.518000,0,248293,546724,45.693,485.298,6.449
+79,12288,100,1,1044344.236000,0,254059,724958,45.646,529.861,6.696
+79,24576,0,1,432766.570000,0,432009,183.055,44.722,351.269,6.613
+79,24576,25,1,840589.013000,0,448714,359142,44.546,411.684,6.591
+79,24576,50,1,1252980.578000,0,467484,720397,45.83,484.436,6.623
+79,24576,75,1,1671051.693000,0,495293,1.07853e+06,45.535,399.904,6.583
+79,24576,100,1,2072303.677000,0,505469,1.43704e+06,45.094,545.051,6.406
+79,49152,0,1,868613.008000,0,867795,187.294,45.191,399.351,6.743
+79,49152,25,1,1684137.703000,0,897554,721334,46.105,484.653,6.752
+79,49152,50,1,2509549.874000,0,938636,1.44068e+06,45.33,518.801,6.841
+79,49152,75,1,3339923.143000,0,987355,2.15688e+06,46.129,399.113,6.647
+79,49152,100,1,4172158.645000,0,1.02126e+06,2.88654e+06,45.878,394.157,6.893
+1,6,0,1,572.125000,0,203.835,184.062,52.618,0,0
+1,6,25,1,556.062000,0,194.105,176.298,51.01,0,0
+1,6,50,1,552.315000,0,193.444,175.226,50.165,0,0
+1,6,75,1,558.440000,0,195.096,175.826,51.24,0,0
+1,6,100,1,549.288000,0,194.055,174.966,50.047,0,0
+1,12,0,1,664.310000,0,300.404,177.165,51.065,0,0
+1,12,25,1,736.987000,0,298.836,244.539,50.22,0,0
+1,12,50,1,884.611000,0,307.29,366.056,51.438,0,0
+1,12,75,1,936.041000,0,309.239,419.495,50.323,0,0
+1,12,100,1,1069.578000,0,319.809,542.422,49.932,0,0
+1,24,0,1,880.416000,0,510.572,177.049,51.021,0,0
+1,24,25,1,1167.822000,0,521.868,426.57,51.598,0,0
+1,24,50,1,1503.426000,0,539.536,717.277,51.669,0,0
+1,24,75,1,1768.911000,0,546.355,953.077,51.917,0,0
+1,24,100,1,2130.004000,0,573.103,1255.84,51.617,0,0
+1,48,0,1,1309.743000,0,935.07,177.775,51.208,0,0
+1,48,25,1,1989.039000,0,959.467,776.282,51.335,0,0
+1,48,50,1,2741.927000,0,999.236,1425.5,51.316,0,0
+1,48,75,1,3437.724000,0,1049.4,2015,51.629,0,0
+1,48,100,1,4193.542000,0,1075.3,2682.12,49.934,0,0
+1,96,0,1,2153.263000,0,1767.01,178.28,51.635,0,0
+1,96,25,1,3654.740000,0,1846.89,1483.47,51.619,0,0
+1,96,50,1,5210.882000,0,1918.49,2843.37,50.564,0,0
+1,96,75,1,6761.975000,0,2020.23,4135.21,50.688,0,0
+1,96,100,1,8253.305000,0,2079.01,5474.01,50.341,0,0
+1,192,0,1,3849.778000,0,3456.36,180.774,52.972,0,0
+1,192,25,1,6939.100000,0,3581.66,2904.26,50.287,0,0
+1,192,50,1,10086.240000,0,3729.37,5655.65,50.397,0,0
+1,192,75,1,13264.916000,0,3955.82,8362.54,50.28,0,0
+1,192,100,1,16351.689000,0,4045.59,11110.8,50.207,0,0
+1,384,0,1,7208.294000,0,6814.08,180.158,52.105,0,0
+1,384,25,1,13582.588000,0,7111.94,5763.48,50.067,0,0
+1,384,50,1,19936.875000,0,7419.22,11303.6,51.078,0,0
+1,384,75,1,26368.840000,0,7861.71,16789.8,51.004,0,0
+1,384,100,1,32612.186000,0,8032.26,22366,51.21,0,0
+1,768,0,1,13926.810000,0,13530.8,180.617,52.991,0,0
+1,768,25,1,26836.022000,0,14285.1,11334.1,50.667,0,0
+1,768,50,1,39438.732000,0,14692.6,22513.5,49.767,0,0
+1,768,75,1,52545.153000,0,15602.2,33711.4,50.277,0,0
+1,768,100,1,65032.277000,0,15819.2,44951.3,50.747,0,0
+1,1536,0,1,27116.898000,0,26722.5,180.872,52.146,0,0
+1,1536,25,1,52946.575000,0,28041,22663.6,49.942,0,0
+1,1536,50,1,78389.685000,0,29071.2,45023.7,49.78,0,0
+1,1536,75,1,105030.308000,0,31155.2,67586.3,50.43,0,0
+1,1536,100,1,131381.624000,0,32208.9,90818,50.592,0,0
+1,3072,0,1,26016.986000,0,25818.1,92.237,25.318,0,0
+1,3072,25,1,50960.404000,0,27142.6,21756.5,24.492,0,0
+1,3072,50,1,75775.874000,0,28463.2,43306.5,24.35,0,0
+1,3072,75,1,101166.474000,0,30109.8,65082.5,24.156,0,0
+1,3072,100,1,126024.898000,0,30857.3,87254.7,24.003,0,0
+1,6144,0,1,51888.614000,0,51689.6,92.445,24.753,0,0
+1,6144,25,1,101754.764000,0,54280,43459.5,24.092,0,0
+1,6144,50,1,151231.975000,0,56782.2,86558.5,23.65,0,0
+1,6144,75,1,201764.844000,0,59940.4,130016,23.844,0,0
+1,6144,100,1,250729.173000,0,61556.2,173483,24.351,0,0
+1,12288,0,1,213009.954000,0,212608,182.282,51.426,0,0
+1,12288,25,1,420592.564000,0,224118,180150,50.599,0,0
+1,12288,50,1,627686.291000,0,234177,361044,50.874,0,0
+1,12288,75,1,835798.055000,0,247637,539592,50.948,0,0
+1,12288,100,1,1038457.423000,0,254855,718946,52.312,0,0
+1,24576,0,1,430672.569000,0,430268,182.821,51.928,0,0
+1,24576,25,1,850213.161000,0,449772,367904,51.923,0,0
+1,24576,50,1,1251856.443000,0,466492,720785,52.09,0,0
+1,24576,75,1,1669742.622000,0,492825,1.07976e+06,52.559,0,0
+1,24576,100,1,2077595.984000,0,504465,1.44324e+06,52.78,0,0
+1,49152,0,1,855262.345000,0,854849,186.616,52.389,0,0
+1,49152,25,1,1689739.604000,0,904696,720276,53.329,0,0
+1,49152,50,1,2506215.413000,0,935803,1.44093e+06,52.923,0,0
+1,49152,75,1,3349519.199000,0,989134,2.16462e+06,53.052,0,0
+1,49152,100,1,4168854.729000,0,1.01201e+06,2.89139e+06,52.238,0,0

TPDS_Submission/Schrick-Noah_MPI-Tasking.aux

@@ -0,0 +1,160 @@
+\relax 
+\providecommand\babel@aux[2]{}
+\@nameuse{bbl@beforestart}
+\providecommand\hyper@newdestlabel[2]{}
+\providecommand\HyperFirstAtBeginDocument{\AtBeginDocument}
+\HyperFirstAtBeginDocument{\ifx\hyper@anchor\@undefined
+\global\let\oldnewlabel\newlabel
+\gdef\newlabel#1#2{\newlabelxx{#1}#2}
+\gdef\newlabelxx#1#2#3#4#5#6{\oldnewlabel{#1}{{#2}{#3}}}
+\AtEndDocument{\ifx\hyper@anchor\@undefined
+\let\newlabel\oldnewlabel
+\fi}
+\fi}
+\global\let\hyper@last\relax 
+\gdef\HyperFirstAtBeginDocument#1{#1}
+\providecommand\HyField@AuxAddToFields[1]{}
+\providecommand\HyField@AuxAddToCoFields[2]{}
+\citation{9678822}
+\citation{7993827}
+\citation{8652334}
+\citation{baloyi_guidelines_2019}
+\citation{allman_complying_2006}
+\citation{j_hale_compliance_nodate}
+\citation{ou_scalable_2006}
+\citation{CPSIOT}
+\citation{ming_jo}
+\citation{cook_rage_2018}
+\citation{pacheco_introduction_2011}
+\citation{ainsworth_graph_2016}
+\citation{yao_efficient_2018}
+\citation{zhang_boosting_2017}
+\citation{dai_fpgp_2016}
+\babel@aux{nil}{}
+\@writefile{toc}{\contentsline {section}{\numberline {I}Introduction}{1}{section.1}\protected@file@percent }
+\newlabel{sec:Intro}{{I}{1}{Introduction}{section.1}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {II}Related Works}{1}{section.2}\protected@file@percent }
+\newlabel{sec:rel_works}{{II}{1}{Related Works}{section.2}{}}
+\citation{arifuzzaman_fast_2015}
+\citation{yu_construction_2018}
+\citation{liakos_memory-optimized_2016}
+\citation{liakos_memory-optimized_2016}
+\citation{liakos_memory-optimized_2016}
+\citation{balaji_graph_2016}
+\citation{noauthor_parmetis_nodate}
+\citation{noauthor_boost_nodate}
+\citation{ou_scalable_2006}
+\citation{cook_scalable_2016}
+\citation{li_concurrency_2019}
+\citation{li_concurrency_2019}
+\citation{9150145}
+\citation{7087377}
+\citation{li_concurrency_2019}
+\citation{9150145}
+\citation{7087377}
+\@writefile{toc}{\contentsline {section}{\numberline {III}Necessary Components}{2}{section.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {III-A}}Serialization}{2}{subsection.3.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {IV}Implementation of the Tasking Approach}{2}{section.4}\protected@file@percent }
+\newlabel{sec:Tasking-Approach}{{IV}{2}{Implementation of the Tasking Approach}{section.4}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {IV-A}}Algorithm Design}{2}{subsection.4.1}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {1}{\ignorespaces Overview of the Tasking Pipeline for the Attack and Compliance Graph Generation Process}}{3}{figure.1}\protected@file@percent }
+\newlabel{fig:tasks}{{1}{3}{Overview of the Tasking Pipeline for the Attack and Compliance Graph Generation Process}{figure.1}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {IV-B}}Communication Structure}{3}{subsection.4.2}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {2}{\ignorespaces Node Allocation for each Task}}{3}{figure.2}\protected@file@percent }
+\newlabel{fig:node-alloc}{{2}{3}{Node Allocation for each Task}{figure.2}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {IV-C}}Task Breakdown}{3}{subsection.4.3}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {\mbox  {IV-C}1}Task 0}{3}{subsubsection.4.3.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {\mbox  {IV-C}2}Task 1}{3}{subsubsection.4.3.2}\protected@file@percent }
+\citation{10124989}
+\@writefile{lof}{\contentsline {figure}{\numberline {3}{\ignorespaces Data Distribution of Task One}}{4}{figure.3}\protected@file@percent }
+\newlabel{fig:Task1-Data-Dist}{{3}{4}{Data Distribution of Task One}{figure.3}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {4}{\ignorespaces Communication From Task 1 to Task 2 when the Number of Nodes Allocated is Equal}}{4}{figure.4}\protected@file@percent }
+\newlabel{fig:Task1-Case1}{{4}{4}{Communication From Task 1 to Task 2 when the Number of Nodes Allocated is Equal}{figure.4}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {\mbox  {IV-C}3}Task 2}{4}{subsubsection.4.3.3}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {5}{\ignorespaces Task 1 to Task 2 Communication, Case 2}}{4}{figure.5}\protected@file@percent }
+\newlabel{fig:Task1-Case2}{{5}{4}{Task 1 to Task 2 Communication, Case 2}{figure.5}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {\mbox  {IV-C}4}Task 3}{4}{subsubsection.4.3.4}\protected@file@percent }
+\newlabel{sec:T4T5}{{\mbox  {IV-C}5}{4}{Task 4 and Task 5}{subsubsection.4.3.5}{}}
+\@writefile{toc}{\contentsline {subsubsection}{\numberline {\mbox  {IV-C}5}Task 4 and Task 5}{4}{subsubsection.4.3.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {IV-D}}MPI Tags}{4}{subsection.4.4}\protected@file@percent }
+\newlabel{sec:tasking-tag}{{\mbox  {IV-D}}{4}{MPI Tags}{subsection.4.4}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {6}{\ignorespaces Program Flow of Synchronous Firing in Task 2}}{5}{figure.6}\protected@file@percent }
+\newlabel{fig:sync-fire}{{6}{5}{Program Flow of Synchronous Firing in Task 2}{figure.6}{}}
+\@writefile{lot}{\contentsline {table}{\numberline {I}{\ignorespaces MPI Tags for the MPI Tasking Approach}}{5}{table.1}\protected@file@percent }
+\newlabel{table:tasking-tag}{{I}{5}{MPI Tags for the MPI Tasking Approach}{table.1}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {V}Performance Expectations and Use Cases}{5}{section.5}\protected@file@percent }
+\newlabel{sec:Task-perf-expec}{{V}{5}{Performance Expectations and Use Cases}{section.5}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {VI}Experimental Setup}{5}{section.6}\protected@file@percent }
+\@writefile{lot}{\contentsline {table}{\numberline {II}{\ignorespaces Task Descriptions and Performance Notes}}{6}{table.2}\protected@file@percent }
+\newlabel{table:tasking-gen-perf}{{II}{6}{Task Descriptions and Performance Notes}{table.2}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {VI-A}}Number of Exploits}{6}{subsection.6.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {VI-B}}Applicability of Exploits}{6}{subsection.6.2}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {7}{\ignorespaces Example of a Not Applicable Exploit for the MPI Tasking Testing}}{6}{figure.7}\protected@file@percent }
+\newlabel{fig:NA-exp}{{7}{6}{Example of a Not Applicable Exploit for the MPI Tasking Testing}{figure.7}{}}
+\citation{cook_rage_2018}
+\citation{li_concurrency_2019}
+\citation{li_combining_2019}
+\citation{Slurm}
+\@writefile{lof}{\contentsline {figure}{\numberline {8}{\ignorespaces Example of an Artificially Applicable Exploit for the MPI Tasking Testing}}{7}{figure.8}\protected@file@percent }
+\newlabel{fig:Appl-exp}{{8}{7}{Example of an Artificially Applicable Exploit for the MPI Tasking Testing}{figure.8}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {VI-C}}Database Load}{7}{subsection.6.3}\protected@file@percent }
+\newlabel{sec:db-stor}{{\mbox  {VI-C}}{7}{Database Load}{subsection.6.3}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {VI-D}}Testing Platform}{7}{subsection.6.4}\protected@file@percent }
+\newlabel{sec:test-platform}{{\mbox  {VI-D}}{7}{Testing Platform}{subsection.6.4}{}}
+\@writefile{toc}{\contentsline {subsection}{\numberline {\mbox  {VI-E}}Testing Process}{7}{subsection.6.5}\protected@file@percent }
+\@writefile{toc}{\contentsline {section}{\numberline {VII}Analysis and Results}{7}{section.7}\protected@file@percent }
+\@writefile{lof}{\contentsline {figure}{\numberline {9}{\ignorespaces Number of Nodes and Number of Exploits (Averaged) vs. Runtime (ms)}}{8}{figure.9}\protected@file@percent }
+\newlabel{fig:nodes-exp}{{9}{8}{Number of Nodes and Number of Exploits (Averaged) vs. Runtime (ms)}{figure.9}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {10}{\ignorespaces Applicability of Exploits (\%) and Database Load (\%) (Averaged) vs. Runtime (ms)}}{8}{figure.10}\protected@file@percent }
+\newlabel{fig:appl-load}{{10}{8}{Applicability of Exploits (\%) and Database Load (\%) (Averaged) vs. Runtime (ms)}{figure.10}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {11}{\ignorespaces Minimum, Maximum, and Mean Speedup of MPI Tasking Across All Problem Sizes}}{9}{figure.11}\protected@file@percent }
+\newlabel{fig:overall-speedup}{{11}{9}{Minimum, Maximum, and Mean Speedup of MPI Tasking Across All Problem Sizes}{figure.11}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {12}{\ignorespaces Minimum, Maximum, and Mean Efficiency of MPI Tasking Across All Problem Sizes}}{9}{figure.12}\protected@file@percent }
+\newlabel{fig:overall-efficiency}{{12}{9}{Minimum, Maximum, and Mean Efficiency of MPI Tasking Across All Problem Sizes}{figure.12}{}}
+\@writefile{toc}{\contentsline {section}{\numberline {VIII}Conclusion and Future Work}{9}{section.8}\protected@file@percent }
+\newlabel{sec:FW}{{VIII}{9}{Conclusion and Future Work}{section.8}{}}
+\citation{Amdahl}
+\citation{Gust}
+\citation{sun}
+\bibdata{Bibliography}
+\bibcite{9678822}{1}
+\bibcite{7993827}{2}
+\bibcite{8652334}{3}
+\bibcite{baloyi_guidelines_2019}{4}
+\bibcite{allman_complying_2006}{5}
+\bibcite{j_hale_compliance_nodate}{6}
+\@writefile{lof}{\contentsline {figure}{\numberline {13}{\ignorespaces Mean Speedup and Efficiency for the Exploit Parameter Across the Number of Compute Nodes}}{10}{figure.13}\protected@file@percent }
+\newlabel{fig:param-exploit}{{13}{10}{Mean Speedup and Efficiency for the Exploit Parameter Across the Number of Compute Nodes}{figure.13}{}}
+\@writefile{lof}{\contentsline {figure}{\numberline {14}{\ignorespaces Mean Speedup and Efficiency for the Applicability of Exploit Parameter Across the Number of Compute Nodes}}{10}{figure.14}\protected@file@percent }
+\newlabel{fig:param-appl}{{14}{10}{Mean Speedup and Efficiency for the Applicability of Exploit Parameter Across the Number of Compute Nodes}{figure.14}{}}
+\@writefile{toc}{\contentsline {section}{References}{10}{section*.1}\protected@file@percent }
+\bibcite{ou_scalable_2006}{7}
+\bibcite{CPSIOT}{8}
+\bibcite{ming_jo}{9}
+\bibcite{cook_rage_2018}{10}
+\bibcite{pacheco_introduction_2011}{11}
+\bibcite{ainsworth_graph_2016}{12}
+\bibcite{yao_efficient_2018}{13}
+\bibcite{zhang_boosting_2017}{14}
+\bibcite{dai_fpgp_2016}{15}
+\bibcite{arifuzzaman_fast_2015}{16}
+\bibcite{yu_construction_2018}{17}
+\bibcite{liakos_memory-optimized_2016}{18}
+\bibcite{balaji_graph_2016}{19}
+\bibcite{noauthor_parmetis_nodate}{20}
+\bibcite{noauthor_boost_nodate}{21}
+\bibcite{cook_scalable_2016}{22}
+\bibcite{li_concurrency_2019}{23}
+\bibcite{9150145}{24}
+\bibcite{7087377}{25}
+\bibcite{10124989}{26}
+\bibcite{li_combining_2019}{27}
+\bibcite{Slurm}{28}
+\bibcite{Amdahl}{29}
+\bibcite{Gust}{30}
+\bibcite{sun}{31}
+\bibstyle{ieeetr}
+\@writefile{toc}{\contentsline {section}{Biographies}{11}{IEEEbiography.0}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{Noah L. Schrick}{11}{IEEEbiography.1}\protected@file@percent }
+\@writefile{toc}{\contentsline {subsection}{Peter J. Hawrylak}{11}{IEEEbiography.2}\protected@file@percent }
+\gdef \@abspage@last{11}

TPDS_Submission/Schrick-Noah_MPI-Tasking.bbl

@@ -0,0 +1,167 @@
+\begin{thebibliography}{10}
+
+\bibitem{9678822}
+N.~Dakhno, O.~Leshchenko, Y.~Kravchenko, A.~Dudnik, O.~Trush, and
+  V.~Khankishiev, ``Dynamic model of the spread of viruses in a computer
+  network using differential equations,'' in {\em 2021 IEEE 3rd International
+  Conference on Advanced Trends in Information Theory (ATIT)}, pp.~111--115,
+  2021.
+
+\bibitem{7993827}
+M.~Kwon, J.~Kwon, B.~Park, and H.~Park, ``An architecture of iptv networks
+  based on network coding,'' in {\em 2017 Ninth International Conference on
+  Ubiquitous and Future Networks (ICUFN)}, pp.~462--464, 2017.
+
+\bibitem{8652334}
+X.~Bai, M.~Liang, and S.~Zhu, ``A new routing scheme for large-scale computer
+  network,'' in {\em 2018 14th IEEE International Conference on Signal
+  Processing (ICSP)}, pp.~1019--1023, 2018.
+
+\bibitem{baloyi_guidelines_2019}
+N.~Baloyi and P.~Kotzé, ``Guidelines for {Data} {Privacy} {Compliance}: {A}
+  {Focus} on {Cyberphysical} {Systems} and {Internet} of {Things},'' in {\em
+  {SAICSIT} '19: {Proceedings} of the {South} {African} {Institute} of
+  {Computer} {Scientists} and {Information} {Technologists} 2019}, (Skukuza
+  South Africa), Association for Computing Machinery, 2019.
+
+\bibitem{allman_complying_2006}
+E.~Allman, ``Complying with {Compliance}: {Blowing} it off is not an option.,''
+  {\em ACM Queue}, vol.~4, no.~7, 2006.
+
+\bibitem{j_hale_compliance_nodate}
+{J. Hale}, P.~Hawrylak, and M.~Papa, ``Compliance {Method} for a
+  {Cyber}-{Physical} {System}.''
+\newblock U.S. Patent Number 9,471,789, Oct. 18, 2016.
+
+\bibitem{ou_scalable_2006}
+X.~Ou, W.~F. Boyer, and M.~A. Mcqueen, ``A {Scalable} {Approach} to {Attack}
+  {Graph} {Generation},'' {\em CCS '06: Proceedings of the 13th ACM conference
+  on Computer and communications security}, pp.~336--345, 2006.
+
+\bibitem{CPSIOT}
+A.~T. Al~Ghazo, M.~Ibrahim, H.~Ren, and R.~Kumar, ``A2g2v: Automated attack
+  graph generator and visualizer,'' in {\em Proceedings of the 1st ACM MobiHoc
+  Workshop on Mobile IoT Sensing, Security, and Privacy}, Mobile IoT SSP'18,
+  (New York, NY, USA), Association for Computing Machinery, 2018.
+
+\bibitem{ming_jo}
+M.~Li, P.~Hawrylak, and J.~Hale, ``Strategies for practical hybrid attack graph
+  generation and analysis,'' {\em Digital Threats}, oct 2021.
+
+\bibitem{cook_rage_2018}
+K.~Cook, ``{RAGE}: {The} {Rage} {Attack} {Graph} {Engine},'' Master's thesis,
+  The {University} of {Tulsa}, 2018.
+
+\bibitem{pacheco_introduction_2011}
+P.~Pacheco, {\em An {Introduction} to {Parallel} {Programming}}.
+\newblock Morgan Kaufmann, print~ed., 2011.
+
+\bibitem{ainsworth_graph_2016}
+S.~Ainsworth and T.~M. Jones, ``Graph prefetching using data structure
+  knowledge,'' {\em Proceedings of the International Conference on
+  Supercomputing}, vol.~01-03-June, 2016.
+
+\bibitem{yao_efficient_2018}
+P.~Yao, L.~Zheng, X.~Liao, H.~Jin, and B.~He, ``An efficient graph accelerator
+  with parallel data conflict management,'' {\em Parallel Architectures and
+  Compilation Techniques - Conference Proceedings, PACT}, 2018.
+
+\bibitem{zhang_boosting_2017}
+J.~Zhang, S.~Khoram, and J.~Li, ``Boosting the performance of {FPGA}-based
+  graph processor using hybrid memory cube: {A} case for breadth first
+  search,'' {\em FPGA 2017 - Proceedings of the 2017 ACM/SIGDA International
+  Symposium on Field-Programmable Gate Arrays}, pp.~207--216, 2017.
+
+\bibitem{dai_fpgp_2016}
+G.~Dai, Y.~Chi, Y.~Wang, and H.~Yang, ``{FPGP}: {Graph} processing framework on
+  {FPGA}: {A} case study of breadth-first search,'' {\em FPGA 2016 -
+  Proceedings of the 2016 ACM/SIGDA International Symposium on
+  Field-Programmable Gate Arrays}, pp.~105--110, 2016.
+
+\bibitem{arifuzzaman_fast_2015}
+S.~Arifuzzaman and M.~Khan, ``Fast parallel conversion of edge list to
+  adjacency list for large-scale graphs,'' in {\em {HPC} '15: {Proceedings} of
+  the {Symposium} on {High} {Performance} {Computing}}, pp.~17--24, Apr. 2015.
+
+\bibitem{yu_construction_2018}
+X.~Yu, W.~Chen, J.~Miao, J.~Chen, H.~Mao, Q.~Luo, and L.~Gu, ``The
+  {Construction} of {Large} {Graph} {Data} {Structures} in a {Scalable}
+  {Distributed} {Message} {System},'' in {\em {HPCCT} 2018: {Proceedings} of
+  the 2018 2nd {High} {Performance} {Computing} and {Cluster} {Technologies}
+  {Conference}}, pp.~6--10, June 2018.
+
+\bibitem{liakos_memory-optimized_2016}
+P.~Liakos, K.~Papakonstantinopoulou, and A.~Delis, ``Memory-{Optimized}
+  {Distributed} {Graph} {Processing} through {Novel} {Compression}
+  {Techniques},'' in {\em {CIKM} '16: {Proceedings} of the 25th {ACM}
+  {International} {Conference} on {Information} and {Knowledge} {Management}},
+  pp.~2317--2322, Oct. 2016.
+
+\bibitem{balaji_graph_2016}
+J.~Balaji and R.~Sunderraman, ``Graph {Topology} {Abstraction} for
+  {Distributed} {Path} {Queries},'' in {\em {HPGP} '16: {Proceedings} of the
+  {ACM} {Workshop} on {High} {Performance} {Graph} {Processing}}, pp.~27--34,
+  May 2016.
+
+\bibitem{noauthor_parmetis_nodate}
+K.~Lab, ``Parmetis - parallel graph partitioning and fill-reducing matrix
+  ordering.''
+\newblock http://glaros.dtc.umn.edu/gkhome/metis/parmetis/overview.
+
+\bibitem{noauthor_boost_nodate}
+J.~Siek, L.-Q. Lee, and A.~Lumsdaine, ``The boost graph library, vers.
+  1.75.0.''
+\newblock
+  https://www.boost.org/doc/libs/1$\_$75$\_$0/libs/graph/doc/index.html.
+
+\bibitem{cook_scalable_2016}
+K.~Cook, T.~Shaw, J.~Hale, and P.~Hawrylak, ``Scalable attack graph
+  generation,'' {\em Proceedings of the 11th Annual Cyber and Information
+  Security Research Conference, CISRC 2016}, 2016.
+
+\bibitem{li_concurrency_2019}
+M.~Li, P.~Hawrylak, and J.~Hale, ``Concurrency {Strategies} for {Attack}
+  {Graph} {Generation},'' {\em Proceedings - 2019 2nd International Conference
+  on Data Intelligence and Security, ICDIS 2019}, pp.~174--179, 2019.
+
+\bibitem{9150145}
+M.~Li, P.~J. Hawrylak, and J.~Hale, ``Implementing an attack graph generator in
+  cuda,'' in {\em 2020 IEEE International Parallel and Distributed Processing
+  Symposium Workshops (IPDPSW)}, pp.~730--738, 2020.
+
+\bibitem{7087377}
+K.~Kaynar and F.~Sivrikaya, ``Distributed attack graph generation,'' {\em IEEE
+  Transactions on Dependable and Secure Computing}, vol.~13, no.~5,
+  pp.~519--532, 2016.
+
+\bibitem{10124989}
+N.~L. Schrick and P.~J. Hawrylak, ``State space explosion mitigation for
+  large-scale attack and compliance graphs using synchronous exploit firing,''
+  {\em IEEE Open Journal of the Computer Society}, vol.~4, pp.~147--157, 2023.
+
+\bibitem{li_combining_2019}
+M.~Li, P.~Hawrylak, and J.~Hale, ``Combining {OpenCL} and {MPI} to support
+  heterogeneous computing on a cluster,'' {\em ACM International Conference
+  Proceeding Series}, 2019.
+
+\bibitem{Slurm}
+SchedMD, ``Slurm {Workload} {Manager}.''
+  https://slurm.schedmd.com/overview.html, Apr. 2023.
+\newblock Version 23.02.
+
+\bibitem{Amdahl}
+G.~M. Amdahl, ``Validity of the single processor approach to achieving large
+  scale computing capabilities,'' in {\em Proceedings of the April 18-20, 1967,
+  Spring Joint Computer Conference}, AFIPS '67 (Spring), (New York, NY, USA),
+  p.~483–485, Association for Computing Machinery, 1967.
+
+\bibitem{Gust}
+J.~L. Gustafson, ``Reevaluating amdahl's law,'' {\em Commun. ACM}, vol.~31,
+  p.~532–533, may 1988.
+
+\bibitem{sun}
+X.-H. Sun and L.~M. Ni, ``Another view on parallel speedup,'' in {\em
+  Proceedings of the 1990 ACM/IEEE conference on Supercomputing}, pp.~324--333,
+  1990.
+
+\end{thebibliography}

TPDS_Submission/Schrick-Noah_MPI-Tasking.blg

@@ -0,0 +1,46 @@
+This is BibTeX, Version 0.99d (TeX Live 2023/Arch Linux)
+Capacity: max_strings=200000, hash_size=200000, hash_prime=170003
+The top-level auxiliary file: Schrick-Noah_MPI-Tasking.aux
+The style file: ieeetr.bst
+Database file #1: Bibliography.bib
+You've used 31 entries,
+            1876 wiz_defined-function locations,
+            645 strings with 9717 characters,
+and the built_in function-call counts, 8129 in all, are:
+= -- 783
+> -- 310
+< -- 0
++ -- 116
+- -- 85
+* -- 528
+:= -- 1109
+add.period$ -- 33
+call.type$ -- 31
+change.case$ -- 31
+chr.to.int$ -- 0
+cite$ -- 31
+duplicate$ -- 454
+empty$ -- 819
+format.name$ -- 85
+if$ -- 2018
+int.to.chr$ -- 0
+int.to.str$ -- 31
+missing$ -- 27
+newline$ -- 101
+num.names$ -- 31
+pop$ -- 151
+preamble$ -- 1
+purify$ -- 0
+quote$ -- 0
+skip$ -- 305
+stack$ -- 0
+substring$ -- 479
+swap$ -- 178
+text.length$ -- 0
+text.prefix$ -- 0
+top$ -- 0
+type$ -- 0
+warning$ -- 0
+while$ -- 72
+width$ -- 33
+write$ -- 287

TPDS_Submission/Schrick-Noah_MPI-Tasking.out

@@ -0,0 +1,27 @@
+\BOOKMARK [1][-]{section.1}{\376\377\000I\000n\000t\000r\000o\000d\000u\000c\000t\000i\000o\000n}{}% 1
+\BOOKMARK [1][-]{section.2}{\376\377\000R\000e\000l\000a\000t\000e\000d\000\040\000W\000o\000r\000k\000s}{}% 2
+\BOOKMARK [1][-]{section.3}{\376\377\000N\000e\000c\000e\000s\000s\000a\000r\000y\000\040\000C\000o\000m\000p\000o\000n\000e\000n\000t\000s}{}% 3
+\BOOKMARK [2][-]{subsection.3.1}{\376\377\000S\000e\000r\000i\000a\000l\000i\000z\000a\000t\000i\000o\000n}{section.3}% 4
+\BOOKMARK [1][-]{section.4}{\376\377\000I\000m\000p\000l\000e\000m\000e\000n\000t\000a\000t\000i\000o\000n\000\040\000o\000f\000\040\000t\000h\000e\000\040\000T\000a\000s\000k\000i\000n\000g\000\040\000A\000p\000p\000r\000o\000a\000c\000h}{}% 5
+\BOOKMARK [2][-]{subsection.4.1}{\376\377\000A\000l\000g\000o\000r\000i\000t\000h\000m\000\040\000D\000e\000s\000i\000g\000n}{section.4}% 6
+\BOOKMARK [2][-]{subsection.4.2}{\376\377\000C\000o\000m\000m\000u\000n\000i\000c\000a\000t\000i\000o\000n\000\040\000S\000t\000r\000u\000c\000t\000u\000r\000e}{section.4}% 7
+\BOOKMARK [2][-]{subsection.4.3}{\376\377\000T\000a\000s\000k\000\040\000B\000r\000e\000a\000k\000d\000o\000w\000n}{section.4}% 8
+\BOOKMARK [3][-]{subsubsection.4.3.1}{\376\377\000T\000a\000s\000k\000\040\0000}{subsection.4.3}% 9
+\BOOKMARK [3][-]{subsubsection.4.3.2}{\376\377\000T\000a\000s\000k\000\040\0001}{subsection.4.3}% 10
+\BOOKMARK [3][-]{subsubsection.4.3.3}{\376\377\000T\000a\000s\000k\000\040\0002}{subsection.4.3}% 11
+\BOOKMARK [3][-]{subsubsection.4.3.4}{\376\377\000T\000a\000s\000k\000\040\0003}{subsection.4.3}% 12
+\BOOKMARK [3][-]{subsubsection.4.3.5}{\376\377\000T\000a\000s\000k\000\040\0004\000\040\000a\000n\000d\000\040\000T\000a\000s\000k\000\040\0005}{subsection.4.3}% 13
+\BOOKMARK [2][-]{subsection.4.4}{\376\377\000M\000P\000I\000\040\000T\000a\000g\000s}{section.4}% 14
+\BOOKMARK [1][-]{section.5}{\376\377\000P\000e\000r\000f\000o\000r\000m\000a\000n\000c\000e\000\040\000E\000x\000p\000e\000c\000t\000a\000t\000i\000o\000n\000s\000\040\000a\000n\000d\000\040\000U\000s\000e\000\040\000C\000a\000s\000e\000s}{}% 15
+\BOOKMARK [1][-]{section.6}{\376\377\000E\000x\000p\000e\000r\000i\000m\000e\000n\000t\000a\000l\000\040\000S\000e\000t\000u\000p}{}% 16
+\BOOKMARK [2][-]{subsection.6.1}{\376\377\000N\000u\000m\000b\000e\000r\000\040\000o\000f\000\040\000E\000x\000p\000l\000o\000i\000t\000s}{section.6}% 17
+\BOOKMARK [2][-]{subsection.6.2}{\376\377\000A\000p\000p\000l\000i\000c\000a\000b\000i\000l\000i\000t\000y\000\040\000o\000f\000\040\000E\000x\000p\000l\000o\000i\000t\000s}{section.6}% 18
+\BOOKMARK [2][-]{subsection.6.3}{\376\377\000D\000a\000t\000a\000b\000a\000s\000e\000\040\000L\000o\000a\000d}{section.6}% 19
+\BOOKMARK [2][-]{subsection.6.4}{\376\377\000T\000e\000s\000t\000i\000n\000g\000\040\000P\000l\000a\000t\000f\000o\000r\000m}{section.6}% 20
+\BOOKMARK [2][-]{subsection.6.5}{\376\377\000T\000e\000s\000t\000i\000n\000g\000\040\000P\000r\000o\000c\000e\000s\000s}{section.6}% 21
+\BOOKMARK [1][-]{section.7}{\376\377\000A\000n\000a\000l\000y\000s\000i\000s\000\040\000a\000n\000d\000\040\000R\000e\000s\000u\000l\000t\000s}{}% 22
+\BOOKMARK [1][-]{section.8}{\376\377\000C\000o\000n\000c\000l\000u\000s\000i\000o\000n\000\040\000a\000n\000d\000\040\000F\000u\000t\000u\000r\000e\000\040\000W\000o\000r\000k}{}% 23
+\BOOKMARK [1][-]{section*.1}{\376\377\000R\000e\000f\000e\000r\000e\000n\000c\000e\000s}{}% 24
+\BOOKMARK [1][-]{IEEEbiography.0}{\376\377\000B\000i\000o\000g\000r\000a\000p\000h\000i\000e\000s}{}% 25
+\BOOKMARK [2][-]{IEEEbiography.1}{\376\377\000N\000o\000a\000h\000\040\000L\000.\000\040\000S\000c\000h\000r\000i\000c\000k}{IEEEbiography.0}% 26
+\BOOKMARK [2][-]{IEEEbiography.2}{\376\377\000P\000e\000t\000e\000r\000\040\000J\000.\000\040\000H\000a\000w\000r\000y\000l\000a\000k}{IEEEbiography.0}% 27

TPDS_Submission/Schrick-Noah_MPI-Tasking.tex

@@ -0,0 +1,392 @@
+\documentclass[lettersize,journal]{IEEEtran}
+\usepackage{cite}
+\usepackage{amsmath,amssymb,amsfonts}
+\usepackage{algorithmic}
+\usepackage{algorithm}
+\usepackage[caption=false,font=normalsize,labelfont=sf,textfont=sf]{subfig}
+\usepackage{array}
+\usepackage{stfloats}
+\usepackage{url}
+\usepackage{verbatim}
+\usepackage{graphicx}
+\graphicspath{ {./images/} }
+\usepackage{babel} % Bibliography
+\usepackage{textcomp}
+\usepackage[utf8]{inputenc}
+\usepackage{float}
+\usepackage{xcolor}
+\usepackage{orcidlink}
+
+\def\BibTeX{{\rm B\kern-.05em{\sc i\kern-.025em b}\kern-.08em
+    T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}}
+\hyphenation{op-tical net-works semi-conduc-tor IEEE-Xplore}
+    
+\begin{document}
+
+\title{Parallelization of Large-Scale Attack and Compliance Graph Generation Using Message-Passing Interface
+}
+
+\author{NOAH L. SCHRICK\,\orcidlink{0000-0003-0875-8927}~\IEEEmembership{Member,~IEEE,}, AND PETER J. HAWRYLAK\,\orcidlink{0000-0003-3268-7452},~\IEEEmembership{Senior Member,~IEEE,}
+        %
+\thanks{The authors are affiliated with the Tandy School of Computer Science, Department of Computer Science, University of Tulsa, Tulsa, 
+OK 74104 USA (e-mail: noah-schrick@utulsa.edu, peter-hawrylak@utulsa.edu).}}%
+\maketitle
+
+\begin{abstract}
+Large-scale attack and compliance graphs can be used for detecting, preventing, and correcting cybersecurity or compliance violations with a system or set of systems. However, as modern-day networks expand in size, and as the number of possible exploits and regulation mandates increase, large-scale attack and compliance graphs can seldom be feasibly generated through serial means. This work presents a parallelized generation process that leverages Message-Passing Interface (MPI) for distributed computing. A task parallelism approach was implemented that includes compatibility for a hybrid MPI-OpenMPI graph generation. This approach was deployed on a High-Performance Computing (HPC) system where a large amount of performance data was collected to capture and conduct a comprehensive analysis on the approach. This work discusses the need for this approach, describes the design process and experimental setup, and illustrates the success that was obtained through speedup and efficiency metrics.
+\end{abstract}
+
+\begin{IEEEkeywords}
+Attack Graph; Compliance Graph; MPI; High-Performance Computing; Cybersecurity; Compliance and Regulation; Speedup; Parallelism;
+\end{IEEEkeywords}
+
+\section{Introduction} \label{sec:Intro}
+As the size of computer networks continues to grow, cybersecurity analysts are tasked to mitigate risk with increasing difficulty. The authors of \cite{9678822}, \cite{7993827}, and \cite{8652334} discuss how the rapidly expanding network sizes bring about drastic changes along with the requirement to shift and refocus to accommodate the expansion. This includes presenting novel architectures to support the ever-growing IPTV networks, examinations of computer viruses through epidemiology modeling, and evaluations of new routing schemes. In recent years, a greater usage of cyber-physical systems and a growing adoption of the Internet of Things (IoT) also contributes to an increased need for risk mitigation across varying types of networks, as discussed by the authors of \cite{baloyi_guidelines_2019}, \cite{allman_complying_2006}, and \cite{j_hale_compliance_nodate}. One approach for analyzing the large number of hosts (assets) and growing lists of exploits is to automate the generation of attack or compliance graphs for later use. Attack and compliance graphs are directed acyclic graphs (DAGs) that typically represent one or many systems as nodes in a graph, and any changes that could be made to them as edges. The automation of these graphs has been used and presented by authors such as \cite{ou_scalable_2006}, \cite{CPSIOT}, and \cite{ming_jo}. The graph generators will take system information and exploits to check for as input, and will exhaustively draw all possible ways that the systems may be at risk of a cybersecurity attack or at risk of violating a compliance regulation or mandate. If a system is able to be modified through a setting change (regardless of intent), have its compliance standing altered, or have a policy updated, an edge is drawn from that node to a new node with the changed system properties. This process is repeated until all possible alterations are identified and represented in the resulting attack or compliance graph.
+
+Due to the expansion in network size, and with the inclusion of IoT and cyber-physical devices, the generation of attack and compliance graph quickly becomes difficult with the large number of assets needed to be processed. In addition, the number of regulatory and compliance checks, the large number of exploit and vulnerability entries available, and any custom internal standard checks or zero-day scripting causes a state space explosion in the graph generation process. As a result, real-world graphs become infeasible to generate and process serially.
+
+The attack and compliance graph generation is a viable process to parallelize and deploy on High-Performance Computing (HPC) environments, and related parallel and speedup works are discussed in Section \ref{sec:rel_works}. This work presents an extension to RAGE (RAGE Attack Graph Engine) \cite{cook_rage_2018} to function on distributed computing environments to take advantage of the increased computing power using message-passing. As mentioned by the author of \cite{pacheco_introduction_2011}, MPI is a widely used message-passing API, and one goal of this work was to utilize an API that was not only familiar and accessible, but versatile and powerful for parallelizing RAGE for distributed computing platforms. This work discusses a task parallelism approach for the generation process, and uses OpenMPI for the MPI implementation.
+
+\section{Related Works} \label{sec:rel_works}
+For architectural and hardware techniques for general graph generation improvement, the authors of \cite{ainsworth_graph_2016} discuss the high cache miss rate, and how general prefetching
+does not increase the prediction rate due to nonsequential graph structures and data-dependent access patterns. However, the authors continue to discuss that generation algorithms are known in advance, so explicit tuning of the hardware prefetcher to follow the traversal order pattern can lead to better performance. The authors were able to achieve over 2x performance improvement of a breadth-first search approach with this method. 
+Another hardware approach is to make use of accelerators. The authors of \cite{yao_efficient_2018} present an approach for minimizing the slowdown caused by the underlying graph atomic functions. By using the atomic function patterns, the authors utilized pipeline stages where vertex updates can be processed in parallel dynamically. 
+Other works, such as those by the authors of \cite{zhang_boosting_2017} and \cite{dai_fpgp_2016}, leverage field-programmable gate arrays (FPGAs) for graph generation in the HPC space through various means. This includes reducing memory strain, storing repeatedly accessed lists, storing results, or other storage through the on-chip block RAM, or even leveraging Hybrid Memory Cubes for optimizing parallel access.
+
+From a data structure standpoint, the authors of \cite{arifuzzaman_fast_2015} describe the infeasibility of adjacency matrices in large-scale graphs, and this work and other works such as those by the authors of \cite{yu_construction_2018} and \cite{liakos_memory-optimized_2016} discuss the appeal of distributing a graph representation across systems.
+The author of \cite{liakos_memory-optimized_2016} discusses the usage of distributed adjacency lists for assigning vertices to workers. 
+The authors of \cite{liakos_memory-optimized_2016} and \cite{balaji_graph_2016} present other techniques for minimizing communication costs by achieving high compression ratios while maintaining a low compression cost. 
+The Boost Graph Library and the Parallel Boost Graph Library both provide appealing features for working with graphs, with the latter library notably having interoperability with MPI, Graphviz, and METIS \cite{noauthor_parmetis_nodate}, \cite{noauthor_boost_nodate}. 
+
+There have also been numerous approaches at generation improvement specific to attack graphs. As a means of improving scalability of attack graphs, the authors of \cite{ou_scalable_2006} present a new representation scheme. Traditional attack graphs encode the entire network at each state, but the representation presented by the authors uses logical statements to represent a portion of the network at each node. This is called a logical attack graph. This approach led to the reduction of the generation process to quadratic time and reduced the number of nodes in the resulting graph to $\mathcal{O}({n}^2)$. However, this approach does require more analysis for identifying attack vectors. 
+Another approach presented by the authors of \cite{cook_scalable_2016} represents a description of systems and their qualities and topologies as a state, with a queue of unexplored states. 
+This work was continued by the authors of \cite{li_concurrency_2019} by implementing a hash table among other features. Each of these works demonstrates an improvement in scalability through refining the desirable information output.
+
+Another approach for generation improvement is through parallelization. The authors of \cite{li_concurrency_2019} leverage OpenMP to parallelize the exploration of a FIFO queue. This parallelization also includes the utilization of OpenMP's dynamic scheduling. In this approach, each thread receives a state to explore, where a critical section is employed to handle the atomic functions of merging new state information while avoiding collisions, race conditions, or stale data usage. The authors measured a 10x speedup over the serial algorithm. 
+The authors of \cite{9150145} present a parallel generation approach using CUDA, where speedup is obtained through a large number of CUDA cores. 
+For a distributed approach, the authors of \cite{7087377} present a technique for utilizing reachability hyper-graph partitioning and a virtual shared memory abstraction to prevent duplicate work by multiple nodes. This work had promising results in terms of speedup and in limiting the state-space explosion as the number of network hosts increases.
+
+\section{Necessary Components}
+\subsection{Serialization}
+In order to distribute workloads across nodes in a distributed system, various
+types of data will need to be sent and received. Support and mechanisms vary based 
+on the MPI implementation, but most fundamental data types such as integers, doubles,
+characters, and Booleans are incorporated into the MPI implementation. While this does
+simplify some of the messages that need to be sent and received in the MPI approaches of
+attack and compliance graph generation, it does not cover the vast majority of them when using RAGE.
+
+RAGE implements many custom classes and structs that are used throughout the generation process.
+Qualities, topologies, network states, and exploits are a few such examples. Rather than breaking
+each of these down into fundamental types manually, serialization functions are leveraged to handle
+most of this. RAGE already incorporates Boost graph libraries for auxiliary support, so this work
+extended this further to utilize the serialization libraries also provided by Boost. These
+libraries also include support for serializing all STL classes, and many of the RAGE 
+classes have members that make use of the STL classes. One additional advantage of the Boost 
+library approach is that many of the RAGE classes are nested. For example, the NetworkState
+class has a member vector of Quality classes, and the Quality class has a Keyvalue class as a member. When serializing the NetworkState class, Boost will
+recursively serialize all members, including the custom class members, assuming they also have
+serialization functions.
+
+When using the serialization libraries, this work opted to use the intrusive route, where the
+class instances are altered directly. This was preferable to the non-intrusive approach, since 
+the class instances were able to be altered with relative ease, and many of the class instances 
+did not expose enough information for the non-intrusive approach to be viable.  
+
+\section{Implementation of the Tasking Approach} \label{sec:Tasking-Approach}
+The high-level overview of the attack and compliance graph generation process can be broken down into six main tasks.
+These tasks are described in Figure \ref{fig:tasks}. Prior works such as that seen by the 
+authors of \cite{li_concurrency_2019}, \cite{9150145}, and \cite{7087377} work to parallelize the graph generation using
+OpenMP, CUDA, and hyper-graph partitioning. This approach, however, utilizes Message Passing Interface (MPI)
+to distribute the six identified tasks of RAGE to examine the effect on speedup, efficiency, and scalability for 
+attack and compliance graph generation.
+
+\begin{figure}[htp]
+    \includegraphics[width=\linewidth]{"./images/schri1.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Overview of the Tasking Pipeline for the Attack and Compliance Graph Generation Process}
+        \label{fig:tasks}
+\end{figure}
+
+\subsection{Algorithm Design}
+The design of the tasking approach is to leverage a pipeline structure with the six tasks and MPI nodes. After its completion, each stage of the pipeline will pass the necessary data to the next stage through various MPI messages, where the next stage's nodes will receive the data and execute their tasks. The pipeline is considered fully saturated when each task has a dedicated node solely for executing work for that task. When there are less nodes than tasks, some nodes will process multiple tasks. When there are more nodes than tasks, additional nodes will be assigned to Tasks 1 and 2. Timings were collected in the serial approach for various networks that displayed more time requirements for Tasks 1 and 2, with larger network sizes requiring vastly more time to be taken in Tasks 1 and 2. As a result, additional nodes are assigned to Tasks 1 and 2. Node allocation can be seen in Figure \ref{fig:node-alloc}; where ``world.size()" is an integer value representing the number of nodes used in the program, and ``num$\_$tasks" is an integer value representing the number of tasks used in the pipeline. By using a variable for the number of tasks, it allows for modular usage of the pipeline, where tasks can be added and removed without needing to change any allocation logic work; only communication between tasks may need to be modified, and the allocation can be adjusted relatively simply to include new tasks. 
+
+For determining which tasks should be handled by the root note, a few considerations were made, where minimizing communication cost and avoiding unnecessary complexity were the main two considerations. In the serial approach, the frontier queue was the primary data structure for the majority of the generation process. Rather than using a distributed queue or passing multiple sub-queues between nodes, the minimum cost option is to pass states individually. This approach also assists in reducing the complexity. Managing multiple frontier queues would require duplication checks, multiple nodes requesting data from and storing data into the database, and devising a strategy to maintain proper queue ordering, all of which would also increase the communication cost. As a result, the root node will be dedicated to Tasks 0 and 3.
+
+\begin{figure}[htp]
+    \includegraphics[width=\linewidth]{"./images/schri2.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Node Allocation for each Task}
+        \label{fig:node-alloc}
+\end{figure}
+
+\subsection{Communication Structure}
+The underlying communication structure for the tasking approach relies on a pseudo-ring structure. As seen in Figure \ref{fig:node-alloc}, nodes n$_2$, n$_3$, and n$_4$ are derived from the previous task's greatest node rank. To keep the development abstract, a custom send function checks the world size (``world.size()") before sending. If the rank of the node that would receive a message is greater than the world size and therefore does not exist, the rank would then be ``looped around" and corrected to fit within the world size constraints. After the rank correction, the MPI Send function was then invoked with the proper node rank.
+
+\subsection{Task Breakdown}
+\subsubsection{Task 0}
+Task 0 is performed by the root node, and is a conditional task; it is not guaranteed to be executed at each pipeline iteration. Task 0 is only executed when the frontier is empty, but the database still holds unexplored states. This occurs when there are memory constraints, and database storage is performed during execution to offload the demand. Additional detail is discussed in Section \ref{sec:db-stor}. After the completion of Task 0, the frontier has a state popped, and the root node sends the state to n$_1$. If the frontier is empty, the root node sends the finalize signal to all nodes.
+
+\subsubsection{Task 1}
+Task 1 begins by distributing the workload between nodes based on the local task communicator rank. Rather than splitting the exploit list at the root node and sending sub-lists to each node allocated to Task 1, each node checks its local communicator rank and performs a modulo operation with the number of nodes allocated to determine whether it should proceed with the current iteration of the exploit loop. Since the exploit list is static, each node has the exploit list initialized prior to the generation process, and communication cost can be avoided from sending sub-lists to each node. Each node in Task 1 works to compile a reduced exploit list that is applicable to the current network state. A breakdown of the Task 1 workload distribution can be seen in Figure \ref{fig:Task1-Data-Dist}.
+
+\begin{figure}[htp]
+    \includegraphics[width=\linewidth]{"./images/schri3.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Data Distribution of Task One}
+        \label{fig:Task1-Data-Dist}
+\end{figure}
+
+Once the computation work of Task 1 is completed, each node must send their compiled applicable exploit list to Task 2. Rather than merging all lists and splitting them back out in Task 2, each node in Task 1 will send an applicable exploit list to at most one node allocated to Task 2. Based on the allocation of nodes seen in Figure \ref{fig:node-alloc}, there are 2 potential cases: the number of nodes allocated to Task 1 is equal to the number of nodes allocated to Task 2, or the number of nodes allocated to Task 1 is one greater than the number of nodes allocated to Task 2. For the first case, each node in Task 1 sends the applicable exploit list to its global rank+n$_1$. This case can be seen in Figure \ref{fig:Task1-Case1}. For the second case, since there are more nodes allocated to Task 1 than Task 2, node n$_1$ scatters its partial applicable exploit list in the local Task 1 communicator, and all other Task 1 nodes follow the same pattern seen in the first case. This second case can be seen in Figure \ref{fig:Task1-Case2}.
+
+\begin{figure}[htp]
+    \includegraphics[width=\linewidth]{"./images/schri4.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Communication From Task 1 to Task 2 when the Number of Nodes Allocated is Equal}
+        \label{fig:Task1-Case1}
+\end{figure}
+
+\begin{figure}[htp]
+    \includegraphics[width=\linewidth]{"./images/schri5.png"}
+    \vspace{.2truein} \centerline{}
+        \caption[Task 1 to Task 2 Communication, Case 2]{Communication From Task 1 to Task 2 when Task 1 Has More Nodes Allocated}
+        \label{fig:Task1-Case2}
+\end{figure}
+
+\subsubsection{Task 2}
+Each node in Task 2 iterates through the received partial applicable exploit list and creates new states with edges to the current state. Part of Task 2's workload is to handle a feature called synchronous firing \cite{10124989}. This feature allows for a grouping of assets. Rather than an exploit firing separately across all assets, synchronous firing allows for an exploit to fire one time, simultaneously across a group of assets. Syncing multiple exploits that could be distributed across multiple nodes leads to additional overhead and complexity. To prevent these difficulties, each node checks its partial applicable exploit list for exploits that are part of a group, removes these exploits from its list, and sends the exploits belonging to a group to the Task 2 local communicator root. Since the Task 2 local root now contains all group exploits, it can execute the synchronous firing work without additional communication or synchronization between other MPI nodes in the Task 2 stage. Other than the additional setup steps required for synchronous firing for the local root, all work performed during this task by all MPI nodes is that seen from the synchronous firing figure (Figure \ref{fig:sync-fire}).
+
+\begin{figure}[htp]
+    \includegraphics[width=0.8\linewidth]{"./images/schri6.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Program Flow of Synchronous Firing in Task 2}
+        \label{fig:sync-fire}
+\end{figure}
+
+\subsubsection{Task 3}
+Task 3 is performed only by the root node, and no division of work is necessary. The root node will continuously check for new states until the Task 2 finalize signal is detected. This task consists of setting the new state's ID, adding it to the frontier, adding its information to the instance, and inserting information into the hash map. When the root node has processed all states and has received the Task 2 finalize signal, it will complete Task 3 by sending the instance and/or frontier to Task 4 and/or 5, respectively if applicable, then proceed to Task 0.
+
+\subsubsection{Task 4 and Task 5} \label{sec:T4T5}
+Intermediate database operations, though not frequent and may never occur for small graphs, are lengthy and time-consuming when they do occur. As discussed in Section \ref{sec:db-stor}, the two main memory consumers are the frontier and the instance, both of which are contained by the root node's memory. Since the database storage requests are blocking, the pipeline would halt for a lengthy period of time while waiting for the root node to finish potentially two large storages. Tasks 4 and 5 work to alleviate the stall by executing independently of the regular pipeline execution flow. Since Tasks 4 and 5 do not send any data, no other tasks must wait for these tasks to complete. The root node can then asynchronously send the frontier and instance to the appropriate nodes as needed, clear its memory, and continue execution without delay. After initial testing, it was determined that the communication cost of the asynchronous sending of data for Tasks 4 and 5 is less than the time requirement of a database storage operation if performed by the root node.
+
+\subsection{MPI Tags} \label{sec:tasking-tag}
+To ensure that the intended message is received by each node, the MPI message envelopes have their tag fields specified. When a node sends a message, it specifies a tag that corresponds with the data and intent for which it is sent. The tag values were arbitrarily chosen, and tags can be added to the existing list or removed as desired. When receiving a message, a node can specify to only look for messages that have an envelope with a matching tag field. Not only do tags ensure that nodes are receiving the correct messages, they also reduce complexity for program design. Table \ref{table:tasking-tag} displays the list of tags used for the MPI Tasking approach.
+
+\begin{table}[] 
+    \centering
+    \begin{tabular}{|c|c|}
+    \hline
+    \textbf{Tag} & \textbf{Description}                                \\ \hline
+    2            & Task 2 Finalize Signal                              \\ \hline
+    3            & Fact for Hash Map Update                            \\ \hline
+    4            & NetworkState for Hash Map Update                    \\ \hline
+    5            & NetworkState to be Added to the Frontier            \\ \hline
+    6            & Current NetworkState Reference for Edge Creation    \\ \hline
+    7            & Factbases for Task 4                                \\ \hline
+    8            & Edges for Task 4                                    \\ \hline
+    9            & Group Exploit Vectors for Local Root in Task 2      \\ \hline
+    10           & Exploit Reference for Task 3 Work                   \\ \hline
+    11           & AssetGroup Reference for Task 3 Work                \\ \hline
+    14           & Continue Signal                                     \\ \hline
+    15           & Finalize Signal                                     \\ \hline
+    20           & Current NetworkState Reference for Task 1           \\ \hline
+    21           & Applicable Exploit Vector Scatter for Task 1 Case 2 \\ \hline
+    30           & Applicable Exploit Vector Send to Task 2            \\ \hline
+    40           & NetworkState Send to Task 2                         \\ \hline
+    50           & NetworkState to Store in Task 5                     \\ \hline
+    \end{tabular}
+    \caption{MPI Tags for the MPI Tasking Approach}
+    \label{table:tasking-tag}
+\end{table}
+
+\section{Performance Expectations and Use Cases} \label{sec:Task-perf-expec}
+Due to the amount of communication between nodes to distribute the necessary data through all stages of the tasking pipeline, this approach is not expected to outperform the serial approach in all cases. This tasking approach was specifically designed to reduce the computation time when the generation of each individual state increases in time. This approach does not offer any guarantees of processing through the frontier at an increased rate; it's main objective is to distribute the workload of individual state generation. As discussed in Section \ref{sec:Intro}, the amount of entries in the National Vulnerability database and any custom vulnerability testing to ensure adequate examination of all assets in the network sums to large number of exploits in the exploit list. Likewise for compliance graphs and compliance examinations, Section \ref{sec:Intro} also discussed that the number of compliance checks for SOX, HIPAA, GDPR, PCI DSS, and/or any other regulatory compliance also sums to a large number of compliance checks in the exploit list. Since the generation of each state is largely dependent on the number of exploits present in the exploit list, this approach is best-suited for when the exploit list grows in size. As will be later discussed, it is also hypothesized that this approach is well-suited when many database operations occur.
+
+\section{Experimental Setup}
+In order to capture a comprehensive image of the tasking approach's impact on performance, a number of parameters were altered and the generation properties were examined. Table \ref{table:tasking-gen-perf} presents each task and the parameters that affect the performance of each task. Generating larger graphs would increase the runtime, but does not necessarily stress each task or provide a consistent, reliable way to draw conclusions regarding the tasking approach. In order to ensure consistency across the experimental testing and minimize the possibility of introducing bias, all tests generated the exact same graph. All tests would generate the same graph with identical numbers of states, identical numbers of edges, identical labeling, and identical inner workings and underlying properties. The following subsections describe the altered parameters, the manner in which they were altered, and how data integrity of the resulting graph was preserved. The parameter alteration process focused on avoiding artificial inflation of the performance metrics, and each subsection emphasizes the practicality of each altered parameter.
+
+\begin{table}[]
+    \centering
+    \begin{tabular}{|c|c|c|}
+    \hline
+    \textbf{Task}
+     & \textbf{Shortened Description} 
+     & \textbf{\begin{tabular}[c]{@{}c@{}}Performance\\ Affected By\end{tabular}} 
+    \\ \hline
+    0  & Retrieve Next State & Database Load \\ \hline
+    1  & \begin{tabular}[c]{@{}c@{}}Compile List of \\ Applicable Exploits\end{tabular} & Number of Exploits \\ \hline
+    2  & \begin{tabular}[c]{@{}c@{}}Loop through List of\\ Applicable Exploits\end{tabular} & \begin{tabular}[c]{@{}c@{}}Number of\\ Applicable Exploits\end{tabular}    \\ \hline
+    3  & Bookkeeping & Number of States \\ \hline
+    4  & \begin{tabular}[c]{@{}c@{}}C/R and/or memory\\ clear of graph instance\end{tabular} & Database Load                                                              \\ \hline
+    5  & \begin{tabular}[c]{@{}c@{}}C/R and/or memory\\ clear of frontier\end{tabular}       & Database Load  \\ \hline
+    \end{tabular}
+    \caption{Task Descriptions and Performance Notes}
+    \label{table:tasking-gen-perf}
+    \end{table}
+
+\subsection{Number of Exploits}
+Task 1 loops through the number of exploits and checks each exploit against the list of assets to see if an exploit is applicable at the current state. As the number of exploits grows, the time taken for Task 1 will increase accordingly. The exploit list used by Task 1 does not need to be applicable to the current asset or state, or even to any asset or any state. Regardless of if the exploit is applicable or not, Task 1 still loops through the entirety of the exploit list to check if any exploit may be applicable. Therefore, to prevent state-space explosion but still gather valid results, each exploit list in the tests contained a set of exploits that could be applicable, and all remaining exploits were not applicable. The not applicable exploits were created in a fashion similar to that seen in Figure \ref{fig:NA-exp}. By creating a multitude of not applicable exploits, the exploit list is able to be artificially increased, which ensures that the resulting graph maintains the same number of states, edges, and identical properties. For the experimental setup, the original exploit list begins with a size of 6, and artificially doubles in size until a final set of graphs is generated using an exploit size of 49,152 exploits. A Python script was used to generate the exploit lists.
+
+\begin{figure}[htp]
+    \centering
+    \includegraphics[scale=0.5]{"./images/schri7.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Example of a Not Applicable Exploit for the MPI Tasking Testing}
+        \label{fig:NA-exp}
+\end{figure}
+
+\subsection{Applicability of Exploits}
+When the number of exploits is artificially increased, the runtime for the overall generation process also increases. However, solely increasing the number of exploits adds a strain on only Task 1; Tasks 0, 2, 3, 4, and 5 are not adequately stress tested through the number of exploits alone. As a result, additional parameters will need to be altered to capture a thorough image of the tasking performance. 
+
+One parameter that can be carefully altered without affecting the resulting graph is the applicability of exploits. As the number of exploits applicable to any state grows, the runtime for Task 2 similarly increases since it must process all applicable exploits and generate new states and edges from the current state. In order for an exploit to be applicable and to not change the resulting graph, the exploit needs to have a precondition that is universally true, with a postcondition that has no effect. For the automobile example, an alteration to the ``not applicable" exploit seen in Figure \ref{fig:NA-exp} can be performed. The new, artificially applicable exploit can be seen in Figure \ref{fig:Appl-exp}. These artificial exploits will be applicable for any asset at any state in the test network, since no car in this example will ever posses a quality that allows it to fly. Likewise, though the exploit will be processed, the postcondition updates the car quality to match the quality it already contains (``flying$\_$car=false" is instantiated in the input network model). The update keyword in the postcondition still triggers the update function, even if no change is actually made. By updating the car quality in this manner, it is ensured that no change to the resulting graph is made, while still gathering accurate timing data and not skipping any functions called in Task 2. 
+
+In RAGE, when an applicable exploit is processed, a new state is always created. The new state is hashed, and its hash is compared to the known hashes. If the hash already exists, the state is discarded and program flow continues. If the hash had not been seen, then the state is added to the instance and frontier. Due to this behavior, it is ensured that the approach for the artificially applicable exploits can capture realistic performance data. In the case of the artificially applicable exploit, the new state is still created and hashed, timing data is captured, and the new state is then discarded along with its edges.
+
+The applicability of exploits was tested by using percentages of overall exploits, excluding the 6 base exploits. The artificial exploits were generated with a Python script based on the example seen in Figure \ref{fig:Appl-exp}. As an illustration, in the case were there are 12 total exploits, the applicability of exploits tests the performance when a percentage of the total exploits were applicable, following the example shown below:
+\begin{itemize}
+    \item{0\% (floor(0.00 * (12-6 base exploits)) = 0 exploits)}
+    \item{25\% (floor(0.25 * (12-6 base exploits)) = 1 exploit)}
+    \item{50\% (floor(0.50 * (12-6 base exploits)) = 3 exploits)}
+    \item{75\% (floor(0.75 * (12-6 base exploits)) = 4 exploits)}
+    \item{100\% (floor(1.00 * (12-6 base exploits)) = 6 exploits)}
+\end{itemize}
+
+\begin{figure}[htp]
+    \centering
+    \includegraphics[scale=0.5]{"./images/schri8.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Example of an Artificially Applicable Exploit for the MPI Tasking Testing}
+        \label{fig:Appl-exp}
+\end{figure}
+
+\subsection{Database Load} \label{sec:db-stor}
+The database load parameter is a parameter passed to RAGE to determine when to offload data. The generation of large-scale attack and compliance graphs often faces challenges with scalability and state space explosion. For these large-scale graphs, as the generation process progresses, the resulting graph and the queue of unexplored states begins to consume too much memory for most systems, and the process either needs to offload the data or run the risk of its process being killed for constraints on memory consumption. Works by the authors of \cite{cook_rage_2018}, \cite{li_concurrency_2019}, and \cite{li_combining_2019} strive for maximum performance of the generation process, which involves making full use of system memory. Since network operations, database operations, and reading and writing from disks slows the generation, it is often preferred to store all data in memory. As a result, there is a balance between performance and system memory consumption. 
+
+RAGE has the option for automatically offloading to a PostgreSQL database based on its memory consumption. The database load parameter can either be a float between 0 and 1, or can be an integer greater than 1. If the parameter is a float, RAGE will automatically offload its graph instance or frontier if the memory consumed by either exceeds a percentage of total system memory corresponding to the float value. If the parameter is an integer greater than 1, RAGE wil automatically offload its graph instance or frontier if the number of items in either is greater than the parameter value.
+
+Since the goal of the stress tests is to generate identical graphs for all tests while still stressing each task, the load parameter was carefully altered. The total number of states generated by RAGE is known in advance since the resulting graph has already been generated, and will be constant for all stress tests. For the automobile example being tested, the total number of states is 394. In order to test the database load, it is preferable to use an integer value for the load parameter rather than a float. By using an integer value, it is possible to specifically target how often the offloading process should occur. If a float value was used, additional work would be needed to give RAGE only a certain amount of system memory per test. Though possible, there is more simplicity with passing in static integer values since the graph is known in advance.
+
+The database load parameter was changed based on percentage of the total resulting graph size, as follows:
+\begin{itemize}
+    \item{0\% Load (Do not ever write to the database) - DBLoad = 395}
+    \item{25\% Load (Write to the database when 25\% of the total resulting graph size is in memory) - DBLoad = 296}
+    \item{50\% Load (Write to the database when 50\% of the total resulting graph size is in memory) - DBLoad = 197}
+    \item{75\% Load (Write to the database when 75\% of the total resulting graph size is in memory) - DBLoad = 79}
+    \item{100\% Load (Write to the database on every new state) - DBLoad = 1}
+\end{itemize}
+
+The database load parameter stresses Tasks 0, 4, and 5. Task 4 will be stress tested on all load parameters, except for when the load is 0\% (size 395), which serves as the control. Task 4 will experience the greatest workload when the load parameter is 100\% (size 1), since as soon as new states are discovered in previous tasks, Task 4 will begin. Task 0 and Task 5 will experience stress at the same intervals. When the queue of unexplored states increases to a size greater than the load parameter, Task 5 will empty the queue, and Task 0 will be forced to pull new states from the database.
+
+\subsection{Testing Platform} \label{sec:test-platform}
+All data was collected on a 13 node cluster, with 12 nodes serving as dedicated compute nodes, and 1 node serving as the login node. Each compute node has a configuration as follows:
+\begin{itemize}
+\item{OS: CentOS release 6.9}
+\item{CPU: Two Intel Xeon E5-2620 v3}
+\item{Two Intel Xeon Phi Co-Processors}
+\item{One FPGA (Nallatech PCIE-385n A7 Altera Stratix V)}
+\item{Memory: 64318MiB}
+\end{itemize}
+All nodes are connected with a 10Gbps Infiniband interconnect.
+
+\subsection{Testing Process}
+Each parameter discussed in this section was individually changed until all permutations of parameters were explored. In addition to changing the parameters, all tests were conducted on a varying number of nodes. All permutations of parameters were examined on 1 compute node (serially) through 12 compute nodes. A bash script for looping through parameters was created on the distributed computing testing platform, with jobs sent to Slurm Workload Manager \cite{Slurm}. When a job is completed with Slurm, the bash script would use grep on the output file to extract the necessary data, and add it to a CSV file that was used for the data analysis.
+
+\section{Analysis and Results}
+Due to a limited amount of compute time, only preliminary results were gathered, instead of deploying the entire testing benchmark suite. For the local University cluster, job allocations had a fixed amount of allowed runtime prior to job scheduler termination. Users were also permitted only a limited amount of concurrent job allocations. With a limited amount of concurrent jobs and a limited amount of job runtime, the full benchmark suite would need to be broken up into several sequences of jobs that would span across a great length of time, since the next jobs could only begin once the previous sequence ended.
+
+The preliminary results gathered were intended to be the ``slowest" tests that would have the lowest speedup. The ``worst-case", minimum-bound data was collected to determine potential success of this approach. If the slowest tests still yielded promising speedups or efficiencies, then this approach would be viable and appealing for future, in-depth testing that could stress each component of the generation process.
+
+Exploratory data analysis was performed on the resulting data using Python to ascertain data relationships. Due to the multivariate nature of the data, there is difficulty visualizing all four independent variables (parameters) and the outcome (runtime) simultaneously. Using pivot tables, Figures \ref{fig:nodes-exp} and \ref{fig:appl-load} show the runtime as they relate to the average of each individual parameter. These figures display the expected outcome: as the number of nodes increase, the runtime decreases, and as the number of exploits, applicability of exploits, and database load increases, the runtime likewise increases.
+
+\begin{figure}
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri9.png"}
+    \includegraphics[width=\linewidth]{"./images/schri10.png"}
+    \caption{Number of Nodes and Number of Exploits (Averaged) vs. Runtime (ms)}
+    \label{fig:nodes-exp}
+\end{figure}
+
+\begin{figure}
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri11.png"}
+    \includegraphics[width=\linewidth]{"./images/schri12.png"}
+    \caption{Applicability of Exploits (\%) and Database Load (\%) (Averaged) vs. Runtime (ms)}
+    \label{fig:appl-load}
+\end{figure}
+
+In terms of speedup, when the number of entries in the exploit list is small, the serial approach has better performance. As discussed in Section \ref{sec:Task-perf-expec}, this is expected due to the time elapsed for the communication cost exceeding the time taken to generate a state. However, as the number of items in the exploit list increase, the Tasking Approach quickly begins to outperform the serial approach. It is notable that even when the tasking pipeline is not fully saturated (when there are less compute nodes assigned than tasks), the performance is still approximately equal to that of the serial approach. The other noticeable feature is that as more compute nodes are assigned, the speedup continues to increase.
+
+Figure \ref{fig:overall-speedup} displays the overall minimum, maximum, and mean of speedup across all problem sizes. It is observable through the mean and maximum bars that as other problem size parameters increase, the speedup of the Tasking Approach also increases. Since database load, applicability of exploits, and number of exploits all affect the runtime, increasing the problem size through any of these parameters showcases the viability of the parallelized approach. At the same time, it is worth noting that the parallelized approach is not strictly better. The minimum speedups shown in Figure \ref{fig:overall-speedup} demonstrate that for small problem sizes, the serial approach performs better due to the communication costs.
+
+\begin{figure}[htp]
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri13.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Minimum, Maximum, and Mean Speedup of MPI Tasking Across All Problem Sizes}
+        \label{fig:overall-speedup}
+\end{figure}
+
+Figure \ref{fig:overall-efficiency} displays the overall minimum, maximum, and mean of efficiency across all problem sizes. In terms of efficiency, 2 compute nodes offer the greatest value. While the 2 compute node configuration does offer the greatest efficiency, it does not provide a speedup greater than 1.0 on any of the testing cases conducted. The results also demonstrate that an odd number of compute nodes in a fully saturated pipeline has better efficiency that an even number of compute nodes. When referring to Figure \ref{fig:node-alloc}, when there is an odd number number of compute nodes, Task 1 is allocated more nodes than Task 2. Task 1 was responsible for iterating through an increased size of the exploit list, so more nodes is advantageous in distributing the workload. However, when many exploits were not applicable, Task 2 had a lower workload. Some test cases only had 6 applicable exploits, which is a substantially lower workload for Task 2 compared to cases where Task 1 had upwards of 49,000 exploits. As the applicability of exploits increases, the disparity in efficiency for odd and even number of nodes is not present.
+
+\begin{figure}[htp]
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri14.png"}
+    \vspace{.2truein} \centerline{}
+        \caption{Minimum, Maximum, and Mean Efficiency of MPI Tasking Across All Problem Sizes}
+        \label{fig:overall-efficiency}
+\end{figure}
+
+Speedups and efficiencies were also computed across each parameter. Using pivot tables, mean speedups and mean efficiencies were computed for a parameter across all node configurations. Figures \ref{fig:param-exploit} and \ref{fig:param-appl} display the speedups and efficiencies of the exploit parameter and the applicability of exploits parameter, respectively. The number of nodes has the largest impact on the exploit parameter, and Figure \ref{fig:param-exploit} illustrates that even when fewer nodes are used, speedup can still be obtained as the exploit list grows in size. Figure \ref{fig:param-appl} demonstrates that though Task 2 has less of an impact on overall runtime and contribution to speedup, speedup is still achievable as more compute nodes are added and as the applicability of exploits increase. Though database load was not a parameter to easily include in preliminary testing, speedup is expected as this parameter changes. By dedicating nodes to solely handle database operations, the tasking pipeline is able to move to new state generation without the need to wait for all preceding database operations to complete.
+
+\begin{figure}
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri15.png"}
+    \includegraphics[width=\linewidth]{"./images/schri16.png"}
+    \caption{Mean Speedup and Efficiency for the Exploit Parameter Across the Number of Compute Nodes}
+    \label{fig:param-exploit}
+\end{figure}
+
+\begin{figure}
+    \centering
+    \includegraphics[width=\linewidth]{"./images/schri17.png"}
+    \includegraphics[width=\linewidth]{"./images/schri18.png"}
+    \caption{Mean Speedup and Efficiency for the Applicability of Exploit Parameter Across the Number of Compute Nodes}
+    \label{fig:param-appl}
+\end{figure}
+
+\section{Conclusion and Future Work} \label{sec:FW}
+This work presents a task parallelism approach for large-scale attack and compliance graphs. This approach is a distributed approach rather than a shared-memory approach, allowing for the generation of these large-scale graphs to be deployed on HPC systems. Tasks were identified in the generation process, with parallelization of the tasks clearly identified and incorporated into the tasking algorithm. The results of this approach highlighted its success, showing speedups as generation parameters and the number of nodes increased. Efficiencies were also computed, with various figures illustrating the efficiency across the generation process as a whole, as well as efficiencies across individual parameters.
+
+Though the results presented in this work were preliminary, they still highlight the viability of this approach. Despite each Task having limited stress during the generation process, speedups of over 3.5x can still be obtained. Exploit applicability and database load parameters were almost entirely unexplored during the preliminary result benchmarking, and speedup is still achievable. As exploit applicability and database load are introduced into the generation process, both speedup and efficiency are expected to increase in future testing. With more compute time, the approach of this work can be deployed on a testing platform to examine how speedups and efficiencies change as the complexity of the generation process increases.
+
+Future work can be performed to investigate and improve the method of this work. This work focused on a distributed approach to large-scale graph generation, but leaves room for additional parallelism at the node-level. For example, after work for Tasks 1 or 2 has been distributed to a node, the node can then leverage OpenMP for additional parallelism. Results can be obtained to show how the additional parallelism affects the speedup and efficiency of the approach.
+
+Additional work can be performed to investigate long-term speedup and efficiency of the approach. This work made use of a local HPC cluster with a limited number of compute nodes. The generation algorithm can be deployed to larger clusters to measure speedup and efficiency as more nodes are added to the tasking pipeline. Scalability can likewise be reexamined as the number of nodes increases.
+
+The analysis portion of this work also has room for additional investigations. This work measured speedup according to Amdahl \cite{Amdahl}. Since tasks are clearly defined and timing data is collected for each task, other speedup metrics can be used. Both Gustafson's Law \cite{Gust} and Sun and Ni's Law \cite{sun} can be leveraged to obtain other results regarding the speedup of the tasking approach.
+
+%\bibliographyp
+\bibliography{Bibliography}
+\bibliographystyle{ieeetr}
+
+\begin{IEEEbiography}[
+    {
+    \includegraphics[width=1in,height=1.25in,clip,keepaspectratio]{"./images/schri19.png"}
+    }
+    ]
+    {Noah L. Schrick}
+    is a fourth-year PhD student in Computer Science at the University of Tulsa. He received his Bachelor of Science in Electrical and Computer Engineering and his Master of Science in Computer Science at the University of Tulsa.\par His research focus is on cybersecurity and compliance, where he is working on the analysis of large-scale attack and compliance graphs to detect, correct, and predict violations in regulations or mandates. He has additional research interests in high-performance computing, research computing, platform engineering, and scientific software development. Noah L. Schrick is a TU-Cyber Fellow at the University of Tulsa, where he focuses on the innovation and growth of industry-applicable research.
+\end{IEEEbiography}
+
+\begin{IEEEbiography}[
+    {
+    \includegraphics[width=1in,height=1.25in,clip,keepaspectratio]{"./images/schri20.jpg"}
+    }
+    ]
+    {Peter J. Hawrylak}
+    is an Associate Professor in the Department of Electrical and Computer Engineering, with joint appointments in the Tandy School for Computer Science and the School of Cyber Studies, at The University of Tulsa, Tulsa, OK, USA.  He has published more than 60 publications and holds 15 patents in the radio frequency identification (RFID), energy harvesting, and cyber-security areas.  His research interests include RFID, security for low-power wireless devices, Internet of Things applications, critical infrastructure security, high-performance computing, and digital design.  Dr. Hawrylak's research has been supported by NASA, DOD, the U.S. Army, DOE, Argonne National Laboratory, DOT, EPA, CDC, NSF, and OCAST.\par
+    Dr. Hawrylak is a senior member of the IEEE and IEEE Computer Society, has served as Secretary of the Tulsa Section of the IEEE 2015-2018, Vice-Chair of the Tulsa Section of the IEEE 2019-2020, and is currently serving as Chair of the Tulsa Section of the IEEE (2020-Present) leading the Section through the COVID-19 pandemic.  He served as chair of the RFID Experts Group (REG) of Association for Automatic Identification and Mobility (AIM) in 2012-2013.  Peter received AIM Inc.'s Ted Williams Award in 2015 for his contributions to the RFID industry.  Dr. Hawrylak serves on the Organizing Committee of the International IEEE RFID Conference, and served two terms as the Editor-in-Chief of the IEEE RFID Virtual Journal (2016-2019) and also as the Editor-in-Chief of the International Journal of Radio Frequency Identification Technology and Applications (IJRFITA) journal published by InderScience Publishers, which focuses on the application and development of RFID technology.\par
+    Peter is a senior member (M'05-SM'17) of IEEE and the IEEE Computer Society, is a member of IEEE-HKN, and is a member of Tau Beta Pi.  He has served as the faculty advisor for the IEEE-HKN chapter at The University of Tulsa (Zeta Nu chapter) from Aug. 2010 to Dec. 2020.
+\end{IEEEbiography}
+
+
+\end{document}

TPDS_Submission/images/Sync-Fire

@@ -0,0 +1,181 @@
+<mxfile host="app.diagrams.net" modified="2023-04-22T22:53:12.998Z" agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/112.0.0.0 Safari/537.36" etag="cYbAeeBUogMmzFaDdVZ4" version="21.1.4" type="device">
+  <diagram id="K7JRYQhel2MMmrMd0Y0x" name="Page-1">
+    <mxGraphModel dx="1587" dy="758" grid="1" gridSize="10" guides="1" tooltips="1" connect="1" arrows="1" fold="1" page="1" pageScale="1" pageWidth="850" pageHeight="1100" math="0" shadow="0">
+      <root>
+        <mxCell id="0" />
+        <mxCell id="1" parent="0" />
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-3" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" parent="1" source="Yg0w0YBVZnjJYA129H6i-1" target="Yg0w0YBVZnjJYA129H6i-2" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-1" value="Pull next applicable exploit" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="370" y="60" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-5" value="" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" parent="1" source="Yg0w0YBVZnjJYA129H6i-2" target="Yg0w0YBVZnjJYA129H6i-4" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="S02b3ZSHm7epOyOR5ffc-5" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="1" source="Yg0w0YBVZnjJYA129H6i-2" target="5dyq7pQDjFANX0ohcFdJ-4" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="645" y="270" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="280" y="205" />
+              <mxPoint x="280" y="210" />
+              <mxPoint x="277" y="210" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="S02b3ZSHm7epOyOR5ffc-6" value="&lt;font style=&quot;font-size: 13px&quot;&gt;No&lt;/font&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="S02b3ZSHm7epOyOR5ffc-5" vertex="1" connectable="0">
+          <mxGeometry x="-0.3739" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-2" value="Part of a group?" style="rhombus;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="380" y="160" width="100" height="90" as="geometry" />
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-6" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.75;entryDx=0;entryDy=0;" parent="1" source="Yg0w0YBVZnjJYA129H6i-4" target="Yg0w0YBVZnjJYA129H6i-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="520" y="345" />
+              <mxPoint x="520" y="105" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-7" value="Break" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontSize=13;fontStyle=1" parent="Yg0w0YBVZnjJYA129H6i-6" vertex="1" connectable="0">
+          <mxGeometry x="-0.0684" y="1" relative="1" as="geometry">
+            <mxPoint as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-8" value="&lt;font style=&quot;font-size: 13px&quot;&gt;Fired&lt;/font&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];" parent="Yg0w0YBVZnjJYA129H6i-6" vertex="1" connectable="0">
+          <mxGeometry x="-0.8947" y="1" relative="1" as="geometry">
+            <mxPoint y="-16" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-26" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" parent="1" source="Yg0w0YBVZnjJYA129H6i-4" target="isFYcWvU-x2YYOKhLKfV-25" edge="1">
+          <mxGeometry relative="1" as="geometry" />
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-4" value="Group status?" style="rhombus;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="380" y="300" width="100" height="90" as="geometry" />
+        </mxCell>
+        <mxCell id="Yg0w0YBVZnjJYA129H6i-9" value="Yes" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;fontSize=13;" parent="1" vertex="1">
+          <mxGeometry x="425" y="260" width="40" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-6" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.317;entryY=0.014;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" target="5dyq7pQDjFANX0ohcFdJ-5" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="361.5833333333335" y="620" as="sourcePoint" />
+            <mxPoint x="404.2099999999998" y="685.04" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-8" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=-0.013;entryY=0.401;entryDx=0;entryDy=0;entryPerimeter=0;" parent="1" source="5dyq7pQDjFANX0ohcFdJ-4" target="5dyq7pQDjFANX0ohcFdJ-5" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="280" y="350" />
+              <mxPoint x="280" y="718" />
+            </Array>
+            <mxPoint x="645" y="340" as="sourcePoint" />
+            <mxPoint x="454.25" y="685.04" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="S02b3ZSHm7epOyOR5ffc-14" value="Not Fired" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;fontSize=13;" parent="1" vertex="1">
+          <mxGeometry x="360" y="380" width="70" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-13" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="427.25" y="880.0000000000002" as="targetPoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-1" value="Pull next loop vector exploit" style="rounded=0;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="367.25" y="800" width="120" height="60" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-10" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;" parent="1" target="isFYcWvU-x2YYOKhLKfV-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="427.25" y="760" as="sourcePoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-17" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;exitX=0.5;exitY=1;exitDx=0;exitDy=0;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="427.25" y="990" as="targetPoint" />
+            <mxPoint x="427.25" y="960.0000000000002" as="sourcePoint" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-18" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.25;entryDx=0;entryDy=0;exitX=1;exitY=0.5;exitDx=0;exitDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-23" target="Yg0w0YBVZnjJYA129H6i-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="430" y="970" as="sourcePoint" />
+            <Array as="points">
+              <mxPoint x="580" y="1035" />
+              <mxPoint x="580" y="75" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-16" value="Yes" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" parent="1" vertex="1">
+          <mxGeometry x="337.25" y="1010" width="40" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-22" value="No" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" parent="1" vertex="1">
+          <mxGeometry x="490" y="1020" width="30" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-24" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0;entryY=0.5;entryDx=0;entryDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-23" target="isFYcWvU-x2YYOKhLKfV-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="327.25" y="1035" />
+              <mxPoint x="327.25" y="830" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-23" value="More items?" style="rhombus;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="377.25" y="990" width="100" height="90" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-27" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-25" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="361.5" y="550" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="362" y="470" />
+              <mxPoint x="362" y="540" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-28" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=0.5;entryY=0;entryDx=0;entryDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-25" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <mxPoint x="498.5" y="550" as="targetPoint" />
+            <Array as="points">
+              <mxPoint x="500" y="470" />
+              <mxPoint x="500" y="540" />
+              <mxPoint x="499" y="540" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-30" style="edgeStyle=orthogonalEdgeStyle;rounded=0;orthogonalLoop=1;jettySize=auto;html=1;entryX=1;entryY=0.5;entryDx=0;entryDy=0;" parent="1" source="isFYcWvU-x2YYOKhLKfV-25" target="Yg0w0YBVZnjJYA129H6i-1" edge="1">
+          <mxGeometry relative="1" as="geometry">
+            <Array as="points">
+              <mxPoint x="550" y="470" />
+              <mxPoint x="550" y="90" />
+            </Array>
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-31" value="&lt;font style=&quot;font-size: 12px&quot;&gt;No&lt;/font&gt;" style="edgeLabel;html=1;align=center;verticalAlign=middle;resizable=0;points=[];fontStyle=0" parent="isFYcWvU-x2YYOKhLKfV-30" vertex="1" connectable="0">
+          <mxGeometry x="-0.8744" y="-4" relative="1" as="geometry">
+            <mxPoint y="-6" as="offset" />
+          </mxGeometry>
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-25" value="All assets ready&lt;br&gt;&amp;nbsp;to fire?" style="rhombus;whiteSpace=wrap;html=1;" parent="1" vertex="1">
+          <mxGeometry x="375" y="420" width="110" height="100" as="geometry" />
+        </mxCell>
+        <mxCell id="isFYcWvU-x2YYOKhLKfV-29" value="Yes" style="text;html=1;align=center;verticalAlign=middle;resizable=0;points=[];autosize=1;strokeColor=none;fillColor=none;" parent="1" vertex="1">
+          <mxGeometry x="430" y="520" width="40" height="20" as="geometry" />
+        </mxCell>
+        <mxCell id="5dyq7pQDjFANX0ohcFdJ-1" value="SET Loop vector = map[group]" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="297.25" y="550" width="120" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="5dyq7pQDjFANX0ohcFdJ-3" value="SET Group status&amp;nbsp;&lt;br style=&quot;border-color: var(--border-color);&quot;&gt;= Fired" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="440" y="550" width="120" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="5dyq7pQDjFANX0ohcFdJ-4" value="SET Loop vector = applicable exploit&amp;nbsp; &amp;nbsp;" style="rounded=1;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="217.25" y="280" width="120" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="5dyq7pQDjFANX0ohcFdJ-5" value="Make new state" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="365" y="690" width="120" height="70" as="geometry" />
+        </mxCell>
+        <mxCell id="5dyq7pQDjFANX0ohcFdJ-6" value="Update state" style="rounded=0;whiteSpace=wrap;html=1;" vertex="1" parent="1">
+          <mxGeometry x="365" y="880" width="120" height="80" as="geometry" />
+        </mxCell>
+      </root>
+    </mxGraphModel>
+  </diagram>
+</mxfile>

TPDS_Submission/texput.log

@@ -0,0 +1,21 @@
+This is pdfTeX, Version 3.141592653-2.6-1.40.25 (TeX Live 2023/Arch Linux) (preloaded format=pdflatex 2023.9.6)  10 SEP 2023 15:27
+entering extended mode
+ restricted \write18 enabled.
+ %&-line parsing enabled.
+**
+
+! Emergency stop.
+<*> 
+    
+End of file on the terminal!
+
+ 
+Here is how much of TeX's memory you used:
+ 5 strings out of 477985
+ 147 string characters out of 5840059
+ 1849388 words of memory out of 5000000
+ 20305 multiletter control sequences out of 15000+600000
+ 512287 words of font info for 32 fonts, out of 8000000 for 9000
+ 14 hyphenation exceptions out of 8191
+ 0i,0n,0p,43b,6s stack positions out of 10000i,1000n,20000p,200000b,200000s
+!  ==> Fatal error occurred, no output PDF file produced!