fsutil

package
v0.0.0-...-a858404 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jan 23, 2024 License: Apache-2.0, MIT Imports: 17 Imported by: 0

Documentation

Overview

Package fsutil provides utilities for implementing vfs.FileDescriptionImpl and vfs.FilesystemImpl.

Index

Constants

View Source
const (
	// minDegree is the minimum degree of an internal node in a Set B-tree.
	//
	//	- Any non-root node has at least minDegree-1 segments.
	//
	//	- Any non-root internal (non-leaf) node has at least minDegree children.
	//
	//	- The root node may have fewer than minDegree-1 segments, but it may
	// only have 0 segments if the tree is empty.
	//
	// Our implementation requires minDegree >= 3. Higher values of minDegree
	// usually improve performance, but increase memory usage for small sets.
	DirtyminDegree = 3

	DirtymaxDegree = 2 * DirtyminDegree
)
View Source
const (
	// minDegree is the minimum degree of an internal node in a Set B-tree.
	//
	//	- Any non-root node has at least minDegree-1 segments.
	//
	//	- Any non-root internal (non-leaf) node has at least minDegree children.
	//
	//	- The root node may have fewer than minDegree-1 segments, but it may
	// only have 0 segments if the tree is empty.
	//
	// Our implementation requires minDegree >= 3. Higher values of minDegree
	// usually improve performance, but increase memory usage for small sets.
	FileRangeminDegree = 3

	FileRangemaxDegree = 2 * FileRangeminDegree
)
View Source
const (
	// minDegree is the minimum degree of an internal node in a Set B-tree.
	//
	//	- Any non-root node has at least minDegree-1 segments.
	//
	//	- Any non-root internal (non-leaf) node has at least minDegree children.
	//
	//	- The root node may have fewer than minDegree-1 segments, but it may
	// only have 0 segments if the tree is empty.
	//
	// Our implementation requires minDegree >= 3. Higher values of minDegree
	// usually improve performance, but increase memory usage for small sets.
	FrameRefminDegree = 3

	FrameRefmaxDegree = 2 * FrameRefminDegree
)
View Source
const DirtytrackGaps = 0

trackGaps is an optional parameter.

If trackGaps is 1, the Set will track maximum gap size recursively, enabling the GapIterator.{Prev,Next}LargeEnoughGap functions. In this case, Key must be an unsigned integer.

trackGaps must be 0 or 1.

View Source
const FileRangetrackGaps = 0

trackGaps is an optional parameter.

If trackGaps is 1, the Set will track maximum gap size recursively, enabling the GapIterator.{Prev,Next}LargeEnoughGap functions. In this case, Key must be an unsigned integer.

trackGaps must be 0 or 1.

View Source
const FrameReftrackGaps = 0

trackGaps is an optional parameter.

If trackGaps is 1, the Set will track maximum gap size recursively, enabling the GapIterator.{Prev,Next}LargeEnoughGap functions. In this case, Key must be an unsigned integer.

trackGaps must be 0 or 1.

Variables

This section is empty.

Functions

func DirtyzeroNodeSlice

func DirtyzeroNodeSlice(slice []*Dirtynode)

func DirtyzeroValueSlice

func DirtyzeroValueSlice(slice []DirtyInfo)

func FileRangezeroNodeSlice

func FileRangezeroNodeSlice(slice []*FileRangenode)

func FileRangezeroValueSlice

func FileRangezeroValueSlice(slice []uint64)

func FrameRefzeroNodeSlice

func FrameRefzeroNodeSlice(slice []*FrameRefnode)

func FrameRefzeroValueSlice

func FrameRefzeroValueSlice(slice []FrameRefSegInfo)

func SyncDirty

func SyncDirty(ctx context.Context, mr memmap.MappableRange, cache *FileRangeSet, dirty *DirtySet, max uint64, mem memmap.File, writeAt func(ctx context.Context, srcs safemem.BlockSeq, offset uint64) (uint64, error)) error

SyncDirty passes pages in the range mr that are stored in cache and identified as dirty to writeAt, updating dirty to reflect successful writes. If writeAt returns a successful partial write, SyncDirty will call it repeatedly until all bytes have been written. max is the true size of the cached object; offsets beyond max will not be passed to writeAt, even if they are marked dirty.

func SyncDirtyAll

func SyncDirtyAll(ctx context.Context, cache *FileRangeSet, dirty *DirtySet, max uint64, mem memmap.File, writeAt func(ctx context.Context, srcs safemem.BlockSeq, offset uint64) (uint64, error)) error

SyncDirtyAll passes all pages stored in cache identified as dirty to writeAt, updating dirty to reflect successful writes. If writeAt returns a successful partial write, SyncDirtyAll will call it repeatedly until all bytes have been written. max is the true size of the cached object; offsets beyond max will not be passed to writeAt, even if they are marked dirty.

Types

type DirtyGapIterator

type DirtyGapIterator struct {
	// contains filtered or unexported fields
}

A GapIterator is conceptually one of:

  • A pointer to a position between two segments, before the first segment, or after the last segment in a set, called a *gap*; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Note that the gap between two adjacent segments exists (iterators to it are non-terminal), but has a length of zero. GapIterator.IsEmpty returns true for such gaps. An empty set contains a single gap, spanning the entire range of the set's keys.

GapIterators are copyable values and are meaningfully equality-comparable. The zero value of GapIterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func (DirtyGapIterator) End

func (gap DirtyGapIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (DirtyGapIterator) IsEmpty

func (gap DirtyGapIterator) IsEmpty() bool

IsEmpty returns true if the iterated gap is empty (that is, the "gap" is between two adjacent segments.)

func (DirtyGapIterator) NextGap

func (gap DirtyGapIterator) NextGap() DirtyGapIterator

NextGap returns the iterated gap's successor. If no such gap exists, NextGap returns a terminal iterator.

func (DirtyGapIterator) NextLargeEnoughGap

func (gap DirtyGapIterator) NextLargeEnoughGap(minSize uint64) DirtyGapIterator

NextLargeEnoughGap returns the iterated gap's first next gap with larger length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (DirtyGapIterator) NextSegment

func (gap DirtyGapIterator) NextSegment() DirtyIterator

NextSegment returns the segment immediately after the iterated gap. If no such segment exists, NextSegment returns a terminal iterator.

func (DirtyGapIterator) Ok

func (gap DirtyGapIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (DirtyGapIterator) PrevGap

func (gap DirtyGapIterator) PrevGap() DirtyGapIterator

PrevGap returns the iterated gap's predecessor. If no such gap exists, PrevGap returns a terminal iterator.

func (DirtyGapIterator) PrevLargeEnoughGap

func (gap DirtyGapIterator) PrevLargeEnoughGap(minSize uint64) DirtyGapIterator

PrevLargeEnoughGap returns the iterated gap's first prev gap with larger or equal length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (DirtyGapIterator) PrevSegment

func (gap DirtyGapIterator) PrevSegment() DirtyIterator

PrevSegment returns the segment immediately before the iterated gap. If no such segment exists, PrevSegment returns a terminal iterator.

func (DirtyGapIterator) Range

Range returns the range spanned by the iterated gap.

func (DirtyGapIterator) Start

func (gap DirtyGapIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

type DirtyInfo

type DirtyInfo struct {
	// Keep is true if the represented offset is concurrently writable, such
	// that writing the data for that offset back to the source does not
	// guarantee that the offset is clean (since it may be concurrently
	// rewritten after the writeback).
	Keep bool
}

DirtyInfo is the value type of DirtySet, and represents information about a Mappable offset that is dirty (the cached data for that offset is newer than its source).

+stateify savable

func (*DirtyInfo) StateFields

func (d *DirtyInfo) StateFields() []string

func (*DirtyInfo) StateLoad

func (d *DirtyInfo) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*DirtyInfo) StateSave

func (d *DirtyInfo) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*DirtyInfo) StateTypeName

func (d *DirtyInfo) StateTypeName() string

type DirtyIterator

type DirtyIterator struct {
	// contains filtered or unexported fields
}

A Iterator is conceptually one of:

  • A pointer to a segment in a set; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Iterators are copyable values and are meaningfully equality-comparable. The zero value of Iterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func DirtysegmentAfterPosition

func DirtysegmentAfterPosition(n *Dirtynode, i int) DirtyIterator

segmentAfterPosition returns the successor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentAfterPosition returns a terminal iterator.

func DirtysegmentBeforePosition

func DirtysegmentBeforePosition(n *Dirtynode, i int) DirtyIterator

segmentBeforePosition returns the predecessor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentBeforePosition returns a terminal iterator.

func (DirtyIterator) End

func (seg DirtyIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (DirtyIterator) NextGap

func (seg DirtyIterator) NextGap() DirtyGapIterator

NextGap returns the gap immediately after the iterated segment.

func (DirtyIterator) NextNonEmpty

func (seg DirtyIterator) NextNonEmpty() (DirtyIterator, DirtyGapIterator)

NextNonEmpty returns the iterated segment's successor if it is adjacent, or the gap after the iterated segment otherwise. If seg.End() == Functions.MaxKey(), NextNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by NextNonEmpty will be non-terminal.

func (DirtyIterator) NextSegment

func (seg DirtyIterator) NextSegment() DirtyIterator

NextSegment returns the iterated segment's successor. If there is no succeeding segment, NextSegment returns a terminal iterator.

func (DirtyIterator) Ok

func (seg DirtyIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (DirtyIterator) PrevGap

func (seg DirtyIterator) PrevGap() DirtyGapIterator

PrevGap returns the gap immediately before the iterated segment.

func (DirtyIterator) PrevNonEmpty

func (seg DirtyIterator) PrevNonEmpty() (DirtyIterator, DirtyGapIterator)

PrevNonEmpty returns the iterated segment's predecessor if it is adjacent, or the gap before the iterated segment otherwise. If seg.Start() == Functions.MinKey(), PrevNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by PrevNonEmpty will be non-terminal.

func (DirtyIterator) PrevSegment

func (seg DirtyIterator) PrevSegment() DirtyIterator

PrevSegment returns the iterated segment's predecessor. If there is no preceding segment, PrevSegment returns a terminal iterator.

func (DirtyIterator) Range

Range returns the iterated segment's range key.

func (DirtyIterator) SetEnd

func (seg DirtyIterator) SetEnd(end uint64)

SetEnd mutates the iterated segment's end. If the new end value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetEnd panics. This operation does not invalidate any iterators.

func (DirtyIterator) SetEndUnchecked

func (seg DirtyIterator) SetEndUnchecked(end uint64)

SetEndUnchecked mutates the iterated segment's end. This operation does not invalidate any iterators.

Preconditions: The new end must be valid:

  • end > seg.Start().
  • If seg.NextSegment().Ok(), then end <= seg.NextSegment().Start().

func (DirtyIterator) SetRange

SetRange mutates the iterated segment's range key. If the new range would cause the iterated segment to overlap another segment, or if the new range is invalid, SetRange panics. This operation does not invalidate any iterators.

func (DirtyIterator) SetRangeUnchecked

func (seg DirtyIterator) SetRangeUnchecked(r __generics_imported0.MappableRange)

SetRangeUnchecked mutates the iterated segment's range key. This operation does not invalidate any iterators.

Preconditions: - r.Length() > 0. - The new range must not overlap an existing one:

  • If seg.NextSegment().Ok(), then r.end <= seg.NextSegment().Start().
  • If seg.PrevSegment().Ok(), then r.start >= seg.PrevSegment().End().

func (DirtyIterator) SetStart

func (seg DirtyIterator) SetStart(start uint64)

SetStart mutates the iterated segment's start. If the new start value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetStart panics. This operation does not invalidate any iterators.

func (DirtyIterator) SetStartUnchecked

func (seg DirtyIterator) SetStartUnchecked(start uint64)

SetStartUnchecked mutates the iterated segment's start. This operation does not invalidate any iterators.

Preconditions: The new start must be valid:

  • start < seg.End()
  • If seg.PrevSegment().Ok(), then start >= seg.PrevSegment().End().

func (DirtyIterator) SetValue

func (seg DirtyIterator) SetValue(val DirtyInfo)

SetValue mutates the iterated segment's value. This operation does not invalidate any iterators.

func (DirtyIterator) Start

func (seg DirtyIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

func (DirtyIterator) Value

func (seg DirtyIterator) Value() DirtyInfo

Value returns a copy of the iterated segment's value.

func (DirtyIterator) ValuePtr

func (seg DirtyIterator) ValuePtr() *DirtyInfo

ValuePtr returns a pointer to the iterated segment's value. The pointer is invalidated if the iterator is invalidated. This operation does not invalidate any iterators.

type DirtySegmentDataSlices

type DirtySegmentDataSlices struct {
	Start  []uint64
	End    []uint64
	Values []DirtyInfo
}

SegmentDataSlices represents segments from a set as slices of start, end, and values. SegmentDataSlices is primarily used as an intermediate representation for save/restore and the layout here is optimized for that.

+stateify savable

func (*DirtySegmentDataSlices) StateFields

func (d *DirtySegmentDataSlices) StateFields() []string

func (*DirtySegmentDataSlices) StateLoad

func (d *DirtySegmentDataSlices) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*DirtySegmentDataSlices) StateSave

func (d *DirtySegmentDataSlices) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*DirtySegmentDataSlices) StateTypeName

func (d *DirtySegmentDataSlices) StateTypeName() string

type DirtySet

type DirtySet struct {
	// contains filtered or unexported fields
}

A Set is a mapping of segments with non-overlapping Range keys. The zero value for a Set is an empty set. Set values are not safely movable nor copyable. Set is thread-compatible.

+stateify savable

func (*DirtySet) Add

Add inserts the given segment into the set and returns true. If the new segment can be merged with adjacent segments, Add will do so. If the new segment would overlap an existing segment, Add returns false. If Add succeeds, all existing iterators are invalidated.

func (*DirtySet) AddWithoutMerging

func (s *DirtySet) AddWithoutMerging(r __generics_imported0.MappableRange, val DirtyInfo) bool

AddWithoutMerging inserts the given segment into the set and returns true. If it would overlap an existing segment, AddWithoutMerging does nothing and returns false. If AddWithoutMerging succeeds, all existing iterators are invalidated.

func (*DirtySet) AllowClean

func (ds *DirtySet) AllowClean(mr memmap.MappableRange)

AllowClean allows MarkClean to mark offsets in mr as not dirty, ending the effect of a previous call to KeepDirty. (It does not itself mark those offsets as not dirty.)

func (*DirtySet) ApplyContiguous

func (s *DirtySet) ApplyContiguous(r __generics_imported0.MappableRange, fn func(seg DirtyIterator)) DirtyGapIterator

ApplyContiguous applies a function to a contiguous range of segments, splitting if necessary. The function is applied until the first gap is encountered, at which point the gap is returned. If the function is applied across the entire range, a terminal gap is returned. All existing iterators are invalidated.

N.B. The Iterator must not be invalidated by the function.

func (*DirtySet) ExportSortedSlices

func (s *DirtySet) ExportSortedSlices() *DirtySegmentDataSlices

ExportSortedSlices returns a copy of all segments in the given set, in ascending key order.

func (*DirtySet) Find

Find returns the segment or gap whose range contains the given key. If a segment is found, the returned Iterator is non-terminal and the returned GapIterator is terminal. Otherwise, the returned Iterator is terminal and the returned GapIterator is non-terminal.

func (*DirtySet) FindGap

func (s *DirtySet) FindGap(key uint64) DirtyGapIterator

FindGap returns the gap containing the given key. If no such gap exists (i.e. the set contains a segment containing that key), FindGap returns a terminal iterator.

func (*DirtySet) FindSegment

func (s *DirtySet) FindSegment(key uint64) DirtyIterator

FindSegment returns the segment whose range contains the given key. If no such segment exists, FindSegment returns a terminal iterator.

func (*DirtySet) FirstGap

func (s *DirtySet) FirstGap() DirtyGapIterator

FirstGap returns the first gap in the set.

func (*DirtySet) FirstSegment

func (s *DirtySet) FirstSegment() DirtyIterator

FirstSegment returns the first segment in the set. If the set is empty, FirstSegment returns a terminal iterator.

func (*DirtySet) ImportSortedSlices

func (s *DirtySet) ImportSortedSlices(sds *DirtySegmentDataSlices) error

ImportSortedSlices initializes the given set from the given slice.

Preconditions:

  • s must be empty.
  • sds must represent a valid set (the segments in sds must have valid lengths that do not overlap).
  • The segments in sds must be sorted in ascending key order.

func (*DirtySet) Insert

Insert inserts the given segment into the given gap. If the new segment can be merged with adjacent segments, Insert will do so. Insert returns an iterator to the segment containing the inserted value (which may have been merged with other values). All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, Insert panics.

Insert is semantically equivalent to a InsertWithoutMerging followed by a Merge, but may be more efficient. Note that there is no unchecked variant of Insert since Insert must retrieve and inspect gap's predecessor and successor segments regardless.

func (*DirtySet) InsertWithoutMerging

InsertWithoutMerging inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, InsertWithoutMerging panics.

func (*DirtySet) InsertWithoutMergingUnchecked

func (s *DirtySet) InsertWithoutMergingUnchecked(gap DirtyGapIterator, r __generics_imported0.MappableRange, val DirtyInfo) DirtyIterator

InsertWithoutMergingUnchecked inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

Preconditions:

  • r.Start >= gap.Start().
  • r.End <= gap.End().

func (*DirtySet) IsEmpty

func (s *DirtySet) IsEmpty() bool

IsEmpty returns true if the set contains no segments.

func (*DirtySet) IsEmptyRange

func (s *DirtySet) IsEmptyRange(r __generics_imported0.MappableRange) bool

IsEmptyRange returns true iff no segments in the set overlap the given range. This is semantically equivalent to s.SpanRange(r) == 0, but may be more efficient.

func (*DirtySet) Isolate

Isolate ensures that the given segment's range does not escape r by splitting at r.Start and r.End if necessary, and returns an updated iterator to the bounded segment. All existing iterators (including seg, but not including the returned iterators) are invalidated.

func (*DirtySet) KeepClean

func (ds *DirtySet) KeepClean(mr memmap.MappableRange)

KeepClean marks all offsets in mr as not dirty, even those that were previously kept dirty by KeepDirty.

func (*DirtySet) KeepDirty

func (ds *DirtySet) KeepDirty(mr memmap.MappableRange)

KeepDirty marks all offsets in mr as dirty and prevents them from being marked as clean by MarkClean.

func (*DirtySet) LastGap

func (s *DirtySet) LastGap() DirtyGapIterator

LastGap returns the last gap in the set.

func (*DirtySet) LastSegment

func (s *DirtySet) LastSegment() DirtyIterator

LastSegment returns the last segment in the set. If the set is empty, LastSegment returns a terminal iterator.

func (*DirtySet) LowerBoundGap

func (s *DirtySet) LowerBoundGap(min uint64) DirtyGapIterator

LowerBoundGap returns the gap with the lowest range that is greater than or equal to min.

func (*DirtySet) LowerBoundSegment

func (s *DirtySet) LowerBoundSegment(min uint64) DirtyIterator

LowerBoundSegment returns the segment with the lowest range that contains a key greater than or equal to min. If no such segment exists, LowerBoundSegment returns a terminal iterator.

func (*DirtySet) MarkClean

func (ds *DirtySet) MarkClean(mr memmap.MappableRange)

MarkClean marks all offsets in mr as not dirty, except for those to which KeepDirty has been applied.

func (*DirtySet) MarkDirty

func (ds *DirtySet) MarkDirty(mr memmap.MappableRange)

MarkDirty marks all offsets in mr as dirty.

func (*DirtySet) Merge

func (s *DirtySet) Merge(first, second DirtyIterator) DirtyIterator

Merge attempts to merge two neighboring segments. If successful, Merge returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, Merge returns a terminal iterator.

If first is not the predecessor of second, Merge panics.

func (*DirtySet) MergeAdjacent

func (s *DirtySet) MergeAdjacent(r __generics_imported0.MappableRange)

MergeAdjacent attempts to merge the segment containing r.Start with its predecessor, and the segment containing r.End-1 with its successor.

func (*DirtySet) MergeAll

func (s *DirtySet) MergeAll()

MergeAll attempts to merge all adjacent segments in the set. All existing iterators are invalidated.

func (*DirtySet) MergeRange

func (s *DirtySet) MergeRange(r __generics_imported0.MappableRange)

MergeRange attempts to merge all adjacent segments that contain a key in the specific range. All existing iterators are invalidated.

func (*DirtySet) MergeUnchecked

func (s *DirtySet) MergeUnchecked(first, second DirtyIterator) DirtyIterator

MergeUnchecked attempts to merge two neighboring segments. If successful, MergeUnchecked returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, MergeUnchecked returns a terminal iterator.

Precondition: first is the predecessor of second: first.NextSegment() == second, first == second.PrevSegment().

func (*DirtySet) Remove

func (s *DirtySet) Remove(seg DirtyIterator) DirtyGapIterator

Remove removes the given segment and returns an iterator to the vacated gap. All existing iterators (including seg, but not including the returned iterator) are invalidated.

func (*DirtySet) RemoveAll

func (s *DirtySet) RemoveAll()

RemoveAll removes all segments from the set. All existing iterators are invalidated.

func (*DirtySet) RemoveRange

RemoveRange removes all segments in the given range. An iterator to the newly formed gap is returned, and all existing iterators are invalidated.

func (*DirtySet) Span

func (s *DirtySet) Span() uint64

Span returns the total size of all segments in the set.

func (*DirtySet) SpanRange

SpanRange returns the total size of the intersection of segments in the set with the given range.

func (*DirtySet) Split

func (s *DirtySet) Split(seg DirtyIterator, split uint64) (DirtyIterator, DirtyIterator)

Split splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

If the segment cannot be split at split (because split is at the start or end of the segment's range, so splitting would produce a segment with zero length, or because split falls outside the segment's range altogether), Split panics.

func (*DirtySet) SplitAt

func (s *DirtySet) SplitAt(split uint64) bool

SplitAt splits the segment straddling split, if one exists. SplitAt returns true if a segment was split and false otherwise. If SplitAt splits a segment, all existing iterators are invalidated.

func (*DirtySet) SplitUnchecked

func (s *DirtySet) SplitUnchecked(seg DirtyIterator, split uint64) (DirtyIterator, DirtyIterator)

SplitUnchecked splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

Preconditions: seg.Start() < key < seg.End().

func (*DirtySet) StateFields

func (s *DirtySet) StateFields() []string

func (*DirtySet) StateLoad

func (s *DirtySet) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*DirtySet) StateSave

func (s *DirtySet) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*DirtySet) StateTypeName

func (s *DirtySet) StateTypeName() string

func (*DirtySet) String

func (s *DirtySet) String() string

String stringifies a Set for debugging.

func (*DirtySet) UpperBoundGap

func (s *DirtySet) UpperBoundGap(max uint64) DirtyGapIterator

UpperBoundGap returns the gap with the highest range that is less than or equal to max.

func (*DirtySet) UpperBoundSegment

func (s *DirtySet) UpperBoundSegment(max uint64) DirtyIterator

UpperBoundSegment returns the segment with the highest range that contains a key less than or equal to max. If no such segment exists, UpperBoundSegment returns a terminal iterator.

type DirtydynamicGap

type DirtydynamicGap [DirtytrackGaps]uint64

dynamicGap is a type that disappears if trackGaps is 0.

func (*DirtydynamicGap) Get

func (d *DirtydynamicGap) Get() uint64

Get returns the value of the gap.

Precondition: trackGaps must be non-zero.

func (*DirtydynamicGap) Set

func (d *DirtydynamicGap) Set(v uint64)

Set sets the value of the gap.

Precondition: trackGaps must be non-zero.

type Dirtynode

type Dirtynode struct {
	// contains filtered or unexported fields
}

+stateify savable

func (*Dirtynode) StateFields

func (n *Dirtynode) StateFields() []string

func (*Dirtynode) StateLoad

func (n *Dirtynode) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*Dirtynode) StateSave

func (n *Dirtynode) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*Dirtynode) StateTypeName

func (n *Dirtynode) StateTypeName() string

func (*Dirtynode) String

func (n *Dirtynode) String() string

String stringifies a node (and all of its children) for debugging.

type FileRangeGapIterator

type FileRangeGapIterator struct {
	// contains filtered or unexported fields
}

A GapIterator is conceptually one of:

  • A pointer to a position between two segments, before the first segment, or after the last segment in a set, called a *gap*; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Note that the gap between two adjacent segments exists (iterators to it are non-terminal), but has a length of zero. GapIterator.IsEmpty returns true for such gaps. An empty set contains a single gap, spanning the entire range of the set's keys.

GapIterators are copyable values and are meaningfully equality-comparable. The zero value of GapIterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func (FileRangeGapIterator) End

func (gap FileRangeGapIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (FileRangeGapIterator) IsEmpty

func (gap FileRangeGapIterator) IsEmpty() bool

IsEmpty returns true if the iterated gap is empty (that is, the "gap" is between two adjacent segments.)

func (FileRangeGapIterator) NextGap

NextGap returns the iterated gap's successor. If no such gap exists, NextGap returns a terminal iterator.

func (FileRangeGapIterator) NextLargeEnoughGap

func (gap FileRangeGapIterator) NextLargeEnoughGap(minSize uint64) FileRangeGapIterator

NextLargeEnoughGap returns the iterated gap's first next gap with larger length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (FileRangeGapIterator) NextSegment

func (gap FileRangeGapIterator) NextSegment() FileRangeIterator

NextSegment returns the segment immediately after the iterated gap. If no such segment exists, NextSegment returns a terminal iterator.

func (FileRangeGapIterator) Ok

func (gap FileRangeGapIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (FileRangeGapIterator) PrevGap

PrevGap returns the iterated gap's predecessor. If no such gap exists, PrevGap returns a terminal iterator.

func (FileRangeGapIterator) PrevLargeEnoughGap

func (gap FileRangeGapIterator) PrevLargeEnoughGap(minSize uint64) FileRangeGapIterator

PrevLargeEnoughGap returns the iterated gap's first prev gap with larger or equal length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (FileRangeGapIterator) PrevSegment

func (gap FileRangeGapIterator) PrevSegment() FileRangeIterator

PrevSegment returns the segment immediately before the iterated gap. If no such segment exists, PrevSegment returns a terminal iterator.

func (FileRangeGapIterator) Range

Range returns the range spanned by the iterated gap.

func (FileRangeGapIterator) Start

func (gap FileRangeGapIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

type FileRangeIterator

type FileRangeIterator struct {
	// contains filtered or unexported fields
}

A Iterator is conceptually one of:

  • A pointer to a segment in a set; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Iterators are copyable values and are meaningfully equality-comparable. The zero value of Iterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func FileRangesegmentAfterPosition

func FileRangesegmentAfterPosition(n *FileRangenode, i int) FileRangeIterator

segmentAfterPosition returns the successor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentAfterPosition returns a terminal iterator.

func FileRangesegmentBeforePosition

func FileRangesegmentBeforePosition(n *FileRangenode, i int) FileRangeIterator

segmentBeforePosition returns the predecessor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentBeforePosition returns a terminal iterator.

func (FileRangeIterator) End

func (seg FileRangeIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (FileRangeIterator) FileRange

func (seg FileRangeIterator) FileRange() memmap.FileRange

FileRange returns the FileRange mapped by seg.

func (FileRangeIterator) FileRangeOf

FileRangeOf returns the FileRange mapped by mr.

Preconditions:

  • seg.Range().IsSupersetOf(mr).
  • mr.Length() != 0.

func (FileRangeIterator) NextGap

NextGap returns the gap immediately after the iterated segment.

func (FileRangeIterator) NextNonEmpty

NextNonEmpty returns the iterated segment's successor if it is adjacent, or the gap after the iterated segment otherwise. If seg.End() == Functions.MaxKey(), NextNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by NextNonEmpty will be non-terminal.

func (FileRangeIterator) NextSegment

func (seg FileRangeIterator) NextSegment() FileRangeIterator

NextSegment returns the iterated segment's successor. If there is no succeeding segment, NextSegment returns a terminal iterator.

func (FileRangeIterator) Ok

func (seg FileRangeIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (FileRangeIterator) PrevGap

PrevGap returns the gap immediately before the iterated segment.

func (FileRangeIterator) PrevNonEmpty

PrevNonEmpty returns the iterated segment's predecessor if it is adjacent, or the gap before the iterated segment otherwise. If seg.Start() == Functions.MinKey(), PrevNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by PrevNonEmpty will be non-terminal.

func (FileRangeIterator) PrevSegment

func (seg FileRangeIterator) PrevSegment() FileRangeIterator

PrevSegment returns the iterated segment's predecessor. If there is no preceding segment, PrevSegment returns a terminal iterator.

func (FileRangeIterator) Range

Range returns the iterated segment's range key.

func (FileRangeIterator) SetEnd

func (seg FileRangeIterator) SetEnd(end uint64)

SetEnd mutates the iterated segment's end. If the new end value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetEnd panics. This operation does not invalidate any iterators.

func (FileRangeIterator) SetEndUnchecked

func (seg FileRangeIterator) SetEndUnchecked(end uint64)

SetEndUnchecked mutates the iterated segment's end. This operation does not invalidate any iterators.

Preconditions: The new end must be valid:

  • end > seg.Start().
  • If seg.NextSegment().Ok(), then end <= seg.NextSegment().Start().

func (FileRangeIterator) SetRange

SetRange mutates the iterated segment's range key. If the new range would cause the iterated segment to overlap another segment, or if the new range is invalid, SetRange panics. This operation does not invalidate any iterators.

func (FileRangeIterator) SetRangeUnchecked

func (seg FileRangeIterator) SetRangeUnchecked(r __generics_imported0.MappableRange)

SetRangeUnchecked mutates the iterated segment's range key. This operation does not invalidate any iterators.

Preconditions: - r.Length() > 0. - The new range must not overlap an existing one:

  • If seg.NextSegment().Ok(), then r.end <= seg.NextSegment().Start().
  • If seg.PrevSegment().Ok(), then r.start >= seg.PrevSegment().End().

func (FileRangeIterator) SetStart

func (seg FileRangeIterator) SetStart(start uint64)

SetStart mutates the iterated segment's start. If the new start value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetStart panics. This operation does not invalidate any iterators.

func (FileRangeIterator) SetStartUnchecked

func (seg FileRangeIterator) SetStartUnchecked(start uint64)

SetStartUnchecked mutates the iterated segment's start. This operation does not invalidate any iterators.

Preconditions: The new start must be valid:

  • start < seg.End()
  • If seg.PrevSegment().Ok(), then start >= seg.PrevSegment().End().

func (FileRangeIterator) SetValue

func (seg FileRangeIterator) SetValue(val uint64)

SetValue mutates the iterated segment's value. This operation does not invalidate any iterators.

func (FileRangeIterator) Start

func (seg FileRangeIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

func (FileRangeIterator) Value

func (seg FileRangeIterator) Value() uint64

Value returns a copy of the iterated segment's value.

func (FileRangeIterator) ValuePtr

func (seg FileRangeIterator) ValuePtr() *uint64

ValuePtr returns a pointer to the iterated segment's value. The pointer is invalidated if the iterator is invalidated. This operation does not invalidate any iterators.

type FileRangeSegmentDataSlices

type FileRangeSegmentDataSlices struct {
	Start  []uint64
	End    []uint64
	Values []uint64
}

SegmentDataSlices represents segments from a set as slices of start, end, and values. SegmentDataSlices is primarily used as an intermediate representation for save/restore and the layout here is optimized for that.

+stateify savable

func (*FileRangeSegmentDataSlices) StateFields

func (f *FileRangeSegmentDataSlices) StateFields() []string

func (*FileRangeSegmentDataSlices) StateLoad

func (f *FileRangeSegmentDataSlices) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FileRangeSegmentDataSlices) StateSave

func (f *FileRangeSegmentDataSlices) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FileRangeSegmentDataSlices) StateTypeName

func (f *FileRangeSegmentDataSlices) StateTypeName() string

type FileRangeSet

type FileRangeSet struct {
	// contains filtered or unexported fields
}

A Set is a mapping of segments with non-overlapping Range keys. The zero value for a Set is an empty set. Set values are not safely movable nor copyable. Set is thread-compatible.

+stateify savable

func (*FileRangeSet) Add

Add inserts the given segment into the set and returns true. If the new segment can be merged with adjacent segments, Add will do so. If the new segment would overlap an existing segment, Add returns false. If Add succeeds, all existing iterators are invalidated.

func (*FileRangeSet) AddWithoutMerging

func (s *FileRangeSet) AddWithoutMerging(r __generics_imported0.MappableRange, val uint64) bool

AddWithoutMerging inserts the given segment into the set and returns true. If it would overlap an existing segment, AddWithoutMerging does nothing and returns false. If AddWithoutMerging succeeds, all existing iterators are invalidated.

func (*FileRangeSet) ApplyContiguous

ApplyContiguous applies a function to a contiguous range of segments, splitting if necessary. The function is applied until the first gap is encountered, at which point the gap is returned. If the function is applied across the entire range, a terminal gap is returned. All existing iterators are invalidated.

N.B. The Iterator must not be invalidated by the function.

func (*FileRangeSet) Drop

func (frs *FileRangeSet) Drop(mr memmap.MappableRange, mf *pgalloc.MemoryFile)

Drop removes segments for memmap.Mappable offsets in mr, freeing the corresponding memmap.FileRanges.

Preconditions: mr must be page-aligned.

func (*FileRangeSet) DropAll

func (frs *FileRangeSet) DropAll(mf *pgalloc.MemoryFile) uint64

DropAll removes all segments in mr, freeing the corresponding memmap.FileRanges. It returns the number of pages freed.

func (*FileRangeSet) ExportSortedSlices

func (s *FileRangeSet) ExportSortedSlices() *FileRangeSegmentDataSlices

ExportSortedSlices returns a copy of all segments in the given set, in ascending key order.

func (*FileRangeSet) Fill

func (frs *FileRangeSet) Fill(ctx context.Context, required, optional memmap.MappableRange, fileSize uint64, mf *pgalloc.MemoryFile, kind usage.MemoryKind, allocMode pgalloc.AllocationMode, readAt func(ctx context.Context, dsts safemem.BlockSeq, offset uint64) (uint64, error)) (uint64, error)

Fill attempts to ensure that all memmap.Mappable offsets in required are mapped to a memmap.File offset, by allocating from mf with the given memory usage kind and invoking readAt to store data into memory. (If readAt returns a successful partial read, Fill will call it repeatedly until all bytes have been read.) EOF is handled consistently with the requirements of mmap(2): bytes after EOF on the same page are zeroed; pages after EOF are invalid. fileSize is an upper bound on the file's size; bytes after fileSize will be zeroed without calling readAt. populate has the same meaning as the pgalloc.MemoryFile.AllocateAndFill() argument of the same name.

Fill may read offsets outside of required, but will never read offsets outside of optional. It returns a non-nil error if any error occurs, even if the error only affects offsets in optional, but not in required.

Fill returns the number of pages that were allocated.

Preconditions:

  • required.Length() > 0.
  • optional.IsSupersetOf(required).
  • required and optional must be page-aligned.

func (*FileRangeSet) Find

Find returns the segment or gap whose range contains the given key. If a segment is found, the returned Iterator is non-terminal and the returned GapIterator is terminal. Otherwise, the returned Iterator is terminal and the returned GapIterator is non-terminal.

func (*FileRangeSet) FindGap

func (s *FileRangeSet) FindGap(key uint64) FileRangeGapIterator

FindGap returns the gap containing the given key. If no such gap exists (i.e. the set contains a segment containing that key), FindGap returns a terminal iterator.

func (*FileRangeSet) FindSegment

func (s *FileRangeSet) FindSegment(key uint64) FileRangeIterator

FindSegment returns the segment whose range contains the given key. If no such segment exists, FindSegment returns a terminal iterator.

func (*FileRangeSet) FirstGap

func (s *FileRangeSet) FirstGap() FileRangeGapIterator

FirstGap returns the first gap in the set.

func (*FileRangeSet) FirstSegment

func (s *FileRangeSet) FirstSegment() FileRangeIterator

FirstSegment returns the first segment in the set. If the set is empty, FirstSegment returns a terminal iterator.

func (*FileRangeSet) ImportSortedSlices

func (s *FileRangeSet) ImportSortedSlices(sds *FileRangeSegmentDataSlices) error

ImportSortedSlices initializes the given set from the given slice.

Preconditions:

  • s must be empty.
  • sds must represent a valid set (the segments in sds must have valid lengths that do not overlap).
  • The segments in sds must be sorted in ascending key order.

func (*FileRangeSet) Insert

Insert inserts the given segment into the given gap. If the new segment can be merged with adjacent segments, Insert will do so. Insert returns an iterator to the segment containing the inserted value (which may have been merged with other values). All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, Insert panics.

Insert is semantically equivalent to a InsertWithoutMerging followed by a Merge, but may be more efficient. Note that there is no unchecked variant of Insert since Insert must retrieve and inspect gap's predecessor and successor segments regardless.

func (*FileRangeSet) InsertWithoutMerging

InsertWithoutMerging inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, InsertWithoutMerging panics.

func (*FileRangeSet) InsertWithoutMergingUnchecked

func (s *FileRangeSet) InsertWithoutMergingUnchecked(gap FileRangeGapIterator, r __generics_imported0.MappableRange, val uint64) FileRangeIterator

InsertWithoutMergingUnchecked inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

Preconditions:

  • r.Start >= gap.Start().
  • r.End <= gap.End().

func (*FileRangeSet) IsEmpty

func (s *FileRangeSet) IsEmpty() bool

IsEmpty returns true if the set contains no segments.

func (*FileRangeSet) IsEmptyRange

IsEmptyRange returns true iff no segments in the set overlap the given range. This is semantically equivalent to s.SpanRange(r) == 0, but may be more efficient.

func (*FileRangeSet) Isolate

Isolate ensures that the given segment's range does not escape r by splitting at r.Start and r.End if necessary, and returns an updated iterator to the bounded segment. All existing iterators (including seg, but not including the returned iterators) are invalidated.

func (*FileRangeSet) LastGap

func (s *FileRangeSet) LastGap() FileRangeGapIterator

LastGap returns the last gap in the set.

func (*FileRangeSet) LastSegment

func (s *FileRangeSet) LastSegment() FileRangeIterator

LastSegment returns the last segment in the set. If the set is empty, LastSegment returns a terminal iterator.

func (*FileRangeSet) LowerBoundGap

func (s *FileRangeSet) LowerBoundGap(min uint64) FileRangeGapIterator

LowerBoundGap returns the gap with the lowest range that is greater than or equal to min.

func (*FileRangeSet) LowerBoundSegment

func (s *FileRangeSet) LowerBoundSegment(min uint64) FileRangeIterator

LowerBoundSegment returns the segment with the lowest range that contains a key greater than or equal to min. If no such segment exists, LowerBoundSegment returns a terminal iterator.

func (*FileRangeSet) Merge

func (s *FileRangeSet) Merge(first, second FileRangeIterator) FileRangeIterator

Merge attempts to merge two neighboring segments. If successful, Merge returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, Merge returns a terminal iterator.

If first is not the predecessor of second, Merge panics.

func (*FileRangeSet) MergeAdjacent

func (s *FileRangeSet) MergeAdjacent(r __generics_imported0.MappableRange)

MergeAdjacent attempts to merge the segment containing r.Start with its predecessor, and the segment containing r.End-1 with its successor.

func (*FileRangeSet) MergeAll

func (s *FileRangeSet) MergeAll()

MergeAll attempts to merge all adjacent segments in the set. All existing iterators are invalidated.

func (*FileRangeSet) MergeRange

MergeRange attempts to merge all adjacent segments that contain a key in the specific range. All existing iterators are invalidated.

func (*FileRangeSet) MergeUnchecked

func (s *FileRangeSet) MergeUnchecked(first, second FileRangeIterator) FileRangeIterator

MergeUnchecked attempts to merge two neighboring segments. If successful, MergeUnchecked returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, MergeUnchecked returns a terminal iterator.

Precondition: first is the predecessor of second: first.NextSegment() == second, first == second.PrevSegment().

func (*FileRangeSet) PagesToFill

func (frs *FileRangeSet) PagesToFill(required, optional memmap.MappableRange) uint64

PagesToFill returns the number of pages that that Fill() will allocate for the given required and optional parameters.

func (*FileRangeSet) Remove

Remove removes the given segment and returns an iterator to the vacated gap. All existing iterators (including seg, but not including the returned iterator) are invalidated.

func (*FileRangeSet) RemoveAll

func (s *FileRangeSet) RemoveAll()

RemoveAll removes all segments from the set. All existing iterators are invalidated.

func (*FileRangeSet) RemoveRange

RemoveRange removes all segments in the given range. An iterator to the newly formed gap is returned, and all existing iterators are invalidated.

func (*FileRangeSet) Span

func (s *FileRangeSet) Span() uint64

Span returns the total size of all segments in the set.

func (*FileRangeSet) SpanRange

SpanRange returns the total size of the intersection of segments in the set with the given range.

func (*FileRangeSet) Split

Split splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

If the segment cannot be split at split (because split is at the start or end of the segment's range, so splitting would produce a segment with zero length, or because split falls outside the segment's range altogether), Split panics.

func (*FileRangeSet) SplitAt

func (s *FileRangeSet) SplitAt(split uint64) bool

SplitAt splits the segment straddling split, if one exists. SplitAt returns true if a segment was split and false otherwise. If SplitAt splits a segment, all existing iterators are invalidated.

func (*FileRangeSet) SplitUnchecked

func (s *FileRangeSet) SplitUnchecked(seg FileRangeIterator, split uint64) (FileRangeIterator, FileRangeIterator)

SplitUnchecked splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

Preconditions: seg.Start() < key < seg.End().

func (*FileRangeSet) StateFields

func (s *FileRangeSet) StateFields() []string

func (*FileRangeSet) StateLoad

func (s *FileRangeSet) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FileRangeSet) StateSave

func (s *FileRangeSet) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FileRangeSet) StateTypeName

func (s *FileRangeSet) StateTypeName() string

func (*FileRangeSet) String

func (s *FileRangeSet) String() string

String stringifies a Set for debugging.

func (*FileRangeSet) Truncate

func (frs *FileRangeSet) Truncate(end uint64, mf *pgalloc.MemoryFile) uint64

Truncate updates frs to reflect Mappable truncation to the given length: bytes after the new EOF on the same page are zeroed, and pages after the new EOF are freed. It returns the number of pages freed.

func (*FileRangeSet) UpperBoundGap

func (s *FileRangeSet) UpperBoundGap(max uint64) FileRangeGapIterator

UpperBoundGap returns the gap with the highest range that is less than or equal to max.

func (*FileRangeSet) UpperBoundSegment

func (s *FileRangeSet) UpperBoundSegment(max uint64) FileRangeIterator

UpperBoundSegment returns the segment with the highest range that contains a key less than or equal to max. If no such segment exists, UpperBoundSegment returns a terminal iterator.

type FileRangeSetFunctions

type FileRangeSetFunctions struct{}

FileRangeSetFunctions implements segment.Functions for FileRangeSet.

func (FileRangeSetFunctions) ClearValue

func (FileRangeSetFunctions) ClearValue(_ *uint64)

ClearValue implements segment.Functions.ClearValue.

func (FileRangeSetFunctions) MaxKey

func (FileRangeSetFunctions) MaxKey() uint64

MaxKey implements segment.Functions.MaxKey.

func (FileRangeSetFunctions) Merge

func (FileRangeSetFunctions) Merge(mr1 memmap.MappableRange, frstart1 uint64, _ memmap.MappableRange, frstart2 uint64) (uint64, bool)

Merge implements segment.Functions.Merge.

func (FileRangeSetFunctions) MinKey

func (FileRangeSetFunctions) MinKey() uint64

MinKey implements segment.Functions.MinKey.

func (FileRangeSetFunctions) Split

func (FileRangeSetFunctions) Split(mr memmap.MappableRange, frstart uint64, split uint64) (uint64, uint64)

Split implements segment.Functions.Split.

type FileRangedynamicGap

type FileRangedynamicGap [FileRangetrackGaps]uint64

dynamicGap is a type that disappears if trackGaps is 0.

func (*FileRangedynamicGap) Get

func (d *FileRangedynamicGap) Get() uint64

Get returns the value of the gap.

Precondition: trackGaps must be non-zero.

func (*FileRangedynamicGap) Set

func (d *FileRangedynamicGap) Set(v uint64)

Set sets the value of the gap.

Precondition: trackGaps must be non-zero.

type FileRangenode

type FileRangenode struct {
	// contains filtered or unexported fields
}

+stateify savable

func (*FileRangenode) StateFields

func (n *FileRangenode) StateFields() []string

func (*FileRangenode) StateLoad

func (n *FileRangenode) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FileRangenode) StateSave

func (n *FileRangenode) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FileRangenode) StateTypeName

func (n *FileRangenode) StateTypeName() string

func (*FileRangenode) String

func (n *FileRangenode) String() string

String stringifies a node (and all of its children) for debugging.

type FrameRefGapIterator

type FrameRefGapIterator struct {
	// contains filtered or unexported fields
}

A GapIterator is conceptually one of:

  • A pointer to a position between two segments, before the first segment, or after the last segment in a set, called a *gap*; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Note that the gap between two adjacent segments exists (iterators to it are non-terminal), but has a length of zero. GapIterator.IsEmpty returns true for such gaps. An empty set contains a single gap, spanning the entire range of the set's keys.

GapIterators are copyable values and are meaningfully equality-comparable. The zero value of GapIterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func (FrameRefGapIterator) End

func (gap FrameRefGapIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (FrameRefGapIterator) IsEmpty

func (gap FrameRefGapIterator) IsEmpty() bool

IsEmpty returns true if the iterated gap is empty (that is, the "gap" is between two adjacent segments.)

func (FrameRefGapIterator) NextGap

NextGap returns the iterated gap's successor. If no such gap exists, NextGap returns a terminal iterator.

func (FrameRefGapIterator) NextLargeEnoughGap

func (gap FrameRefGapIterator) NextLargeEnoughGap(minSize uint64) FrameRefGapIterator

NextLargeEnoughGap returns the iterated gap's first next gap with larger length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (FrameRefGapIterator) NextSegment

func (gap FrameRefGapIterator) NextSegment() FrameRefIterator

NextSegment returns the segment immediately after the iterated gap. If no such segment exists, NextSegment returns a terminal iterator.

func (FrameRefGapIterator) Ok

func (gap FrameRefGapIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (FrameRefGapIterator) PrevGap

PrevGap returns the iterated gap's predecessor. If no such gap exists, PrevGap returns a terminal iterator.

func (FrameRefGapIterator) PrevLargeEnoughGap

func (gap FrameRefGapIterator) PrevLargeEnoughGap(minSize uint64) FrameRefGapIterator

PrevLargeEnoughGap returns the iterated gap's first prev gap with larger or equal length than minSize. If not found, return a terminal gap iterator (does NOT include this gap itself).

Precondition: trackGaps must be 1.

func (FrameRefGapIterator) PrevSegment

func (gap FrameRefGapIterator) PrevSegment() FrameRefIterator

PrevSegment returns the segment immediately before the iterated gap. If no such segment exists, PrevSegment returns a terminal iterator.

func (FrameRefGapIterator) Range

Range returns the range spanned by the iterated gap.

func (FrameRefGapIterator) Start

func (gap FrameRefGapIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

type FrameRefIterator

type FrameRefIterator struct {
	// contains filtered or unexported fields
}

A Iterator is conceptually one of:

  • A pointer to a segment in a set; or

  • A terminal iterator, which is a sentinel indicating that the end of iteration has been reached.

Iterators are copyable values and are meaningfully equality-comparable. The zero value of Iterator is a terminal iterator.

Unless otherwise specified, any mutation of a set invalidates all existing iterators into the set.

func FrameRefsegmentAfterPosition

func FrameRefsegmentAfterPosition(n *FrameRefnode, i int) FrameRefIterator

segmentAfterPosition returns the successor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentAfterPosition returns a terminal iterator.

func FrameRefsegmentBeforePosition

func FrameRefsegmentBeforePosition(n *FrameRefnode, i int) FrameRefIterator

segmentBeforePosition returns the predecessor segment of the position given by n.children[i], which may or may not contain a child. If no such segment exists, segmentBeforePosition returns a terminal iterator.

func (FrameRefIterator) End

func (seg FrameRefIterator) End() uint64

End is equivalent to Range().End, but should be preferred if only the end of the range is needed.

func (FrameRefIterator) NextGap

func (seg FrameRefIterator) NextGap() FrameRefGapIterator

NextGap returns the gap immediately after the iterated segment.

func (FrameRefIterator) NextNonEmpty

NextNonEmpty returns the iterated segment's successor if it is adjacent, or the gap after the iterated segment otherwise. If seg.End() == Functions.MaxKey(), NextNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by NextNonEmpty will be non-terminal.

func (FrameRefIterator) NextSegment

func (seg FrameRefIterator) NextSegment() FrameRefIterator

NextSegment returns the iterated segment's successor. If there is no succeeding segment, NextSegment returns a terminal iterator.

func (FrameRefIterator) Ok

func (seg FrameRefIterator) Ok() bool

Ok returns true if the iterator is not terminal. All other methods are only valid for non-terminal iterators.

func (FrameRefIterator) PrevGap

func (seg FrameRefIterator) PrevGap() FrameRefGapIterator

PrevGap returns the gap immediately before the iterated segment.

func (FrameRefIterator) PrevNonEmpty

PrevNonEmpty returns the iterated segment's predecessor if it is adjacent, or the gap before the iterated segment otherwise. If seg.Start() == Functions.MinKey(), PrevNonEmpty will return two terminal iterators. Otherwise, exactly one of the iterators returned by PrevNonEmpty will be non-terminal.

func (FrameRefIterator) PrevSegment

func (seg FrameRefIterator) PrevSegment() FrameRefIterator

PrevSegment returns the iterated segment's predecessor. If there is no preceding segment, PrevSegment returns a terminal iterator.

func (FrameRefIterator) Range

Range returns the iterated segment's range key.

func (FrameRefIterator) SetEnd

func (seg FrameRefIterator) SetEnd(end uint64)

SetEnd mutates the iterated segment's end. If the new end value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetEnd panics. This operation does not invalidate any iterators.

func (FrameRefIterator) SetEndUnchecked

func (seg FrameRefIterator) SetEndUnchecked(end uint64)

SetEndUnchecked mutates the iterated segment's end. This operation does not invalidate any iterators.

Preconditions: The new end must be valid:

  • end > seg.Start().
  • If seg.NextSegment().Ok(), then end <= seg.NextSegment().Start().

func (FrameRefIterator) SetRange

SetRange mutates the iterated segment's range key. If the new range would cause the iterated segment to overlap another segment, or if the new range is invalid, SetRange panics. This operation does not invalidate any iterators.

func (FrameRefIterator) SetRangeUnchecked

func (seg FrameRefIterator) SetRangeUnchecked(r __generics_imported0.FileRange)

SetRangeUnchecked mutates the iterated segment's range key. This operation does not invalidate any iterators.

Preconditions: - r.Length() > 0. - The new range must not overlap an existing one:

  • If seg.NextSegment().Ok(), then r.end <= seg.NextSegment().Start().
  • If seg.PrevSegment().Ok(), then r.start >= seg.PrevSegment().End().

func (FrameRefIterator) SetStart

func (seg FrameRefIterator) SetStart(start uint64)

SetStart mutates the iterated segment's start. If the new start value would cause the iterated segment to overlap another segment, or would result in an invalid range, SetStart panics. This operation does not invalidate any iterators.

func (FrameRefIterator) SetStartUnchecked

func (seg FrameRefIterator) SetStartUnchecked(start uint64)

SetStartUnchecked mutates the iterated segment's start. This operation does not invalidate any iterators.

Preconditions: The new start must be valid:

  • start < seg.End()
  • If seg.PrevSegment().Ok(), then start >= seg.PrevSegment().End().

func (FrameRefIterator) SetValue

func (seg FrameRefIterator) SetValue(val FrameRefSegInfo)

SetValue mutates the iterated segment's value. This operation does not invalidate any iterators.

func (FrameRefIterator) Start

func (seg FrameRefIterator) Start() uint64

Start is equivalent to Range().Start, but should be preferred if only the start of the range is needed.

func (FrameRefIterator) Value

func (seg FrameRefIterator) Value() FrameRefSegInfo

Value returns a copy of the iterated segment's value.

func (FrameRefIterator) ValuePtr

func (seg FrameRefIterator) ValuePtr() *FrameRefSegInfo

ValuePtr returns a pointer to the iterated segment's value. The pointer is invalidated if the iterator is invalidated. This operation does not invalidate any iterators.

type FrameRefSegInfo

type FrameRefSegInfo struct {
	// contains filtered or unexported fields
}

FrameRefSegInfo holds reference count and memory cgroup id of the segment.

type FrameRefSegmentDataSlices

type FrameRefSegmentDataSlices struct {
	Start  []uint64
	End    []uint64
	Values []FrameRefSegInfo
}

SegmentDataSlices represents segments from a set as slices of start, end, and values. SegmentDataSlices is primarily used as an intermediate representation for save/restore and the layout here is optimized for that.

+stateify savable

func (*FrameRefSegmentDataSlices) StateFields

func (f *FrameRefSegmentDataSlices) StateFields() []string

func (*FrameRefSegmentDataSlices) StateLoad

func (f *FrameRefSegmentDataSlices) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FrameRefSegmentDataSlices) StateSave

func (f *FrameRefSegmentDataSlices) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FrameRefSegmentDataSlices) StateTypeName

func (f *FrameRefSegmentDataSlices) StateTypeName() string

type FrameRefSet

type FrameRefSet struct {
	// contains filtered or unexported fields
}

A Set is a mapping of segments with non-overlapping Range keys. The zero value for a Set is an empty set. Set values are not safely movable nor copyable. Set is thread-compatible.

+stateify savable

func (*FrameRefSet) Add

Add inserts the given segment into the set and returns true. If the new segment can be merged with adjacent segments, Add will do so. If the new segment would overlap an existing segment, Add returns false. If Add succeeds, all existing iterators are invalidated.

func (*FrameRefSet) AddWithoutMerging

func (s *FrameRefSet) AddWithoutMerging(r __generics_imported0.FileRange, val FrameRefSegInfo) bool

AddWithoutMerging inserts the given segment into the set and returns true. If it would overlap an existing segment, AddWithoutMerging does nothing and returns false. If AddWithoutMerging succeeds, all existing iterators are invalidated.

func (*FrameRefSet) ApplyContiguous

ApplyContiguous applies a function to a contiguous range of segments, splitting if necessary. The function is applied until the first gap is encountered, at which point the gap is returned. If the function is applied across the entire range, a terminal gap is returned. All existing iterators are invalidated.

N.B. The Iterator must not be invalidated by the function.

func (*FrameRefSet) DecRefAndAccount

func (frSet *FrameRefSet) DecRefAndAccount(fr memmap.FileRange)

DecRefAndAccount removes a reference on the range fr and untracks segments that are removed from memory accounting.

func (*FrameRefSet) ExportSortedSlices

func (s *FrameRefSet) ExportSortedSlices() *FrameRefSegmentDataSlices

ExportSortedSlices returns a copy of all segments in the given set, in ascending key order.

func (*FrameRefSet) Find

Find returns the segment or gap whose range contains the given key. If a segment is found, the returned Iterator is non-terminal and the returned GapIterator is terminal. Otherwise, the returned Iterator is terminal and the returned GapIterator is non-terminal.

func (*FrameRefSet) FindGap

func (s *FrameRefSet) FindGap(key uint64) FrameRefGapIterator

FindGap returns the gap containing the given key. If no such gap exists (i.e. the set contains a segment containing that key), FindGap returns a terminal iterator.

func (*FrameRefSet) FindSegment

func (s *FrameRefSet) FindSegment(key uint64) FrameRefIterator

FindSegment returns the segment whose range contains the given key. If no such segment exists, FindSegment returns a terminal iterator.

func (*FrameRefSet) FirstGap

func (s *FrameRefSet) FirstGap() FrameRefGapIterator

FirstGap returns the first gap in the set.

func (*FrameRefSet) FirstSegment

func (s *FrameRefSet) FirstSegment() FrameRefIterator

FirstSegment returns the first segment in the set. If the set is empty, FirstSegment returns a terminal iterator.

func (*FrameRefSet) ImportSortedSlices

func (s *FrameRefSet) ImportSortedSlices(sds *FrameRefSegmentDataSlices) error

ImportSortedSlices initializes the given set from the given slice.

Preconditions:

  • s must be empty.
  • sds must represent a valid set (the segments in sds must have valid lengths that do not overlap).
  • The segments in sds must be sorted in ascending key order.

func (*FrameRefSet) IncRefAndAccount

func (frSet *FrameRefSet) IncRefAndAccount(fr memmap.FileRange, memCgID uint32)

IncRefAndAccount adds a reference on the range fr. All newly inserted segments are accounted as host page cache memory mappings. The new segments will be associated with the memCgID, if the segment already exists then the memCgID will not be changed.

func (*FrameRefSet) Insert

Insert inserts the given segment into the given gap. If the new segment can be merged with adjacent segments, Insert will do so. Insert returns an iterator to the segment containing the inserted value (which may have been merged with other values). All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, Insert panics.

Insert is semantically equivalent to a InsertWithoutMerging followed by a Merge, but may be more efficient. Note that there is no unchecked variant of Insert since Insert must retrieve and inspect gap's predecessor and successor segments regardless.

func (*FrameRefSet) InsertWithoutMerging

InsertWithoutMerging inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

If the gap cannot accommodate the segment, or if r is invalid, InsertWithoutMerging panics.

func (*FrameRefSet) InsertWithoutMergingUnchecked

func (s *FrameRefSet) InsertWithoutMergingUnchecked(gap FrameRefGapIterator, r __generics_imported0.FileRange, val FrameRefSegInfo) FrameRefIterator

InsertWithoutMergingUnchecked inserts the given segment into the given gap and returns an iterator to the inserted segment. All existing iterators (including gap, but not including the returned iterator) are invalidated.

Preconditions:

  • r.Start >= gap.Start().
  • r.End <= gap.End().

func (*FrameRefSet) IsEmpty

func (s *FrameRefSet) IsEmpty() bool

IsEmpty returns true if the set contains no segments.

func (*FrameRefSet) IsEmptyRange

func (s *FrameRefSet) IsEmptyRange(r __generics_imported0.FileRange) bool

IsEmptyRange returns true iff no segments in the set overlap the given range. This is semantically equivalent to s.SpanRange(r) == 0, but may be more efficient.

func (*FrameRefSet) Isolate

Isolate ensures that the given segment's range does not escape r by splitting at r.Start and r.End if necessary, and returns an updated iterator to the bounded segment. All existing iterators (including seg, but not including the returned iterators) are invalidated.

func (*FrameRefSet) LastGap

func (s *FrameRefSet) LastGap() FrameRefGapIterator

LastGap returns the last gap in the set.

func (*FrameRefSet) LastSegment

func (s *FrameRefSet) LastSegment() FrameRefIterator

LastSegment returns the last segment in the set. If the set is empty, LastSegment returns a terminal iterator.

func (*FrameRefSet) LowerBoundGap

func (s *FrameRefSet) LowerBoundGap(min uint64) FrameRefGapIterator

LowerBoundGap returns the gap with the lowest range that is greater than or equal to min.

func (*FrameRefSet) LowerBoundSegment

func (s *FrameRefSet) LowerBoundSegment(min uint64) FrameRefIterator

LowerBoundSegment returns the segment with the lowest range that contains a key greater than or equal to min. If no such segment exists, LowerBoundSegment returns a terminal iterator.

func (*FrameRefSet) Merge

func (s *FrameRefSet) Merge(first, second FrameRefIterator) FrameRefIterator

Merge attempts to merge two neighboring segments. If successful, Merge returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, Merge returns a terminal iterator.

If first is not the predecessor of second, Merge panics.

func (*FrameRefSet) MergeAdjacent

func (s *FrameRefSet) MergeAdjacent(r __generics_imported0.FileRange)

MergeAdjacent attempts to merge the segment containing r.Start with its predecessor, and the segment containing r.End-1 with its successor.

func (*FrameRefSet) MergeAll

func (s *FrameRefSet) MergeAll()

MergeAll attempts to merge all adjacent segments in the set. All existing iterators are invalidated.

func (*FrameRefSet) MergeRange

func (s *FrameRefSet) MergeRange(r __generics_imported0.FileRange)

MergeRange attempts to merge all adjacent segments that contain a key in the specific range. All existing iterators are invalidated.

func (*FrameRefSet) MergeUnchecked

func (s *FrameRefSet) MergeUnchecked(first, second FrameRefIterator) FrameRefIterator

MergeUnchecked attempts to merge two neighboring segments. If successful, MergeUnchecked returns an iterator to the merged segment, and all existing iterators are invalidated. Otherwise, MergeUnchecked returns a terminal iterator.

Precondition: first is the predecessor of second: first.NextSegment() == second, first == second.PrevSegment().

func (*FrameRefSet) Remove

Remove removes the given segment and returns an iterator to the vacated gap. All existing iterators (including seg, but not including the returned iterator) are invalidated.

func (*FrameRefSet) RemoveAll

func (s *FrameRefSet) RemoveAll()

RemoveAll removes all segments from the set. All existing iterators are invalidated.

func (*FrameRefSet) RemoveRange

RemoveRange removes all segments in the given range. An iterator to the newly formed gap is returned, and all existing iterators are invalidated.

func (*FrameRefSet) Span

func (s *FrameRefSet) Span() uint64

Span returns the total size of all segments in the set.

func (*FrameRefSet) SpanRange

SpanRange returns the total size of the intersection of segments in the set with the given range.

func (*FrameRefSet) Split

Split splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

If the segment cannot be split at split (because split is at the start or end of the segment's range, so splitting would produce a segment with zero length, or because split falls outside the segment's range altogether), Split panics.

func (*FrameRefSet) SplitAt

func (s *FrameRefSet) SplitAt(split uint64) bool

SplitAt splits the segment straddling split, if one exists. SplitAt returns true if a segment was split and false otherwise. If SplitAt splits a segment, all existing iterators are invalidated.

func (*FrameRefSet) SplitUnchecked

func (s *FrameRefSet) SplitUnchecked(seg FrameRefIterator, split uint64) (FrameRefIterator, FrameRefIterator)

SplitUnchecked splits the given segment at the given key and returns iterators to the two resulting segments. All existing iterators (including seg, but not including the returned iterators) are invalidated.

Preconditions: seg.Start() < key < seg.End().

func (*FrameRefSet) StateFields

func (s *FrameRefSet) StateFields() []string

func (*FrameRefSet) StateLoad

func (s *FrameRefSet) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FrameRefSet) StateSave

func (s *FrameRefSet) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FrameRefSet) StateTypeName

func (s *FrameRefSet) StateTypeName() string

func (*FrameRefSet) String

func (s *FrameRefSet) String() string

String stringifies a Set for debugging.

func (*FrameRefSet) UpperBoundGap

func (s *FrameRefSet) UpperBoundGap(max uint64) FrameRefGapIterator

UpperBoundGap returns the gap with the highest range that is less than or equal to max.

func (*FrameRefSet) UpperBoundSegment

func (s *FrameRefSet) UpperBoundSegment(max uint64) FrameRefIterator

UpperBoundSegment returns the segment with the highest range that contains a key less than or equal to max. If no such segment exists, UpperBoundSegment returns a terminal iterator.

type FrameRefSetFunctions

type FrameRefSetFunctions struct{}

FrameRefSetFunctions implements segment.Functions for FrameRefSet.

func (FrameRefSetFunctions) ClearValue

func (FrameRefSetFunctions) ClearValue(val *FrameRefSegInfo)

ClearValue implements segment.Functions.ClearValue.

func (FrameRefSetFunctions) MaxKey

func (FrameRefSetFunctions) MaxKey() uint64

MaxKey implements segment.Functions.MaxKey.

func (FrameRefSetFunctions) Merge

Merge implements segment.Functions.Merge.

func (FrameRefSetFunctions) MinKey

func (FrameRefSetFunctions) MinKey() uint64

MinKey implements segment.Functions.MinKey.

func (FrameRefSetFunctions) Split

Split implements segment.Functions.Split.

type FrameRefdynamicGap

type FrameRefdynamicGap [FrameReftrackGaps]uint64

dynamicGap is a type that disappears if trackGaps is 0.

func (*FrameRefdynamicGap) Get

func (d *FrameRefdynamicGap) Get() uint64

Get returns the value of the gap.

Precondition: trackGaps must be non-zero.

func (*FrameRefdynamicGap) Set

func (d *FrameRefdynamicGap) Set(v uint64)

Set sets the value of the gap.

Precondition: trackGaps must be non-zero.

type FrameRefnode

type FrameRefnode struct {
	// contains filtered or unexported fields
}

+stateify savable

func (*FrameRefnode) StateFields

func (n *FrameRefnode) StateFields() []string

func (*FrameRefnode) StateLoad

func (n *FrameRefnode) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*FrameRefnode) StateSave

func (n *FrameRefnode) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*FrameRefnode) StateTypeName

func (n *FrameRefnode) StateTypeName() string

func (*FrameRefnode) String

func (n *FrameRefnode) String() string

String stringifies a node (and all of its children) for debugging.

type HostFileMapper

type HostFileMapper struct {
	// contains filtered or unexported fields
}

HostFileMapper caches mappings of an arbitrary host file descriptor. It is used by implementations of memmap.Mappable that represent a host file descriptor.

+stateify savable

func NewHostFileMapper

func NewHostFileMapper() *HostFileMapper

NewHostFileMapper returns an initialized HostFileMapper allocated on the heap with no references or cached mappings.

func (*HostFileMapper) DecRefOn

func (f *HostFileMapper) DecRefOn(mr memmap.MappableRange)

DecRefOn decrements the reference count on all offsets in mr.

Preconditions:

  • mr.Length() != 0.
  • mr.Start and mr.End must be page-aligned.

func (*HostFileMapper) IncRefOn

func (f *HostFileMapper) IncRefOn(mr memmap.MappableRange)

IncRefOn increments the reference count on all offsets in mr.

Preconditions:

  • mr.Length() != 0.
  • mr.Start and mr.End must be page-aligned.

func (*HostFileMapper) Init

func (f *HostFileMapper) Init()

Init must be called on zero-value HostFileMappers before first use.

func (*HostFileMapper) IsInited

func (f *HostFileMapper) IsInited() bool

IsInited returns true if f.Init() has been called. This is used when restoring a checkpoint that contains a HostFileMapper that may or may not have been initialized.

func (*HostFileMapper) MapInternal

func (f *HostFileMapper) MapInternal(fr memmap.FileRange, fd int, write bool) (safemem.BlockSeq, error)

MapInternal returns a mapping of offsets in fr from fd. The returned safemem.BlockSeq is valid as long as at least one reference is held on all offsets in fr or until the next call to UnmapAll.

Preconditions: The caller must hold a reference on all offsets in fr.

func (*HostFileMapper) RegenerateMappings

func (f *HostFileMapper) RegenerateMappings(fd int) error

RegenerateMappings must be called when the file description mapped by f changes, to replace existing mappings of the previous file description.

func (*HostFileMapper) StateFields

func (f *HostFileMapper) StateFields() []string

func (*HostFileMapper) StateLoad

func (f *HostFileMapper) StateLoad(stateSourceObject state.Source)

+checklocksignore

func (*HostFileMapper) StateSave

func (f *HostFileMapper) StateSave(stateSinkObject state.Sink)

+checklocksignore

func (*HostFileMapper) StateTypeName

func (f *HostFileMapper) StateTypeName() string

func (*HostFileMapper) UnmapAll

func (f *HostFileMapper) UnmapAll()

UnmapAll unmaps all cached mappings. Callers are responsible for synchronization with mappings returned by previous calls to MapInternal.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL