Performance

Now Wine has matured to the point of running many applications correctly, people are expecting them to run as fast as on Windows. Sadly, this is not always the case. Here are a few notes related to tracking down performance issues.

User Tips

If you're just trying to increase FPS in your games, you can experiment with the following short list of settings:

if the game has an opengl mode, try using that

else winetricks glsl=disable can improve Direct3D performance (but not for all games, and probably only if you have an nvidia card)

Performance-related bugs

Known Bottlenecks

applications that frequently compile d3d shaders may have low FPS; see e.g. http://bugs.winehq.org/show_bug.cgi?id=23832 ('winetricks glsl-disable' helps some games with this, as it avoids translating hlsl bytecodes into glsl and running them through the slow compiler. Only works on Nvidia, though.)

See WineD3DOnWindows for how to build WineD3D for Windows; this is cool because it lets you figure out if the bottleneck is in wined3d itself. You might also be able to use debugging nvidia or ati drivers on Windows that point out silly things wined3d is doing.

Graphic Remedy are making their OpenGL profiler/debugger gDEBugger, available at zero cost see here, GNU/Linux, Mac and Windows versions are available.

Game Performance Debugging Tutorial

First, the bad news: Often there is not a magic bullet to improve performance. It needs careful debugging and may be tricky to fix.

Note that "unlikely" below doesn't mean "impossible", neither does "likely" mean "always". Rules of thumb can be wrong, so some intuition, double-checking of assumptions and deviations from the guide are necessary.

1) Basic steps for debugging Direct3D performance problems:

Before digging too deep check a few common issues:

Keep your software up to date

Make sure you actually have a problem: Test the game on Windows on the same hardware. If it runs at the same speed there's probably nothing Wine can do to fix it. You're free to try though.

A few drivers are known to cause issues(Sept. 17th 2010): Mesa(all Open Source Linux drivers) and drivers for Intel GPUs on OSX.

Check for log messages. Sometimes Wine knows it hits a slow path and writes a FIXME or WARN. Don't fix too much on such warnings, they may indicate a comparatively minor problem.

Watch out for high wineserver CPU usage

Currently 80% of Windows performance is a high water mark, few games run faster. Many games run around 50%, which means there's a lot of room for improvement. If your game runs even slower there are probably some nasty bugs around.

2) GPU, CPU or bandwidth limited?

3D rendering is a complex process, and multiple components have to play together:

The bus must be fast enough to transfer data between the GPU and CPU without delays

Bus transfers are usually not an issue with Wine. If they are you can probably fix this by improving our GL_ARB_vertex_buffer or GL_ARB_pixel_buffer based code.

If your game slows down if you increase the screen resolution(or speeds up when you lower it) you are probably GPU limited. This is because the CPU rarely touches single pixels, so with increased resolution only the strain on the GPU increases. Exceptions may apply especially in older ddraw/d3d7 based games..

3a) GPU limited situation:

If you're GPU limited the problem could be inefficient shaders, or incorrectly configured render target formats. Try ARB shaders(if the game is happy with Shader Model 2.0 or you have a Nvidia GPU), and check logs for usage of 16 bit per channel or floating point render targets.

Unless you have a low end GPU or play at a very high resolution GPU limitations are rare. A seeming GPU limitation may also be a sign of a software rendering fallback in the fragment pipeline.

3b) CPU limitation

Most performance issues on Mid-End or High-End systems are CPU side bottlenecks. The problem can be in pretty much every component involved in running the game:

The Linux Kernel

The X server

The 3D parts of Wine

The non-3D parts of Wine

The 3D driver

It is tricky to tell those apart. A useful first test is comparing the following 3 metrics:

The performance on a normal Windows system

The performance on Windows while running the game with wined3d[insert link here]

The performance on Linux/OSX with Wine

If you are on OSX: The performance with Wine+OSX.

If there is a noticeable difference between (1) and (2) the problem is likely in the 3D related parts(wined3d, OpenGL driver). That's because all the other components haven't been changed. If there is a noticeable difference between (2) and (3) the problem is either in the non-3D parts(Rest of Wine, Linux kernel, ...). Make sure the game runs in the same codepath in all 4(or 3) cases - some games can use both d3d9 and d3d10 for example.

A difference between (2) and (3) may also indicate a problem in the Linux 3D driver that does not occur on Windows. If you are using AMD's or Nvidia's binary drivers this is unlikely because the Windows and Linux drivers share a pretty big common core. On OSX there is less code sharing, so if you're debugging performance issues on OSX the difference between (3) and (4) can matter.

4) Oprofile

Now that you have a rough idea if you're looking for issues in 3D or non 3D parts it's time to separate modules further. Oprofile or other profilers can help here.

Case A): 3D related problems:

The main question is if the GPU time is spent in wined3d.dll or the driver. If more than 5% CPU time are spent in wined3d this is suspicious. If a lot of CPU time is spent in the driver libraries(> 30% if you need some threshold) it may indicate a bug in the driver itself, or inefficient GL calls made by wined3d. With binary drivers the difference doesn't matter much since you can't change the driver anyway.

Case B): Non 3D related problems:

Usual suspects are ntdll.dll, kernel32.dll, wineserver, various C/C++ runtime libraries, the Linux kernel. You may be able to use the native version of the library in Wine. If that fixes your issues you know where to fix it in Wine. Again note that a high CPU usage in the Linux kernel or in low level Wine libs may be caused by inefficient calls to that library from a higher level, so be careful before taking out the pitchforks.

5) Telling wined3d problems from driver problems

Telling those apart is not easy. A driver may not support OpenGL extensions used for speedups, causing high CPU usage in wined3d(e.g. GL_ARB_vertex_buffer_object, GL_ARB_vertey_array_bgra). WineD3D may make inefficient calls causing high CPU usage in the driver.

A rule of thumb way is to try a different GPU/driver. If a game is slow on Nvidia GPUs(compared to Windows) and fast on AMD GPUs(compared to Windows on the same card) then the problem may be in the driver. If you have a binary driver you may as well just assume that the problem is in wined3d since otherwise you're mostly out of luck anyway.

If you isolate a problem in the driver don't forget to report it to the driver vendor.

6) Other hints:

GPU vendors offer various performance debugging tools. Those can be helpful for debugging GPU or bandwidth limitations. They're usually focused on Windows, so you're probably better off by debugging wined3d on windows

OSX has some nice tools too, specifically the OpenGL profiler and the Driver Monitor. If you have OSX available it may give you some helpful hints even if you are mainly focusing on fixing a performance bug on Linux.

Windows has helpful tools as well, for example VsPerfMon (Kinda like oprofile). To use those you may have to compile wined3d with Visual Studio to get Microsoft-Style debug symbols.

Don't hesitate to contact wine-devel for help.

Do your homework before contacting driver developers or other projects. Installing Wine and a Windows Game means a lot of work for non-Wine people, so make sure you're not wasting their time.