Am Montag 18 Dezember 2006 19:25 schrieb Stefan Dösinger: Another issue I stumbled uppon: This patch moves the + 1 for the array declaration to the right place.
> Am Montag 18 Dezember 2006 14:06 schrieb Stefan Dösinger: > Another update, it fixes an spotted by Henri issue where the state was used > instead of the representative and uses shifting and bitmasks to calculate > the index and shift for the bitmap. > > > This is another updated version, it uses bitmaps for the isStateDirty > > member. > > > > Am Sonntag 17 Dezember 2006 14:45 schrieb Stefan Dösinger: > > > Am Freitag 15 Dezember 2006 18:31 schrieb Stefan Dösinger: > > > > This patch adds the dirty list infrastructure. A dirty marker > > > > consists of a DWORD containing the state it marks dirty, and the list > > > > structure to build the list. > > > > > > > > The wined3ddevice has 3 new members: > > > > dirtyStateList: The list of dirty states. This will be moved to a > > > > per-context stucture once we add multithreading support > > > > freeListElems: A list containing unused dirty markers to avoid > > > > unnecessary HeapAlloc/HeapFree calls. I have seen D3D games spending > > > > 15% cpu time in the Heap code, we don't want to increase that. > > > > dirtyStates: An array that tells if a state is dirty. It is used to > > > > avoid double dirtification. I do not use the > > > > stateblock->changed.XXXX[] array because this is used for different > > > > purposes in the stateblock code. Ivan, do we still need it? > > > > > > Attached is an updated patch that uses an array for dirtification > > > instead of a list. Actually there are 2 arrays, one to quickly find out > > > if a specific state is dirty, and one to quickly find all dirty states. > > > > > > Checking if a state is dirty is done very often, so we need the > > > isStateDirty. A linear search on the dirtyArray would take way too much > > > time. On the other hand, my experiance so far shows that usually not > > > more than 10-20 states are dirty at the beginning of a drawprim call, > > > so iterating over all states would be a waste of time too. That's why > > > the dirtyArray is there. > > > > > > In the end there will be around 1000 states, so the size of those > > > arrays will be 8-10 kilobytes. Even oldest games load textures in the > > > area of megabytes, with recent games it's about gigabytes, so I don't > > > think those 10 kb's are an issue :-) . I could easilly change the > > > DWORDs to shorts, but all d3d states are defined as DWORDs, so I > > > decided to use DWORDS. > > > > > > If I used a bitmap I could squeeze the same information in about 128 > > > bytes + extra size for the code dealing with the bitmap + extra runtime > > > needs for bit shifting and checking all DWORDs in the bitmap. D3D games > > > are usually cpu limited, so I prefer the more memory intensive version. > > > > > > The other patches should apply cleanly over this patch, so I do not > > > resend them.
From e0b86ee56d5e91feaff5384ed5231f2b419fd8b3 Mon Sep 17 00:00:00 2001 From: Stefan Doesinger <[EMAIL PROTECTED]> Date: Mon, 18 Dec 2006 20:18:54 +0100 Subject: [PATCH] WineD3D: Add state dirtification infrastructure --- dlls/wined3d/device.c | 13 +++++++++++++ dlls/wined3d/drawprim.c | 12 ++++++++++++ dlls/wined3d/wined3d_private.h | 20 ++++++++++++++++++++ 3 files changed, 45 insertions(+), 0 deletions(-) diff --git a/dlls/wined3d/device.c b/dlls/wined3d/device.c index 685cdf9..217f666 100644 --- a/dlls/wined3d/device.c +++ b/dlls/wined3d/device.c @@ -7084,3 +7084,16 @@ const DWORD SavedVertexStates_T[NUM_SAVE const DWORD SavedVertexStates_S[NUM_SAVEDVERTEXSTATES_S] = { WINED3DSAMP_DMAPOFFSET }; + +void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state) { + DWORD rep = StateTable[state].representative; + DWORD idx; + BYTE shift; + + if(!rep || isStateDirty(This, rep)) return; + + This->dirtyArray[This->numDirtyEntries++] = rep; + idx = rep >> 5; + shift = rep & 0x1f; + This->isStateDirty[idx] |= (1 << shift); +} diff --git a/dlls/wined3d/drawprim.c b/dlls/wined3d/drawprim.c index a560084..06a86ae 100644 --- a/dlls/wined3d/drawprim.c +++ b/dlls/wined3d/drawprim.c @@ -2129,6 +2129,8 @@ void drawPrimitive(IWineD3DDevice *iface IWineD3DSwapChainImpl *swapchain; int i; BOOL fixup = FALSE; + DWORD dirtyState, idx; + BYTE shift; BOOL lighting_changed, lighting_original = FALSE; @@ -2163,6 +2165,16 @@ void drawPrimitive(IWineD3DDevice *iface /* Ok, we will be updating the screen from here onwards so grab the lock */ ENTER_GL(); + /* Apply dirty states */ + for(i=0; i < This->numDirtyEntries; i++) { + dirtyState = This->dirtyArray[i]; + idx = dirtyState >> 5; + shift = dirtyState & 0x1f; + This->isStateDirty[idx] &= ~(1 << shift); + StateTable[dirtyState].apply(dirtyState, This->stateBlock); + } + This->numDirtyEntries = 0; /* This makes the whole list clean */ + if(DrawPrimStrideData) { /* Note: this is a ddraw fixed-function code path */ diff --git a/dlls/wined3d/wined3d_private.h b/dlls/wined3d/wined3d_private.h index da3fbe9..e01a529 100644 --- a/dlls/wined3d/wined3d_private.h +++ b/dlls/wined3d/wined3d_private.h @@ -413,6 +413,8 @@ typedef void (*APPLYSTATEFUNC)(DWORD sta #define STATE_RENDER(a) (a) #define STATE_IS_RENDER(a) ((a) >= STATE_RENDER(1) && (a) <= STATE_RENDER(WINEHIGHEST_RENDER_STATE)) +#define STATE_HIGHEST (STATE_RENDER(WINEHIGHEST_RENDER_STATE)) + struct StateEntry { DWORD representative; @@ -627,10 +629,28 @@ #define NEEDS_DI /* Final position fixup constant */ float posFixup[4]; + + /* State dirtification + * dirtyArray is an array that contains markers for dirty states. numDirtyEntries states are dirty, their numbers are in indices + * 0...numDirtyEntries - 1. isStateDirty is a redundant copy of the dirtyArray. Technically only one of them would be needed, + * but with the help of both it is easy to find out if a state is dirty(just check the array index), and for applying dirty states + * only numDirtyEntries array elements have to be checked, not STATE_HIGHEST states. + */ + DWORD dirtyArray[STATE_HIGHEST + 1]; /* Won't get bigger than that, a state is never marked dirty 2 times */ + DWORD numDirtyEntries; + DWORD isStateDirty[(STATE_HIGHEST) / (sizeof(DWORD) * 8) + 1]; /* Bitmap to find out quickly if a state is dirty */ + } IWineD3DDeviceImpl; extern const IWineD3DDeviceVtbl IWineD3DDevice_Vtbl; +void IWineD3DDeviceImpl_MarkStateDirty(IWineD3DDeviceImpl *This, DWORD state); +static inline BOOL isStateDirty(IWineD3DDeviceImpl *This, DWORD state) { + DWORD idx = state >> 5; + BYTE shift = state & 0x1f; + return This->isStateDirty[idx] & (1 << shift); +} + /* Support for IWineD3DResource ::Set/Get/FreePrivateData. I don't think * anybody uses it for much so a good implementation is optional. */ typedef struct PrivateData -- 1.4.2.4