// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Tests increasing and decreasing GOMAXPROCS to try and
// catch issues with stale proc state.

//go:build ignore

package main

import (
	"log"
	"os"
	"runtime"
	"runtime/trace"
	"time"
)

func main() {
	// Start a goroutine that calls runtime.GC to try and

	By(decreasingDistance).Sort(planets)
	fmt.Println("By decreasing distance:", planets)

	// Output: By name: [{Earth 1 1} {Mars 0.107 1.5} {Mercury 0.055 0.4} {Venus 0.815 0.7}]
	// By mass: [{Mercury 0.055 0.4} {Mars 0.107 1.5} {Venus 0.815 0.7} {Earth 1 1}]
	// By distance: [{Mercury 0.055 0.4} {Venus 0.815 0.7} {Earth 1 1} {Mars 0.107 1.5}]
	// By decreasing distance: [{Mars 0.107 1.5} {Earth 1 1} {Venus 0.815 0.7} {Mercury 0.055 0.4}]

kind: feature
area: installation
issues:
- 29326

releaseNotes:
- |
  **Updated** the base image versions to be built on `ubuntu:focal` and `debian10` (for distroless).
- |

package report

import (
	"regexp"

	"github.com/google/pprof/internal/graph"
)

var sepRE = regexp.MustCompile(`::|\.`)

// shortNameList returns a non-empty sequence of shortened names
// (in decreasing preference) that can be used to represent name.
func shortNameList(name string) []string {
	name = graph.ShortenFunctionName(name)
	seps := sepRE.FindAllStringIndex(name, -1)
	result := make([]string, 0, len(seps)+1)

### Important notices

Decreasing resource requirements for cluster addons may cause system instability. The effects may include (but are not limited to):
  - Horizontal Pod Autoscaler not working
  - `kubectl top` not working (starting with Kubernetes 1.10)

    // destruction of py::bytes and returns a raw python object handle.
    return py::bytes(Serialize(src)).release();
  }

  // Constructs a `bytes` object by serializing `src`.
  static handle cast(const ProtoT& src, return_value_policy policy,
                     handle parent) {
    // release() prevents the reference count from decreasing upon the

	// Insert a new item and then modify its priority.
	item := &Item{
		value:    "orange",
		priority: 1,
	}
	heap.Push(&pq, item)
	pq.update(item, item.value, 5)

	// Take the items out; they arrive in decreasing priority order.
	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		fmt.Printf("%.2d:%s ", item.priority, item.value)
	}
	// Output:
	// 05:orange 04:pear 03:banana 02:apple

 * that exhibits the problem.
 *
 */
public interface Problem {

    /**
     * The different severity levels for a problem, in decreasing order.
     */
    enum Severity {
        FATAL, //
        ERROR, //
        WARNING //
    }

    /**

 * that exhibits the problem.
 *
 */
public interface SettingsProblem {

    /**
     * The different severity levels for a problem, in decreasing order.
     */
    enum Severity {
        FATAL, //
        ERROR, //
        WARNING //
    }

    /**

     *
     * @return the severity level of this problem, never {@code null}
     */
    @Nonnull
    Severity getSeverity();

    /**
     * The different severity levels for a problem, in decreasing order.
     *
     * @since 4.0.0
     */
    @Experimental
    enum Severity {
        FATAL, //
        ERROR, //
        WARNING //
    }