[libc] add the CPP algorithm header for min/max

[gchatelet]

It came up in https://reviews.llvm.org/D156981?id=547819#inline-1521250

[jhuber6]

These should probably be constexpr and need LIBC_INLINE. If you want to go the extra mile you'd use type traits to confirm that T::operator< exists, but I don't think that's necessary. Make the first use of this the usage in rpc_utils.h

[gchatelet]

• Rebase and address comments

[gchatelet]

• Fix typo

libc/src/__support/CMakeLists.txt

 )
 
 add_header_library(
   integer_to_string
   HDRS
     integer_to_string.h
   DEPENDS
     libc.src.__support.common
+    libc.src.__support.CPP.algorithm
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.span
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.type_traits
 )
 
 
 add_header_library(

libc/src/__support/CPP/CMakeLists.txt

 add_header_library(
+  algorithm
+  HDRS
+    algorithm.h
+)
+
+add_header_library(
   array
   HDRS
     array.h
 )
 
 add_header_library(
   bit
   HDRS

libc/src/__support/CPP/algorithm.h

+//===-- A self contained equivalent of <algorithm> --------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// This file is minimalist on purpose but can receive a few more function if
+// they prove useful.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SUPPORT_CPP_ALGORITHM_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_ALGORITHM_H
+
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
+
+namespace __llvm_libc {
+namespace cpp {
+
+template <class T> LIBC_INLINE constexpr const T &max(const T &a, const T &b) {
+  return (a < b) ? b : a;
+}
+
+template <class T> LIBC_INLINE constexpr const T &min(const T &a, const T &b) {
+  return (a < b) ? a : b;
+}
+
+} // namespace cpp
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_ALGORITHM_H

libc/src/__support/RPC/CMakeLists.txt

 if(NOT LIBC_TARGET_ARCHITECTURE_IS_GPU)
   return()
 endif()
 
 add_header_library(
   rpc
   HDRS
     rpc.h
     rpc_util.h
   DEPENDS
     libc.src.__support.common
+    libc.src.__support.CPP.algorithm
     libc.src.__support.CPP.atomic
-    libc.src.__support.CPP.optional
     libc.src.__support.CPP.functional
+    libc.src.__support.CPP.optional
     libc.src.__support.GPU.utils
 )
 
 add_object_library(
   rpc_client
   SRCS
     rpc_client.cpp
   HDRS
     rpc_client.h
   DEPENDS
     libc.include.gpu_rpc
     libc.src.__support.GPU.utils
     .rpc
 )

libc/src/__support/RPC/rpc.h

 // the buffer.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_RPC_RPC_H
 #define LLVM_LIBC_SRC_SUPPORT_RPC_RPC_H
 
 #include "rpc_util.h"
+#include "src/__support/CPP/algorithm.h" // max
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/functional.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/GPU/utils.h"
 #include "src/string/memory_utils/inline_memcpy.h"
 
 #include <stdint.h>
 

 /// Sends an arbitrarily sized data buffer \p src across the shared channel in
 /// multiples of the packet length.
 template <bool T, typename S>
 LIBC_INLINE void Port<T, S>::send_n(const void *const *src, uint64_t *size) {
   uint64_t num_sends = 0;
   send([&](Buffer *buffer, uint32_t id) {
     reinterpret_cast<uint64_t *>(buffer->data)[0] = lane_value(size, id);
     num_sends = is_process_gpu() ? lane_value(size, id)
-                                 : max(lane_value(size, id), num_sends);
+                                 : cpp::max(lane_value(size, id), num_sends);
     uint64_t len =
         lane_value(size, id) > sizeof(Buffer::data) - sizeof(uint64_t)
             ? sizeof(Buffer::data) - sizeof(uint64_t)
             : lane_value(size, id);
     inline_memcpy(&buffer->data[1], lane_value(src, id), len);
   });
   uint64_t idx = sizeof(Buffer::data) - sizeof(uint64_t);
   uint64_t mask = process.packet[index].header.mask;

 template <typename A>
 LIBC_INLINE void Port<T, S>::recv_n(void **dst, uint64_t *size, A &&alloc) {
   uint64_t num_recvs = 0;
   recv([&](Buffer *buffer, uint32_t id) {
     lane_value(size, id) = reinterpret_cast<uint64_t *>(buffer->data)[0];
     lane_value(dst, id) =
         reinterpret_cast<uint8_t *>(alloc(lane_value(size, id)));
     num_recvs = is_process_gpu() ? lane_value(size, id)
-                                 : max(lane_value(size, id), num_recvs);
+                                 : cpp::max(lane_value(size, id), num_recvs);
     uint64_t len =
         lane_value(size, id) > sizeof(Buffer::data) - sizeof(uint64_t)
             ? sizeof(Buffer::data) - sizeof(uint64_t)
             : lane_value(size, id);
     inline_memcpy(lane_value(dst, id), &buffer->data[1], len);
   });
   uint64_t idx = sizeof(Buffer::data) - sizeof(uint64_t);
   uint64_t mask = process.packet[index].header.mask;

libc/src/__support/RPC/rpc_util.h

 //===-- Shared memory RPC client / server utilities -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_RPC_RPC_UTILS_H
 #define LLVM_LIBC_SRC_SUPPORT_RPC_RPC_UTILS_H
 
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/GPU/utils.h"
-#include "src/__support/macros/attributes.h"
+#include "src/__support/macros/attributes.h" // LIBC_INLINE
 #include "src/__support/macros/properties/architectures.h"
 
 namespace __llvm_libc {
 namespace rpc {
 
 /// Maximum amount of data a single lane can use.
 constexpr uint64_t MAX_LANE_SIZE = 64;
 

 /// simply use the variable passed in. On the CPU we need to allocate enough
 /// space for the whole lane and index into it.
 template <typename V> LIBC_INLINE V &lane_value(V *val, uint32_t id) {
   if constexpr (is_process_gpu())
     return *val;
   return val[id];
 }
 
-/// Helper to get the maximum value.
-template <typename T> LIBC_INLINE const T &max(const T &x, const T &y) {
-  return x < y ? y : x;
-}
-
 /// Advance the \p p by \p bytes.
 template <typename T, typename U> LIBC_INLINE T *advance(T *ptr, U bytes) {
   if constexpr (cpp::is_const_v<T>)
     return reinterpret_cast<T *>(reinterpret_cast<const uint8_t *>(ptr) +
                                  bytes);
   else
     return reinterpret_cast<T *>(reinterpret_cast<uint8_t *>(ptr) + bytes);
 }
 
 } // namespace rpc
 } // namespace __llvm_libc
 
 #endif

libc/src/__support/integer_to_string.h

 //   IntegerToString<uint8_t, radix::Hex::WithWidth<4>::Uppercase>(255) : "00FF"
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 #define LLVM_LIBC_SRC_SUPPORT_INTEGER_TO_STRING_H
 
 #include <stdint.h>
 
+#include "src/__support/CPP/algorithm.h" // max
 #include "src/__support/CPP/array.h"
 #include "src/__support/CPP/bit.h"
 #include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/type_traits.h"
 #include "src/__support/common.h"
constexpr auto max_digits = []() -> size_t {
         size_t i = 0;
         for (; num > 1; num /= 2)
           ++i;
         return i;
       };
       constexpr size_t BITS_PER_DIGIT = floor_log_2(Fmt::BASE);
       return ((sizeof(T) * 8 + (BITS_PER_DIGIT - 1)) / BITS_PER_DIGIT);
     };
-    constexpr auto max = [](size_t a, size_t b) -> size_t {
-      return a > b ? a : b;
-    };
-    constexpr size_t digit_size = max(max_digits(), Fmt::MIN_DIGITS);
+    constexpr size_t digit_size = cpp::max(max_digits(), Fmt::MIN_DIGITS);
     constexpr size_t sign_size = Fmt::BASE == 10 ? 1 : 0;
     constexpr size_t prefix_size = Fmt::PREFIX ? 2 : 0;
     return digit_size + sign_size + prefix_size;
   }
 
   static constexpr size_t BUFFER_SIZE = compute_buffer_size();
   static_assert(BUFFER_SIZE > 0);
 

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

libc_support_library(
     deps = [
         ":__support_macros_attributes",
         ":__support_macros_properties_architectures",
         ":libc_root",
     ],
 )
 
 libc_support_library(
+    name = "__support_cpp_algorithm",
+    hdrs = ["src/__support/CPP/algorithm.h"],
+    deps = [
+        ":libc_root",
+    ],
+)
+
+libc_support_library(
     name = "__support_cpp_array",
     hdrs = ["src/__support/CPP/array.h"],
     deps = [
         ":__support_macros_attributes",
         ":libc_root",
     ],
 )
 
libc_support_library(
     deps = [":__support_cpp_type_traits"],
 )
 
 libc_support_library(
     name = "__support_integer_to_string",
     hdrs = ["src/__support/integer_to_string.h"],
     deps = [
         ":__support_common",
+        ":__support_cpp_algorithm",
         ":__support_cpp_bit",
         ":__support_cpp_limits",
         ":__support_cpp_optional",
         ":__support_cpp_span",
         ":__support_cpp_string_view",
         ":__support_cpp_type_traits",
         ":libc_root",
     ],