
	Where results make sense

Topic: Reference counting

Related Topics

Smart pointer

Handle

Memory leak

Inu yasha

Mac OS

Avoca (village), New York

New Jersey State Highway 208

Eric Woolfson

Petit Jean State Park

Shanghainese

New York City blackout of 1977

Oedipus Aegyptiacus

Goldsworthy Lowes Dickinson

Seattle Metropolitans

Diana Kennedy

In the News (Fri 17 Feb 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Reference counting - Wikipedia, the free encyclopedia
		In computer science, reference counting is a technique of storing the number of references, pointers, or handles to a resource such as an object or block of memory.
		Reference counting is often known as a garbage collection algorithm where each object contains a count of the number of references to it held by other objects.
		Whenever a reference is destroyed or overwritten, the reference count of the object it references is decremented, and whenever one is created or copied, the reference count of the object it references is incremented.
	en.wikipedia.org /wiki/Reference_counting (2241 words)

	Reference.com/Encyclopedia/Counting sort
		Counting sort is a sorting algorithm which (like bucket sort) takes advantage of knowing the range of the numbers in the array to be sorted (array A).
		Counting sort is stable (see sorting algorithm) and has a running time of Θ(n+k), where n and k are the lengths of the arrays A (the input array) and C (the counting array), respectively.
		Counting sort may for example be the best algorithm for sorting numbers whose range is between 0 and 100, but it is probably unsuitable for sorting a list of names alphabetically.
	www.reference.com /browse/wiki/Counting_sort (656 words)

	Zend Technologies - Articles - PHP 4: Reference Counting and Aliasing
		Reference counting is a new mechanism in the PHP 4 Zend engine for eliminating memory allocation and copying of a value when it is assigned to a new variable.
		In addition, reference counting keeps track of how many variables are currently pointing to the particular memory location for that value: when no variables point to that value, its memory location is freed.
		Reference counting is used for all the PHP 4 basic data types: such as integers, booleans, strings, arrays, objects and resources.
	www.zend.com /zend/art/ref-count.php (1815 words)

	Weighted Reference Counting (Site not responding. Last check: 2007-11-06)
		Weighted reference counting (WRC) was proposed by Bevan (in [1]) and Watson and Watson (in [8]) in 1987.
		On deletion of a reference, a decrement reference count (DRC) message, containing the value of the RW of the deleted reference, is sent to the object and the object's RC is decremented by that value.
		As such, the number of references to an object were, he found, between 1.25 and 1.45 on average; with larger objects he found this to be between 1.6 and 2.3.
	www.dcs.gla.ac.uk /~ian/project/node13.html (806 words)

	reference counting corba server object com reference counting uk - jetbyte (Site not responding. Last check: 2007-11-06)
		In COM you're used to your clients having control over the lifetime of your server objects, reference counting is a way of life and if you need an object that acts as a persistent singleton within a server you can achieve it by altering how the reference counting works in the server.
		To solve the problem of deleting an object when references to it are being held, requires that we allow the servant object to know how many references to it are in existence and only allow itself to be deleted if the count of outstanding references falls to 0.
		This reference counting is used to allow servant objects to be created on the heap in the server, activated and handed out to clients, and then automatically cleaned up when the server deactivates them.
	www.jetbyte.com /portfolio-showarticle.asp (2263 words)

	August 1997/A Template for Reference Counting (Site not responding. Last check: 2007-11-06)
		Reference counting is a well known technique for improving performance, particularly when manipulating large or complex objects.
		Reference counting is an object-oriented concept that improves efficiency by allowing objects that are assigned to each other to share the same memory.
		When the last reference object is destroyed, the memory for the shared data structure, as well as the memory for the reference counter, is deallocated.
	www.tcnj.edu /~hernande/cujv5/html/15.08/ngai/ngai.htm (802 words)

	Reference counting (Site not responding. Last check: 2007-11-06)
		Each time a reference to the object is destroyed, the reference count is decremented.
		Reference counting is used in some garbage collectors, but this is not common because it's expensive, and in particular can't reclaim cyclic structures.
		All the objects in a cycle have a reference count of at least one, even if the cycle is not accessible from anywhere else.
	www.cs.man.ac.uk /arch/people/j-sargeant/practicalnotes/node36.html (136 words)

	Reference Counting Architectures [UPDATED!] (Site not responding. Last check: 2007-11-06)
		Distributed reference counting is something typically performed either by a remote object, the factory for the remote object or possibly by the
		Reference counting might be one mechanism for determining a remote object’s “load”.
		While it is possible to design reference counting into an application, it is the burden of the application designer/developer to ensure that such an approach is implemented correctly.
	security-protocols.com /programming-tutorials/CORBA/ref-counting.html (578 words)

	Reference counting at opensource encyclopedia (Site not responding. Last check: 2007-11-06)
		In computer science, reference counting is a garbage collection algorithm where each object contains a count of the number of references to it held by other objects.
		Reference counting has two main disadvantages over the more common tracing garbage collection, both of which require additional mechanisms to ameliorate.
		The main advantage of reference counting over tracing is that objects are reclaimed as soon as they can no longer be referenced, and in an incremental fashion, without long pauses for collection cycles.
	www.wiki.tatet.com /Reference_counting.html (1336 words)

	CObjectCon in Reference Counting Objects
		A pointer to the reference counting object to be removed.
		If the reference counting object has a name, then it is unique only if there is no other reference counting object in the container with the same full name.
		If the reference counting object has no name, then it is unique only if there is no other reference counting object in the container with the same pointer.
	www.symbian.com /developer/techlib/v70sdocs/doc_source/reference/cpp/ReferenceCountingObjects/CObjectConClass.html (1297 words)

	More Effective C++ \| Item 29: Reference counting (Site not responding. Last check: 2007-11-06)
		Reference counting is a technique that allows multiple objects with the same value to share a single representation of that value.
		We added reference counting, we added the ability to mark individual string values as unshareable, we moved the notion of reference countability into a new base class, we added smart pointers to automate the manipulation of reference counts, yet not one line of client code needs to be changed.
		Reference counting is an optimization technique predicated on the assumption that objects will commonly share values (see also Item 18).
	www.sm.luth.se /~alapaa/file_fetch/MeyersEffectiveCpp/MEC/MI29.HTM (5693 words)

	Indirect Reference Counting (Site not responding. Last check: 2007-11-06)
		This algorithm was proposed by Piquer (see [4]) in 1991 and uses tree structures to represent the diffusion tree of the pointer throughout the system, i.e the spread of remote references to an object.
		When a reference is created or duplicated a node is added as a child of the creator.
		The pointer to the root is used for dereferencing and the pointer to the parent is used for garbage collection (see figure 2.5).
	www.dcs.gla.ac.uk /~ian/project/node16.html (368 words)

	H-World - Docs - Reference Counting
		The idea of reference counting is simple: count how many references to a object exist, and if that count drops to zero, the object is obviously no longer needed by the program and can be deleted.
		Reference counting in it's pure form provides automated memory management, but it cannot manage double linked or cyclic data structures because the reference count never drops to zero in such structures.
		Assume A references B and B references A. Even if neither A or B are referenced by something else (and thus could be cleaned up) their reference count is still 1 because they reference each other and reference counting won't clean them up.
	h-world.simugraph.com /docs/refcount.html (574 words)

	CObjectIx in Reference Counting Objects
		This is referred to as an object index.
		Adding a reference counting object to an object index is the way in which a unique handle number can be generated for that object.
		Removes the reference counting object identified by handle number from this object index and closes it.
	www.symbian.com /developer/techlib/v70sdocs/doc_source/reference/cpp/ReferenceCountingObjects/CObjectIxClass.html (571 words)

	Larry Osterman's WebLog : Concurrency, part 6 - Reference counting is hard :)
		The other day, I talked about using reference counting as a way of ensuring object when enumerating a list containing objects.
		Reference counting is an incredibly useful, but incredibly dangerous technique.
		Often, reference counting is used as a remedy for some problem and added on some stage of coding (or even after it was already done).
	blogs.msdn.com /larryosterman/archive/2005/02/21/377485.aspx (1479 words)

	1.5 Reference counting (Site not responding. Last check: 2007-11-06)
		When a new reference to a COM interface pointer is made, the function add-ref should be called to increment its reference count.
		When a reference is removed, the function release should be called to decrement it again.
		Refer to standard COM texts for more details of the reference counting rules.
	www.lispworks.com /documentation/lw44/COM/html/com-12.htm (114 words)

	Implementing Reference Counting
		Reference counting requires work on the part of both the implementor of a class and the clients who use objects of that class.
		A common implementation approach for most objects is to have only one implementation of these methods (along with QueryInterface), which is shared between all interfaces, and therefore a reference count that applies to the entire object.
		However, from a client's perspective, reference counting is strictly and clearly a per-interface-pointer notion, and therefore objects that take advantage of this capability by dynamically constructing, destroying, loading, or unloading portions of their functionality based on the currently extant interface pointers may be implemented.
	msdn.microsoft.com /library/en-us/com/html/d4fd98c9-afa4-4c5c-a3c9-44d34881cbdb.asp?frame=true (419 words)

	flipcode - Limited-Field Reference Counting
		Limited-field reference counting uses reference counts that are smaller than usual: Suppose that n bits are set aside for storing a single reference count.
		In particular the resource associated with the reference count will never be freed by the reference counter; this is an example of where having a garbage collector is useful.
		However, if a reference count is stored inside a pointer, there will be as many copies of this reference count as there are pointers to the object (potentially very many), and every one of these are going to have to be updated when the reference count changes.
	www.flipcode.com /cgi-bin/fcarticles.cgi?show=63923 (2844 words)

	Why Reference Counting Does Not Work (Site not responding. Last check: 2007-11-06)
		Therefore, the reference count on the first list element is two; whereas, the remaining list elements all have a reference count of one.
		However, its reference count is not zero, because the tail of the list still refers to the head.
		Therefore, reference counting by itself is not a suitable garbage collection scheme for arbitrary objects.
	www.brpreiss.com /books/opus5/html/page423.html (248 words)

	Reference Counting Garbage Collection
		In general, every time one reference variable is assigned to another, it may be necessary to update several reference counts.
		refer to the same object--its reference count is two.
		The advantage of using reference counts is that garbage is easily identified.
	www.brpreiss.com /books/opus5/html/page421.html (446 words)

	David Chappell :: Articles :: The Joy of Reference Counting
		Whenever a client is finished using an interface pointer, it calls Release on that pointer, and the object subtracts one from the reference count.
		Reference counting is still used to control the lifetime of every COM object, but the Java programmer is freed from the responsibility of worrying about it-it's taken care of automatically.
		Reference counting remains the underlying mechanism used for controlling the lifetime of COM objects, but it no longer need be the programmer's concern.
	www.chappellassoc.com /articles/article_Refer_Counting.html (1547 words)

	Reference Counting and Not Reference Counting
		When the count reaches zero, no one is using the object and it can call its Terminate event and deallocate its data.
		In simple reference counting schemes such as COM’s, it doesn’t matter what the count is, just whether it’s zero.
		COM objects are responsible for keeping a reference count, and Visual Basic, as a good implementor of COM, keeps reference counts religiously—sometimes too religiously.
	vb.mvps.org /hardcore/html/referencecountingnotreferencecounting.htm (279 words)

	Reference counting done correctly
		And that causes serious problems in case you want to create a safe execution environment, because it creates a reference to a pointer to a piece of memory which is no longer in use, and is likely to be used for some other object in the future.
		The reference from a parent node to a child node is a different kind of reference then that of the child node to its parent.
		A claiming aggregration reference, means that the object being referenced should not be deleted as long as the reference still exists.
	www.iwriteiam.nl /RefCounting.html (1794 words)

	Reference counting in netfs
		In libnetfs, the netfs_nref, netfs_nput, etc. functions use a global spin lock that they acquire before changing the reference count of a node.
		On the server side, the successful lookup of "x" adds a reference to the corresponding node which is then dropped when the client closes it.
		If the above scenario is correct, using a mutex for the refcnt count should remove the problem since it would enforce the order in which reference counts are changed (ie.
	www.mail-archive.com /help-hurd@gnu.org/msg02948.html (227 words)

	GotW #44: Reference Counting - Part II
		The problem is that the reference was taken while the original string was unshared, but then the string became shared and the single update through the reference modified both String objects' visible state.
		In short, calling a mutator clearly invalidates references into the string because you never know if the underlying memory may move (invisibly, from the point of view of the calling code).
		So, instead of marking s as "unshareable for all time" just because someone might have remembered a reference into it, we could just mark it "unshareable until after the next mutating operation," when any such remembered reference would be invalidated anyway.
	www.gotw.ca /gotw/044.htm (1264 words)

	Reference Counting
		Reference counting occurs when the object being copied is an instance of the destination object.
		Under reference counting, it is possible for many Collection objects to have pointers to the same Container object.
		The return of a temporary object cannot be accomplished by reference, so without reference counting, an efficient return would require dynamic memory allocation.
	dimacs.rutgers.edu /~berryj/manual/node85.html (443 words)

	A couple garbage collector questions (Site not responding. Last check: 2007-11-06)
		The per-object storage cost for > the extra reference count is surely greater than the bit or two > required for a typical mark and sweep.
		Frankly, I'm a bit confused as to why everybody and their brother seems to want to implement reference count based garbage collectors when better has been available through languages like LISP for years.
		I do know for a fact though that reference counting is a lot easier than other forms of GC.
	mail.python.org /pipermail/python-list/2001-April/036304.html (274 words)

	Re: Reference counting in modules (Site not responding. Last check: 2007-11-06)
		When the module Common is unloaded the reference count > is decremented.
		When the reference count reaches zero then the > "unload" commands are executed.
		The reference > count is now 0 so Common's "unload" commands > are now run.
	www.eng.auburn.edu /pub/mail-lists/modules-interest.Mar00/msg00025.html (282 words)

	Reference Counting and Memory Mangement
		Reference Counting and Memory Mangement -- Functions to perform reference counting and memory management on a
		The pixbuf will be destroyed when its reference count drops to zero.
		() is called on this pixbuf and it has a reference count of 1, i.e.
	www.vision.ee.ethz.ch /computing/sepp-irix/gtk-1.2.9-ds/gdk-pixbuf/gdk-pixbuf-refcounting.html (520 words)

	epowiki: Reference Counting (Site not responding. Last check: 2007-11-06)
		Reference counting means you have to be very careful about taking a large enough scale lock to protect the object.
		Reference counting means you don't have to copy an object to put it in multiple lists.
		Reference counting means you can aggregate changes while
	www.possibility.com /epowiki/Wiki.jsp?page=ReferenceCounting (161 words)

Try your search on: Qwika (all wikis)