You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
140 lines
5.0 KiB
140 lines
5.0 KiB
/*
|
|
* Copyright (c) 2005 Bart Coppens <kde@bartcoppens.be>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
#ifndef KIS_TILEMANAGER_H_
|
|
#define KIS_TILEMANAGER_H_
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <tqglobal.h>
|
|
#include <tqmap.h>
|
|
#include <tqvaluelist.h>
|
|
#include <tqmutex.h>
|
|
|
|
#include <tdetempfile.h>
|
|
|
|
class KisTile;
|
|
class KisTiledDataManager;
|
|
|
|
/**
|
|
* This class keeps has the intention to make certain tile-related operations faster or more
|
|
* efficient. It does this by keeping lots of info on KisTiles, and manages the way they are
|
|
* created, used, etc.
|
|
* It mainly does the following more visible things
|
|
* * provide a way to store tiles on disk to a swap file, to reduce memory usage
|
|
* * keep a list of previously swapped (but now unused) tiles, to reuse these when we want
|
|
* to swap new tiles.
|
|
* * tries to preallocate and recycle some tiles to make future allocations faster
|
|
* (not done yet)
|
|
*/
|
|
class KisTileManager {
|
|
public:
|
|
~KisTileManager();
|
|
static KisTileManager* instance();
|
|
|
|
public: // Tile management
|
|
void registerTile(KisTile* tile);
|
|
void deregisterTile(KisTile* tile);
|
|
// these can change the tile indirectly, though, through the actual swapping!
|
|
void ensureTileLoaded(const KisTile* tile);
|
|
void maySwapTile(const KisTile* tile);
|
|
|
|
public: // Pool management
|
|
TQ_UINT8* requestTileData(TQ_INT32 pixelSize);
|
|
void dontNeedTileData(TQ_UINT8* data, TQ_INT32 pixelSize);
|
|
|
|
public: // Configuration
|
|
void configChanged();
|
|
|
|
private:
|
|
KisTileManager();
|
|
KisTileManager(KisTileManager&) {}
|
|
KisTileManager operator=(const KisTileManager&);
|
|
|
|
private:
|
|
static KisTileManager *m_singleton;
|
|
|
|
// For use when any swap-allocating function failed; the risk of swap allocating failing
|
|
// again is too big, and we'd clutter the logs with kdWarnings otherwise
|
|
bool m_swapForbidden;
|
|
|
|
// This keeps track of open swap files, and their associated filesizes
|
|
struct TempFile {
|
|
KTempFile* tempFile;
|
|
off_t fileSize;
|
|
};
|
|
// validNode says if you can swap it (true) or not (false) mmapped, if this tile
|
|
// currently is memory mapped. If it is false, but onFile, it is on disk,
|
|
// but not mmapped, and should be mapped!
|
|
// filePos is the position inside the file; size is the actual size, fsize is the size
|
|
// being used in the swap for this tile (may be larger!)
|
|
// The file points to 0 if it is not swapped, and to the relevant TempFile otherwise
|
|
struct TileInfo { KisTile *tile; KTempFile* file; off_t filePos; int size; int fsize;
|
|
TQValueList<TileInfo*>::iterator node;
|
|
bool inMem; bool onFile; bool mmapped; bool validNode; };
|
|
typedef struct { KTempFile* file; off_t filePos; int size; } FreeInfo;
|
|
typedef TQMap<const KisTile*, TileInfo*> TileMap;
|
|
typedef TQValueList<TileInfo*> TileList;
|
|
typedef TQValueList<FreeInfo*> FreeList;
|
|
typedef TQValueVector<FreeList> FreeListList;
|
|
typedef TQValueList<TQ_UINT8*> PoolFreeList;
|
|
typedef TQValueList<TempFile> FileList;
|
|
|
|
|
|
TileMap m_tileMap;
|
|
TileList m_swappableList;
|
|
FreeListList m_freeLists;
|
|
FileList m_files;
|
|
TQ_INT32 m_maxInMem;
|
|
TQ_INT32 m_currentInMem;
|
|
TQ_UINT32 m_swappiness;
|
|
TQ_INT32 m_tileSize; // size of a tile if it used 1 byte per pixel
|
|
unsigned long m_bytesInMem;
|
|
unsigned long m_bytesTotal;
|
|
|
|
TQ_UINT8 **m_pools;
|
|
TQ_INT32 *m_poolPixelSizes;
|
|
TQ_INT32 m_tilesPerPool;
|
|
PoolFreeList *m_poolFreeList;
|
|
TQMutex * m_poolMutex;
|
|
TQMutex * m_swapMutex;
|
|
|
|
// This is the constant that we will use to see if we want to add a new tempfile
|
|
// We use 1<<30 (one gigabyte) because apparently 32bit systems don't really like very
|
|
// large files.
|
|
static const long MaxSwapFileSize = 1<<30; // For debugging purposes: 1<<20 is a megabyte
|
|
|
|
// debug
|
|
int counter;
|
|
|
|
private:
|
|
void fromSwap(TileInfo* info);
|
|
void toSwap(TileInfo* info);
|
|
void doSwapping();
|
|
void printInfo();
|
|
TQ_UINT8* findTileFor(TQ_INT32 pixelSize);
|
|
bool isPoolTile(TQ_UINT8* data, TQ_INT32 pixelSize);
|
|
void reclaimTileToPool(TQ_UINT8* data, TQ_INT32 pixelSize);
|
|
|
|
// Mmap wrapper that prints warnings on error. The result is stored in the *& result
|
|
// the return value is true on succes, false on failure. Other args as in man mmap
|
|
bool chalkMmap(TQ_UINT8*& result, void *start, size_t length,
|
|
int prot, int flags, int fd, off_t offset);
|
|
};
|
|
|
|
#endif // KIS_TILEMANAGER_H_
|