Live counters in d8

src/d8.cc

 // Copyright 2008 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 66 matching lines @@
 i::SmartPointer<char> DumbLineEditor::Prompt(const char* prompt) {
   static const int kBufferSize = 256;
   char buffer[kBufferSize];
   printf("%s", prompt);
   char* str = fgets(buffer, kBufferSize, stdin);
   return i::SmartPointer<char>(str ? i::StrDup(str) : str);
 }
 
 
 Shell::CounterMap Shell::counter_map_;
+i::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
+CounterCollection Shell::local_counters_;
+CounterCollection* Shell::counters_ = &local_counters_;
 Persistent<Context> Shell::utility_context_;
 Persistent<Context> Shell::evaluation_context_;
 
 
 // Executes a string within the current v8 context.
 bool Shell::ExecuteString(Handle<String> source,
                           Handle<Value> name,
                           bool print_result,
                           bool report_exceptions) {
   HandleScope handle_scope;
@@ skipping 105 matching lines @@
   Context::Scope context_scope(utility_context_);
   Handle<Object> global = utility_context_->Global();
   Handle<Value> fun = global->Get(String::New("GetCompletions"));
   static const int kArgc = 3;
   Handle<Value> argv[kArgc] = { evaluation_context_->Global(), text, full };
   Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
   return handle_scope.Close(Handle<Array>::Cast(val));
 }
 
 
+int32_t* Counter::Bind(const char* name) {
+  int i;
+  for (i = 0; i < kMaxNameSize - 1 && name[i]; i++)
+    name_[i] = static_cast<char>(name[i]);
+  name_[i] = '\0';
+  return &counter_;
+}
+
+
+CounterCollection::CounterCollection() {
+  magic_number_ = 0xDEADFACE;
+  max_counters_ = kMaxCounters;
+  max_name_size_ = Counter::kMaxNameSize;
+  counters_in_use_ = 0;
+}
+
+
+Counter* CounterCollection::GetNextCounter() {
+  if (counters_in_use_ == kMaxCounters) return NULL;
+  return &counters_[counters_in_use_++];
+}
+
+
+void Shell::MapCounters(const char* name) {
+  counters_file_ = i::OS::MemoryMappedFile::create(name,
+    sizeof(CounterCollection), &local_counters_);
+  void* memory = (counters_file_ == NULL) ?
+      NULL : counters_file_->memory();
+  if (memory == NULL) {
+    printf("Could not map counters file %s\n", name);
+    exit(1);
+  }
+  counters_ = static_cast<CounterCollection*>(memory);
+  V8::SetCounterFunction(LookupCounter);
+}
+
+
 int* Shell::LookupCounter(const char* name) {
   CounterMap::iterator item = counter_map_.find(name);
   if (item != counter_map_.end()) {
     Counter* result = (*item).second;
-    return result->GetValuePtr();
+    return result->ptr();
   }
-  Counter* result = new Counter(name);
-  counter_map_[name] = result;
-  return result->GetValuePtr();
+  Counter* result = counters_->GetNextCounter();
+  if (result == NULL) return NULL;
+  return result->Bind(name);
 }
 
 
 void Shell::Initialize() {
   // Set up counters
+  if (i::FLAG_map_counters != NULL)
+    MapCounters(i::FLAG_map_counters);
   if (i::FLAG_dump_counters)
     V8::SetCounterFunction(LookupCounter);
   // Initialize the global objects
   HandleScope scope;
   Handle<ObjectTemplate> global_template = ObjectTemplate::New();
   global_template->Set(String::New("print"), FunctionTemplate::New(Print));
   global_template->Set(String::New("load"), FunctionTemplate::New(Load));
   global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
   global_template->Set(String::New("version"), FunctionTemplate::New(Version));
 
@@ skipping 43 matching lines @@
 
 void Shell::OnExit() {
   if (i::FLAG_dump_counters) {
     ::printf("+----------------------------------------+----------+\n");
     ::printf("| Name                                   | Value    |\n");
     ::printf("+----------------------------------------+----------+\n");
     for (CounterMap::iterator i = counter_map_.begin();
          i != counter_map_.end();
          i++) {
       Counter* counter = (*i).second;
-      ::printf("| %-38s | %8i |\n", counter->name(), counter->value());
+      ::printf("| %-38s | %8i |\n", (*i).first, counter->value());
     }
     ::printf("+----------------------------------------+----------+\n");
   }
+  if (counters_file_ != NULL)
+    delete counters_file_;
 }
 
 
 // Reads a file into a v8 string.
 Handle<String> Shell::ReadFile(const char* name) {
   FILE* file = i::OS::FOpen(name, "rb");
   if (file == NULL) return Handle<String>();
 
   fseek(file, 0, SEEK_END);
   int size = ftell(file);
@@ skipping 73 matching lines @@
   return 0;
 }
 
 
 }  // namespace v8
 
 
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }