wp

2026-06-12 06:11:57 +00:00
parent dc0410c9e4
commit 58db58a0a0
14 changed files with 1305 additions and 1227 deletions
--- a/database/database.go
+++ b/database/database.go
@@ -288,67 +288,6 @@ func (s *Database) relayMetricsToMetrics(replayMetrics map[uint32]*ReplayMetric)
 	}
 }

-// FIX
-// УВАГА!
-// Якщо буфер metric.buffer < розміру сторінки - для timestamps доступний весь буфер.
-// Якщо буфер досяг розміру сторінки - в timestamps я передаю buffer[:DataPagePayloadSize]
-
-var dataBufferSizes = []int{
-	1024,
-	2048,
-	4096,
-	8192,
-}
-
-func calculateDataBufferSize(payloadSize int) int {
-	for _, bufferSize := range dataBufferSizes {
-		if payloadSize <= bufferSize {
-			return bufferSize
-		}
-	}
-	return storage.DataPageSize
-}
-
-func allocateBuffers(requiredSpace int) (buf, databuf []byte) {
-	bufferSize := calculateDataBufferSize(requiredSpace)
-	buf = make([]byte, bufferSize)
-	if bufferSize == storage.DataPageSize {
-		databuf = buf[:storage.DataPagePayloadSize]
-	} else {
-		databuf = buf
-	}
-	return
-}
-
-// src - databuf
-type growBuffersIn struct {
-	databuf       []byte
-	tSize         int
-	vSize         int
-	requiredSpace int
-}
-
-func growBuffers(in growBuffersIn) (buf, databuf []byte) {
-	buf, databuf = allocateBuffers(in.requiredSpace)
-	copy(databuf[len(databuf)-in.tSize:], in.databuf[len(in.databuf)-in.tSize:])
-	copy(databuf, in.databuf[:in.vSize])
-	return
-}
-
-type shrinkBufferIn struct {
-	Buffer         []byte
-	TimestampsSize int
-	ValuesSize     int
-	NewBufferSize  int
-}
-
-func shrinkBuffer(in shrinkBufferIn) []byte {
-	buf := make([]byte, in.NewBufferSize)
-	copy(buf, in.Buffer[:in.ValuesSize])
-	copy(buf[:len(buf)-in.TimestampsSize], in.Buffer[len(in.Buffer)-in.TimestampsSize:])
-	return buf
-}
-
 //func (s *Database) verifySnapshot(fileName string) (_ bool, err error) {
 // 	file, err := os.Open(fileName)
 // 	if err != nil {
--- a/database/metric.go
+++ b/database/metric.go
@@ -10,7 +10,7 @@ import (

 // METRIC

-const minBufferSize = 1024
+//const minBufferSize = 1024

 var (
 	indexRecordSize = 8
@@ -79,29 +79,31 @@ func (s *_metric) StartAppendMeasures(req tryAppendMeasuresReq, tmp []byte, send
 		timestampsOffset int
 		valuesOffset     int

+		headTimestamps []byte
+		headValues     []byte
+
 		written    int
 		resultCode byte
 	)

 	s.capturedState = &CapturedState{
 		//
-		TimeState:  s.timestamps.CaptureState(),
-		ValueState: s.values.CaptureState(),
+
 	}

+	s.timestamps.CaptureState()
+	s.values.CaptureState()
+
 	for idx, measure := range req.Measures {
 		if measure.Timestamp <= s.timestamps.LastTimestamp() {
 			resultCode = ExpiredMeasure
 			break
 		}
-
 		if s.metricType == qb.Cumulative && measure.Value < s.lastValue {
 			resultCode = NonMonotonicValue
 			break
 		}

-		// fix - 1 + 8 bytes
-
 		tReport := timestamps.Evaluate(tmp, measure.Timestamp)
 		vReport := values.Evaluate(tmp, measure.Value)

@@ -114,48 +116,33 @@ func (s *_metric) StartAppendMeasures(req tryAppendMeasuresReq, tmp []byte, send
 				valuesOffset = vReport.Offset
 			}
 		} else {
-			if len(s.buffer) < storage.DataPageSize {
-				// allocate bigger buffer
-				buf, databuf := growBuffers(growBuffersIn{
-					databuf:       s.buffer,
-					tSize:         timestamps.Size(),
-					vSize:         values.Size(),
-					requiredSpace: totalRequiredSpace,
-				})
+			// сторінка заповнена
+			since := s.timestamps.ReplaceSinceWithUntil()

-				s.buffer = buf
-				// replace buffer in timestamps and values
-				timestamps.Rotate(databuf) // fix pos
-				values.Rotate(databuf)     // fix pos
-			} else {
-				// сторінка заповнена
-				since := s.timestamps.ReplaceSinceWithUntil()
-
-				if len(s.capturedState.Pages) == 0 {
-					// head page FIX
-					// timestampsPayload =
-					// valuesPayload =
-				}
-
-				s.capturedState.Pages = append(s.capturedState.Pages, storage.DataPayload{
-					Since:          since,
-					Content:        s.buffer,
-					TimestampsSize: timestamps.Size(),
-					ValuesSize:     values.Size(),
-				})
-
-				buffer := make([]byte, minBufferSize)
-
-				timestamps.Rotate(buffer)
-				values.Rotate(buffer)
-
-				// renew
-				s.buffer = buffer
+			if len(s.capturedState.Pages) == 0 {
+				headTimestamps = timestamps.Tail(timestampsOffset)
+				headValues = values.Tail(valuesOffset)
 			}
+
+			s.capturedState.Pages = append(s.capturedState.Pages, storage.DataPayload{
+				Since:          since,
+				Content:        s.buffer,
+				TimestampsSize: timestamps.Size(),
+				ValuesSize:     values.Size(),
+			})
+
+			buf := make([]byte, storage.DataPageSize)
+			databuf := buf[:storage.DataPagePayloadSize]
+
+			timestamps.ReplaceBuffer(databuf)
+			values.ReplaceBuffer(databuf)
+
+			// renew
+			s.buffer = buf
 		}

-		timestamps.Append(tReport.Offset, tmp[:tReport.ChangeSize], measure.Timestamp)
-		values.Append(vReport.Offset, tmp[7:7+vReport.ChangeSize], measure.Value, vReport.Delta)
+		timestamps.Append(tReport.RewindOffset, tmp[:tReport.ChangeSize], measure.Timestamp)
+		values.Append(vReport.RewindOffset, tmp[7:7+vReport.ChangeSize], measure.Value, vReport.Delta)
 		//
 		s.lastValue = measure.Value
 		written++
@@ -173,39 +160,33 @@ func (s *_metric) StartAppendMeasures(req tryAppendMeasuresReq, tmp []byte, send
 	// скопіювати. Причому можна скопіювати зрізи chunks

 	if len(s.capturedState.Pages) > 0 {
-		head := s.capturedState.Pages[0]
-		databuf := head.Content[:storage.DataPagePayloadSize]
 		// пишу в storage довгим шляхом через redo файл і запис в data файл
 		sendToStorage(storage.AppendedMeasures{
 			MetricID:         req.MetricID,
 			LastPageNo:       s.lastPageNo,
 			TimestampsOffset: timestampsOffset,
-			Timestamps:       databuf[len(databuf)-head.TimestampsSize : len(databuf)-timestampsOffset],
+			Timestamps:       headTimestamps,
 			ValuesOffset:     valuesOffset,
-			Values:           databuf[valuesOffset:head.ValuesSize],
+			Values:           headValues,
 			IndexLevelTails:  s.indexLevelTails,
 			DataPages:        s.capturedState.Pages,
-			TailTimestamps:   nil, // payload
-			TailValues:       s.buffer[:values.Size()],
+			TailTimestamps:   timestamps.Tail(0), // payload
+			TailValues:       values.Tail(0),
 			ResultCode:       resultCode,
 			WrittenCount:     written,
-			ResultCh:         nil,
+			//ResultCh:         req.ResultCh,
 		})
 	} else {
-		databuf := s.buffer
-		if len(s.buffer) == storage.DataPageSize {
-			databuf = s.buffer[:storage.DataPagePayloadSize]
-		}
 		// короткий шлях - запис лише в storage
 		sendToStorage(storage.AppendedMeasures{
 			MetricID:         req.MetricID,
 			TimestampsOffset: timestampsOffset,
 			ValuesOffset:     valuesOffset,
-			Timestamps:       databuf[len(databuf)-timestamps.Size() : len(databuf)-timestampsOffset],
-			Values:           databuf[valuesOffset:values.Size()],
+			Timestamps:       timestamps.Tail(timestampsOffset),
+			Values:           values.Tail(valuesOffset),
 			ResultCode:       resultCode,
 			WrittenCount:     written,
-			ResultCh:         nil,
+			//ResultCh:         req.ResultCh,
 		})
 	}

--- a/database/proc.go
+++ b/database/proc.go
@@ -472,14 +472,15 @@ func (s *Database) applyAddMetric(rec storage.MetricAddRecord) {

 func (s *Database) addMetric(rec storage.MetricAddRecord) {
 	var (
-		buffer = make([]byte, minBufferSize)
+		buf     = make([]byte, storage.DataPageSize)
+		databuf = buf[:storage.DataPagePayloadSize]
 	)
 	s.metrics[rec.MetricID] = &_metric{
 		metricType: rec.MetricType,
-		fracDigits: byte(rec.FracDigits),
-		buffer:     buffer,
-		timestamps: enc.NewTimeDeltaCompressor(buffer, 0),
-		values:     enc.NewValueDeltaCompressor(rec.MetricType, byte(rec.FracDigits), buffer, 0),
+		fracDigits: rec.FracDigits,
+		buffer:     buf,
+		timestamps: enc.NewTimeDeltaCompressor(databuf, 0),
+		values:     enc.NewValueDeltaCompressor(rec.MetricType, rec.FracDigits, databuf, 0),
 	}
 }

--- a/database/replay_metric.go
+++ b/database/replay_metric.go
@@ -271,57 +271,17 @@ func composeHeadDataPage(databuf []byte, head storage.HeadDataPage) storage.Page
 }

 func (s *ReplayMetric) ToMetric() *_metric {
-	var (
-		requiredSpace = s.tSize + s.vSize
-	)
-	bufferSize := calculateDataBufferSize(requiredSpace)
-	if len(s.buf) > bufferSize {
-		s.buf = shrinkBuffer(shrinkBufferIn{
-			Buffer:         s.buf,
-			TimestampsSize: s.tSize,
-			ValuesSize:     s.vSize,
-			NewBufferSize:  bufferSize,
-		})
-	}
-	values := enc.NewValueDeltaCompressor(s.metricType, s.fracDigits, s.buf, s.vSize)
+
+	databuf := s.buf[:storage.DataPagePayloadSize]
+	values := enc.NewValueDeltaCompressor(s.metricType, s.fracDigits, databuf, s.vSize)
 	return &_metric{
 		metricType:      s.metricType,
 		fracDigits:      s.fracDigits,
 		lastPageNo:      s.lastPageNo,
 		lastValue:       values.LastValue(),
 		buffer:          s.buf,
-		timestamps:      enc.NewTimeDeltaCompressor(s.buf, s.tSize),
+		timestamps:      enc.NewTimeDeltaCompressor(databuf, s.tSize),
 		values:          values,
 		indexLevelTails: s.indexLevelTails,
 	}
 }
-
-// func (s *ReplayMetric) ApplyHeadDataPage(p storage.HeadDataPage) {
-// 	// буфер має бути розміру сторінки
-// 	if len(s.buf) != atree.DataPageSize {
-// 		s.buf, s.databuf = growBuffers(growBuffersIn{
-// 			databuf:       s.databuf,
-// 			tSize:         s.tSize,
-// 			vSize:         s.vSize,
-// 			requiredSpace: atree.DataPageSize,
-// 		})
-// 	}
-// 	// дописую дані по зміщенню
-// 	pos := len(s.databuf) - p.TimestampsOffset - len(p.Timestamps)
-// 	copy(s.databuf[pos:], p.Timestamps)
-// 	copy(s.databuf[p.ValuesOffset:], p.Values)
-// 	//
-// 	s.tSize = p.TimestampsOffset + len(p.Timestamps)
-// 	s.tSize = p.ValuesOffset + len(p.Values)
-
-// 	// fix - заполнить страницу
-// 	// fix - check checksum
-// }
-
-// func (s *ReplayMetric) ApplyHeadIndexPages(changedIndexLevels storage.ChangedIndexLevel) {
-// 	for levelIdx, changedLevel := range changedIndexLevels {
-//
-
-//
-// 	}
-// }
--- a/database/tmp
+++ b/database/tmp
@@ -0,0 +1,93 @@
+// IN APPEND MEASURES
+// if len(s.buffer) < storage.DataPageSize {
+// 	// allocate bigger buffer
+// 	buf, databuf := growBuffers(growBuffersIn{
+// 		databuf:       s.buffer,
+// 		tSize:         timestamps.Size(),
+// 		vSize:         values.Size(),
+// 		requiredSpace: totalRequiredSpace,
+// 	})
+
+// 	s.buffer = buf
+// 	// replace buffer in timestamps and values
+// 	timestamps.Rotate(databuf) // fix pos
+// 	values.Rotate(databuf)     // fix pos
+// } else {
+
+// IN DATABASE
+
+// FIX
+// УВАГА!
+// Якщо буфер metric.buffer < розміру сторінки - для timestamps доступний весь буфер.
+// Якщо буфер досяг розміру сторінки - в timestamps я передаю buffer[:DataPagePayloadSize]
+
+// var dataBufferSizes = []int{
+// 	1024,
+// 	2048,
+// 	4096,
+// 	8192,
+// }
+
+// func calculateDataBufferSize(payloadSize int) int {
+// 	for _, bufferSize := range dataBufferSizes {
+// 		if payloadSize <= bufferSize {
+// 			return bufferSize
+// 		}
+// 	}
+// 	return storage.DataPageSize
+// }
+
+// func allocateBuffers(requiredSpace int) (buf, databuf []byte) {
+// 	bufferSize := calculateDataBufferSize(requiredSpace)
+// 	buf = make([]byte, bufferSize)
+// 	if bufferSize == storage.DataPageSize {
+// 		databuf = buf[:storage.DataPagePayloadSize]
+// 	} else {
+// 		databuf = buf
+// 	}
+// 	return
+// }
+
+// // src - databuf
+// type growBuffersIn struct {
+// 	databuf       []byte
+// 	tSize         int
+// 	vSize         int
+// 	requiredSpace int
+// }
+
+// func growBuffers(in growBuffersIn) (buf, databuf []byte) {
+// 	buf, databuf = allocateBuffers(in.requiredSpace)
+// 	copy(databuf[len(databuf)-in.tSize:], in.databuf[len(in.databuf)-in.tSize:])
+// 	copy(databuf, in.databuf[:in.vSize])
+// 	return
+// }
+
+// type shrinkBufferIn struct {
+// 	Buffer         []byte
+// 	TimestampsSize int
+// 	ValuesSize     int
+// 	NewBufferSize  int
+// }
+
+// func shrinkBuffer(in shrinkBufferIn) []byte {
+// 	buf := make([]byte, in.NewBufferSize)
+// 	copy(buf, in.Buffer[:in.ValuesSize])
+// 	copy(buf[:len(buf)-in.TimestampsSize], in.Buffer[len(in.Buffer)-in.TimestampsSize:])
+// 	return buf
+// }
+
+// IN REPLAY_METRIC.TO_METRIC
+
+// var (
+// 	requiredSpace = s.tSize + s.vSize
+// )
+// bufferSize := calculateDataBufferSize(requiredSpace)
+// if len(s.buf) > bufferSize {
+// 	s.buf = shrinkBuffer(shrinkBufferIn{
+// 		Buffer:         s.buf,
+// 		TimestampsSize: s.tSize,
+// 		ValuesSize:     s.vSize,
+// 		NewBufferSize:  bufferSize,
+// 	})
+// }