[OS][ww12] - Upstreaming compiler repository (#47)

Author: DariaMityagina

CMakeLists.txt

@@ -88,11 +88,14 @@ include(cmake/bundle_static_library.cmake)
 include(cmake/embed_bin_file.cmake)
 include(cmake/add_tool_target.cmake)
 include(cmake/coverage.cmake)
+include(cmake/log_level.cmake)
 
 if(ENABLE_PRIVATE_TESTS)
     enable_testing()
 endif()
 
+set_log_level()
+
 print_enabled_npu_features()
 
 #

cmake/embed_bin_file.cmake

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2022 Intel Corporation
+# Copyright 2022 Intel Corporation.
 # SPDX-License-Identifier: Apache 2.0
 #
 

cmake/features.cmake

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2022 Intel Corporation.
+# Copyright (C) 2022-2025 Intel Corporation.
 # SPDX-License-Identifier: Apache 2.0
 #
 

cmake/log_level.cmake

@@ -0,0 +1,34 @@
+#
+# Copyright (C) 2024 Intel Corporation.
+# SPDX-License-Identifier: Apache 2.0
+#
+
+function(set_log_level)
+    if(NOT DEFINED BUILD_LOG_LEVEL)
+        if(CMAKE_BUILD_TYPE STREQUAL "Release" AND NOT ENABLE_DEVELOPER_BUILD)
+            set(DEFAULT_LOG_LEVEL "LOG_INFO")
+        else()
+            set(DEFAULT_LOG_LEVEL "LOG_TRACE")
+        endif()
+        set(BUILD_LOG_LEVEL ${DEFAULT_LOG_LEVEL} CACHE STRING "Build log level")
+    endif()
+    if(BUILD_LOG_LEVEL STREQUAL "LOG_NONE")
+        set(LOG_LEVEL_VALUE 0)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_FATAL")
+        set(LOG_LEVEL_VALUE 1)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_ERROR")
+        set(LOG_LEVEL_VALUE 2)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_WARNING")
+        set(LOG_LEVEL_VALUE 3)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_INFO")
+        set(LOG_LEVEL_VALUE 4)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_DEBUG")
+        set(LOG_LEVEL_VALUE 5)
+    elseif(BUILD_LOG_LEVEL STREQUAL "LOG_TRACE")
+        set(LOG_LEVEL_VALUE 6)
+    else()
+        message(FATAL_ERROR "Unknown log level: `${BUILD_LOG_LEVEL}`")
+    endif()
+    # Add a global definition since logger might be used without explicit cmake dependency
+    add_compile_definitions(BUILD_LOG_LEVEL=${LOG_LEVEL_VALUE})
+endfunction()

scripts/run_all_lit_tests.sh

@@ -49,7 +49,6 @@ echo ""
 echo "Executing tests on NPU40XX platform: $CMD_NPU40XX_TESTS"
 eval "$CMD_NPU40XX_TESTS"; EXIT_CODE=$(($EXIT_CODE + $?))
 echo ""
-
 if [ $EXIT_CODE -ne 0 ]
 then
     echo "FAILURES identified"

src/CMakeLists.txt

@@ -11,16 +11,11 @@ if(NOT ENABLE_NPU_MONO)
     add_definitions(-DOV_BUILD_POSTFIX=${OV_BUILD_POSTFIX_VAR})
 endif()
 
-add_subdirectory(vpux_ngraph_transformations)
-
 if(BUILD_COMPILER_FOR_DRIVER)
+    add_definitions("-DCOMPILER_FOR_DRIVER_ENABLED")
     add_subdirectory(vpux_driver_compiler)
 endif()
 
 add_subdirectory(vpux_utils)
 
 add_subdirectory(vpux_compiler)
-
-if(BUILD_SHARED_LIBS AND ENABLE_MLIR_COMPILER)
-    add_subdirectory(vpux_translate_utils)
-endif()

src/vpux_compiler/cmake/vpux_tblgen.cmake

@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2023 Intel Corporation.
+# Copyright (C) 2023-2025 Intel Corporation.
 # SPDX-License-Identifier: Apache 2.0
 #
 

src/vpux_compiler/docs/code_style.md

@@ -595,6 +595,35 @@ TEST_F(MLIR_IndexedSymbolAttr, CheckNestedAttr) {
 
 ## Pipelines and passes
 
+### Pass implementation
+
+Passes that are defined in Tablegen have their base class auto-generated in the
+associated dialect's `passes.hpp.inc` file. Each pass class has its own macros:
+- `GEN_PASS_DEF_MYPASSNAME`: when defined, including the corresponding `passes.hpp.inc`
+results in the base class definition being included without including the rest of the file
+- `GEN_PASS_DECL_MYPASSNAME`: passes which have options also have a structure generated
+with said options; when this macro is defined, including the corresponding `passes.hpp.inc`
+results in the structure being included
+  - the base class usually contains a constructor which receives this structure as a parameter;
+it is often a good idea to specify both macros
+
+When creating the implementation of a pass, you can make its base class available
+by including it explicitly in the source file. For example, for a pass in IE dialect:
+```C++
+namespace vpux::IE {
+#define GEN_PASS_DECL_MYPASSNAME
+#define GEN_PASS_DEF_MYPASSNAME
+#include "vpux/compiler/dialect/IE/passes.hpp.inc"
+}  // namespace vpux::IE
+```
+
+Then, the base class can be found in `vpux::IE::impl::MyPassNameBase`, which
+you can use as the parent class for the pass implementation.
+
+*Note:* When including the base class of a pass using `passes.hpp.inc`, you
+might also need to include the dependencies used in this class. For example,
+the dialect headers for the dependent dialects (e.g. `IE/IR/dialect.hpp`).
+
 ### Adding rewriter to a pass
 
 The IR traversal within a pass usually follows a specific direction: it is

src/vpux_compiler/docs/guides/how_to_debug.md

@@ -146,7 +146,7 @@ The tools can be used to perform a full compilation of a model:
 ./vpux-translate --vpu-arch=NPU37XX --import-IE <path to OV IR> -o net.mlir
 
 # Call the DefaultHWMode pipeline over the imported IR
-./vpux-opt --vpu-arch=NPU37XX --default-hw-mode net.mlir -o net_out.mlir
+./vpux-opt --vpu-arch=NPU37XX --default-hw-mode --lower-VPUIP-to-ELF net.mlir -o net_out.mlir
 
 # Export the final IR into an ELF file
 ./vpux-translate --vpu-arch=NPU37XX --export-ELF net_out.mlir > net.blob
@@ -171,6 +171,41 @@ The compiler contains a pass which can generate a Dot Graph representation of th
 - Using the compiler pipeline, by manually adding the `PrintDot` pass where desired and rebuilding the project
   - example: `pm.addPass(createPrintDot(<FileName>, <Options>));`
 
+## Debugging barrier dependencies
+
+At several stages of compilation the structure of the control graph may change due to adding new tasks,
+reordering tasks, optimizing tasks dependencies etc. It is possible to check what exactly has changed after applying some
+transformations either across several passes, within single pass or some individual routine. BarrierInfo class
+offers methods to dump actual state of barrier dependencies at any stage of compilation where the concept of barriers is defined (i.e. in the VPUIP and VPURT dialects). This is typically done
+as follows:
+
+```cpp
+    auto& barrierInfo = getAnalysis<BarrierInfo>();
+    barrierInfo.dumpBarriers("beforeTransformation"); // dump state before barrier optimization
+    barrierInfo.optimizeBarriers(/* checkValidSlotCount */ false, _considerTaskFifoDependency);
+    barrierInfo.dumpBarriers("afterTransformation"); // dump state after barrier optimization
+```
+
+The subsequent compilation will generate a set of files prefixed "beforeTransformation" and "afterTransformation" respectively, containing the corresponding states of the graph.
+Extensions of the dumped files are as follows:
+- taskUpdateBarriers - contains list of indexes of update barriers for each task in the graph. Each row starts with a unique task index.
+- taskWaitBarriers - contains list of indexes of wait barriers for each task in the graph. Each row starts with a unique task index.
+- barrierProducerMap - contains list of indexes of producers for each barrier in the graph. Each row starts with a unique barrier index.
+- barrierConsumerMap - contains list of indexes of consumers for each barrier in the graph. Each row starts with a unique barrier index.
+- slots - contains number of slots occupied by a task when it waits or updates a barrier. Each row starts with a unique task index.
+- taskQueueTypeMap - contains list task indexes in each queue. Each row starts with queue name, followed by a number tasks in the queue (provided within parentheses), followed by a colon.
+
+At times, it is also handy to print out the `module` or the main function, in order to make a connection between tasks/barriers indexes from the dump files and their IR representation. Tracing graph changes is not limited to methods of the BarrierInfo class, but an object of that class needs to be created in order to dump the graph dependencies with the actual state of the IR.
+
+Quick investigation of the dependencies from the dump files can be easier than browsing the IR. A plotting tool (located in `tools/barrier-plotter`) can process the dump files and generate `dot` graphs, ready for viewing with e.g. `xdot`. It also exports the `dot` files to `PDF`.
+
+Example usage:
+
+```python
+plot_barriers.py beforeTransformation -o beforeTransformation
+```
+This command will read dump files `beforeTransformation.taskUpdateBarriers`, `beforeTransformation.taskWaitBarriers`, `beforeTransformation.slots` and `beforeTransformation.taskQueueTypeMap` and will produce `beforeTransformation.dot` and `beforeTransformation.dot.pdf`. The output file prefix need not be identical with the dump files prefix and can be adjusted to indicate the dump point and/or compilation configuration.
+
 **Notes**
 - By default, declarations and constants are not included. To include them, add `print-declarations=true and print-const=true` to the pass options.
 - The `xdot` application can be used to visualize the dot graph. For big networks however, the application may fail to show the graph. The size of the graph can be reduced by specifying which operations should be included, with the `start-after` & `stop-before` pass options. They should be configured with the exact names of the operation from the compiler IR.

src/vpux_compiler/docs/guides/project_structure.md

@@ -67,7 +67,7 @@ HW-specific passes must also be registered in [vpux-opt](../../../../tools/vpux-
 
 ```C++
 // ...
-vpux::IE::arch37xx::registerIEPasses();
+vpux::IE::arch37xx::registerPasses();
 // ...
 ```