fix USAGE: clang-tidy [options] <source0> [... <sourceN>]

OPTIONS:

Generic Options:

  --help                           - Display available options (--help-hidden for more)
  --version                        - Display the version of this program

clang-tidy options:

  --allow-no-checks                - Allow empty enabled checks. This suppresses
                                     the "no checks enabled" error when disabling
                                     all of the checks.
  --checks=<string>                - Comma-separated list of globs with optional '-'
                                     prefix. Globs are processed in order of
                                     appearance in the list. Globs without '-'
                                     prefix add checks with matching names to the
                                     set, globs with the '-' prefix remove checks
                                     with matching names from the set of enabled
                                     checks. This option's value is appended to the
                                     value of the 'Checks' option in .clang-tidy
                                     file, if any.
  --config=<string>                - Specifies a configuration in YAML/JSON format:
                                       -config="{Checks: '*',
                                                 CheckOptions: {x: y}}"
                                     When the value is empty, clang-tidy will
                                     attempt to find a file named .clang-tidy for
                                     each source file in its parent directories.
  --config-file=<string>           - Specify the path of .clang-tidy or custom config file:
                                      e.g. --config-file=/some/path/myTidyConfigFile
                                     This option internally works exactly the same way as
                                      --config option after reading specified config file.
                                     Use either --config-file or --config, not both.
  --dump-config                    - Dumps configuration in the YAML format to
                                     stdout. This option can be used along with a
                                     file name (and '--' if the file is outside of a
                                     project with configured compilation database).
                                     The configuration used for this file will be
                                     printed.
                                     Use along with -checks=* to include
                                     configuration of all checks.
  --enable-check-profile           - Enable per-check timing profiles, and print a
                                     report to stderr.
  --enable-module-headers-parsing  - Enables preprocessor-level module header parsing
                                     for C++20 and above, empowering specific checks
                                     to detect macro definitions within modules. This
                                     feature may cause performance and parsing issues
                                     and is therefore considered experimental.
  --exclude-header-filter=<string> - Regular expression matching the names of the
                                     headers to exclude diagnostics from. Diagnostics
                                     from the main file of each translation unit are
                                     always displayed.
                                     Must be used together with --header-filter.
                                     Can be used together with -line-filter.
                                     This option overrides the 'ExcludeHeaderFilterRegex'
                                     option in .clang-tidy file, if any.
  --explain-config                 - For each enabled check explains, where it is
                                     enabled, i.e. in clang-tidy binary, command
                                     line or a specific configuration file.
  --export-fixes=<filename>        - YAML file to store suggested fixes in. The
                                     stored fixes can be applied to the input source
                                     code with clang-apply-replacements.
  --extra-arg=<string>             - Additional argument to append to the compiler command line
  --extra-arg-before=<string>      - Additional argument to prepend to the compiler command line
  --fix                            - Apply suggested fixes. Without -fix-errors
                                     clang-tidy will bail out if any compilation
                                     errors were found.
  --fix-errors                     - Apply suggested fixes even if compilation
                                     errors were found. If compiler errors have
                                     attached fix-its, clang-tidy will apply them as
                                     well.
  --fix-notes                      - If a warning has no fix, but a single fix can
                                     be found through an associated diagnostic note,
                                     apply the fix.
                                     Specifying this flag will implicitly enable the
                                     '--fix' flag.
  --format-style=<string>          - Style for formatting code around applied fixes:
                                       - 'none' (default) turns off formatting
                                       - 'file' (literally 'file', not a placeholder)
                                         uses .clang-format file in the closest parent
                                         directory
                                       - '{ <json> }' specifies options inline, e.g.
                                         -format-style='{BasedOnStyle: llvm, IndentWidth: 8}'
                                       - 'llvm', 'google', 'webkit', 'mozilla'
                                     See clang-format documentation for the up-to-date
                                     information about formatting styles and options.
                                     This option overrides the 'FormatStyle` option in
                                     .clang-tidy file, if any.
  --header-filter=<string>         - Regular expression matching the names of the
                                     headers to output diagnostics from. Diagnostics
                                     from the main file of each translation unit are
                                     always displayed.
                                     Can be used together with -line-filter.
                                     This option overrides the 'HeaderFilterRegex'
                                     option in .clang-tidy file, if any.
  --line-filter=<string>           - List of files with line ranges to filter the
                                     warnings. Can be used together with
                                     -header-filter. The format of the list is a
                                     JSON array of objects:
                                       [
                                         {"name":"file1.cpp","lines":[[1,3],[5,7]]},
                                         {"name":"file2.h"}
                                       ]
  --list-checks                    - List all enabled checks and exit. Use with
                                     -checks=* to list all available checks.
  --load=<pluginfilename>          - Load the specified plugin
  -p <string>                      - Build path
  --quiet                          - Run clang-tidy in quiet mode. This suppresses
                                     printing statistics about ignored warnings and
                                     warnings treated as errors if the respective
                                     options are specified.
  --store-check-profile=<prefix>   - By default reports are printed in tabulated
                                     format to stderr. When this option is passed,
                                     these per-TU profiles are instead stored as JSON.
  --system-headers                 - Display the errors from system headers.
                                     This option overrides the 'SystemHeaders' option
                                     in .clang-tidy file, if any.
  --use-color                      - Use colors in diagnostics. If not set, colors
                                     will be used if the terminal connected to
                                     standard output supports colors.
                                     This option overrides the 'UseColor' option in
                                     .clang-tidy file, if any.
  --verify-config                  - Check the config files to ensure each check and
                                     option is recognized.
  --vfsoverlay=<filename>          - Overlay the virtual filesystem described by file
                                     over the real file system.
  --warnings-as-errors=<string>    - Upgrades warnings to errors. Same format as
                                     '-checks'.
                                     This option's value is appended to the value of
                                     the 'WarningsAsErrors' option in .clang-tidy
                                     file, if any. and nits

runtime/lib/ttnn/runtime.cpp

@@ -568,7 +568,7 @@ std::vector<float> getTensorData(Tensor tensor) {
 }
 
 std::vector<std::byte> getDataBuffer(::tt::runtime::Tensor tensor) {
-  auto ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
+  auto *ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
   void *dataPtr = nullptr;
   size_t numBytes = getElementSize(tensor) * getVolume(tensor);
   std::vector<std::byte> dataVec(numBytes);
@@ -580,32 +580,32 @@ std::vector<std::byte> getDataBuffer(::tt::runtime::Tensor tensor) {
   case target::DataType::BFP_BFloat8:
   case target::DataType::Float32:
     dataPtr = ttnnTensor->to_vector<float>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   case target::DataType::BFloat16:
     dataPtr = ttnnTensor->to_vector<bfloat16>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   case target::DataType::Int32:
     dataPtr = ttnnTensor->to_vector<std::int32_t>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   case target::DataType::UInt32:
     dataPtr = ttnnTensor->to_vector<std::uint32_t>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   case target::DataType::UInt16:
     dataPtr = ttnnTensor->to_vector<std::uint16_t>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   case target::DataType::UInt8:
     dataPtr = ttnnTensor->to_vector<std::uint8_t>().data();
-    assert(dataPtr != nullptr);
+    LOG_ASSERT(dataPtr != nullptr);
     std::memcpy(dataVec.data(), dataPtr, numBytes);
     return dataVec;
   default:
@@ -616,26 +616,26 @@ std::vector<std::byte> getDataBuffer(::tt::runtime::Tensor tensor) {
 }
 
 std::vector<std::uint32_t> getShape(::tt::runtime::Tensor tensor) {
-  auto ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
+  auto *ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
   std::vector<std::uint32_t> shape(ttnnTensor->logical_shape().cbegin(),
                                    ttnnTensor->logical_shape().cend());
   return shape;
 }
 
 std::vector<std::uint32_t> getStride(::tt::runtime::Tensor tensor) {
-  auto ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
+  auto *ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
   std::vector<std::uint32_t> stride(ttnnTensor->strides().cbegin(),
                                     ttnnTensor->strides().cend());
   return stride;
 }
 
 std::uint32_t getElementSize(::tt::runtime::Tensor tensor) {
-  auto ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
+  auto *ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
   return ttnnTensor->element_size();
 }
 
 std::uint32_t getVolume(::tt::runtime::Tensor tensor) {
-  auto ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
+  auto *ttnnTensor = static_cast<::ttnn::Tensor *>(tensor.handle.get());
   return ttnnTensor->volume();
 }