Yahoo Web Search

Search results

1. • • Programmers ask the heap manager to allocate these regions of memory via calls to heap functions like malloc. These allocated regions of memory, or “allocations”, can then be used, modified or referenced by the programmer up until the programmer no longer needs it and returns the allocation back to the heap manager via a call to free.
     azeria-labs.com › heap-exploitation-part-1-understanding-the-glibc-heap-implementation

     Heap Exploitation Part 1: Understanding the Glibc Heap ...

2. Top results related to how does a heap manager work?

   • How does the heap manager in java or C++ keep track of all the memory locations used by the threads or processes?

     Top Answer

     Answered Jun 13, 2013 · 2 votes

     Note that unmanaged languages are going to be allocating/freeing memory through system calls, generally not managing it themselves. Still regardless of what level of abstraction (OS to the run time), something has to deal with this:

     One method is called buddy block allocation, described well with an example on Wikipedia. It essentially keeps track of the usage of spaces in memory of varying sizes (typically multiples of 2). This can be done with a number of arrays with clever indexing, or perhaps more intuitively with a binary tree, each node tell whether a certain block is free, all nodes on a level representing the same size block.

     This suffers from internal fragmentation; as things come and go, you might ended up with your data scattered rather than being efficiently consolidated, making it harder to fit in large data. This could be countered by a more complicated, dynamic system, but buddy blocks have the advantage of simplicity.

     Check all answers on Stack Overflow

     1/5

   • How does a Mutex work? Does a mutex protect variables globally? Does the scope in which it is defined matter?

     Top Answer

     Answered Nov 15, 2022 · 7 votes

     So my question has become simply "are mutexes global?"

     No. A mutex has a lock() and an unlock() method, and the only thing a mutex does is cause its lock() call (from any thread) not to return for as long as another thread has that mutex locked. When the thread that was holding the mutex locked calls unlock(), that is when the lock() call will return in the first thread. That way it is guaranteed that only a single thread will be holding the mutex-lock (i.e. executing in the region between its lock() call and its unlock() call) at any given time.

     That's really all there is to it. So a mutex will effect only the threads that call lock() on that particular mutex, and nothing else.

     Mutex stands for "Mutual Exclusion" - using one correctly ensures that only one thread at a time will ever be executing any "critical section" protected by the same mutex.

     If there are some variables you only ever modify inside critical sections protected by the same mutex, your code doesn't have a data race. No matter whether they're global, static, or pointed to by different variables in different threads or any other way two threads might have a reference to the same object.

     Check all answers on Stack Overflow

     2/5

   • how does a pointer know its at the end of a heap memory?

     Top Answer

     Answered Aug 11, 2021 · 6 votes

     how does a pointer know its at the end of a heap memory?

     A pointer is "dumb". It doesn't know such thing.

     How can I initialize values in the block of memory on the heap using the dereference and increment operators? I don't think the code below is correct.

     Here is a corrected version:

     int* it = p;int* end = p + 5;while(it != end){ *it++ = ++val; }

     P.S. Don't increment the pointer that owns the resource.

     P.P.S. Avoid owning bare pointers.

     P.P.P.S. Avoid unnecessary dynamic allocation.

     Check all answers on Stack Overflow

     3/5

   • How does heap compaction work quickly?

     Top Answer

     Answered Apr 19, 2010 · 35 votes

     Compaction means moving objects in RAM so that some objects are removed (the dead objects, that the GC is supposed to reclaim) and all remaining objects become contiguous in RAM.

     Most compacting GC work by allocating objects within a single, contiguous area obtained from the operating system. Compaction is then like removing the dead objects, and then pushing all remaining live objects "to the left", squeezing out the holes. If the GC works by compaction, then allocation is simply a matter of moving up the "end of allocated area" pointer. Synthetically, within the allocation area, there is a pointer such that the free area consists of the bytes after that pointer. To allocate space for an object, the pointer is simply moved up by the new object size. Occasionally, the GC decides that it is time to run, detects the dead object, squeezes the holes out, and thus lowers the allocation pointer.

     The performance gains from a compacting GC come from several sources:

     • For allocation, there is no need to find a suitable "hole": by construction, free space is, at all times, a single, big area, and it suffices to just move a pointer up.
     • There is no fragmentation: the compaction moves all live objects together, but this can be seen as moving all holes together into a single big free space.
     • Locality is improved. By moving live objects into adjacent areas, behaviour with regards to cache memory is improved. In particular, compaction algorithms tend to keep objects in their respective allocation order (objects are slided but not swapped) which has been reported to be heuristically good for most applications.

     If the operating system refuses to give a single allocation area, instead yielding several blocks, then things become a bit more complex, and could begin to look like the bin-packing problem, because the compacting GC then has to decide in which block goes each live object. However, the complexity of bin-packing is about finding the "perfect" match in the general case; an approximate solution is already good enough for a memory allocator.

     The algorithmic difficulty in a compaction algorithm is about updating all pointers, so that they point to the new object location. Through strict typing, the .NET virtual machine can unambiguously decide whether each word in RAM is a pointer or not, but updating all pointers efficiently without using too much extra RAM can be tricky. H.B.M. Jonkers has described a wonderfully smart algorithm for that, in "A Fast Garbage Compaction Algorithm" (Information Processing Letters, Volume 9, Number 1, 1979, pp. 26-30). I could not find a copy of that paper on the Vast Internet, but the algorithm is described in the "Garbage Collection" book by Jones and Lins (section 5.6). I warmly recommend that book to anyone who is interested in understanding garbage collectors. Jonkers' algorithm requires two linear passes on the live objects and turns out to be easy to implement (a few dozen lines of code, no more; the most difficult part is understanding why it works).

     Additional complexity comes from generational collectors which try, most of the time, to leave most of the objects untouched, working preferentially with young objects only. Here, this means compacting only the end of the heap; full compaction being applied only rarely. The point here is that a full compaction, although linear, could still induce a noticeable pause. Generational GC tries to make such pauses rarer. There again, Jones' and Lins' book is a must-read.

     Check all answers on Stack Overflow

     4/5

   • How does google indexing work and how does a sitemap work?

     Top Answer

     Answered Dec 14, 2011 · 3 votes

     Yeah, sitemaps should do what you need. It is a way of listing all the pages in your website, so that Google knows about ones especially that its spider may not find. You can find details about it, including links to instructions on creating your sitemap, here:

     http://support.google.com/webmasters/bin/answer.py?hl=en&answer=156184

     There are no guarantees with regards to the sitemap though, like that Google will actually search the new pages.

     Google doesn't guarantee that we'll crawl or index all of your URLs. However, we use the data in your Sitemap to learn about your site's structure, which will allow us to improve our crawler schedule and do a better job crawling your site in the future. In most cases, webmasters will benefit from Sitemap submission, and in no case will you be penalized for it.

     Just wondering though, why don't you just create pages at the old URLs that redirect to the new ones? It seems like that would be better than 404ing.

     Check all answers on Stack Overflow

     5/5

   Show moreShow less

3. People also ask

   How does a heap manager work?

   • The heap manager has its own, private data structures to record what areas of the heap are committed to what purpose at any moment. The heap manager satisfies each allocation request from the pool of free memory and updates its private data structures to record which areas of the heap are in use. 5. 6.1.2. Deallocation ¶

   5.6. Heap Memory — CS2 Software Design & Data Structures - Virginia …

   opendsa-server.cs.vt.edu/ODSA/Books/CS2/html/HeapMem.html

   See all results for this question

   How does heap memory work?

   • Heap memory is different in every way. The programmer explicitly requests that space be allocated, using the new operator in Java or C++. This memory “block” will be of a particular size, ususally determined automatically from the size of the object being created.

   5.6. Heap Memory — CS2 Software Design & Data Structures - Virginia …

   opendsa-server.cs.vt.edu/ODSA/Books/CS2/html/HeapMem.html

   See all results for this question

   What is a heap in computing?

   • What is a heap? A heap is an untidy collection of things piled up haphazardly. In computing architectures the heap is an area of dynamically-allocated memory that is managed automatically by the operating system or the memory manager library.

   What and where are the stack and heap?

   stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap

   See all results for this question

   How does heap allocation work?

   • Heap allocation requires maintaining a full record of what memory is allocated and what isn't, as well as some overhead maintenance to reduce fragmentation, find contiguous memory segments big enough to fit the requested size, and so on. Memory can be deallocated at any time leaving free space.

   What and where are the stack and heap?

   stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap

   See all results for this question

4. stackoverflow.com › questions › 79923data structures - What and where are the stack and heap ...

   stackoverflow.com › questions › 79923

   • Cached

   Sep 17, 2008 · In computing architectures the heap is an area of dynamically-allocated memory that is managed automatically by the operating system or the memory manager library. Memory on the heap is allocated, deallocated, and resized regularly during program execution, and this can lead to a problem called fragmentation.

   Code sample

   int foo() {

     char *pBuffer;

     bool b = true;

     if(b) {

     char buffer[500];...

   See more on stackoverflow

5. opendsa-server.cs.vt.edu › ODSA › Books5.6. Heap Memory — CS2 Software Design & Data Structures

   opendsa-server.cs.vt.edu › ODSA › Books

   • Cached

   • Allocation¶ The heap is a large area of memory available for use by the program. The program can request areas, or “blocks”, of memory for its use within the heap.
   • Deallocation¶ When the program is finished using a block of memory, in some languages the block must be explicitly deallocated. In such cases, the block will be marked unused.
   • Programming the Heap¶ Programming the heap looks pretty much the same in most languages. The basic features are: The heap is an area of memory available to allocate areas (“blocks”) of memory for the program.
   • A Heap Example¶ Settings. Saving... Server Error. Resubmit.

6. Videos

   • 

     12:32

     youtube.com

     Concepts of Heap | Understanding heap

     Jan 9, 2021

     69.1K Views

   • 

     5:56

     youtube.com

     Heaps in 6 minutes — Methods

     Jul 6, 2022

     61K Views

   • 

     10:32

     youtube.com

     Data Structures: Heaps

     Sep 27, 2016

     1.3M Views

   View all

7. www.geeksforgeeks.org › java-memory-managementJava Memory Management - GeeksforGeeks

   www.geeksforgeeks.org › java-memory-management

   • Cached

   Dec 14, 2018 · This article will focus on Java memory management, how the heap works, reference types, garbage collection, and also related concepts. Why Learn Java Memory Management? We all know that Java itself manages the memory and needs no explicit intervention of the programmer.

8. web.stanford.edu › class › archiveCS107, Lecture 14 - Stanford University

   web.stanford.edu › class › archive

   A heap allocator is a set of functions that fulfills requests for heap memory. On initialization, a heap allocator is provided the starting address and size of a large contiguous block of memory (the heap). A heap allocator must manage this memory as clients request or no longer need pieces of it.

9. medium.com › codimis › heap-memory-and-how-it-worksUnderstanding Java Heap Memory Management and Usage | Codimis

   medium.com › codimis › heap-memory-and-how-it-works

   • Cached

   Nov 20, 2023 · Nov 20, 2023. -- Heap memory is an important concept in Java that every developer should understand. The heap is the runtime data area. Hence heap memory keeps all class instances and arrays...

10. en.wikipedia.org › wiki › Heap_(data_structure)Heap (data structure) - Wikipedia

    en.wikipedia.org › wiki › Heap_(data_structure)

    • Cached

    The common operations involving heaps are: Basic. find-max (or find-min ): find a maximum item of a max-heap, or a minimum item of a min-heap, respectively (a.k.a. peek) insert: adding a new key to the heap (a.k.a., push [4])

11. see.stanford.edu › Course › CS107Lecture 8 - Heap Management - How Information about ...

    see.stanford.edu › Course › CS107

    • Cached

    Topics: Heap Management - How Information about Allocations are Stored in the Heap, Result of Freeing Memory Improperly, Actual Sizes of Heap Allocations - Nearest Power of 2, Management of Free Blocks on the Heap by Storing Addresses in the Blocks of Free Memory, Algorithms for Choosing Which Free Block to Allocate, How the Heap's Free List ...