1. 18 Dec, 2018 2 commits
  2. 17 Dec, 2018 13 commits
    • Ell's avatar
    • Ell's avatar
      buffer: fix race condition in GeglTileBackendSwap · c130b8be
      Ell authored
      ... when compressing a tile before pushing to the queue in one
      thread, while changing the swap compression algorithm in another
    • Ell's avatar
      configure.ac: verify zlib version · d0fa5a97
      Ell authored
      ... and whitespace foo in gegl-compression-zlib.c
    • Ell's avatar
      buffer: deprecate gegl_tile_backend_unlink_swap() · a4b93a37
      Ell authored
      ... in favor of gegl_buffer_swap_remove_file().
      Adapt GeglTileBackendFileAsync to the change.
      This should have been part of commit
    • Ell's avatar
      buffer: add gegl_buffer_swap_has_file() · 1597e17d
      Ell authored
      ... which checks if a given file is a swap file, that is, if it has
      been created with gegl_buffer_swap_create_file(), and hasn't been
      removed yet.
    • Ell's avatar
      gegl-stats: rename "{tile-cache,swap}-total-uncloned" to "-uncompressed" · 1ee31231
      Ell authored
      In GeglStats, rename the "swap-total-uncloned" property to "swap-
      total-uncompressed", since it now factors the space the swap would
      occupy without *any* form of compression: both block cloning, and
      tile-data compression.
      Rename "tile-cache-total-uncloned" to "tile-cache-total-
      uncompressed", for consistency, even though tile cloning is
      currently the only form of compression employed by the cache.
    • Ell's avatar
      buffer, gegl-config: compress tile data stored in the swap · 9a7738da
      Ell authored
      Use gegl-compression to compress tile data stored in the swap.
      This can both reduce the swap size, and improve its speed, by
      minimizing I/O.  Compression is normally performed by the writer
      thread, however, if the swap queue is full, and a thread attempting
      to store a tile has to block, the thread attempting the store
      compresses the tile before blocking, to minimize the tile cost in
      the queue, and to distribute compression over multiple threads,
      improving tile-store speed.  Decompression is always performed by
      the thread fetching the tile.
      Add a "swap-compression" property to GeglConfig (and a
      corresponding --gegl-swap-compression command-line option, and
      GEGL_SWAP_COMPRESSION environment variable), which specifies the
      compression algorithm to be used by the swap.  This property is set
      to "fast" by default.  Setting it to "none" disables compression
      (in contrast to "nop", which doesn't technically *disables*
      compression, but rather uses a NOP compression).
      Note that the "swap-compression" property can be changed during
      runtime, which affects the compression used for future tile stores
      (but doesn't affect existing stored tiles).  This can be used, for
      example, to select a better algorithm when running out of swap
    • Ell's avatar
      gegl-compression: add "fast", "balanced", and "best" aliases · 11fb76af
      Ell authored
      ... which alias concrete algorithms, based on availability,
      offerring a trade-off between speed and quality.
    • Ell's avatar
      gegl-compression: add zlib algorithms · ace1a79e
      Ell authored
      Add "zlib", and "zlib1" through "zlib9", compression algorithms,
      which use zlib's DEFLATE algorithm to compress the data.  The
      numeric suffix specifies the compression level, with higher levels
      being better, but slower; "zlib" uses the default compression
      These algorithms are only present when the zlib library is
    • Ell's avatar
      gegl-compression: add RLE algorithms · d87873cd
      Ell authored
      Add a set of RLE compression algorithms: "rle1", "rle2", "rle4",
      and "rle8".  The numeric suffix specifies the unit of compression,
      in bits -- the algorithms independently compress the respective
      units of each pixel.  That is, "rle1" RLE-compresses the first bit
      of each pixel, then the second bit of each pixel, and so on, while
      "rle8" RLE-compresses the first byte of each pixel, then the second
      byte of each pixel, and so on.  Smaller units yield better, but
      slower, compression.
    • Ell's avatar
      gegl-compression: add "nop" algorithm · 798cb4d6
      Ell authored
      A simple "compression" algorithm, which simply memcpy()s the data.
      Useful mostly for testing.
    • Ell's avatar
      buffer, tests, perf: add gegl-compression · f4b7ae53
      Ell authored
      gegl-compression is a simple compression framework, meant for
      (losslessly) compressing image data.  It exposes a set of
      compression algorithms, which can be used to compress/decompress
      data.  We're going to use gegl-compression to compress tile data
      stored in the swap.
      Add correctness and performance tests, which test all the available
    • Ell's avatar
      perf: fix convergence test; lower no. of iterations · cd5e2a1a
      Ell authored
      In test-common.h, fix the convergence test, which should allow us
      to lower the number of iterations without sacrificing too much
  3. 12 Dec, 2018 2 commits
  4. 11 Dec, 2018 3 commits
  5. 10 Dec, 2018 2 commits
  6. 09 Dec, 2018 5 commits
    • Ell's avatar
      buffer: over-trim cache when it fills up frequently · a64637b3
      Ell authored
      Trimming the tile cache can have a high overhead, since we need to
      scan the tile list for an eligible/worthwhile tile to trim.  If
      trimming happens frequently, we end up re-scanning the list each
      In order to amortize the cost of scanning the tile list, over-trim
      the cache by a certain amount, instead of only trimming the excess.
      When trimming happens frequently, we progressively increase the
      over-trimming ratio, up to 50% of the cache size limit.
    • Ell's avatar
      buffer: lower cost of cloned tiles queued for writing to the swap · af2c5ed3
      Ell authored
      In the swap tile backend, when calculating the cost of the tiles
      queued for writing, divide the tile size by the number of clones it
      has, so that if all clones of a given tile are queued for writing,
      their total cost (i.e., the amount of memory they consume) is equal
      to the size of a single tile.  This allows more cloned tiles to be
      queued for writing simultaneously, reducing the number of stalls.
    • Marco Ciampa's avatar
    • Marco Ciampa's avatar
      Fixed Italian filter description · 917cd332
      Marco Ciampa authored
    • Piotr Drąg's avatar
      Update Polish translation · 79906239
      Piotr Drąg authored
  7. 07 Dec, 2018 2 commits
  8. 06 Dec, 2018 1 commit
  9. 04 Dec, 2018 10 commits