tree 446ce8f36cff43eef85b079dbd5b3cd2bca05599
parent 28cd3027c967dae642b24aedf80e3c6ceb306aa0
author Joerg Kubitz <jkubitz-eclipse@gmx.de> 1638543169 +0100
committer Andrey Loskutov <loskutov@gmx.de> 1644844027 -0500

Bug 576646 - JavaModel save: gzip'ed state.dat

Can be disabled with system property
 "org.eclipse.jdt.disable_gzip=false"

File size is typically reduced by factor ~ 4.
Makes read and write from RAM/Cache slower(read ~ 15%, write ~ 400%).
But its faster when reading from physical Disk (depends on Disk speed).

The zipped files can be opened by regular zip utils for inspection.

Change-Id: Iea47af88887871fc65b2b5b384f4bea3151f5cd2
Signed-off-by: Joerg Kubitz <jkubitz-eclipse@gmx.de>
Reviewed-on: https://git.eclipse.org/r/c/jdt/eclipse.jdt.core/+/188503
Tested-by: JDT Bot <jdt-bot@eclipse.org>
Tested-by: Andrey Loskutov <loskutov@gmx.de>
Reviewed-by: Sebastian Zarnekow <sebastian.zarnekow@gmail.com>
Reviewed-by: Andrey Loskutov <loskutov@gmx.de>
