From 3dc3bd56271c14d42e900041317bad00b553752a Mon Sep 17 00:00:00 2001
From: bunnei <ericbunnie@gmail.com>
Date: Tue, 8 Apr 2014 19:11:21 -0400
Subject: [PATCH] fixed licensing issue with core_timing being GPL v2+ instead
of Dolphin's GPL v2
---
src/core/src/core_timing.cpp | 804 +++++++++++++++++------------------
src/core/src/core_timing.h | 116 +++--
2 files changed, 444 insertions(+), 476 deletions(-)
diff --git a/src/core/src/core_timing.cpp b/src/core/src/core_timing.cpp
index 73dd9b549d..78bbaafe2d 100644
--- a/src/core/src/core_timing.cpp
+++ b/src/core/src/core_timing.cpp
@@ -1,20 +1,6 @@
-// Copyright (c) 2012- PPSSPP Project / Dolphin Project.
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
#include <vector>
#include <cstdio>
@@ -26,8 +12,6 @@
#include "core.h"
#include "chunk_file.h"
-//#include "HLE/sceKernelThread.h"
-
int g_clock_rate_arm11 = 268123480;
// is this really necessary?
@@ -39,23 +23,23 @@ namespace CoreTiming
struct EventType
{
- EventType() {}
+ EventType() {}
- EventType(TimedCallback cb, const char *n)
- : callback(cb), name(n) {}
+ EventType(TimedCallback cb, const char *n)
+ : callback(cb), name(n) {}
- TimedCallback callback;
- const char *name;
+ TimedCallback callback;
+ const char *name;
};
std::vector<EventType> event_types;
struct BaseEvent
{
- s64 time;
- u64 userdata;
- int type;
-// Event *next;
+ s64 time;
+ u64 userdata;
+ int type;
+ // Event *next;
};
typedef LinkedListItem<BaseEvent> Event;
@@ -81,123 +65,123 @@ s64 idledCycles;
static std::recursive_mutex externalEventSection;
// Warning: not included in save state.
-void (*advanceCallback)(int cyclesExecuted) = NULL;
+void(*advanceCallback)(int cyclesExecuted) = NULL;
void SetClockFrequencyMHz(int cpuMhz)
{
- g_clock_rate_arm11 = cpuMhz * 1000000;
- // TODO: Rescale times of scheduled events?
+ g_clock_rate_arm11 = cpuMhz * 1000000;
+ // TODO: Rescale times of scheduled events?
}
int GetClockFrequencyMHz()
{
- return g_clock_rate_arm11 / 1000000;
+ return g_clock_rate_arm11 / 1000000;
}
Event* GetNewEvent()
{
- if(!eventPool)
- return new Event;
+ if (!eventPool)
+ return new Event;
- Event* ev = eventPool;
- eventPool = ev->next;
- return ev;
+ Event* ev = eventPool;
+ eventPool = ev->next;
+ return ev;
}
Event* GetNewTsEvent()
{
- allocatedTsEvents++;
+ allocatedTsEvents++;
- if(!eventTsPool)
- return new Event;
+ if (!eventTsPool)
+ return new Event;
- Event* ev = eventTsPool;
- eventTsPool = ev->next;
- return ev;
+ Event* ev = eventTsPool;
+ eventTsPool = ev->next;
+ return ev;
}
void FreeEvent(Event* ev)
{
- ev->next = eventPool;
- eventPool = ev;
+ ev->next = eventPool;
+ eventPool = ev;
}
void FreeTsEvent(Event* ev)
{
- ev->next = eventTsPool;
- eventTsPool = ev;
- allocatedTsEvents--;
+ ev->next = eventTsPool;
+ eventTsPool = ev;
+ allocatedTsEvents--;
}
int RegisterEvent(const char *name, TimedCallback callback)
{
- event_types.push_back(EventType(callback, name));
- return (int)event_types.size() - 1;
+ event_types.push_back(EventType(callback, name));
+ return (int)event_types.size() - 1;
}
void AntiCrashCallback(u64 userdata, int cyclesLate)
{
- ERROR_LOG(TIME, "Savestate broken: an unregistered event was called.");
- Core::Halt("invalid timing events");
+ ERROR_LOG(TIME, "Savestate broken: an unregistered event was called.");
+ Core::Halt("invalid timing events");
}
void RestoreRegisterEvent(int event_type, const char *name, TimedCallback callback)
{
- if (event_type >= (int) event_types.size())
- event_types.resize(event_type + 1, EventType(AntiCrashCallback, "INVALID EVENT"));
+ if (event_type >= (int)event_types.size())
+ event_types.resize(event_type + 1, EventType(AntiCrashCallback, "INVALID EVENT"));
- event_types[event_type] = EventType(callback, name);
+ event_types[event_type] = EventType(callback, name);
}
void UnregisterAllEvents()
{
- if (first)
- PanicAlert("Cannot unregister events with events pending");
- event_types.clear();
+ if (first)
+ PanicAlert("Cannot unregister events with events pending");
+ event_types.clear();
}
void Init()
{
- //currentMIPS->downcount = INITIAL_SLICE_LENGTH;
- //slicelength = INITIAL_SLICE_LENGTH;
- globalTimer = 0;
- idledCycles = 0;
- hasTsEvents = 0;
+ //currentMIPS->downcount = INITIAL_SLICE_LENGTH;
+ //slicelength = INITIAL_SLICE_LENGTH;
+ globalTimer = 0;
+ idledCycles = 0;
+ hasTsEvents = 0;
}
void Shutdown()
{
- MoveEvents();
- ClearPendingEvents();
- UnregisterAllEvents();
+ MoveEvents();
+ ClearPendingEvents();
+ UnregisterAllEvents();
- while(eventPool)
- {
- Event *ev = eventPool;
- eventPool = ev->next;
- delete ev;
- }
+ while (eventPool)
+ {
+ Event *ev = eventPool;
+ eventPool = ev->next;
+ delete ev;
+ }
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- while(eventTsPool)
- {
- Event *ev = eventTsPool;
- eventTsPool = ev->next;
- delete ev;
- }
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ while (eventTsPool)
+ {
+ Event *ev = eventTsPool;
+ eventTsPool = ev->next;
+ delete ev;
+ }
}
u64 GetTicks()
{
- ERROR_LOG(TIME, "Unimplemented function!");
- return 0;
- //return (u64)globalTimer + slicelength - currentMIPS->downcount;
+ ERROR_LOG(TIME, "Unimplemented function!");
+ return 0;
+ //return (u64)globalTimer + slicelength - currentMIPS->downcount;
}
u64 GetIdleTicks()
{
- return (u64)idledCycles;
+ return (u64)idledCycles;
}
@@ -205,60 +189,60 @@ u64 GetIdleTicks()
// schedule things to be executed on the main thread.
void ScheduleEvent_Threadsafe(s64 cyclesIntoFuture, int event_type, u64 userdata)
{
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- Event *ne = GetNewTsEvent();
- ne->time = GetTicks() + cyclesIntoFuture;
- ne->type = event_type;
- ne->next = 0;
- ne->userdata = userdata;
- if(!tsFirst)
- tsFirst = ne;
- if(tsLast)
- tsLast->next = ne;
- tsLast = ne;
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ Event *ne = GetNewTsEvent();
+ ne->time = GetTicks() + cyclesIntoFuture;
+ ne->type = event_type;
+ ne->next = 0;
+ ne->userdata = userdata;
+ if (!tsFirst)
+ tsFirst = ne;
+ if (tsLast)
+ tsLast->next = ne;
+ tsLast = ne;
- Common::AtomicStoreRelease(hasTsEvents, 1);
+ Common::AtomicStoreRelease(hasTsEvents, 1);
}
// Same as ScheduleEvent_Threadsafe(0, ...) EXCEPT if we are already on the CPU thread
// in which case the event will get handled immediately, before returning.
void ScheduleEvent_Threadsafe_Immediate(int event_type, u64 userdata)
{
- if(false) //Core::IsCPUThread())
- {
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- event_types[event_type].callback(userdata, 0);
- }
- else
- ScheduleEvent_Threadsafe(0, event_type, userdata);
+ if (false) //Core::IsCPUThread())
+ {
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ event_types[event_type].callback(userdata, 0);
+ }
+ else
+ ScheduleEvent_Threadsafe(0, event_type, userdata);
}
void ClearPendingEvents()
{
- while (first)
- {
- Event *e = first->next;
- FreeEvent(first);
- first = e;
- }
+ while (first)
+ {
+ Event *e = first->next;
+ FreeEvent(first);
+ first = e;
+ }
}
void AddEventToQueue(Event* ne)
{
- Event* prev = NULL;
- Event** pNext = &first;
- for(;;)
- {
- Event*& next = *pNext;
- if(!next || ne->time < next->time)
- {
- ne->next = next;
- next = ne;
- break;
- }
- prev = next;
- pNext = &prev->next;
- }
+ Event* prev = NULL;
+ Event** pNext = &first;
+ for (;;)
+ {
+ Event*& next = *pNext;
+ if (!next || ne->time < next->time)
+ {
+ ne->next = next;
+ next = ne;
+ break;
+ }
+ prev = next;
+ pNext = &prev->next;
+ }
}
// This must be run ONLY from within the cpu thread
@@ -266,374 +250,374 @@ void AddEventToQueue(Event* ne)
// than Advance
void ScheduleEvent(s64 cyclesIntoFuture, int event_type, u64 userdata)
{
- Event *ne = GetNewEvent();
- ne->userdata = userdata;
- ne->type = event_type;
- ne->time = GetTicks() + cyclesIntoFuture;
- AddEventToQueue(ne);
+ Event *ne = GetNewEvent();
+ ne->userdata = userdata;
+ ne->type = event_type;
+ ne->time = GetTicks() + cyclesIntoFuture;
+ AddEventToQueue(ne);
}
// Returns cycles left in timer.
s64 UnscheduleEvent(int event_type, u64 userdata)
{
- s64 result = 0;
- if (!first)
- return result;
- while(first)
- {
- if (first->type == event_type && first->userdata == userdata)
- {
- result = first->time - globalTimer;
+ s64 result = 0;
+ if (!first)
+ return result;
+ while (first)
+ {
+ if (first->type == event_type && first->userdata == userdata)
+ {
+ result = first->time - globalTimer;
- Event *next = first->next;
- FreeEvent(first);
- first = next;
- }
- else
- {
- break;
- }
- }
- if (!first)
- return result;
- Event *prev = first;
- Event *ptr = prev->next;
- while (ptr)
- {
- if (ptr->type == event_type && ptr->userdata == userdata)
- {
- result = ptr->time - globalTimer;
+ Event *next = first->next;
+ FreeEvent(first);
+ first = next;
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (!first)
+ return result;
+ Event *prev = first;
+ Event *ptr = prev->next;
+ while (ptr)
+ {
+ if (ptr->type == event_type && ptr->userdata == userdata)
+ {
+ result = ptr->time - globalTimer;
- prev->next = ptr->next;
- FreeEvent(ptr);
- ptr = prev->next;
- }
- else
- {
- prev = ptr;
- ptr = ptr->next;
- }
- }
+ prev->next = ptr->next;
+ FreeEvent(ptr);
+ ptr = prev->next;
+ }
+ else
+ {
+ prev = ptr;
+ ptr = ptr->next;
+ }
+ }
- return result;
+ return result;
}
s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata)
{
- s64 result = 0;
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- if (!tsFirst)
- return result;
- while(tsFirst)
- {
- if (tsFirst->type == event_type && tsFirst->userdata == userdata)
- {
- result = tsFirst->time - globalTimer;
+ s64 result = 0;
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ if (!tsFirst)
+ return result;
+ while (tsFirst)
+ {
+ if (tsFirst->type == event_type && tsFirst->userdata == userdata)
+ {
+ result = tsFirst->time - globalTimer;
- Event *next = tsFirst->next;
- FreeTsEvent(tsFirst);
- tsFirst = next;
- }
- else
- {
- break;
- }
- }
- if (!tsFirst)
- {
- tsLast = NULL;
- return result;
- }
+ Event *next = tsFirst->next;
+ FreeTsEvent(tsFirst);
+ tsFirst = next;
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (!tsFirst)
+ {
+ tsLast = NULL;
+ return result;
+ }
- Event *prev = tsFirst;
- Event *ptr = prev->next;
- while (ptr)
- {
- if (ptr->type == event_type && ptr->userdata == userdata)
- {
- result = ptr->time - globalTimer;
+ Event *prev = tsFirst;
+ Event *ptr = prev->next;
+ while (ptr)
+ {
+ if (ptr->type == event_type && ptr->userdata == userdata)
+ {
+ result = ptr->time - globalTimer;
- prev->next = ptr->next;
- if (ptr == tsLast)
- tsLast = prev;
- FreeTsEvent(ptr);
- ptr = prev->next;
- }
- else
- {
- prev = ptr;
- ptr = ptr->next;
- }
- }
+ prev->next = ptr->next;
+ if (ptr == tsLast)
+ tsLast = prev;
+ FreeTsEvent(ptr);
+ ptr = prev->next;
+ }
+ else
+ {
+ prev = ptr;
+ ptr = ptr->next;
+ }
+ }
- return result;
+ return result;
}
// Warning: not included in save state.
-void RegisterAdvanceCallback(void (*callback)(int cyclesExecuted))
+void RegisterAdvanceCallback(void(*callback)(int cyclesExecuted))
{
- advanceCallback = callback;
+ advanceCallback = callback;
}
-bool IsScheduled(int event_type)
+bool IsScheduled(int event_type)
{
- if (!first)
- return false;
- Event *e = first;
- while (e) {
- if (e->type == event_type)
- return true;
- e = e->next;
- }
- return false;
+ if (!first)
+ return false;
+ Event *e = first;
+ while (e) {
+ if (e->type == event_type)
+ return true;
+ e = e->next;
+ }
+ return false;
}
void RemoveEvent(int event_type)
{
- if (!first)
- return;
- while(first)
- {
- if (first->type == event_type)
- {
- Event *next = first->next;
- FreeEvent(first);
- first = next;
- }
- else
- {
- break;
- }
- }
- if (!first)
- return;
- Event *prev = first;
- Event *ptr = prev->next;
- while (ptr)
- {
- if (ptr->type == event_type)
- {
- prev->next = ptr->next;
- FreeEvent(ptr);
- ptr = prev->next;
- }
- else
- {
- prev = ptr;
- ptr = ptr->next;
- }
- }
+ if (!first)
+ return;
+ while (first)
+ {
+ if (first->type == event_type)
+ {
+ Event *next = first->next;
+ FreeEvent(first);
+ first = next;
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (!first)
+ return;
+ Event *prev = first;
+ Event *ptr = prev->next;
+ while (ptr)
+ {
+ if (ptr->type == event_type)
+ {
+ prev->next = ptr->next;
+ FreeEvent(ptr);
+ ptr = prev->next;
+ }
+ else
+ {
+ prev = ptr;
+ ptr = ptr->next;
+ }
+ }
}
void RemoveThreadsafeEvent(int event_type)
{
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- if (!tsFirst)
- {
- return;
- }
- while(tsFirst)
- {
- if (tsFirst->type == event_type)
- {
- Event *next = tsFirst->next;
- FreeTsEvent(tsFirst);
- tsFirst = next;
- }
- else
- {
- break;
- }
- }
- if (!tsFirst)
- {
- tsLast = NULL;
- return;
- }
- Event *prev = tsFirst;
- Event *ptr = prev->next;
- while (ptr)
- {
- if (ptr->type == event_type)
- {
- prev->next = ptr->next;
- if (ptr == tsLast)
- tsLast = prev;
- FreeTsEvent(ptr);
- ptr = prev->next;
- }
- else
- {
- prev = ptr;
- ptr = ptr->next;
- }
- }
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ if (!tsFirst)
+ {
+ return;
+ }
+ while (tsFirst)
+ {
+ if (tsFirst->type == event_type)
+ {
+ Event *next = tsFirst->next;
+ FreeTsEvent(tsFirst);
+ tsFirst = next;
+ }
+ else
+ {
+ break;
+ }
+ }
+ if (!tsFirst)
+ {
+ tsLast = NULL;
+ return;
+ }
+ Event *prev = tsFirst;
+ Event *ptr = prev->next;
+ while (ptr)
+ {
+ if (ptr->type == event_type)
+ {
+ prev->next = ptr->next;
+ if (ptr == tsLast)
+ tsLast = prev;
+ FreeTsEvent(ptr);
+ ptr = prev->next;
+ }
+ else
+ {
+ prev = ptr;
+ ptr = ptr->next;
+ }
+ }
}
void RemoveAllEvents(int event_type)
{
- RemoveThreadsafeEvent(event_type);
- RemoveEvent(event_type);
+ RemoveThreadsafeEvent(event_type);
+ RemoveEvent(event_type);
}
//This raise only the events required while the fifo is processing data
void ProcessFifoWaitEvents()
{
- while (first)
- {
- if (first->time <= globalTimer)
- {
-// LOG(TIMER, "[Scheduler] %s (%lld, %lld) ",
-// first->name ? first->name : "?", (u64)globalTimer, (u64)first->time);
- Event* evt = first;
- first = first->next;
- event_types[evt->type].callback(evt->userdata, (int)(globalTimer - evt->time));
- FreeEvent(evt);
- }
- else
- {
- break;
- }
- }
+ while (first)
+ {
+ if (first->time <= globalTimer)
+ {
+ // LOG(TIMER, "[Scheduler] %s (%lld, %lld) ",
+ // first->name ? first->name : "?", (u64)globalTimer, (u64)first->time);
+ Event* evt = first;
+ first = first->next;
+ event_types[evt->type].callback(evt->userdata, (int)(globalTimer - evt->time));
+ FreeEvent(evt);
+ }
+ else
+ {
+ break;
+ }
+ }
}
void MoveEvents()
{
- Common::AtomicStoreRelease(hasTsEvents, 0);
+ Common::AtomicStoreRelease(hasTsEvents, 0);
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- // Move events from async queue into main queue
- while (tsFirst)
- {
- Event *next = tsFirst->next;
- AddEventToQueue(tsFirst);
- tsFirst = next;
- }
- tsLast = NULL;
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ // Move events from async queue into main queue
+ while (tsFirst)
+ {
+ Event *next = tsFirst->next;
+ AddEventToQueue(tsFirst);
+ tsFirst = next;
+ }
+ tsLast = NULL;
- // Move free events to threadsafe pool
- while(allocatedTsEvents > 0 && eventPool)
- {
- Event *ev = eventPool;
- eventPool = ev->next;
- ev->next = eventTsPool;
- eventTsPool = ev;
- allocatedTsEvents--;
- }
+ // Move free events to threadsafe pool
+ while (allocatedTsEvents > 0 && eventPool)
+ {
+ Event *ev = eventPool;
+ eventPool = ev->next;
+ ev->next = eventTsPool;
+ eventTsPool = ev;
+ allocatedTsEvents--;
+ }
}
void Advance()
{
- ERROR_LOG(TIME, "Unimplemented function!");
- //int cyclesExecuted = slicelength - currentMIPS->downcount;
- //globalTimer += cyclesExecuted;
- //currentMIPS->downcount = slicelength;
+ ERROR_LOG(TIME, "Unimplemented function!");
+ //int cyclesExecuted = slicelength - currentMIPS->downcount;
+ //globalTimer += cyclesExecuted;
+ //currentMIPS->downcount = slicelength;
- //if (Common::AtomicLoadAcquire(hasTsEvents))
- // MoveEvents();
- //ProcessFifoWaitEvents();
+ //if (Common::AtomicLoadAcquire(hasTsEvents))
+ // MoveEvents();
+ //ProcessFifoWaitEvents();
- //if (!first)
- //{
- // // WARN_LOG(TIMER, "WARNING - no events in queue. Setting currentMIPS->downcount to 10000");
- // currentMIPS->downcount += 10000;
- //}
- //else
- //{
- // slicelength = (int)(first->time - globalTimer);
- // if (slicelength > MAX_SLICE_LENGTH)
- // slicelength = MAX_SLICE_LENGTH;
- // currentMIPS->downcount = slicelength;
- //}
- //if (advanceCallback)
- // advanceCallback(cyclesExecuted);
+ //if (!first)
+ //{
+ // // WARN_LOG(TIMER, "WARNING - no events in queue. Setting currentMIPS->downcount to 10000");
+ // currentMIPS->downcount += 10000;
+ //}
+ //else
+ //{
+ // slicelength = (int)(first->time - globalTimer);
+ // if (slicelength > MAX_SLICE_LENGTH)
+ // slicelength = MAX_SLICE_LENGTH;
+ // currentMIPS->downcount = slicelength;
+ //}
+ //if (advanceCallback)
+ // advanceCallback(cyclesExecuted);
}
void LogPendingEvents()
{
- Event *ptr = first;
- while (ptr)
- {
- //INFO_LOG(TIMER, "PENDING: Now: %lld Pending: %lld Type: %d", globalTimer, ptr->time, ptr->type);
- ptr = ptr->next;
- }
+ Event *ptr = first;
+ while (ptr)
+ {
+ //INFO_LOG(TIMER, "PENDING: Now: %lld Pending: %lld Type: %d", globalTimer, ptr->time, ptr->type);
+ ptr = ptr->next;
+ }
}
void Idle(int maxIdle)
{
- ERROR_LOG(TIME, "Unimplemented function!");
- //int cyclesDown = currentMIPS->downcount;
- //if (maxIdle != 0 && cyclesDown > maxIdle)
- // cyclesDown = maxIdle;
+ ERROR_LOG(TIME, "Unimplemented function!");
+ //int cyclesDown = currentMIPS->downcount;
+ //if (maxIdle != 0 && cyclesDown > maxIdle)
+ // cyclesDown = maxIdle;
- //if (first && cyclesDown > 0)
- //{
- // int cyclesExecuted = slicelength - currentMIPS->downcount;
- // int cyclesNextEvent = (int) (first->time - globalTimer);
+ //if (first && cyclesDown > 0)
+ //{
+ // int cyclesExecuted = slicelength - currentMIPS->downcount;
+ // int cyclesNextEvent = (int) (first->time - globalTimer);
- // if (cyclesNextEvent < cyclesExecuted + cyclesDown)
- // {
- // cyclesDown = cyclesNextEvent - cyclesExecuted;
- // // Now, now... no time machines, please.
- // if (cyclesDown < 0)
- // cyclesDown = 0;
- // }
- //}
+ // if (cyclesNextEvent < cyclesExecuted + cyclesDown)
+ // {
+ // cyclesDown = cyclesNextEvent - cyclesExecuted;
+ // // Now, now... no time machines, please.
+ // if (cyclesDown < 0)
+ // cyclesDown = 0;
+ // }
+ //}
- //INFO_LOG(TIME, "Idle for %i cycles! (%f ms)", cyclesDown, cyclesDown / (float)(g_clock_rate_arm11 * 0.001f));
+ //INFO_LOG(TIME, "Idle for %i cycles! (%f ms)", cyclesDown, cyclesDown / (float)(g_clock_rate_arm11 * 0.001f));
- //idledCycles += cyclesDown;
- //currentMIPS->downcount -= cyclesDown;
- //if (currentMIPS->downcount == 0)
- // currentMIPS->downcount = -1;
+ //idledCycles += cyclesDown;
+ //currentMIPS->downcount -= cyclesDown;
+ //if (currentMIPS->downcount == 0)
+ // currentMIPS->downcount = -1;
}
std::string GetScheduledEventsSummary()
{
- Event *ptr = first;
- std::string text = "Scheduled events\n";
- text.reserve(1000);
- while (ptr)
- {
- unsigned int t = ptr->type;
- if (t >= event_types.size())
- PanicAlert("Invalid event type"); // %i", t);
- const char *name = event_types[ptr->type].name;
- if (!name)
- name = "[unknown]";
- char temp[512];
- sprintf(temp, "%s : %i %08x%08x\n", name, (int)ptr->time, (u32)(ptr->userdata >> 32), (u32)(ptr->userdata));
- text += temp;
- ptr = ptr->next;
- }
- return text;
+ Event *ptr = first;
+ std::string text = "Scheduled events\n";
+ text.reserve(1000);
+ while (ptr)
+ {
+ unsigned int t = ptr->type;
+ if (t >= event_types.size())
+ PanicAlert("Invalid event type"); // %i", t);
+ const char *name = event_types[ptr->type].name;
+ if (!name)
+ name = "[unknown]";
+ char temp[512];
+ sprintf(temp, "%s : %i %08x%08x\n", name, (int)ptr->time, (u32)(ptr->userdata >> 32), (u32)(ptr->userdata));
+ text += temp;
+ ptr = ptr->next;
+ }
+ return text;
}
void Event_DoState(PointerWrap &p, BaseEvent *ev)
{
- p.Do(*ev);
+ p.Do(*ev);
}
void DoState(PointerWrap &p)
{
- std::lock_guard<std::recursive_mutex> lk(externalEventSection);
+ std::lock_guard<std::recursive_mutex> lk(externalEventSection);
- auto s = p.Section("CoreTiming", 1);
- if (!s)
- return;
+ auto s = p.Section("CoreTiming", 1);
+ if (!s)
+ return;
- int n = (int) event_types.size();
- p.Do(n);
- // These (should) be filled in later by the modules.
- event_types.resize(n, EventType(AntiCrashCallback, "INVALID EVENT"));
+ int n = (int)event_types.size();
+ p.Do(n);
+ // These (should) be filled in later by the modules.
+ event_types.resize(n, EventType(AntiCrashCallback, "INVALID EVENT"));
- p.DoLinkedList<BaseEvent, GetNewEvent, FreeEvent, Event_DoState>(first, (Event **) NULL);
- p.DoLinkedList<BaseEvent, GetNewTsEvent, FreeTsEvent, Event_DoState>(tsFirst, &tsLast);
+ p.DoLinkedList<BaseEvent, GetNewEvent, FreeEvent, Event_DoState>(first, (Event **)NULL);
+ p.DoLinkedList<BaseEvent, GetNewTsEvent, FreeTsEvent, Event_DoState>(tsFirst, &tsLast);
- p.Do(g_clock_rate_arm11);
- p.Do(slicelength);
- p.Do(globalTimer);
- p.Do(idledCycles);
+ p.Do(g_clock_rate_arm11);
+ p.Do(slicelength);
+ p.Do(globalTimer);
+ p.Do(idledCycles);
}
} // namespace
diff --git a/src/core/src/core_timing.h b/src/core/src/core_timing.h
index 1ef17f6f81..b62acea6c3 100644
--- a/src/core/src/core_timing.h
+++ b/src/core/src/core_timing.h
@@ -1,22 +1,8 @@
-// Copyright (c) 2012- PPSSPP Project / Dolphin Project.
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, version 2.0 or later versions.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License 2.0 for more details.
-
-// A copy of the GPL 2.0 should have been included with the program.
-// If not, see http://www.gnu.org/licenses/
-
-// Official git repository and contact information can be found at
-// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
-
-#ifndef CORE_CORE_TIMING_H_
-#define CORE_CORE_TIMING_H_
+#pragma once
// This is a system to schedule events into the emulated machine's future. Time is measured
// in main CPU clock cycles.
@@ -38,88 +24,86 @@ class PointerWrap;
extern int g_clock_rate_arm11;
inline s64 msToCycles(int ms) {
- return g_clock_rate_arm11 / 1000 * ms;
+ return g_clock_rate_arm11 / 1000 * ms;
}
inline s64 msToCycles(float ms) {
- return (s64)(g_clock_rate_arm11 * ms * (0.001f));
+ return (s64)(g_clock_rate_arm11 * ms * (0.001f));
}
inline s64 msToCycles(double ms) {
- return (s64)(g_clock_rate_arm11 * ms * (0.001));
+ return (s64)(g_clock_rate_arm11 * ms * (0.001));
}
inline s64 usToCycles(float us) {
- return (s64)(g_clock_rate_arm11 * us * (0.000001f));
+ return (s64)(g_clock_rate_arm11 * us * (0.000001f));
}
inline s64 usToCycles(int us) {
- return (g_clock_rate_arm11 / 1000000 * (s64)us);
+ return (g_clock_rate_arm11 / 1000000 * (s64)us);
}
inline s64 usToCycles(s64 us) {
- return (g_clock_rate_arm11 / 1000000 * us);
+ return (g_clock_rate_arm11 / 1000000 * us);
}
inline s64 usToCycles(u64 us) {
- return (s64)(g_clock_rate_arm11 / 1000000 * us);
+ return (s64)(g_clock_rate_arm11 / 1000000 * us);
}
inline s64 cyclesToUs(s64 cycles) {
- return cycles / (g_clock_rate_arm11 / 1000000);
+ return cycles / (g_clock_rate_arm11 / 1000000);
}
-namespace CoreTiming
-{
- void Init();
- void Shutdown();
+namespace CoreTiming {
- typedef void (*TimedCallback)(u64 userdata, int cyclesLate);
+void Init();
+void Shutdown();
- u64 GetTicks();
- u64 GetIdleTicks();
+typedef void(*TimedCallback)(u64 userdata, int cyclesLate);
- // Returns the event_type identifier.
- int RegisterEvent(const char *name, TimedCallback callback);
- // For save states.
- void RestoreRegisterEvent(int event_type, const char *name, TimedCallback callback);
- void UnregisterAllEvents();
+u64 GetTicks();
+u64 GetIdleTicks();
- // userdata MAY NOT CONTAIN POINTERS. userdata might get written and reloaded from disk,
- // when we implement state saves.
- void ScheduleEvent(s64 cyclesIntoFuture, int event_type, u64 userdata=0);
- void ScheduleEvent_Threadsafe(s64 cyclesIntoFuture, int event_type, u64 userdata=0);
- void ScheduleEvent_Threadsafe_Immediate(int event_type, u64 userdata=0);
- s64 UnscheduleEvent(int event_type, u64 userdata);
- s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata);
+// Returns the event_type identifier.
+int RegisterEvent(const char *name, TimedCallback callback);
+// For save states.
+void RestoreRegisterEvent(int event_type, const char *name, TimedCallback callback);
+void UnregisterAllEvents();
- void RemoveEvent(int event_type);
- void RemoveThreadsafeEvent(int event_type);
- void RemoveAllEvents(int event_type);
- bool IsScheduled(int event_type);
- void Advance();
- void MoveEvents();
- void ProcessFifoWaitEvents();
+// userdata MAY NOT CONTAIN POINTERS. userdata might get written and reloaded from disk,
+// when we implement state saves.
+void ScheduleEvent(s64 cyclesIntoFuture, int event_type, u64 userdata = 0);
+void ScheduleEvent_Threadsafe(s64 cyclesIntoFuture, int event_type, u64 userdata = 0);
+void ScheduleEvent_Threadsafe_Immediate(int event_type, u64 userdata = 0);
+s64 UnscheduleEvent(int event_type, u64 userdata);
+s64 UnscheduleThreadsafeEvent(int event_type, u64 userdata);
- // Pretend that the main CPU has executed enough cycles to reach the next event.
- void Idle(int maxIdle = 0);
+void RemoveEvent(int event_type);
+void RemoveThreadsafeEvent(int event_type);
+void RemoveAllEvents(int event_type);
+bool IsScheduled(int event_type);
+void Advance();
+void MoveEvents();
+void ProcessFifoWaitEvents();
- // Clear all pending events. This should ONLY be done on exit or state load.
- void ClearPendingEvents();
+// Pretend that the main CPU has executed enough cycles to reach the next event.
+void Idle(int maxIdle = 0);
- void LogPendingEvents();
+// Clear all pending events. This should ONLY be done on exit or state load.
+void ClearPendingEvents();
- // Warning: not included in save states.
- void RegisterAdvanceCallback(void (*callback)(int cyclesExecuted));
+void LogPendingEvents();
- std::string GetScheduledEventsSummary();
+// Warning: not included in save states.
+void RegisterAdvanceCallback(void(*callback)(int cyclesExecuted));
- void DoState(PointerWrap &p);
+std::string GetScheduledEventsSummary();
- void SetClockFrequencyMHz(int cpuMhz);
- int GetClockFrequencyMHz();
- extern int slicelength;
+void DoState(PointerWrap &p);
+
+void SetClockFrequencyMHz(int cpuMhz);
+int GetClockFrequencyMHz();
+extern int slicelength;
}; // namespace
-
-#endif // CORE_CORE_TIMING_H_