Question

我多次提到最好将脚本放入proc以提高运行时性能，例如this answer有以下内容：

这是建议将所有代码放入过程中的一个原因（它们以这种方式进行字节编译）

有些东西没有点击我。

正如答案中所述，第一次运行脚本时，检查命令是否可以进行字节码编译，如果是，则编译。这完全有道理。但我不明白＆＃34; proc＆＃34;起着重要作用。例如。比较以下两个脚本：

set v [concat [lindex $::argv 1] [lindex $::argv 2]]
myCmd $v

和

proc p1 {v1 v2} {
  set v [concat $v1 $v2]
  return [myCmd $v]
}
p1 [lindex $::argv 1] [lindex $::argv 2]

我对2个脚本的高级解释说明如下：

第一次运行任何一个脚本，＆＃34;设置＆＃34;，＆＃34; concat＆＃34;，＆＃34; lindex＆＃34;并且＆＃34;返回＆＃34;命令编译

第二个脚本也有＆＃34; proc＆＃34;编译。

＆＃34; myCmd＆＃34;没有在任何一个脚本中编译

后续运行任一脚本都会运行bycode，除了＆＃34; myCmd＆＃34;。

那么＆＃34; proc＆＃34;？

的优势是什么？

我确实在脚本上运行了dissamble：

第一个脚本：

ByteCode 0x0x83fc70, refCt 1, epoch 3, interp 0x0x81d680 (epoch 3)
  Source "set v [concat [lindex $::argv 1] [lindex $::argv 2]]\nmy"
  Cmds 5, src 61, inst 50, litObjs 4, aux 0, stkDepth 4, code/src 0.00
  Commands 5:
      1: pc 0-41, src 0-51         2: pc 2-39, src 7-50
      3: pc 4-20, src 15-30        4: pc 21-37, src 34-49
      5: pc 42-48, src 53-60
  Command 1: "set v [concat [lindex $::argv 1] [lindex $::argv 2]]"
    (0) push1 0         # "v"
  Command 2: "concat [lindex $::argv 1] [lindex $::argv 2]"
    (2) push1 1         # "concat"
  Command 3: "lindex $::argv 1"
    (4) startCommand +17 1      # next cmd at pc 21
    (13) push1 2        # "::argv"
    (15) loadScalarStk
    (16) listIndexImm 1
  Command 4: "lindex $::argv 2"
    (21) startCommand +17 1     # next cmd at pc 38
    (30) push1 2        # "::argv"
    (32) loadScalarStk
    (33) listIndexImm 2
    (38) invokeStk1 3
    (40) storeScalarStk
    (41) pop
  Command 5: "myCmd $v"
    (42) push1 3        # "myCmd"
    (44) push1 0        # "v"
    (46) loadScalarStk
    (47) invokeStk1 2
    (49) done

第二个脚本：

ByteCode 0x0xc06c80, refCt 1, epoch 3, interp 0x0xbe4680 (epoch 3)
  Source "proc p1 {v1 v2} {\n    set v [concat $v1 $v2]\n    return"
  Cmds 4, src 109, inst 50, litObjs 5, aux 0, stkDepth 4, code/src 0.00
  Commands 4:
      1: pc 0-10, src 0-67         2: pc 11-48, src 69-108
      3: pc 13-29, src 73-88       4: pc 30-46, src 92-107
  Command 1: "proc p1 {v1 v2} {\n    set v [concat $v1 $v2]\n    return"
    (0) push1 0         # "proc"
    (2) push1 1         # "p1"
    (4) push1 2         # "v1 v2"
    (6) push1 3         # "\n    set v [concat $v1 $v2]\n    return ["
    (8) invokeStk1 4
    (10) pop
  Command 2: "p1 [lindex $::argv 1] [lindex $::argv 2]"
    (11) push1 1        # "p1"
  Command 3: "lindex $::argv 1"
    (13) startCommand +17 1     # next cmd at pc 30
    (22) push1 4        # "::argv"
    (24) loadScalarStk
    (25) listIndexImm 1
  Command 4: "lindex $::argv 2"
    (30) startCommand +17 1     # next cmd at pc 47
    (39) push1 4        # "::argv"
    (41) loadScalarStk
    (42) listIndexImm 2
    (47) invokeStk1 3
    (49) done

因此脚本2的TCL命令少了1个，但两个脚本都有49个字节的代码命令。

最后是跑步测试，我注释掉了＃34; myCmd＆＃34;因为我实际上没有这样的延伸。结果如下：

% time {source 1.tcl} 10000
242.8156 microseconds per iteration
% time {source 2.tcl} 10000
257.9389 microseconds per iteration

因此proc版本更慢。

我想念什么？或者更确切地说，对proc和性能的准确理解是什么？

Answer 1

将程序置于事务中的重要原因是程序具有局部变量表。 LVT中的变量可以通过数字索引访问，这比替代方法快得多（通过哈希表查找，即使Tcl有一个极快速哈希表实现）。对于一次性呼叫而言，它没有太大区别，但是通过重复呼叫或循环，性能差异很快就会产生重大影响。这可以很容易地使额外编译和堆栈框架管理的额外成本（程序不能自由进入，尽管我们试图保持它们便宜）在实际脚本中基本上无关紧要。

是的，Tcl实际上是字节码编译的一切。只是它经常在过程（类似上下文）s之外生成次优字节码;在次优的极限情况下，所有字节码正在进行的是将参数组装到列表中，执行动态命令调用以及路由结果。

（在读取Tcl的反汇编字节码时要记住特定字节码的成本不都很重要。你不能只计算指令的数量，以任何有用的方式计算成本。例如，push1非常便宜，但invokeStk1可能非常昂贵。另一个例子，loadScalarStk通常比loadScalar1贵得多;后者仅在程序内部使用。）

Answer 2

以下两个脚本演示了由于使用proc而导致的性能提升。在第二个脚本中，内部循环被提取到proc，导致5倍的加速。

<强> without_proc.tcl

#!/usr/bin/env tclsh

set sum 0
set n 10000
set k 100
for { set i 0 } { $i < $k } { incr i } {
    set s 0
    for { set j 0 } { $j < $n } { incr j } {
        set s [expr {$s + $j}]
    }
    set sum [expr {$sum + $s}]
}
puts "sum=$sum"

<强> with_proc.tcl

#!/usr/bin/env tclsh

proc foo {n} {
    set s 0
    for { set j 0 } { $j < $n } { incr j } {
        set s [expr {$s + $j}]
    }
    return $s
}

set sum 0
set n 10000
set k 100
for { set i 0 } { $i < $k } { incr i } {
    set s [foo $n]
    set sum [expr {$sum + $s}]
}
puts "sum=$sum"

<强>基准：

$ tclsh
% time {source with_proc.tcl} 1
sum=4999500000
67482 microseconds per iteration
% time {source without_proc.tcl} 1
sum=4999500000
406557 microseconds per iteration

或

$ time tclsh with_proc.tcl 
sum=4999500000

real    0m0.089s
user    0m0.080s
sys     0m0.004s

$ time tclsh without_proc.tcl
sum=4999500000

real    0m0.401s
user    0m0.388s
sys     0m0.016s

TCL proc和字节码编译 - 链接是什么？

2 个答案: