wp
This commit is contained in:
@@ -1,3 +1,5 @@
|
||||
package chunkenc
|
||||
|
||||
const eps = 0.000001
|
||||
|
||||
const flagLiteral = 128
|
||||
298
chunkenc/chunkenc_test.go
Normal file
298
chunkenc/chunkenc_test.go
Normal file
@@ -0,0 +1,298 @@
|
||||
package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"gordenko.dev/dima/qb/conbuf"
|
||||
)
|
||||
|
||||
func TestCumdelta(t *testing.T) {
|
||||
var (
|
||||
fracDigits byte = 0
|
||||
buf = conbuf.New(nil)
|
||||
value float64
|
||||
done bool
|
||||
)
|
||||
c := NewReverseCumulativeDeltaCompressor(buf, 0, fracDigits)
|
||||
// c.Append(1.55)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23.5)
|
||||
|
||||
c.Append(130)
|
||||
c.Append(191)
|
||||
|
||||
c.Append(248)
|
||||
c.Append(305)
|
||||
|
||||
//fmt.Printf("pos: %d\n", c.pos)
|
||||
//fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
d := NewReverseCumulativeDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
|
||||
for range 8 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsdelta(t *testing.T) {
|
||||
var (
|
||||
fracDigits byte = 2
|
||||
buf = conbuf.New(nil)
|
||||
value float64
|
||||
done bool
|
||||
)
|
||||
c := NewReverseInstantDeltaCompressor(buf, 0, fracDigits)
|
||||
c.Append(-1.55)
|
||||
c.Append(23)
|
||||
|
||||
//fmt.Printf("pos: %d\n", c.pos)
|
||||
//fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(23)
|
||||
c.Append(23)
|
||||
|
||||
c.Append(-23.5)
|
||||
|
||||
//fmt.Printf("pos: %d\n", c.pos)
|
||||
//fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
|
||||
for range 8 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTimeDelta(t *testing.T) {
|
||||
var (
|
||||
buf = conbuf.New(nil)
|
||||
value uint32
|
||||
done bool
|
||||
)
|
||||
c := NewReverseTimeDeltaCompressor(buf, 0)
|
||||
c.Append(10)
|
||||
|
||||
//c.Append(131)
|
||||
|
||||
//fmt.Printf("pos: %d\n", c.pos)
|
||||
//fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(70)
|
||||
|
||||
c.Append(130)
|
||||
c.Append(191)
|
||||
|
||||
c.Append(248)
|
||||
c.Append(305)
|
||||
c.Append(330)
|
||||
c.Append(390)
|
||||
c.Append(450)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
//c.Sync()
|
||||
|
||||
bound := c.GetState()
|
||||
|
||||
fmt.Println("AFTER SYNC")
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
chunks := buf.Chunks()
|
||||
if len(chunks) > 0 {
|
||||
fmt.Printf("%d\n", chunks[0])
|
||||
}
|
||||
|
||||
d := NewReverseTimeDeltaDecompressor(buf, c.Size())
|
||||
d.RestoreFromBound(bound)
|
||||
//d.RestoreFromEnd()
|
||||
|
||||
for range 12 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCumdeltaBound(t *testing.T) {
|
||||
var (
|
||||
fracDigits byte = 0
|
||||
buf = conbuf.New(nil)
|
||||
value float64
|
||||
done bool
|
||||
)
|
||||
c := NewReverseCumulativeDeltaCompressor(buf, 0, fracDigits)
|
||||
// c.Append(1.55)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23.5)
|
||||
c.Append(10)
|
||||
c.Append(70)
|
||||
|
||||
c.Append(130)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(191)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(191)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
//////////////////////////
|
||||
|
||||
bound := c.GetState()
|
||||
|
||||
fmt.Printf("bound: pos=%d, h=%d\n", bound.Pos, bound.H)
|
||||
|
||||
c.Append(248)
|
||||
c.Append(305)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
d := NewReverseCumulativeDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
d.RestoreFromEnd()
|
||||
|
||||
for range 8 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
|
||||
boundDecompressor := NewReverseCumulativeDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
boundDecompressor.RestoreFromBound(bound)
|
||||
|
||||
fmt.Println("from bound:")
|
||||
for range 8 {
|
||||
value, done = boundDecompressor.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsdeltaBound(t *testing.T) {
|
||||
var (
|
||||
fracDigits byte = 0
|
||||
buf = conbuf.New(nil)
|
||||
value float64
|
||||
done bool
|
||||
)
|
||||
c := NewReverseInstantDeltaCompressor(buf, 0, fracDigits)
|
||||
// c.Append(1.55)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23.5)
|
||||
c.Append(10)
|
||||
c.Append(70)
|
||||
|
||||
c.Append(130)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(191)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(191)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
//////////////////////////
|
||||
|
||||
bound := c.GetState()
|
||||
|
||||
fmt.Printf("bound: pos=%d, h=%d\n", bound.Pos, bound.H)
|
||||
|
||||
c.Append(248)
|
||||
c.Append(305)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
d.RestoreFromEnd()
|
||||
|
||||
for range 8 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
|
||||
boundDecompressor := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
boundDecompressor.RestoreFromBound(bound)
|
||||
|
||||
fmt.Println("from bound:")
|
||||
for range 8 {
|
||||
value, done = boundDecompressor.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInsdeltaBound2(t *testing.T) {
|
||||
var (
|
||||
fracDigits byte = 0
|
||||
buf = conbuf.New(nil)
|
||||
value float64
|
||||
done bool
|
||||
)
|
||||
c := NewReverseInstantDeltaCompressor(buf, 0, fracDigits)
|
||||
// c.Append(1.55)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23)
|
||||
// c.Append(23.5)
|
||||
c.Append(305)
|
||||
c.Append(248)
|
||||
|
||||
c.Append(191)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(191)
|
||||
|
||||
// fmt.Printf("pos: %d\n", c.pos)
|
||||
// fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
c.Append(130)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
//////////////////////////
|
||||
|
||||
bound := c.GetState()
|
||||
|
||||
fmt.Printf("bound: pos=%d, h=%d\n", bound.Pos, bound.H)
|
||||
|
||||
c.Append(70)
|
||||
c.Append(10)
|
||||
|
||||
fmt.Printf("pos: %d\n", c.pos)
|
||||
fmt.Printf("%d\n", buf.Chunks()[0])
|
||||
|
||||
d := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
d.RestoreFromEnd()
|
||||
|
||||
for range 8 {
|
||||
value, done = d.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
|
||||
boundDecompressor := NewReverseInstantDeltaDecompressor(buf, c.Size(), fracDigits)
|
||||
boundDecompressor.RestoreFromBound(bound)
|
||||
|
||||
fmt.Println("from bound:")
|
||||
for range 8 {
|
||||
value, done = boundDecompressor.NextValue()
|
||||
fmt.Println(value, done)
|
||||
}
|
||||
}
|
||||
@@ -2,22 +2,49 @@ package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
|
||||
"gordenko.dev/dima/qb/bin"
|
||||
"gordenko.dev/dima/qb/conbuf"
|
||||
)
|
||||
|
||||
// REVERSE
|
||||
// COMPRESSOR REVERSE
|
||||
|
||||
/*
|
||||
Формат:
|
||||
base value (var u64)
|
||||
delta (var u64)
|
||||
q (qty of previous deltas; msb=0 - series, msb=1 - non series, low 7 bits - qty 1..128)
|
||||
delta
|
||||
delta
|
||||
delta
|
||||
q
|
||||
|
||||
Дельта рахується від base value.
|
||||
Декодування у зворотньому порядку.
|
||||
|
||||
Після base value слідують run або literal блоки.
|
||||
Run блок - це delta + header byte в кінці.
|
||||
Literal блок - це від одної до N дельт + header byte в кінці.
|
||||
Спочатку створюється literal блок.
|
||||
Якщо для останної дельти додається дублікат, literal блок модифікується -
|
||||
лічильник зменшується до 1. А остання дельта переміщюється в новий run блок.
|
||||
Причому лічильник 0 - означає 2 елементи. Приклад:
|
||||
До:
|
||||
v1 v2 v3 h-byte(literal, 3) <- v3
|
||||
Після:
|
||||
v1 v2 h-byte(literal, 2) v3 h-byte(run, 2)
|
||||
*/
|
||||
|
||||
type ReverseCumulativeDeltaCompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
firstValue float64
|
||||
lastDelta uint64
|
||||
length uint16
|
||||
numIdx int
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
baseValue float64
|
||||
lastDelta uint64
|
||||
lastDeltaSize int
|
||||
h byte
|
||||
state *CumulativeDeltaBound
|
||||
}
|
||||
|
||||
func NewReverseCumulativeDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaCompressor {
|
||||
@@ -27,236 +54,166 @@ func NewReverseCumulativeDeltaCompressor(buf *conbuf.ContinuousBuffer, size int,
|
||||
}
|
||||
s := &ReverseCumulativeDeltaCompressor{
|
||||
buf: buf,
|
||||
pos: size,
|
||||
pos: size, // перший вільний байт
|
||||
coef: coef,
|
||||
}
|
||||
if size > 0 {
|
||||
s.restoreState()
|
||||
u64, _, err := s.buf.GetVarUint64(0)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get base value: %s", err)
|
||||
}
|
||||
s.baseValue = float64(u64) / s.coef
|
||||
s.h = s.buf.GetByte(s.pos - 1)
|
||||
s.lastDelta, s.lastDeltaSize, err = s.buf.ReverseGetVarUint64(s.pos - 2)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last delta: %s", err)
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) restoreState() {
|
||||
u64, n, err := s.buf.GetVarUint64(0)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("bug: get first value: %s", err))
|
||||
}
|
||||
s.firstValue = float64(u64) / s.coef
|
||||
|
||||
if s.pos > n {
|
||||
pos := s.pos - 1
|
||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
||||
pos--
|
||||
s8 := s.buf.GetByte(pos)
|
||||
pos--
|
||||
|
||||
var n int
|
||||
s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("bug: get last delta: %s", err))
|
||||
}
|
||||
pos -= n
|
||||
s.numIdx = pos + 1
|
||||
|
||||
var flag byte = 1 << idxOf8
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) Size() int {
|
||||
return s.pos
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) CalcRequiredSpace(value float64) int {
|
||||
if s.pos == 0 {
|
||||
n := bin.CalcVarUint64Length(uint64(value * s.coef))
|
||||
return n + 3
|
||||
}
|
||||
delta := uint64((value-s.firstValue)*s.coef + eps)
|
||||
if delta == s.lastDelta {
|
||||
if s.length == 0 {
|
||||
return 1
|
||||
} else {
|
||||
newLength := s.length + 1
|
||||
if newLength < 130 {
|
||||
return 0
|
||||
} else if newLength == 130 {
|
||||
return 1
|
||||
} else {
|
||||
if newLength < 32769 {
|
||||
return 0
|
||||
} else {
|
||||
n := bin.CalcVarUint64Length(delta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
n := bin.CalcVarUint64Length(delta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
//func (s *ReverseCumulativeDeltaCompressor) CalcRequiredSpace(value float64) int {
|
||||
//}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) Append(value float64) {
|
||||
if s.pos == 0 {
|
||||
n := s.buf.PutVarUint64(s.pos, uint64(value*s.coef))
|
||||
s.pos += n
|
||||
s.firstValue = value
|
||||
s.encodeNewDelta(0, 0, 1)
|
||||
// base value
|
||||
s.pos += s.buf.PutVarUint64(s.pos, uint64(value*s.coef))
|
||||
s.baseValue = value
|
||||
s.appendNewLiteral(0)
|
||||
} else {
|
||||
delta := uint64((value-s.firstValue)*s.coef + eps)
|
||||
delta := uint64((value-s.baseValue)*s.coef + eps)
|
||||
if delta == s.lastDelta {
|
||||
if s.length == 0 {
|
||||
s.length = 2
|
||||
s.shiftOnePosToRight()
|
||||
s.buf.SetByte(s.numIdx-1, 0)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
||||
} else {
|
||||
s.length++
|
||||
if s.length < 130 {
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
||||
} else if s.length == 130 {
|
||||
s.shiftOnePosToRight()
|
||||
s.encode2bLength()
|
||||
if s.h < 128 {
|
||||
// run блок - отже треба збільшити лічильник
|
||||
if s.h < 127 {
|
||||
// increase counter
|
||||
s.h++
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
} else {
|
||||
if s.length < 32769 {
|
||||
s.encode2bLength()
|
||||
} else {
|
||||
s.appendNewDelta(delta)
|
||||
}
|
||||
// не можу збільшити - буде переповнення. Додаю новий literal блок
|
||||
// counter overflow
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
} else {
|
||||
// literal блок.
|
||||
// Якщо в ньому лише одне значення - перетворюю його на run блок.
|
||||
// Інакше забираю останнє значення із literal блока і додаю новий run блок.
|
||||
q := s.h & 127
|
||||
if q == 0 { // 1 кодується як 0
|
||||
s.convertLiteralToRun()
|
||||
} else {
|
||||
// забираю останнє значення із literal блоку щоб зробити run блок
|
||||
s.convertLastFromLiteralToRun()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.appendNewDelta(delta)
|
||||
if s.h < 127 { // fix 128?
|
||||
// end of run
|
||||
s.appendNewLiteral(delta)
|
||||
} else {
|
||||
if s.h < 255 {
|
||||
// encode value from pos - 1, then append h byte
|
||||
s.appendDeltaToLiteral(delta)
|
||||
} else {
|
||||
// overflowed - encode new
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) appendNewDelta(delta uint64) {
|
||||
s.length = 0
|
||||
|
||||
s8 := s.buf.GetByte(s.pos - 2)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
|
||||
if s8q == 8 {
|
||||
s.pos -= 1
|
||||
s8 = 0
|
||||
s8q = 1
|
||||
} else {
|
||||
s.pos -= 2
|
||||
s8q++
|
||||
}
|
||||
|
||||
s.encodeNewDelta(delta, s8, s8q)
|
||||
func (s *ReverseCumulativeDeltaCompressor) convertLastFromLiteralToRun() {
|
||||
// Зменшую кількість елементів в literal блоці
|
||||
s.h--
|
||||
s.pos -= 1 + s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h) // закриваю literal блок
|
||||
s.pos++
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, s.lastDelta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.h = 0 // run блок, довжини 2
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) encodeNewDelta(delta uint64, s8 byte, s8q byte) {
|
||||
func (s *ReverseCumulativeDeltaCompressor) convertLiteralToRun() {
|
||||
// Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||
s.h = 0
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) appendDeltaToLiteral(delta uint64) {
|
||||
s.h++ // збільшую к-сть дельт
|
||||
s.lastDelta = delta
|
||||
s.numIdx = s.pos
|
||||
n := s.buf.ReversePutVarUint64(s.pos, s.lastDelta)
|
||||
s.pos += n
|
||||
s.buf.SetByte(s.pos, s8)
|
||||
s.pos++
|
||||
s.buf.SetByte(s.pos, s8q)
|
||||
s.pos--
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, delta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) shiftOnePosToRight() {
|
||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
||||
func (s *ReverseCumulativeDeltaCompressor) appendNewLiteral(delta uint64) {
|
||||
s.h = flagLiteral
|
||||
s.lastDelta = delta
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, delta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, flagLiteral) // literal, length = 1
|
||||
s.pos++
|
||||
s.numIdx++
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) encode2bLength() {
|
||||
num := s.length - 2
|
||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) DeleteLast() {
|
||||
var (
|
||||
s8q = s.buf.GetByte(s.pos - 1)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag byte = 1 << uint(8-s8q)
|
||||
)
|
||||
|
||||
if s.length > 0 {
|
||||
if s.length == 2 {
|
||||
s.length = 0
|
||||
s.buf.UnsetFlag(s.pos-2, flag)
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
} else if s.length < 130 {
|
||||
s.length--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else if s.length == 130 {
|
||||
s.length--
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else {
|
||||
s.length--
|
||||
s.encode2bLength()
|
||||
}
|
||||
} else {
|
||||
if s8q > 1 {
|
||||
s8q--
|
||||
flag = 1 << uint(8-s8q)
|
||||
s.pos = s.numIdx + 2
|
||||
s.buf.SetByte(s.pos-2, s8)
|
||||
s.buf.SetByte(s.pos-1, s8q)
|
||||
} else {
|
||||
s.pos = s.numIdx + 1
|
||||
s.buf.SetByte(s.pos-1, 8)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag = 1
|
||||
}
|
||||
var (
|
||||
pos = s.pos - 3
|
||||
n int
|
||||
err error
|
||||
)
|
||||
s.lastDelta, n, err = s.buf.ReverseGetVarUint64(pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s.numIdx = pos - n
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
||||
}
|
||||
}
|
||||
|
||||
type CumulativeDeltaBound struct {
|
||||
Pos int
|
||||
H byte
|
||||
LastDelta uint64
|
||||
Chunks [][]byte
|
||||
}
|
||||
|
||||
// delta h
|
||||
func (s *ReverseCumulativeDeltaCompressor) Lock() {
|
||||
s.state = &CumulativeDeltaBound{
|
||||
Pos: s.pos - 1 - s.lastDeltaSize,
|
||||
H: s.h,
|
||||
LastDelta: s.lastDelta,
|
||||
Chunks: s.buf.Chunks(),
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) CreateDecompressor(fracDigits byte) *ReverseCumulativeDeltaDecompressor {
|
||||
if s.state == nil {
|
||||
d := NewReverseCumulativeDeltaDecompressor(s.buf, s.Size(), fracDigits)
|
||||
d.RestoreFromEnd()
|
||||
return d
|
||||
}
|
||||
d := NewReverseCumulativeDeltaDecompressor(s.buf, s.Size(), fracDigits)
|
||||
d.RestoreFromBound(*s.state)
|
||||
return d
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaCompressor) Unlock() {
|
||||
s.state = nil
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
type ReverseCumulativeDeltaDecompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
bound int
|
||||
firstValue float64
|
||||
lastValue float64
|
||||
length uint16
|
||||
coef float64
|
||||
idxOf8 uint
|
||||
s8 byte
|
||||
step byte
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
bound int
|
||||
baseValue float64
|
||||
lastValue float64
|
||||
isRun bool
|
||||
pending int
|
||||
done bool
|
||||
}
|
||||
|
||||
func NewReverseCumulativeDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseCumulativeDeltaDecompressor {
|
||||
@@ -264,67 +221,91 @@ func NewReverseCumulativeDeltaDecompressor(buf *conbuf.ContinuousBuffer, size in
|
||||
if fracDigits > 0 {
|
||||
coef = math.Pow(10, float64(fracDigits))
|
||||
}
|
||||
return &ReverseCumulativeDeltaDecompressor{
|
||||
buf: buf,
|
||||
coef: coef,
|
||||
pos: size,
|
||||
u64, n, err := buf.GetVarUint64(0)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get base value: %s", err)
|
||||
}
|
||||
//fmt.Printf("baseValue: %.2f, bound: %d, pos: %d\n", float64(u64)/coef, n, size)
|
||||
return &ReverseCumulativeDeltaDecompressor{
|
||||
buf: buf,
|
||||
coef: coef,
|
||||
pos: size - 1, // last elem
|
||||
baseValue: float64(u64) / coef,
|
||||
bound: n,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaDecompressor) RestoreFromEnd() {
|
||||
if s.pos > s.bound {
|
||||
// читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readValue()
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaDecompressor) RestoreFromBound(bound CumulativeDeltaBound) {
|
||||
s.pos = bound.Pos - 1
|
||||
s.lastValue = s.baseValue + float64(bound.LastDelta)
|
||||
s.decodeHeaderByte(bound.H)
|
||||
fmt.Printf("restore from bound: isRun=%t, pending=%d\n", s.isRun, s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaDecompressor) NextValue() (value float64, done bool) {
|
||||
if s.step > 0 {
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
return s.lastValue, false
|
||||
}
|
||||
if s.pos < s.bound {
|
||||
return 0, true
|
||||
}
|
||||
if s.idxOf8 == 0 {
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
}
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
return s.lastValue, false
|
||||
//fmt.Printf("NextValue(): bound: %d, pos: %d, pending: %d\n", s.bound, s.pos, s.pending)
|
||||
if s.done {
|
||||
return 0, true
|
||||
}
|
||||
u64, n, err := s.buf.GetVarUint64(0)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
// повертаю значення, що було прочитано в методі RestoreFromBound/RestoreFromEnd
|
||||
value = s.lastValue
|
||||
s.pending--
|
||||
if s.pending > 0 {
|
||||
// якщо в серії залишаються елементи
|
||||
if !s.isRun {
|
||||
s.readValue()
|
||||
}
|
||||
} else if s.pos > s.bound {
|
||||
// в серії більше немає елементів, отже перевіряє чи є ще дані в буфері.
|
||||
// дані є - читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readValue()
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
s.firstValue = float64(u64) / s.coef
|
||||
s.bound = n
|
||||
s.pos--
|
||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
||||
s.pos--
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
s.step = 1
|
||||
return s.lastValue, false
|
||||
// серія завершена - перевіряю чи є ще серії
|
||||
return value, false
|
||||
}
|
||||
|
||||
func (s *ReverseCumulativeDeltaDecompressor) readVar() {
|
||||
func (s *ReverseCumulativeDeltaDecompressor) readHeader() {
|
||||
h := s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
s.decodeHeaderByte(h)
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
}
|
||||
func (s *ReverseCumulativeDeltaDecompressor) readValue() {
|
||||
u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
log.Fatalln(err)
|
||||
}
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("read delta:", u64)
|
||||
// fmt.Println("read delta n:", n)
|
||||
// fmt.Println()
|
||||
s.pos -= n
|
||||
s.lastValue = s.firstValue + float64(u64)/s.coef
|
||||
s.lastValue = s.baseValue + float64(u64)/s.coef
|
||||
}
|
||||
|
||||
var flag byte = 1 << s.idxOf8
|
||||
if (s.s8 & flag) == flag {
|
||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
||||
s.pos -= n
|
||||
}
|
||||
if s.idxOf8 == 7 {
|
||||
s.idxOf8 = 0
|
||||
func (s *ReverseCumulativeDeltaDecompressor) decodeHeaderByte(h byte) {
|
||||
s.isRun = h < 128
|
||||
if s.isRun {
|
||||
s.pending = int(h&127) + 2
|
||||
} else {
|
||||
s.idxOf8++
|
||||
s.pending = int(h&127) + 1
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
@@ -2,22 +2,20 @@ package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
"math"
|
||||
|
||||
"gordenko.dev/dima/qb/bin"
|
||||
"gordenko.dev/dima/qb/conbuf"
|
||||
)
|
||||
|
||||
// REVERSE
|
||||
|
||||
type ReverseInstantDeltaCompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
firstValue float64
|
||||
lastDelta int64
|
||||
length uint16
|
||||
numIdx int
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
baseValue float64
|
||||
lastDelta int64
|
||||
lastDeltaSize int
|
||||
h byte
|
||||
}
|
||||
|
||||
func NewReverseInstantDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaCompressor {
|
||||
@@ -31,246 +29,146 @@ func NewReverseInstantDeltaCompressor(buf *conbuf.ContinuousBuffer, size int, fr
|
||||
coef: coef,
|
||||
}
|
||||
if size > 0 {
|
||||
s.restoreState()
|
||||
i64, _, err := s.buf.GetVarInt64(0)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get base value: %s", err)
|
||||
}
|
||||
s.baseValue = float64(i64) / s.coef
|
||||
s.h = s.buf.GetByte(s.pos - 1)
|
||||
s.lastDelta, s.lastDeltaSize, err = s.buf.ReverseGetVarInt64(s.pos - 2)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last delta: %s", err)
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) restoreState() {
|
||||
i64, n, err := s.buf.GetVarInt64(0)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("bug: get first value: %s", err))
|
||||
}
|
||||
s.firstValue = float64(i64) / s.coef
|
||||
|
||||
if s.pos > n {
|
||||
pos := s.pos - 1
|
||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
||||
pos--
|
||||
s8 := s.buf.GetByte(pos)
|
||||
pos--
|
||||
|
||||
var n int
|
||||
s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("bug: get last delta: %s", err))
|
||||
}
|
||||
pos -= n
|
||||
s.numIdx = pos + 1
|
||||
var flag byte = 1 << idxOf8
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) Size() int {
|
||||
return s.pos
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) CalcRequiredSpace(value float64) int {
|
||||
if s.pos == 0 {
|
||||
n := bin.CalcVarInt64Length(int64(value * s.coef))
|
||||
return n + 3
|
||||
}
|
||||
|
||||
tmp := (value - s.firstValue) * s.coef
|
||||
if tmp > 0 {
|
||||
tmp += eps
|
||||
} else {
|
||||
tmp -= eps
|
||||
}
|
||||
delta := int64(tmp)
|
||||
|
||||
if delta == s.lastDelta {
|
||||
if s.length == 0 {
|
||||
return 1
|
||||
} else {
|
||||
newLength := s.length + 1
|
||||
if newLength < 130 {
|
||||
return 0
|
||||
} else if newLength == 130 {
|
||||
return 1
|
||||
} else {
|
||||
if newLength < 32769 {
|
||||
return 0
|
||||
} else {
|
||||
n := bin.CalcVarInt64Length(delta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
n := bin.CalcVarInt64Length(delta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
|
||||
// В начале буфера кодирую базовое значение.
|
||||
func (s *ReverseInstantDeltaCompressor) Append(value float64) {
|
||||
if s.pos == 0 {
|
||||
// base value
|
||||
n := s.buf.PutVarInt64(s.pos, int64(value*s.coef))
|
||||
s.pos += n
|
||||
s.firstValue = value
|
||||
s.encodeNewDelta(0, 0, 1)
|
||||
s.baseValue = value
|
||||
s.appendNewLiteral(0)
|
||||
} else {
|
||||
tmp := (value - s.firstValue) * s.coef
|
||||
tmp := (value - s.baseValue) * s.coef
|
||||
if tmp > 0 {
|
||||
tmp += eps
|
||||
} else {
|
||||
tmp -= eps
|
||||
}
|
||||
delta := int64(tmp)
|
||||
|
||||
if delta == s.lastDelta {
|
||||
if s.length == 0 {
|
||||
s.length = 2
|
||||
s.shiftOnePosToRight()
|
||||
s.buf.SetByte(s.numIdx-1, 0)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
||||
} else {
|
||||
s.length++
|
||||
if s.length < 130 {
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
||||
} else if s.length == 130 {
|
||||
s.shiftOnePosToRight()
|
||||
s.encode2bLength()
|
||||
if s.h < 128 {
|
||||
// run блок - отже треба збільшити лічильник
|
||||
if s.h < 127 {
|
||||
// increase counter
|
||||
s.h++
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
} else {
|
||||
if s.length < 32769 {
|
||||
s.encode2bLength()
|
||||
} else {
|
||||
s.appendNewDelta(delta)
|
||||
}
|
||||
// не можу збільшити - буде переповнення. Додаю новий literal блок
|
||||
// counter overflow
|
||||
// fix encode delta
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
} else {
|
||||
// literal блок.
|
||||
// Якщо в ньому лише одне значення - перетворюю його на run блок.
|
||||
// Інакше забираю останнє значення із literal блока і додаю новий run блок.
|
||||
q := s.h & 127
|
||||
if q == 0 { // 1 кодується як 0
|
||||
s.convertLiteralToRun()
|
||||
} else {
|
||||
s.convertLastFromLiteralToRun()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.appendNewDelta(delta)
|
||||
if s.h < 127 {
|
||||
// end of run
|
||||
s.appendNewLiteral(delta)
|
||||
} else {
|
||||
if s.h < 255 {
|
||||
// encode value from pos - 1, then append h byte
|
||||
s.appendDeltaToLiteral(delta)
|
||||
} else {
|
||||
// overflowed - encode new
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) appendNewDelta(delta int64) {
|
||||
s.length = 0
|
||||
|
||||
s8 := s.buf.GetByte(s.pos - 2)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
|
||||
if s8q == 8 {
|
||||
s.pos -= 1
|
||||
s8 = 0
|
||||
s8q = 1
|
||||
} else {
|
||||
s.pos -= 2
|
||||
s8q++
|
||||
}
|
||||
s.encodeNewDelta(delta, s8, s8q)
|
||||
func (s *ReverseInstantDeltaCompressor) convertLastFromLiteralToRun() {
|
||||
// Зменшую кількість елементів в literal блоці
|
||||
s.h--
|
||||
s.pos -= 1 + s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h) // закриваю literal блок
|
||||
s.pos++
|
||||
s.lastDeltaSize = s.buf.ReversePutVarInt64(s.pos, s.lastDelta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.h = 0 // run блок, довжини 2
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) encodeNewDelta(delta int64, s8 byte, s8q byte) {
|
||||
func (s *ReverseInstantDeltaCompressor) convertLiteralToRun() {
|
||||
// Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||
s.h = 0
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) appendDeltaToLiteral(delta int64) {
|
||||
s.h++ // збільшую к-сть дельт
|
||||
s.lastDelta = delta
|
||||
s.numIdx = s.pos
|
||||
n := s.buf.ReversePutVarInt64(s.pos, s.lastDelta)
|
||||
s.pos += n
|
||||
s.buf.SetByte(s.pos, s8)
|
||||
s.pos++
|
||||
s.buf.SetByte(s.pos, s8q)
|
||||
s.pos--
|
||||
s.lastDeltaSize = s.buf.ReversePutVarInt64(s.pos, delta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) shiftOnePosToRight() {
|
||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
||||
func (s *ReverseInstantDeltaCompressor) appendNewLiteral(delta int64) {
|
||||
s.h = flagLiteral
|
||||
s.lastDelta = delta
|
||||
s.lastDeltaSize = s.buf.ReversePutVarInt64(s.pos, delta)
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, flagLiteral) // literal, length = 1
|
||||
s.pos++
|
||||
s.numIdx++
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) encode2bLength() {
|
||||
num := s.length - 2
|
||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
||||
func (s *ReverseInstantDeltaCompressor) DeleteLast() {}
|
||||
|
||||
type InstantDeltaBound struct {
|
||||
Pos int
|
||||
H byte
|
||||
LastDelta int64
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaCompressor) DeleteLast() {
|
||||
var (
|
||||
s8q = s.buf.GetByte(s.pos - 1)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag byte = 1 << uint(8-s8q)
|
||||
)
|
||||
|
||||
if s.length > 0 {
|
||||
if s.length == 2 {
|
||||
s.length = 0
|
||||
s.buf.UnsetFlag(s.pos-2, flag)
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
} else if s.length < 130 {
|
||||
s.length--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else if s.length == 130 {
|
||||
s.length--
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else {
|
||||
s.length--
|
||||
s.encode2bLength()
|
||||
}
|
||||
} else {
|
||||
if s8q > 1 {
|
||||
s8q--
|
||||
flag = 1 << uint(8-s8q)
|
||||
s.pos = s.numIdx + 2
|
||||
s.buf.SetByte(s.pos-2, s8)
|
||||
s.buf.SetByte(s.pos-1, s8q)
|
||||
} else {
|
||||
s.pos = s.numIdx + 1
|
||||
s.buf.SetByte(s.pos-1, 8)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag = 1
|
||||
}
|
||||
var (
|
||||
pos = s.pos - 3
|
||||
n int
|
||||
err error
|
||||
)
|
||||
s.lastDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s.numIdx = pos - n
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
||||
}
|
||||
func (s *ReverseInstantDeltaCompressor) GetState() InstantDeltaBound {
|
||||
return InstantDeltaBound{
|
||||
Pos: s.pos - 1 - s.lastDeltaSize,
|
||||
H: s.h,
|
||||
LastDelta: s.lastDelta,
|
||||
}
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
type ReverseInstantDeltaDecompressor struct {
|
||||
step byte
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
bound int
|
||||
firstValue float64
|
||||
lastValue float64
|
||||
length uint16
|
||||
coef float64
|
||||
idxOf8 uint
|
||||
s8 byte
|
||||
buf *conbuf.ContinuousBuffer
|
||||
coef float64
|
||||
pos int
|
||||
bound int
|
||||
baseValue float64
|
||||
lastValue float64
|
||||
isRun bool
|
||||
pending int
|
||||
done bool
|
||||
}
|
||||
|
||||
func NewReverseInstantDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaDecompressor {
|
||||
@@ -278,68 +176,169 @@ func NewReverseInstantDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int,
|
||||
if fracDigits > 0 {
|
||||
coef = math.Pow(10, float64(fracDigits))
|
||||
}
|
||||
return &ReverseInstantDeltaDecompressor{
|
||||
buf: buf,
|
||||
coef: coef,
|
||||
pos: size,
|
||||
i64, n, err := buf.GetVarInt64(0)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get base value: %s", err)
|
||||
}
|
||||
//fmt.Printf("baseValue: %.2f, bound: %d, pos: %d\n", float64(u64)/coef, n, size)
|
||||
return &ReverseInstantDeltaDecompressor{
|
||||
buf: buf,
|
||||
coef: coef,
|
||||
pos: size - 1, // last elem
|
||||
baseValue: float64(i64) / coef,
|
||||
bound: n,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaDecompressor) RestoreFromEnd() {
|
||||
if s.pos > s.bound {
|
||||
// читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readValue()
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaDecompressor) RestoreFromBound(bound InstantDeltaBound) {
|
||||
s.pos = bound.Pos - 1
|
||||
s.lastValue = s.baseValue + float64(bound.LastDelta)
|
||||
s.decodeHeaderByte(bound.H)
|
||||
fmt.Printf("restore from bound: isRun=%t, pending=%d\n", s.isRun, s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaDecompressor) NextValue() (value float64, done bool) {
|
||||
if s.step > 0 {
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
return s.lastValue, false
|
||||
}
|
||||
if s.pos < s.bound {
|
||||
return 0, true
|
||||
}
|
||||
|
||||
if s.idxOf8 == 0 {
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
}
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
return s.lastValue, false
|
||||
//fmt.Printf("NextValue(): bound: %d, pos: %d, pending: %d\n", s.bound, s.pos, s.pending)
|
||||
if s.done {
|
||||
return 0, true
|
||||
}
|
||||
i64, n, err := s.buf.GetVarInt64(0)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
// повертаю значення, що було прочитано в методі RestoreFromBound/RestoreFromEnd
|
||||
value = s.lastValue
|
||||
s.pending--
|
||||
if s.pending > 0 {
|
||||
// якщо в серії залишаються елементи
|
||||
if !s.isRun {
|
||||
s.readValue()
|
||||
}
|
||||
} else if s.pos > s.bound {
|
||||
// в серії більше немає елементів, отже перевіряє чи є ще дані в буфері.
|
||||
// дані є - читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readValue()
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
s.firstValue = float64(i64) / s.coef
|
||||
s.bound = n
|
||||
s.pos--
|
||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
||||
s.pos--
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
s.step = 1
|
||||
return s.lastValue, false
|
||||
// серія завершена - перевіряю чи є ще серії
|
||||
return value, false
|
||||
}
|
||||
|
||||
func (s *ReverseInstantDeltaDecompressor) readVar() {
|
||||
func (s *ReverseInstantDeltaDecompressor) readHeader() {
|
||||
h := s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
s.decodeHeaderByte(h)
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
}
|
||||
func (s *ReverseInstantDeltaDecompressor) readValue() {
|
||||
i64, n, err := s.buf.ReverseGetVarInt64(s.pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
log.Fatalln(err)
|
||||
}
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("read delta:", u64)
|
||||
// fmt.Println("read delta n:", n)
|
||||
// fmt.Println()
|
||||
s.pos -= n
|
||||
s.lastValue = s.firstValue + float64(i64)/s.coef
|
||||
s.lastValue = s.baseValue + float64(i64)/s.coef
|
||||
}
|
||||
|
||||
var flag byte = 1 << s.idxOf8
|
||||
if (s.s8 & flag) == flag {
|
||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
||||
s.pos -= n
|
||||
}
|
||||
if s.idxOf8 == 7 {
|
||||
s.idxOf8 = 0
|
||||
func (s *ReverseInstantDeltaDecompressor) decodeHeaderByte(h byte) {
|
||||
s.isRun = h < 128
|
||||
if s.isRun {
|
||||
s.pending = int(h&127) + 2
|
||||
} else {
|
||||
s.idxOf8++
|
||||
s.pending = int(h&127) + 1
|
||||
}
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
// type ReverseInstantDeltaDecompressor struct {
|
||||
// buf *conbuf.ContinuousBuffer
|
||||
// pos int
|
||||
// bound int
|
||||
// baseValue float64
|
||||
// lastValue float64
|
||||
// coef float64
|
||||
// isRun bool
|
||||
// pending int
|
||||
// }
|
||||
|
||||
// func NewReverseInstantDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int, fracDigits byte) *ReverseInstantDeltaDecompressor {
|
||||
// var coef float64 = 1
|
||||
// if fracDigits > 0 {
|
||||
// coef = math.Pow(10, float64(fracDigits))
|
||||
// }
|
||||
// u64, n, err := buf.GetVarInt64(0)
|
||||
// if err != nil {
|
||||
// log.Fatalf("bug: get base value: %s", err)
|
||||
// }
|
||||
// //fmt.Printf("baseValue: %.2f, bound: %d, pos: %d\n", float64(u64)/coef, n, size)
|
||||
// return &ReverseInstantDeltaDecompressor{
|
||||
// buf: buf,
|
||||
// coef: coef,
|
||||
// pos: size - 1, // last elem
|
||||
// baseValue: float64(u64) / coef,
|
||||
// bound: n,
|
||||
// }
|
||||
// }
|
||||
|
||||
// func (s *ReverseInstantDeltaDecompressor) NextValue() (value float64, done bool) {
|
||||
// //fmt.Printf("NextValue(): bound: %d, pos: %d, pending: %d\n", s.bound, s.pos, s.pending)
|
||||
// if s.pending > 0 {
|
||||
// // якщо в серії залишаються елементи
|
||||
// if !s.isRun {
|
||||
// s.readValue()
|
||||
// }
|
||||
// s.pending--
|
||||
// return s.lastValue, false
|
||||
// }
|
||||
// if s.pos > s.bound {
|
||||
// // читаю заголовок наступної серії
|
||||
// s.readHeader()
|
||||
// s.readValue()
|
||||
// s.pending--
|
||||
// return s.lastValue, false
|
||||
// }
|
||||
// // серія завершена - перевіряю чи є ще серії
|
||||
// return 0, true
|
||||
// }
|
||||
|
||||
// func (s *ReverseInstantDeltaDecompressor) readHeader() {
|
||||
// h := s.buf.GetByte(s.pos)
|
||||
// s.pos--
|
||||
// s.isRun = h < 128
|
||||
// if s.isRun {
|
||||
// s.pending = int(h&127) + 2
|
||||
// } else {
|
||||
// s.pending = int(h&127) + 1
|
||||
// }
|
||||
// // fmt.Println("h:", h)
|
||||
// // fmt.Println("isRun:", s.isRun)
|
||||
// // fmt.Println("pending:", s.pending)
|
||||
// }
|
||||
// func (s *ReverseInstantDeltaDecompressor) readValue() {
|
||||
// i64, n, err := s.buf.ReverseGetVarInt64(s.pos)
|
||||
// if err != nil {
|
||||
// log.Fatalln(err)
|
||||
// }
|
||||
// // fmt.Println()
|
||||
// // fmt.Println("read from pos:", s.pos)
|
||||
// // fmt.Println("read delta:", u64)
|
||||
// // fmt.Println("read delta n:", n)
|
||||
// // fmt.Println()
|
||||
// s.pos -= n
|
||||
// s.lastValue = s.baseValue + float64(i64)/s.coef
|
||||
// }
|
||||
|
||||
288
chunkenc/time_delta.go
Normal file
288
chunkenc/time_delta.go
Normal file
@@ -0,0 +1,288 @@
|
||||
package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"log"
|
||||
|
||||
"gordenko.dev/dima/pretty"
|
||||
"gordenko.dev/dima/qb/conbuf"
|
||||
)
|
||||
|
||||
type ReverseTimeDeltaCompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
lastUnixtime uint32
|
||||
lastDelta uint32
|
||||
lastDeltaSize int
|
||||
h byte
|
||||
}
|
||||
|
||||
func NewReverseTimeDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaCompressor {
|
||||
s := &ReverseTimeDeltaCompressor{
|
||||
buf: buf,
|
||||
pos: size, // перший вільний байт
|
||||
}
|
||||
if size > 0 {
|
||||
u64, n, err := s.buf.ReverseGetVarUint64(s.pos - 1)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last unixtime: %s", err)
|
||||
}
|
||||
s.lastUnixtime = uint32(u64)
|
||||
s.pos -= n
|
||||
if s.pos > 0 {
|
||||
s.h = s.buf.GetByte(s.pos - 1)
|
||||
u64, s.lastDeltaSize, err = s.buf.ReverseGetVarUint64(s.pos - 2)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last delta: %s", err)
|
||||
}
|
||||
s.lastDelta = uint32(u64)
|
||||
}
|
||||
}
|
||||
return s
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Size() int {
|
||||
return s.pos
|
||||
}
|
||||
|
||||
//func (s *ReverseTimeDeltaCompressor) CalcRequiredSpace(value float64) int {
|
||||
//}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Append(unixtime uint32) {
|
||||
if s.lastUnixtime > 0 {
|
||||
// base value
|
||||
//s.pos += s.buf.PutVarUint64(s.pos, uint64(value*s.coef))
|
||||
//s.baseValue = value
|
||||
//s.appendNewLiteral(0)
|
||||
|
||||
//} else {
|
||||
delta := unixtime - s.lastUnixtime
|
||||
if delta == s.lastDelta {
|
||||
if s.h < 128 {
|
||||
// run блок - отже треба збільшити лічильник
|
||||
if s.h < 127 {
|
||||
// increase counter
|
||||
s.h++
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
} else {
|
||||
// не можу збільшити - буде переповнення. Додаю новий literal блок
|
||||
// counter overflow
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
} else {
|
||||
// literal блок.
|
||||
// Якщо в ньому лише одне значення - перетворюю його на run блок.
|
||||
// Інакше забираю останнє значення із literal блока і додаю новий run блок.
|
||||
q := s.h & 127
|
||||
if q == 0 { // 1 кодується як 0
|
||||
s.convertLiteralToRun()
|
||||
} else {
|
||||
// забираю останнє значення із literal блоку щоб зробити run блок
|
||||
s.convertLastFromLiteralToRun()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if s.h < 127 { // fix 128?
|
||||
// end of run
|
||||
s.appendNewLiteral(delta)
|
||||
} else {
|
||||
if s.h < 255 {
|
||||
// encode value from pos - 1, then append h byte
|
||||
s.appendDeltaToLiteral(delta)
|
||||
} else {
|
||||
// overflowed - encode new
|
||||
s.appendNewLiteral(delta)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
s.lastUnixtime = unixtime
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) convertLastFromLiteralToRun() {
|
||||
// Зменшую кількість елементів в literal блоці
|
||||
s.h--
|
||||
s.pos -= 1 + s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h) // закриваю literal блок
|
||||
s.pos++
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, uint64(s.lastDelta))
|
||||
s.pos += s.lastDeltaSize
|
||||
s.h = 0 // run блок, довжини 2
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) convertLiteralToRun() {
|
||||
// Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||
s.h = 0
|
||||
s.buf.SetByte(s.pos-1, s.h)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) appendDeltaToLiteral(delta uint32) {
|
||||
s.h++ // збільшую к-сть дельт
|
||||
s.lastDelta = delta
|
||||
s.pos--
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, uint64(delta))
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, s.h)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) appendNewLiteral(delta uint32) {
|
||||
//fmt.Println("appendNewLiteral", delta)
|
||||
s.h = flagLiteral
|
||||
s.lastDelta = delta
|
||||
s.lastDeltaSize = s.buf.ReversePutVarUint64(s.pos, uint64(delta))
|
||||
s.pos += s.lastDeltaSize
|
||||
s.buf.SetByte(s.pos, flagLiteral) // literal, length = 1
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) DeleteLast() {
|
||||
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaCompressor) Sync() {
|
||||
s.pos += s.buf.ReversePutVarUint64(s.pos, uint64(s.lastUnixtime))
|
||||
}
|
||||
|
||||
type TimeDeltaBound struct {
|
||||
Pos int
|
||||
H byte
|
||||
LastUnixtime uint32
|
||||
LastDelta uint32
|
||||
}
|
||||
|
||||
// delta h
|
||||
func (s *ReverseTimeDeltaCompressor) GetState() TimeDeltaBound {
|
||||
bound := TimeDeltaBound{
|
||||
LastUnixtime: s.lastUnixtime,
|
||||
}
|
||||
if s.pos > 0 {
|
||||
bound.Pos = s.pos - 1 - s.lastDeltaSize
|
||||
bound.H = s.h
|
||||
bound.LastDelta = s.lastDelta
|
||||
}
|
||||
return bound
|
||||
}
|
||||
|
||||
// DECOMPRESSOR
|
||||
|
||||
type ReverseTimeDeltaDecompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
lastDelta uint32
|
||||
lastUnixtime uint32
|
||||
isRegular bool
|
||||
isRun bool
|
||||
pending int
|
||||
done bool
|
||||
}
|
||||
|
||||
func NewReverseTimeDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaDecompressor {
|
||||
return &ReverseTimeDeltaDecompressor{
|
||||
buf: buf,
|
||||
pos: size,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) RestoreFromEnd() {
|
||||
fmt.Println("RestoreFromEnd", s.pos)
|
||||
if s.pos > 0 {
|
||||
s.pos-- // перший байт даних
|
||||
u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
|
||||
if err != nil {
|
||||
log.Fatalf("bug: get last unixtime: %s", err)
|
||||
}
|
||||
s.lastUnixtime = uint32(u64)
|
||||
s.pos -= n
|
||||
fmt.Println("restored", s.lastUnixtime, s.pos)
|
||||
if s.pos > 0 {
|
||||
s.readHeader()
|
||||
s.readDelta()
|
||||
}
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) RestoreFromBound(bound TimeDeltaBound) {
|
||||
pretty.Println(bound)
|
||||
s.lastUnixtime = bound.LastUnixtime
|
||||
if bound.LastDelta > 0 {
|
||||
s.pos = bound.Pos - 1
|
||||
s.lastDelta = bound.LastDelta
|
||||
s.decodeHeaderByte(bound.H)
|
||||
} else {
|
||||
s.pos = -1
|
||||
}
|
||||
fmt.Printf("restore from bound: pos=%d, isRun=%t, pending=%d\n", s.pos, s.isRun, s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) NextValue() (value uint32, done bool) {
|
||||
//fmt.Printf("NextValue(): pos: %d, isRegular: %t, pending: %d\n", s.pos, s.isRegular, s.pending)
|
||||
if s.done {
|
||||
return 0, true
|
||||
}
|
||||
// повертаю значення, що було прочитано в методі RestoreFromBound/RestoreFromEnd
|
||||
value = s.lastUnixtime
|
||||
if s.isRegular {
|
||||
s.pending--
|
||||
if s.pending > 0 {
|
||||
// якщо в серії залишаються елементи
|
||||
if !s.isRun {
|
||||
s.readDelta()
|
||||
}
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else if s.pos > 0 {
|
||||
// в серії більше немає елементів, отже перевіряє чи є ще дані в буфері.
|
||||
// дані є - читаю заголовок наступної серії
|
||||
s.readHeader()
|
||||
s.readDelta()
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else {
|
||||
s.done = true
|
||||
}
|
||||
} else {
|
||||
if s.lastDelta > 0 {
|
||||
s.isRegular = true
|
||||
s.lastUnixtime -= s.lastDelta
|
||||
} else {
|
||||
// був закодований лише last unixtime
|
||||
s.done = true
|
||||
}
|
||||
}
|
||||
return value, false
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) readHeader() {
|
||||
h := s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
s.decodeHeaderByte(h)
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) decodeHeaderByte(h byte) {
|
||||
s.isRun = h < 128
|
||||
if s.isRun {
|
||||
s.pending = int(h&127) + 2
|
||||
} else {
|
||||
s.pending = int(h&127) + 1
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaDecompressor) readDelta() {
|
||||
u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
|
||||
if err != nil {
|
||||
log.Fatalln(err)
|
||||
}
|
||||
// fmt.Println()
|
||||
// fmt.Println("read from pos:", s.pos)
|
||||
// fmt.Println("read delta:", u64)
|
||||
// fmt.Println("read delta n:", n)
|
||||
// fmt.Println()
|
||||
s.pos -= n
|
||||
s.lastDelta = uint32(u64)
|
||||
}
|
||||
@@ -1,374 +1,270 @@
|
||||
package chunkenc
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
// // REVERSE
|
||||
|
||||
"gordenko.dev/dima/qb/bin"
|
||||
"gordenko.dev/dima/qb/conbuf"
|
||||
)
|
||||
// // const (
|
||||
// // lastUnixtimeIdx = 0
|
||||
// // baseDeltaIdx = 4
|
||||
// // )
|
||||
|
||||
// REVERSE
|
||||
// type ReverseTimeDeltaOfDeltaCompressor struct {
|
||||
// buf *conbuf.ContinuousBuffer
|
||||
// pos int
|
||||
// lastDelta uint32
|
||||
// lastUnixtime uint32
|
||||
// lastDeltaOfDelta int64
|
||||
// lastDeltaOfDeltaSize int
|
||||
// h byte
|
||||
// }
|
||||
|
||||
const (
|
||||
lastUnixtimeIdx = 0
|
||||
baseDeltaIdx = 4
|
||||
)
|
||||
// func NewReverseTimeDeltaOfDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaCompressor {
|
||||
// s := &ReverseTimeDeltaOfDeltaCompressor{
|
||||
// buf: buf,
|
||||
// pos: size,
|
||||
// }
|
||||
// if size > 0 {
|
||||
// // s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
|
||||
// // u64, _, err := s.buf.GetVarUint64(baseDeltaIdx)
|
||||
// // if err != nil {
|
||||
// // log.Fatalf("bug: get base delta: %s", err)
|
||||
// // }
|
||||
// // s.baseDelta = uint32(u64)
|
||||
// // s.h = s.buf.GetByte(s.pos - 1)
|
||||
// // s.lastDeltaOfDelta, s.lastDeltaOfDeltaSize, err = s.buf.ReverseGetVarInt64(s.pos - 2)
|
||||
// // if err != nil {
|
||||
// // log.Fatalf("bug: get last delta of delta: %s", err)
|
||||
// // }
|
||||
// } else {
|
||||
// //s.baseDelta = baseDelta
|
||||
// }
|
||||
// return s
|
||||
// }
|
||||
|
||||
type ReverseTimeDeltaOfDeltaCompressor struct {
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
baseDelta uint32
|
||||
lastUnixtime uint32
|
||||
lastDeltaOfDelta int64
|
||||
length uint16
|
||||
numIdx int
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) Size() int {
|
||||
// return s.pos
|
||||
// }
|
||||
|
||||
func NewReverseTimeDeltaOfDeltaCompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaCompressor {
|
||||
s := &ReverseTimeDeltaOfDeltaCompressor{
|
||||
buf: buf,
|
||||
pos: size,
|
||||
}
|
||||
if size > 0 {
|
||||
s.restoreState()
|
||||
}
|
||||
return s
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) Append(unixtime uint32) {
|
||||
// if s.lastUnixtime > 0 {
|
||||
// if s.pos == 0 {
|
||||
// // 2-й unixtime
|
||||
// s.lastDelta = unixtime - s.lastUnixtime
|
||||
// s.appendNewLiteral(0)
|
||||
// } else {
|
||||
// // 3-й unixtime і наступні
|
||||
// lastDelta := unixtime - s.lastUnixtime
|
||||
// deltaOfDelta := int64(lastDelta) - int64(s.lastDelta)
|
||||
// if deltaOfDelta == s.lastDeltaOfDelta {
|
||||
// if s.h < 128 {
|
||||
// // run блок - отже треба збільшити лічильник
|
||||
// if s.h < 127 {
|
||||
// // increase counter
|
||||
// s.h++
|
||||
// s.buf.SetByte(s.pos-1, s.h)
|
||||
// } else {
|
||||
// // не можу збільшити - буде переповнення. Додаю новий literal блок
|
||||
// // counter overflow
|
||||
// // fix encode delta
|
||||
// s.appendNewLiteral(deltaOfDelta)
|
||||
// }
|
||||
// } else {
|
||||
// // literal блок.
|
||||
// // Якщо в ньому лише одне значення - перетворюю його на run блок.
|
||||
// // Інакше забираю останнє значення із literal блока і додаю новий run блок.
|
||||
// q := s.h & 127
|
||||
// if q == 0 { // 1 кодується як 0
|
||||
// s.convertLiteralToRun()
|
||||
// } else {
|
||||
// s.convertLastFromLiteralToRun(deltaOfDelta)
|
||||
// }
|
||||
// }
|
||||
// } else {
|
||||
// s.lastDelta = lastDelta
|
||||
// if s.h < 127 {
|
||||
// // end of run
|
||||
// s.appendNewLiteral(deltaOfDelta)
|
||||
// } else {
|
||||
// if s.h < 255 {
|
||||
// // encode value from pos - 1, then append h byte
|
||||
// s.appendDeltaToLiteral(deltaOfDelta)
|
||||
// } else {
|
||||
// // overflowed - encode new
|
||||
// s.appendNewLiteral(deltaOfDelta)
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
// // для першого unixtime - лише оновлюємо lastUnixtime, а для наступних -
|
||||
// // теж оновлюємо, але після запису серій в buf.
|
||||
// s.lastUnixtime = unixtime
|
||||
// }
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) restoreState() {
|
||||
s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
|
||||
if s.pos > 4 {
|
||||
u64, _, err := s.buf.GetVarUint64(baseDeltaIdx)
|
||||
if err != nil {
|
||||
panic(fmt.Sprintf("bug: get base delta: %s", err))
|
||||
}
|
||||
s.baseDelta = uint32(u64)
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) convertLastFromLiteralToRun(deltaOfDelta int64) {
|
||||
// // Зменшую кількість елементів в literal блоці
|
||||
// s.h--
|
||||
// s.pos -= 1 + s.lastDeltaOfDeltaSize
|
||||
// s.buf.SetByte(s.pos, s.h) // закриваю literal блок
|
||||
// s.pos++
|
||||
// s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
|
||||
// s.pos += s.lastDeltaOfDeltaSize
|
||||
// s.h = 0 // run блок, довжини 2
|
||||
// s.buf.SetByte(s.pos, s.h)
|
||||
// s.pos++
|
||||
// }
|
||||
|
||||
pos := s.pos - 1
|
||||
idxOf8 := uint(8 - s.buf.GetByte(pos))
|
||||
pos--
|
||||
s8 := s.buf.GetByte(pos)
|
||||
pos--
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) convertLiteralToRun() {
|
||||
// // Знімаю flagLiteral, а лічильник 0 дорівнює 2 елементам в серії.
|
||||
// s.h = 0
|
||||
// s.buf.SetByte(s.pos-1, s.h)
|
||||
// }
|
||||
|
||||
var n int
|
||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
pos -= n
|
||||
s.numIdx = pos + 1
|
||||
var flag byte = 1 << idxOf8
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(pos)
|
||||
}
|
||||
}
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) appendDeltaToLiteral(deltaOfDelta int64) {
|
||||
// s.h++ // збільшую к-сть дельт
|
||||
// s.lastDeltaOfDelta = deltaOfDelta
|
||||
// s.pos--
|
||||
// s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
|
||||
// s.pos += s.lastDeltaOfDeltaSize
|
||||
// s.buf.SetByte(s.pos, s.h)
|
||||
// s.pos++
|
||||
// }
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) Size() int {
|
||||
return s.pos
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) appendNewLiteral(deltaOfDelta int64) {
|
||||
// s.h = flagLiteral
|
||||
// s.lastDeltaOfDelta = deltaOfDelta
|
||||
// s.lastDeltaOfDeltaSize = s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
|
||||
// s.pos += s.lastDeltaOfDeltaSize
|
||||
// s.buf.SetByte(s.pos, flagLiteral) // literal, length = 1
|
||||
// s.pos++
|
||||
// }
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) CalcRequiredSpace(unixtime uint32) int {
|
||||
if s.pos == 0 {
|
||||
return 4
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) Sync() {
|
||||
// // дописую в кінець lastDelta та lastUnixtime
|
||||
// if s.pos > 0 {
|
||||
// n := s.buf.ReversePutVarUint64(s.pos, uint64(s.lastDelta))
|
||||
// s.pos += n
|
||||
// }
|
||||
// if s.lastUnixtime > 0 {
|
||||
// s.buf.PutUint32(s.pos, s.lastUnixtime)
|
||||
// s.pos += 4
|
||||
// }
|
||||
// }
|
||||
|
||||
if s.baseDelta == 0 {
|
||||
baseDelta := unixtime - s.lastUnixtime
|
||||
n := bin.CalcVarUint64Length(uint64(baseDelta))
|
||||
return n + 3
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) DeleteLast() {
|
||||
|
||||
deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta)
|
||||
if deltaOfDelta == s.lastDeltaOfDelta {
|
||||
if s.length == 0 {
|
||||
return 1
|
||||
} else {
|
||||
newLength := s.length + 1
|
||||
if newLength < 130 {
|
||||
return 0
|
||||
} else if newLength == 130 {
|
||||
return 1
|
||||
} else {
|
||||
if newLength < 32769 {
|
||||
return 0
|
||||
} else {
|
||||
n := bin.CalcVarInt64Length(deltaOfDelta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
n := bin.CalcVarInt64Length(deltaOfDelta)
|
||||
n += 2
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
if s8q == 8 {
|
||||
n -= 1
|
||||
} else {
|
||||
n -= 2
|
||||
}
|
||||
return n
|
||||
}
|
||||
}
|
||||
// }
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) Append(unixtime uint32) {
|
||||
if s.pos == 0 {
|
||||
s.lastUnixtime = unixtime
|
||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
||||
s.pos += 4
|
||||
return
|
||||
}
|
||||
// type TimeDeltaOfDeltaBound struct {
|
||||
// LastUnixtime uint32
|
||||
// LastDelta uint32
|
||||
// Pos int
|
||||
// H byte
|
||||
// LastDeltaOfDelta int64
|
||||
// }
|
||||
|
||||
if s.baseDelta == 0 {
|
||||
s.baseDelta = unixtime - s.lastUnixtime
|
||||
s.lastDeltaOfDelta = 0
|
||||
s.lastUnixtime = unixtime
|
||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
||||
// func (s *ReverseTimeDeltaOfDeltaCompressor) GetState() TimeDeltaOfDeltaBound {
|
||||
// return TimeDeltaOfDeltaBound{
|
||||
// LastUnixtime: s.lastUnixtime,
|
||||
// LastDelta: s.lastDelta,
|
||||
// Pos: s.pos,
|
||||
// H: s.h,
|
||||
// LastDeltaOfDelta: s.lastDeltaOfDelta,
|
||||
// }
|
||||
// }
|
||||
|
||||
n := s.buf.PutVarUint64(s.pos, uint64(s.baseDelta))
|
||||
s.pos += n
|
||||
s.encodeNewDeltaOfDelta(0, 0, 1)
|
||||
return
|
||||
}
|
||||
// // DECOMPRESSOR
|
||||
|
||||
deltaOfDelta := int64(unixtime-s.lastUnixtime) - int64(s.baseDelta)
|
||||
s.lastUnixtime = unixtime
|
||||
s.buf.PutUint32(lastUnixtimeIdx, unixtime)
|
||||
// type ReverseTimeDeltaOfDeltaDecompressor struct {
|
||||
// buf *conbuf.ContinuousBuffer
|
||||
// size int
|
||||
// pos int
|
||||
// lastUnixtime uint32
|
||||
// lastDelta uint32
|
||||
// //lastDeltaOfDelta int64
|
||||
// isRun bool
|
||||
// pending int
|
||||
// }
|
||||
|
||||
if deltaOfDelta == s.lastDeltaOfDelta {
|
||||
if s.length == 0 {
|
||||
s.length = 2
|
||||
s.shiftOnePosToRight()
|
||||
s.buf.SetByte(s.numIdx-1, 0)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
s.buf.SetFlag(s.pos-2, 1<<(8-s8q))
|
||||
} else {
|
||||
s.length++
|
||||
if s.length < 130 {
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length-2))
|
||||
} else if s.length == 130 {
|
||||
s.shiftOnePosToRight()
|
||||
s.encode2bLength()
|
||||
} else {
|
||||
if s.length < 32769 {
|
||||
s.encode2bLength()
|
||||
} else {
|
||||
s.appendNewDeltaOfDelta(deltaOfDelta)
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.appendNewDeltaOfDelta(deltaOfDelta)
|
||||
}
|
||||
}
|
||||
// func NewReverseTimeDeltaOfDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaDecompressor {
|
||||
// return &ReverseTimeDeltaOfDeltaDecompressor{
|
||||
// buf: buf,
|
||||
// size: size,
|
||||
// pos: size, // last elem
|
||||
// }
|
||||
// }
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) appendNewDeltaOfDelta(deltaOfDelta int64) {
|
||||
s.length = 0
|
||||
s8 := s.buf.GetByte(s.pos - 2)
|
||||
s8q := s.buf.GetByte(s.pos - 1)
|
||||
// func (s *ReverseTimeDeltaOfDeltaDecompressor) NextValue() (value uint32, done bool) {
|
||||
// fmt.Printf("\nNextValue(): pos: %d, size: %d, pending: %d\n", s.pos, s.size, s.pending)
|
||||
// if s.pos < s.size {
|
||||
// if s.pending > 0 {
|
||||
// //fmt.Println("pending", )
|
||||
// // якщо в серії залишаються елементи
|
||||
// fmt.Println("s.lastUnixtime -= s.lastDelta", s.lastUnixtime, s.lastDelta)
|
||||
// s.lastUnixtime -= s.lastDelta
|
||||
// if !s.isRun {
|
||||
// s.readValue()
|
||||
// }
|
||||
// s.pending--
|
||||
// return s.lastUnixtime, false
|
||||
// }
|
||||
// // FIX - читаю lastUnixtime
|
||||
// if s.pos > 0 {
|
||||
// s.lastUnixtime -= s.lastDelta
|
||||
// // читаю заголовок наступної серії
|
||||
// s.readHeader()
|
||||
// s.readValue()
|
||||
// s.pending--
|
||||
// return s.lastUnixtime, false
|
||||
// }
|
||||
// // серія завершена - перевіряю чи є ще серії
|
||||
// return 0, true
|
||||
// } else {
|
||||
// s.pos -= 4
|
||||
// s.lastUnixtime = s.buf.GetUint32(s.pos)
|
||||
// fmt.Println("lastUnix", s.lastUnixtime)
|
||||
// if s.pos > 0 {
|
||||
// s.pos--
|
||||
// u64, n, err := s.buf.ReverseGetVarUint64(s.pos)
|
||||
// if err != nil {
|
||||
// log.Fatalln(err)
|
||||
// }
|
||||
// s.pos -= n
|
||||
// s.lastDelta = uint32(u64)
|
||||
// fmt.Println("lastDelta", s.lastDelta)
|
||||
// }
|
||||
// return s.lastUnixtime, false
|
||||
// }
|
||||
// }
|
||||
|
||||
if s8q == 8 {
|
||||
s.pos -= 1
|
||||
s8 = 0
|
||||
s8q = 1
|
||||
} else {
|
||||
s.pos -= 2
|
||||
s8q++
|
||||
}
|
||||
|
||||
s.encodeNewDeltaOfDelta(deltaOfDelta, s8, s8q)
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) encodeNewDeltaOfDelta(deltaOfDelta int64, s8 byte, s8q byte) {
|
||||
s.lastDeltaOfDelta = deltaOfDelta
|
||||
s.numIdx = s.pos
|
||||
n := s.buf.ReversePutVarInt64(s.pos, deltaOfDelta)
|
||||
s.pos += n
|
||||
s.buf.SetByte(s.pos, s8)
|
||||
s.pos++
|
||||
s.buf.SetByte(s.pos, s8q)
|
||||
s.pos++
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) shiftOnePosToRight() {
|
||||
s.buf.ShiftOnePosToRight(s.numIdx, s.pos)
|
||||
s.pos++
|
||||
s.numIdx++
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) encode2bLength() {
|
||||
num := s.length - 2
|
||||
s.buf.SetByte(s.numIdx-1, byte(num&127)|128)
|
||||
s.buf.SetByte(s.numIdx-2, byte(num>>7))
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaCompressor) DeleteLast() {
|
||||
var (
|
||||
s8q = s.buf.GetByte(s.pos - 1)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag byte = 1 << uint(8-s8q)
|
||||
)
|
||||
|
||||
if s.length > 0 {
|
||||
if s.length == 2 {
|
||||
s.length = 0
|
||||
s.buf.UnsetFlag(s.pos-2, flag)
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
} else if s.length < 130 {
|
||||
s.length--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else if s.length == 130 {
|
||||
s.length--
|
||||
s.buf.ShiftOnePosToLeft(s.numIdx, s.pos)
|
||||
s.numIdx--
|
||||
s.pos--
|
||||
s.buf.SetByte(s.numIdx-1, byte(s.length)-2)
|
||||
} else {
|
||||
s.length--
|
||||
s.encode2bLength()
|
||||
}
|
||||
} else {
|
||||
if s8q > 1 {
|
||||
s8q--
|
||||
flag = 1 << uint(8-s8q)
|
||||
s.pos = s.numIdx + 2
|
||||
s.buf.SetByte(s.pos-2, s8)
|
||||
s.buf.SetByte(s.pos-1, s8q)
|
||||
} else {
|
||||
s.pos = s.numIdx + 1
|
||||
s.buf.SetByte(s.pos-1, 8)
|
||||
s8 = s.buf.GetByte(s.pos - 2)
|
||||
flag = 1
|
||||
}
|
||||
var (
|
||||
pos = s.pos - 3
|
||||
n int
|
||||
err error
|
||||
)
|
||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s.numIdx = pos - n
|
||||
if (s8 & flag) == flag {
|
||||
s.length, _ = s.buf.DecodeRunLength(s.numIdx - 1)
|
||||
}
|
||||
}
|
||||
|
||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
||||
s.buf.PutUint32(lastUnixtimeIdx, s.lastUnixtime)
|
||||
}
|
||||
|
||||
type ReverseTimeDeltaOfDeltaDecompressor struct {
|
||||
step byte
|
||||
buf *conbuf.ContinuousBuffer
|
||||
pos int
|
||||
bound int
|
||||
lastUnixtime uint32
|
||||
baseDelta uint32
|
||||
lastDeltaOfDelta int64
|
||||
length uint16
|
||||
idxOf8 uint
|
||||
s8 byte
|
||||
}
|
||||
|
||||
func NewReverseTimeDeltaOfDeltaDecompressor(buf *conbuf.ContinuousBuffer, size int) *ReverseTimeDeltaOfDeltaDecompressor {
|
||||
return &ReverseTimeDeltaOfDeltaDecompressor{
|
||||
buf: buf,
|
||||
pos: size,
|
||||
}
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaDecompressor) NextValue() (value uint32, done bool) {
|
||||
if s.step == 0 {
|
||||
if s.pos == 0 {
|
||||
return 0, true
|
||||
}
|
||||
s.lastUnixtime = s.buf.GetUint32(lastUnixtimeIdx)
|
||||
s.step = 1
|
||||
return s.lastUnixtime, false
|
||||
}
|
||||
|
||||
if s.step == 1 {
|
||||
if s.pos == baseDeltaIdx {
|
||||
return 0, true
|
||||
}
|
||||
u64, n, err := s.buf.GetVarUint64(baseDeltaIdx)
|
||||
if err != nil {
|
||||
panic("EOF")
|
||||
}
|
||||
s.bound = baseDeltaIdx + n
|
||||
s.baseDelta = uint32(u64)
|
||||
|
||||
s.pos--
|
||||
s.idxOf8 = uint(8 - s.buf.GetByte(s.pos))
|
||||
s.pos--
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
s.step = 2
|
||||
return s.lastUnixtime, false
|
||||
}
|
||||
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
||||
return s.lastUnixtime, false
|
||||
}
|
||||
|
||||
if s.pos < s.bound {
|
||||
return 0, true
|
||||
}
|
||||
|
||||
if s.idxOf8 == 0 {
|
||||
s.s8 = s.buf.GetByte(s.pos)
|
||||
s.pos--
|
||||
}
|
||||
s.readVar()
|
||||
if s.length > 0 {
|
||||
s.length--
|
||||
}
|
||||
return s.lastUnixtime, false
|
||||
}
|
||||
|
||||
func (s *ReverseTimeDeltaOfDeltaDecompressor) readVar() {
|
||||
var (
|
||||
n int
|
||||
err error
|
||||
)
|
||||
|
||||
s.lastDeltaOfDelta, n, err = s.buf.ReverseGetVarInt64(s.pos)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
s.pos -= n
|
||||
|
||||
delta := int64(s.baseDelta) + s.lastDeltaOfDelta
|
||||
s.lastUnixtime = uint32(int64(s.lastUnixtime) - delta)
|
||||
|
||||
var flag byte = 1 << s.idxOf8
|
||||
if (s.s8 & flag) == flag {
|
||||
s.length, n = s.buf.DecodeRunLength(s.pos)
|
||||
s.pos -= n
|
||||
}
|
||||
if s.idxOf8 == 7 {
|
||||
s.idxOf8 = 0
|
||||
} else {
|
||||
s.idxOf8++
|
||||
}
|
||||
}
|
||||
// func (s *ReverseTimeDeltaOfDeltaDecompressor) readHeader() {
|
||||
// h := s.buf.GetByte(s.pos)
|
||||
// s.pos--
|
||||
// s.isRun = h < 128
|
||||
// if s.isRun {
|
||||
// s.pending = int(h&127) + 2
|
||||
// } else {
|
||||
// s.pending = int(h&127) + 1
|
||||
// }
|
||||
// fmt.Println("h:", h)
|
||||
// fmt.Println("isRun:", s.isRun)
|
||||
// fmt.Println("pending:", s.pending)
|
||||
// }
|
||||
// func (s *ReverseTimeDeltaOfDeltaDecompressor) readValue() {
|
||||
// //s.lastUnixtime -= s.lastDelta
|
||||
// // var (
|
||||
// // err error
|
||||
// // n int
|
||||
// // )
|
||||
// lastDeltaOfDelta, n, err := s.buf.ReverseGetVarInt64(s.pos)
|
||||
// if err != nil {
|
||||
// log.Fatalln(err)
|
||||
// }
|
||||
// fmt.Println()
|
||||
// fmt.Println("read Value from pos:", s.pos)
|
||||
// fmt.Println("delta of delta:", lastDeltaOfDelta)
|
||||
// //fmt.Println("delta of delta n:", n)
|
||||
// s.pos -= n
|
||||
// s.lastDelta = uint32(int64(s.lastDelta) - lastDeltaOfDelta)
|
||||
// fmt.Println("last delta:", s.lastDelta)
|
||||
// fmt.Println()
|
||||
// }
|
||||
|
||||
Reference in New Issue
Block a user