Line data Source code
1 : // Copyright 2015 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "src/profiler/strings-storage.h"
6 :
7 : #include <memory>
8 :
9 : #include "src/objects-inl.h"
10 :
11 : namespace v8 {
12 : namespace internal {
13 :
14 :
15 5171434 : bool StringsStorage::StringsMatch(void* key1, void* key2) {
16 5171434 : return strcmp(reinterpret_cast<char*>(key1), reinterpret_cast<char*>(key2)) ==
17 5171434 : 0;
18 : }
19 :
20 :
21 181794 : StringsStorage::StringsStorage(Heap* heap)
22 363587 : : hash_seed_(heap->HashSeed()), names_(StringsMatch) {}
23 :
24 :
25 178781 : StringsStorage::~StringsStorage() {
26 2187386 : for (base::HashMap::Entry* p = names_.Start(); p != NULL;
27 : p = names_.Next(p)) {
28 1829824 : DeleteArray(reinterpret_cast<const char*>(p->value));
29 : }
30 178781 : }
31 :
32 :
33 29515 : const char* StringsStorage::GetCopy(const char* src) {
34 29515 : int len = static_cast<int>(strlen(src));
35 29515 : base::HashMap::Entry* entry = GetEntry(src, len);
36 29515 : if (entry->value == NULL) {
37 25380 : Vector<char> dst = Vector<char>::New(len + 1);
38 12690 : StrNCpy(dst, src, len);
39 12690 : dst[len] = '\0';
40 12690 : entry->key = dst.start();
41 12690 : entry->value = entry->key;
42 : }
43 29515 : return reinterpret_cast<const char*>(entry->value);
44 : }
45 :
46 :
47 3894240 : const char* StringsStorage::GetFormatted(const char* format, ...) {
48 : va_list args;
49 3894240 : va_start(args, format);
50 3894240 : const char* result = GetVFormatted(format, args);
51 3894240 : va_end(args);
52 3894240 : return result;
53 : }
54 :
55 :
56 6975044 : const char* StringsStorage::AddOrDisposeString(char* str, int len) {
57 6975044 : base::HashMap::Entry* entry = GetEntry(str, len);
58 6975044 : if (entry->value == NULL) {
59 : // New entry added.
60 1825286 : entry->key = str;
61 1825286 : entry->value = str;
62 : } else {
63 : DeleteArray(str);
64 : }
65 6975044 : return reinterpret_cast<const char*>(entry->value);
66 : }
67 :
68 :
69 3894240 : const char* StringsStorage::GetVFormatted(const char* format, va_list args) {
70 3894240 : Vector<char> str = Vector<char>::New(1024);
71 3894240 : int len = VSNPrintF(str, format, args);
72 3894240 : if (len == -1) {
73 : DeleteArray(str.start());
74 0 : return GetCopy(format);
75 : }
76 3894240 : return AddOrDisposeString(str.start(), len);
77 : }
78 :
79 :
80 3104407 : const char* StringsStorage::GetName(Name* name) {
81 3104407 : if (name->IsString()) {
82 : String* str = String::cast(name);
83 : int length = Min(kMaxNameSize, str->length());
84 3080804 : int actual_length = 0;
85 : std::unique_ptr<char[]> data = str->ToCString(
86 3080804 : DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL, 0, length, &actual_length);
87 6161608 : return AddOrDisposeString(data.release(), actual_length);
88 23603 : } else if (name->IsSymbol()) {
89 : return "<symbol>";
90 : }
91 0 : return "";
92 : }
93 :
94 :
95 2931412 : const char* StringsStorage::GetName(int index) {
96 2931412 : return GetFormatted("%d", index);
97 : }
98 :
99 :
100 201858 : const char* StringsStorage::GetFunctionName(Name* name) {
101 201858 : return GetName(name);
102 : }
103 :
104 :
105 29485 : const char* StringsStorage::GetFunctionName(const char* name) {
106 29485 : return GetCopy(name);
107 : }
108 :
109 :
110 0 : size_t StringsStorage::GetUsedMemorySize() const {
111 : size_t size = sizeof(*this);
112 0 : size += sizeof(base::HashMap::Entry) * names_.capacity();
113 0 : for (base::HashMap::Entry* p = names_.Start(); p != NULL;
114 : p = names_.Next(p)) {
115 0 : size += strlen(reinterpret_cast<const char*>(p->value)) + 1;
116 : }
117 0 : return size;
118 : }
119 :
120 7004559 : base::HashMap::Entry* StringsStorage::GetEntry(const char* str, int len) {
121 7004559 : uint32_t hash = StringHasher::HashSequentialString(str, len, hash_seed_);
122 14009118 : return names_.LookupOrInsert(const_cast<char*>(str), hash);
123 : }
124 : } // namespace internal
125 : } // namespace v8
|