Tweak the Printer code in runtime for smaller code

cmake/HalideTestHelpers.cmake

@@ -54,7 +54,9 @@ function(add_halide_test TARGET)
  add_test(NAME ${TARGET}
  COMMAND ${args_COMMAND} ${args_ARGS}
  WORKING_DIRECTORY "${args_WORKING_DIRECTORY}")
- set_halide_compiler_warnings(${TARGET})
+ if (NOT Halide_TARGET MATCHES "wasm")
+ set_halide_compiler_warnings(${TARGET})
+ endif ()
 
  # We can't add Halide::TerminateHandler here, because it requires Halide::Error
  # and friends to be present in the final linkage, but some callers of add_halide_test()

src/runtime/d3d12compute.cpp

@@ -98,11 +98,11 @@ static constexpr uint64_t trace_buf_size = 4096;
 WEAK char trace_buf[trace_buf_size] = {};
 WEAK int trace_indent = 0;
 
-struct trace : public BasicPrinter<trace_buf_size> {
+struct trace : public PrinterBase {
  ScopedMutexLock lock;
 
  explicit trace(void *user_context = nullptr)
- : BasicPrinter<trace_buf_size>(user_context, trace_buf),
+ : PrinterBase(user_context, trace_buf, trace_buf_size),
  lock(&trace_lock) {
  for (int i = 0; i < trace_indent; i++) {
  *this << " ";

src/runtime/posix_error_handler.cpp

@@ -7,18 +7,16 @@ extern "C" {
 extern void abort();
 
 WEAK void halide_default_error(void *user_context, const char *msg) {
- char buf[4096];
- char *dst = halide_string_to_string(buf, buf + 4094, "Error: ");
- dst = halide_string_to_string(dst, dst + 4094, msg);
- // We still have one character free. Add a newline if there
- // isn't one already.
- if (dst[-1] != '\n') {
- dst[0] = '\n';
- dst[1] = 0;
- dst += 1;
+ // Can't use StackBasicPrinter here because it limits size to 256
+ constexpr int buf_size = 4096;
+ char buf[buf_size];
+ PrinterBase dst(user_context, buf, buf_size);
+ dst << "Error: " << msg;
+ const char *d = dst.str();
+ if (d && *d && d[strlen(d) - 1] != '\n') {
+ dst << "\n";
  }
- (void)halide_msan_annotate_memory_is_initialized(user_context, buf, dst - buf + 1);
- halide_print(user_context, buf);
+ halide_print(user_context, dst.str());
  abort();
 }
 }

src/runtime/printer.h

@@ -41,179 +41,174 @@ constexpr uint64_t default_printer_buffer_length = 1024;
 // Then remember the print only happens when the debug object leaves
 // scope, which may print at a confusing time.
 
-namespace {
-template<PrinterType printer_type, uint64_t buffer_length = default_printer_buffer_length>
-class Printer {
- char *buf, *dst, *end;
- void *user_context;
- bool own_mem;
+class PrinterBase {
+protected:
+ char *dst;
+ char *const end;
+ char *const start;
+ void *const user_context;
+
+ NEVER_INLINE void allocation_error() const {
+ halide_error(user_context, "Printer buffer allocation failed.\n");
+ }
 
 public:
- explicit Printer(void *ctx, char *mem = nullptr)
- : user_context(ctx), own_mem(mem == nullptr) {
- if (mem != nullptr) {
- buf = mem;
- } else {
- buf = (char *)malloc(buffer_length);
+ // This class will stream text into the range [start, start + size - 1].
+ // It does *not* assume any ownership of the memory; it assumes
+ // the memory will remain valid for its lifespan, and doesn't
+ // attempt to free any allocations. It also doesn't do any sanity
+ // checking of the pointers, so if you pass in a null or bogus value,
+ // it will attempt to use it.
+ NEVER_INLINE PrinterBase(void *user_context_, char *start_, uint64_t size_)
+ : dst(start_),
+ // (If start is null, set end = start to ensure no writes are done)
+ end(start_ ? start_ + size_ - 1 : start_),
+ start(start_),
+ user_context(user_context_) {
+ if (end > start) {
+ // null-terminate the final byte to ensure string isn't $ENDLESS
+ *end = 0;
  }
+ }
+
+ NEVER_INLINE const char *str() {
+ (void)halide_msan_annotate_memory_is_initialized(user_context, start, dst - start + 1);
+ return start;
+ }
+
+ uint64_t size() const {
+ halide_debug_assert(user_context, dst >= start);
+ return (uint64_t)(dst - start);
+ }
+
+ uint64_t capacity() const {
+ halide_debug_assert(user_context, end >= start);
+ return (uint64_t)(end - start);
+ }
 
- dst = buf;
+ NEVER_INLINE void clear() {
+ dst = start;
  if (dst) {
- end = buf + (buffer_length - 1);
- *end = 0;
- } else {
- // Pointers equal ensures no writes to buffer via formatting code
- end = dst;
+ dst[0] = 0;
  }
+ }
 
-#if HALIDE_RUNTIME_PRINTER_LOG_THREADID
- uint64_t tid;
- pthread_threadid_np(0, &tid);
- *this << "(TID:" << tid << ")";
-#endif
+ NEVER_INLINE void erase(int n) {
+ if (dst) {
+ dst -= n;
+ if (dst < start) {
+ dst = start;
+ }
+ dst[0] = 0;
+ }
  }
 
- // Not movable, not copyable
- Printer(const Printer &copy) = delete;
- Printer &operator=(const Printer &) = delete;
- Printer(Printer &&) = delete;
- Printer &operator=(Printer &&) = delete;
+ struct Float16Bits {
+ uint16_t bits;
+ };
 
- Printer &operator<<(const char *arg) {
+ // These are NEVER_INLINE because Clang will aggressively inline
+ // all of them, but the code size of calling out-of-line here is slightly
+ // smaller, and we ~always prefer smaller code size when using Printer
+ // in the runtime (it's a modest but nonzero difference).
+ NEVER_INLINE PrinterBase &operator<<(const char *arg) {
  dst = halide_string_to_string(dst, end, arg);
  return *this;
  }
 
- Printer &operator<<(int64_t arg) {
+ NEVER_INLINE PrinterBase &operator<<(int64_t arg) {
  dst = halide_int64_to_string(dst, end, arg, 1);
  return *this;
  }
 
- Printer &operator<<(int32_t arg) {
+ NEVER_INLINE PrinterBase &operator<<(int32_t arg) {
  dst = halide_int64_to_string(dst, end, arg, 1);
  return *this;
  }
 
- Printer &operator<<(uint64_t arg) {
+ NEVER_INLINE PrinterBase &operator<<(uint64_t arg) {
  dst = halide_uint64_to_string(dst, end, arg, 1);
  return *this;
  }
 
- Printer &operator<<(uint32_t arg) {
+ NEVER_INLINE PrinterBase &operator<<(uint32_t arg) {
  dst = halide_uint64_to_string(dst, end, arg, 1);
  return *this;
  }
 
- Printer &operator<<(double arg) {
+ NEVER_INLINE PrinterBase &operator<<(double arg) {
  dst = halide_double_to_string(dst, end, arg, 1);
  return *this;
  }
 
- Printer &operator<<(float arg) {
+ NEVER_INLINE PrinterBase &operator<<(float arg) {
  dst = halide_double_to_string(dst, end, arg, 0);
  return *this;
  }
 
- Printer &operator<<(const void *arg) {
- dst = halide_pointer_to_string(dst, end, arg);
+ NEVER_INLINE PrinterBase &operator<<(Float16Bits arg) {
+ double value = halide_float16_bits_to_double(arg.bits);
+ dst = halide_double_to_string(dst, end, value, 1);
  return *this;
  }
 
- Printer &write_float16_from_bits(const uint16_t arg) {
- double value = halide_float16_bits_to_double(arg);
- dst = halide_double_to_string(dst, end, value, 1);
+ NEVER_INLINE PrinterBase &operator<<(const void *arg) {
+ dst = halide_pointer_to_string(dst, end, arg);
  return *this;
  }
 
- Printer &operator<<(const halide_type_t &t) {
+ NEVER_INLINE PrinterBase &operator<<(const halide_type_t &t) {
  dst = halide_type_to_string(dst, end, &t);
  return *this;
  }
 
- Printer &operator<<(const halide_buffer_t &buf) {
+ NEVER_INLINE PrinterBase &operator<<(const halide_buffer_t &buf) {
  dst = halide_buffer_to_string(dst, end, &buf);
  return *this;
  }
 
- template<typename T>
- void append(const T &value) {
- *this << value;
- }
-
- template<typename First, typename Second, typename... Rest>
- void append(const First &first, const Second &second, const Rest &...rest) {
- append<First>(first);
- append<Second, Rest...>(second, rest...);
- }
-
- // Use it like a stringstream.
- const char *str() {
- if (buf) {
- if (printer_type == StringStreamPrinterType) {
- msan_annotate_is_initialized();
- }
- return buf;
- } else {
- return allocation_error();
- }
- }
-
- // Clear it. Useful for reusing a stringstream.
- void clear() {
- dst = buf;
- if (dst) {
- dst[0] = 0;
- }
+ template<typename... Args>
+ void append(const Args &...args) {
+ ((*this << args), ...);
  }
 
- // Returns the number of characters in the buffer
- uint64_t size() const {
- return (uint64_t)(dst - buf);
- }
+ // Not movable, not copyable
+ PrinterBase(const PrinterBase &copy) = delete;
+ PrinterBase &operator=(const PrinterBase &) = delete;
+ PrinterBase(PrinterBase &&) = delete;
+ PrinterBase &operator=(PrinterBase &&) = delete;
+};
 
- uint64_t capacity() const {
- return buffer_length;
- }
+namespace {
 
- // Delete the last N characters
- void erase(int n) {
- if (dst) {
- dst -= n;
- if (dst < buf) {
- dst = buf;
- }
- dst[0] = 0;
+template<PrinterType printer_type, uint64_t buffer_length = default_printer_buffer_length>
+class HeapPrinter : public PrinterBase {
+public:
+ NEVER_INLINE explicit HeapPrinter(void *user_context)
+ : PrinterBase(user_context, (char *)malloc(buffer_length), buffer_length) {
+ if (!start) {
+ allocation_error();
  }
- }
 
- const char *allocation_error() {
- return "Printer buffer allocation failed.\n";
- }
-
- void msan_annotate_is_initialized() {
- (void)halide_msan_annotate_memory_is_initialized(user_context, buf, dst - buf + 1);
+#if HALIDE_RUNTIME_PRINTER_LOG_THREADID
+ uint64_t tid;
+ pthread_threadid_np(0, &tid);
+ *this << "(TID:" << tid << ")";
+#endif
  }
 
- ~Printer() {
- if (!buf) {
- halide_error(user_context, allocation_error());
+ NEVER_INLINE ~HeapPrinter() {
+ if (printer_type == ErrorPrinterType) {
+ halide_error(user_context, str());
+ } else if (printer_type == BasicPrinterType) {
+ halide_print(user_context, str());
  } else {
- msan_annotate_is_initialized();
- if (printer_type == ErrorPrinterType) {
- halide_error(user_context, buf);
- } else if (printer_type == BasicPrinterType) {
- halide_print(user_context, buf);
- } else {
- // It's a stringstream. Do nothing.
- }
+ // It's a stringstream. Do nothing.
  }
 
- if (own_mem) {
- free(buf);
- }
+ free(start);
  }
 };
-
 // A class that supports << with all the same types as Printer, but
 // does nothing and should compile to a no-op.
 class SinkPrinter {
@@ -227,13 +222,13 @@ ALWAYS_INLINE SinkPrinter operator<<(const SinkPrinter &s, T) {
 }
 
 template<uint64_t buffer_length = default_printer_buffer_length>
-using BasicPrinter = Printer<BasicPrinterType, buffer_length>;
+using BasicPrinter = HeapPrinter<BasicPrinterType, buffer_length>;
 
 template<uint64_t buffer_length = default_printer_buffer_length>
-using ErrorPrinter = Printer<ErrorPrinterType, buffer_length>;
+using ErrorPrinter = HeapPrinter<ErrorPrinterType, buffer_length>;
 
 template<uint64_t buffer_length = default_printer_buffer_length>
-using StringStreamPrinter = Printer<StringStreamPrinterType, buffer_length>;
+using StringStreamPrinter = HeapPrinter<StringStreamPrinterType, buffer_length>;
 
 using print = BasicPrinter<>;
 using error = ErrorPrinter<>;
@@ -244,17 +239,16 @@ using debug = BasicPrinter<>;
 #else
 using debug = SinkPrinter;
 #endif
-} // namespace
 
 // A Printer that automatically reserves stack space for the printer buffer, rather than malloc.
 // Note that this requires an explicit buffer_length, and it (generally) should be <= 256.
 template<PrinterType printer_type, uint64_t buffer_length>
-class StackPrinter : public Printer<printer_type, buffer_length> {
+class StackPrinter : public PrinterBase {
  char scratch[buffer_length];
 
 public:
- explicit StackPrinter(void *ctx)
- : Printer<printer_type, buffer_length>(ctx, scratch) {
+ explicit StackPrinter(void *user_context)
+ : PrinterBase(user_context, scratch, buffer_length) {
  static_assert(buffer_length <= 256, "StackPrinter is meant only for small buffer sizes; you are probably making a mistake.");
  }
 };
@@ -268,6 +262,8 @@ using StackErrorPrinter = StackPrinter<ErrorPrinterType, buffer_length>;
 template<uint64_t buffer_length = default_printer_buffer_length>
 using StackStringStreamPrinter = StackPrinter<StringStreamPrinterType, buffer_length>;
 
+} // namespace
+
 } // namespace Internal
 } // namespace Runtime
 } // namespace Halide

src/runtime/runtime_internal.h

@@ -51,6 +51,8 @@ typedef ptrdiff_t ssize_t;
 
 #define WEAK __attribute__((weak))
 
+#define NEVER_INLINE __attribute__((noinline))
+
 // Note that ALWAYS_INLINE should *always* also be `inline`.
 #define ALWAYS_INLINE inline __attribute__((always_inline))