haiku.git

/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "SummaryProfileResult.h"

#include <new>


// #pragma mark - SummaryImage


SummaryImage::SummaryImage(ImageProfileResult* result)
	:
	fResult(result)
{
	fResult->AcquireReference();
}


SummaryImage::~SummaryImage()
{
	fResult->ReleaseReference();
}


// #pragma mark - SummaryProfileResult


SummaryProfileResult::SummaryProfileResult(ProfileResult* result)
	:
	fResult(result),
	fNextImageID(1)
{
	fResult->AcquireReference();
}


SummaryProfileResult::~SummaryProfileResult()
{
	fResult->ReleaseReference();
}


void
SummaryProfileResult::SetInterval(bigtime_t interval)
{
	ProfileResult::SetInterval(interval);
	fResult->SetInterval(interval);
}


status_t
SummaryProfileResult::Init(ProfiledEntity* entity)
{
	status_t error = ProfileResult::Init(entity);
	if (error != B_OK)
		return error;

	error = fImages.Init();
	if (error != B_OK)
		return error;

	return B_OK;
}


void
SummaryProfileResult::AddSamples(ImageProfileResultContainer* container,
	addr_t* samples, int32 sampleCount)
{
	fResult->AddSamples(container, samples, sampleCount);
}


void
SummaryProfileResult::AddExpectedTicks(int32 expected)
{
	fResult->AddExpectedTicks(expected);
}


void
SummaryProfileResult::AddDroppedTicks(int32 dropped)
{
	fResult->AddDroppedTicks(dropped);
}


void
SummaryProfileResult::PrintResults(ImageProfileResultContainer* container)
{
	// This is called for individual threads. We only print results in
	// PrintSummaryResults(), though.
}


void
SummaryProfileResult::PrintSummaryResults()
{
	fResult->PrintResults(this);
}


status_t
SummaryProfileResult::GetImageProfileResult(SharedImage* image, image_id id,
	ImageProfileResult*& _imageResult)
{
	// Check whether we do already know the image.
	SummaryImage* summaryImage = fImages.Lookup(image);
	if (summaryImage == NULL) {
		// nope, create it
		ImageProfileResult* imageResult;
		status_t error = fResult->GetImageProfileResult(image, fNextImageID++,
			imageResult);
		if (error != B_OK)
			return error;

		BReference<ImageProfileResult> imageResultReference(imageResult, true);

		summaryImage = new(std::nothrow) SummaryImage(imageResult);
		if (summaryImage == NULL)
			return B_NO_MEMORY;

		fImages.Insert(summaryImage);
	}

	_imageResult = summaryImage->Result();
	_imageResult->AcquireReference();

	return B_OK;
}


int32
SummaryProfileResult::CountImages() const
{
	return fImages.CountElements();
}


ImageProfileResult*
SummaryProfileResult::VisitImages(Visitor& visitor) const
{
	for (ImageTable::Iterator it = fImages.GetIterator();
			SummaryImage* image = it.Next();) {
		if (visitor.VisitImage(image->Result()))
			return image->Result();
	}

	return NULL;
}


ImageProfileResult*
SummaryProfileResult::FindImage(addr_t address, addr_t& _loadDelta) const
{
	// We cannot and don't need to implement this. It's only relevant for
	// AddSamples(), where we use the caller's container implementation.
	return NULL;
}