vec.clone() is slow

[zhuxiujia]

#[bench]
fn Bench_Clone(b: &mut Bencher) {
    let test=vec![1 as u8];
    b.iter(|| {
        test.clone();
    });
}
//result    ... bench:          49 ns/iter (+/- 0)

Why is VEC cloning so slow? Causing String struct to be slow？？

[tesuji]

@zhuxiujia Slow compared to which?

[leonardo-m]

"1 as u8" is better written "1u8" or something similar.

[zhuxiujia]

"1 as u8" is better written "1u8" or something similar.

yes, any type(i32,String,f64.....) bench also cost 49 ns/iter (+/- 0)

[zhuxiujia]

"1 as u8" is better written "1u8" or something similar.

you can try it, 100% also very slow!

[zhuxiujia]

@zhuxiujia Slow compared to which?

compared with any type like vec![ 1 as i32 ],vec![ 1 as f64 ],vec!["1"]... all of 49 ns/iter (+/- 0)
but , other struct .clone() only use 0 ns/iter (+/- 0)
Is it because VEC data is stored on the heap instead of on the stack?

[sfackler]

Yes

[kstrafe]

Most likely your struct uses only stack memory, and since the heap is non-deterministic (sbrk from the OS), you force the LLVM to not optimize your code.

With a struct, use black_box(black_box(struct).clone()).

Looking at the disassembly, LLVM won't even generate code for stack copy benchmarks (iter_inner) even with black_box, that's why you get 0 ns/iter.

[zhuxiujia]

Most likely your struct uses only stack memory, and since the heap is non-deterministic (sbrk from the OS), you force the LLVM to not optimize your code.

With a struct, use black_box(black_box(struct).clone()).

Looking at the disassembly, LLVM won't even generate code for stack copy benchmarks (iter_inner) even with black_box, that's why you get 0 ns/iter.

Thank you, as you said, why do other languages like “go，java“ clone performance is not low? is llvm not auto optimization assembly code?

[SimonSapin]

Have you benchmarked a heap allocation and deallocation taking, together, significantly less than 49 nanoseconds in Go or Java?

[zhuxiujia]

Have you benchmarked a heap allocation and deallocation taking, together, significantly less than 49 nanoseconds in Go or Java?

it is in golang code.

package main

import "testing"

func BenchmarkClone(b *testing.B) {
	b.StopTimer()
	var str = "dfasdfas"
	var target=[]byte{}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		copy([]byte(str),target)
	}
}
//BenchmarkClone-8   	200000000	         7.29 ns/op
//PASS

[zhuxiujia]

Have you benchmarked a heap allocation and deallocation taking, together, significantly less than 49 nanoseconds in Go or Java?
it is java code

 public static void main(String[] args) {
        Date start=new Date();
        ArrayList<String> list=new ArrayList<String>();
        list.add("dsf");
        list.add("fsadf");
        for (int i=0;i<100000;i++){
            list.clone();
        }
       System.out.println((new Date().getTime()-d.getTime())/100000f+" ns/op");
    }
//BenchmarkClone            150ns/op

[kstrafe]

Have you benchmarked a heap allocation and deallocation taking, together, significantly less than 49 nanoseconds in Go or Java?

it is in golang code.

package main

import "testing"

func BenchmarkClone(b *testing.B) {
	b.StopTimer()
	var str = "dfasdfas"
	var target=[]byte{}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		copy([]byte(str),target)
	}
}
//BenchmarkClone-8   	200000000	         7.29 ns/op
//PASS

I don't know Go very well but this might just be copying stack data, have you tried attaching valgrind to see if it allocates?

[SimonSapin]

It might be worth trying with https://crates.io/crates/jemallocator_global as well.

[the8472]

Take a look at https://crates.io/crates/smallvec if you want on-tack cloning of small vecs

[zhuxiujia]

Have you benchmarked a heap allocation and deallocation taking, together, significantly less than 49 nanoseconds in Go or Java?

it is in golang code.

package main

import "testing"

func BenchmarkClone(b *testing.B) {
	b.StopTimer()
	var str = "dfasdfas"
	var target=[]byte{}
	b.StartTimer()
	for i := 0; i < b.N; i++ {
		copy([]byte(str),target)
	}
}
//BenchmarkClone-8   	200000000	         7.29 ns/op
//PASS

I don't know Go very well but this might just be copying stack data, have you tried attaching valgrind to see if it allocates?

golang slice data stored on heap!I don't know why go is so fast.