[big.Integer] slow operations div and mod

[sibkod]

module main

import time
import math.big

fn main() {
	iterations := 1000000
	a := big.integer_from_string('115792089237316195423570985008687907853269984665640564039457584007908834671663') or { panic(err) }
	b := big.integer_from_string('105792089237316195423570985008687907852837564279074904382605163141518161494337') or { panic(err) }
	shift := u32(5)


	mut start := time.now()
	for _ in 0..iterations {
		_ = a + b
	}
	println('Add: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a * b
	}
	println('Mul: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a / b
	}
	println('Div: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a % b
	}
	println('Mod: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.left_shift(shift)
	}
	println('LShift: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.right_shift(shift)
	}
	println('RShift: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_and(b)
	}
	println('And: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_or(b)
	}
	println('Or: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_xor(b)
	}
	println('Xor: ${time.since(start).nanoseconds()/iterations} ns/op')
}

Result

Add: 32 ns/op
Mul: 71 ns/op
Div: 82 ns/op
Mod: 84 ns/op
LShift: 36 ns/op
RShift: 25 ns/op
And: 17 ns/op
Or: 17 ns/op
Xor: 17 ns/op

Next

module main

import time
import math.big

fn main() {
	iterations := 1000000
	a := big.integer_from_string('115792089237316195423570985008687907853269984665640564039457584007908834671663') or { panic(err) }
	b := big.integer_from_string('7852837564279074904382605163141518161494337') or { panic(err) }
	shift := u32(5)


	mut start := time.now()
	for _ in 0..iterations {
		_ = a + b
	}
	println('Add: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a * b
	}
	println('Mul: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a / b
	}
	println('Div: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a % b
	}
	println('Mod: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.left_shift(shift)
	}
	println('LShift: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.right_shift(shift)
	}
	println('RShift: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_and(b)
	}
	println('And: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_or(b)
	}
	println('Or: ${time.since(start).nanoseconds()/iterations} ns/op')

	start = time.now()
	for _ in 0..iterations {
		_ = a.bitwise_xor(b)
	}
	println('Xor: ${time.since(start).nanoseconds()/iterations} ns/op')
}

Result

Add: 29 ns/op
Mul: 50 ns/op
Div: 1178 ns/op
Mod: 1179 ns/op
LShift: 39 ns/op
RShift: 27 ns/op
And: 16 ns/op
Or: 18 ns/op
Xor: 18 ns/op

[huly-for-github]

Connected to Huly®: V_0.6-22523

[jorgeluismireles]

Question: I notice first you show a Golang program with results and then you edited this into V? Now I see two V programs...

[sibkod]

Question: I notice first you show a Golang program with results and then you edited this into V? Now I see two V programs...

That's right, this is how 2 V programs should be.
I was comparing it with go and accidentally copied the wrong code)

[jorgeluismireles]

V

I found V division of a/b takes 620 nanoseconds when:

a = 115792089237316195423570985008687907853269984665640564039457584007908834671663
b = 105792089237316195423570985008687907852837564279074904382605163141518161494337

And V division of a/b takes 12 microseconds when:

a = 115792089237316195423570985008687907853269984665640564039457584007908834671663
b := 7852837564279074904382605163141518161494337

import time
import math.big

fn main() {
	iterations := 1_000_000
	a := big.integer_from_string('115792089237316195423570985008687907853269984665640564039457584007908834671663')!
	b := big.integer_from_string('105792089237316195423570985008687907852837564279074904382605163141518161494337')!
	//b := big.integer_from_string('7852837564279074904382605163141518161494337')!

	t1 := time.now()
	for _ in 0..iterations {
		a / b
	}
	t2 := time.now()
	println('Iterations:${iterations}')
	println('Div: ${(t2-t1)/iterations}')
}

Go

For the two cases above, I found Golang takes aprox. 270ns and 300ns respectively, so seems those particular numbers takes too much for V to make the division.

package main

import (
	"fmt"
	"math/big"
	"time"
)

func main() {
	a := new(big.Int)
	fmt.Sscan("115792089237316195423570985008687907853269984665640564039457584007908834671663", a)
	b := new(big.Int)
	fmt.Sscan("105792089237316195423570985008687907852837564279074904382605163141518161494337", b)
	//fmt.Sscan("7852837564279074904382605163141518161494337", b)

	iterations := 1_000_000
	t1 := time.Now()
	for i := 0; i < iterations; i++ {
		new(big.Int).Div(a, b)
	}
	div := int64(time.Since(t1))
	fmt.Printf("Iterations:%d\n", iterations)
	fmt.Printf("Div:%d ns/oper\n", div/int64(iterations))
}