1st
This commit is contained in:
430
atree/io.go
Normal file
430
atree/io.go
Normal file
@@ -0,0 +1,430 @@
|
||||
package atree
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"hash/crc32"
|
||||
"io/fs"
|
||||
"math"
|
||||
"os"
|
||||
|
||||
diploma "gordenko.dev/dima/qb"
|
||||
"gordenko.dev/dima/qb/atree/redo"
|
||||
"gordenko.dev/dima/qb/bin"
|
||||
)
|
||||
|
||||
type AllocatedPage struct {
|
||||
PageNo uint32
|
||||
Data []byte
|
||||
IsReused bool
|
||||
}
|
||||
|
||||
type readResult struct {
|
||||
Data []byte
|
||||
Err error
|
||||
}
|
||||
|
||||
// INDEX PAGES
|
||||
|
||||
func (s *Atree) DeleteIndexPages(pageNumbers []uint32) {
|
||||
s.mutex.Lock()
|
||||
for _, pageNo := range pageNumbers {
|
||||
delete(s.indexPages, pageNo)
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
}
|
||||
|
||||
func (s *Atree) fetchIndexPage(pageNo uint32) ([]byte, error) {
|
||||
s.mutex.Lock()
|
||||
p, ok := s.indexPages[pageNo]
|
||||
if ok {
|
||||
p.ReferenceCount++
|
||||
s.mutex.Unlock()
|
||||
return p.Buf, nil
|
||||
}
|
||||
|
||||
resultCh := make(chan readResult, 1)
|
||||
s.indexWaits[pageNo] = append(s.indexWaits[pageNo], resultCh)
|
||||
if len(s.indexWaits[pageNo]) == 1 {
|
||||
s.indexPagesToRead = append(s.indexPagesToRead, pageNo)
|
||||
s.mutex.Unlock()
|
||||
|
||||
select {
|
||||
case s.readSignalCh <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
} else {
|
||||
s.mutex.Unlock()
|
||||
}
|
||||
|
||||
result := <-resultCh
|
||||
if result.Err == nil {
|
||||
result.Err = s.verifyCRC(result.Data, IndexPageSize)
|
||||
}
|
||||
return result.Data, result.Err
|
||||
}
|
||||
|
||||
func (s *Atree) releaseIndexPage(pageNo uint32) {
|
||||
s.mutex.Lock()
|
||||
defer s.mutex.Unlock()
|
||||
|
||||
p, ok := s.indexPages[pageNo]
|
||||
if ok {
|
||||
if p.ReferenceCount > 0 {
|
||||
p.ReferenceCount--
|
||||
return
|
||||
} else {
|
||||
diploma.Abort(
|
||||
diploma.ReferenceCountBug,
|
||||
fmt.Errorf("call releaseIndexPage on page %d with reference count = %d",
|
||||
pageNo, p.ReferenceCount),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Atree) allocIndexPage() AllocatedPage {
|
||||
var (
|
||||
allocated = AllocatedPage{
|
||||
Data: make([]byte, IndexPageSize),
|
||||
}
|
||||
)
|
||||
|
||||
allocated.PageNo = s.indexFreelist.ReservePage()
|
||||
if allocated.PageNo > 0 {
|
||||
allocated.IsReused = true
|
||||
|
||||
s.mutex.Lock()
|
||||
} else {
|
||||
s.mutex.Lock()
|
||||
if s.allocatedIndexPagesQty == math.MaxUint32 {
|
||||
diploma.Abort(diploma.MaxAtreeSizeExceeded,
|
||||
errors.New("no space in Atree index"))
|
||||
}
|
||||
s.allocatedIndexPagesQty++
|
||||
allocated.PageNo = s.allocatedIndexPagesQty
|
||||
}
|
||||
|
||||
s.indexPages[allocated.PageNo] = &_page{
|
||||
PageNo: allocated.PageNo,
|
||||
Buf: allocated.Data,
|
||||
ReferenceCount: 1,
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
return allocated
|
||||
}
|
||||
|
||||
// DATA PAGES
|
||||
|
||||
func (s *Atree) DeleteDataPages(pageNumbers []uint32) {
|
||||
s.mutex.Lock()
|
||||
for _, pageNo := range pageNumbers {
|
||||
delete(s.dataPages, pageNo)
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
}
|
||||
|
||||
func (s *Atree) fetchDataPage(pageNo uint32) ([]byte, error) {
|
||||
s.mutex.Lock()
|
||||
p, ok := s.dataPages[pageNo]
|
||||
if ok {
|
||||
p.ReferenceCount++
|
||||
s.mutex.Unlock()
|
||||
return p.Buf, nil
|
||||
}
|
||||
|
||||
resultCh := make(chan readResult, 1)
|
||||
s.dataWaits[pageNo] = append(s.dataWaits[pageNo], resultCh)
|
||||
if len(s.dataWaits[pageNo]) == 1 {
|
||||
s.dataPagesToRead = append(s.dataPagesToRead, pageNo)
|
||||
s.mutex.Unlock()
|
||||
|
||||
select {
|
||||
case s.readSignalCh <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
} else {
|
||||
s.mutex.Unlock()
|
||||
}
|
||||
result := <-resultCh
|
||||
if result.Err == nil {
|
||||
result.Err = s.verifyCRC(result.Data, DataPageSize)
|
||||
}
|
||||
return result.Data, result.Err
|
||||
}
|
||||
|
||||
func (s *Atree) releaseDataPage(pageNo uint32) {
|
||||
s.mutex.Lock()
|
||||
defer s.mutex.Unlock()
|
||||
|
||||
p, ok := s.dataPages[pageNo]
|
||||
if ok {
|
||||
if p.ReferenceCount > 0 {
|
||||
p.ReferenceCount--
|
||||
return
|
||||
} else {
|
||||
diploma.Abort(
|
||||
diploma.ReferenceCountBug,
|
||||
fmt.Errorf("call releaseDataPage on page %d with reference count = %d",
|
||||
pageNo, p.ReferenceCount),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Atree) allocDataPage() AllocatedPage {
|
||||
var (
|
||||
allocated = AllocatedPage{
|
||||
Data: make([]byte, DataPageSize),
|
||||
}
|
||||
)
|
||||
|
||||
allocated.PageNo = s.dataFreelist.ReservePage()
|
||||
if allocated.PageNo > 0 {
|
||||
allocated.IsReused = true
|
||||
s.mutex.Lock()
|
||||
} else {
|
||||
s.mutex.Lock()
|
||||
if s.allocatedDataPagesQty == math.MaxUint32 {
|
||||
diploma.Abort(diploma.MaxAtreeSizeExceeded,
|
||||
errors.New("no space in Atree index"))
|
||||
}
|
||||
s.allocatedDataPagesQty++
|
||||
allocated.PageNo = s.allocatedDataPagesQty
|
||||
}
|
||||
|
||||
s.dataPages[allocated.PageNo] = &_page{
|
||||
PageNo: allocated.PageNo,
|
||||
Buf: allocated.Data,
|
||||
ReferenceCount: 1,
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
return allocated
|
||||
}
|
||||
|
||||
// READ
|
||||
|
||||
func (s *Atree) pageReader() {
|
||||
for {
|
||||
select {
|
||||
case <-s.readSignalCh:
|
||||
s.readPages()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Atree) readPages() {
|
||||
s.mutex.Lock()
|
||||
if len(s.indexPagesToRead) == 0 && len(s.dataPagesToRead) == 0 {
|
||||
s.mutex.Unlock()
|
||||
return
|
||||
}
|
||||
indexPagesToRead := s.indexPagesToRead
|
||||
s.indexPagesToRead = nil
|
||||
dataPagesToRead := s.dataPagesToRead
|
||||
s.dataPagesToRead = nil
|
||||
s.mutex.Unlock()
|
||||
|
||||
for _, pageNo := range dataPagesToRead {
|
||||
buf := make([]byte, DataPageSize)
|
||||
off := (pageNo - 1) * DataPageSize
|
||||
n, err := s.dataFile.ReadAt(buf, int64(off))
|
||||
if n != DataPageSize {
|
||||
err = fmt.Errorf("read %d instead of %d", n, DataPageSize)
|
||||
}
|
||||
|
||||
s.mutex.Lock()
|
||||
resultChannels := s.dataWaits[pageNo]
|
||||
delete(s.dataWaits, pageNo)
|
||||
|
||||
if err != nil {
|
||||
s.mutex.Unlock()
|
||||
for _, resultCh := range resultChannels {
|
||||
resultCh <- readResult{
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.dataPages[pageNo] = &_page{
|
||||
PageNo: pageNo,
|
||||
Buf: buf,
|
||||
ReferenceCount: len(resultChannels),
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
for _, resultCh := range resultChannels {
|
||||
resultCh <- readResult{
|
||||
Data: buf,
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for _, pageNo := range indexPagesToRead {
|
||||
buf := make([]byte, IndexPageSize)
|
||||
off := (pageNo - 1) * IndexPageSize
|
||||
n, err := s.indexFile.ReadAt(buf, int64(off))
|
||||
if n != IndexPageSize {
|
||||
err = fmt.Errorf("read %d instead of %d", n, IndexPageSize)
|
||||
}
|
||||
|
||||
s.mutex.Lock()
|
||||
resultChannels := s.indexWaits[pageNo]
|
||||
delete(s.indexWaits, pageNo)
|
||||
|
||||
if err != nil {
|
||||
s.mutex.Unlock()
|
||||
for _, resultCh := range resultChannels {
|
||||
resultCh <- readResult{
|
||||
Err: err,
|
||||
}
|
||||
}
|
||||
} else {
|
||||
s.indexPages[pageNo] = &_page{
|
||||
PageNo: pageNo,
|
||||
Buf: buf,
|
||||
ReferenceCount: len(resultChannels),
|
||||
}
|
||||
s.mutex.Unlock()
|
||||
for _, resultCh := range resultChannels {
|
||||
resultCh <- readResult{
|
||||
Data: buf,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// WRITE
|
||||
|
||||
func (s *Atree) pageWriter() {
|
||||
for {
|
||||
select {
|
||||
case <-s.writeSignalCh:
|
||||
err := s.writeTasks()
|
||||
if err != nil {
|
||||
diploma.Abort(diploma.WriteToAtreeFailed, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type WriteTask struct {
|
||||
WaitCh chan struct{}
|
||||
DataPage redo.PageToWrite
|
||||
IndexPages []redo.PageToWrite
|
||||
}
|
||||
|
||||
func (s *Atree) appendWriteTaskToQueue(task WriteTask) {
|
||||
s.mutex.Lock()
|
||||
s.writeTasksQueue = append(s.writeTasksQueue, task)
|
||||
s.mutex.Unlock()
|
||||
|
||||
select {
|
||||
case s.writeSignalCh <- struct{}{}:
|
||||
default:
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Atree) writeTasks() error {
|
||||
s.mutex.Lock()
|
||||
tasks := s.writeTasksQueue
|
||||
s.writeTasksQueue = nil
|
||||
s.mutex.Unlock()
|
||||
|
||||
for _, task := range tasks {
|
||||
// data page
|
||||
p := task.DataPage
|
||||
if len(p.Data) != DataPageSize {
|
||||
return fmt.Errorf("wrong data page %d size: %d",
|
||||
p.PageNo, len(p.Data))
|
||||
}
|
||||
off := (p.PageNo - 1) * DataPageSize
|
||||
n, err := s.dataFile.WriteAt(p.Data, int64(off))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if n != len(p.Data) {
|
||||
return fmt.Errorf("write %d instead of %d", n, len(p.Data))
|
||||
}
|
||||
|
||||
// index pages
|
||||
for _, p := range task.IndexPages {
|
||||
if len(p.Data) != IndexPageSize {
|
||||
return fmt.Errorf("wrong index page %d size: %d",
|
||||
p.PageNo, len(p.Data))
|
||||
}
|
||||
bin.PutUint32(p.Data[indexCRC32Idx:], crc32.ChecksumIEEE(p.Data[:indexCRC32Idx]))
|
||||
|
||||
off := (p.PageNo - 1) * IndexPageSize
|
||||
n, err := s.indexFile.WriteAt(p.Data, int64(off))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if n != len(p.Data) {
|
||||
return fmt.Errorf("write %d instead of %d", n, len(p.Data))
|
||||
}
|
||||
}
|
||||
close(task.WaitCh)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// IO
|
||||
|
||||
func isFileExist(fileName string) (bool, error) {
|
||||
_, err := os.Stat(fileName)
|
||||
if err != nil {
|
||||
if errors.Is(err, fs.ErrNotExist) {
|
||||
return false, nil
|
||||
} else {
|
||||
return false, err
|
||||
}
|
||||
} else {
|
||||
return true, nil
|
||||
}
|
||||
}
|
||||
|
||||
func openFile(fileName string, pageSize int) (_ *os.File, _ uint32, err error) {
|
||||
file, err := os.OpenFile(fileName, os.O_RDWR, filePerm)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
fi, err := file.Stat()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
fileSize := fi.Size()
|
||||
|
||||
if (fileSize % int64(pageSize)) > 0 {
|
||||
err = fmt.Errorf("the file size %d is not a multiple of the page size %d",
|
||||
fileSize, pageSize)
|
||||
return
|
||||
}
|
||||
|
||||
allocatedPagesQty := fileSize / int64(pageSize)
|
||||
if allocatedPagesQty > math.MaxUint32 {
|
||||
err = fmt.Errorf("allocated pages %d is > max pages %d",
|
||||
allocatedPagesQty, math.MaxUint32)
|
||||
return
|
||||
}
|
||||
|
||||
return file, uint32(allocatedPagesQty), nil
|
||||
}
|
||||
|
||||
func (s *Atree) ApplyREDO(task WriteTask) {
|
||||
s.appendWriteTaskToQueue(task)
|
||||
}
|
||||
|
||||
func (s *Atree) verifyCRC(data []byte, pageSize int) error {
|
||||
var (
|
||||
pos = pageSize - 4
|
||||
calculatedCRC = crc32.ChecksumIEEE(data[:pos])
|
||||
storedCRC = bin.GetUint32(data[pos:])
|
||||
)
|
||||
if calculatedCRC != storedCRC {
|
||||
return fmt.Errorf("calculatedCRC %d not equal storedCRC %d",
|
||||
calculatedCRC, storedCRC)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user