112 lines
2.2 KiB
Go
112 lines
2.2 KiB
Go
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"fmt"
|
|
"io"
|
|
"math/big"
|
|
mrand "math/rand"
|
|
"runtime"
|
|
"time"
|
|
)
|
|
|
|
type job struct {
|
|
p *big.Int // Number to check
|
|
i int // Iterations
|
|
result bool
|
|
id int
|
|
}
|
|
|
|
func main() {
|
|
runtime.GOMAXPROCS(101)
|
|
s1 := mrand.NewSource(time.Now().UnixMicro())
|
|
r1 := mrand.New(s1)
|
|
start := time.Now()
|
|
|
|
p, _ := prime(r1, 8096, 100)
|
|
|
|
finish := time.Now()
|
|
elapsed := finish.Sub(start)
|
|
fmt.Printf("p: %v\n", p)
|
|
fmt.Printf("That took: %dms\n", elapsed.Milliseconds())
|
|
|
|
start = time.Now()
|
|
p2, _ := rand.Prime(r1, 8096)
|
|
finish = time.Now()
|
|
elapsed = finish.Sub(start)
|
|
fmt.Printf("p2: %v\n", p2)
|
|
fmt.Printf("Normal generation took: %dms\n", elapsed.Milliseconds())
|
|
|
|
}
|
|
|
|
func prime(rand io.Reader, bits int, threads int) (p *big.Int, err error) {
|
|
//bytes := make([]byte, (bits+7)/8)
|
|
|
|
//p = new(big.Int)
|
|
jobs := make(chan job, 100)
|
|
results := make(chan job, 100)
|
|
numbers := make(chan *big.Int, 100)
|
|
done := new(bool)
|
|
*done = false
|
|
|
|
for i := 0; i < threads; i++ {
|
|
go worker(i, jobs, results, done)
|
|
}
|
|
|
|
fmt.Printf("Seeding and starting worker pool\n")
|
|
for i := 0; i < 10; i++ {
|
|
go rng(i, bits, numbers, done)
|
|
time.Sleep(1 * time.Millisecond)
|
|
}
|
|
|
|
fmt.Printf("Starting!\n")
|
|
for i := 0; ; i++ {
|
|
newjob := &job{
|
|
p: <-numbers,
|
|
i: 20,
|
|
id: i,
|
|
}
|
|
|
|
jobs <- *newjob
|
|
|
|
r := <-results
|
|
if r.result {
|
|
fmt.Printf("Found one, closing the channel and returning\n")
|
|
close(jobs)
|
|
*done = true
|
|
close(results)
|
|
return r.p, nil
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
func rng(id int, bits int, num chan<- *big.Int, done *bool) {
|
|
s1 := mrand.NewSource(time.Hour.Microseconds())
|
|
rand := mrand.New(s1)
|
|
bytes := make([]byte, (bits+7)/8)
|
|
for !*done {
|
|
p := new(big.Int)
|
|
io.ReadFull(rand, bytes)
|
|
// This makes sure that the least significant bit is always 1
|
|
// meaning that the number is always odd, since even numbers
|
|
// aren't prime
|
|
bytes[len(bytes)-1] |= 1
|
|
|
|
p.SetBytes(bytes)
|
|
num <- p
|
|
}
|
|
}
|
|
|
|
func worker(id int, jobs <-chan job, results chan<- job, done *bool) {
|
|
//fmt.Printf("Worker %d starting now!\n", id)
|
|
for j := range jobs {
|
|
j.result = j.p.ProbablyPrime(j.i)
|
|
fmt.Printf("Worker\t %d checked a number\n", id)
|
|
if *done {
|
|
return
|
|
}
|
|
results <- j
|
|
}
|
|
}
|