grpc 1.45.0 → 1.53.0

data/src/core/lib/experiments/config.cc

@@ -0,0 +1,161 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/experiments/config.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <atomic>
+#include <string>
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/support/log.h>
+
+#include "src/core/lib/experiments/experiments.h"
+#include "src/core/lib/gprpp/crash.h"  // IWYU pragma: keep
+#include "src/core/lib/gprpp/global_config.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/no_destruct.h"
+
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
+GPR_GLOBAL_CONFIG_DEFINE_STRING(
+    grpc_experiments, "",
+    "List of grpc experiments to enable (or with a '-' prefix to disable).");
+
+namespace grpc_core {
+
+namespace {
+struct Experiments {
+  bool enabled[kNumExperiments];
+};
+
+struct ForcedExperiment {
+  bool forced = false;
+  bool value;
+};
+ForcedExperiment g_forced_experiments[kNumExperiments];
+
+std::atomic<bool> g_loaded;
+
+GPR_ATTRIBUTE_NOINLINE Experiments LoadExperimentsFromConfigVariable() {
+  GPR_ASSERT(g_loaded.exchange(true, std::memory_order_relaxed) == false);
+  // Set defaults from metadata.
+  Experiments experiments;
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    if (!g_forced_experiments[i].forced) {
+      experiments.enabled[i] = g_experiment_metadata[i].default_value;
+    } else {
+      experiments.enabled[i] = g_forced_experiments[i].value;
+    }
+  }
+  // Get the global config.
+  auto experiments_str = GPR_GLOBAL_CONFIG_GET(grpc_experiments);
+  // For each comma-separated experiment in the global config:
+  for (auto experiment :
+       absl::StrSplit(absl::string_view(experiments_str.get()), ',')) {
+    // Strip whitespace.
+    experiment = absl::StripAsciiWhitespace(experiment);
+    // Handle ",," without crashing.
+    if (experiment.empty()) continue;
+    // Enable unless prefixed with '-' (=> disable).
+    bool enable = true;
+    if (experiment[0] == '-') {
+      enable = false;
+      experiment.remove_prefix(1);
+    }
+    // See if we can find the experiment in the list in this binary.
+    bool found = false;
+    for (size_t i = 0; i < kNumExperiments; i++) {
+      if (experiment == g_experiment_metadata[i].name) {
+        experiments.enabled[i] = enable;
+        found = true;
+        break;
+      }
+    }
+    // If not found log an error, but don't take any other action.
+    // Allows us an easy path to disabling experiments.
+    if (!found) {
+      gpr_log(GPR_ERROR, "Unknown experiment: %s",
+              std::string(experiment).c_str());
+    }
+  }
+  return experiments;
+}
+}  // namespace
+
+bool IsExperimentEnabled(size_t experiment_id) {
+  // One time initialization:
+  static const NoDestruct<Experiments> experiments{
+      LoadExperimentsFromConfigVariable()};
+  // Normal path: just return the value;
+  return experiments->enabled[experiment_id];
+}
+
+void PrintExperimentsList() {
+  size_t max_experiment_length = 0;
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    max_experiment_length =
+        std::max(max_experiment_length, strlen(g_experiment_metadata[i].name));
+  }
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    gpr_log(GPR_DEBUG, "%s",
+            absl::StrCat(
+                "gRPC EXPERIMENT ", g_experiment_metadata[i].name,
+                std::string(max_experiment_length -
+                                strlen(g_experiment_metadata[i].name) + 1,
+                            ' '),
+                IsExperimentEnabled(i) ? "ON " : "OFF", " (default:",
+                g_experiment_metadata[i].default_value ? "ON" : "OFF",
+                g_forced_experiments[i].forced
+                    ? absl::StrCat(" force:",
+                                   g_forced_experiments[i].value ? "ON" : "OFF")
+                    : std::string(),
+                ")")
+                .c_str());
+  }
+}
+
+void ForceEnableExperiment(absl::string_view experiment, bool enable) {
+  GPR_ASSERT(g_loaded.load(std::memory_order_relaxed) == false);
+  for (size_t i = 0; i < kNumExperiments; i++) {
+    if (g_experiment_metadata[i].name != experiment) continue;
+    if (g_forced_experiments[i].forced) {
+      GPR_ASSERT(g_forced_experiments[i].value == enable);
+    } else {
+      g_forced_experiments[i].forced = true;
+      g_forced_experiments[i].value = enable;
+    }
+    return;
+  }
+  gpr_log(GPR_INFO, "gRPC EXPERIMENT %s not found to force %s",
+          std::string(experiment).c_str(), enable ? "enable" : "disable");
+}
+
+}  // namespace grpc_core
+#else
+namespace grpc_core {
+void PrintExperimentsList() {}
+void ForceEnableExperiment(absl::string_view experiment_name, bool) {
+  Crash(absl::StrCat("ForceEnableExperiment(\"", experiment_name,
+                     "\") called in final build"));
+}
+}  // namespace grpc_core
+#endif

data/src/core/lib/experiments/config.h

@@ -0,0 +1,53 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
+#define GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "absl/strings/string_view.h"
+
+// #define GRPC_EXPERIMENTS_ARE_FINAL
+
+namespace grpc_core {
+
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
+// Return true if experiment \a experiment_id is enabled.
+// Experiments are numbered by their order in the g_experiment_metadata array
+// declared in experiments.h.
+bool IsExperimentEnabled(size_t experiment_id);
+#endif
+
+// Print out a list of all experiments that are built into this binary.
+void PrintExperimentsList();
+
+// Force an experiment to be on or off.
+// Must be called before experiments are configured (the first
+// IsExperimentEnabled call).
+// If the experiment does not exist, emits a warning but continues execution.
+// If this is called twice for the same experiment, both calls must agree.
+void ForceEnableExperiment(absl::string_view experiment_name, bool enable);
+
+struct ExperimentMetadata {
+  const char* name;
+  const char* description;
+  bool default_value;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_EXPERIMENTS_CONFIG_H

data/src/core/lib/experiments/experiments.cc

@@ -0,0 +1,81 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Automatically generated by tools/codegen/core/gen_experiments.py
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/experiments/experiments.h"
+
+#ifndef GRPC_EXPERIMENTS_ARE_FINAL
+namespace {
+const char* const description_tcp_frame_size_tuning =
+    "If set, enables TCP to use RPC size estimation made by higher layers. TCP "
+    "would not indicate completion of a read operation until a specified "
+    "number of bytes have been read over the socket. Buffers are also "
+    "allocated according to estimated RPC sizes.";
+const char* const description_tcp_rcv_lowat =
+    "Use SO_RCVLOWAT to avoid wakeups on the read path.";
+const char* const description_peer_state_based_framing =
+    "If set, the max sizes of frames sent to lower layers is controlled based "
+    "on the peer's memory pressure which is reflected in its max http2 frame "
+    "size.";
+const char* const description_flow_control_fixes =
+    "Various fixes for flow control, max frame size setting.";
+const char* const description_memory_pressure_controller =
+    "New memory pressure controller";
+const char* const description_unconstrained_max_quota_buffer_size =
+    "Discard the cap on the max free pool size for one memory allocator";
+const char* const description_event_engine_client =
+    "Use EventEngine clients instead of iomgr's grpc_tcp_client";
+const char* const description_monitoring_experiment =
+    "Placeholder experiment to prove/disprove our monitoring is working";
+const char* const description_promise_based_client_call =
+    "If set, use the new gRPC promise based call code when it's appropriate "
+    "(ie when all filters in a stack are promise based)";
+const char* const description_free_large_allocator =
+    "If set, return all free bytes from a \042big\042 allocator";
+const char* const description_promise_based_server_call =
+    "If set, use the new gRPC promise based call code when it's appropriate "
+    "(ie when all filters in a stack are promise based)";
+const char* const description_transport_supplies_client_latency =
+    "If set, use the transport represented value for client latency in "
+    "opencensus";
+const char* const description_event_engine_listener =
+    "Use EventEngine listeners instead of iomgr's grpc_tcp_server";
+}  // namespace
+
+namespace grpc_core {
+
+const ExperimentMetadata g_experiment_metadata[] = {
+    {"tcp_frame_size_tuning", description_tcp_frame_size_tuning, false},
+    {"tcp_rcv_lowat", description_tcp_rcv_lowat, false},
+    {"peer_state_based_framing", description_peer_state_based_framing, false},
+    {"flow_control_fixes", description_flow_control_fixes, true},
+    {"memory_pressure_controller", description_memory_pressure_controller,
+     false},
+    {"unconstrained_max_quota_buffer_size",
+     description_unconstrained_max_quota_buffer_size, false},
+    {"event_engine_client", description_event_engine_client, false},
+    {"monitoring_experiment", description_monitoring_experiment, true},
+    {"promise_based_client_call", description_promise_based_client_call, false},
+    {"free_large_allocator", description_free_large_allocator, false},
+    {"promise_based_server_call", description_promise_based_server_call, false},
+    {"transport_supplies_client_latency",
+     description_transport_supplies_client_latency, false},
+    {"event_engine_listener", description_event_engine_listener, false},
+};
+
+}  // namespace grpc_core
+#endif

data/src/core/lib/experiments/experiments.h

@@ -0,0 +1,117 @@
+// Copyright 2022 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Automatically generated by tools/codegen/core/gen_experiments.py
+//
+// This file contains the autogenerated parts of the experiments API.
+//
+// It generates two symbols for each experiment.
+//
+// For the experiment named new_car_project, it generates:
+//
+// - a function IsNewCarProjectEnabled() that returns true if the experiment
+//   should be enabled at runtime.
+//
+// - a macro GRPC_EXPERIMENT_IS_INCLUDED_NEW_CAR_PROJECT that is defined if the
+//   experiment *could* be enabled at runtime.
+//
+// The function is used to determine whether to run the experiment or
+// non-experiment code path.
+//
+// If the experiment brings significant bloat, the macro can be used to avoid
+// including the experiment code path in the binary for binaries that are size
+// sensitive.
+//
+// By default that includes our iOS and Android builds.
+//
+// Finally, a small array is included that contains the metadata for each
+// experiment.
+//
+// A macro, GRPC_EXPERIMENTS_ARE_FINAL, controls whether we fix experiment
+// configuration at build time (if it's defined) or allow it to be tuned at
+// runtime (if it's disabled).
+//
+// If you are using the Bazel build system, that macro can be configured with
+// --define=grpc_experiments_are_final=true
+
+#ifndef GRPC_SRC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H
+#define GRPC_SRC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include "src/core/lib/experiments/config.h"
+
+namespace grpc_core {
+
+#ifdef GRPC_EXPERIMENTS_ARE_FINAL
+inline bool IsTcpFrameSizeTuningEnabled() { return false; }
+inline bool IsTcpRcvLowatEnabled() { return false; }
+inline bool IsPeerStateBasedFramingEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_FLOW_CONTROL_FIXES
+inline bool IsFlowControlFixesEnabled() { return true; }
+inline bool IsMemoryPressureControllerEnabled() { return false; }
+inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() { return false; }
+inline bool IsEventEngineClientEnabled() { return false; }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
+inline bool IsMonitoringExperimentEnabled() { return true; }
+inline bool IsPromiseBasedClientCallEnabled() { return false; }
+inline bool IsFreeLargeAllocatorEnabled() { return false; }
+inline bool IsPromiseBasedServerCallEnabled() { return false; }
+inline bool IsTransportSuppliesClientLatencyEnabled() { return false; }
+inline bool IsEventEngineListenerEnabled() { return false; }
+#else
+#define GRPC_EXPERIMENT_IS_INCLUDED_TCP_FRAME_SIZE_TUNING
+inline bool IsTcpFrameSizeTuningEnabled() { return IsExperimentEnabled(0); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_TCP_RCV_LOWAT
+inline bool IsTcpRcvLowatEnabled() { return IsExperimentEnabled(1); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PEER_STATE_BASED_FRAMING
+inline bool IsPeerStateBasedFramingEnabled() { return IsExperimentEnabled(2); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_FLOW_CONTROL_FIXES
+inline bool IsFlowControlFixesEnabled() { return IsExperimentEnabled(3); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MEMORY_PRESSURE_CONTROLLER
+inline bool IsMemoryPressureControllerEnabled() {
+  return IsExperimentEnabled(4);
+}
+#define GRPC_EXPERIMENT_IS_INCLUDED_UNCONSTRAINED_MAX_QUOTA_BUFFER_SIZE
+inline bool IsUnconstrainedMaxQuotaBufferSizeEnabled() {
+  return IsExperimentEnabled(5);
+}
+#define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_CLIENT
+inline bool IsEventEngineClientEnabled() { return IsExperimentEnabled(6); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_MONITORING_EXPERIMENT
+inline bool IsMonitoringExperimentEnabled() { return IsExperimentEnabled(7); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_CLIENT_CALL
+inline bool IsPromiseBasedClientCallEnabled() { return IsExperimentEnabled(8); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_FREE_LARGE_ALLOCATOR
+inline bool IsFreeLargeAllocatorEnabled() { return IsExperimentEnabled(9); }
+#define GRPC_EXPERIMENT_IS_INCLUDED_PROMISE_BASED_SERVER_CALL
+inline bool IsPromiseBasedServerCallEnabled() {
+  return IsExperimentEnabled(10);
+}
+#define GRPC_EXPERIMENT_IS_INCLUDED_TRANSPORT_SUPPLIES_CLIENT_LATENCY
+inline bool IsTransportSuppliesClientLatencyEnabled() {
+  return IsExperimentEnabled(11);
+}
+#define GRPC_EXPERIMENT_IS_INCLUDED_EVENT_ENGINE_LISTENER
+inline bool IsEventEngineListenerEnabled() { return IsExperimentEnabled(12); }
+
+constexpr const size_t kNumExperiments = 13;
+extern const ExperimentMetadata g_experiment_metadata[kNumExperiments];
+
+#endif
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_EXPERIMENTS_EXPERIMENTS_H

data/src/core/lib/gpr/alloc.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -24,10 +24,9 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/lib/profiling/timers.h"
+#include "src/core/lib/gprpp/crash.h"
 
 void* gpr_malloc(size_t size) {
-  GPR_TIMER_SCOPE("gpr_malloc", 0);
   void* p;
   if (size == 0) return nullptr;
   p = malloc(size);
@@ -38,7 +37,6 @@ void* gpr_malloc(size_t size) {
 }
 
 void* gpr_zalloc(size_t size) {
-  GPR_TIMER_SCOPE("gpr_zalloc", 0);
   void* p;
   if (size == 0) return nullptr;
   p = calloc(size, 1);
@@ -48,13 +46,9 @@ void* gpr_zalloc(size_t size) {
   return p;
 }
 
-void gpr_free(void* p) {
-  GPR_TIMER_SCOPE("gpr_free", 0);
-  free(p);
-}
+void gpr_free(void* p) { free(p); }
 
 void* gpr_realloc(void* p, size_t size) {
-  GPR_TIMER_SCOPE("gpr_realloc", 0);
   if ((size == 0) && (p == nullptr)) return nullptr;
   p = realloc(p, size);
   if (!p) {

data/src/core/lib/gpr/alloc.h

@@ -1,23 +1,23 @@
-/*
- *
- * Copyright 2018 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2018 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
-#ifndef GRPC_CORE_LIB_GPR_ALLOC_H
-#define GRPC_CORE_LIB_GPR_ALLOC_H
+#ifndef GRPC_SRC_CORE_LIB_GPR_ALLOC_H
+#define GRPC_SRC_CORE_LIB_GPR_ALLOC_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,4 +25,4 @@
 #define GPR_ROUND_UP_TO_ALIGNMENT_SIZE(x) \
   (((x) + GPR_MAX_ALIGNMENT - 1u) & ~(GPR_MAX_ALIGNMENT - 1u))
 
-#endif /* GRPC_CORE_LIB_GPR_ALLOC_H */
+#endif  // GRPC_SRC_CORE_LIB_GPR_ALLOC_H

data/src/core/lib/gpr/atm.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2017 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 

data/src/core/lib/gpr/cpu_iphone.cc

@@ -1,20 +1,20 @@
-/*
- *
- * Copyright 2015 gRPC authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
+//
+//
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
 
 #include <grpc/support/port_platform.h>
 
@@ -33,12 +33,12 @@ unsigned gpr_cpu_num_cores(void) {
   return ncpu;
 }
 
-/* Most code that's using this is using it to shard across work queues. So
-   unless profiling shows it's a problem or there appears a way to detect the
-   currently running CPU core, let's have it shard the default way.
-   Note that the interface in cpu.h lets gpr_cpu_num_cores return 0, but doing
-   it makes it impossible for gpr_cpu_current_cpu to satisfy its stated range,
-   and some code might be relying on it. */
+// Most code that's using this is using it to shard across work queues. So
+// unless profiling shows it's a problem or there appears a way to detect the
+// currently running CPU core, let's have it shard the default way.
+// Note that the interface in cpu.h lets gpr_cpu_num_cores return 0, but doing
+// it makes it impossible for gpr_cpu_current_cpu to satisfy its stated range,
+// and some code might be relying on it.
 unsigned gpr_cpu_current_cpu(void) { return 0; }
 
-#endif /* GPR_CPU_IPHONE */
+#endif  // GPR_CPU_IPHONE