289 lines
7.3 KiB
Go
289 lines
7.3 KiB
Go
|
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)
|
|||
|
|
}
|