The goal of this commit is to let people who experience driver issues
with libusb and windows disable the scanning thread (to avoid mouse
issues, keyboard issues, and audio issues).
Also disable the rumble setting when the adapter driver is not detected,
and don’t do anything if libusb can’t init for some reason.
fcmpo and fcmpu can be matched by the REORDER_CMP pass, as they set CR0
and they can cause interrupts if the fpu is disabled.
So we add an extra check to make sure op a is an integer op too.
The constructor sets up way_from_valid and way_from_plur as fast lookup
tables for implementing the PLRU algrothm. Then the Init function
memsets them to zero, meaning the instruction cache will now always
choose the first way in each set.
This degrades the cache from 128 sets, 8 way to 128 sets, 1 way.
Not only does fixing this bug increase accuracy, but it increases
preformance too, giving a 1% speedup to interpreter.
Instead of opening... and... closing... files... after... every...
file... operation... (which can be slow, especially if a virus scanner
is running), we catch attempts to open the same file twice and
only open one copy of the file.
I streamed this implementation earlier today to get people to have a feel for implementing instructions in the AArch64 recompiler.
This one was a fairly simple one to implement.
On the first boot of Pokemon Snap it copies a 144KB file to the Wii's
NAND, but it only copies 32 bytes per IPC write call.
This was causing dolphin to open and close the same file over 4000
times. This wouldn't usually be a huge issue, except some operating
systems (namely Windows) allow 3rd party programs (namely antivirus
software) to hook all accesses to the filesystem.
This causes the antivirus software to scan the same file for viruses
4000+ times, which is kind of slow.
This fix reduces the initial boot time of pokemon snap from 3+ min
to just a few seconds. Could also improve other games which write
things to NAND.
Will break a few things, see the next commit for an improved fix.
This is a bit indirect, but since homebrew always boots in a European environment the framerate depends on the bPAL60 flag, which is always auto turned off if bNTSC is set to true as of 2e5e724f94. By actually indicating that we're PAL on homebrew boot, the rest just falls into place.
NTSC GameCubes have no Language setting, so the language byte in SRAM is always 0. Some NTSC games do react oddly and display unfinished translations and similar when the byte is set to a nonzero value that corresponds to a non-English language on a PAL GameCube. See issue 7731: https://code.google.com/p/dolphin-emu/issues/detail?id=7731.
NaNs always propagate, so we can get away with only checking for NaN
inputs in the rare case that the result is NaN (as already done in
Jit64::HandleNaNs()).
Fixes block dots in THP videos.
Nintendo's THP video uses paired U8 stores to write their THP videos after decoding with floating point operations.
Paired stores clamp the range to the minimum and maximum values(0 - 255 in this case).
In some instances the resulting float will be larger than what a U8 can fit(Typically white) and results in black dots due to how AArch64 handles
quantizing.
The new implementation has 3 options:
SyncGpuMaxDistance
SyncGpuMinDistance
SyncGpuOverclock
The MaxDistance controlls how many CPU cycles the CPU is allowed to be in front
of the GPU. Too low values will slow down extremly, too high values are as
unsynchronized and half of the games will crash.
The -MinDistance (negative) set how many cycles the GPU is allowed to be in
front of the CPU. As we are used to emulate an infinitiv fast GPU, this may be
set to any high (negative) number.
The last parameter is to hack a faster (>1.0) or slower(<1.0) GPU. As we don't
emulate GPU timing very well (eg skip the timings of the pixel stage completely),
an overclock factor of ~0.5 is often much more accurate than 1.0
Should fix Issue 8209: Emulated Wiimote tilt is incorrect since 4.0-4543.
Original changes can be looked at the link below and discussion about the issue can be followed within Issue 8209 at googlecode.
http://pastebin.com/yKA2nuGp
Thanks to hk.konpie for the fix.
When AccurateNaNs is enabled, NaNs are handled accurately by checking
for NaN results and choosing the correct input NaN or replacing x86's
generated -QNaN with +QNaN.
This fixes a minor bug where the IPL thinks the SRAM has been corrupted and forces you to re-set date/time and settings when you change language in Config -> GameCube while not skipping the IPL on boot.
Note - I removed a SleepCurrentThread(1) the patch added which seemed to
be unrelated to the actual job at hand. If there was a real need for it
(which sounds like it would be an enet-related bug - enet_host_service
is supposed to *sleep*), that needs to be dealt with...
ISOFile and GameFile were using IsWiiDisc() and IsWadFile() to set
an enum value. The volume might as well return an enum directly.
I increased the Qt CACHE_REVISION because m_platform now is saved as u32
instead of int, but increasing the wx CACHE_REVISION is not necessary.
I tried to change messages that contained instructions for users,
while avoiding messages that are so technical that most users
wouldn't understand them even if they were in the right language.
Fixes a bug in lfs where I was doing a rev64.16b when I needed to do a rev32.8b.
Change a ld1r.4s to a ld1r.2s.
Fix an issue where a fcvtl2 needed to be a fcvtl.
Re-enabled psq_l, issue with flickering can't be reproduced anymore, so whatever.
This cleans up some of the code between core and UI for disassembling and dumping code blocks.
Should help the QT UI in bringing up its debug UI since it won't have to deal with this garbage now.
We already use ALT + ENTER for toggling fullscreen.
But as ENTER is both home and start, this buttons will always
also be triggered on toggling fullscreen. Now we check for
those buttons if ALT is not pressed.
So now we're able to toggle fullscreen without pressing home or start.
- Change the Wiimote emulation SYSCONF R/W to use the temporary NAND if in use.
- Fix up SysConf API so this actually works.
Kind of a hack. Like I said, this can be cleaned up when configuration
is synced...
Eventually, netplay will be able to use the host's NAND, but this could
still be useful in some cases; for TAS it definitely makes sense to have
a way to avoid using any preexisting NAND.
In terms of implementation: remove D_WIIUSER_IDX, which was just WIIROOT
+ "/", as well as some other indices which are pointless to have as
separate variables rather than just using the actual path (fixed, since
they're actual Wii NAND paths) at the call site. Then split off
D_SESSION_WIIROOT_IDX, which can point to the dummy NAND directory, from
D_WIIROOT_IDX, which always points to the "real" one the user
configured.
Specifically, things like GETHOSTBYNAME, GETHOSTID, etc. could be done
without creating a socket, which is what the old check blocked. Now we
check at the ioctl and ioctlv handlers. Might be possible to get a bit
more realistic behavior in future by filtering individual ioctls, but it
probably doesn't matter.
This includes net, which is nonsensical to "sync" in netplay/replays
(could have the host do the Wii networking in future though...), and USB
keyboard, which just needs some love to do the same.
- FileSearch is now just one function, and it converts the original glob
into a regex on all platforms rather than relying on native Windows
pattern matching on there and a complete hack elsewhere. It now
supports recursion out of the box rather than manually expanding
into a full list of directories in multiple call sites.
- This adds a GCC >= 4.9 dependency due to older versions having
outright broken <regex>. MSVC is fine with it.
- ScanDirectoryTree returns the parent entry rather than filling parts
of it in via reference. The count is now stored in the entry like it
was for subdirectories.
- .glsl file search is now done with DoFileSearch.
- IOCTLV_READ_DIR now uses ScanDirectoryTree directly and sorts the
results after replacements for better determinism.
We had to lock audiocommon with the old asynchron HLE audio emulation,
now our Mixer is just a plain FIFO which may underrun.
Of course, this will stutter, but underruning the audio backend is likely worse.
Until loadstores are fully investigated, let's artificially extend the life of it by disabling all of them.
These instructions break in a very terrible way and eventually all loadstores end up attempting to access memory region (u32)-1.
Disable until someone has enough time to investigate further.
This was a struct with exactly one element, and
an overloaded constructor which matches the construtor
of this element. So there is no need for this stacked
structur.
This is time based block profiling unlike the ARMv7 core.
I would like to add cycle counter based block profiling like the ARMv7 core, but it first requires writing a kernel module to enable the counters to userland applications
This is intended to better separate it from GetNames and to clarify
that this name originally wasn't meant to be shown to users.
The ISOProperties GUI is also updated, mainly because labeling
the long banner name "short name" was confusing.
This affects enabling and disabling block profiling on the fly.
The block profiling pauses the CPU cores and then flushes the JIT's block cache and enables block profile.
The issue with this is that when we pause the CPU core, we don't have a way to tell if the JIT recompiler has actually left.
So if the secondary thread that is clearing the JIT block cache is too quick, it will clear the cache as a recompiler is still running that block that
has been cleared.
Replaces them with forward declarations of used types, or removes them entirely if they aren't used at all. This also replaces certain Common headers with less inclusive ones (in terms of definitions they pull in).
This is available with the `GDBSocket` option in
`~/.dolphin-emu/Config/Dolphin.ini`.
GDB can connect to it with:
$ powerpc-eabi-gdb
(gdb) target remote |socat STDIO UNIX:foo.sock
Because I don't like so much binding the GDB stub socket to 0.0.0.0.
On Linux, with a suitable umask, we can make sure that another local
user cannot connect to the socket.
I'm not sure if Maker is the best name (Developer? Publisher?
Company? Copyright?) but I went with it because it's
what the game properties window uses. For the sake of
backwards compatibility, the INI option wasn't renamed.
This scanning thread either polls libusb or checks every 500ms for a
change depending on host capabilities. The GC Adapter can now be plugged
and unplugged at any time when dolphin is open, it will be used if the
direct connect option is set.
- CEXIETHERNET::SendComplete is always called from the main thread, so
drop the _Threadsafe.
- Mark the FIFO player thread as the "CPU thread" so it can call
ScheduleEvent without complaints. I haven't actually tested this,
since I don't know how to use the FIFO player; it might break
something.
PowerPC does exceptions and hardware and stuff, Memory doesn't.
I did not realize until a few minutes ago that there were two versions of these functions. This is why namespaces suck. Anyway, these were added by Mullin earlier this year.
They weren't sufficient and are made redundant by previous commits; they
also (on master) caused breakage due to Jit64::psq_stXX assuming writes
would be fastmem and not clobber a register under certain conditions.
That really needs to be refactored, but for now, this works.
Change TMemCheck::Action to return whether to break rather than calling
PPCDebugInterface::BreakNow, as this simplified the implementation; then
remove said method, as that was its only caller. One "interface" method
down, many to go...
Without fastmem, the JIT code still does an inline check for RAM
addresses. With watchpoints we have to disable that too. (Hardware
watchpoints would avoid all the slow, but be complicated to implement
and limited in number - I doubt most people debugging games care much if
they run slower.)
With this change and watchpoints enabled, Melee runs at no more than 40%
speed, despite running at full speed without them. Oh well. Better
works slowly than doesn't bloody work.
Incidentally, I'm getting an unrelated crash in
PowerPC::HostIsRAMAddress when shutting down a game. This code sucks.
- Move JitState::memcheck to JitOptions because it's an option.
- Add JitOptions::fastmem; switch JIT code to checking that rather than
bFastmem directly.
- Add JitBase::UpdateMemoryOptions(), which sets both two JIT options
(replacing the duplicate lines in Jit64 and JitIL that set memcheck
from bMMU).
- (!) The ARM JITs both had some lines that checked js.memcheck
despite it being uninitialized in their cases. I've added
UpdateMemoryOptions to both. There is a chance this could make
something slower compared to the old behavior if the uninitialized
value happened to be nonzero... hdkr should check this.
- UpdateMemoryOptions forces jo.fastmem and jo.memcheck off and on,
respectively, if there are any watchpoints set.
- Also call that function from ClearCache.
- Have MemChecks call ClearCache when the {first,last} watchpoint is
{added,removed}.
Enabling jo.memcheck (bah, confusing names) is currently pointless
because hitting a watchpoint does not interrupt the basic block. That
will change in the next commit.
All the multiplying and dividing by 100 in controller configs is
messy... An attempted solution to the problem was to not multiply
default_value by 100 in ControllerEmu::ControlGroup::LoadConfig,
but that broke other things instead, so I went with this.
This makes the code cleaner and also leads to some user-visible changes:
The wx game properties will no longer let the user
select WAD languages that don't have any names.
The Qt game list will now display names using the languages
set in the configuration instead of always using
English for PAL GC games and Japanese for WADs.
If a WAD doesn't have a name in the user's preferred language,
English is now selected as a fallback before Japanese.
Boot_BS2Emu was trying to read from the inserted disc even when
nothing was inserted, and this happened to not crash (but not
work either) before VolumeHandler was removed. This commit adds
a check that restores the old behavior, so there is no longer a
crash, but the game ID still doesn't get set for WADs. I don't
know if/how it should be set, so this felt like the safest option.
Core::Shutdown was only called on app exit, yet the emu thread exits
whenever emulation stops; if you launched a new game it would just join
via the destructor when s_emu_thread was set to a new thread.
(Incidentally, the destructor also makes explicitly joining on app exit
rather pointless.)
Because the GUI thread wasn't waiting for the CPU thread to fully shut
down, Core::IsRunning would remain true briefly after CFrame::DoStop
which, given Dolphin's penchant for accessing variables belonging to
other threads, can only mean trouble... In my case, because the previous
commit caused UpdateGUI, which is called at the end of DoStop, to call
PauseAndLock, which checks IsRunning, pressing stop at the right time
would cause strange behavior.
Since its lifetime is managed on the CPU thread, this (or a refactoring)
is absolutely required. One of the functions with a PauseAndLock call
added is CFrame::UpdateGUI; this is fine now, since it's called only
after important events happen, so just make sure not to call it every
frame or something :)
The regBuildMemAddress function already clears the address register.
Not only is clearing it again pointless, regBuildMemAddress uses the
bits in IInfo slightly diffrently and the second clear can clear
the wrong registers causing bugs if something else actually needs to
use those registers.
VolumeHandler is basically just a wrapper around a single IVolume object.
This change moves that object to DVDInterface, moves the Read32
function to IVolume, and gets rid of the rest of VolumeHandler.
The instant speed broke some games. SUDTR will now emulate
the transfer from the disc drive buffer to the main memory,
but not the speed of the disc drive itself.
With some specific, STUN-hostile routers, the netplay client can get
stuck forever while trying to connect to the stun server. This adds a
5 seconds (much more than should be necessary if it works) timer until
a failure is registered and the attempt stops.
Scott Mansell