HeapInspector-for-iOS - Find memory issues & leaks in your iOS app without instruments

  •        62

HeapInspector is a debug tool that monitors the memory heap with backtrace recording in your iOS app. You can discover memory leaks, no longer used objects, abandoned memory and more issues directly on your device without ever starting Instruments. Since ARC has been introduced we don't need to manage the retain & release anymore. ARC is very powerful and makes Objective-C more stable. ARC decreased the number of crashes and improves the memory footprint. ARC is technically doing a powerful job. It knows when to retain, autorelease and release. But ARC doesn't think about the overall architecture how to design for low memory usage. You should be aware that you can still do a lot of things wrong with your memory (even with ARC). You can still get memory pressures or peaks with ARC.

https://github.com/tapwork/HeapInspector-for-iOS

Tags
Implementation
License
Platform

   




Related Projects

LifetimeTracker - Find retain cycles / memory leaks sooner.

  •    Swift

LifetimeTracker can surface retain cycle / memory issues right as you develop your application, and it will surface them to you immediately, so you can find them with more ease. Instruments and Memory Graph Debugger are great, but too many times developers forget to check for issues as they close the feature implementation.

stackimpact-python - StackImpact Python Profiler - Production-Grade Performance Profiler: CPU, memory allocations, blocking calls, exceptions, metrics, and more

  •    Python

StackImpact is a production-grade performance profiler built for both production and development environments. It gives developers continuous and historical code-level view of application performance that is essential for locating CPU, memory allocation and I/O hot spots as well as latency bottlenecks. Included runtime metrics and error monitoring complement profiles for extensive performance analysis. Learn more at stackimpact.com. Learn more on the features page (with screenshots).

Apache Mnemonic - Non-volatile hybrid memory storage oriented library

  •    Java

Apache Mnemonic is a non-volatile hybrid memory storage oriented library, it proposed a non-volatile/durable Java object model and durable computing service that bring several advantages to significantly improve the performance of massive real-time data processing/analytics. developers are able to use this library to design their cache-less and SerDe-less high performance applications.

memory-allocators - Custom memory allocators in C++ to improve the performance of dynamic memory allocation

  •    C++

When applications need more memory this can be allocated in the heap (rather than in the stack) in runtime. This memory is called 'dynamic memory' because it can't be known at compile time and its need changes during the execution. Our programs can ask for dynamic memory usin 'malloc'. Malloc returns an address to a position in memory where we can store our data. Once we're done with that data, we can call 'free' to free the memory and let others processes use it. For this project I've implemented different ways to manage by ourselves dynamic memory in C++.This means that instead of using native calls like 'malloc' or 'free' we're going to use a custom memory allocator that will do this for us but in a more efficient way. The goal, then, is to understand how the most common allocators work, what they offer and compare them to see which one performs better.


MLeaksFinder - Find memory leaks in your iOS app at develop time.

  •    Objective-C

MLeaksFinder helps you find memory leaks in your iOS apps at develop time. It can automatically find leaks in UIView and UIViewController objects, present an alert with the leaked object in its View-ViewController stack when leaks happening. More over, it can try to find a retain cycle for the leaked object using FBRetainCycleDetector. Besides finding leaks in UIView and UIViewController objects, developers can extend it to find leaks in other kinds of objects. MLeaksFinder comes into effect after pod install, there is no need to add any code nor to import any header file.

FBRetainCycleDetector - iOS library to help detecting retain cycles in runtime.

  •    Objective-C++

An iOS library that finds retain cycles using runtime analysis.Retain cycles are one of the most common ways of creating memory leaks. It's incredibly easy to create a retain cycle, and tends to be hard to spot it. The goal of FBRetainCycleDetector is to help find retain cycles at runtime. The features of this project were influenced by Circle.

Memprof - A Ruby gem for memory profiling

  •    Ruby

Memprof is a Ruby level memory profiler that can help you find reference leaks in your application. Memprof can also do very lightweight function call tracing to help you figure out which system calls, and library calls your code causes. Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM.

Agrona - Library to build high-performance applications in Java and C++

  •    Java

Agrona provides a library of data structures and utility methods that are a common need when building high-performance applications in Java and C++. It supports Buffers, Map, Sets, Cache, Queues and lot more.

OOMDetector - OOMDetector is a memory monitoring component for iOS which provides you with OOM monitoring, memory allocation monitoring, memory leak detection and other functions

  •    Objective-C++

OOMDetector is a memory monitoring component for iOS which provides you with OOM monitoring, memory allocation monitoring, memory leak detection and other functions.

atop - System and process monitor for Linux

  •    C

Atop is an ASCII full-screen performance monitor for Linux that is capable of reporting the activity of all processes (even if processes have finished during the interval), daily logging of system and process activity for long-term analysis, highlighting overloaded system resources by using colors, etcetera. At regular intervals, it shows system-level activity related to the CPU, memory, swap, disks (including LVM) and network layers, and for every process (and thread) it shows e.g. the CPU utilization, memory growth, disk utilization, priority, username, state, and exit code. In combination with the optional kernel module netatop, it even shows network activity per process/thread. In combination with the optional daemon atopgpud, it also shows GPU activity on system level and process level. Resource consumption by all processes. It shows the resource consumption by all processes that were active during the interval, so also the resource consumption by those processes that have finished during the interval.

node-memory-leak-tutorial - A tutorial for debugging memory leaks in node

  •    Javascript

This is a quick tutorial for debugging memory leaks in node.js.First of all, you need to install the v8-profiler module. Without that required from within your app, you will not be able to take heap snapshots in the debugger.

dbgmem

  •    C

DBGMEM is a memory debugger designed for large scale C and C++ programs on Linux. It helps you to find: memory leaks, heap memory corruption, passing of illegal argument to selected standard library functions, use of freed or uninitialized heap blocks

FASTER - Fast key-value store from Microsoft Research

  •    CSharp

Managing large application state easily and with high performance is one of the hardest problems in the cloud today. We present FASTER, a new concurrent key-value store designed for point lookups and heavy updates. FASTER supports data larger than memory, by leveraging fast external storage. What differentiates FASTER are its cache-optimized index that achieves very high performance — up to 160 million operations per second when data fits in memory; its unique “hybrid record log” design that combines a traditional persistent log with in-place updates, to shape the memory working set and retain performance; and its architecture as an component that can be embedded in cloud apps. FASTER achieves higher throughput than current systems, by more than two orders of magnitude, and scales better than current pure in-memory data structures, for in-memory working sets. FASTER also offers a new consistent recovery scheme that achieves better performance at the expense of slightly higher commit latency. Go to our website for more details and papers.

scala-offheap - Experimental type-safe off-heap memory for Scala.

  •    Scala

Garbage collection is the standard memory management paradigm on the JVM. In theory, it lets one completely forget about the hurdles of memory management and delegate all of it to the underlying runtime. In practice, GC often leads to scalability issues on large heaps and latency-sensitive workloads. The goal of this project is to expose a completely different memory management paradigm to the developers: explicitly annotated region-based memory. This paradigm gives more control over memory management without the need to micro-manage allocations.

goappmonitor - Golang application performance data monitoring.

  •    Go

Golang application performance data monitoring.GoAppMonitor is a library which provides a monitor on your golang applications. It contains system level based monitoring and business level monitoring(custom monitoring).Just add the repository into your apps and register what you want to monitoring.

MTHawkeye - Profiling / Debugging assist tools for iOS

  •    Objective-C

MTHawkeye is profiling, debugging tools for iOS used in Meitu. It's designed to help iOS developers improve development productivity and assist in optimizing the App performance. During the App product development cycle, we introduced MTHawkeye to help us discover, find, analyze, locate, and solve problems faster.

WatchdogInspector - Shows your current framerate (fps) in the status bar of your iOS app

  •    Shell

WatchdogInspector counts your app's framerate and displays the fps in the status bar. The coloured status bar lets you know when your framerate drops below 60 fps. If everything is fine your status bar gets happy and will stay green. To detect unwanted main thread stalls you can set a custom watchdog timeout. and run pod install You can see the example project how to setup and run WatchdogInspector Make sure that you don't use WatchdogInspector in production.

Chronicle Map - High performance, off-heap, key-value, in memory, persisted data store

  •    Java

Chronicle Map is a high performance, off-heap, key-value, in memory, persisted data store. It works like a standard java map yet it automatically distributes data between processes, these processes can be both on the same server or across your network. In other words its a low latency, huge data key value store, which can store terabytes of data locally to your process.

DiskCache - Python disk backed cache (Django-compatible). Faster than Redis and Memcached. Pure-Python

  •    Python

DiskCache is a disk and file backed cache library, written in pure-Python, and compatible with Django. The cloud-based computing of 2021 puts a premium on memory. Gigabytes of empty space is left on disks as processes vie for memory. Among these processes is Memcached (and sometimes Redis) which is used as a cache. It is good to use empty disk space for caching.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.