Jens Johansen
3e599229b9
Currently serializing the ast for kernel is done in two passe: 1) Scan the program to find and index all strings. These are then sorted based on frequency and assigned an id. All string- references are refering to that id. As small numbers use less space in the binary than big numbers, sorting the numbers by frequency saves a certain amount of space. In addition the string indexing is "hijacked" for the "LimitedBinaryPrinter" to also perform some CanonicalName re-indexing. 2) We then serialize the entire thing. This CL gets rid of a pass by not indexing the strings up-front. Whenever it is asked to serialize a string it adds it to the index (if not already there). The serialization is otherwise the same. This means that: 1) Strings are not sorted by frequency, i.e. the binary output size can by bigger (numbers below). 2) The stringindex and canonical names are moved to the end of the binary instead of the front. As we still need it up front for deserialization some additional data is added to the ProgramIndex. 3) The "hijacking" done in "LimitedBinaryPrinter" is replaced by an alternative. 4) We don't spend time on walking the tree twice. The cost is the binary size. Compiling helloworld with fasta, as well as looking at outline.dill, platform.dill and vmservice_io.dill reveals these numbers: * helloworld.dill is 0.657248732% bigger (26573 bytes) * outline.dill is 1.686911399% bigger (9395 bytes) * platform.dill is 0.657062238% bigger (26565 bytes) * vmservice_io.dill is 0.44991899% bigger (19147 bytes) The cost does thus not appear to be very big. The gain is the serialization time. From 20 runs of an instrumented VM/serialization, running numbers through calculations stolens from ministat (https://www.freebsd.org/cgi/man.cgi?query=ministat) reveals the following: * Serialization time: -21.69% +/- 1.44% * Total time spend in relevant parts of bootstrap_nocore.cc, dart_api_impl.cc (Dart_LoadKernel), bootstrap_nocore.cc, dart_api_impl.cc (LoadKernelProgram) as well as serialization: -14.01% +/- 1.58% From 5 runs of "time python tools/test.py -m release -cdartk language -j6" (again run through ministat calculations): * real: -4.18% +/- 0.5% * user: -4.2% +/- 0.29% * sys: No difference at 95% * user+sys: -3.3% +/- 0.36% Change-Id: I1c220eac083496994f0a9f1e2a2445b3707c9a93 Reviewed-on: https://dart-review.googlesource.com/2880 Reviewed-by: Samir Jindel <sjindel@google.com>
104 lines
2.6 KiB
C++
104 lines
2.6 KiB
C++
// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#ifndef RUNTIME_VM_KERNEL_H_
|
|
#define RUNTIME_VM_KERNEL_H_
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
#include "platform/assert.h"
|
|
#include "vm/allocation.h"
|
|
#include "vm/globals.h"
|
|
#include "vm/growable_array.h"
|
|
#include "vm/object.h"
|
|
#include "vm/token_position.h"
|
|
|
|
namespace dart {
|
|
|
|
class Field;
|
|
class ParsedFunction;
|
|
class Zone;
|
|
|
|
namespace kernel {
|
|
|
|
class Reader;
|
|
|
|
class StringIndex {
|
|
public:
|
|
StringIndex() : value_(-1) {}
|
|
explicit StringIndex(int value) : value_(value) {}
|
|
|
|
operator int() const { return value_; }
|
|
|
|
private:
|
|
int value_;
|
|
};
|
|
|
|
class NameIndex {
|
|
public:
|
|
NameIndex() : value_(-1) {}
|
|
explicit NameIndex(int value) : value_(value) {}
|
|
|
|
operator int() const { return value_; }
|
|
|
|
private:
|
|
int value_;
|
|
};
|
|
|
|
const uint8_t kNativeYieldFlags = 0x2;
|
|
|
|
enum LogicalOperator { kAnd, kOr };
|
|
|
|
class Program {
|
|
public:
|
|
~Program() {
|
|
free(const_cast<uint8_t*>(kernel_data_));
|
|
kernel_data_ = NULL;
|
|
}
|
|
|
|
static Program* ReadFrom(Reader* reader);
|
|
|
|
NameIndex main_method() { return main_method_reference_; }
|
|
intptr_t string_table_offset() { return string_table_offset_; }
|
|
intptr_t name_table_offset() { return name_table_offset_; }
|
|
const uint8_t* kernel_data() { return kernel_data_; }
|
|
intptr_t kernel_data_size() { return kernel_data_size_; }
|
|
intptr_t library_count() { return library_count_; }
|
|
|
|
private:
|
|
Program() : kernel_data_(NULL), kernel_data_size_(-1) {}
|
|
|
|
NameIndex main_method_reference_; // Procedure.
|
|
intptr_t library_count_;
|
|
|
|
// The offset from the start of the binary to the start of the source table.
|
|
intptr_t source_table_offset_;
|
|
|
|
// The offset from the start of the binary to the canonical name table.
|
|
intptr_t name_table_offset_;
|
|
|
|
// The offset from the start of the binary to the start of the string table.
|
|
intptr_t string_table_offset_;
|
|
|
|
const uint8_t* kernel_data_;
|
|
intptr_t kernel_data_size_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Program);
|
|
};
|
|
|
|
ParsedFunction* ParseStaticFieldInitializer(Zone* zone, const Field& field);
|
|
|
|
bool FieldHasFunctionLiteralInitializer(const Field& field,
|
|
TokenPosition* start,
|
|
TokenPosition* end);
|
|
|
|
} // namespace kernel
|
|
|
|
kernel::Program* ReadPrecompiledKernelFromBuffer(const uint8_t* buffer,
|
|
intptr_t buffer_length);
|
|
|
|
} // namespace dart
|
|
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
#endif // RUNTIME_VM_KERNEL_H_
|