Slicer3:Memory Management - Revision history

Grundlett: Text replacement - "http://www.slicer.org/slicerWiki/index.php/" to "https://www.slicer.org/wiki/"

2017-07-10T18:07:33Z

Text replacement - "http://www.slicer.org/slicerWiki/index.php/" to "https://www.slicer.org/wiki/"

Marianna: Protected "Slicer3:Memory Management" [edit=sysop:move=sysop]

2008-05-22T16:29:52Z

Protected "Slicer3:Memory Management" [edit=sysop:move=sysop]

Marianna: Unprotected "Slicer3:Memory Management"

2008-05-19T21:52:37Z

Unprotected "Slicer3:Memory Management"

Marianna: Replacing page with ''''Note:''' We are migrating this content to the slicer.org domain - The newer page is [http://www.slicer.org/slicerWiki/index.php/Slicer3:Memory_Mana...'

2008-05-19T21:52:24Z

Replacing page with '<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [http://www.slicer.org/slicerWiki/index.php/Slicer3:Memory_Mana...'

Millerjv: /* What does this mean for Slicer3 */

2007-01-05T22:11:21Z

What does this mean for Slicer3

Millerjv at 22:11, 5 January 2007

2007-01-05T22:11:08Z

Millerjv: /* SmartPointers */

2007-01-05T22:03:00Z

SmartPointers

Millerjv: /* How does memory get deleted multiple times? */

2007-01-05T22:01:01Z

How does memory get deleted multiple times?

Millerjv: /* What is a memory leak? */

2007-01-05T21:59:32Z

What is a memory leak?

Millerjv: /* Stack-based coding */

2007-01-05T21:55:34Z

Stack-based coding

← Older revision		Revision as of 18:07, 10 July 2017
Line 1:		Line 1:
−	<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [~~http~~://www.slicer.org/~~slicerWiki/index.php~~/Slicer3:Memory_Management here]</font></big>	+	<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [https://www.slicer.org/wiki/Slicer3:Memory_Management here]</font></big>

← Older revision		Revision as of 21:52, 19 May 2008
Line 1:		Line 1:
−	~~This page discusses strategies for writing and debugging code in Slicer3 such that you avoid memory leaks and double deletes.~~	+	<big>'''Note:''' We are migrating this content to the slicer.org domain - <font color="orange">The newer page is [http://www.slicer.org/slicerWiki/index.php/Slicer3:Memory_Management here]</font></big>
−
−	~~=== What is a memory leak? ===~~
−
−	~~Memory leaks occur when a section of code allocates a block of memory that is never reclaimed.~~
−
−	~~void MyFunction()~~
−	{
−	~~short *buffer = new short[1000]; // this memory is leaked!~~
−	}
−
−	This example is rather contrived. There more insipid cases where it is very unclear that memory is not being reclaimed. Most memory leaks occur where several objects are referencing the same block of memory with each object assuming some other object is responsible for deallocating the memory.
−
−	~~=== How does memory get deleted multiple times? ===~~
−
−	A frequent problem with passing pointers from routine to routine is that it becomes very easy to loose track of which routine is responsible for deleting the block of memory. APIs rely on their documentation to educate the developers as to whether the developer is responsible for deleting the memory.
−
−	~~short *buffer = mykit::CreateBuffer(1000);~~
−	~~...~~
−	~~myKit::CleanUp();~~
−	~~...~~
−	~~delete [] buffer; // did myKit::CleanUp() already delete this memory?~~
−
−	~~Memory can be deleted multiple times when it is particularly unclear as to whether the memory was allocated on the heap or the stack.~~
−
−	~~=== Reference Counting ===~~
−
−	VTK and ITK both use reference counting to keep track of outstanding references to an object and automatically delete an object when it is no longer needed. VTK does with via calls to New()/Delete() and Register()/UnRegister() to increase and decrease the number of references to an object. If a function call returns a pointer to an object, the caller can choose to keep a long term handle to that object by increasing the reference count. The caller is responsible for decreasing the reference count when they no longer need the object.
−
−	~~<pre>~~
−	~~MyClass::Function1()~~
−	{
−	~~this->SomeObject = MyOtherClass::GetObject();~~
−	~~this->SomeObject->Register( this );~~
−	}
−
−	~~MyClass::~MyClass()~~
−	{
−	~~if (this->SomeObject)~~
−	{
−	~~this->SomeObject->UnRegister();~~
−	~~this->SomeObject = 0;~~
−	}
−	}
−	~~</pre>~~
−
−	~~=== Stack-based coding ===~~
−
−	~~One way to avoid memory leaks is to avoid allocating objects on the heap. Instead objects are allocated directly on the stack and deallocated from the stack using standard scoping rules.~~
−
−	~~<pre>~~
−	~~MyObject::Function()~~
−	{
−	~~MyOtherObject* object1 = new MyOtherObject(); // object1 allocated from the heap.~~
−	~~// The developer must reclaim this memory later or it is a leak.~~
−
−	~~MyOtherObject object2(); // object2 allocated on the stack.~~
−	~~// Memory reclaimed automatically when the object goes out of~~
−	~~// scope (in this case at the end of the function).~~
−	}
−	<~~/pre~~>
−
−	The Standard Template Library (STL) promotes which type of coding. To use STL safely, all objects stored in STL containers should be default constructible and have proper copy constructors, etc. This is needed so the containers can shuffle objects in memory, reallocate space, etc.
−	~~When STL containers of objects go out of scope, the destructor of the vector calls the destructor of each object it contains. If these vectors are vectors to pointers to objects, the~~ '''~~destructors of each object are not called.~~'''
−
−	~~<pre>~~
−	~~MyObject::Function()~~
−	{
−	~~std::vector<MyObject*> vec;~~
−
−	~~vec.push_back( MyOtherClass::GetObject(0) );~~
−	~~vec.push_back( MyOtherClass::GetObject(1) );~~
−	~~} // destructors~~ are ~~not called on items pointed~~ to ~~by elements of~~ the ~~vector~~
−	~~</pre>~~
−
−	~~=== SmartPointers ===~~
−
−	~~ITK has used SmartPointers since its beginning to simply the reference counting semantics~~. With SmartPointers, the reference count of an object is automatically increased when assigned to a SmartPointer and automatically decreased when ''unassigned'' from a SmartPointer. Objects are unassigned from a SmartPointer whenever that SmartPointer is assigned to another object or to 0. The latter occurs automatically whenever a SmartPointer goes out of scope.
−
−	~~<pre>~~
−	~~MyObject::Function()~~
−	{
−	~~itk::Image~~<~~short, 2>::Pointer smartPointer~~ = ~~itk::Image<short,2~~>:~~:New(); // creates a new image~~
−
−	~~smartPointer = MyOtherClass::GetImage();~~ // ~~reference count of the image previously pointed to by~~
−	~~// smartPointer decremented~~. ~~Reference count on image returned~~
−	~~// by MyOtherClass::GetImage() incremented~~.
−
−
−	} // ~~smartPointer goes out of scope, reference count of the image returned by MyOtherClass::GetImage() decremented~~.
−	</~~pre>~~
−
−	~~Because SmartPointers abide by scoping semantics, they can be used with STL containers.~~
−
−	~~<pre>~~
−	~~std::vector<itk::Image<short, 2>::Pointer> vec;~~
−
−	~~vec.push_back( itk::Image<short, 2>::New() );~~
−	~~vec.push_back( itk::Image<short, 2>::New() );~~
−
−	~~vec = std::vector<itk::Image<short, 2>:~~:~~Pointer>();~~ ~~// vec is now a copy of an empty vector~~
−	~~// Reference counts to the images pointed to by the elements~~
−	~~// of the vector properly managed.~~
−	</~~pre~~>
−
−	We like SmartPointers in ITK so much, they were added into VTK. The behavior is the same as in ITK. However, the New() in VTK has always returned a raw pointer whereas the New() method in ITK returns a SmartPointer. So a little more setup is needed to use a SmartPointer in VTK.
−
−	~~<pre>~~
−	~~itk::Image<short, 2>::Pointer itkPointer = itk::Image<short, 2>::New(); // after this line, reference count is 1~~
−
−	~~vtkImageData *image = vtkImageData::New(); // after this line, reference count is 1~~
−	~~vtkSmartPointer~~<~~vtkImageData> vtkPointer = image; /~~/ ~~after this line, reference count is 2~~
−	~~image-~~>~~Delete(); // after this line, reference count is 1~~
−	~~</pre>~~
−
−	~~VTK SmartPointers can be used in STL containers just like ITK SmartPointers.~~
−
−	~~<pre>~~
−	~~std::map<std::string, vtkSmartPointer<vtkImageData> > myMap;~~
−
−	~~myMap["foreground"] = a->GetOutput();~~
−	~~myMap["background"] = b->GetOutput();~~
−	~~</pre>~~
−
−
−	~~=== What does this mean for Slicer3? ===~~
−
−	Slicer creates a large number of objects which are subclasses of VTK object. Every image, model, transform, node, module, and GUI component is a VTK object. The referencing counting on these objects is all manually coded. There are many opportunities to use SmartPointers and simplify the code and avoid programming errors. We suggest using SmartPointers where possible.
−
−	~~In ITK, there are a set of guidelines for using SmartPointers.~~
−	~~# If you need a ''persistent'' handle to an object, store it in a SmartPointer.~~
−	~~# Functions take raw pointers as parameters and return raw pointers as return values.~~
−	~~## The exception to this rule is if the routine creates the object but does not hold onto a persistent reference itself. In this case, the routine must return a SmartPointer.~~

← Older revision		Revision as of 22:11, 5 January 2007
Line 124:		Line 124:


−	=== What does this mean for Slicer3 ===	+	=== What does this mean for Slicer3? ===

	Slicer creates a large number of objects which are subclasses of VTK object. Every image, model, transform, node, module, and GUI component is a VTK object. The referencing counting on these objects is all manually coded. There are many opportunities to use SmartPointers and simplify the code and avoid programming errors. We suggest using SmartPointers where possible.		Slicer creates a large number of objects which are subclasses of VTK object. Every image, model, transform, node, module, and GUI component is a VTK object. The referencing counting on these objects is all manually coded. There are many opportunities to use SmartPointers and simplify the code and avoid programming errors. We suggest using SmartPointers where possible.

← Older revision		Revision as of 22:11, 5 January 2007
Line 122:		Line 122:
	myMap["background"] = b->GetOutput();		myMap["background"] = b->GetOutput();
	</pre>		</pre>
		+
		+
		+	=== What does this mean for Slicer3 ===
		+
		+	Slicer creates a large number of objects which are subclasses of VTK object. Every image, model, transform, node, module, and GUI component is a VTK object. The referencing counting on these objects is all manually coded. There are many opportunities to use SmartPointers and simplify the code and avoid programming errors. We suggest using SmartPointers where possible.
		+
		+	In ITK, there are a set of guidelines for using SmartPointers.
		+	# If you need a ''persistent'' handle to an object, store it in a SmartPointer.
		+	# Functions take raw pointers as parameters and return raw pointers as return values.
		+	## The exception to this rule is if the routine creates the object but does not hold onto a persistent reference itself. In this case, the routine must return a SmartPointer.

← Older revision		Revision as of 22:03, 5 January 2007
Line 115:		Line 115:

	VTK SmartPointers can be used in STL containers just like ITK SmartPointers.		VTK SmartPointers can be used in STL containers just like ITK SmartPointers.
		+
		+	<pre>
		+	std::map<std::string, vtkSmartPointer<vtkImageData> > myMap;
		+
		+	myMap["foreground"] = a->GetOutput();
		+	myMap["background"] = b->GetOutput();
		+	</pre>

← Older revision	Revision as of 16:29, 22 May 2008
(No difference)

@@ Line 21: / Line 21: @@
   ...
   delete [] buffer; // did myKit::CleanUp() already delete this memory?
 === Reference Counting ===

@@ Line 9: / Line 9: @@
      short *buffer = new short[1000]; // this memory is leaked!
+  }
 === How does memory get deleted multiple times? ===

@@ Line 67: / Line 67: @@
    vec.push_back( MyOtherClass::GetObject(0) );
    vec.push_back( MyOtherClass::GetObject(1) );
-  }                             // destructors are not called on items pointed to by elements of the vector
+  }  // destructors are not called on items pointed to by elements of the vector
 </pre>