GGSTClonesArrayService Class Reference

A service which manages a pool of reusable TClonesArray. More...

#include <GGSTClonesArrayService.h>

Public Member Functions
	GGSTClonesArrayService (const char *className)
	Constructor. More...
	~GGSTClonesArrayService ()
	Destructor. More...
TClonesArray *	ProvideArray (int sizeHint=0, bool clearElements=false)
	Method to obtain an array from the service. More...
void	TakeBackArray (TClonesArray *&array)
	Gives an array back to the service. More...
void	DeleteAll ()
	Delete all unassigned arrays in storage. More...
void	DumpMemInfo ()

Detailed Description

A service which manages a pool of reusable TClonesArray.

This class takes care of managing a pool of TClonesArray. User routine can ask for TClonesArrays (possibly with a hint for desired size) and then release the array when finished. The released arrays can then be assigned to other routines which require them. The goal of this class is to prevent instantiating TClonesArrays when there are unused ones, and to assign available big arrays where they are most needed. The class owns the TClonesArray and will take care of deleting them. An array obtained with ProvideArray must never be explicitly deleted, it must instead be returned to the GGSTClonesArrayService by calling TakeBackArray.

Definition at line 30 of file GGSTClonesArrayService.h.

Constructor & Destructor Documentation

GGSTClonesArrayService::GGSTClonesArrayService

(

const char *

className

)

Constructor.

Parameters

className

The name of the class whose objects the TClonesArrays will contain.

Definition at line 15 of file GGSTClonesArrayService.cpp.

: _className(className) {}

GGSTClonesArrayService::~GGSTClonesArrayService

(

)

Destructor.

When the service is destroyed it will destroy all the arrays it currently manages, including the assigned ones that may still be in use. It is user's responsibility to ensure that this does not happen.

TODO: Raise an exception when deleting assigned arrays?

Definition at line 19 of file GGSTClonesArrayService.cpp.

                                                {
  static const std::string routineName("GGSTClonesArrayService::~GGSTClonesArrayService");
  if (_assignedArrays.size() != 0) {
    COUT(WARNING) << "There are still " << _assignedArrays.size() << " currently assigned arrays for class "
                  << _className << "." << ENDL;
    CCOUT(WARNING) << "These will not be deleted. The user routine must delete them." << ENDL;
    for (ArrayList::iterator iArray = _assignedArrays.begin(); iArray != _assignedArrays.end(); iArray++) {
      iArray->array = NULL; // Set the array pointer to NULL to avoid array deletion in ~ArrayDescriptor
    }
  }
}

Member Function Documentation

void GGSTClonesArrayService::DeleteAll

(

)

Delete all unassigned arrays in storage.

This method deletes all the arrays managed by the service which are currently not assigned.

Definition at line 111 of file GGSTClonesArrayService.cpp.

                                       {
  _availableArrays.resize(0); // The destructor of ArrayDescriptor will delete the array
}

TClonesArray * GGSTClonesArrayService::ProvideArray	(	int	sizeHint = 0,
		bool	clearElements = false
	)

Method to obtain an array from the service.

This method will return an array which can be used by the caller. The array will always have GetEntries = 0, but the service will try to provide an array whose actually allocated elements are as close as possible to sizeHint. The existing array elements will be cleared if the clear flag is set to true, i.e. the TClonesArray::Clear("C") method will be called before returning the array.

Parameters

sizeHint	The desired number of allocated elements.
clearElements	if true the elements in the TClonesArray are cleared.

Returns

pointer to the TClonesArray.

Definition at line 33 of file GGSTClonesArrayService.cpp.

                                                                                   {
  static const std::string routineName("GGSTClonesArrayService::ProvideArray");

  // Step 1: search for available array whose size is fitting the request.
  // Current "size fit" implementation: return the first array which has same or more elements than sizeHint
  // (_availableArrays is ordered).
  for (ArrayList::iterator iArray = _availableArrays.begin(); iArray != _availableArrays.end(); iArray++) {
    if (iArray->allocSize >= sizeHint) {
      _assignedArrays.splice(_assignedArrays.end(), _availableArrays, iArray);
      if (clearElements) {
        iArray->array->Clear("C");
      } else {
        iArray->array->Clear();
      }
      COUT(DEEPDEB) << "Assigned array at " << iArray->array << " for class " << _className << " with size " << sizeHint
                    << ENDL;
      return iArray->array;
    }
  }
  // Step 2: return the greatest available array if step 1 failed.
  if (_availableArrays.size() > 0) {
    ArrayList::iterator lastAvailable = _availableArrays.end();
    lastAvailable--;
    _assignedArrays.splice(_assignedArrays.end(), _availableArrays, lastAvailable);
    if (clearElements) {
      _assignedArrays.back().array->Clear("C");
    } else {
      _assignedArrays.back().array->Clear();
    }
    COUT(DEEPDEB) << "Assigned array at " << _assignedArrays.back().array << " for class " << _className
                  << " with size " << sizeHint << ENDL;
    return _assignedArrays.back().array;
  }
  // Step 3: return a new array if step 2 failed.
  _assignedArrays.push_back(ArrayDescriptor());
  _assignedArrays.back().array = new TClonesArray(_className.c_str(), sizeHint);
  _assignedArrays.back().allocSize = sizeHint;
  COUT(DEEPDEB) << "Created array at " << _assignedArrays.back().array << " for class " << _className << " with size "
                << sizeHint << ENDL;
  return _assignedArrays.back().array;
}

void GGSTClonesArrayService::TakeBackArray

(

TClonesArray *&

array

)

Gives an array back to the service.

This method should be called when an array obtained via ProvideArray is no longer needed. The service will clear and store it for future usage by some other applicant. If the array has not been retrieved by a call to ProvideArray, the service will adopt it and take care of its destruction.

Parameters

array

The array to be returned to the service (will be set to NULL to avoid accidental delete).

Definition at line 77 of file GGSTClonesArrayService.cpp.

                                                               {
  static const std::string routineName("GGSTClonesArrayService::TakeBackArray");

  int arraySize = array->GetEntries();

  // Step 1: find insertion point in available arrays list
  ArrayList::iterator iAvArray;
  for (iAvArray = _availableArrays.begin(); iAvArray != _availableArrays.end(); iAvArray++) {
    if (iAvArray->allocSize > arraySize) {
      break;
    }
  }

  // Step 2: search the array between the currently assigned ones
  for (ArrayList::iterator iArray = _assignedArrays.begin(); iArray != _assignedArrays.end(); iArray++) {
    if (array == iArray->array) {
      _availableArrays.splice(iAvArray, _assignedArrays, iArray);
      array = NULL;
      COUT(DEEPDEB) << "Took back array at " << iArray->array << " for class " << _className << " with size "
                    << arraySize << ENDL;
      return;
    }
  }
  // Step 2: new array, allocate a new element for it
  ArrayList::iterator newArray = _availableArrays.insert(iAvArray, ArrayDescriptor());
  newArray->array = array;
  newArray->allocSize = arraySize;
  array = NULL;
  COUT(DEEPDEB) << "Adopted array at " << newArray->array << " for class " << _className << " with size " << arraySize
                << ENDL;
}

---

The documentation for this class was generated from the following files:

• GGSTClonesArrayService.h
• GGSTClonesArrayService.cpp