coosld/ceremonyclient
1
0
Fork 0
mirror of https://github.com/QuilibriumNetwork/ceremonyclient.git synced 2026-02-21 10:27:26 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

adjustments

Browse Source
This commit is contained in:
Cassandra Heart 2025-01-21 04:39:04 -06:00
parent e896a0fb60
commit c54c42c0ed
No known key found for this signature in database
GPG Key ID: 6352152859385958
2 changed files with 67 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
crates/classgroup/build.rs
View File

@ -12,7 +12,6 @@ fn main() {
let target = env::var("TARGET").expect("cargo should have set this");
if target == "aarch64-apple-darwin" {
println!("cargo:rustc-link-search=/opt/homebrew/Cellar/gmp/6.3.0/lib");
println!("cargo:rustc-link-search=/opt/homebrew/Cellar/flint/3.1.3-p1/lib");
println!("cargo:rustc-link-search=/opt/homebrew/Cellar/mpfr/4.2.1/lib");
} else if target == "aarch64-unknown-linux-gnu" {
println!("cargo:rustc-link-search=/usr/lib/aarch64-linux-gnu/");
@ -25,11 +24,10 @@ fn main() {
cc::Build::new()
.cpp(true)
.file("src/vdf.cpp")
.static_flag(true)
.flag("-I/opt/homebrew/Cellar/gmp/6.3.0/include")
.flag("-I/opt/homebrew/Cellar/flint/3.1.3-p1/include")
.flag("-I/opt/homebrew/Cellar/mpfr/4.2.1/include")
.flag("-L/opt/homebrew/Cellar/gmp/6.3.0/lib")
.flag("-L/opt/homebrew/Cellar/flint/3.1.3-p1/lib")
.flag("-L/opt/homebrew/Cellar/mpfr/4.2.1/lib")
.flag("-lgmp")
.flag("-lflint")

173
node/main.go
View File

@ -198,134 +198,93 @@ func main() {
fmt.Println("Performing proof tree tests...")
fmt.Println("\nTree Insertion")
sets := []int{1000, 10000, 100000, 1000000, 10000000, 100000000}
sets := []int{1000, 10000, 100000, 1000000, 10000000}
if memory.TotalMemory() > 64*1024*1024*1024 {
sets = append(sets, 100000000)
}
for _, set := range sets {
for i := 1; i <= maxProcs; i *= 2 {
fmt.Println("Total Parallelism:", i)
var total atomic.Int64
wg := sync.WaitGroup{}
wg.Add(i)
for j := 0; j < i; j++ {
go func() {
defer wg.Done()
vecTree := &qcrypto.VectorCommitmentTree{}
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
start := time.Now()
err := vecTree.Insert(d, d)
total.Add(int64(time.Since(start)))
if err != nil {
panic(err)
}
}
}()
var total atomic.Int64
vecTree := &qcrypto.VectorCommitmentTree{}
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
start := time.Now()
err := vecTree.Insert(d, d)
total.Add(int64(time.Since(start)))
if err != nil {
panic(err)
}
wg.Wait()
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set)/time.Duration(i))
}
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set))
}
fmt.Println("\nTree Deletion")
for _, set := range sets {
for i := 1; i <= maxProcs; i *= 2 {
fmt.Println("Total Parallelism:", i)
var total atomic.Int64
wg := sync.WaitGroup{}
wg.Add(i)
for j := 0; j < i; j++ {
go func() {
defer wg.Done()
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
}
for k := 0; k < set; k++ {
start := time.Now()
err := vecTree.Delete(data[k])
total.Add(int64(time.Since(start)))
if err != nil {
panic(err)
}
}
}()
var total atomic.Int64
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
wg.Wait()
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set)/time.Duration(i))
}
for k := 0; k < set; k++ {
start := time.Now()
err := vecTree.Delete(data[k])
total.Add(int64(time.Since(start)))
if err != nil {
panic(err)
}
}
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set))
}
fmt.Println("\nTree Commit")
for _, set := range sets {
for i := 1; i <= maxProcs; i *= 2 {
fmt.Println("Total Parallelism:", i)
var total atomic.Int64
wg := sync.WaitGroup{}
wg.Add(i)
for j := 0; j < i; j++ {
go func() {
defer wg.Done()
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
}
start := time.Now()
vecTree.Commit()
total.Add(int64(time.Since(start)))
}()
var total atomic.Int64
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
wg.Wait()
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(i))
}
start := time.Now()
vecTree.Commit()
total.Add(int64(time.Since(start)))
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load()))
}
fmt.Println("\nTree Proof")
for _, set := range sets {
for i := 1; i <= maxProcs; i *= 2 {
fmt.Println("Total Parallelism:", i)
var total atomic.Int64
wg := sync.WaitGroup{}
wg.Add(i)
for j := 0; j < i; j++ {
go func() {
defer wg.Done()
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
}
vecTree.Commit()
for k := 0; k < set; k++ {
start := time.Now()
vecTree.Prove(data[k])
total.Add(int64(time.Since(start)))
}
}()
var total atomic.Int64
vecTree := &qcrypto.VectorCommitmentTree{}
data := make([][]byte, set)
for k := 0; k < set; k++ {
d := make([]byte, 32)
rand.Read(d)
data[k] = d
err := vecTree.Insert(d, d)
if err != nil {
panic(err)
}
wg.Wait()
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set)/time.Duration(i))
}
vecTree.Commit()
for k := 0; k < set; k++ {
start := time.Now()
vecTree.Prove(data[k])
total.Add(int64(time.Since(start)))
}
fmt.Println("Size: ", set, "Op Speed: ", time.Duration(total.Load())/time.Duration(set))
}
fmt.Println("\nVDF Prove")