func main() {
core.RegisterTypes()
flag.Parse()
db := core.ContinueDB(filepath.Join(*BaseDbPath, "balances"), *treapToken)
logtreap := new(verified.LogTreap)
logtreap.MakeOpaque()
ads.GetInfo(logtreap).Token = *treapToken
pagingC := core.NewPagingC(db)
pagingC.Load(ads.GetInfo(logtreap))
c := pagingC
c.Use(logtreap)
length := logtreap.Count(c)
hash := logtreap.Slice(0, length, c)
// this hash is what we commit to....
c.Use(hash)
tree := hash.Finish(c).(verified.LogTree)
c.Use(tree)
lastReturn := tree.Index(length-1, c)
c.Use(lastReturn)
balances := lastReturn.ArgsOrResults[0].(bitrie.Bitrie)
c.Use(balances)
// core.Dump(bitrie.Bits{}, balances, c)
fmt.Println(logtreap.Count(c))
fmt.Println(commitmentToBalances(hash, c))
n := 1000
sizes := make([]int, 0)
for i := 0; i < n; i++ {
sizes = append(sizes, randomBalance(balances, c))
}
sort.Ints(sizes)
fmt.Println(sizes)
sizes = make([]int, 0)
for i := 0; i < n; i++ {
j := rand.Intn(int(logtreap.Count(c) - 1))
hash := logtreap.Slice(0, int32(j+1), c)
sizes = append(sizes, nextstep(hash, c))
}
for i := 0; i < 20; i++ {
j := rand.Intn(int(logtreap.Count(c) - 5000 - 1))
for k := j; k < j+5000; k++ {
hash := logtreap.Slice(0, int32(k+1), c)
sizes = append(sizes, nextstep(hash, c))
}
}
sort.Ints(sizes)
fmt.Println(sizes)
}
func (c *PagingC) Store(info *ads.Info) int64 {
if info.Token != 0 {
return info.Token
}
buffer := ads.GetFromPool()
defer ads.ReturnToPool(buffer)
ads.Hash(info.Value)
buffer.Reset()
e := ads.Encoder{
Writer: buffer,
Transparent: map[ads.ADS]bool{info.Value: true},
}
e.Encode(&info.Value)
for _, root := range ads.CollectChildren(info.Value) {
info := ads.GetInfo(root)
c.Store(info)
var buffer [8]byte
binary.LittleEndian.PutUint64(buffer[:], uint64(info.Token))
if n, err := e.Write(buffer[:]); n != 8 || err != nil {
log.Panic(err)
}
}
info.Token = c.DB.Write(buffer.Bytes())
return info.Token
}
func (c *PagingC) MarkUsed(value ads.ADS, include bool) {
if value.IsOpaque() {
return
}
info := ads.GetInfo(value)
if info.Next != nil {
a, b := info.Prev, info.Next
a.Next = b
b.Prev = a
} else {
if !include {
return
} else {
for _, child := range ads.CollectChildren(value) {
c.MarkUsed(child, true)
}
}
c.Count++
}
a, b := c.Tail.Prev, c.Tail
a.Next = info
info.Prev = a
info.Next = b
b.Prev = info
}
func main() {
core.RegisterTypes()
transactions.RegisterTypes()
flag.Parse()
db := core.ContinueDB(filepath.Join(*BaseDbPath, "transactions"), *treapToken)
logtreap := new(verified.LogTreap)
logtreap.MakeOpaque()
ads.GetInfo(logtreap).Token = *treapToken
pagingC := core.NewPagingC(db)
pagingC.Load(ads.GetInfo(logtreap))
c := pagingC
c.Use(logtreap)
length := logtreap.Count(c)
hash := logtreap.Slice(0, length, c)
// this hash is what we commit to....
c.Use(hash)
tree := hash.Finish(c).(verified.LogTree)
c.Use(tree)
lastReturn := tree.Index(length-1, c)
c.Use(lastReturn)
transactions := lastReturn.ArgsOrResults[0].(bitrie.Bitrie)
c.Use(transactions)
fmt.Println(BitrieSize(transactions, c))
for i := 0; i < 100; i++ {
fmt.Println(core.RandomKey(bitrie.Bits{}, transactions, c))
}
}
func (c *PagingC) Use(values ...ads.ADS) {
for _, value := range values {
comp.Uses++
if value.IsOpaque() {
c.Loads++
info := ads.GetInfo(value)
c.Load(info)
}
c.MarkUsed(value, false)
}
}
func main() {
flag.Parse()
var mode = flag.Arg(0)
var f func(b *core.Block, c comp.C) bitrie.Bitrie
if mode == "balances" {
f = core.CalculateBalancesImpl
} else if mode == "transactions" {
f = transactions.CalculateTxnsImpl
} else {
log.Fatalf("Usage: buildbalances [balances|transactions]")
}
core.RegisterTypes()
transactions.RegisterTypes()
db := core.CreateDB(filepath.Join(*BaseDbPath, mode))
pagingC := core.NewPagingC(db)
file, err := os.Open(*BootstrapPath)
if err != nil {
log.Fatalf("couldn't open %v: %v\n", *BootstrapPath, err)
}
loader := NewLoader(file)
processed := int64(0)
processedNow := int64(0)
startNow := time.Now()
start := time.Now()
last := time.Now()
log.Println(ads.GetFuncId(f))
c := &verified.ProofC{
Outer: pagingC,
Stack: []*verified.LogTreap{nil},
ToCache: ads.GetFuncId(f),
}
var lastBlock *core.Block
c.Stack[0] = nil
c.Call(f, (*core.Block)(nil))
for i := 0; ; i++ {
b, err := loader.readBlock()
if err != nil {
log.Fatalf("couldn't read block: %v\n", err)
}
if b == nil {
break
}
block := core.MakeBlock(b, lastBlock)
// balances = ProcessBlock(block, balances, c)
c.Stack[0] = nil
c.Call(f, block)
//fmt.Printf("block: %v\n", i)
//dump(bitrie.Bits{}, balances)
// logtreap = verified.CombineTreap(logtreap, c.Stack[0], c)
logtreap := c.Stack[0]
// markUsed(&c.Log[0])
pagingC.Unload()
if i%100 == 0 {
// before we page logtreap, we must compute all seqhashes, or they'll be stored empty...
logtreap.SeqHash(c)
pagingC.MarkUsed(logtreap, true)
// dump(bitrie.Bits{}, balances)
//fmt.Printf("%v: %v\n", i, doCount(balances, c))
}
if i%1000 == 0 {
token := pagingC.Store(ads.GetInfo(logtreap))
log.Printf("after %d: %d\n", i, token)
if err := db.BufferedWriter.Flush(); err != nil {
log.Panic(err)
}
}
bytes, _ := b.Bytes()
processed += int64(len(bytes))
processedNow += int64(len(bytes))
now := time.Now()
if now.Sub(last) > time.Second {
last = now
log.Printf("block: %d\n", i)
nowSecs := int64(now.Sub(startNow) / time.Second)
secs := int64(now.Sub(start) / time.Second)
ops := int64(logtreap.Count(c)) / 2
log.Printf("count: %d\n", pagingC.Count)
log.Printf("processed % 8.2f MB, % 5.2f MB/sec\n", float64(processed)/1000/1000, float64(processed/secs)/1000/1000)
log.Printf("procesnow % 8.2f MB, % 5.2f MB/sec\n", float64(processedNow)/1000/1000, float64(processedNow/nowSecs)/1000/1000)
log.Printf("merges % 8.3fe6, % 5.3fe6 per sec\n", float64(seqhash.Calls)/1000/1000, float64(seqhash.Calls/secs)/1000/1000)
log.Printf("ops % 8.3fe6, % 5.3fe6 per sec\n", float64(ops)/1000/1000, float64(ops/secs)/1000/1000)
log.Printf("uses % 8.3fe6, % 5.3fe6 per sec\n", float64(comp.Uses)/1000/1000, float64(comp.Uses/secs)/1000/1000)
log.Printf("loads % 8.3fe6, % 5.3fe6 per sec\n", float64(pagingC.Loads)/1000/1000, float64(pagingC.Loads/secs)/1000/1000)
log.Printf("unloads % 8.3fe6, % 5.3fe6 per sec\n", float64(pagingC.Unloads)/1000/1000, float64(pagingC.Unloads/secs)/1000/1000)
log.Printf("loadtime %d unloadtime %d loaddisktime %d total %d", pagingC.LoadTime/time.Second, pagingC.UnloadTime/time.Second, pagingC.LoadDiskTime/time.Second, secs)
if nowSecs > 5 {
startNow = now
processedNow = 0
}
}
}
logtreap := c.Stack[0]
token := pagingC.Store(ads.GetInfo(logtreap))
log.Printf("final: %d\n", token)
if err := db.BufferedWriter.Flush(); err != nil {
log.Panic(err)
}
}