Skip to content

V
V8
Commit ab234760 authored by yangguo's avatar yangguo Committed by Commit bot
Browse files
Options

Reland "Encode reservation meta data in the snapshot blob." 

CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux_nosnap_dbg,v8_linux_nosnap_rel

Review URL: https://codereview.chromium.org/781943002

Cr-Commit-Position: refs/heads/master@{#25681}
parent aae8fe75
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 365 additions and 601 deletions
src/mksnapshot.cc
View file @ ab234760
...@@ -20,24 +20,13 @@ ...@@ -20,24 +20,13 @@
using namespace v8; using namespace v8;
class Compressor {
public:
virtual ~Compressor() {}
virtual bool Compress(i::Vector<i::byte> input) = 0;
virtual i::Vector<i::byte>* output() = 0;
};
class SnapshotWriter { class SnapshotWriter {
public: public:
explicit SnapshotWriter(const char* snapshot_file) explicit SnapshotWriter(const char* snapshot_file)
: fp_(GetFileDescriptorOrDie(snapshot_file)) : fp_(GetFileDescriptorOrDie(snapshot_file)),
, raw_file_(NULL) raw_file_(NULL),
, raw_context_file_(NULL) raw_context_file_(NULL),
, startup_blob_file_(NULL) startup_blob_file_(NULL) {}
, compressor_(NULL) {
}
~SnapshotWriter() { ~SnapshotWriter() {
fclose(fp_); fclose(fp_);
...@@ -46,10 +35,6 @@ class SnapshotWriter { ...@@ -46,10 +35,6 @@ class SnapshotWriter {
if (startup_blob_file_) fclose(startup_blob_file_); if (startup_blob_file_) fclose(startup_blob_file_);
} }
void SetCompressor(Compressor* compressor) {
compressor_ = compressor;
}
void SetRawFiles(const char* raw_file, const char* raw_context_file) { void SetRawFiles(const char* raw_file, const char* raw_context_file) {
raw_file_ = GetFileDescriptorOrDie(raw_file); raw_file_ = GetFileDescriptorOrDie(raw_file);
raw_context_file_ = GetFileDescriptorOrDie(raw_context_file); raw_context_file_ = GetFileDescriptorOrDie(raw_context_file);
...@@ -60,51 +45,21 @@ class SnapshotWriter { ...@@ -60,51 +45,21 @@ class SnapshotWriter {
startup_blob_file_ = GetFileDescriptorOrDie(startup_blob_file); startup_blob_file_ = GetFileDescriptorOrDie(startup_blob_file);
} }
void WriteSnapshot(const i::List<i::byte>& snapshot_data, void WriteSnapshot(const i::SnapshotData& sd,
const i::Serializer& serializer, const i::SnapshotData& csd) const {
const i::List<i::byte>& context_snapshot_data, WriteSnapshotFile(sd, csd);
const i::Serializer& context_serializer) const { MaybeWriteStartupBlob(sd, csd);
WriteSnapshotFile(snapshot_data, serializer,
context_snapshot_data, context_serializer);
MaybeWriteStartupBlob(snapshot_data, serializer,
context_snapshot_data, context_serializer);
} }
private: private:
void MaybeWriteStartupBlob(const i::List<i::byte>& snapshot_data, void MaybeWriteStartupBlob(const i::SnapshotData& sd,
const i::Serializer& serializer, const i::SnapshotData& csd) const {
const i::List<i::byte>& context_snapshot_data,
const i::Serializer& context_serializer) const {
if (!startup_blob_file_) return; if (!startup_blob_file_) return;
i::SnapshotByteSink sink; i::SnapshotByteSink sink;
int spaces[] = {i::NEW_SPACE, i::OLD_POINTER_SPACE, sink.PutBlob(sd.RawData(), "snapshot");
i::OLD_DATA_SPACE, i::CODE_SPACE, sink.PutBlob(csd.RawData(), "context");
i::MAP_SPACE, i::CELL_SPACE,
i::PROPERTY_CELL_SPACE, i::LO_SPACE};
i::byte* snapshot_bytes = snapshot_data.begin();
sink.PutBlob(snapshot_bytes, snapshot_data.length(), "snapshot");
for (size_t i = 0; i < arraysize(spaces); ++i) {
i::Vector<const uint32_t> chunks =
serializer.FinalAllocationChunks(spaces[i]);
// For the start-up snapshot, none of the reservations has more than
// one chunk (reservation for each space fits onto a single page).
CHECK_EQ(1, chunks.length());
sink.PutInt(chunks[0], "spaces");
}
i::byte* context_bytes = context_snapshot_data.begin();
sink.PutBlob(context_bytes, context_snapshot_data.length(), "context");
for (size_t i = 0; i < arraysize(spaces); ++i) {
i::Vector<const uint32_t> chunks =
context_serializer.FinalAllocationChunks(spaces[i]);
// For the context snapshot, none of the reservations has more than
// one chunk (reservation for each space fits onto a single page).
CHECK_EQ(1, chunks.length());
sink.PutInt(chunks[0], "spaces");
}
const i::List<i::byte>& startup_blob = sink.data(); const i::List<i::byte>& startup_blob = sink.data();
size_t written = fwrite(startup_blob.begin(), 1, startup_blob.length(), size_t written = fwrite(startup_blob.begin(), 1, startup_blob.length(),
...@@ -115,15 +70,11 @@ class SnapshotWriter { ...@@ -115,15 +70,11 @@ class SnapshotWriter {
} }
} }
void WriteSnapshotFile(const i::List<i::byte>& snapshot_data, void WriteSnapshotFile(const i::SnapshotData& snapshot_data,
const i::Serializer& serializer, const i::SnapshotData& context_snapshot_data) const {
const i::List<i::byte>& context_snapshot_data,
const i::Serializer& context_serializer) const {
WriteFilePrefix(); WriteFilePrefix();
WriteData("", snapshot_data, raw_file_); WriteData("", snapshot_data.RawData(), raw_file_);
WriteData("context_", context_snapshot_data, raw_context_file_); WriteData("context_", context_snapshot_data.RawData(), raw_context_file_);
WriteMeta("context_", context_serializer);
WriteMeta("", serializer);
WriteFileSuffix(); WriteFileSuffix();
} }
...@@ -141,90 +92,43 @@ class SnapshotWriter { ...@@ -141,90 +92,43 @@ class SnapshotWriter {
fprintf(fp_, "} // namespace v8\n"); fprintf(fp_, "} // namespace v8\n");
} }
void WriteData(const char* prefix, const i::List<i::byte>& source_data, void WriteData(const char* prefix,
const i::Vector<const i::byte>& source_data,
FILE* raw_file) const { FILE* raw_file) const {
const i::List<i::byte>* data_to_be_written = NULL; MaybeWriteRawFile(&source_data, raw_file);
i::List<i::byte> compressed_data; WriteData(prefix, source_data);
if (!compressor_) {
data_to_be_written = &source_data;
} else if (compressor_->Compress(source_data.ToVector())) {
compressed_data.AddAll(*compressor_->output());
data_to_be_written = &compressed_data;
} else {
i::PrintF("Compression failed. Aborting.\n");
exit(1);
}
DCHECK(data_to_be_written);
MaybeWriteRawFile(data_to_be_written, raw_file);
WriteData(prefix, source_data, data_to_be_written);
} }
void MaybeWriteRawFile(const i::List<i::byte>* data, FILE* raw_file) const { void MaybeWriteRawFile(const i::Vector<const i::byte>* data,
if (!data || !raw_file) FILE* raw_file) const {
return; if (!data || !raw_file) return;
// Sanity check, whether i::List iterators truly return pointers to an // Sanity check, whether i::List iterators truly return pointers to an
// internal array. // internal array.
DCHECK(data->end() - data->begin() == data->length()); DCHECK(data->end() - data->begin() == data->length());
size_t written = fwrite(data->begin(), 1, data->length(), raw_file); size_t written = fwrite(data->begin(), 1, data->length(), raw_file);
if (written != (size_t)data->length()) { if (written != static_cast<size_t>(data->length())) {
i::PrintF("Writing raw file failed.. Aborting.\n"); i::PrintF("Writing raw file failed.. Aborting.\n");
exit(1); exit(1);
} }
} }
void WriteData(const char* prefix, const i::List<i::byte>& source_data, void WriteData(const char* prefix,
const i::List<i::byte>* data_to_be_written) const { const i::Vector<const i::byte>& source_data) const {
fprintf(fp_, "const byte Snapshot::%sdata_[] = {\n", prefix); fprintf(fp_, "const byte Snapshot::%sdata_[] = {\n", prefix);
WriteSnapshotData(data_to_be_written); WriteSnapshotData(source_data);
fprintf(fp_, "};\n"); fprintf(fp_, "};\n");
fprintf(fp_, "const int Snapshot::%ssize_ = %d;\n", prefix, fprintf(fp_, "const int Snapshot::%ssize_ = %d;\n", prefix,
data_to_be_written->length()); source_data.length());
if (data_to_be_written == &source_data) {
fprintf(fp_, "const byte* Snapshot::%sraw_data_ = Snapshot::%sdata_;\n",
prefix, prefix);
fprintf(fp_, "const int Snapshot::%sraw_size_ = Snapshot::%ssize_;\n",
prefix, prefix);
} else {
fprintf(fp_, "const byte* Snapshot::%sraw_data_ = NULL;\n", prefix);
fprintf(fp_, "const int Snapshot::%sraw_size_ = %d;\n",
prefix, source_data.length());
}
fprintf(fp_, "\n");
}
void WriteMeta(const char* prefix, const i::Serializer& ser) const {
WriteSizeVar(ser, prefix, "new", i::NEW_SPACE);
WriteSizeVar(ser, prefix, "pointer", i::OLD_POINTER_SPACE);
WriteSizeVar(ser, prefix, "data", i::OLD_DATA_SPACE);
WriteSizeVar(ser, prefix, "code", i::CODE_SPACE);
WriteSizeVar(ser, prefix, "map", i::MAP_SPACE);
WriteSizeVar(ser, prefix, "cell", i::CELL_SPACE);
WriteSizeVar(ser, prefix, "property_cell", i::PROPERTY_CELL_SPACE);
WriteSizeVar(ser, prefix, "lo", i::LO_SPACE);
fprintf(fp_, "\n"); fprintf(fp_, "\n");
} }
void WriteSizeVar(const i::Serializer& ser, const char* prefix, void WriteSnapshotData(const i::Vector<const i::byte>& data) const {
const char* name, int space) const { for (int i = 0; i < data.length(); i++) {
i::Vector<const uint32_t> chunks = ser.FinalAllocationChunks(space); if ((i & 0x1f) == 0x1f) fprintf(fp_, "\n");
// For the start-up snapshot, none of the reservations has more than if (i > 0) fprintf(fp_, ",");
// one chunk (total reservation fits into a single page). fprintf(fp_, "%u", static_cast<unsigned char>(data.at(i)));
CHECK_EQ(1, chunks.length());
fprintf(fp_, "const int Snapshot::%s%s_space_used_ = %d;\n", prefix, name,
chunks[0]);
}
void WriteSnapshotData(const i::List<i::byte>* data) const {
for (int i = 0; i < data->length(); i++) {
if ((i & 0x1f) == 0x1f)
fprintf(fp_, "\n");
if (i > 0)
fprintf(fp_, ",");
fprintf(fp_, "%u", static_cast<unsigned char>(data->at(i)));
} }
fprintf(fp_, "\n"); fprintf(fp_, "\n");
} }
...@@ -242,7 +146,6 @@ class SnapshotWriter { ...@@ -242,7 +146,6 @@ class SnapshotWriter {
FILE* raw_file_; FILE* raw_file_;
FILE* raw_context_file_; FILE* raw_context_file_;
FILE* startup_blob_file_; FILE* startup_blob_file_;
Compressor* compressor_;
}; };
...@@ -365,17 +268,15 @@ int main(int argc, char** argv) { ...@@ -365,17 +268,15 @@ int main(int argc, char** argv) {
context_ser.Serialize(&raw_context); context_ser.Serialize(&raw_context);
ser.SerializeWeakReferences(); ser.SerializeWeakReferences();
context_ser.FinalizeAllocation();
ser.FinalizeAllocation();
{ {
SnapshotWriter writer(argv[1]); SnapshotWriter writer(argv[1]);
if (i::FLAG_raw_file && i::FLAG_raw_context_file) if (i::FLAG_raw_file && i::FLAG_raw_context_file)
writer.SetRawFiles(i::FLAG_raw_file, i::FLAG_raw_context_file); writer.SetRawFiles(i::FLAG_raw_file, i::FLAG_raw_context_file);
if (i::FLAG_startup_blob) if (i::FLAG_startup_blob)
writer.SetStartupBlobFile(i::FLAG_startup_blob); writer.SetStartupBlobFile(i::FLAG_startup_blob);
writer.WriteSnapshot(snapshot_sink.data(), ser, context_sink.data(), i::SnapshotData sd(snapshot_sink, ser);
context_ser); i::SnapshotData csd(context_sink, context_ser);
writer.WriteSnapshot(sd, csd);
} }
} }
......
src/natives-external.cc
View file @ ab234760
...@@ -142,9 +142,8 @@ void SetNativesFromFile(StartupData* natives_blob) { ...@@ -142,9 +142,8 @@ void SetNativesFromFile(StartupData* natives_blob) {
DCHECK(natives_blob->data); DCHECK(natives_blob->data);
DCHECK(natives_blob->raw_size > 0); DCHECK(natives_blob->raw_size > 0);
SnapshotByteSource bytes( SnapshotByteSource bytes(reinterpret_cast<const byte*>(natives_blob->data),
reinterpret_cast<const byte*>(natives_blob->data), natives_blob->raw_size);
natives_blob->raw_size);
NativesHolder<CORE>::set(NativesStore::MakeFromScriptsSource(&bytes)); NativesHolder<CORE>::set(NativesStore::MakeFromScriptsSource(&bytes));
NativesHolder<EXPERIMENTAL>::set(NativesStore::MakeFromScriptsSource(&bytes)); NativesHolder<EXPERIMENTAL>::set(NativesStore::MakeFromScriptsSource(&bytes));
DCHECK(!bytes.HasMore()); DCHECK(!bytes.HasMore());
......
src/serialize.cc
View file @ ab234760
This diff is collapsed.
src/serialize.h
View file @ ab234760
...@@ -453,11 +453,63 @@ class SerializerDeserializer: public ObjectVisitor { ...@@ -453,11 +453,63 @@ class SerializerDeserializer: public ObjectVisitor {
}; };
class SerializedData {
public:
class Reservation {
public:
explicit Reservation(uint32_t size)
: reservation_(ChunkSizeBits::encode(size)) {}
uint32_t chunk_size() const { return ChunkSizeBits::decode(reservation_); }
bool is_last() const { return IsLastChunkBits::decode(reservation_); }
void mark_as_last() { reservation_ |= IsLastChunkBits::encode(true); }
private:
uint32_t reservation_;
};
SerializedData(byte* data, int size)
: data_(data), size_(size), owns_data_(false) {}
SerializedData() : data_(NULL), size_(0), owns_data_(false) {}
~SerializedData() {
if (owns_data_) DeleteArray<byte>(data_);
}
class ChunkSizeBits : public BitField<uint32_t, 0, 31> {};
class IsLastChunkBits : public BitField<bool, 31, 1> {};
protected:
void SetHeaderValue(int offset, int value) {
reinterpret_cast<int*>(data_)[offset] = value;
}
int GetHeaderValue(int offset) const {
return reinterpret_cast<const int*>(data_)[offset];
}
void AllocateData(int size);
byte* data_;
int size_;
bool owns_data_;
};
// A Deserializer reads a snapshot and reconstructs the Object graph it defines. // A Deserializer reads a snapshot and reconstructs the Object graph it defines.
class Deserializer: public SerializerDeserializer { class Deserializer: public SerializerDeserializer {
public: public:
// Create a deserializer from a snapshot byte source. // Create a deserializer from a snapshot byte source.
explicit Deserializer(SnapshotByteSource* source); template <class Data>
explicit Deserializer(Data* data)
: isolate_(NULL),
attached_objects_(NULL),
source_(data->Payload()),
external_reference_decoder_(NULL),
deserialized_large_objects_(0) {
DecodeReservation(data->Reservations());
}
virtual ~Deserializer(); virtual ~Deserializer();
...@@ -471,12 +523,6 @@ class Deserializer: public SerializerDeserializer { ...@@ -471,12 +523,6 @@ class Deserializer: public SerializerDeserializer {
void DeserializePartial(Isolate* isolate, Object** root, void DeserializePartial(Isolate* isolate, Object** root,
OnOOM on_oom = FATAL_ON_OOM); OnOOM on_oom = FATAL_ON_OOM);
void AddReservation(int space, uint32_t chunk) {
DCHECK(space >= 0);
DCHECK(space < kNumberOfSpaces);
reservations_[space].Add({chunk, NULL, NULL});
}
void FlushICacheForNewCodeObjects(); void FlushICacheForNewCodeObjects();
// Serialized user code reference certain objects that are provided in a list // Serialized user code reference certain objects that are provided in a list
...@@ -494,6 +540,8 @@ class Deserializer: public SerializerDeserializer { ...@@ -494,6 +540,8 @@ class Deserializer: public SerializerDeserializer {
UNREACHABLE(); UNREACHABLE();
} }
void DecodeReservation(Vector<const SerializedData::Reservation> res);
bool ReserveSpace(); bool ReserveSpace();
// Allocation sites are present in the snapshot, and must be linked into // Allocation sites are present in the snapshot, and must be linked into
...@@ -523,7 +571,7 @@ class Deserializer: public SerializerDeserializer { ...@@ -523,7 +571,7 @@ class Deserializer: public SerializerDeserializer {
// Objects from the attached object descriptions in the serialized user code. // Objects from the attached object descriptions in the serialized user code.
Vector<Handle<Object> >* attached_objects_; Vector<Handle<Object> >* attached_objects_;
SnapshotByteSource* source_; SnapshotByteSource source_;
// The address of the next object that will be allocated in each space. // The address of the next object that will be allocated in each space.
// Each space has a number of chunks reserved by the GC, with each chunk // Each space has a number of chunks reserved by the GC, with each chunk
// fitting into a page. Deserialized objects are allocated into the // fitting into a page. Deserialized objects are allocated into the
...@@ -549,16 +597,7 @@ class Serializer : public SerializerDeserializer { ...@@ -549,16 +597,7 @@ class Serializer : public SerializerDeserializer {
~Serializer(); ~Serializer();
virtual void VisitPointers(Object** start, Object** end) OVERRIDE; virtual void VisitPointers(Object** start, Object** end) OVERRIDE;
void FinalizeAllocation(); void EncodeReservations(List<SerializedData::Reservation>* out) const;
Vector<const uint32_t> FinalAllocationChunks(int space) const {
if (space == LO_SPACE) {
return Vector<const uint32_t>(&large_objects_total_size_, 1);
} else {
DCHECK_EQ(0, pending_chunk_[space]); // No pending chunks.
return completed_chunks_[space].ToConstVector();
}
}
Isolate* isolate() const { return isolate_; } Isolate* isolate() const { return isolate_; }
...@@ -782,7 +821,7 @@ class CodeSerializer : public Serializer { ...@@ -782,7 +821,7 @@ class CodeSerializer : public Serializer {
return source_; return source_;
} }
List<uint32_t>* stub_keys() { return &stub_keys_; } const List<uint32_t>* stub_keys() const { return &stub_keys_; }
int num_internalized_strings() const { return num_internalized_strings_; } int num_internalized_strings() const { return num_internalized_strings_; }
private: private:
...@@ -819,10 +858,42 @@ class CodeSerializer : public Serializer { ...@@ -819,10 +858,42 @@ class CodeSerializer : public Serializer {
}; };
// Wrapper around reservation sizes and the serialization payload.
class SnapshotData : public SerializedData {
public:
// Used when producing.
SnapshotData(const SnapshotByteSink& sink, const Serializer& ser);
// Used when consuming.
explicit SnapshotData(const byte* data, int size)
: SerializedData(const_cast<byte*>(data), size) {
CHECK(IsSane());
}
Vector<const Reservation> Reservations() const;
Vector<const byte> Payload() const;
Vector<const byte> RawData() const {
return Vector<const byte>(data_, size_);
}
private:
bool IsSane();
// The data header consists of int-sized entries:
// [0] version hash
// [1] number of reservation size entries
// [2] payload length
static const int kCheckSumOffset = 0;
static const int kReservationsOffset = 1;
static const int kPayloadLengthOffset = 2;
static const int kHeaderSize = (kPayloadLengthOffset + 1) * kIntSize;
};
// Wrapper around ScriptData to provide code-serializer-specific functionality. // Wrapper around ScriptData to provide code-serializer-specific functionality.
class SerializedCodeData { class SerializedCodeData : public SerializedData {
public: public:
// Used by when consuming. // Used when consuming.
static SerializedCodeData* FromCachedData(ScriptData* cached_data, static SerializedCodeData* FromCachedData(ScriptData* cached_data,
String* source) { String* source) {
DisallowHeapAllocation no_gc; DisallowHeapAllocation no_gc;
...@@ -834,75 +905,20 @@ class SerializedCodeData { ...@@ -834,75 +905,20 @@ class SerializedCodeData {
} }
// Used when producing. // Used when producing.
SerializedCodeData(const List<byte>& payload, CodeSerializer* cs); SerializedCodeData(const List<byte>& payload, const CodeSerializer& cs);
~SerializedCodeData() {
if (owns_script_data_) delete script_data_;
}
// Return ScriptData object and relinquish ownership over it to the caller. // Return ScriptData object and relinquish ownership over it to the caller.
ScriptData* GetScriptData() { ScriptData* GetScriptData();
ScriptData* result = script_data_;
script_data_ = NULL;
DCHECK(owns_script_data_);
owns_script_data_ = false;
return result;
}
class Reservation {
public:
uint32_t chunk_size() const { return ChunkSizeBits::decode(reservation); }
bool is_last_chunk() const { return IsLastChunkBits::decode(reservation); }
private: Vector<const Reservation> Reservations() const;
uint32_t reservation; Vector<const byte> Payload() const;
DISALLOW_COPY_AND_ASSIGN(Reservation); int NumInternalizedStrings() const;
}; Vector<const uint32_t> CodeStubKeys() const;
int NumInternalizedStrings() const {
return GetHeaderValue(kNumInternalizedStringsOffset);
}
Vector<const Reservation> Reservations() const {
return Vector<const Reservation>(reinterpret_cast<const Reservation*>(
script_data_->data() + kHeaderSize),
GetHeaderValue(kReservationsOffset));
}
Vector<const uint32_t> CodeStubKeys() const {
int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
const byte* start = script_data_->data() + kHeaderSize + reservations_size;
return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
GetHeaderValue(kNumCodeStubKeysOffset));
}
const byte* Payload() const {
int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
int code_stubs_size = GetHeaderValue(kNumCodeStubKeysOffset) * kInt32Size;
return script_data_->data() + kHeaderSize + reservations_size +
code_stubs_size;
}
int PayloadLength() const {
int payload_length = GetHeaderValue(kPayloadLengthOffset);
DCHECK_EQ(script_data_->data() + script_data_->length(),
Payload() + payload_length);
return payload_length;
}
private: private:
explicit SerializedCodeData(ScriptData* data) explicit SerializedCodeData(ScriptData* data)
: script_data_(data), owns_script_data_(false) {} : SerializedData(const_cast<byte*>(data->data()), data->length()) {}
void SetHeaderValue(int offset, int value) {
reinterpret_cast<int*>(const_cast<byte*>(script_data_->data()))[offset] =
value;
}
int GetHeaderValue(int offset) const {
return reinterpret_cast<const int*>(script_data_->data())[offset];
}
bool IsSane(String* source); bool IsSane(String* source);
...@@ -912,24 +928,14 @@ class SerializedCodeData { ...@@ -912,24 +928,14 @@ class SerializedCodeData {
// [0] version hash // [0] version hash
// [1] number of internalized strings // [1] number of internalized strings
// [2] number of code stub keys // [2] number of code stub keys
// [3] payload length // [3] number of reservation size entries
// [4..10] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE. // [4] payload length
static const int kCheckSumOffset = 0; static const int kCheckSumOffset = 0;
static const int kNumInternalizedStringsOffset = 1; static const int kNumInternalizedStringsOffset = 1;
static const int kReservationsOffset = 2; static const int kReservationsOffset = 2;
static const int kNumCodeStubKeysOffset = 3; static const int kNumCodeStubKeysOffset = 3;
static const int kPayloadLengthOffset = 4; static const int kPayloadLengthOffset = 4;
static const int kHeaderSize = (kPayloadLengthOffset + 1) * kIntSize; static const int kHeaderSize = (kPayloadLengthOffset + 1) * kIntSize;
class ChunkSizeBits : public BitField<uint32_t, 0, 31> {};
class IsLastChunkBits : public BitField<bool, 31, 1> {};
// Following the header, we store, in sequential order
// - code stub keys
// - serialization payload
ScriptData* script_data_;
bool owns_script_data_;
}; };
} } // namespace v8::internal } } // namespace v8::internal
......
src/snapshot-common.cc
View file @ ab234760
...@@ -14,27 +14,14 @@ ...@@ -14,27 +14,14 @@
namespace v8 { namespace v8 {
namespace internal { namespace internal {
void Snapshot::ReserveSpaceForLinkedInSnapshot(Deserializer* deserializer) {
deserializer->AddReservation(NEW_SPACE, new_space_used_);
deserializer->AddReservation(OLD_POINTER_SPACE, pointer_space_used_);
deserializer->AddReservation(OLD_DATA_SPACE, data_space_used_);
deserializer->AddReservation(CODE_SPACE, code_space_used_);
deserializer->AddReservation(MAP_SPACE, map_space_used_);
deserializer->AddReservation(CELL_SPACE, cell_space_used_);
deserializer->AddReservation(PROPERTY_CELL_SPACE, property_cell_space_used_);
deserializer->AddReservation(LO_SPACE, lo_space_used_);
}
bool Snapshot::Initialize(Isolate* isolate) { bool Snapshot::Initialize(Isolate* isolate) {
if (size_ > 0) { if (size_ > 0) {
base::ElapsedTimer timer; base::ElapsedTimer timer;
if (FLAG_profile_deserialization) { if (FLAG_profile_deserialization) timer.Start();
timer.Start();
} SnapshotData snapshot_data(data_, size_);
SnapshotByteSource source(raw_data_, raw_size_); Deserializer deserializer(&snapshot_data);
Deserializer deserializer(&source);
ReserveSpaceForLinkedInSnapshot(&deserializer);
bool success = isolate->Init(&deserializer); bool success = isolate->Init(&deserializer);
if (FLAG_profile_deserialization) { if (FLAG_profile_deserialization) {
double ms = timer.Elapsed().InMillisecondsF(); double ms = timer.Elapsed().InMillisecondsF();
...@@ -52,22 +39,11 @@ bool Snapshot::HaveASnapshotToStartFrom() { ...@@ -52,22 +39,11 @@ bool Snapshot::HaveASnapshotToStartFrom() {
Handle<Context> Snapshot::NewContextFromSnapshot(Isolate* isolate) { Handle<Context> Snapshot::NewContextFromSnapshot(Isolate* isolate) {
if (context_size_ == 0) { if (context_size_ == 0) return Handle<Context>();
return Handle<Context>();
} SnapshotData snapshot_data(context_data_, context_size_);
SnapshotByteSource source(context_raw_data_, Deserializer deserializer(&snapshot_data);
context_raw_size_);
Deserializer deserializer(&source);
Object* root; Object* root;
deserializer.AddReservation(NEW_SPACE, context_new_space_used_);
deserializer.AddReservation(OLD_POINTER_SPACE, context_pointer_space_used_);
deserializer.AddReservation(OLD_DATA_SPACE, context_data_space_used_);
deserializer.AddReservation(CODE_SPACE, context_code_space_used_);
deserializer.AddReservation(MAP_SPACE, context_map_space_used_);
deserializer.AddReservation(CELL_SPACE, context_cell_space_used_);
deserializer.AddReservation(PROPERTY_CELL_SPACE,
context_property_cell_space_used_);
deserializer.AddReservation(LO_SPACE, context_lo_space_used_);
deserializer.DeserializePartial(isolate, &root); deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsContext()); CHECK(root->IsContext());
return Handle<Context>(Context::cast(root)); return Handle<Context>(Context::cast(root));
......
src/snapshot-empty.cc
View file @ ab234760
...@@ -12,29 +12,8 @@ namespace v8 { ...@@ -12,29 +12,8 @@ namespace v8 {
namespace internal { namespace internal {
const byte Snapshot::data_[] = { 0 }; const byte Snapshot::data_[] = { 0 };
const byte* Snapshot::raw_data_ = NULL;
const int Snapshot::size_ = 0; const int Snapshot::size_ = 0;
const int Snapshot::raw_size_ = 0;
const byte Snapshot::context_data_[] = { 0 }; const byte Snapshot::context_data_[] = { 0 };
const byte* Snapshot::context_raw_data_ = NULL;
const int Snapshot::context_size_ = 0; const int Snapshot::context_size_ = 0;
const int Snapshot::context_raw_size_ = 0;
const int Snapshot::new_space_used_ = 0;
const int Snapshot::pointer_space_used_ = 0;
const int Snapshot::data_space_used_ = 0;
const int Snapshot::code_space_used_ = 0;
const int Snapshot::map_space_used_ = 0;
const int Snapshot::cell_space_used_ = 0;
const int Snapshot::property_cell_space_used_ = 0;
const int Snapshot::lo_space_used_ = 0;
const int Snapshot::context_new_space_used_ = 0;
const int Snapshot::context_pointer_space_used_ = 0;
const int Snapshot::context_data_space_used_ = 0;
const int Snapshot::context_code_space_used_ = 0;
const int Snapshot::context_map_space_used_ = 0;
const int Snapshot::context_cell_space_used_ = 0;
const int Snapshot::context_property_cell_space_used_ = 0;
const int Snapshot::context_lo_space_used_ = 0;
} } // namespace v8::internal } } // namespace v8::internal
src/snapshot-external.cc
View file @ ab234760
...@@ -18,25 +18,8 @@ struct SnapshotImpl { ...@@ -18,25 +18,8 @@ struct SnapshotImpl {
public: public:
const byte* data; const byte* data;
int size; int size;
int new_space_used;
int pointer_space_used;
int data_space_used;
int code_space_used;
int map_space_used;
int cell_space_used;
int property_cell_space_used;
int lo_space_used;
const byte* context_data; const byte* context_data;
int context_size; int context_size;
int context_new_space_used;
int context_pointer_space_used;
int context_data_space_used;
int context_code_space_used;
int context_map_space_used;
int context_cell_space_used;
int context_property_cell_space_used;
int context_lo_space_used;
}; };
...@@ -49,25 +32,12 @@ bool Snapshot::HaveASnapshotToStartFrom() { ...@@ -49,25 +32,12 @@ bool Snapshot::HaveASnapshotToStartFrom() {
bool Snapshot::Initialize(Isolate* isolate) { bool Snapshot::Initialize(Isolate* isolate) {
if (!HaveASnapshotToStartFrom()) if (!HaveASnapshotToStartFrom()) return false;
return false;
base::ElapsedTimer timer; base::ElapsedTimer timer;
if (FLAG_profile_deserialization) { if (FLAG_profile_deserialization) timer.Start();
timer.Start();
} SnapshotData snapshot_data(snapshot_impl_->data, snapshot_impl_->size);
SnapshotByteSource source(snapshot_impl_->data, snapshot_impl_->size); Deserializer deserializer(&snapshot_data);
Deserializer deserializer(&source);
deserializer.AddReservation(NEW_SPACE, snapshot_impl_->new_space_used);
deserializer.AddReservation(OLD_POINTER_SPACE,
snapshot_impl_->pointer_space_used);
deserializer.AddReservation(OLD_DATA_SPACE, snapshot_impl_->data_space_used);
deserializer.AddReservation(CODE_SPACE, snapshot_impl_->code_space_used);
deserializer.AddReservation(MAP_SPACE, snapshot_impl_->map_space_used);
deserializer.AddReservation(CELL_SPACE, snapshot_impl_->cell_space_used);
deserializer.AddReservation(PROPERTY_CELL_SPACE,
snapshot_impl_->property_cell_space_used);
deserializer.AddReservation(LO_SPACE, snapshot_impl_->lo_space_used);
bool success = isolate->Init(&deserializer); bool success = isolate->Init(&deserializer);
if (FLAG_profile_deserialization) { if (FLAG_profile_deserialization) {
double ms = timer.Elapsed().InMillisecondsF(); double ms = timer.Elapsed().InMillisecondsF();
...@@ -78,27 +48,11 @@ bool Snapshot::Initialize(Isolate* isolate) { ...@@ -78,27 +48,11 @@ bool Snapshot::Initialize(Isolate* isolate) {
Handle<Context> Snapshot::NewContextFromSnapshot(Isolate* isolate) { Handle<Context> Snapshot::NewContextFromSnapshot(Isolate* isolate) {
if (!HaveASnapshotToStartFrom()) if (!HaveASnapshotToStartFrom()) return Handle<Context>();
return Handle<Context>();
SnapshotData snapshot_data(snapshot_impl_->context_data,
SnapshotByteSource source(snapshot_impl_->context_data, snapshot_impl_->context_size);
snapshot_impl_->context_size); Deserializer deserializer(&snapshot_data);
Deserializer deserializer(&source);
deserializer.AddReservation(NEW_SPACE,
snapshot_impl_->context_new_space_used);
deserializer.AddReservation(OLD_POINTER_SPACE,
snapshot_impl_->context_pointer_space_used);
deserializer.AddReservation(OLD_DATA_SPACE,
snapshot_impl_->context_data_space_used);
deserializer.AddReservation(CODE_SPACE,
snapshot_impl_->context_code_space_used);
deserializer.AddReservation(MAP_SPACE,
snapshot_impl_->context_map_space_used);
deserializer.AddReservation(CELL_SPACE,
snapshot_impl_->context_cell_space_used);
deserializer.AddReservation(PROPERTY_CELL_SPACE,
snapshot_impl_->context_property_cell_space_used);
deserializer.AddReservation(LO_SPACE, snapshot_impl_->context_lo_space_used);
Object* root; Object* root;
deserializer.DeserializePartial(isolate, &root); deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsContext()); CHECK(root->IsContext());
...@@ -115,29 +69,10 @@ void SetSnapshotFromFile(StartupData* snapshot_blob) { ...@@ -115,29 +69,10 @@ void SetSnapshotFromFile(StartupData* snapshot_blob) {
snapshot_impl_ = new SnapshotImpl; snapshot_impl_ = new SnapshotImpl;
SnapshotByteSource source(reinterpret_cast<const byte*>(snapshot_blob->data), SnapshotByteSource source(reinterpret_cast<const byte*>(snapshot_blob->data),
snapshot_blob->raw_size); snapshot_blob->raw_size);
bool success = source.GetBlob(&snapshot_impl_->data, bool success = source.GetBlob(&snapshot_impl_->data,
&snapshot_impl_->size); &snapshot_impl_->size);
snapshot_impl_->new_space_used = source.GetInt();
snapshot_impl_->pointer_space_used = source.GetInt();
snapshot_impl_->data_space_used = source.GetInt();
snapshot_impl_->code_space_used = source.GetInt();
snapshot_impl_->map_space_used = source.GetInt();
snapshot_impl_->cell_space_used = source.GetInt();
snapshot_impl_->property_cell_space_used = source.GetInt();
snapshot_impl_->lo_space_used = source.GetInt();
success &= source.GetBlob(&snapshot_impl_->context_data, success &= source.GetBlob(&snapshot_impl_->context_data,
&snapshot_impl_->context_size); &snapshot_impl_->context_size);
snapshot_impl_->context_new_space_used = source.GetInt();
snapshot_impl_->context_pointer_space_used = source.GetInt();
snapshot_impl_->context_data_space_used = source.GetInt();
snapshot_impl_->context_code_space_used = source.GetInt();
snapshot_impl_->context_map_space_used = source.GetInt();
snapshot_impl_->context_cell_space_used = source.GetInt();
snapshot_impl_->context_property_cell_space_used = source.GetInt();
snapshot_impl_->context_lo_space_used = source.GetInt();
DCHECK(success); DCHECK(success);
} }
......
src/snapshot-source-sink.cc
View file @ ab234760
...@@ -13,15 +13,6 @@ ...@@ -13,15 +13,6 @@
namespace v8 { namespace v8 {
namespace internal { namespace internal {
SnapshotByteSource::SnapshotByteSource(const byte* array, int length)
: data_(array), length_(length), position_(0) {
}
SnapshotByteSource::~SnapshotByteSource() { }
int32_t SnapshotByteSource::GetUnalignedInt() { int32_t SnapshotByteSource::GetUnalignedInt() {
DCHECK(position_ < length_); // Require at least one byte left. DCHECK(position_ < length_); // Require at least one byte left.
int32_t answer = data_[position_]; int32_t answer = data_[position_];
...@@ -52,15 +43,17 @@ void SnapshotByteSink::PutInt(uintptr_t integer, const char* description) { ...@@ -52,15 +43,17 @@ void SnapshotByteSink::PutInt(uintptr_t integer, const char* description) {
if (bytes > 3) Put(static_cast<int>((integer >> 24) & 0xff), "IntPart4"); if (bytes > 3) Put(static_cast<int>((integer >> 24) & 0xff), "IntPart4");
} }
void SnapshotByteSink::PutRaw(byte* data, int number_of_bytes,
void SnapshotByteSink::PutRaw(const byte* data, int number_of_bytes,
const char* description) { const char* description) {
data_.AddAll(Vector<byte>(data, number_of_bytes)); data_.AddAll(Vector<byte>(const_cast<byte*>(data), number_of_bytes));
} }
void SnapshotByteSink::PutBlob(byte* data, int number_of_bytes,
void SnapshotByteSink::PutBlob(Vector<const byte> blob,
const char* description) { const char* description) {
PutInt(number_of_bytes, description); PutInt(blob.length(), description);
PutRaw(data, number_of_bytes, description); PutRaw(blob.start(), blob.length(), description);
} }
...@@ -77,7 +70,7 @@ bool SnapshotByteSource::GetBlob(const byte** data, int* number_of_bytes) { ...@@ -77,7 +70,7 @@ bool SnapshotByteSource::GetBlob(const byte** data, int* number_of_bytes) {
int size = GetInt(); int size = GetInt();
*number_of_bytes = size; *number_of_bytes = size;
if (position_ + size < length_) { if (position_ + size <= length_) {
*data = &data_[position_]; *data = &data_[position_];
Advance(size); Advance(size);
return true; return true;
......
src/snapshot-source-sink.h
View file @ ab234760
...@@ -19,8 +19,13 @@ namespace internal { ...@@ -19,8 +19,13 @@ namespace internal {
*/ */
class SnapshotByteSource FINAL { class SnapshotByteSource FINAL {
public: public:
SnapshotByteSource(const byte* array, int length); SnapshotByteSource(const byte* data, int length)
~SnapshotByteSource(); : data_(data), length_(length), position_(0) {}
explicit SnapshotByteSource(Vector<const byte> payload)
: data_(payload.start()), length_(payload.length()), position_(0) {}
~SnapshotByteSource() {}
bool HasMore() { return position_ < length_; } bool HasMore() { return position_ < length_; }
...@@ -83,8 +88,8 @@ class SnapshotByteSink { ...@@ -83,8 +88,8 @@ class SnapshotByteSink {
} }
void PutInt(uintptr_t integer, const char* description); void PutInt(uintptr_t integer, const char* description);
void PutRaw(byte* data, int number_of_bytes, const char* description); void PutRaw(const byte* data, int number_of_bytes, const char* description);
void PutBlob(byte* data, int number_of_bytes, const char* description); void PutBlob(Vector<const byte> blob, const char* description);
int Position() { return data_.length(); } int Position() { return data_.length(); }
const List<byte>& data() const { return data_; } const List<byte>& data() const { return data_; }
......
src/snapshot.h
View file @ ab234760
...@@ -23,31 +23,9 @@ class Snapshot { ...@@ -23,31 +23,9 @@ class Snapshot {
private: private:
static const byte data_[]; static const byte data_[];
static const byte* raw_data_;
static const byte context_data_[];
static const byte* context_raw_data_;
static const int new_space_used_;
static const int pointer_space_used_;
static const int data_space_used_;
static const int code_space_used_;
static const int map_space_used_;
static const int cell_space_used_;
static const int property_cell_space_used_;
static const int lo_space_used_;
static const int context_new_space_used_;
static const int context_pointer_space_used_;
static const int context_data_space_used_;
static const int context_code_space_used_;
static const int context_map_space_used_;
static const int context_cell_space_used_;
static const int context_property_cell_space_used_;
static const int context_lo_space_used_;
static const int size_; static const int size_;
static const int raw_size_; static const byte context_data_[];
static const int context_size_; static const int context_size_;
static const int context_raw_size_;
static void ReserveSpaceForLinkedInSnapshot(Deserializer* deserializer);
DISALLOW_IMPLICIT_CONSTRUCTORS(Snapshot); DISALLOW_IMPLICIT_CONSTRUCTORS(Snapshot);
}; };
......
test/cctest/test-serialize.cc
View file @ ab234760
...@@ -114,7 +114,7 @@ TEST(ExternalReferenceDecoder) { ...@@ -114,7 +114,7 @@ TEST(ExternalReferenceDecoder) {
} }
void WritePayload(const List<byte>& payload, const char* file_name) { void WritePayload(const Vector<const byte>& payload, const char* file_name) {
FILE* file = v8::base::OS::FOpen(file_name, "wb"); FILE* file = v8::base::OS::FOpen(file_name, "wb");
if (file == NULL) { if (file == NULL) {
PrintF("Unable to write to snapshot file \"%s\"\n", file_name); PrintF("Unable to write to snapshot file \"%s\"\n", file_name);
...@@ -129,50 +129,12 @@ void WritePayload(const List<byte>& payload, const char* file_name) { ...@@ -129,50 +129,12 @@ void WritePayload(const List<byte>& payload, const char* file_name) {
} }
void WriteSpaceUsed(Serializer* ser, const char* file_name) {
int file_name_length = StrLength(file_name) + 10;
Vector<char> name = Vector<char>::New(file_name_length + 1);
SNPrintF(name, "%s.size", file_name);
FILE* fp = v8::base::OS::FOpen(name.start(), "w");
name.Dispose();
Vector<const uint32_t> chunks = ser->FinalAllocationChunks(NEW_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "new %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(OLD_POINTER_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "pointer %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(OLD_DATA_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "data %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(CODE_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "code %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(MAP_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "map %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(CELL_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "cell %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(PROPERTY_CELL_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "property cell %d\n", chunks[0]);
chunks = ser->FinalAllocationChunks(LO_SPACE);
CHECK_EQ(1, chunks.length());
fprintf(fp, "lo %d\n", chunks[0]);
fclose(fp);
}
static bool WriteToFile(Isolate* isolate, const char* snapshot_file) { static bool WriteToFile(Isolate* isolate, const char* snapshot_file) {
SnapshotByteSink sink; SnapshotByteSink sink;
StartupSerializer ser(isolate, &sink); StartupSerializer ser(isolate, &sink);
ser.Serialize(); ser.Serialize();
ser.FinalizeAllocation(); SnapshotData snapshot_data(sink, ser);
WritePayload(snapshot_data.RawData(), snapshot_file);
WritePayload(sink.data(), snapshot_file);
WriteSpaceUsed(&ser, snapshot_file);
return true; return true;
} }
...@@ -220,53 +182,14 @@ UNINITIALIZED_TEST(SerializeTwice) { ...@@ -220,53 +182,14 @@ UNINITIALIZED_TEST(SerializeTwice) {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// Tests that the heap can be deserialized. // Tests that the heap can be deserialized.
static void ReserveSpaceForSnapshot(Deserializer* deserializer,
const char* file_name) {
int file_name_length = StrLength(file_name) + 10;
Vector<char> name = Vector<char>::New(file_name_length + 1);
SNPrintF(name, "%s.size", file_name);
FILE* fp = v8::base::OS::FOpen(name.start(), "r");
name.Dispose();
int new_size, pointer_size, data_size, code_size, map_size, cell_size,
property_cell_size, lo_size;
#if V8_CC_MSVC
// Avoid warning about unsafe fscanf from MSVC.
// Please note that this is only fine if %c and %s are not being used.
#define fscanf fscanf_s
#endif
CHECK_EQ(1, fscanf(fp, "new %d\n", &new_size));
CHECK_EQ(1, fscanf(fp, "pointer %d\n", &pointer_size));
CHECK_EQ(1, fscanf(fp, "data %d\n", &data_size));
CHECK_EQ(1, fscanf(fp, "code %d\n", &code_size));
CHECK_EQ(1, fscanf(fp, "map %d\n", &map_size));
CHECK_EQ(1, fscanf(fp, "cell %d\n", &cell_size));
CHECK_EQ(1, fscanf(fp, "property cell %d\n", &property_cell_size));
CHECK_EQ(1, fscanf(fp, "lo %d\n", &lo_size));
#if V8_CC_MSVC
#undef fscanf
#endif
fclose(fp);
deserializer->AddReservation(NEW_SPACE, new_size);
deserializer->AddReservation(OLD_POINTER_SPACE, pointer_size);
deserializer->AddReservation(OLD_DATA_SPACE, data_size);
deserializer->AddReservation(CODE_SPACE, code_size);
deserializer->AddReservation(MAP_SPACE, map_size);
deserializer->AddReservation(CELL_SPACE, cell_size);
deserializer->AddReservation(PROPERTY_CELL_SPACE, property_cell_size);
deserializer->AddReservation(LO_SPACE, lo_size);
}
v8::Isolate* InitializeFromFile(const char* snapshot_file) { v8::Isolate* InitializeFromFile(const char* snapshot_file) {
int len; int len;
byte* str = ReadBytes(snapshot_file, &len); byte* str = ReadBytes(snapshot_file, &len);
if (!str) return NULL; if (!str) return NULL;
v8::Isolate* v8_isolate = NULL; v8::Isolate* v8_isolate = NULL;
{ {
SnapshotByteSource source(str, len); SnapshotData snapshot_data(str, len);
Deserializer deserializer(&source); Deserializer deserializer(&snapshot_data);
ReserveSpaceForSnapshot(&deserializer, snapshot_file);
Isolate* isolate = Isolate::NewForTesting(); Isolate* isolate = Isolate::NewForTesting();
v8_isolate = reinterpret_cast<v8::Isolate*>(isolate); v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);
v8::Isolate::Scope isolate_scope(v8_isolate); v8::Isolate::Scope isolate_scope(v8_isolate);
...@@ -436,14 +359,11 @@ UNINITIALIZED_TEST(PartialSerialization) { ...@@ -436,14 +359,11 @@ UNINITIALIZED_TEST(PartialSerialization) {
startup_serializer.SerializeWeakReferences(); startup_serializer.SerializeWeakReferences();
partial_serializer.FinalizeAllocation(); SnapshotData startup_snapshot(startup_sink, startup_serializer);
startup_serializer.FinalizeAllocation(); SnapshotData partial_snapshot(partial_sink, partial_serializer);
WritePayload(partial_sink.data(), FLAG_testing_serialization_file);
WritePayload(startup_sink.data(), startup_name.start());
WriteSpaceUsed(&partial_serializer, FLAG_testing_serialization_file); WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
WriteSpaceUsed(&startup_serializer, startup_name.start()); WritePayload(startup_snapshot.RawData(), startup_name.start());
startup_name.Dispose(); startup_name.Dispose();
} }
...@@ -473,9 +393,8 @@ UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) { ...@@ -473,9 +393,8 @@ UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) {
Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate); Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
Object* root; Object* root;
{ {
SnapshotByteSource source(snapshot, snapshot_size); SnapshotData snapshot_data(snapshot, snapshot_size);
Deserializer deserializer(&source); Deserializer deserializer(&snapshot_data);
ReserveSpaceForSnapshot(&deserializer, file_name);
deserializer.DeserializePartial(isolate, &root); deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsString()); CHECK(root->IsString());
} }
...@@ -485,9 +404,8 @@ UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) { ...@@ -485,9 +404,8 @@ UNINITIALIZED_DEPENDENT_TEST(PartialDeserialization, PartialSerialization) {
Object* root2; Object* root2;
{ {
SnapshotByteSource source(snapshot, snapshot_size); SnapshotData snapshot_data(snapshot, snapshot_size);
Deserializer deserializer(&source); Deserializer deserializer(&snapshot_data);
ReserveSpaceForSnapshot(&deserializer, file_name);
deserializer.DeserializePartial(isolate, &root2); deserializer.DeserializePartial(isolate, &root2);
CHECK(root2->IsString()); CHECK(root2->IsString());
CHECK(*root_handle == root2); CHECK(*root_handle == root2);
...@@ -552,14 +470,11 @@ UNINITIALIZED_TEST(ContextSerialization) { ...@@ -552,14 +470,11 @@ UNINITIALIZED_TEST(ContextSerialization) {
partial_serializer.Serialize(&raw_context); partial_serializer.Serialize(&raw_context);
startup_serializer.SerializeWeakReferences(); startup_serializer.SerializeWeakReferences();
partial_serializer.FinalizeAllocation(); SnapshotData startup_snapshot(startup_sink, startup_serializer);
startup_serializer.FinalizeAllocation(); SnapshotData partial_snapshot(partial_sink, partial_serializer);
WritePayload(partial_sink.data(), FLAG_testing_serialization_file);
WritePayload(startup_sink.data(), startup_name.start());
WriteSpaceUsed(&partial_serializer, FLAG_testing_serialization_file); WritePayload(partial_snapshot.RawData(), FLAG_testing_serialization_file);
WriteSpaceUsed(&startup_serializer, startup_name.start()); WritePayload(startup_snapshot.RawData(), startup_name.start());
startup_name.Dispose(); startup_name.Dispose();
} }
...@@ -588,9 +503,8 @@ UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { ...@@ -588,9 +503,8 @@ UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate); Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
Object* root; Object* root;
{ {
SnapshotByteSource source(snapshot, snapshot_size); SnapshotData snapshot_data(snapshot, snapshot_size);
Deserializer deserializer(&source); Deserializer deserializer(&snapshot_data);
ReserveSpaceForSnapshot(&deserializer, file_name);
deserializer.DeserializePartial(isolate, &root); deserializer.DeserializePartial(isolate, &root);
CHECK(root->IsContext()); CHECK(root->IsContext());
} }
...@@ -600,9 +514,8 @@ UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) { ...@@ -600,9 +514,8 @@ UNINITIALIZED_DEPENDENT_TEST(ContextDeserialization, ContextSerialization) {
Object* root2; Object* root2;
{ {
SnapshotByteSource source(snapshot, snapshot_size); SnapshotData snapshot_data(snapshot, snapshot_size);
Deserializer deserializer(&source); Deserializer deserializer(&snapshot_data);
ReserveSpaceForSnapshot(&deserializer, file_name);
deserializer.DeserializePartial(isolate, &root2); deserializer.DeserializePartial(isolate, &root2);
CHECK(root2->IsContext()); CHECK(root2->IsContext());
CHECK(*root_handle != root2); CHECK(*root_handle != root2);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment