Involve more log compression techniques.

src/log-utils.h

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 70 matching lines @@
   const char* seal_;
   const int seal_size_;
   ScopedVector<char*> blocks_;
   int write_pos_;
   int block_index_;
   int block_write_pos_;
   bool is_sealed_;
 };
 
 
-// An utility class for performing backward reference compression
-// of string ends. It operates using a window of previous strings.
-class LogRecordCompressor {
- public:
-  // 'window_size' is the size of backward lookup window.
-  // 'start_pos' is the length of string prefix that must be left uncompressed.
-  LogRecordCompressor(int window_size, int start_pos)
-      : buffer_(window_size), start_pos_(start_pos), curr_(-1), prev_(-1) {
-    // Must have place for the current record and the previous.
-    ASSERT(window_size >= 2);
-  }
-  ~LogRecordCompressor();
-
-  // Fills vector with a compressed version of the previous record.
-  // Returns false if there is no previous record.
-  bool RetrievePreviousCompressed(Vector<char>* prev_record);
-
-  // Stores a record if it differs from a previous one (or there's no previous).
-  // Returns true, if the record has been stored.
-  bool Store(const Vector<const char>& record);
-
- private:
-  // Record field separator. It is assumed that it can't appear
-  // inside a field (a simplified version of CSV format).
-  static const char kFieldSeparator = ',';
-
-  // Formatting string for back references.
-  static const char* kBackwardReferenceFormat;
-
-  // A boundary value. If current record only differs in
-  // kUncompressibleBound chars, don't compress it.
-  // The value must be greater than the length of maximum
-  // projected backward reference length.
-  static const intptr_t kUncompressibleBound = 10;
-
-  ScopedVector< Vector<const char> > buffer_;
-  const int start_pos_;
-  int curr_;
-  int prev_;
-};
-
-
 // Functions and data for performing output of log messages.
 class Log : public AllStatic {
  public:
   // Opens stdout for logging.
   static void OpenStdout();
 
   // Opens file for logging.
   static void OpenFile(const char* name);
 
   // Opens memory buffer for logging.
   static void OpenMemoryBuffer();
 
   // Disables logging, but preserves acquired resources.
   static void stop() { is_stopped_ = true; }
 
   // Frees all resources acquired in Open... functions.
   static void Close();
 
   // See description in include/v8.h.
   static int GetLogLines(int from_pos, char* dest_buf, int max_size);
 
   // Returns whether logging is enabled.
   static bool IsEnabled() {
     return !is_stopped_ && (output_handle_ != NULL || output_buffer_ != NULL);
   }
 
-  // Size of buffer used for record compression.
-  static const int kRecordCompressorWindow = 6;
-
  private:
   typedef int (*WritePtr)(const char* msg, int length);
 
   // Initialization function called from Open... functions.
   static void Init();
 
   // Write functions assume that mutex_ is acquired by the caller.
   static WritePtr Write;
 
   // Implementation of writing to a log file.
@@ skipping 35 matching lines @@
   // access to the formatting buffer and the log file or log memory buffer.
   static Mutex* mutex_;
 
   // Size of buffer used for formatting log messages.
   static const int kMessageBufferSize = 2048;
 
   // Buffer used for formatting log messages. This is a singleton buffer and
   // mutex_ should be acquired before using it.
   static char* message_buffer_;
 
-  // An utility object for compressing repeated parts of records.
-  static LogRecordCompressor* record_compressor_;
-
-  static const char* kCompressedTickEventName;
-
   friend class LogMessageBuilder;
+  friend class LogRecordCompressor;
 };
 
 
+// An utility class for performing backward reference compression
+// of string ends. It operates using a window of previous strings.
+class LogRecordCompressor {
+ public:
+  // 'window_size' is the size of backward lookup window.
+  explicit LogRecordCompressor(int window_size)
+      : buffer_(window_size + kNoCompressionWindowSize),
+        kMaxBackwardReferenceSize(
+            GetBackwardReferenceSize(window_size, Log::kMessageBufferSize)),
+        curr_(-1), prev_(-1) {
+  }
+
+  ~LogRecordCompressor();
+
+  // Fills vector with a compressed version of the previous record.
+  // Returns false if there is no previous record.
+  bool RetrievePreviousCompressed(Vector<char>* prev_record);
+
+  // Stores a record if it differs from a previous one (or there's no previous).
+  // Returns true, if the record has been stored.
+  bool Store(const Vector<const char>& record);
+
+ private:
+  // The minimum size of a buffer: a place needed for the current and
+  // the previous record. Since there is no place for precedessors of a previous
+  // record, it can't be compressed at all.
+  static const int kNoCompressionWindowSize = 2;
+
+  // Formatting strings for back references.
+  static const char* kLineBackwardReferenceFormat;
+  static const char* kBackwardReferenceFormat;
+
+  static int GetBackwardReferenceSize(int distance, int pos);
+
+  static void PrintBackwardReference(Vector<char> dest, int distance, int pos);
+
+  ScopedVector< Vector<const char> > buffer_;
+  const int kMaxBackwardReferenceSize;
+  int curr_;
+  int prev_;
+};
+
+
 // Utility class for formatting log messages. It fills the message into the
 // static buffer in Log.
 class LogMessageBuilder BASE_EMBEDDED {
  public:
   // Create a message builder starting from position 0. This acquires the mutex
   // in the log as well.
   explicit LogMessageBuilder();
   ~LogMessageBuilder() { }
 
   // Append string data to the log message.
   void Append(const char* format, ...);
 
   // Append string data to the log message.
   void Append(const char* format, va_list args);
 
   // Append a character to the log message.
   void Append(const char c);
 
   // Append a heap string.
   void Append(String* str);
 
+  // Appends an address, compressing it if needed by offsetting
+  // from Logger::last_address_.
+  void AppendAddress(Address addr);
+
+  // Appends an address, compressing it if needed.
+  void AppendAddress(Address addr, Address bias);
+
   void AppendDetailed(String* str, bool show_impl_info);
 
   // Stores log message into compressor, returns true if the message
-  // was stored (i.e. doesn't repeat the previous one). If log compression is
-  // disabled, does nothing and returns true.
-  bool StoreInCompressor();
+  // was stored (i.e. doesn't repeat the previous one).
+  bool StoreInCompressor(LogRecordCompressor* compressor);
 
   // Sets log message to a previous version of compressed message.
-  // Returns false, if there is no previous message. If log compression
-  // is disabled, does nothing and retuns true.
-  bool RetrieveCompressedPrevious() { return RetrieveCompressedPrevious(""); }
+  // Returns false, if there is no previous message.
+  bool RetrieveCompressedPrevious(LogRecordCompressor* compressor) {
+    return RetrieveCompressedPrevious(compressor, "");
+  }
 
   // Does the same at the version without arguments, and sets a prefix.
-  bool RetrieveCompressedPrevious(const char* prefix);
+  bool RetrieveCompressedPrevious(LogRecordCompressor* compressor,
+                                  const char* prefix);
 
   // Write the log message to the log file currently opened.
   void WriteToLogFile();
 
   // Write a null-terminated string to to the log file currently opened.
   void WriteCStringToLogFile(const char* str);
 
   // A handler that is called when Log::Write fails.
   typedef void (*WriteFailureHandler)();
 
   static void set_write_failure_handler(WriteFailureHandler handler) {
     write_failure_handler = handler;
   }
 
  private:
   static WriteFailureHandler write_failure_handler;
 
   ScopedLock sl;
   int pos_;
 };
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal
 
 #endif  // V8_LOG_UTILS_H_