What is the difference between global and :: in TCL? - tcl

Question

I am working with an EDA SW. It requires me to rely on global variables.
Say I have a proc, and I am looking for a global variable CCK_FOO. I have 2 choices:
Use global CCK_FOO within the code.
Use ::CCK_FOO
In terms of "management level", these appear identical. Is there an "under the hood" pro and con for either of the methods? I actually prefer using ::, as it minimizes the chances of accidental override.

Answer 1

Under the hood, using ::CCK_FOO goes through the parsed variable name route every time the execution engine uses it, whereas global CCK_FOO allows the engine to set up a local variable (with a local variable table — LVT — slot) that is linked to the global variable. Accesses via the LVT is much faster because that's just an index into a C array (and an extra pointer dereference because it's a link) whereas looking up a global variable means doing a hash table lookup (there's a hash table for variables in the global namespace implementation). The actual internal parse of ::CCK_FOO into :: and CCK_FOO is cached.
In practical terms, it's perhaps slightly faster to use ::CCK_FOO if you are only accessing a variable once, but as soon as you use it twice (let alone more) you get better performance by paying the extra cost of global CCK_FOO and accessing it via LVT indexing.
% proc style1 {} {
set ::CCK_FOO abc
}
% proc style2 {} {
global CCK_FOO
set CCK_FOO abc
}
% time { style1 } 100000
0.52350635 microseconds per iteration
% time { style2 } 100000
0.5267007100000001 microseconds per iteration
Note, times between code above and code below are not comparable as they do different amounts of other work. Look instead at the differences in timings between style1 and style2.
% proc style1 {} {
set ::CCK_FOO [string reverse $::CCK_FOO]
}
% proc style2 {} {
global CCK_FOO
set CCK_FOO [string reverse $CCK_FOO]
}
% time { style1 } 100000
0.9733970200000001 microseconds per iteration
% time { style2 } 100000
0.78782093 microseconds per iteration
# Calibration...
% time { string reverse abc } 100000
0.28694849 microseconds per iteration
As you can see, with just two accesses, we're getting quite a lot of speedup by using global.