func (r *Packed8ThreeBlocks) RamBytesUsed() int64 {
return util.AlignObjectSize(
util.NUM_BYTES_OBJECT_HEADER +
2*util.NUM_BYTES_INT +
util.NUM_BYTES_OBJECT_REF +
util.SizeOf(r.blocks))
}
func (w *NumericDocValuesWriter) docsWithFieldBytesUsed() int64 {
// size of the []int64 + some overhead
if w.docsWithField == nil {
return 0
}
return util.SizeOf(w.docsWithField.Bits()) + 64
}
func (d *Direct32) RamBytesUsed() int64 {
return util.AlignObjectSize(
util.NUM_BYTES_OBJECT_HEADER +
2*util.NUM_BYTES_INT +
util.NUM_BYTES_OBJECT_REF +
util.SizeOf(d.values))
}
func (p *Packed64SingleBlock) RamBytesUsed() int64 {
return util.AlignObjectSize(
util.NUM_BYTES_OBJECT_HEADER +
2*util.NUM_BYTES_INT +
util.NUM_BYTES_OBJECT_REF +
util.SizeOf(p.blocks))
}
func (np *NormsProducer) loadNorms(field *FieldInfo) (NumericDocValues, error) {
entry, ok := np.norms[int(field.Number)]
assert(ok)
switch entry.format {
case CONST_COMPRESSED:
return func(int) int64 { return entry.offset }, nil
case UNCOMPRESSED:
panic("not implemented yet")
case DELTA_COMPRESSED:
panic("not implemented yet")
case TABLE_COMPRESSED:
var err error
if err = np.data.Seek(entry.offset); err == nil {
var packedVersion int32
if packedVersion, err = np.data.ReadVInt(); err == nil {
var size int
if size, err = int32ToInt(np.data.ReadVInt()); err == nil {
if size > 256 {
return nil, errors.New(fmt.Sprintf(
"TABLE_COMPRESSED cannot have more than 256 distinct values, input=%v",
np.data))
}
decode := make([]int64, size)
for i, _ := range decode {
if decode[i], err = np.data.ReadLong(); err != nil {
break
}
}
if err == nil {
var formatId int
if formatId, err = int32ToInt(np.data.ReadVInt()); err == nil {
var bitsPerValue int32
if bitsPerValue, err = np.data.ReadVInt(); err == nil {
var ordsReader packed.PackedIntsReader
if ordsReader, err = packed.ReaderNoHeader(np.data,
packed.PackedFormat(formatId), packedVersion,
int32(np.maxDoc), uint32(bitsPerValue)); err == nil {
atomic.AddInt64(&np.ramBytesUsed, util.SizeOf(decode)+ordsReader.RamBytesUsed())
return func(docId int) int64 {
return decode[int(ordsReader.Get(docId))]
}, nil
}
}
}
}
}
}
}
if err != nil {
return nil, err
}
default:
panic("assert fail")
}
panic("should not be here")
}
/*
Build a PackedLongValues instance that contains values that have been
added to this builder. This operation is destructive.
*/
func (b *PackedLongValuesBuilderImpl) Build() PackedLongValues {
b.finish()
b.pending = nil
values := make([]PackedIntsReader, b.valuesOff)
copy(values, b.values[:b.valuesOff])
ramBytesUsed := util.ShallowSizeOfInstance(reflect.TypeOf(&PackedLongValuesImpl{})) +
util.SizeOf(values)
return newPackedLongValues(b.pageShift, b.pageMask, values, b.size, ramBytesUsed)
}
func NewDeltaPackedLongValuesBuilder(pageSize int,
acceptableOverheadRatio float32) *DeltaPackedLongValuesBuilderImpl {
super := newPackedLongValuesBuilder(pageSize, acceptableOverheadRatio)
ans := &DeltaPackedLongValuesBuilderImpl{
PackedLongValuesBuilderImpl: super,
mins: make([]int64, len(super.values)),
}
ans.ramBytesUsed += util.ShallowSizeOfInstance(reflect.TypeOf(&DeltaPackedLongValuesBuilderImpl{})) +
util.SizeOf(ans.mins)
return ans
}
func newPackedLongValuesBuilder(pageSize int,
acceptableOverheadRatio float32) *PackedLongValuesBuilderImpl {
ans := &PackedLongValuesBuilderImpl{
pageShift: checkBlockSize(pageSize, MIN_PAGE_SIZE, MAX_PAGE_SIZE),
pageMask: pageSize - 1,
acceptableOverheadRatio: acceptableOverheadRatio,
values: make([]PackedIntsReader, INITIAL_PAGE_COUNT),
pending: make([]int64, pageSize),
}
ans.ramBytesUsed = util.ShallowSizeOfInstance(reflect.TypeOf(&PackedLongValuesBuilderImpl{})) +
util.SizeOf(ans.pending) + util.ShallowSizeOf(ans.values)
return ans
}
