First step towards generation of application script snapshots

vm/snapshot.h

 // Copyright (c) 2011, 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 VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "vm/allocation.h"
 #include "vm/assert.h"
 #include "vm/bitfield.h"
 #include "vm/globals.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // Forward declarations.
 class Heap;
+class Library;
+class Object;
 class ObjectStore;
 class RawClass;
 class RawObject;
-class Object;
 
 static const int8_t kSerializedBitsPerByte = 7;
 static const int8_t kMaxSerializedUnsignedValuePerByte = 127;
 static const int8_t kMaxSerializedValuePerByte = 63;
 static const int8_t kMinSerializedValuePerByte = -64;
 static const uint8_t kEndByteMarker = (255 - kMaxSerializedValuePerByte);
 static const int8_t kSerializedByteMask = (1 << kSerializedBitsPerByte) - 1;
 
 // Serialized object header encoding is as follows:
 // - Smi: the Smi value is written as is (last bit is not tagged).
@@ skipping 14 matching lines @@
 };
 
 
 class SerializedHeaderData : public BitField<intptr_t, 2, 30> {
 };
 
 
 // Structure capturing the raw snapshot.
 class Snapshot {
  public:
+  enum Kind {
+    kFull = 0,  // Full snapshot of the current dart heap.
+    kScript,    // A partial snapshot of only the application script.
+    kMessage,   // A partial snapshot used only for isolate messaging.
+  };
+
   static const int kHeaderSize = 2 * sizeof(int32_t);
   static const int kLengthIndex = 0;
   static const int kSnapshotFlagIndex = 1;
 
   static const Snapshot* SetupFromBuffer(const void* raw_memory);
 
   // Getters.
   const uint8_t* content() const { return content_; }
   int32_t length() const { return length_; }
+  Kind kind() const { return static_cast<Kind>(kind_); }
 
-  bool IsPartialSnapshot() const { return full_snapshot_ == 0; }
-  bool IsFullSnapshot() const { return full_snapshot_ != 0; }
+  bool IsMessageSnapshot() const { return kind_ == kMessage; }
+  bool IsScriptSnapshot() const { return kind_ == kScript; }
+  bool IsFullSnapshot() const { return kind_ == kFull; }
   int32_t Size() const { return length_ + sizeof(Snapshot); }
   uint8_t* Addr() { return reinterpret_cast<uint8_t*>(this); }
 
   static intptr_t length_offset() { return OFFSET_OF(Snapshot, length_); }
-  static intptr_t full_snapshot_offset() {
-    return OFFSET_OF(Snapshot, full_snapshot_);
+  static intptr_t kind_offset() {
+    return OFFSET_OF(Snapshot, kind_);
   }
 
  private:
-  Snapshot() : length_(0), full_snapshot_(0) {}
+  Snapshot() : length_(0), kind_(kFull) {}
 
   int32_t length_;  // Stream length.
-  int32_t full_snapshot_;  // Classes are serialized too.
+  int32_t kind_;  // Kind of snapshot.
   uint8_t content_[];  // Stream content.
 
   DISALLOW_COPY_AND_ASSIGN(Snapshot);
 };
 
 
 // Stream for reading various types from a buffer.
 class ReadStream : public ValueObject {
  public:
   ReadStream(const uint8_t* buffer, intptr_t size) : buffer_(buffer),
@@ skipping 170 matching lines @@
 };
 
 
 // Reads a snapshot into objects.
 class SnapshotReader {
  public:
   SnapshotReader(const Snapshot* snapshot,
                  Heap* heap,
                  ObjectStore* object_store)
       : stream_(snapshot->content(), snapshot->length()),
-        classes_serialized_(snapshot->IsFullSnapshot()),
+        kind_(snapshot->kind()),
         heap_(heap),
         object_store_(object_store),
         backward_references_() { }
   ~SnapshotReader() { }
 
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
@@ skipping 21 matching lines @@
   // or an object that was already serialized before).
   RawObject* ReadIndexedObject(intptr_t object_id);
 
   // Read an inlined object from the stream.
   RawObject* ReadInlinedObject(intptr_t object_id);
 
   // Based on header field check to see if it is an internal VM class.
   RawClass* LookupInternalClass(intptr_t class_header);
 
   ReadStream stream_;  // input stream.
-  bool classes_serialized_;  // Indicates if classes are serialized.
+  Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
   Heap* heap_;  // Heap into which the objects are deserialized into.
   ObjectStore* object_store_;  // Object store for common classes.
   GrowableArray<Object*> backward_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
 class MessageWriter {
  public:
@@ skipping 21 matching lines @@
     value = SerializedHeaderData::update(id, value);
     Write<uword>(value);
   }
 
   // Finalize the serialized buffer by filling in the header information
   // which comprises of a flag(full/partial snaphot) and the length of
   // serialzed bytes.
   void FinalizeBuffer() {
     int32_t* data = reinterpret_cast<int32_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
-    data[Snapshot::kSnapshotFlagIndex] = false;
+    data[Snapshot::kSnapshotFlagIndex] = Snapshot::kMessage;
   }
 
   WriteStream stream_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageWriter);
 };
 
 
 class SnapshotWriter {
  public:
-  SnapshotWriter(bool full_snapshot, uint8_t** buffer, ReAlloc alloc)
+  SnapshotWriter(Snapshot::Kind kind, uint8_t** buffer, ReAlloc alloc)
       : stream_(buffer, alloc),
-        serialize_classes_(full_snapshot),
+        kind_(kind),
         object_store_(Isolate::Current()->object_store()),
         forward_list_() {
     ASSERT(buffer != NULL);
     ASSERT(alloc != NULL);
   }
   ~SnapshotWriter() { }
 
   // Size of the snapshot.
   intptr_t Size() const { return stream_.bytes_written(); }
 
   // Finalize the serialized buffer by filling in the header information
   // which comprises of a flag(full/partial snaphot) and the length of
   // serialzed bytes.
   void FinalizeBuffer() {
     int32_t* data = reinterpret_cast<int32_t*>(stream_.buffer());
     data[Snapshot::kLengthIndex] = stream_.bytes_written();
-    data[Snapshot::kSnapshotFlagIndex] = serialize_classes_;
+    data[Snapshot::kSnapshotFlagIndex] = kind_;
     UnmarkAll();
   }
 
   // Writes raw data to the stream (basic type).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   void Write(T value) {
     WriteStream::Raw<sizeof(T), T>::Write(&stream_, value);
   }
 
@@ skipping 25 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(ForwardObjectNode);
   };
 
   intptr_t MarkObject(RawObject* raw, RawClass* cls);
 
   void WriteInlinedObject(RawObject* raw);
 
   ObjectStore* object_store() const { return object_store_; }
 
   WriteStream stream_;
-  bool serialize_classes_;
+  Snapshot::Kind kind_;
   ObjectStore* object_store_;  // Object store for common classes.
   GrowableArray<ForwardObjectNode*> forward_list_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
+class ScriptSnapshotWriter : public SnapshotWriter {
+ public:
+  ScriptSnapshotWriter(const Library& lib, uint8_t** buffer, ReAlloc alloc)
+      : SnapshotWriter(Snapshot::kScript, buffer, alloc) {
+    ASSERT(buffer != NULL);
+    ASSERT(alloc != NULL);
+  }
+  ~ScriptSnapshotWriter() { }
+
+  // Writes a partial snapshot of the script.
+  void WriteScriptSnapshot();
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ScriptSnapshotWriter);
+};
+
+
 // An object pointer visitor implementation which writes out
 // objects to a snap shot.
 class SnapshotWriterVisitor : public ObjectPointerVisitor {
  public:
   explicit SnapshotWriterVisitor(SnapshotWriter* writer) : writer_(writer) {}
 
   virtual void VisitPointers(RawObject** first, RawObject** last);
 
  private:
   SnapshotWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_