blob: 4c9981dffd0158a75688bd058cc77f1ffdc0dd09 [file] [log] [blame]
"""YAML Summariser
The flang plugin ``flang-omp-report`` takes one fortran
file in and returns a YAML report file of the input file.
This becomes an issue when you want to analyse an entire project
into one final report.
The purpose of this Python script is to generate a final YAML
summary from all of the files generated by ``flang-omp-report``.
Currently, it requires ``ruamel.yaml``,
which can be installed with:
``pip3 install ruamel.yaml``
By default it scans the directory it is ran in
for any YAML files and outputs a summary to
stdout. It can be ran as:
-d --directory Specify which directory to scan. Multiple directories can be searched by
providing a semicolon seperated list of directories.
-l --log Combine all yaml files into one log (instead of generating a summary)
-o --output Specify a directory in which to save the summary file
-r --recursive Recursively search directory for all yaml files
``python3 -d ~/llvm-project/build/ -r``
``python3 -d "~/llvm-project/build/;~/llvm-project/flang/test/Examples"``
``python3 -l -o ~/examples/report.yaml``
$ python3 file_1.yaml file_2.yaml
<Unique OMP constructs with there grouped clauses from file_1.yaml and file_2.yaml>
Construcsts are in the form:
- construct: someOMPconstruct
count: 8
- clause: clauseOne
count: 4
- clause: ClauseTwo
count: 2
$ python3 -l file_1.yaml file_2.yaml
<OMP clauses and constructs from file_1.yaml>
<OMP clauses and constructs from file_2.yaml>
Constructs are in the form:
- construct: someOMPConstruct
line: 12
- clause: clauseOne
details: 'someDetailForClause'
import sys
import glob
import argparse
from pathlib import Path
from os.path import isdir
from ruamel.yaml import YAML
def find_yaml_files(search_directory: Path, search_pattern: str):
Find all '.yaml' files and returns an iglob iterator to them.
Keyword arguments:
search_pattern -- Search pattern for 'iglob' to use for finding '.yaml' files.
If this is set to 'None', then it will default to just searching
for all '.yaml' files in the current directory.
# @TODO: Currently *all* yaml files are read - regardless of whether they have
# been generated with 'flang-omp-report' or not. This might result in the script
# reading files that it should ignore.
if search_directory:
return glob.iglob(str(search_directory.joinpath(search_pattern)), recursive=True)
return glob.iglob(str("/" + search_pattern), recursive=True)
def process_log(data, result: list):
Process the data input as a 'log' to the result array. This esssentially just
stitches together all of the input '.yaml' files into one result.
Keyword arguments:
data -- Data from yaml.load() for a yaml file. So the type can be 'Any'.
result -- Array to add the processed data to.
for datum in data:
items = result.get(datum['file'], [])
items.append({"construct" : datum['construct'],
"line" : datum['line'],
"clauses" : datum['clauses']})
result[datum['file']] = items
def add_clause(datum, construct):
Add clauses to the construct if they're missing
Otherwise increment their count by one.
Keyword arguments:
datum -- Data construct containing clauses to check.
construct -- Construct to add or increment clause count.
to_check = [i['clause'] for i in construct['clauses']]
to_add = [i['clause'] for i in datum['clauses']]
clauses = construct["clauses"]
for item in to_add:
if item in to_check:
for clause in clauses:
if clause["clause"] == item:
clause["count"] += 1
clauses.append({"clause" : item,
"count" : 1})
def process_summary(data, result: dict):
Process the data input as a 'summary' to the 'result' dictionary.
Keyword arguments:
data -- Data from yaml.load() for a yaml file. So the type can be 'Any'.
result -- Dictionary to add the processed data to.
for datum in data:
construct = next((item for item in result
if item["construct"] == datum["construct"]), None)
clauses = []
# Add the construct and clauses to the summary if
# they haven't been seen before
if not construct:
for i in datum['clauses']:
clauses.append({"clause" : i['clause'],
"count" : 1})
result.append({"construct" : datum['construct'],
"count" : 1,
"clauses" : clauses})
construct["count"] += 1
add_clause(datum, construct)
def clean_summary(result):
""" Cleans the result after processing the yaml files with summary format."""
# Remove all "clauses" that are empty to keep things compact
for construct in result:
if construct["clauses"] == []:
def clean_log(result):
""" Cleans the result after processing the yaml files with log format."""
for constructs in result.values():
for construct in constructs:
if construct["clauses"] == []:
def output_result(yaml: YAML, result, output_file: Path):
Outputs result to either 'stdout' or to a output file.
Keyword arguments:
result -- Format result to output.
output_file -- File to output result to. If this is 'None' then result will be
outputted to 'stdout'.
if output_file:
with open(output_file, 'w+', encoding='utf-8') as file:
if output_file.suffix == ".yaml":
yaml.dump(result, file)
yaml.dump(result, sys.stdout)
def process_yaml(search_directories: list, search_pattern: str,
result_format: str, output_file: Path):
Reads each yaml file, calls the appropiate format function for
the file and then ouputs the result to either 'stdout' or to an output file.
Keyword arguments:
search_directories -- List of directory paths to search for '.yaml' files in.
search_pattern -- String pattern formatted for use with glob.iglob to find all
'.yaml' files.
result_format -- String representing output format. Current supported strings are: 'log'.
output_file -- Path to output file (If value is None, then default to outputting to 'stdout').
if result_format == "log":
result = {}
action = process_log
clean_report = clean_log
result = []
action = process_summary
clean_report = clean_summary
yaml = YAML()
for search_directory in search_directories:
for file in find_yaml_files(search_directory, search_pattern):
with open(file, "r", encoding='utf-8') as yaml_file:
data = yaml.load(yaml_file)
action(data, result)
if clean_report is not None:
output_result(yaml, result, output_file)
def create_arg_parser():
""" Create and return a argparse.ArgumentParser modified for script. """
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--directory", help="Specify a directory to scan",
dest="dir", type=str)
parser.add_argument("-o", "--output", help="Writes to a file instead of\
stdout", dest="output", type=str)
parser.add_argument("-r", "--recursive", help="Recursive search for .yaml files",
dest="recursive", type=bool, nargs='?', const=True, default=False)
exclusive_parser = parser.add_mutually_exclusive_group()
exclusive_parser.add_argument("-l", "--log", help="Modifies report format: "
"Combines the log '.yaml' files into one file.",
action='store_true', dest='log')
return parser
def parse_arguments():
""" Parses arguments given to script and returns a tuple of processed arguments. """
parser = create_arg_parser()
args = parser.parse_args()
if args.dir:
search_directory = [Path(path) for path in args.dir.split(";")]
search_directory = [Path.cwd()]
if args.recursive:
search_pattern = "**/*.yaml"
search_pattern = "*.yaml"
if args.log:
result_format = "log"
result_format = "summary"
if args.output:
if isdir(args.output):
output_file = Path(args.output).joinpath("summary.yaml")
elif isdir(Path(args.output).resolve().parent):
output_file = Path(args.output)
output_file = None
return (search_directory, search_pattern, result_format, output_file)
def main():
""" Main function of script. """
(search_directory, search_pattern, result_format, output_file) = parse_arguments()
process_yaml(search_directory, search_pattern, result_format, output_file)
return 0
if __name__ == "__main__":