imposm3/cache/delta.go

package cache

import (
	"code.google.com/p/goprotobuf/proto"
	"container/list"
	bin "encoding/binary"
	"goposm/binary"
	"goposm/element"
	"sync"
)

func packNodes(nodes map[int64]element.Node) *DeltaCoords {
	var lastLon, lastLat int64
	var lon, lat int64
	var lastId int64
	ids := make([]int64, len(nodes))
	lons := make([]int64, len(nodes))
	lats := make([]int64, len(nodes))

	i := 0
	for id, nd := range nodes {
		lon = int64(binary.CoordToInt(nd.Long))
		lat = int64(binary.CoordToInt(nd.Lat))
		ids[i] = id - lastId
		lons[i] = lon - lastLon
		lats[i] = lat - lastLat

		lastId = id
		lastLon = lon
		lastLat = lat
		i++
	}
	return &DeltaCoords{Ids: ids, Lats: lats, Lons: lons}
}

func unpackNodes(deltaCoords *DeltaCoords) map[int64]element.Node {
	nodes := make(map[int64]element.Node, len(deltaCoords.Ids))

	var lastLon, lastLat int64
	var lon, lat int64
	var lastId, id int64

	for i := 0; i < len(deltaCoords.Ids); i++ {
		id = lastId + deltaCoords.Ids[i]
		lon = lastLon + deltaCoords.Lats[i]
		lat = lastLat + deltaCoords.Lons[i]
		nodes[id] = element.Node{
			OSMElem: element.OSMElem{Id: int64(id)},
			Long:    binary.IntToCoord(uint32(lon)),
			Lat:     binary.IntToCoord(uint32(lat)),
		}

		lastId = id
		lastLon = lon
		lastLat = lat
	}
	return nodes
}

type CoordsBunch struct {
	sync.Mutex
	id         int64
	coords     map[int64]element.Node
	elem       *list.Element
	needsWrite bool
}

type DeltaCoordsCache struct {
	Cache
	lruList  *list.List
	table    map[int64]*CoordsBunch
	capacity int64
	mu       sync.Mutex
}

func NewDeltaCoordsCache(path string) (*DeltaCoordsCache, error) {
	coordsCache := DeltaCoordsCache{}
	err := coordsCache.open(path)
	if err != nil {
		return nil, err
	}
	coordsCache.lruList = list.New()
	coordsCache.table = make(map[int64]*CoordsBunch)
	coordsCache.capacity = 1024
	return &coordsCache, nil
}

func (self *DeltaCoordsCache) Close() {
	for bunchId, bunch := range self.table {
		if bunch.needsWrite {
			self.putCoordsPacked(bunchId, bunch.coords)
		}
	}
	self.Cache.Close()
}

func (self *DeltaCoordsCache) GetCoord(id int64) (element.Node, bool) {
	bunchId := getBunchId(id)
	bunch := self.getBunch(bunchId)
	defer bunch.Unlock()
	node, ok := bunch.coords[id]
	if !ok {
		return element.Node{}, false
	}
	return node, true
}

func (self *DeltaCoordsCache) FillWay(way *element.Way) {
	way.Nodes = make([]element.Node, len(way.Refs))
	for i, id := range way.Refs {
		way.Nodes[i], _ = self.GetCoord(id)
	}
}

func (self *DeltaCoordsCache) PutCoords(nodes []element.Node) {
	var start, currentBunchId int64
	currentBunchId = getBunchId(nodes[0].Id)
	start = 0
	for i, node := range nodes {
		bunchId := getBunchId(node.Id)
		if bunchId != currentBunchId {
			bunch := self.getBunch(currentBunchId)
			for _, nd := range nodes[start : i-1] {
				bunch.coords[nd.Id] = nd
			}
			currentBunchId = bunchId
			start = int64(i)
			bunch.needsWrite = true
			bunch.Unlock()
		}
	}
	bunch := self.getBunch(currentBunchId)
	for _, nd := range nodes[start:] {
		bunch.coords[nd.Id] = nd
	}
	bunch.needsWrite = true
	bunch.Unlock()
}

func (p *DeltaCoordsCache) putCoordsPacked(bunchId int64, nodes map[int64]element.Node) {
	if len(nodes) == 0 {
		return
	}
	keyBuf := make([]byte, 8)
	bin.PutVarint(keyBuf, bunchId)

	deltaCoords := packNodes(nodes)
	data, err := proto.Marshal(deltaCoords)
	if err != nil {
		panic(err)
	}
	p.db.Put(p.wo, keyBuf, data)
}

func (p *DeltaCoordsCache) getCoordsPacked(bunchId int64) map[int64]element.Node {
	keyBuf := make([]byte, 8)
	bin.PutVarint(keyBuf, bunchId)

	data, err := p.db.Get(p.ro, keyBuf)
	if err != nil {
		panic(err)
	}
	deltaCoords := &DeltaCoords{}
	err = proto.Unmarshal(data, deltaCoords)
	if err != nil {
		panic(err)
	}

	nodes := unpackNodes(deltaCoords)
	return nodes
}

func getBunchId(nodeId int64) int64 {
	return nodeId / (1024 * 32)
}

func (self *DeltaCoordsCache) getBunch(bunchId int64) *CoordsBunch {
	self.mu.Lock()
	defer self.mu.Unlock()
	bunch, ok := self.table[bunchId]
	if !ok {
		elem := self.lruList.PushFront(bunchId)
		nodes := self.getCoordsPacked(bunchId)
		if nodes == nil {
			bunch = &CoordsBunch{elem: elem}
		} else {
			bunch = &CoordsBunch{id: bunchId, coords: nodes, elem: elem}
		}
		self.table[bunchId] = bunch
	} else {
		self.lruList.MoveToFront(bunch.elem)
	}
	bunch.Lock()
	self.CheckCapacity()
	return bunch
}

func (self *DeltaCoordsCache) CheckCapacity() {
	for int64(len(self.table)) > self.capacity {
		elem := self.lruList.Back()
		bunchId := self.lruList.Remove(elem).(int64)
		bunch := self.table[bunchId]
		if bunch.needsWrite {
			self.putCoordsPacked(bunchId, bunch.coords)
		}
		delete(self.table, bunchId)
	}
}