Package: github.com/cespare/xxhash/v2

package xxhash Import Path github.com/cespare/xxhash/v2 (on go.dev) Dependency Relation imports 5 packages, and imported by 2 packages

Involved Source Files d➜ xxhash.go Package xxhash implements the 64-bit variant of xxHash (XXH64) as described at http://cyan4973.github.io/xxHash/. xxhash_amd64.go xxhash_unsafe.go xxhash_amd64.s

Package-Level Type Names (only one, which is exported)

/* sort exporteds by: alphabet | popularity */

type Digest (struct) Digest implements hash.Hash64. Fields (total 7, none are exported) /* 7 unexporteds ... *//* 7 unexporteds: */ mem [32]byte n int // how much of mem is used total uint64 v1 uint64 v2 uint64 v3 uint64 v4 uint64 Methods (total 9, all are exported) (*T) BlockSize() int BlockSize always returns 32 bytes. (*T) MarshalBinary() ([]byte, error) MarshalBinary implements the encoding.BinaryMarshaler interface. (*T) Reset() Reset clears the Digest's state so that it can be reused. (*T) Size() int Size always returns 8 bytes. (*T) Sum(b []byte) []byte Sum appends the current hash to b and returns the resulting slice. (*T) Sum64() uint64 Sum64 returns the current hash. (*T) UnmarshalBinary(b []byte) error UnmarshalBinary implements the encoding.BinaryUnmarshaler interface. (*T) Write(b []byte) (n int, err error) Write adds more data to d. It always returns len(b), nil. (*T) WriteString(s string) (n int, err error) WriteString adds more data to d. It always returns len(s), nil. It may be faster than Write([]byte(s)) by avoiding a copy. Implements (at least 11, in which 8 are exported) *T : github.com/go-git/go-git/v5/plumbing/protocol/packp/sideband.Progress *T : github.com/jbenet/go-context/io.Writer *T : encoding.BinaryMarshaler *T : encoding.BinaryUnmarshaler *T : hash.Hash *T : hash.Hash64 *T : io.StringWriter *T : io.Writer /* 3+ unexporteds ... *//* 3+ unexporteds: */ *T : crypto/hmac.marshalable *T : golang.org/x/net/http2.stringWriter *T : net/http.http2stringWriter As Outputs Of (at least one exported) func New() *Digest As Inputs Of (at least one unexported) /* at least one unexported ... *//* at least one unexported: */ func writeBlocks(d *Digest, b []byte) int

Package-Level Functions (total 18, in which 3 are exported)

func New() *Digest New creates a new Digest that computes the 64-bit xxHash algorithm.

func Sum64(b []byte) uint64 Sum64 computes the 64-bit xxHash digest of b.

func Sum64String(s string) uint64 Sum64String computes the 64-bit xxHash digest of s. It may be faster than Sum64([]byte(s)) by avoiding a copy.

/* 15 unexporteds ... *//* 15 unexporteds: */

func appendUint64(b []byte, x uint64) []byte

func consumeUint64(b []byte) ([]byte, uint64)

func mergeRound(acc, val uint64) uint64

func rol1(x uint64) uint64

func rol11(x uint64) uint64

func rol12(x uint64) uint64

func rol18(x uint64) uint64

func rol23(x uint64) uint64

func rol27(x uint64) uint64

func rol31(x uint64) uint64

func rol7(x uint64) uint64

func round(acc, input uint64) uint64

func u32(b []byte) uint32

func u64(b []byte) uint64

func writeBlocks(d *Digest, b []byte) int

Package-Level Variables (total 5, none are exported) /* 5 unexporteds ... *//* 5 unexporteds: */

var prime1v uint64 NOTE(caleb): I'm using both consts and vars of the primes. Using consts where possible in the Go code is worth a small (but measurable) performance boost by avoiding some MOVQs. Vars are needed for the asm and also are useful for convenience in the Go code in a few places where we need to intentionally avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the result overflows a uint64).

var prime2v uint64 NOTE(caleb): I'm using both consts and vars of the primes. Using consts where possible in the Go code is worth a small (but measurable) performance boost by avoiding some MOVQs. Vars are needed for the asm and also are useful for convenience in the Go code in a few places where we need to intentionally avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the result overflows a uint64).

var prime3v uint64 NOTE(caleb): I'm using both consts and vars of the primes. Using consts where possible in the Go code is worth a small (but measurable) performance boost by avoiding some MOVQs. Vars are needed for the asm and also are useful for convenience in the Go code in a few places where we need to intentionally avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the result overflows a uint64).

var prime4v uint64 NOTE(caleb): I'm using both consts and vars of the primes. Using consts where possible in the Go code is worth a small (but measurable) performance boost by avoiding some MOVQs. Vars are needed for the asm and also are useful for convenience in the Go code in a few places where we need to intentionally avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the result overflows a uint64).

var prime5v uint64 NOTE(caleb): I'm using both consts and vars of the primes. Using consts where possible in the Go code is worth a small (but measurable) performance boost by avoiding some MOVQs. Vars are needed for the asm and also are useful for convenience in the Go code in a few places where we need to intentionally avoid constant arithmetic (e.g., v1 := prime1 + prime2 fails because the result overflows a uint64).

Package-Level Constants (total 7, none are exported) /* 7 unexporteds ... *//* 7 unexporteds: */

const magic = "xxh\x06"

const marshaledSize int = 76

const prime1 uint64 = 11400714785074694791

const prime2 uint64 = 14029467366897019727

const prime3 uint64 = 1609587929392839161

const prime4 uint64 = 9650029242287828579

const prime5 uint64 = 2870177450012600261