Each directory object creates a new service port which will start a
new thread. As these service ports are currently never closed this is
a huge problem causing the standalone VM to fail when running out of
threads.
This change uses a pool of native ports for directory operations. This
still ensures that the operations for each directory object are
serialized and limits the number of native ports allocated and thus
threads started.
Even when closing of native ports is possible we might want to keep
some kind of pool like this. The reason for this is that to actually
determine when the native port is not needed any more we need a
finalizer callback on the directory object.
R=ager@google.com
BUG=none
TEST=tests/standalone/src/ManyDirectoryOperationsTest.dart
Review URL: https://chromiumcodereview.appspot.com//9568010
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4795 260f80e4-7a28-3924-810f-c04153c831b5
It is permitted to specify a start index equal to the array length
when the copy length is 0. This runs afoul of an assertion in
ByteAddr that validates 0 <= index < length. Consistent with other
methods to retrieve a raw element address, we now guard this call with
an implicit check for this boundary condition by ensuring length is
greater than zero.
In addition, some simple unit tests for ByteArray::Copy have been added.
BUG=1891
Review URL: https://chromiumcodereview.appspot.com//9560001
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4772 260f80e4-7a28-3924-810f-c04153c831b5
On standalone dartium which has about 50000 tokens in the libraries (core, coreimpl, builtin, io etc.) this reduces the heap size by about 180kb. The size of the standalone snapshot buffer reduces by about 72kb.
Also moved the keyword symbol table to the object store so that it does not have to repopulated on every script compilation. Should benefit regular user script load times.
Review URL: https://chromiumcodereview.appspot.com//9462003
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4734 260f80e4-7a28-3924-810f-c04153c831b5
Change the handling of the received data on HTTPRequest and
HTTPClientResponse to use the InputStream interface instead of
dataReceived and dataEnd handlers.
We should probably do something to make the following serer side and
client side patterns simpler:
void handler(HTTPRequest request, HTTPResponse response) {
...
StringBuffer body = new StringBuffer();
StringInputStream input = new StringInputStream(request.inputStream);
input.dataHandler = () => body.add(input.read());
input.closeHandler = () {
String data = body.toString();
...
}
}
HTTPClientConnection conn = ...
conn.responseHandler = (HTTPClientResponse r) {
...
StringBuffer body = new StringBuffer();
StringInputStream input = new StringInputStream(request.inputStream);
input.dataHandler = () => body.add(input.read());
input.closeHandler = () {
String data = body.toString();
...
}
}
R=ager@google.com,ajohnsen@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9495007
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4679 260f80e4-7a28-3924-810f-c04153c831b5
Continue to bailout on optional parameters and context-allocated local
variables.
Implement compilation of Bind and Do instructions, LoadLocal and StoreLocal
computations, and temporary values. Temporary allocation assumes they obey
a stack-discipline and have a single use---so any use is always the last
use. Temporaries can then be allocated via push and used via pop. This
dart function:
hukairs(a) {
var b, c;
c = b = a;
return c;
}
compiles to this annotated generated code snippet:
;; StoreLocal(b, #null)
66: mov $0x7f99303c0021,%rax
70: mov %rax,-0x8(%rbp)
;; StoreLocal(c, #null)
74: mov $0x7f99303c0021,%rax
7e: mov %rax,-0x10(%rbp)
;; t0 <-LoadLocal(a)
82: mov 0x10(%rbp),%ax
86: push %rax
;; t0 <-StoreLocal(b, t0)
87: pop %rax
88: mov %rax,-0x8(%rbp)
8c: push %rax
;; StoreLocal(c, t0)
8d: pop %rax
8e: mov %rax,-0x10(%rbp)
;; t0 <-LoadLocal(c)
92: mov -0x10(%rbp),%ax
96: push %rax
;; return t0
97: pop %rax
;; ...
bf: mov %rbp,%rsp
c2: pop %rbp
c3: retq
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9447102
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4666 260f80e4-7a28-3924-810f-c04153c831b5
big global change, so let me explain in more detail. This refactoring CL does
the following:
- moves all the dart code for isolates in a common library (lib/isolate)
- changes frog to understand 'dart:isolate' imoprts by loading the code from the
location above.
- changes the vm to undernstand 'dart:isolate' imports by creating a separate
library that is part of the bootstrap. This follows the same code-structure
that Todd suggested in his CL introducing the mirror library
- changes dartc to use the shared isolate library as the source of truth for
type checking. I left around some of the internal js code in dartc so that the
backend continues to work for apps that don't use isolates.
- changes all tests that use isolates to import the library explicitly (this is a large bulk of the files in this CL)
- changes test status for tests we can't fix in this repo (e.g. co19)
- splits the isolate library code to make it possible to preserve some tests
without exposing internal types (e.g. tests about
serialization/deserialization)
- changes the create_sdk script to copy the isolate library to the sdk
- includes the isolate library in dartdoc
I'll wait for at least one lgtm from each area (dartc, vm, frog, sdk)
There is one important pending thing this CL doesn't do:
- update test_runner.dart: This should be updated next time we upload the new
binaries to tool/testing/bin
- dartium specific changes: Vijay, is there anything I need to do for dartium?
Review URL: https://chromiumcodereview.appspot.com//9422019
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4647 260f80e4-7a28-3924-810f-c04153c831b5
Implement a simple compilation visitor for the intermediate language. Copy
code from the x64 code generator to support compilation of functions with no
arguments, no locals, and that return a literal.
Compiled code is not used, but it can be disassembled and visually checked
against the code from the old code generator.
R=srdjan@google.com
BUG=
TEST=expected to pass all tests on x64
Review URL: https://chromiumcodereview.appspot.com//9464009
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4601 260f80e4-7a28-3924-810f-c04153c831b5
This keeps the IL simple for the benefit of the optimizing compiler.
It intentionally relies on a particular temporary allocation strategy
for the non-optimizing compiler.
For the dart function
main() {
var x = 2;
hukairs(1, x, 3);
}
The flow graph is:
0: [target]
StoreLocal(x, #2)
t0 <-#1
t1 <-LoadLocal(x)
t2 <-#3
StaticCall(hukairs, t0, t1, t2)
return #null
R=srdjan@google.com
BUG=
TEST=
Review URL: https://chromiumcodereview.appspot.com//9463007
git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4600 260f80e4-7a28-3924-810f-c04153c831b5
turnidge@google.com