草庐IT

performance - Go按位运算性能之谜

coder 2024-07-12 原文

在对从字节数组到 uint32 的转换性能进行基准测试时，我注意到从最低有效位开始时转换运行得更快:

package blah

import (
    "testing"
    "encoding/binary"
    "bytes"
)

func BenchmarkByteConversion(t *testing.B) {
    var i uint32 = 3419234848
    buf := new(bytes.Buffer)
    _ = binary.Write(buf, binary.BigEndian, i)
    b := buf.Bytes()

    for n := 0; n < t.N; n++ {
        // Start with least significant bit: 0.27 nanos
        value := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[2])<<16 | uint32(b[0])<<24

        // Start with most significant bit: 0.68 nanos
        // value := uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
        _ = value
    }
}

当我运行 go test -bench=. 时，以第一种方式计算 value 时每次迭代获得 0.27 纳米，而计算 时每次迭代获得 0.68 纳米值 第二种方式。为什么 | 将数字放在一起时，从最低有效位开始的速度是原来的两倍？

最佳答案

没有什么神秘的。优化!

package blah

import (
    "bytes"
    "encoding/binary"
    "testing"
)

func BenchmarkByteConversionLeast(t *testing.B) {
    var i uint32 = 3419234848
    buf := new(bytes.Buffer)
    _ = binary.Write(buf, binary.BigEndian, i)
    b := buf.Bytes()

    for n := 0; n < t.N; n++ {
        // Start with least significant bit: 0.27 nanos
        value := uint32(b[3]) | uint32(b[2])<<8 | uint32(b[2])<<16 | uint32(b[0])<<24
        _ = value
    }
}

func BenchmarkByteConversionMost(t *testing.B) {
    var i uint32 = 3419234848
    buf := new(bytes.Buffer)
    _ = binary.Write(buf, binary.BigEndian, i)
    b := buf.Bytes()

    for n := 0; n < t.N; n++ {
        // Start with most significant bit: 0.68 nanos
        value := uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
        _ = value
    }
}

输出:

go test silly_test.go -bench=.
goos: linux
goarch: amd64
BenchmarkByteConversionLeast-4      2000000000           0.72 ns/op
BenchmarkByteConversionMost-4       2000000000           1.80 ns/op

这应该是显而易见的。边界检查消除。

只需使用常识。如果检查索引 3、2、1 和 0 的数组边界，则可以在 3 处停止检查，因为显然 2、1 和 0 也是有效的。如果检查索引 0、1、2 和 3 的数组边界，则必须检查所有索引的边界。一次边界检查与四次边界检查。

Wikipedia: Bounds checking

Wikipedia: Bounds-checking elimination

您还应该阅读优秀的代码，例如 Go 标准库。例如，

func (littleEndian) PutUint64(b []byte, v uint64) {
    _ = b[7] // early bounds check to guarantee safety of writes below
    b[0] = byte(v)
    b[1] = byte(v >> 8)
    b[2] = byte(v >> 16)
    b[3] = byte(v >> 24)
    b[4] = byte(v >> 32)
    b[5] = byte(v >> 40)
    b[6] = byte(v >> 48)
    b[7] = byte(v >> 56)
}

关于performance - Go按位运算性能之谜，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/51972759/

performance按位uintcodeltgo

有关performance - Go按位运算性能之谜的更多相关文章

  1. ruby - 触发器 ruby​​ 中 3 点范围运算符和 2 点范围运算符的区别 - 2

    请帮助我理解范围运算符...和..之间的区别，作为Ruby中使用的“触发器”。这是PragmaticProgrammersguidetoRuby中的一个示例:a=(11..20).collect{|i|(i%4==0)..(i%3==0)?i:nil}返回:[nil,12,nil,nil,nil,16,17,18,nil,20]还有:a=(11..20).collect{|i|(i%4==0)...(i%3==0)?i:nil}返回:[nil,12,13,14,15,16,17,18,nil,20] 最佳答案 触发器(又名f/f)是

  2. ruby - 带括号和 splat 运算符的并行赋值 - 2

    我明白了:x,(y,z)=1,*[2,3]x#=>1y#=>2z#=>nil我想知道为什么z的值为nil。 最佳答案 x,(y,z)=1,*[2,3]右侧的splat*是内联扩展的，所以它等同于:x,(y,z)=1,2,3左边带括号的列表被视为嵌套赋值，所以它等价于:x=1y,z=23被丢弃，而z被分配给nil。 关于ruby-带括号和splat运算符的并行赋值，我们在StackOverflow上找到一个类似的问题： https://stackoverflow

  3. ruby-on-rails - Resque - 类的未定义方法 'perform' - 2

    我目前对后台队列不太满意。我正在尝试让Resque工作。我已经安装了redis和Resquegem。Redis正在运行。一个worker正在运行(rakeresque:workQUEUE=simple)。使用Web界面，我可以看到工作人员正在运行并等待工作。当我运行“rakeget_updates”时，作业已排队但失败了。我已经用defself.perform和defperform试过了。发条.raketask:get_updates=>:environmentdoResque.enqueue(GetUpdates)end类文件(app/workers/get_updates.rb)c

  4. Ruby 的数字方法性能 - 2

    我正在使用Ruby解决一些ProjectEuler问题，特别是这里我要讨论的问题25(Fibonacci数列中包含1000位数字的第一项的索引是多少？)。起初，我使用的是Ruby2.2.3，我将问题编码为:number=3a=1b=2whileb.to_s.length但后来我发现2.4.2版本有一个名为digits的方法，这正是我需要的。我转换为代码:whileb.digits.length当我比较这两种方法时，digits慢得多。时间./025/problem025.rb0.13s用户0.02s系统80%cpu0.190总计./025/problem025.rb2.19s用户0.0

  5. ruby - Ruby 性能中的计时器 - 2

    我正在寻找一个用ruby​​演示计时器的在线示例，并发现了下面的代码。它按预期工作，但这个简单的程序使用30Mo内存(如Windows任务管理器中所示)和太多CPU有意义吗？非常感谢deftime_blockstart_time=Time.nowThread.new{yield}Time.now-start_timeenddefrepeat_every(seconds)whiletruedotime_spent=time_block{yield}#Tohandle-vesleepinteravalsleep(seconds-time_spent)iftime_spent

  6. ruby - 定义自定义 Ruby 运算符 - 2

    问题是:除了在“OperatorExpressions”？例如:1%!2 最佳答案 是的，可以创建自定义运算符，但有一些注意事项。Ruby本身并不直接支持它，但是superatorsgem做了一个巧妙的把戏，将运算符链接在一起。这允许您创建自己的运算符，但有一些限制:$geminstallsuperators19然后:require'superators19'classArraysuperator"%~"do|operand|"#{self}percent-tilde#{operand}"endendputs[1]%~[2]#Out

  7. ruby-on-rails - 如果条件与 &&，是否有任何性能提升 - 2

    如果用户是所有者，我有一个条件来检查说删除和文章。delete_articleifuser.owner?另一种方式是user.owner?&&delete_article选择它有什么好处还是它只是一种写作风格 最佳答案 性能不太可能成为该声明的问题。第一个要好得多-它更容易阅读。您future的自己和其他将开始编写代码的人会为此感谢您。 关于ruby-on-rails-如果条件与&&，是否有任何性能提升，我们在StackOverflow上找到一个类似的问题：

  8. ruby - Ruby 中 <=> 运算符的名称是什么？他们怎么调用它？ - 2

    在Ruby中有运算符(operator)。在API中，他们没有命名它的名字，只是:Theclassmustdefinetheoperator...Comparableusestoimplementtheconventionalcomparison......theobjectsinthecollectionmustalsoimplementameaningfuloperator...它叫什么名字？ 最佳答案 参见上面的@Tony。然而，它也被称为(俚语)“宇宙飞船运算符(operator)”。

  9. ruby - 将运算符传递给函数？ - 2

    也许这听起来很荒谬，但我想知道这对Ruby是否可行？基本上我有一个功能...defadda,bc=a+breturncend我希望能够将“+”或其他运算符(例如“-”)传递给函数，这样它就类似于...defsuma,b,operatorc=aoperatorbreturncend这可能吗？ 最佳答案 两种可能性:以方法/算子名作为符号:defsuma,b,operatora.send(operator,b)endsum42,23,:+或者更通用的解决方案:采取一个block:defsuma,byielda,bendsum42,23,

  10. ruby - OR 运算符和 Ruby where 子句 - 2

    可能真的很简单，但我很难在网上找到关于这个的文档我在Ruby中有两个activerecord查询，我想通过OR运算符连接在一起@pro=Project.where(:manager_user_id=>current_user.id)@proa=Project.where(:account_manager=>current_user.id)我是ruby​​的新手，但我自己尝试使用||@pro=Project.where(:manager_user_id=>current_user.id||:account_manager=>current_user.id)这没有用，所以1.我想知道如何在

随机推荐