* Added team and thread management to Model.

* ModelLoader does now at least evaluation team and thread added/removed events.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@30301 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/apps/debuganalyzer/ModelLoader.cpp

@@ -61,21 +61,12 @@ ModelLoader::StartLoading()
 	if (fModel != NULL || fLoading || fDataSource == NULL)
 		return B_BAD_VALUE;
 
-	// create a model
-	Model* model = new(std::nothrow) Model;
-	if (model == NULL)
-		return B_NO_MEMORY;
-	ObjectDeleter<Model> modelDeleter(model);
-
 	// spawn the loader thread
 	fLoaderThread = spawn_thread(&_LoaderEntry, "main model loader",
 		B_NORMAL_PRIORITY, this);
 	if (fLoaderThread < 0)
 		return fLoaderThread;
 
-	modelDeleter.Detach();
-	fModel = model;
-
 	fLoading = true;
 	fAborted = false;
 
@@ -156,12 +147,19 @@ ModelLoader::_Loader()
 status_t
 ModelLoader::_Load()
 {
-	// get a BDataIO from the data source
-	BDataIO* io;
-	status_t error = fDataSource->CreateDataIO(&io);
+	// read the complete data into memory
+	void* eventData;
+	size_t eventDataSize;
+	status_t error = _ReadDebugEvents(&eventData, &eventDataSize);
 	if (error != B_OK)
 		return error;
-	ObjectDeleter<BDataIO> dataIOtDeleter(io);
+
+	// create a model
+	fModel = new(std::nothrow) Model(eventData, eventDataSize);
+	if (fModel == NULL) {
+		free(eventData);
+		return B_NO_MEMORY;
+	}
 
 	// create a debug input stream
 	BDebugEventInputStream* input = new(std::nothrow) BDebugEventInputStream;
@@ -169,11 +167,12 @@ ModelLoader::_Load()
 		return B_NO_MEMORY;
 	ObjectDeleter<BDebugEventInputStream> inputDeleter(input);
 
-	error = input->SetTo(io);
+	error = input->SetTo(eventData, eventDataSize, false);
 	if (error != B_OK)
 		return error;
 
 	// process the events
+	fLastEventTime = -1;
 	uint32 count = 0;
 
 	while (true) {
@@ -202,26 +201,143 @@ ModelLoader::_Load()
 }
 
 
+status_t
+ModelLoader::_ReadDebugEvents(void** _eventData, size_t* _size)
+{
+	// get a BDataIO from the data source
+	BDataIO* io;
+	status_t error = fDataSource->CreateDataIO(&io);
+	if (error != B_OK)
+		return error;
+	ObjectDeleter<BDataIO> dataIOtDeleter(io);
+
+	// First we need to find out how large a buffer to allocate.
+	size_t size;
+
+	if (BPositionIO* positionIO = dynamic_cast<BPositionIO*>(io)) {
+		// it's a BPositionIO -- this makes things easier, since we know how
+		// many bytes to read
+		off_t currentPos = positionIO->Position();
+		if (currentPos < 0)
+			return currentPos;
+
+		off_t fileSize;
+		error = positionIO->GetSize(&fileSize);
+		if (error != B_OK)
+			return error;
+
+		size = fileSize - currentPos;
+	} else {
+		// no BPositionIO -- we need to determine the total size by iteratively
+		// reading the whole data one time
+
+		// allocate a dummy buffer for reading
+		const size_t kBufferSize = 1024 * 1024;
+		void* buffer = malloc(kBufferSize);
+		if (buffer == NULL)
+			return B_NO_MEMORY;
+		MemoryDeleter bufferDeleter(buffer);
+
+		size = 0;
+		while (true) {
+			ssize_t bytesRead = io->Read(buffer, kBufferSize);
+			if (bytesRead < 0)
+				return bytesRead;
+			if (bytesRead == 0)
+				break;
+
+			size += bytesRead;
+		}
+
+		// we've got the size -- recreate the BDataIO
+		dataIOtDeleter.Delete();
+		error = fDataSource->CreateDataIO(&io);
+		if (error != B_OK)
+			return error;
+		dataIOtDeleter.SetTo(io);
+	}
+
+	// allocate the data buffer
+	void* data = malloc(size);
+	if (data == NULL)
+		return B_NO_MEMORY;
+	MemoryDeleter dataDeleter(data);
+
+	// read the data
+	ssize_t bytesRead = io->Read(data, size);
+	if (bytesRead < 0)
+		return bytesRead;
+	if ((size_t)bytesRead != size)
+		return B_FILE_ERROR;
+
+	dataDeleter.Detach();
+	*_eventData = data;
+	*_size = size;
+	return B_OK;
+}
+
+
 status_t
 ModelLoader::_ProcessEvent(uint32 event, uint32 cpu, const void* buffer,
 	size_t size)
 {
 	switch (event) {
 		case B_SYSTEM_PROFILER_TEAM_ADDED:
-printf("B_SYSTEM_PROFILER_TEAM_ADDED: %lu\n", size);
-			break;
+		{
+//printf("B_SYSTEM_PROFILER_TEAM_ADDED: %lu\n", size);
+			system_profiler_team_added* event
+				= (system_profiler_team_added*)buffer;
+
+			if (fModel->AddTeam(event, fLastEventTime) == NULL)
+				return B_NO_MEMORY;
+			return B_OK;
+		}
+
 		case B_SYSTEM_PROFILER_TEAM_REMOVED:
-printf("B_SYSTEM_PROFILER_TEAM_REMOVED: %lu\n", size);
+		{
+//printf("B_SYSTEM_PROFILER_TEAM_REMOVED: %lu\n", size);
+			system_profiler_team_removed* event
+				= (system_profiler_team_removed*)buffer;
+
+			if (Model::Team* team = fModel->TeamByID(event->team)) {
+				team->SetDeletionTime(fLastEventTime);
+			} else {
+				printf("Removed event for unknown team: %ld\n", event->team);
+			}
 			break;
+		}
+
 		case B_SYSTEM_PROFILER_TEAM_EXEC:
 printf("B_SYSTEM_PROFILER_TEAM_EXEC: %lu\n", size);
 			break;
+
 		case B_SYSTEM_PROFILER_THREAD_ADDED:
-printf("B_SYSTEM_PROFILER_THREAD_ADDED: %lu\n", size);
+		{
+//printf("B_SYSTEM_PROFILER_THREAD_ADDED: %lu\n", size);
+			system_profiler_thread_added* event
+				= (system_profiler_thread_added*)buffer;
+
+			if (fModel->AddThread(event, fLastEventTime) == NULL)
+				return B_NO_MEMORY;
+			return B_OK;
+			
 			break;
+		}
+
 		case B_SYSTEM_PROFILER_THREAD_REMOVED:
-printf("B_SYSTEM_PROFILER_THREAD_REMOVED: %lu\n", size);
+//printf("B_SYSTEM_PROFILER_THREAD_REMOVED: %lu\n", size);
+		{
+			system_profiler_thread_removed* event
+				= (system_profiler_thread_removed*)buffer;
+
+			if (Model::Thread* thread = fModel->ThreadByID(event->thread)) {
+				thread->SetDeletionTime(fLastEventTime);
+			} else {
+				printf("Removed event for unknown team: %ld\n", event->thread);
+			}
 			break;
+		}
+
 		case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
 printf("B_SYSTEM_PROFILER_THREAD_SCHEDULED: %lu\n", size);
 			break;
@@ -240,7 +356,5 @@ return B_BAD_DATA;
 			break;
 	}
 
-
-	// TODO: Implement!
 	return B_OK;
 }