final long freeBytes = runtime.freeMemory();
        final long maxBytes = runtime.maxMemory();
        final long totalBytes = runtime.totalMemory();
        final long usedBytes = totalBytes - freeBytes;
        return "Mem:{used " + byteCountToDisplaySize(usedBytes) + ", heap " + byteCountToDisplaySize(totalBytes) + ", max "
                + byteCountToDisplaySize(maxBytes) + "}";
    }

	var totalBytes int64
	for _, p := range prof {
		bytes := p.AllocBytes - p.FreeBytes
		nobj := p.AllocObjects - p.FreeObjects
		if nobj == 0 {
			// There may be a record that has had all of its objects
			// freed. That's fine. Avoid a divide-by-zero and skip.
			continue
		}
		size := bytes / nobj
		if size == tinyBlockSize {
			totalBytes += bytes
		}
	}

//
// addrRanges is not thread-safe.
type addrRanges struct {
	// ranges is a slice of ranges sorted by base.
	ranges []addrRange

	// totalBytes is the total amount of address space in bytes counted by
	// this addrRanges.
	totalBytes uintptr

	// sysStat is the stat to track allocations by this type
	sysStat *sysMemStat
}

func (a *addrRanges) init(sysStat *sysMemStat) {

				totalBytes := resource.NewQuantity(usage.Total, resource.BinarySI)
				usedBytes := resource.NewQuantity(usage.Used, resource.BinarySI)
				if metrics.Available.Cmp(*availableBytes) != 0 {
					t.Fatalf("for %s: error: expected :%v , got: %v", tc.name, *availableBytes, *(metrics.Available))
				}
				if metrics.Capacity.Cmp(*totalBytes) != 0 {

      }
      offset += elem.NumElements();
    } else {
      std::copy_n(elem.tensor_data().data(), elem.TotalBytes(),
                  const_cast<char*>(t.tensor_data().data()) + offset);
      offset += elem.TotalBytes();
    }
  }
  tensor = t;
}

				Namespace: b.pod.Namespace,
				Name:      b.source.Name,
			},
		}
	}

	totalBytes := totalBytes(configMap)
	klog.V(3).Infof("Received configMap %v/%v containing (%v) pieces of data, %v total bytes",
		b.pod.Namespace,
		b.source.Name,
		len(configMap.Data)+len(configMap.BinaryData),
		totalBytes)

	payload, err := MakePayload(b.source.Items, configMap, b.source.DefaultMode, optional)
	if err != nil {

				Namespace: b.pod.Namespace,
				Name:      b.source.SecretName,
			},
		}
	}

	totalBytes := totalSecretBytes(secret)
	klog.V(3).Infof("Received secret %v/%v containing (%v) pieces of data, %v total bytes",
		b.pod.Namespace,
		b.source.SecretName,
		len(secret.Data),
		totalBytes)

	payload, err := MakePayload(b.source.Items, secret, b.source.DefaultMode, optional)
	if err != nil {

  }

  private static void assertReadableBytes(HashCode hashCode) {
    assertTrue(hashCode.bits() >= 32); // sanity
    byte[] hashBytes = hashCode.asBytes();
    int totalBytes = hashCode.bits() / 8;

    for (int bytes = 0; bytes < totalBytes; bytes++) {
      byte[] bb = new byte[bytes];
      hashCode.writeBytesTo(bb, 0, bb.length);

      assertTrue(Arrays.equals(Arrays.copyOf(hashBytes, bytes), bb));
    }
  }

    var publicSuffixExceptionListBytes: ByteArray?

    try {
      GzipSource(fileSystem.source(path)).buffer().use { bufferedSource ->
        val totalBytes = bufferedSource.readInt()
        publicSuffixListBytes = bufferedSource.readByteArray(totalBytes.toLong())

        val totalExceptionBytes = bufferedSource.readInt()
        publicSuffixExceptionListBytes = bufferedSource.readByteArray(totalExceptionBytes.toLong())

				t.Errorf("ranges %d and %d overlap", i-1, i)
			}
		}
	}
	if wantTotalBytes != gotTotalBytes {
		t.Errorf("expected %d total bytes, got %d", wantTotalBytes, gotTotalBytes)
	}
	if b := a.TotalBytes(); b != gotTotalBytes {
		t.Errorf("inconsistent total bytes: want %d, got %d", gotTotalBytes, b)
	}
	if t.Failed() {
		t.Errorf("addrRanges: %v", ranges)
		t.Fatal("detected bad addrRanges")
	}
}