Jak są reprezentowane zamknięcia i zakresy w czasie uruchamiania w JavaScript

To nie prawda, że istnieją ograniczenia, które uniemożliwiają wywołanie eval, które byłyby pominięte przez Analizę statyczną: po prostu takie odniesienia do eval działają w zasięgu globalnym. Zauważ, że jest to zmiana w ES5 z ES3, gdzie pośrednie i bezpośrednie odniesienia do eval zarówno działał w zakresie lokalnym, i jako takie, nie jestem pewien, czy cokolwiek faktycznie robi jakieś optymalizacje oparte na tym fakcie.

Oczywistym sposobem na przetestowanie tego jest uczynienie BigObject naprawdę dużym obiektem i wymusić gc po uruchomieniu f0-f2. (Ponieważ, hej, o ile myślę, że znam odpowiedź, testowanie jest zawsze lepsze!)

Test

var closure;
function BigObject() {
  var a = '';
  for (var i = 0; i <= 0xFFFF; i++) a += String.fromCharCode(i);
  return new String(a); // Turn this into an actual object
}
function f0() {
  var x = new BigObject();
  var y = 0;
  closure = function(){ return 7; };
}
function f1() {
  var x = new BigObject();
  closure =  (function(y) { return function(){return y++;}; })(0);
}
function f2() {
  var x = new BigObject();
  var y = 0;
  closure = function(){ return y++; };
}
function f3() {
  var x = new BigObject();
  var y = 0;
  closure = eval("(function(){ return 7; })"); // direct eval
}
function f4() {
  var x = new BigObject();
  var y = 0;
  closure = (1,eval)("(function(){ return 7; })"); // indirect eval (evaluates in global scope)
}
function f5() {
  var x = new BigObject();
  var y = 0;
  closure = (function(){ return eval("(function(){ return 7; })"); })();
}
function f6() {
  var x = new BigObject();
  var y = 0;
  closure = function(){ return eval("(function(){ return 7; })"); };
}
function f7() {
  var x = new BigObject();
  var y = 0;
  closure = (function(){ return (1,eval)("(function(){ return 7; })"); })();
}
function f8() {
  var x = new BigObject();
  var y = 0;
  closure = function(){ return (1,eval)("(function(){ return 7; })"); };
}
function f9() {
  var x = new BigObject();
  var y = 0;
  closure = new Function("return 7;"); // creates function in global scope
}

Dodałem testy dla eval / Function, wydaje się, że są to również ciekawe przypadki. Różnica między f5/f6 jest interesująca, ponieważ F5 jest tak naprawdę identyczna z f3, biorąc pod uwagę to, co jest tak naprawdę identyczną funkcją zamknięcia; f6 zwraca tylko coś, co raz ocenione daje to, a ponieważ eval nie został jeszcze oceniony, kompilator Nie wiem, czy nie ma w nim odniesienia do X.

SpiderMonkey

js> gc();
"before 73728, after 69632, break 01d91000\n"
js> f0();
js> gc(); 
"before 6455296, after 73728, break 01d91000\n"
js> f1(); 
js> gc(); 
"before 6455296, after 77824, break 01d91000\n"
js> f2(); 
js> gc(); 
"before 6455296, after 77824, break 01d91000\n"
js> f3(); 
js> gc(); 
"before 6455296, after 6455296, break 01db1000\n"
js> f4(); 
js> gc(); 
"before 12828672, after 73728, break 01da2000\n"
js> f5(); 
js> gc(); 
"before 6455296, after 6455296, break 01da2000\n"
js> f6(); 
js> gc(); 
"before 12828672, after 6467584, break 01da2000\n"
js> f7(); 
js> gc(); 
"before 12828672, after 73728, break 01da2000\n"
js> f8(); 
js> gc(); 
"before 6455296, after 73728, break 01da2000\n"
js> f9(); 
js> gc(); 
"before 6455296, after 73728, break 01da2000\n"

Wydaje się tak bardzo, jak to możliwe (tj., jeśli to możliwe, y, jak również x), chyba że istnieje bezpośrednie wywołanie eval w łańcuchu zakresu dowolnej funkcji, która nadal istnieje. (Nawet jeśli sam obiekt funkcji został GC ' D i już nie istnieje, Jak to ma miejsce w przypadku f5, co teoretycznie oznacza, że może GC x / y.)

V8

gsnedders@dolores:~$ v8 --expose-gc --trace_gc --shell foo.js
V8 version 3.0.7
> gc();
Mark-sweep 0.8 -> 0.7 MB, 1 ms.
> f0();
Scavenge 1.7 -> 1.7 MB, 2 ms.
Scavenge 2.4 -> 2.4 MB, 2 ms.
Scavenge 3.9 -> 3.9 MB, 4 ms.
> gc();   
Mark-sweep 5.2 -> 0.7 MB, 3 ms.
> f1();
Scavenge 4.7 -> 4.7 MB, 9 ms.
> gc();
Mark-sweep 5.2 -> 0.7 MB, 3 ms.
> f2();
Scavenge 4.8 -> 4.8 MB, 6 ms.
> gc();
Mark-sweep 5.3 -> 0.8 MB, 3 ms.
> f3();
> gc();
Mark-sweep 5.3 -> 5.2 MB, 17 ms.
> f4();
> gc();
Mark-sweep 9.7 -> 0.7 MB, 5 ms.
> f5();
> gc();
Mark-sweep 5.3 -> 5.2 MB, 12 ms.
> f6();
> gc();
Mark-sweep 9.7 -> 5.2 MB, 14 ms.
> f7();
> gc();
Mark-sweep 9.7 -> 0.7 MB, 5 ms.
> f8();
> gc();
Mark-sweep 5.2 -> 0.7 MB, 2 ms.
> f9();
> gc();
Mark-sweep 5.2 -> 0.7 MB, 2 ms.

Carakan

Nie będę zawracał sobie głowy uruchomieniem tego ponownie, ale nie trzeba dodawać, że zachowanie jest identyczne z SpiderMonkey i V8. Trudniejsze do przetestowania bez powłoki JS, ale wykonalne z czas.

JSC (Nitro) i czakra

Budowanie JSC to ból w Linuksie, a Chakra nie działa na Linuksie. Wydaje mi się, że JSC ma takie samo zachowanie jak wyżej wymienione silniki. zdziwiłbym się, gdyby nie Chakra. (Robienie czegoś lepszego szybko staje się bardzo złożone, robienie czegoś gorszego, cóż, prawie nigdy nie robiłbyś GC i nie miałbyś poważnych problemów z pamięcią...) {]}