discopop 5.0.0__tar.gz → 5.0.1__tar.gz

{discopop-5.0.0 → discopop-5.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 5.0.0
+Version: 5.0.1
 Summary: DiscoPoP is a tool that helps software developers parallelize their programs with threads. It discovers potential parallelism in a sequential program and makes recommendations on how to exploit it.
 Home-page: https://www.discopop.tu-darmstadt.de/
 Author: TU Darmstadt and Iowa State University

{discopop-5.0.0 → discopop-5.0.1}/README.md

@@ -36,7 +36,7 @@ For detailed information on the gathered and stored data as well as the tools th
 ## Installation
 To simplify the setup we provide a Debian package via the [Release Assets](https://github.com/discopop-project/discopop/releases/latest).
 
-## TL;DR
+## TL;DR - Example
 If you are interested in installing DiscoPoP as a `developer`, please refer to the [DiscoPoP setup wiki page](https://discopop-project.github.io/discopop/setup/discopop/).
 
 The following example installs DiscoPoP for `users`, instruments and builds the provided example, analyzes the results, and prints the identified parallelization suggestions to the console.
@@ -44,48 +44,43 @@ In case any issues arise during the process, please refer to the detailed [setup
 
 ### Prerequisites
 - Download and install `.deb` package from [latest Release](https://github.com/discopop-project/discopop/releases/latest).
+- Install the [Visual Studio Code Extension](https://marketplace.visualstudio.com/items?itemName=TUDarmstadt-LaboratoryforParallelProgramming.discopop)
 ### Example
+Instrument and execute the code.
 ```
 # create a copy of the example code
 cp -r /opt/DiscoPoP/example discopop_example
 cd discopop_example
 
 # instrument and build the example code
-discopop_cxx example.cpp -o cmake_example
+discopop_cxx example.cpp -o example
 
 # execute instrumented code
-./cmake_example
+./example
+```
 
+Execute the pattern analysis on the gathered data.
+```
 # identify parallel patterns
 cd .discopop
 discopop_explorer
-# print patches to the console
-for f in $(find patch_generator -maxdepth 1 -type d); do
-    echo "SUGGESTION: $f"
-    cat $f/1.patch
-    echo ""
-done
-# apply patch with id 1
-discopop_patch_applicator -a 1
-# reset code to the original state
-discopop_patch_applicator -C
 ```
 
+Navigate to the `DiscoPoP` extension tab in Visual Studio Code to browse the created parallelization suggestions.
+Analyzing new projects, like the example code will lead to the automatic creation of a project configuration in the `Configurations` view.
+By default, the current timestamp will be used as the configuration label (in the following screenshots, `03_12_2025-16_27_15`).
+Click the clock-like `Load Results` button next to the configuration name to load the identified parallelization suggestions.
+Suggestions can be browsed, previewed, and applied via the `Suggestions` view, or the added annotations (`Potential Parallelism(count)`) in the analyzed source code.
+<br />
+<br />
+![Screenshot of the DiscoPoP VSCode Extension](docs/assets/README/Screenshot_1.png)
+<br />
+<br />
+The following screenshot shows an exemplary suggestion preview.
+<br />
+<br />
+![Screenshot of the suggestion preview in the DiscoPoP VSCode Extension](docs/assets/README/Screenshot_2.png)
 
-## Exemplary output
-The following is an automatically generated, exemplary output patch file generated and applicable as shown in the provided [examples](https://discopop-project.github.io/discopop/Examples).
-```
- --- /home/lukas/temp/discopop_tmp/discopop/example/example.cpp	2024-01-09 10:11:50.369555235 +0100
-+++ /home/lukas/temp/discopop_tmp/discopop/example/example.cpp.discopop_patch_generator.temp	2024-01-09 11:14:20.904823624 +0100
-@@ -20,6 +20,7 @@
-         Arr[i] = i % 13;
-     }
-
-+    #pragma omp parallel for shared(Arr,N) reduction(+:sum)
-     for(int i = 0; i < N; i++){
-         sum += Arr[i];
-     }
-```
 
 ## License
 © DiscoPoP is available under the terms of the BSD-3-Clause license, as specified in the LICENSE file.

{discopop-5.0.0 → discopop-5.0.1}/discopop.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discopop
-Version: 5.0.0
+Version: 5.0.1
 Summary: DiscoPoP is a tool that helps software developers parallelize their programs with threads. It discovers potential parallelism in a sequential program and makes recommendations on how to exploit it.
 Home-page: https://www.discopop.tu-darmstadt.de/
 Author: TU Darmstadt and Iowa State University

{discopop-5.0.0 → discopop-5.0.1}/discopop.egg-info/SOURCES.txt

@@ -301,6 +301,11 @@ discopop_library/SanityChecker/__main__.py
 discopop_library/SanityChecker/utils.py
 discopop_library/SanityChecker/Classes/CodeConfiguration.py
 discopop_library/SanityChecker/Classes/ExecutionResult.py
+discopop_library/Viewer/ViewerArguments.py
+discopop_library/Viewer/__init__.py
+discopop_library/Viewer/__main__.py
+discopop_library/Viewer/suggestions_view.py
+discopop_library/Viewer/viewer.py
 discopop_library/__pycache__/__init__.cpython-38.pyc
 discopop_library/discopop_optimizer/OptimizationGraph.py
 discopop_library/discopop_optimizer/OptimizerArguments.py

{discopop-5.0.0 → discopop-5.0.1}/discopop_explorer/discopop_explorer.py

@@ -35,6 +35,8 @@ from discopop_library.LineMapping.initialize import initialize_line_mapping
 from discopop_library.LineMapping.delete import delete_line_mapping
 from discopop_library.PatchGenerator.PatchGeneratorArguments import PatchGeneratorArguments
 from discopop_library.PathManagement.PathManagement import get_path, load_file_mapping
+from discopop_library.Viewer.ViewerArguments import ViewerArguments
+from discopop_library.Viewer.suggestions_view import print_suggestions_overview
 from discopop_library.discopop_optimizer.Microbench.ExtrapInterpolatedMicrobench import (
     ExtrapInterpolatedMicrobench,
 )
@@ -288,14 +290,42 @@ def run(arguments: ExplorerArguments) -> None:
             with open(arguments.enable_json_file, "w+") as f:
                 json.dump(res, f, indent=2, cls=PatternBaseSerializer)
 
-        print("Time taken for pattern detection: {0}".format(end - start))
-
         # create applicable patch files from the found suggestions
         logger.info("executing discopop_patch_generator")
         out = subprocess.check_output(["discopop_patch_generator"], cwd=arguments.project_path).decode("utf-8")
         logger.debug("\t Out:\n" + out)
         logger.info("\tDone.")
 
+        # print suggestions overview for users
+        logger.info("printing suggestions overview")
+        print_suggestions_overview(
+            ViewerArguments(
+                log_level="WARNING", write_log=False, path=arguments.project_path, print_suggestions_overview=True
+            )
+        )
+        logger.info("\tDone.")
+
+        print(
+            """
+To browse the created parallelization suggestions:
+1. Open the DiscoPoP VSCode extension tab in VSCode
+2. Open the project configuration
+  - A new Configuration should have been created automatically,
+    if the .discopop folder was newly created.
+  - You can add a configuration manually via the following steps:
+    - Configurations -> '+' -> ViewOnly
+    - Select a name for the Configuration
+    - Provide the following path to the .discopop folder
+    ========\n"""
+            + "    "
+            + arguments.project_path
+            + """\n    ========
+3. Load results (clock-like icon)
+"""
+        )
+
+        print("Time taken for pattern detection: {0}".format(end - start))
+
         # demonstration of Microbenchmark possibilities
         if arguments.microbench_file is not None:
             microbench_file = get_path(

discopop-5.0.1/discopop_library/Viewer/ViewerArguments.py

@@ -0,0 +1,27 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+from dataclasses import dataclass
+
+from discopop_library.ArgumentClasses.GeneralArguments import GeneralArguments
+
+
+@dataclass
+class ViewerArguments(GeneralArguments):
+    """Container Class for the arguments passed to the discopop_viewer"""
+
+    path: str  # .discopop folder
+    print_suggestions_overview: bool
+
+    def __post_init__(self) -> None:
+        self.__validate()
+
+    def __validate(self) -> None:
+        pass
+
+    def __str__(self) -> str:
+        return str(self.__dict__)

discopop-5.0.1/discopop_library/Viewer/__main__.py

@@ -0,0 +1,50 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+
+from argparse import ArgumentParser
+import os
+
+from discopop_library.GlobalLogger.setup import setup_logger
+from discopop_library.Viewer.ViewerArguments import ViewerArguments
+from discopop_library.Viewer.viewer import run
+
+
+def parse_args() -> ViewerArguments:
+    """Parse the arguments passed to the discopop_viewer"""
+    parser = ArgumentParser(description="DiscoPoP Viewer")
+
+    # fmt: off
+    mutually_exclusive = parser.add_mutually_exclusive_group()
+    mutually_exclusive.add_argument("-so", "--suggestions_overview", action="store_true",
+                        help="Print an overview of the identified parallelization suggestions to the console.")
+    parser.add_argument(
+        "--path", type=str, default=str(os.getcwd()),
+        help="Path to the .discopop directory to be analyzed")
+    parser.add_argument("--log", type=str, default="WARNING", help="Specify log level: DEBUG, INFO, WARNING, ERROR, CRITICAL")
+    parser.add_argument("--write-log", action="store_true", help="Create Logfile.")
+    # EXPERIMENTAL FLAGS:
+    # fmt: on
+
+    arguments = parser.parse_args()
+
+    return ViewerArguments(
+        path=arguments.path,
+        print_suggestions_overview=arguments.suggestions_overview,
+        log_level=arguments.log.upper(),
+        write_log=arguments.write_log,
+    )
+
+
+def main() -> None:
+    arguments = parse_args()
+    setup_logger(arguments)
+    run(arguments)
+
+
+if __name__ == "__main__":
+    main()

discopop-5.0.1/discopop_library/Viewer/suggestions_view.py

@@ -0,0 +1,69 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+
+import logging
+import os
+from typing import Dict, List, Set
+from discopop_library.PathManagement.PathManagement import load_file_mapping
+from discopop_library.Viewer.ViewerArguments import ViewerArguments
+
+logger = logging.getLogger("Viewer").getChild("Suggestions").getChild("Print")
+
+
+def print_suggestions_overview(arguments: ViewerArguments) -> None:
+    if not os.path.exists(arguments.path):
+        raise FileNotFoundError(arguments.path)
+    if not os.path.exists(os.path.join(arguments.path, "FileMapping.txt")):
+        raise FileNotFoundError(os.path.join(arguments.path, "FileMapping.txt"))
+    if not os.path.exists(os.path.join(arguments.path, "patch_generator")):
+        raise FileNotFoundError(os.path.join(arguments.path, "patch_generator"))
+
+    # collect information for display
+    suggestion_to_files_map: Dict[int, Set[int]] = dict()
+    files_to_suggestions_map: Dict[int, Set[int]] = dict()
+
+    suggestion_ids = [
+        x
+        for x in os.listdir(os.path.join(arguments.path, "patch_generator"))
+        if os.path.isdir(os.path.join(arguments.path, "patch_generator", x))
+    ]
+
+    for suggestion_id in suggestion_ids:
+        suggestion_to_files_map[int(suggestion_id)] = set()
+        file_ids = [
+            x.replace(".patch", "")
+            for x in os.listdir(os.path.join(arguments.path, "patch_generator", suggestion_id))
+            if os.path.isfile(os.path.join(arguments.path, "patch_generator", suggestion_id, x))
+        ]
+        for file_id in file_ids:
+            suggestion_to_files_map[int(suggestion_id)].add(int(file_id))
+            if int(file_id) not in files_to_suggestions_map:
+                files_to_suggestions_map[int(file_id)] = set()
+            files_to_suggestions_map[int(file_id)].add(int(suggestion_id))
+    file_mapping = load_file_mapping(os.path.join(arguments.path, "FileMapping.txt"))
+
+    print("########################")
+    print()
+    print("Suggestion IDs by files:")
+    print("---------------------")
+    for key_file_id in files_to_suggestions_map:
+        print("==> " + str(file_mapping[key_file_id]))
+        for val_suggestion_id in files_to_suggestions_map[key_file_id]:
+            print("|---> " + str(val_suggestion_id))
+    print()
+    print("########################")
+    print()
+    print("Files by Suggestion IDs:")
+    print("---------------------")
+    for key_suggestion_id in suggestion_to_files_map:
+        print("==> " + str(key_suggestion_id))
+        for file_id_key in suggestion_to_files_map[key_suggestion_id]:
+            print("|---> " + str(file_mapping[file_id_key]))
+
+    print()
+    print("########################")

discopop-5.0.1/discopop_library/Viewer/viewer.py

@@ -0,0 +1,27 @@
+# This file is part of the DiscoPoP software (http://www.discopop.tu-darmstadt.de)
+#
+# Copyright (c) 2020, Technische Universitaet Darmstadt, Germany
+#
+# This software may be modified and distributed under the terms of
+# the 3-Clause BSD License.  See the LICENSE file in the package base
+# directory for details.
+
+import os
+from pathlib import Path
+
+from discopop_library.Viewer.ViewerArguments import ViewerArguments
+from discopop_library.Viewer.suggestions_view import print_suggestions_overview
+from discopop_library.global_data.version.utils import get_version
+import shutil
+import logging
+
+logger = logging.getLogger("Viewer")
+
+
+def run(arguments: ViewerArguments) -> None:
+    logger.info("DiscoPoP Viewer: ")
+    for arg in arguments.__dict__:
+        logger.info("-> " + str(arg) + ": " + str(arguments.__dict__[arg]))
+
+    if arguments.print_suggestions_overview:
+        print_suggestions_overview(arguments)

discopop-5.0.1/discopop_library/global_data/version/VERSION

@@ -0,0 +1 @@
+5.0.1

discopop-5.0.0/discopop_library/global_data/version/VERSION

@@ -1 +0,0 @@
-5.0.0