OLD | NEW |
1 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2017, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "platform/globals.h" | 5 #include "platform/globals.h" |
6 | 6 |
7 #if defined(DART_USE_TCMALLOC) && !defined(PRODUCT) && \ | 7 #if defined(DART_USE_TCMALLOC) && !defined(PRODUCT) && !defined(TARGET_ARCH_DBC) |
8 !defined(TARGET_ARCH_DBC) && !defined(HOST_OS_FUCHSIA) | |
9 | 8 |
10 #include "vm/malloc_hooks.h" | 9 #include "vm/malloc_hooks.h" |
11 | 10 |
12 #include "gperftools/malloc_hook.h" | 11 #include "gperftools/malloc_hook.h" |
13 | 12 |
14 #include "platform/assert.h" | 13 #include "platform/assert.h" |
15 #include "vm/hash_map.h" | 14 #include "vm/hash_map.h" |
16 #include "vm/json_stream.h" | 15 #include "vm/json_stream.h" |
17 #include "vm/os_thread.h" | 16 #include "vm/os_thread.h" |
18 #include "vm/profiler.h" | 17 #include "vm/profiler.h" |
(...skipping 236 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
255 ASSERT(malloc_hook_mutex()->IsOwnedByCurrentThread()); | 254 ASSERT(malloc_hook_mutex()->IsOwnedByCurrentThread()); |
256 active_ = false; | 255 active_ = false; |
257 original_pid_ = kInvalidPid; | 256 original_pid_ = kInvalidPid; |
258 ResetStats(); | 257 ResetStats(); |
259 delete address_map_; | 258 delete address_map_; |
260 address_map_ = NULL; | 259 address_map_ = NULL; |
261 } | 260 } |
262 | 261 |
263 | 262 |
264 void MallocHooks::InitOnce() { | 263 void MallocHooks::InitOnce() { |
265 if (!FLAG_enable_malloc_hooks || MallocHooks::Active()) { | 264 if (!FLAG_profiler_native_memory || MallocHooks::Active()) { |
266 return; | 265 return; |
267 } | 266 } |
268 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 267 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
269 MallocHooksState::malloc_hook_mutex_owner()); | 268 MallocHooksState::malloc_hook_mutex_owner()); |
270 ASSERT(!MallocHooksState::Active()); | 269 ASSERT(!MallocHooksState::Active()); |
271 | 270 |
272 MallocHooksState::Init(); | 271 MallocHooksState::Init(); |
273 | 272 |
274 // Register malloc hooks. | 273 // Register malloc hooks. |
275 bool success = false; | 274 bool success = false; |
276 success = MallocHook::AddNewHook(&MallocHooksState::RecordAllocHook); | 275 success = MallocHook::AddNewHook(&MallocHooksState::RecordAllocHook); |
277 ASSERT(success); | 276 ASSERT(success); |
278 success = MallocHook::AddDeleteHook(&MallocHooksState::RecordFreeHook); | 277 success = MallocHook::AddDeleteHook(&MallocHooksState::RecordFreeHook); |
279 ASSERT(success); | 278 ASSERT(success); |
280 } | 279 } |
281 | 280 |
282 | 281 |
283 void MallocHooks::TearDown() { | 282 void MallocHooks::TearDown() { |
284 if (!FLAG_enable_malloc_hooks || !MallocHooks::Active()) { | 283 if (!FLAG_profiler_native_memory || !MallocHooks::Active()) { |
285 return; | 284 return; |
286 } | 285 } |
287 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 286 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
288 MallocHooksState::malloc_hook_mutex_owner()); | 287 MallocHooksState::malloc_hook_mutex_owner()); |
289 ASSERT(MallocHooksState::Active()); | 288 ASSERT(MallocHooksState::Active()); |
290 | 289 |
291 // Remove malloc hooks. | 290 // Remove malloc hooks. |
292 bool success = false; | 291 bool success = false; |
293 success = MallocHook::RemoveNewHook(&MallocHooksState::RecordAllocHook); | 292 success = MallocHook::RemoveNewHook(&MallocHooksState::RecordAllocHook); |
294 ASSERT(success); | 293 ASSERT(success); |
(...skipping 17 matching lines...) Expand all Loading... |
312 | 311 |
313 | 312 |
314 void MallocHooks::set_stack_trace_collection_enabled(bool enabled) { | 313 void MallocHooks::set_stack_trace_collection_enabled(bool enabled) { |
315 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 314 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
316 MallocHooksState::malloc_hook_mutex_owner()); | 315 MallocHooksState::malloc_hook_mutex_owner()); |
317 MallocHooksState::set_stack_trace_collection_enabled(enabled); | 316 MallocHooksState::set_stack_trace_collection_enabled(enabled); |
318 } | 317 } |
319 | 318 |
320 | 319 |
321 void MallocHooks::ResetStats() { | 320 void MallocHooks::ResetStats() { |
322 if (!FLAG_enable_malloc_hooks) { | 321 if (!FLAG_profiler_native_memory) { |
323 return; | 322 return; |
324 } | 323 } |
325 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 324 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
326 MallocHooksState::malloc_hook_mutex_owner()); | 325 MallocHooksState::malloc_hook_mutex_owner()); |
327 if (MallocHooksState::Active()) { | 326 if (MallocHooksState::Active()) { |
328 MallocHooksState::ResetStats(); | 327 MallocHooksState::ResetStats(); |
329 } | 328 } |
330 } | 329 } |
331 | 330 |
332 | 331 |
333 bool MallocHooks::Active() { | 332 bool MallocHooks::Active() { |
334 if (!FLAG_enable_malloc_hooks) { | 333 if (!FLAG_profiler_native_memory) { |
335 return false; | 334 return false; |
336 } | 335 } |
337 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 336 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
338 MallocHooksState::malloc_hook_mutex_owner()); | 337 MallocHooksState::malloc_hook_mutex_owner()); |
339 | 338 |
340 return MallocHooksState::Active(); | 339 return MallocHooksState::Active(); |
341 } | 340 } |
342 | 341 |
343 | 342 |
344 void MallocHooks::PrintToJSONObject(JSONObject* jsobj) { | 343 void MallocHooks::PrintToJSONObject(JSONObject* jsobj) { |
345 if (!FLAG_enable_malloc_hooks) { | 344 if (!FLAG_profiler_native_memory) { |
346 return; | 345 return; |
347 } | 346 } |
348 intptr_t allocated_memory = 0; | 347 intptr_t allocated_memory = 0; |
349 intptr_t allocation_count = 0; | 348 intptr_t allocation_count = 0; |
350 bool add_usage = false; | 349 bool add_usage = false; |
351 // AddProperty may call malloc which would result in an attempt | 350 // AddProperty may call malloc which would result in an attempt |
352 // to acquire the lock recursively so we extract the values first | 351 // to acquire the lock recursively so we extract the values first |
353 // and then add the JSON properties. | 352 // and then add the JSON properties. |
354 { | 353 { |
355 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 354 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
356 MallocHooksState::malloc_hook_mutex_owner()); | 355 MallocHooksState::malloc_hook_mutex_owner()); |
357 if (MallocHooksState::Active()) { | 356 if (MallocHooksState::Active()) { |
358 allocated_memory = MallocHooksState::heap_allocated_memory_in_bytes(); | 357 allocated_memory = MallocHooksState::heap_allocated_memory_in_bytes(); |
359 allocation_count = MallocHooksState::allocation_count(); | 358 allocation_count = MallocHooksState::allocation_count(); |
360 add_usage = true; | 359 add_usage = true; |
361 } | 360 } |
362 } | 361 } |
363 if (add_usage) { | 362 if (add_usage) { |
364 jsobj->AddProperty("_heapAllocatedMemoryUsage", allocated_memory); | 363 jsobj->AddProperty("_heapAllocatedMemoryUsage", allocated_memory); |
365 jsobj->AddProperty("_heapAllocationCount", allocation_count); | 364 jsobj->AddProperty("_heapAllocationCount", allocation_count); |
366 } | 365 } |
367 } | 366 } |
368 | 367 |
369 | 368 |
370 intptr_t MallocHooks::allocation_count() { | 369 intptr_t MallocHooks::allocation_count() { |
371 if (!FLAG_enable_malloc_hooks) { | 370 if (!FLAG_profiler_native_memory) { |
372 return 0; | 371 return 0; |
373 } | 372 } |
374 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 373 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
375 MallocHooksState::malloc_hook_mutex_owner()); | 374 MallocHooksState::malloc_hook_mutex_owner()); |
376 return MallocHooksState::allocation_count(); | 375 return MallocHooksState::allocation_count(); |
377 } | 376 } |
378 | 377 |
379 | 378 |
380 intptr_t MallocHooks::heap_allocated_memory_in_bytes() { | 379 intptr_t MallocHooks::heap_allocated_memory_in_bytes() { |
381 if (!FLAG_enable_malloc_hooks) { | 380 if (!FLAG_profiler_native_memory) { |
382 return 0; | 381 return 0; |
383 } | 382 } |
384 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 383 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
385 MallocHooksState::malloc_hook_mutex_owner()); | 384 MallocHooksState::malloc_hook_mutex_owner()); |
386 return MallocHooksState::heap_allocated_memory_in_bytes(); | 385 return MallocHooksState::heap_allocated_memory_in_bytes(); |
387 } | 386 } |
388 | 387 |
389 | 388 |
390 Sample* MallocHooks::GetSample(const void* ptr) { | 389 Sample* MallocHooks::GetSample(const void* ptr) { |
391 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), | 390 MallocLocker ml(MallocHooksState::malloc_hook_mutex(), |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
439 ASSERT(result); | 438 ASSERT(result); |
440 delete allocation_info; | 439 delete allocation_info; |
441 } | 440 } |
442 } | 441 } |
443 } | 442 } |
444 | 443 |
445 } // namespace dart | 444 } // namespace dart |
446 | 445 |
447 #endif // defined(DART_USE_TCMALLOC) && !defined(PRODUCT) && | 446 #endif // defined(DART_USE_TCMALLOC) && !defined(PRODUCT) && |
448 // !defined(TARGET_ARCH_DBC) && !defined(HOST_OS_FUCHSIA) | 447 // !defined(TARGET_ARCH_DBC) && !defined(HOST_OS_FUCHSIA) |
OLD | NEW |