Like the symbols and the VM functions this is data that is static from startup until shutdown and has no need to be subjected to garbage collection. All things combined this reduces the amount of GC-sensitive objects at startup from 9600 to 600.
Symbols are very easy to manage once they are in a symbol table and there's lots of them so this reduces the amount of work the GC needs to do quite considerably.
After cleaning out compile-time-only symbols there will still be more than 2000 left, one for each function and one for each member variable of a class or struct.
This means more than 2000 object that won't need to tracked constantly by the garbage collector.
Note that loose fields which do occur during code generation will be GC'd just as before.
As it stood, just compiling the internal ZScript code created more than 9000 DObjects, none of which really need to be subjected to garbage collection, aside from allowing lazy deallocation.
This puts an incredible drag on the garbage collector which often needs several minutes to finish processing before actual deletion can start.
The VM functions with roughly 1800 of these objects were by far the easiest to refactor so they are now. They also use a memory arena now which significantly reduces their memory footprint.
If a later module reused an existing name for a different class or struct type, this new name would completely shadow the old one, even in the base files.
Changed it so that each compilation unit (i.e. each ZScript and DECORATE lump) get their own symbol table and can only see the symbol tables that got defined in lower numbered resource files so that later definitions do not pollute the available list of symbols when running the compiler backend and code generator - which happens after everything has been parsed.
Another effect of this is that a mod that reuses the name of an internal global constant will only see its own constant, again reducing the risk of potential errors in case the internal definitions add some new values.
Global constants are still discouraged from being used because what this does not and can not handle is the case that a mod defines a global constant with the same name as a class variable. In such a case the class variable will always take precedence for code inside that class.
Note that the internal struct String had to be renamed for this because the stricter checks did not let the type String pass on the left side of a '.' anymore.
- made PEnum inherit from PInt and not from PNamedType.
The old inheritance broke nearly every check for integer compatibility in the compiler, so this hopefully leads to a working enum implementation.
Needless to say, this is simply too volatile and would require constant active maintenance, not to mention a huge amount of work up front to get going.
It also hid a nasty problem with the Destroy method. Due to the way the garbage collector works, Destroy cannot be exposed to scripts as-is. It may be called from scripts but it may not be overridden from scripts because the garbage collector can call this function after all data needed for calling a scripted override has already been destroyed because if that data is also being collected there is no guarantee that proper order of destruction is observed. So for now Destroy is just a normal native method to scripted classes
- instead add a list of SpecialInits to VMScriptFunction so this can be done transparently when setting up and popping the stack frame. The only drawback is that this requires permanent allocation of stack objects for the entire lifetime of a function but this is a relatively small tradeoff for significantly reduced maintenance work throughout.
- removed most #include "vm.h", because nearly all files already pull this in through dobject.h.
* everything related to scripting is now placed in a subdirectory 'scripting', which itself is separated into DECORATE, ZSCRIPT, the VM and code generation.
* a few items have been moved to different headers so that the DECORATE parser definitions can mostly be kept local. The only exception at the moment is the flags interface on which 3 source files depend.
- The A_Jump family of action functions now return the state to jump
to (NULL if no jump is to be taken) instead of jumping directly.
It is the caller's responsibility to handle the jump. This will
make it possible to use their results in if statements and
do something other than jump.
- DECORATE return statements can now return the result of a function
(but not any random expression--it must be a function call). To
make a jump happen from inside a multi-action block, you must
return the value of an A_Jump function. e.g.:
{ return A_Jump(128, "SomeState"); }
- The VMFunction class now contains its prototype instead of storing
it at a higher level in PFunction. This is so that
FState::CallAction can easily tell if a function returns a state.
- Removed the FxTailable class because with explicit return
statements, it's not useful anymore.
This was to resolve some circular dependencies with the portal code.
The most notable changees:
* FTextureID was moved from textures.h to doomtype.h because it is frequently needed in files that don't want to do anything with actual textures.
* split off the parts from p_maputl into a separate header.
* consolidated all blockmap related data into p_blockmap.h
* split off the polyobject parts into po_man.h
* FInterpolator depended on external references to prevent its content from getting GC'd.
* none of the pointers in the interpolation objects were declared to the GC.
The result of these issues was that changing anything about the life cycle of interpolation objects caused corrupted memory crashes when a level was changed.
- The global symbol table was never marked by the GC, so anything pointed
only by it was fair game to disappear.
- Don't clear the global symbol table during DECORATE parsing. Junk in
there should be considered constant after initialization.
once in the level struct and then use that for sectors with a NULL skybox. This fixes zpack's
E2M3 so that when it removes its sector stacks, you will get the default skybox in their
place, since stacked sectors and skyboxes use the same pointers in a sector.
SVN r4224 (trunk)
actors with names that conflicted with preceding actors from being freed, even though they
can still be accessed via PClassActor::AllActorClasses, which gets iterated over in a number
of places. (e.g. Zen Dynamics defines a Grenade actor, although there is one in zdoom.pk3 now.
The Zen Dynamics' version would not go in the TypeTable, so it would be collected on map load,
leading to a crash when attempts to access it through AllActorClasses are made.)
SVN r3908 (scripting)
- fixed: D_ErrorCleanup must clear 'savegamerestore'.
- fixed: Cleaning up when loading a savegame failed while restoring the thinker list did not work. There were two issues:
* removed the asserts in GC::SweepList because they get triggered by thinkers that were not fully initialized during loading.
* AActor::UnlinkFromWorld may not assume that the sector list has been initialized when this function is called.
SVN r3274 (trunk)
instead of PClass::m_Types (now PClass::AllClasses).
- Removed ClassIndex from PClass. It was only needed by FArchive, and maps take care of the
problem just as well.
- Moved PClass into a larger type system (which is likely to change some/lots once I try and actually use it and have a better feel for what I need from it).
SVN r2281 (scripting)
- Derive PClass from dobject.cpp. This has one major ramification: Since the PClass
is not allocated until runtime, you cannot initialize any static/global data
structures with pointers to PClasses using RUNTIME_CLASS. Attempting to do so
will just initialize with a NULL pointer. Instead, you can initialize using
the address of the pointer returned by RUNTIME_CLASS and dereference that. By
the time you have an opportunity to dereference it, it will no longer be NULL.
- Sync CmakeLists.txt.
- Random fixes for problems GCC spotted.
SVN r1852 (scripting)
issues that caused its inclusion. Is an optimized GCC build any faster
for being able to use strict aliasing rules? I dunno. It's still slower
than a VC++ build.
I did run into two cases where TAutoSegIterator caused intractable problems
with breaking strict aliasing rules, so I removed the templating from it,
and the caller is now responsible for casting the probe value from void *.
- Removed #include "autosegs.h" from several files that did not need it
(in particular, dobject.h when not compiling with VC++).
SVN r1743 (trunk)
structure.
- Fixed: Items which should stay but had an IF_ALWAYSPICKUP flag were removed.
- Fixed: The pickup flash must only play when an item is picked up so the
correct place to spawn it is in AInventory::Touch, not in AInventory::GoAway.
SVN r1278 (trunk)
thinkers tick, not just once every game tick. This more closely follows
the original Lua behavior. This change was made because, in cases of
extremely large and frequent memory allocations, the collector may not run
fast enough if it only has a chance to execute once per tick.
SVN r1197 (trunk)
- Fixed: Before a level's thinkers are loaded all previous interpolations must
be cleared.
- Fixed: deleted interpolations didn't NULL the pointer in the interpolated
object. Also added all interpolation pointers to DSectorMarker to ensure
that they are properyl processed by the garbage collector.
SVN r1028 (trunk)
