Add {fmt} (#822)

Author: Jacobfaib

cmake/thirdparty/get_fmt.cmake

@@ -0,0 +1,22 @@
+#=============================================================================
+# SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
+#
+# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+# property and proprietary rights in and to this material, related
+# documentation and any modifications thereto. Any use, reproduction,
+# disclosure or distribution of this material and related documentation
+# without an express license agreement from NVIDIA CORPORATION or
+# its affiliates is strictly prohibited.
+#=============================================================================
+
+include_guard(GLOBAL)
+
+function(find_or_configure_fmt)
+  list(APPEND CMAKE_MESSAGE_CONTEXT "fmt")
+
+  include(${rapids-cmake-dir}/cpm/fmt.cmake)
+
+  rapids_cpm_fmt(BUILD_EXPORT_SET legate-core-exports
+                 INSTALL_EXPORT_SET legate-core-exports)
+endfunction()

legate/CMakeLists.txt

@@ -21,6 +21,10 @@ endif()
 # the day it will be an arms race we cannot win.
 add_compile_options(-w)
 
+include(../cmake/Modules/find_or_configure.cmake)
+
+legate_core_find_or_configure(PACKAGE fmt)
+
 function(legate_core_create_cython_modules)
   list(APPEND CMAKE_MESSAGE_CONTEXT "create_cython_modules")
 
@@ -36,7 +40,17 @@ function(legate_core_create_cython_modules)
 
   rapids_cython_create_modules(CXX ASSOCIATED_TARGETS legate::core
                                SOURCE_FILES "${_LEGATE_CORE_CYTHON_SOURCES}"
-                               LINKED_LIBRARIES legate::core Python3::Module)
+                               LINKED_LIBRARIES legate::core
+                                                Python3::Module
+                                                # Some Cython modules require delving into
+                                                # the private headers of legate.core,
+                                                # which may contain fmt headers. As a
+                                                # result, we also need to add the fmt
+                                                # include paths etc. This is not done
+                                                # automatically for us, since fmt is a
+                                                # PRIVATE dependency of legate.core (as it
+                                                # is not found in any public includes).
+                                                fmt::fmt)
 
   foreach(target IN LISTS RAPIDS_CYTHON_CREATED_TARGETS)
     target_compile_features(${target} PRIVATE cxx_std_${CMAKE_CXX_STANDARD})

legate_core_cpp.cmake

@@ -157,6 +157,11 @@ legate_core_find_or_configure(PACKAGE span)
 
 legate_core_find_or_configure(PACKAGE mdspan)
 
+# ########################################################################################
+# * fmt::fmt --------------------------------------------------------------
+
+legate_core_find_or_configure(PACKAGE fmt)
+
 # ########################################################################################
 # * legate.core --------------------------------------------------------------
 
@@ -263,6 +268,7 @@ list(APPEND
      src/core/utilities/detail/buffer_builder.cc
      src/core/utilities/detail/tuple.cc
      src/core/utilities/detail/deserializer.cc
+     src/core/utilities/detail/formatters.cc
      src/timing/timing.cc
      # stl
      src/core/experimental/stl/detail/clang_tidy_dummy.cpp)
@@ -395,7 +401,7 @@ target_link_libraries(legate_core
                              $<TARGET_NAME_IF_EXISTS:OpenMP::OpenMP_CXX>
                              $<TARGET_NAME_IF_EXISTS:std::mdspan>
                              $<TARGET_NAME_IF_EXISTS:std::span>
-                      PRIVATE $<TARGET_NAME_IF_EXISTS:NCCL::NCCL>
+                      PRIVATE $<TARGET_NAME_IF_EXISTS:NCCL::NCCL> fmt::fmt
                               $<TARGET_NAME_IF_EXISTS:conda_env>)
 
 if(Legion_USE_CUDA)

src/core/data/detail/logical_array.cc

@@ -19,6 +19,7 @@
 #include "core/partitioning/detail/constraint_solver.h"
 
 #include <algorithm>
+#include <fmt/format.h>
 #include <iterator>
 #include <stdexcept>
 
@@ -240,7 +241,7 @@ InternalSharedPtr<LogicalArray> ListLogicalArray::child(std::uint32_t index) con
     case 0: return descriptor_;
     case 1: return vardata_;
     default: {
-      throw std::out_of_range{"List array does not have child " + std::to_string(index)};
+      throw std::out_of_range{fmt::format("List array does not have child {}", index)};
       break;
     }
   }

src/core/data/detail/logical_store.cc

@@ -29,6 +29,9 @@
 #include "legate_defines.h"
 
 #include <algorithm>
+#include <fmt/format.h>
+#include <fmt/ostream.h>
+#include <fmt/ranges.h>
 #include <numeric>
 #include <stdexcept>
 #include <utility>
@@ -368,7 +371,7 @@ InternalSharedPtr<StoragePartition> Storage::create_partition(
 
 std::string Storage::to_string() const
 {
-  auto kind_str = [&] {
+  const auto kind_str = [&] {
     switch (kind_) {
       case Kind::REGION_FIELD: return "Region";
       case Kind::FUTURE: return "Future";
@@ -377,12 +380,12 @@ std::string Storage::to_string() const
     LEGATE_UNREACHABLE();
   }();
 
-  std::stringstream ss;
-
-  ss << "Storage(" << storage_id_ << ") {" << shape_->to_string() << ", kind: " << kind_str
-     << ", type: " << type_->to_string() << ", level: " << level_ << "}";
-
-  return std::move(ss).str();
+  return fmt::format("Storage({}) {{{}, kind: {}, type: {}, level: {}}}",
+                     storage_id_,
+                     *shape_,
+                     kind_str,
+                     *type_,
+                     level_);
 }
 
 ////////////////////////////////////////////////////
@@ -445,8 +448,8 @@ namespace {
 void assert_fixed_storage_size(const Storage* storage)
 {
   if (storage->type()->variable_size()) {
-    throw std::invalid_argument{"Store cannot be created with variable size type " +
-                                storage->type()->to_string()};
+    throw std::invalid_argument{
+      fmt::format("Store cannot be created with variable size type {}", *(storage->type()))};
   }
 }
 
@@ -510,8 +513,8 @@ void LogicalStore::set_future_map(Legion::FutureMap future_map, std::size_t scal
 InternalSharedPtr<LogicalStore> LogicalStore::promote(std::int32_t extra_dim, std::size_t dim_size)
 {
   if (extra_dim < 0 || extra_dim > static_cast<std::int32_t>(dim())) {
-    throw std::invalid_argument{"Invalid promotion on dimension " + std::to_string(extra_dim) +
-                                " for a " + std::to_string(dim()) + "-D store"};
+    throw std::invalid_argument{
+      fmt::format("Invalid promotion on dimension {} for a {}-D store", extra_dim, dim())};
   }
 
   auto new_extents = extents().insert(extra_dim, dim_size);
@@ -524,13 +527,13 @@ InternalSharedPtr<LogicalStore> LogicalStore::project(std::int32_t d, std::int64
   auto&& old_extents = extents();
 
   if (d < 0 || d >= static_cast<std::int32_t>(dim())) {
-    throw std::invalid_argument{"Invalid projection on dimension " + std::to_string(d) + " for a " +
-                                std::to_string(dim()) + "-D store"};
+    throw std::invalid_argument{
+      fmt::format("Invalid projection on dimension {} for a {}-D store", d, dim())};
   }
 
   if (index < 0 || index >= static_cast<std::int64_t>(old_extents[d])) {
-    throw std::invalid_argument{"Projection index " + std::to_string(index) +
-                                " is out of bounds [0, " + std::to_string(old_extents[d]) + ")"};
+    throw std::invalid_argument{
+      fmt::format("Projection index {} is out of bounds [0, {})", index, old_extents[d])};
   }
 
   auto new_extents = old_extents.remove(d);
@@ -550,8 +553,8 @@ InternalSharedPtr<LogicalStore> LogicalStore::slice_(const InternalSharedPtr<Log
 {
   LEGATE_ASSERT(self.get() == this);
   if (dim < 0 || dim >= static_cast<std::int32_t>(this->dim())) {
-    throw std::invalid_argument{"Invalid slicing of dimension " + std::to_string(dim) + " for a " +
-                                std::to_string(this->dim()) + "-D store"};
+    throw std::invalid_argument{
+      fmt::format("Invalid slicing of dimension {} for a {}-D store", dim, this->dim())};
   }
 
   constexpr auto sanitize_slice = [](const Slice& san_slice, std::int64_t extent) {
@@ -573,9 +576,8 @@ InternalSharedPtr<LogicalStore> LogicalStore::slice_(const InternalSharedPtr<Log
   auto [start, stop] = sanitize_slice(slice, static_cast<std::int64_t>(exts[dim]));
 
   if (start < stop && (start >= exts[dim] || stop > exts[dim])) {
-    throw std::invalid_argument{"Out-of-bounds slicing on dimension " +
-                                std::to_string(this->dim()) + " for a store of shape " +
-                                extents().to_string()};
+    throw std::invalid_argument{fmt::format(
+      "Out-of-bounds slicing on dimension {} for a store of shape {}", this->dim(), extents())};
   }
 
   exts[dim] = (start < stop) ? (stop - start) : 0;
@@ -603,8 +605,8 @@ InternalSharedPtr<LogicalStore> LogicalStore::slice_(const InternalSharedPtr<Log
 InternalSharedPtr<LogicalStore> LogicalStore::transpose(std::vector<std::int32_t> axes)
 {
   if (axes.size() != dim()) {
-    throw std::invalid_argument{"Dimension Mismatch: expected " + std::to_string(dim()) +
-                                " axes, but got " + std::to_string(axes.size())};
+    throw std::invalid_argument{
+      fmt::format("Dimension Mismatch: expected {} axes, but got {}", dim(), axes.size())};
   }
 
   if (axes.size() != std::set<std::int32_t>{axes.begin(), axes.end()}.size()) {
@@ -613,8 +615,7 @@ InternalSharedPtr<LogicalStore> LogicalStore::transpose(std::vector<std::int32_t
 
   for (auto&& ax_i : axes) {
     if (ax_i < 0 || ax_i >= static_cast<std::int32_t>(dim())) {
-      throw std::invalid_argument{"Invalid axis " + std::to_string(ax_i) + " for a " +
-                                  std::to_string(dim()) + "-D store"};
+      throw std::invalid_argument{fmt::format("Invalid axis {} for a {}-D store", ax_i, dim())};
     }
   }
 
@@ -627,8 +628,8 @@ InternalSharedPtr<LogicalStore> LogicalStore::delinearize(std::int32_t dim,
                                                           std::vector<std::uint64_t> sizes)
 {
   if (dim < 0 || dim >= static_cast<std::int32_t>(this->dim())) {
-    throw std::invalid_argument{"Invalid delinearization on dimension " + std::to_string(dim) +
-                                " for a " + std::to_string(this->dim()) + "-D store"};
+    throw std::invalid_argument{
+      fmt::format("Invalid delinearization on dimension {} for a {}-D store", dim, this->dim())};
   }
 
   auto&& old_extents = extents();
@@ -642,9 +643,8 @@ InternalSharedPtr<LogicalStore> LogicalStore::delinearize(std::int32_t dim,
   };
 
   if (!delinearizable(old_extents[dim], sizes)) {
-    throw std::invalid_argument{"Dimension of size " + std::to_string(old_extents[dim]) +
-                                " cannot be delinearized into " +
-                                tuple<std::uint64_t>{sizes}.to_string()};
+    throw std::invalid_argument{
+      fmt::format("Dimension of size {} cannot be delinearized into {}", old_extents[dim], sizes)};
   }
 
   auto new_extents = tuple<std::uint64_t>{};
@@ -669,9 +669,10 @@ InternalSharedPtr<LogicalStorePartition> LogicalStore::partition_by_tiling_(
 {
   LEGATE_ASSERT(self.get() == this);
   if (tile_shape.size() != dim()) {
-    throw std::invalid_argument{"Incompatible tile shape: expected a " +
-                                std::to_string(extents().size()) + "-tuple, got a " +
-                                std::to_string(tile_shape.size()) + "-tuple"};
+    throw std::invalid_argument{
+      fmt::format("Incompatible tile shape: expected a {}-tuple, got a {}-tuple",
+                  extents().size(),
+                  tile_shape.size())};
   }
   if (tile_shape.volume() == 0) {
     throw std::invalid_argument{"Tile shape must have a volume greater than 0"};
@@ -1031,19 +1032,18 @@ std::unique_ptr<Analyzable> LogicalStore::to_launcher_arg_for_fixup_(
 
 std::string LogicalStore::to_string() const
 {
-  std::stringstream ss;
+  auto result = fmt::format("Store({}) {{shape: ", store_id_);
 
-  ss << "Store(" << store_id_ << ") {shape: ";
   if (unbound()) {
-    ss << "(unbound)";
+    fmt::format_to(std::back_inserter(result), "(unbound)");
   } else {
-    ss << extents();
+    fmt::format_to(std::back_inserter(result), "{}", extents());
   }
   if (!transform_->identity()) {
-    ss << ", transform: " << *transform_;
+    fmt::format_to(std::back_inserter(result), ", transform: {}", fmt::streamed(*transform_));
   }
-  ss << ", storage: " << get_storage()->id() << "}";
-  return std::move(ss).str();
+  fmt::format_to(std::back_inserter(result), ", storage: {}}}", get_storage()->id());
+  return result;
 }
 
 bool LogicalStore::equal_storage(const LogicalStore& other) const
@@ -1088,9 +1088,8 @@ InternalSharedPtr<LogicalStore> LogicalStorePartition::get_child_store(
   const auto* tiling = static_cast<const Tiling*>(partition_.get());
 
   if (!tiling->has_color(color)) {
-    throw std::out_of_range{"Color " + color.to_string() +
-                            " is invalid for partition of color shape " +
-                            color_shape().to_string()};
+    throw std::out_of_range{
+      fmt::format("Color {} is invalid for partition of color shape {}", color, color_shape())};
   }
 
   auto transform = store_->transform();

src/core/data/detail/physical_array.cc

@@ -12,6 +12,7 @@
 
 #include "core/data/detail/physical_array.h"
 
+#include <fmt/format.h>
 #include <stdexcept>
 
 namespace legate::detail {
@@ -79,7 +80,7 @@ InternalSharedPtr<PhysicalArray> ListPhysicalArray::child(std::uint32_t index) c
     case 0: return descriptor();
     case 1: return vardata();
     default: {
-      throw std::out_of_range{"List array does not have child " + std::to_string(index)};
+      throw std::out_of_range{fmt::format("List array does not have child {}", index)};
       break;
     }
   }

src/core/data/detail/physical_store.cc

@@ -17,8 +17,8 @@
 #include "core/utilities/dispatch.h"
 
 #include <cstring>  // std::memcpy
+#include <fmt/format.h>
 #include <stdexcept>
-#include <string>
 
 namespace legate::detail {
 
@@ -129,24 +129,24 @@ void PhysicalStore::bind_empty_data()
 void PhysicalStore::check_accessor_dimension_(std::int32_t dim) const
 {
   if (dim != this->dim() && (this->dim() != 0 || dim != 1)) {
-    throw std::invalid_argument{"Dimension mismatch: invalid to create a " + std::to_string(dim) +
-                                "-D accessor to a " + std::to_string(this->dim()) + "-D store"};
+    throw std::invalid_argument{fmt::format(
+      "Dimension mismatch: invalid to create a {}-D accessor to a {}-D store", dim, this->dim())};
   }
 }
 
 void PhysicalStore::check_buffer_dimension_(std::int32_t dim) const
 {
   if (dim != this->dim()) {
-    throw std::invalid_argument{"Dimension mismatch: invalid to bind a " + std::to_string(dim) +
-                                "-D buffer to a " + std::to_string(this->dim()) + "-D store"};
+    throw std::invalid_argument{fmt::format(
+      "Dimension mismatch: invalid to bind a {}-D buffer to a {}-D store", dim, this->dim())};
   }
 }
 
 void PhysicalStore::check_shape_dimension_(std::int32_t dim) const
 {
   if (dim != this->dim() && (this->dim() != 0 || dim != 1)) {
-    throw std::invalid_argument{"Dimension mismatch: invalid to retrieve a " + std::to_string(dim) +
-                                "-D rect from a " + std::to_string(this->dim()) + "-D store"};
+    throw std::invalid_argument{fmt::format(
+      "Dimension mismatch: invalid to retrieve a {}-D rect from a {}-D store", dim, this->dim())};
   }
 }
 

src/core/data/detail/shape.cc

@@ -16,6 +16,8 @@
 #include "core/runtime/detail/runtime.h"
 #include "core/utilities/detail/tuple.h"
 
+#include <fmt/ranges.h>
+
 namespace legate::detail {
 
 Shape::Shape(tuple<std::uint64_t>&& extents)
@@ -76,13 +78,13 @@ std::string Shape::to_string() const
 {
   switch (state_) {
     case State::UNBOUND: {
-      return "Shape(unbound " + std::to_string(dim_) + "D)";
+      return fmt::format("Shape(unbound {}D)", dim_);
     }
     case State::BOUND: {
-      return "Shape(bound " + std::to_string(dim_) + "D)";
+      return fmt::format("Shape(bound {}D)", dim_);
     }
     case State::READY: {
-      return "Shape" + extents_.to_string();
+      return fmt::format("Shape {}", extents_);
     }
   }
   return "";

src/core/data/detail/shape.h

@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include "core/utilities/detail/formatters.h"
 #include "core/utilities/tuple.h"
 
 #include "legion.h"