essgateway","refId":"A"},{"datasource":{"type":"prometheus","uid":"${datasource}"},"expr":"(sum(irate(container_cpu_usage_seconds_total{namespace!=\"istio-system\",container=\"istio-proxy\"}[1m]))/ (round(sum(irate(istio_requests_total[1m])), 0.001)/1000))/ (sum(irate(istio_requests_total{source_workload=\"istio-ingressgateway\"}[1m])) >bool 10)","format":"time_series","intervalFactor":1,"legendFormat":"istio-proxy","refId":"B"}],"title":"vCPU / 1k rps","type":"timeseries"},{"datasource":{"type"...

          'Bytes ({{pod}})',
          |||
            sum by (pod) (
              rate(
                go_memstats_alloc_bytes_total{%(appLabels)s}
              [$__rate_interval])
            )
          |||
        ),
        self.query(
          'Objects ({{pod}})',
          |||
            sum by (pod) (
              rate(
                go_memstats_mallocs_total{%(appLabels)s}
              [$__rate_interval])

               "expr": "sum by (pod) (\n  rate(\n    go_memstats_alloc_bytes_total{app=\"istiod\"}\n  [$__rate_interval])\n)",
               "legendFormat": "Bytes ({{pod}})"
            },
            {
               "datasource": {
                  "type": "prometheus",
                  "uid": "$datasource"
               },

               "expr": "sum by (pod) (\n  rate(\n    istio_tcp_connections_opened_total{pod=~\"ztunnel-.*\"}\n  [$__rate_interval])\n)",
               "legendFormat": "Opened ({{pod}})"
            },
            {
               "datasource": {
                  "type": "prometheus",
                  "uid": "$datasource"
               },

##################################################################################################
# Redis service and deployment
# Ratelimit service and deployment

# Note: a configmap is needed to make the rate limit deployment work properly, for example:
#
#  apiVersion: v1
#  kind: ConfigMap
#  metadata:
#    name: ratelimit-config
#  data:
#    config.yaml: |
#      domain: echo-ratelimit
#      descriptors:

	s.function = function
	switch function {
	case sha3_224:
		s.rate = 144
		s.outputLen = 28
	case sha3_256:
		s.rate = 136
		s.outputLen = 32
	case sha3_384:
		s.rate = 104
		s.outputLen = 48
	case sha3_512:
		s.rate = 72
		s.outputLen = 64
	case shake_128:
		s.rate = 168
		s.outputLen = 32
	case shake_256:
		s.rate = 136
		s.outputLen = 64
	default:
		panic("sha3: unrecognized function code")

	}
	written = len(p)

	for len(p) > 0 {
		if d.n == 0 && len(p) >= d.rate {
			// The fast path; absorb a full "rate" bytes of input and apply the permutation.
			xorIn(d, p[:d.rate])
			p = p[d.rate:]
			keccakF1600(&d.a)
		} else {
			// The slow path; buffer the input until we can fill the sponge, and then xor it in.
			todo := d.rate - d.n
			if todo > len(p) {
				todo = len(p)
			}

// which samples to collect, based on the desired average collection
// rate R. The probability of a sample of size S to appear in that
// profile is 1-exp(-S/R).
func scaleHeapSample(count, size, rate int64) (int64, int64) {
	if count == 0 || size == 0 {
		return 0, 0
	}

	if rate <= 1 {
		// if rate==1 all samples were collected so no adjustment is needed.
		// if rate<1 treat as unknown and skip scaling.
		return count, size
	}

	i := byte(1)
	for i < 8 && b[i] == 0 {
		i++
	}
	// Prepend number of encoded bytes
	b[i-1] = 9 - i
	return b[i-1:]
}

func newCShake(N, S []byte, rate, outputLen int, dsbyte byte) ShakeHash {
	c := cshakeState{state: &state{rate: rate, outputLen: outputLen, dsbyte: dsbyte}}

	// leftEncode returns max 9 bytes
	c.initBlock = make([]byte, 0, 9*2+len(N)+len(S))

	return new512()
}

func new224Generic() *state {
	return &state{rate: 144, outputLen: 28, dsbyte: 0x06}
}

func new256Generic() *state {
	return &state{rate: 136, outputLen: 32, dsbyte: 0x06}
}

func new384Generic() *state {
	return &state{rate: 104, outputLen: 48, dsbyte: 0x06}
}

func new512Generic() *state {
	return &state{rate: 72, outputLen: 64, dsbyte: 0x06}
}