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


#include "ModelLoader.h"

#include <stdio.h>
#include <string.h>

#include <algorithm>
#include <new>

#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <DebugEventStream.h>

#include <system_profiler_defs.h>
#include <thread_defs.h>

#include "DataSource.h"
#include "MessageCodes.h"
#include "Model.h"


// add a scheduling state snapshot every x events
static const uint32 kSchedulingSnapshotInterval = 1024;

static const uint32 kMaxCPUCount = 1024;


struct SimpleWaitObjectInfo : system_profiler_wait_object_info {
        SimpleWaitObjectInfo(uint32 type)
        {
                this->type = type;
                object = 0;
                referenced_object = 0;
                name[0] = '\0';
        }
};


static const SimpleWaitObjectInfo kSnoozeWaitObjectInfo(
        THREAD_BLOCK_TYPE_SNOOZE);
static const SimpleWaitObjectInfo kSignalWaitObjectInfo(
        THREAD_BLOCK_TYPE_SIGNAL);


// #pragma mark - CPUInfo


struct ModelLoader::CPUInfo {
        nanotime_t      idleTime;

        CPUInfo()
                :
                idleTime(0)
        {
        }
};


// #pragma mark - IOOperation


struct ModelLoader::IOOperation : DoublyLinkedListLinkImpl<IOOperation> {
        io_operation_started*   startedEvent;
        io_operation_finished*  finishedEvent;

        IOOperation(io_operation_started* startedEvent)
                :
                startedEvent(startedEvent),
                finishedEvent(NULL)
        {
        }
};


// #pragma mark - IORequest


struct ModelLoader::IORequest : DoublyLinkedListLinkImpl<IORequest> {
        io_request_scheduled*   scheduledEvent;
        io_request_finished*    finishedEvent;
        IOOperationList                 operations;
        size_t                                  operationCount;
        IORequest*                              hashNext;

        IORequest(io_request_scheduled* scheduledEvent)
                :
                scheduledEvent(scheduledEvent),
                finishedEvent(NULL),
                operationCount(0)
        {
        }

        ~IORequest()
        {
                while (IOOperation* operation = operations.RemoveHead())
                        delete operation;
        }

        void AddOperation(IOOperation* operation)
        {
                operations.Add(operation);
                operationCount++;
        }

        IOOperation* FindOperation(void* address) const
        {
                for (IOOperationList::ConstReverseIterator it
                                = operations.GetReverseIterator();
                        IOOperation* operation = it.Next();) {
                        if (operation->startedEvent->operation == address)
                                return operation;
                }

                return NULL;
        }

        Model::IORequest* CreateModelRequest() const
        {
                size_t operationCount = operations.Count();

                Model::IORequest* modelRequest = Model::IORequest::Create(
                        scheduledEvent, finishedEvent, operationCount);
                if (modelRequest == NULL)
                        return NULL;

                size_t index = 0;
                for (IOOperationList::ConstIterator it = operations.GetIterator();
                                IOOperation* operation = it.Next();) {
                        Model::IOOperation& modelOperation
                                = modelRequest->operations[index++];
                        modelOperation.startedEvent = operation->startedEvent;
                        modelOperation.finishedEvent = operation->finishedEvent;
                }

                return modelRequest;
        }
};


// #pragma mark - IORequestHashDefinition


struct ModelLoader::IORequestHashDefinition {
        typedef void*           KeyType;
        typedef IORequest       ValueType;

        size_t HashKey(KeyType key) const
                { return (size_t)key; }

        size_t Hash(const IORequest* value) const
                { return HashKey(value->scheduledEvent->request); }

        bool Compare(KeyType key, const IORequest* value) const
                { return key == value->scheduledEvent->request; }

        IORequest*& GetLink(IORequest* value) const
                { return value->hashNext; }
};


// #pragma mark - ExtendedThreadSchedulingState


struct ModelLoader::ExtendedThreadSchedulingState
                : Model::ThreadSchedulingState {

        ExtendedThreadSchedulingState(Model::Thread* thread)
                :
                Model::ThreadSchedulingState(thread),
                fEvents(NULL),
                fEventIndex(0),
                fEventCount(0)
        {
        }

        ~ExtendedThreadSchedulingState()
        {
                delete[] fEvents;

                while (IORequest* request = fIORequests.RemoveHead())
                        delete request;
                while (IORequest* request = fPendingIORequests.RemoveHead())
                        delete request;
        }

        system_profiler_event_header** Events() const
        {
                return fEvents;
        }

        size_t CountEvents() const
        {
                return fEventCount;
        }

        system_profiler_event_header** DetachEvents()
        {
                system_profiler_event_header** events = fEvents;
                fEvents = NULL;
                return events;
        }

        void IncrementEventCount()
        {
                fEventCount++;
        }

        void AddEvent(system_profiler_event_header* event)
        {
                fEvents[fEventIndex++] = event;
        }

        bool AllocateEventArray()
        {
                if (fEventCount == 0)
                        return true;

                fEvents = new(std::nothrow) system_profiler_event_header*[fEventCount];
                if (fEvents == NULL)
                        return false;

                return true;
        }

        void AddIORequest(IORequest* request)
        {
                fPendingIORequests.Add(request);
        }

        void IORequestFinished(IORequest* request)
        {
                fPendingIORequests.Remove(request);
                fIORequests.Add(request);
        }

        bool PrepareThreadIORequests(Model::IORequest**& _requests,
                size_t& _requestCount)
        {
                fIORequests.TakeFrom(&fPendingIORequests);
                size_t requestCount = fIORequests.Count();

                if (requestCount == 0) {
                        _requests = NULL;
                        _requestCount = 0;
                        return true;
                }

                Model::IORequest** requests
                        = new(std::nothrow) Model::IORequest*[requestCount];
                if (requests == NULL)
                        return false;

                size_t index = 0;
                while (IORequest* request = fIORequests.RemoveHead()) {
                        ObjectDeleter<IORequest> requestDeleter(request);

                        Model::IORequest* modelRequest = request->CreateModelRequest();
                        if (modelRequest == NULL) {
                                for (size_t i = 0; i < index; i++)
                                        requests[i]->Delete();
                                delete[] requests;
                                return false;
                        }

                        requests[index++] = modelRequest;
                }

                _requests = requests;
                _requestCount = requestCount;
                return true;
        }

private:
        system_profiler_event_header**  fEvents;
        size_t                                                  fEventIndex;
        size_t                                                  fEventCount;
        IORequestList                                   fIORequests;
        IORequestList                                   fPendingIORequests;
};


// #pragma mark - ExtendedSchedulingState


struct ModelLoader::ExtendedSchedulingState : Model::SchedulingState {
        inline ExtendedThreadSchedulingState* LookupThread(thread_id threadID) const
        {
                Model::ThreadSchedulingState* thread
                        = Model::SchedulingState::LookupThread(threadID);
                return thread != NULL
                        ? static_cast<ExtendedThreadSchedulingState*>(thread) : NULL;
        }


protected:
        virtual void DeleteThread(Model::ThreadSchedulingState* thread)
        {
                delete static_cast<ExtendedThreadSchedulingState*>(thread);
        }
};


// #pragma mark - ModelLoader


inline void
ModelLoader::_UpdateLastEventTime(nanotime_t time)
{
        if (fBaseTime < 0) {
                fBaseTime = time;
                fModel->SetBaseTime(time);
        }

        fState->SetLastEventTime(time - fBaseTime);
}


ModelLoader::ModelLoader(DataSource* dataSource,
        const BMessenger& target, void* targetCookie)
        :
        AbstractModelLoader(target, targetCookie),
        fModel(NULL),
        fDataSource(dataSource),
        fCPUInfos(NULL),
        fState(NULL),
        fIORequests(NULL)
{
}


ModelLoader::~ModelLoader()
{
        delete[] fCPUInfos;
        delete fDataSource;
        delete fModel;
        delete fState;
        delete fIORequests;
}


Model*
ModelLoader::DetachModel()
{
        AutoLocker<BLocker> locker(fLock);

        if (fModel == NULL || fLoading)
                return NULL;

        Model* model = fModel;
        fModel = NULL;

        return model;
}


status_t
ModelLoader::PrepareForLoading()
{
        if (fModel != NULL || fDataSource == NULL)
                return B_BAD_VALUE;

        // create and init the state
        fState = new(std::nothrow) ExtendedSchedulingState;
        if (fState == NULL)
                return B_NO_MEMORY;

        status_t error = fState->Init();
        if (error != B_OK)
                return error;

        // create CPU info array
        fCPUInfos = new(std::nothrow) CPUInfo[kMaxCPUCount];
        if (fCPUInfos == NULL)
                return B_NO_MEMORY;

        // create IORequest hash table
        fIORequests = new(std::nothrow) IORequestTable;
        if (fIORequests == NULL || fIORequests->Init() != B_OK)
                return B_NO_MEMORY;

        return B_OK;
}


status_t
ModelLoader::Load()
{
        try {
                return _Load();
        } catch(...) {
                return B_ERROR;
        }
}


void
ModelLoader::FinishLoading(bool success)
{
        delete fState;
        fState = NULL;

        if (!success) {
                delete fModel;
                fModel = NULL;
        }

        delete[] fCPUInfos;
        fCPUInfos = NULL;

        delete fIORequests;
        fIORequests = NULL;
}


status_t
ModelLoader::_Load()
{
        // read the complete data into memory
        void* eventData;
        size_t eventDataSize;
        status_t error = _ReadDebugEvents(&eventData, &eventDataSize);
        if (error != B_OK)
                return error;
        MemoryDeleter eventDataDeleter(eventData);

        // create a debug event array
        system_profiler_event_header** events;
        size_t eventCount;
        error = _CreateDebugEventArray(eventData, eventDataSize, events,
                eventCount);
        if (error != B_OK)
                return error;
        ArrayDeleter<system_profiler_event_header*> eventsDeleter(events);

        // get the data source name
        BString dataSourceName;
        fDataSource->GetName(dataSourceName);

        // create a model
        fModel = new(std::nothrow) Model(dataSourceName.String(), eventData,
                eventDataSize, events, eventCount);
        if (fModel == NULL)
                return B_NO_MEMORY;
        eventDataDeleter.Detach();
        eventsDeleter.Detach();

        // create a debug input stream
        BDebugEventInputStream input;
        error = input.SetTo(eventData, eventDataSize, false);
        if (error != B_OK)
                return error;

        // add the snooze and signal wait objects to the model
        if (fModel->AddWaitObject(&kSnoozeWaitObjectInfo, NULL) == NULL
                || fModel->AddWaitObject(&kSignalWaitObjectInfo, NULL) == NULL) {
                return B_NO_MEMORY;
        }

        // process the events
        fMaxCPUIndex = 0;
        fState->Clear();
        fBaseTime = -1;
        uint64 count = 0;

        while (true) {
                // get next event
                uint32 event;
                uint32 cpu;
                const void* buffer;
                off_t offset;
                ssize_t bufferSize = input.ReadNextEvent(&event, &cpu, &buffer,
                        &offset);
                if (bufferSize < 0)
                        return bufferSize;
                if (buffer == NULL)
                        break;

                // process the event
                status_t error = _ProcessEvent(event, cpu, buffer, bufferSize);
                if (error != B_OK)
                        return error;

                if (cpu > fMaxCPUIndex) {
                        if (cpu + 1 > kMaxCPUCount)
                                return B_BAD_DATA;
                        fMaxCPUIndex = cpu;
                }

                // periodically check whether we're supposed to abort
                if (++count % 32 == 0) {
                        AutoLocker<BLocker> locker(fLock);
                        if (fAborted)
                                return B_ERROR;
                }

                // periodically add scheduling snapshots
                if (count % kSchedulingSnapshotInterval == 0)
                        fModel->AddSchedulingStateSnapshot(*fState, offset);
        }

        if (!fModel->SetCPUCount(fMaxCPUIndex + 1))
                return B_NO_MEMORY;

        for (uint32 i = 0; i <= fMaxCPUIndex; i++)
                fModel->CPUAt(i)->SetIdleTime(fCPUInfos[i].idleTime);

        fModel->SetLastEventTime(fState->LastEventTime());

        if (!_SetThreadEvents() || !_SetThreadIORequests())
                return B_NO_MEMORY;

        fModel->LoadingFinished();

        return B_OK;
}


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::_CreateDebugEventArray(void* eventData, size_t eventDataSize,
        system_profiler_event_header**& _events, size_t& _eventCount)
{
        // count the events
        BDebugEventInputStream input;
        status_t error = input.SetTo(eventData, eventDataSize, false);
        if (error != B_OK)
                return error;

        size_t eventCount = 0;
        while (true) {
                // get next event
                uint32 event;
                uint32 cpu;
                const void* buffer;
                ssize_t bufferSize = input.ReadNextEvent(&event, &cpu, &buffer, NULL);
                if (bufferSize < 0)
                        return bufferSize;
                if (buffer == NULL)
                        break;

                eventCount++;
        }

        // create the array
        system_profiler_event_header** events = new(std::nothrow)
                system_profiler_event_header*[eventCount];
        if (events == NULL)
                return B_NO_MEMORY;

        // populate the array
        error = input.SetTo(eventData, eventDataSize, false);
        if (error != B_OK) {
                delete[] events;
                return error;
        }

        size_t eventIndex = 0;
        while (true) {
                // get next event
                uint32 event;
                uint32 cpu;
                const void* buffer;
                off_t offset;
                input.ReadNextEvent(&event, &cpu, &buffer, &offset);
                if (buffer == NULL)
                        break;

                events[eventIndex++]
                        = (system_profiler_event_header*)((uint8*)eventData + offset);
        }

        _events = events;
        _eventCount = eventCount;
        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:
                        _HandleTeamAdded((system_profiler_team_added*)buffer);
                        break;

                case B_SYSTEM_PROFILER_TEAM_REMOVED:
                        _HandleTeamRemoved((system_profiler_team_removed*)buffer);
                        break;

                case B_SYSTEM_PROFILER_TEAM_EXEC:
                        _HandleTeamExec((system_profiler_team_exec*)buffer);
                        break;

                case B_SYSTEM_PROFILER_THREAD_ADDED:
                        _HandleThreadAdded((system_profiler_thread_added*)buffer);
                        break;

                case B_SYSTEM_PROFILER_THREAD_REMOVED:
                        _HandleThreadRemoved((system_profiler_thread_removed*)buffer);
                        break;

                case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
                        _HandleThreadScheduled(cpu,
                                (system_profiler_thread_scheduled*)buffer);
                        break;

                case B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE:
                        _HandleThreadEnqueuedInRunQueue(
                                (thread_enqueued_in_run_queue*)buffer);
                        break;

                case B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE:
                        _HandleThreadRemovedFromRunQueue(cpu,
                                (thread_removed_from_run_queue*)buffer);
                        break;

                case B_SYSTEM_PROFILER_WAIT_OBJECT_INFO:
                        _HandleWaitObjectInfo((system_profiler_wait_object_info*)buffer);
                        break;

                case B_SYSTEM_PROFILER_IO_SCHEDULER_ADDED:
                        _HandleIOSchedulerAdded(
                                (system_profiler_io_scheduler_added*)buffer);
                        break;

                case B_SYSTEM_PROFILER_IO_SCHEDULER_REMOVED:
                        // not so interesting
                        break;

                case B_SYSTEM_PROFILER_IO_REQUEST_SCHEDULED:
                        _HandleIORequestScheduled((io_request_scheduled*)buffer);
                        break;
                case B_SYSTEM_PROFILER_IO_REQUEST_FINISHED:
                        _HandleIORequestFinished((io_request_finished*)buffer);
                        break;
                case B_SYSTEM_PROFILER_IO_OPERATION_STARTED:
                        _HandleIOOperationStarted((io_operation_started*)buffer);
                        break;
                case B_SYSTEM_PROFILER_IO_OPERATION_FINISHED:
                        _HandleIOOperationFinished((io_operation_finished*)buffer);
                        break;

                default:
                        printf("unsupported event type %" B_PRIu32 ", size: %" B_PRIuSIZE
                                "\n", event, size);
                        return B_BAD_DATA;
        }

        return B_OK;
}


bool
ModelLoader::_SetThreadEvents()
{
        // allocate the threads' events arrays
        for (int32 i = 0; Model::Thread* thread = fModel->ThreadAt(i); i++) {
                ExtendedThreadSchedulingState* state
                        = fState->LookupThread(thread->ID());
                if (!state->AllocateEventArray())
                        return false;
        }

        // fill the threads' event arrays
        system_profiler_event_header** events = fModel->Events();
        size_t eventCount = fModel->CountEvents();
        for (size_t i = 0; i < eventCount; i++) {
                system_profiler_event_header* header = events[i];
                void* buffer = header + 1;

                switch (header->event) {
                        case B_SYSTEM_PROFILER_THREAD_ADDED:
                        {
                                system_profiler_thread_added* event
                                        = (system_profiler_thread_added*)buffer;
                                fState->LookupThread(event->thread)->AddEvent(header);
                                break;
                        }

                        case B_SYSTEM_PROFILER_THREAD_REMOVED:
                        {
                                system_profiler_thread_removed* event
                                        = (system_profiler_thread_removed*)buffer;
                                fState->LookupThread(event->thread)->AddEvent(header);
                                break;
                        }

                        case B_SYSTEM_PROFILER_THREAD_SCHEDULED:
                        {
                                system_profiler_thread_scheduled* event
                                        = (system_profiler_thread_scheduled*)buffer;
                                fState->LookupThread(event->thread)->AddEvent(header);

                                if (event->thread != event->previous_thread) {
                                        fState->LookupThread(event->previous_thread)
                                                ->AddEvent(header);
                                }
                                break;
                        }

                        case B_SYSTEM_PROFILER_THREAD_ENQUEUED_IN_RUN_QUEUE:
                        {
                                thread_enqueued_in_run_queue* event
                                        = (thread_enqueued_in_run_queue*)buffer;
                                fState->LookupThread(event->thread)->AddEvent(header);
                                break;
                        }

                        case B_SYSTEM_PROFILER_THREAD_REMOVED_FROM_RUN_QUEUE:
                        {
                                thread_removed_from_run_queue* event
                                        = (thread_removed_from_run_queue*)buffer;
                                fState->LookupThread(event->thread)->AddEvent(header);
                                break;
                        }

                        default:
                                break;
                }
        }

        // transfer the events arrays from the scheduling states to the thread
        // objects
        for (int32 i = 0; Model::Thread* thread = fModel->ThreadAt(i); i++) {
                ExtendedThreadSchedulingState* state
                        = fState->LookupThread(thread->ID());
                thread->SetEvents(state->Events(), state->CountEvents());
                state->DetachEvents();
        }

        return true;
}


bool
ModelLoader::_SetThreadIORequests()
{
        for (int32 i = 0; Model::Thread* thread = fModel->ThreadAt(i); i++) {
                ExtendedThreadSchedulingState* state
                        = fState->LookupThread(thread->ID());
                Model::IORequest** requests;
                size_t requestCount;
                if (!state->PrepareThreadIORequests(requests, requestCount))
                        return false;
                if (requestCount > 0)
                        _SetThreadIORequests(thread, requests, requestCount);
        }

        return true;
}


void
ModelLoader::_SetThreadIORequests(Model::Thread* thread,
        Model::IORequest** requests, size_t requestCount)
{
        // compute some totals
        int64 ioCount = 0;
        nanotime_t ioTime = 0;

        // sort requests by scheduler and start time
        std::sort(requests, requests + requestCount,
                Model::IORequest::SchedulerTimeLess);

        nanotime_t endTime = fBaseTime + fModel->LastEventTime();

        // compute the summed up I/O times
        nanotime_t ioStart = requests[0]->scheduledEvent->time;
        nanotime_t previousEnd = requests[0]->finishedEvent != NULL
                ? requests[0]->finishedEvent->time : endTime;
        int32 scheduler = requests[0]->scheduledEvent->scheduler;

        for (size_t i = 1; i < requestCount; i++) {
                system_profiler_io_request_scheduled* scheduledEvent
                        = requests[i]->scheduledEvent;
                if (scheduledEvent->scheduler != scheduler
                        || scheduledEvent->time >= previousEnd) {
                        ioCount++;
                        ioTime += previousEnd - ioStart;
                        ioStart = scheduledEvent->time;
                }

                previousEnd = requests[i]->finishedEvent != NULL
                        ? requests[i]->finishedEvent->time : endTime;
        }

        ioCount++;
        ioTime += previousEnd - ioStart;

        // sort requests by start time
        std::sort(requests, requests + requestCount, Model::IORequest::TimeLess);

        // set the computed values
        thread->SetIORequests(requests, requestCount);
        thread->SetIOs(ioCount, ioTime);
}


void
ModelLoader::_HandleTeamAdded(system_profiler_team_added* event)
{
        if (fModel->AddTeam(event, fState->LastEventTime()) == NULL)
                throw std::bad_alloc();
}


void
ModelLoader::_HandleTeamRemoved(system_profiler_team_removed* event)
{
        if (Model::Team* team = fModel->TeamByID(event->team))
                team->SetDeletionTime(fState->LastEventTime());
        else {
                printf("Warning: Removed event for unknown team: %" B_PRId32 "\n",
                        event->team);
        }
}


void
ModelLoader::_HandleTeamExec(system_profiler_team_exec* event)
{
        // TODO:...
}


void
ModelLoader::_HandleThreadAdded(system_profiler_thread_added* event)
{
        _AddThread(event)->IncrementEventCount();
}


void
ModelLoader::_HandleThreadRemoved(system_profiler_thread_removed* event)
{
        ExtendedThreadSchedulingState* thread = fState->LookupThread(event->thread);
        if (thread == NULL) {
                printf("Warning: Removed event for unknown thread: %" B_PRId32 "\n",
                        event->thread);
                thread = _AddUnknownThread(event->thread);
        }

        thread->thread->SetDeletionTime(fState->LastEventTime());
        thread->IncrementEventCount();
}


void
ModelLoader::_HandleThreadScheduled(uint32 cpu,
        system_profiler_thread_scheduled* event)
{
        _UpdateLastEventTime(event->time);

        ExtendedThreadSchedulingState* thread = fState->LookupThread(event->thread);
        if (thread == NULL) {
                printf("Warning: Schedule event for unknown thread: %" B_PRId32 "\n",
                        event->thread);
                thread = _AddUnknownThread(event->thread);
                return;
        }

        nanotime_t diffTime = fState->LastEventTime() - thread->lastTime;

        if (thread->state == READY) {
                // thread scheduled after having been woken up
                thread->thread->AddLatency(diffTime);
        } else if (thread->state == PREEMPTED) {
                // thread scheduled after having been preempted before
                thread->thread->AddRerun(diffTime);
        }

        if (thread->state == STILL_RUNNING) {
                // Thread was running and continues to run.
                thread->state = RUNNING;
        }

        if (thread->state != RUNNING) {
                thread->lastTime = fState->LastEventTime();
                thread->state = RUNNING;
        }

        thread->IncrementEventCount();

        // unscheduled thread

        if (event->thread == event->previous_thread)
                return;

        thread = fState->LookupThread(event->previous_thread);
        if (thread == NULL) {
                printf("Warning: Schedule event for unknown previous thread: %" B_PRId32
                        "\n", event->previous_thread);
                thread = _AddUnknownThread(event->previous_thread);
        }

        diffTime = fState->LastEventTime() - thread->lastTime;

        if (thread->state == STILL_RUNNING) {
                // thread preempted
                thread->thread->AddPreemption(diffTime);
                thread->thread->AddRun(diffTime);
                if (thread->priority == 0)
                        _AddIdleTime(cpu, diffTime);

                thread->lastTime = fState->LastEventTime();
                thread->state = PREEMPTED;
        } else if (thread->state == RUNNING) {
                // thread starts waiting (it hadn't been added to the run
                // queue before being unscheduled)
                thread->thread->AddRun(diffTime);
                if (thread->priority == 0)
                        _AddIdleTime(cpu, diffTime);

                if (event->previous_thread_state == B_THREAD_WAITING) {
                        addr_t waitObject = event->previous_thread_wait_object;
                        switch (event->previous_thread_wait_object_type) {
                                case THREAD_BLOCK_TYPE_SNOOZE:
                                case THREAD_BLOCK_TYPE_SIGNAL:
                                        waitObject = 0;
                                        break;
                                case THREAD_BLOCK_TYPE_SEMAPHORE:
                                case THREAD_BLOCK_TYPE_CONDITION_VARIABLE:
                                case THREAD_BLOCK_TYPE_MUTEX:
                                case THREAD_BLOCK_TYPE_RW_LOCK:
                                case THREAD_BLOCK_TYPE_OTHER:
                                case THREAD_BLOCK_TYPE_OTHER_OBJECT:
                                default:
                                        break;
                        }

                        _AddThreadWaitObject(thread,
                                event->previous_thread_wait_object_type, waitObject);
                }

                thread->lastTime = fState->LastEventTime();
                thread->state = WAITING;
        } else if (thread->state == UNKNOWN) {
                uint32 threadState = event->previous_thread_state;
                if (threadState == B_THREAD_WAITING
                        || threadState == B_THREAD_SUSPENDED) {
                        thread->lastTime = fState->LastEventTime();
                        thread->state = WAITING;
                } else if (threadState == B_THREAD_READY) {
                        thread->lastTime = fState->LastEventTime();
                        thread->state = PREEMPTED;
                }
        }

        thread->IncrementEventCount();
}


void
ModelLoader::_HandleThreadEnqueuedInRunQueue(
        thread_enqueued_in_run_queue* event)
{
        _UpdateLastEventTime(event->time);

        ExtendedThreadSchedulingState* thread = fState->LookupThread(event->thread);
        if (thread == NULL) {
                printf("Warning: Enqueued in run queue event for unknown thread: %"
                        B_PRId32 "\n", event->thread);
                thread = _AddUnknownThread(event->thread);
        }

        if (thread->state == RUNNING || thread->state == STILL_RUNNING) {
                // Thread was running and is reentered into the run queue. This
                // is done by the scheduler, if the thread remains ready.
                thread->state = STILL_RUNNING;
        } else {
                // Thread was waiting and is ready now.
                nanotime_t diffTime = fState->LastEventTime() - thread->lastTime;
                if (thread->waitObject != NULL) {
                        thread->waitObject->AddWait(diffTime);
                        thread->waitObject = NULL;
                        thread->thread->AddWait(diffTime);
                } else if (thread->state != UNKNOWN)
                        thread->thread->AddUnspecifiedWait(diffTime);

                thread->lastTime = fState->LastEventTime();
                thread->state = READY;
        }

        thread->priority = event->priority;

        thread->IncrementEventCount();
}


void
ModelLoader::_HandleThreadRemovedFromRunQueue(uint32 cpu,
        thread_removed_from_run_queue* event)
{
        _UpdateLastEventTime(event->time);

        ExtendedThreadSchedulingState* thread = fState->LookupThread(event->thread);
        if (thread == NULL) {
                printf("Warning: Removed from run queue event for unknown thread: "
                        "%" B_PRId32 "\n", event->thread);
                thread = _AddUnknownThread(event->thread);
        }

        // This really only happens when the thread priority is changed
        // while the thread is ready.

        nanotime_t diffTime = fState->LastEventTime() - thread->lastTime;
        if (thread->state == RUNNING) {
                // This should never happen.
                thread->thread->AddRun(diffTime);
                if (thread->priority == 0)
                        _AddIdleTime(cpu, diffTime);
        } else if (thread->state == READY || thread->state == PREEMPTED) {
                // Not really correct, but the case is rare and we keep it
                // simple.
                thread->thread->AddUnspecifiedWait(diffTime);
        }

        thread->lastTime = fState->LastEventTime();
        thread->state = WAITING;

        thread->IncrementEventCount();
}


void
ModelLoader::_HandleWaitObjectInfo(system_profiler_wait_object_info* event)
{
        if (fModel->AddWaitObject(event, NULL) == NULL)
                throw std::bad_alloc();
}


void
ModelLoader::_HandleIOSchedulerAdded(system_profiler_io_scheduler_added* event)
{
        Model::IOScheduler* scheduler = fModel->IOSchedulerByID(event->scheduler);
        if (scheduler != NULL) {
                printf("Warning: Duplicate added event for I/O scheduler %" B_PRId32
                        "\n", event->scheduler);
                return;
        }

        if (fModel->AddIOScheduler(event) == NULL)
                throw std::bad_alloc();
}


void
ModelLoader::_HandleIORequestScheduled(io_request_scheduled* event)
{
        IORequest* request = fIORequests->Lookup(event->request);
        if (request != NULL) {
                printf("Warning: Duplicate schedule event for I/O request %p\n",
                        event->request);
                return;
        }

        ExtendedThreadSchedulingState* thread = fState->LookupThread(event->thread);
        if (thread == NULL) {
                printf("Warning: I/O request for unknown thread %" B_PRId32 "\n",
                        event->thread);
                thread = _AddUnknownThread(event->thread);
        }

        if (fModel->IOSchedulerByID(event->scheduler) == NULL) {
                printf("Warning: I/O requests for unknown scheduler %" B_PRId32 "\n",
                        event->scheduler);
                // TODO: Add state for unknown scheduler, as we do for threads.
                return;
        }

        request = new(std::nothrow) IORequest(event);
        if (request == NULL)
                throw std::bad_alloc();

        fIORequests->Insert(request);
        thread->AddIORequest(request);
}


void
ModelLoader::_HandleIORequestFinished(io_request_finished* event)
{
        IORequest* request = fIORequests->Lookup(event->request);
        if (request == NULL)
                return;

        request->finishedEvent = event;

        fIORequests->Remove(request);
        fState->LookupThread(request->scheduledEvent->thread)
                ->IORequestFinished(request);
}


void
ModelLoader::_HandleIOOperationStarted(io_operation_started* event)
{
        IORequest* request = fIORequests->Lookup(event->request);
        if (request == NULL) {
                printf("Warning: I/O request for operation %p not found\n",
                        event->operation);
                return;
        }

        IOOperation* operation = new(std::nothrow) IOOperation(event);
        if (operation == NULL)
                throw std::bad_alloc();

        request->AddOperation(operation);
}


void
ModelLoader::_HandleIOOperationFinished(io_operation_finished* event)
{
        IORequest* request = fIORequests->Lookup(event->request);
        if (request == NULL) {
                printf("Warning: I/O request for operation %p not found\n",
                        event->operation);
                return;
        }

        IOOperation* operation = request->FindOperation(event->operation);
        if (operation == NULL) {
                printf("Warning: operation %p not found\n", event->operation);
                return;
        }

        operation->finishedEvent = event;
}


ModelLoader::ExtendedThreadSchedulingState*
ModelLoader::_AddThread(system_profiler_thread_added* event)
{
        // do we know the thread already?
        ExtendedThreadSchedulingState* info = fState->LookupThread(event->thread);
        if (info != NULL) {
                printf("Warning: Duplicate thread added event for thread %" B_PRId32
                        "\n", event->thread);
                return info;
        }

        // add the thread to the model
        Model::Thread* thread = fModel->AddThread(event, fState->LastEventTime());
        if (thread == NULL)
                throw std::bad_alloc();

        // create and add a ThreadSchedulingState
        info = new(std::nothrow) ExtendedThreadSchedulingState(thread);
        if (info == NULL)
                throw std::bad_alloc();

        // TODO: The priority is missing from the system_profiler_thread_added
        // struct. For now guess at least whether this is an idle thread.
        if (strncmp(event->name, "idle thread", strlen("idle thread")) == 0)
                info->priority = 0;
        else
                info->priority = B_NORMAL_PRIORITY;

        fState->InsertThread(info);

        return info;
}


ModelLoader::ExtendedThreadSchedulingState*
ModelLoader::_AddUnknownThread(thread_id threadID)
{
        // create a dummy "add thread" event
        system_profiler_thread_added* event = (system_profiler_thread_added*)
                malloc(sizeof(system_profiler_thread_added));
        if (event == NULL)
                throw std::bad_alloc();

        if (!fModel->AddAssociatedData(event)) {
                free(event);
                throw std::bad_alloc();
        }

        try {
                event->team = _AddUnknownTeam()->ID();
                event->thread = threadID;
                snprintf(event->name, sizeof(event->name), "unknown thread %" B_PRId32,
                        threadID);

                // add the thread to the model
                ExtendedThreadSchedulingState* state = _AddThread(event);
                return state;
        } catch (...) {
                throw;
        }
}

Model::Team*
ModelLoader::_AddUnknownTeam()
{
        team_id teamID = 0;
        Model::Team* team = fModel->TeamByID(teamID);
        if (team != NULL)
                return team;

        // create a dummy "add team" event
        static const char* const kUnknownThreadsTeamName = "unknown threads";
        size_t nameLength = strlen(kUnknownThreadsTeamName);

        system_profiler_team_added* event = (system_profiler_team_added*)
                malloc(sizeof(system_profiler_team_added) + nameLength);
        if (event == NULL)
                throw std::bad_alloc();

        event->team = teamID;
        event->args_offset = nameLength;
        strlcpy(event->name, kUnknownThreadsTeamName, nameLength + 1);

        // add the team to the model
        team = fModel->AddTeam(event, fState->LastEventTime());
        if (team == NULL)
                throw std::bad_alloc();

        return team;
}


void
ModelLoader::_AddThreadWaitObject(ExtendedThreadSchedulingState* thread,
        uint32 type, addr_t object)
{
        Model::WaitObjectGroup* waitObjectGroup
                = fModel->WaitObjectGroupFor(type, object);
        if (waitObjectGroup == NULL) {
                // The algorithm should prevent this case.
                printf("ModelLoader::_AddThreadWaitObject(): Unknown wait object: type:"
                        " %" B_PRIu32 ", " "object: %#" B_PRIxADDR "\n", type, object);
                return;
        }

        Model::WaitObject* waitObject = waitObjectGroup->MostRecentWaitObject();

        Model::ThreadWaitObjectGroup* threadWaitObjectGroup
                = fModel->ThreadWaitObjectGroupFor(thread->ID(), type, object);

        if (threadWaitObjectGroup == NULL
                || threadWaitObjectGroup->MostRecentWaitObject() != waitObject) {
                Model::ThreadWaitObject* threadWaitObject
                        = fModel->AddThreadWaitObject(thread->ID(), waitObject,
                                &threadWaitObjectGroup);
                if (threadWaitObject == NULL)
                        throw std::bad_alloc();
        }

        thread->waitObject = threadWaitObjectGroup->MostRecentThreadWaitObject();
}


void
ModelLoader::_AddIdleTime(uint32 cpu, nanotime_t time)
{
        fCPUInfos[cpu].idleTime += time;
}