#include <SwapFile.h>

Collaboration diagram for Kwave::SwapFile:

Public Member Functions
	SwapFile (const QString &name)

virtual	~SwapFile ()

bool	allocate (size_t size)

void *	address () const

size_t	size () const

int	mapCount () const

size_t	pagesize () const

bool	resize (size_t size)

void *	map ()

int	unmap ()

int	read (unsigned int offset, void *buffer, unsigned int length)

int	write (unsigned int offset, const void *buffer, unsigned int length)

Private Member Functions
void	close ()

Private Attributes
QTemporaryFile	m_file

void *	m_address

size_t	m_size

size_t	m_pagesize

int	m_map_count

Detailed Description

Definition at line 32 of file SwapFile.h.

Constructor & Destructor Documentation

◆ SwapFile()

Kwave::SwapFile::SwapFile ( const QString & name )

explicit

Constructor

Parameters

name	full path to the swap file, actually a template that must contain 6 "X" characters at the end!

Definition at line 37 of file SwapFile.cpp.

References g_instances, m_pagesize, and Kwave::toInt().

     :m_file(name), m_address(Q_NULLPTR), m_size(0), m_pagesize(0), m_map_count(0)
 {
     // determine the system's native page size
 #if defined(HAVE_GETPAGESIZE)
     if (!m_pagesize) m_pagesize = getpagesize();
 #endif
 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
     if (!m_pagesize) m_pagesize = sysconf(_SC_PAGESIZE);
 #endif
 
     // fallback: assume 4kB pagesize
     if (Kwave::toInt(m_pagesize) <= 0) {
         qWarning("SwapFile: unable to determine page size, using fallback");
         m_pagesize = (4 << 10);
     }
 
     g_instances++;
 }

Here is the call graph for this function:

◆ ~SwapFile()

Kwave::SwapFile::~SwapFile ( )

virtual

Destructor

Definition at line 58 of file SwapFile.cpp.

References close(), and g_instances.

 {
     close();
     g_instances--;
 }

Here is the call graph for this function:

Member Function Documentation

◆ address()

void* Kwave::SwapFile::address ( ) const

inline

Returns the address of the allocated memory or 0 if nothing has been allocated.

Definition at line 58 of file SwapFile.h.

References m_address.

Referenced by Kwave::MemoryManager::map(), and Kwave::MemoryManager::readFrom().

58 { return m_address; }

Kwave::SwapFile::m_address

void * m_address

Definition: SwapFile.h:129

Here is the caller graph for this function:

◆ allocate()

bool Kwave::SwapFile::allocate ( size_t size )

Allocates virtual memory by creating an empty swap file. Must be mapped into memory before used.

Parameters

size	number of bytes to allocate

Returns: true if succeeded, false if failed

Definition at line 65 of file SwapFile.cpp.

References close(), DBG, m_address, m_file, m_pagesize, m_size, size(), and Kwave::toUint().

Referenced by Kwave::MemoryManager::allocateVirtual().

 {
     Q_ASSERT(!m_address); // MUST NOT be mapped !
     if (m_address) return false;
 
     if (m_size) close();
 //     qDebug("SwapFile::allocate(%u), instances: %u",
 //            Kwave::toUint(size), g_instances);
 
     // try to create the temporary file
     if (!m_file.open()) {
         qWarning("SwapFile(%s) -> open failed", DBG(m_file.fileName()));
         return false;
     }
 
     // when it is created, also try to unlink it so that it will always
     // be removed, even if the application crashes !
 #ifdef HAVE_UNLINK
     unlink(m_file.fileName().toLocal8Bit().data());
 #endif /* HAVE_UNLINK */
 
     // round up the new size to a full page
     size_t rounded = Kwave::round_up<size_t>(size, m_pagesize);
 
     // touch each new page in order to *really* allocate the disk space
     size_t offset = 0;
     while (offset < rounded) {
         //      qDebug("SwapFile: touching at offset 0x%08X",
         //              Kwave::toUint(offset));
         m_file.seek(offset);
         m_file.putChar(0);
         m_file.flush();
         if (m_file.pos() != static_cast<qint64>(offset + 1)) {
             qWarning("SwapFile::allocate(): seek failed. DISK FULL !?");
             return false;
         }
         offset += m_pagesize;
     }
 
     m_file.seek(rounded - 1);
     m_file.putChar(0);
     m_file.flush();
     if (m_file.pos() + 1 < static_cast<qint64>(size)) {
         qWarning("SwapFile::allocate(%d MB) failed, DISK FULL ?",
                  Kwave::toUint(size >> 20));
         m_size = 0;
         return false;
     }
 
     // now the size is valid
     m_size = size;
 
 //  qDebug("SwapFile::allocate(%d kB)",size >> 10);
     return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close()

void Kwave::SwapFile::close ( )

private

Frees the allocated memory by unmapping and deleting the swap file.

Definition at line 187 of file SwapFile.cpp.

References DBG, m_address, m_file, m_map_count, and m_size.

Referenced by allocate(), pagesize(), resize(), and ~SwapFile().

 {
     Q_ASSERT(!m_map_count);
     if (m_address) m_file.unmap(static_cast<uchar *>(m_address));
     m_address = Q_NULLPTR;
     m_size = 0;
 
     m_file.resize(0);
     if (m_file.isOpen()) m_file.close();
 
     if (m_file.exists(m_file.fileName())) {
         if (!m_file.remove()) {
             qWarning("SwapFile(%s) -> remove FAILED", DBG(m_file.fileName()));
         }
     }
 
 }

Here is the caller graph for this function:

◆ map()

void * Kwave::SwapFile::map ( )

Map the memory and return the physical address.

Returns: pointer to the mapped area or null if failed

Definition at line 206 of file SwapFile.cpp.

References DBG, m_address, m_file, m_map_count, and m_size.

Referenced by Kwave::MemoryManager::map(), and pagesize().

 {
 //  qDebug("    SwapFile::map() - m_size=%u", m_size);
 
     // shortcut if already mapped
     if (m_map_count) {
         m_map_count++;
         Q_ASSERT(m_address);
         return m_address;
     }
 
     m_file.flush();
 
     m_address = m_file.map(0, m_size, QFile::NoOptions);
 
     // map -1 to null pointer
     if (m_address == reinterpret_cast<void *>(-1)) m_address = Q_NULLPTR;
 
     // if succeeded, increase map reference counter
     if (m_address) {
         m_map_count++;
     } else {
         qWarning("SwapFile(%s) -> map FAILED", DBG(m_file.fileName()));
     }
 
     return m_address;
 }

Here is the caller graph for this function:

◆ mapCount()

int Kwave::SwapFile::mapCount ( ) const

inline

returns the map count

Definition at line 67 of file SwapFile.h.

References m_map_count.

Referenced by Kwave::MemoryManager::free(), Kwave::MemoryManager::map(), Kwave::MemoryManager::readFrom(), Kwave::MemoryManager::unmap(), and Kwave::MemoryManager::unmapFromCache().

67 { return m_map_count; }

Kwave::SwapFile::m_map_count

int m_map_count

Definition: SwapFile.h:138

Here is the caller graph for this function:

◆ pagesize()

size_t Kwave::SwapFile::pagesize ( ) const

inline

Returns the size of one storage unit in bytes

Definition at line 72 of file SwapFile.h.

References close(), m_pagesize, map(), read(), resize(), unmap(), and write().

72 { return m_pagesize; }

Kwave::SwapFile::m_pagesize

size_t m_pagesize

Definition: SwapFile.h:135

Here is the call graph for this function:

◆ read()

int Kwave::SwapFile::read	(	unsigned int	offset,
		void *	buffer,
		unsigned int	length
	)

Read bytes into a buffer

Parameters

offset	offset within the file [bytes]
buffer	pointer to a buffer that is to be filled
length	number of bytes to read

Returns: number of read bytes or < 0 if failed

Definition at line 258 of file SwapFile.cpp.

References m_file, and Kwave::toInt().

Referenced by Kwave::MemoryManager::convertToPhysical(), pagesize(), and Kwave::MemoryManager::readFrom().

 {
     // seek to the given offset
     if (!m_file.seek(offset)) return -1;
 
     // read into the buffer
     if (!m_file.flush()) return -1;
 
     if (length > INT_MAX) length = INT_MAX;
     return Kwave::toInt(
         m_file.read(reinterpret_cast<char *>(buffer), length)
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ resize()

bool Kwave::SwapFile::resize ( size_t size )

Resizes the allocated swap file.

Parameters

size	the new size

Returns: true if successful or false if failed

Definition at line 122 of file SwapFile.cpp.

References BLOCK_SIZE, close(), m_address, m_file, m_map_count, m_pagesize, m_size, MINIMUM_SIZE, and size().

Referenced by pagesize(), and Kwave::MemoryManager::resize().

 {
     Q_ASSERT(!m_address); // MUST NOT be mappped !
     Q_ASSERT(!m_map_count);
     if (m_address || m_map_count) return false;
     if (size == m_size) return true; // nothing to do
 
     // special case: shutdown
     if (size == 0) {
         close();
         return true;
     }
 
     // this file seems to be a growing one:
     // round up the new size to a full block
     size_t rounded = Kwave::round_up<size_t>(size, BLOCK_SIZE);
 
     // optimization: if rounded size already matches -> done
     if (rounded == m_size) {
 //      qDebug("SwapFile::resize(%u MB) -> skipped, already big enough",
 //             Kwave::toUint(size >> 20));
         return true;
     }
 
     // do not shrink below minimum size
     if ((size < m_size) && (size < MINIMUM_SIZE)) {
 //      qDebug("SwapFile::resize(%u MB) -> skipped, limited by min size",
 //             Kwave::toUint(size >> 20));
         return true;
     }
 
     // resize the file
     //  qDebug("SwapFile::resize(%u)", size);
 
     // touch each new page in order to *really* allocate the disk space
     size_t offset = static_cast<size_t>((m_size + m_pagesize - 1) / m_pagesize);
     while (offset < rounded) {
 //      qDebug("SwapFile: touching at offset 0x%08X",
 //              Kwave::toUint(offset));
         m_file.seek(offset);
         m_file.putChar(0);
         m_file.flush();
         if (m_file.pos() != static_cast<qint64>(offset + 1)) {
             qWarning("SwapFile::resize(): seek failed. DISK FULL !?");
             return false;
         }
         offset += m_pagesize;
     }
 
     bool ok = true;
     ok &= m_file.resize(rounded);
     ok &= m_file.seek(rounded - 1);
     ok &= m_file.putChar(0);
     ok &= m_file.flush();
     if (ok) {
         m_size = rounded;
     } else {
         qWarning("SwapFile::resize(): failed. DISK FULL !?");
     }
 
 //  qDebug("SwapFile::resize() to size=%u", m_size);
     return ok;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

size_t Kwave::SwapFile::size ( ) const

inline

Returns the size of the allocated memory or 0 if nothing has been allocated.

Definition at line 64 of file SwapFile.h.

References m_size.

Referenced by allocate(), Kwave::MemoryManager::convertToPhysical(), Kwave::MemoryManager::free(), Kwave::MemoryManager::map(), Kwave::MemoryManager::resize(), resize(), Kwave::MemoryManager::sizeOf(), Kwave::MemoryManager::tryToMakePhysical(), Kwave::MemoryManager::unmap(), Kwave::MemoryManager::unmapFromCache(), and Kwave::MemoryManager::virtualUsed().

64 { return m_size; }

Kwave::SwapFile::m_size

size_t m_size

Definition: SwapFile.h:132

Here is the caller graph for this function:

◆ unmap()

int Kwave::SwapFile::unmap ( )

Unmap a memory area, previously mapped with map()

Returns: current reference count

Definition at line 235 of file SwapFile.cpp.

References DBG, m_address, m_file, m_map_count, and m_size.

Referenced by pagesize(), Kwave::MemoryManager::unmap(), and Kwave::MemoryManager::unmapFromCache().

 {
     Q_ASSERT(m_address);
     Q_ASSERT(m_size);
     Q_ASSERT(m_map_count);
 
     // first decrease refcount and do nothing if not zero
     if (!m_map_count) return 0;
     if (--m_map_count) return m_map_count;
 
     // really do the unmap
     if (m_size && m_address) {
 //      qDebug("      --- SwapFile::unmap() (%p)", this);
         if (!m_file.unmap(static_cast<uchar *>(m_address))) {
             qWarning("SwapFile(%s) -> unmap FAILED", DBG(m_file.fileName()));
         }
     }
 
     m_address = Q_NULLPTR;
     return m_map_count;
 }

Here is the caller graph for this function:

◆ write()

int Kwave::SwapFile::write	(	unsigned int	offset,
		const void *	buffer,
		unsigned int	length
	)

Write bytes from a buffer

Parameters

offset	offset within the file [bytes]
buffer	pointer to a buffer with data
length	number of bytes to write

Returns: number of written bytes or < 0 if failed

Definition at line 274 of file SwapFile.cpp.

References m_file, and Kwave::toInt().

Referenced by Kwave::MemoryManager::convertToVirtual(), pagesize(), and Kwave::MemoryManager::writeTo().

 {
     // seek to the given offset
     if (!m_file.seek(offset)) return -1;
 
     // write data from the buffer
     if (length > INT_MAX) length = INT_MAX;
     return Kwave::toInt(
         m_file.write(reinterpret_cast<const char *>(buffer), length)
     );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

◆ m_address

void* Kwave::SwapFile::m_address

private

address of the allocated virtual memory or 0

Definition at line 129 of file SwapFile.h.

Referenced by address(), allocate(), close(), map(), resize(), and unmap().

◆ m_file

QTemporaryFile Kwave::SwapFile::m_file

private

file used for swapping

Definition at line 126 of file SwapFile.h.

Referenced by allocate(), close(), map(), read(), resize(), unmap(), and write().

◆ m_map_count

int Kwave::SwapFile::m_map_count

private

reference count for mmap [0...N]

Definition at line 138 of file SwapFile.h.

Referenced by close(), map(), mapCount(), resize(), and unmap().

◆ m_pagesize

size_t Kwave::SwapFile::m_pagesize

private

size of one storage unit

Definition at line 135 of file SwapFile.h.

Referenced by allocate(), pagesize(), resize(), and SwapFile().

◆ m_size

size_t Kwave::SwapFile::m_size

private

number of allocated bytes or 0

Definition at line 132 of file SwapFile.h.

Referenced by allocate(), close(), map(), resize(), size(), and unmap().

The documentation for this class was generated from the following files:

libkwave/SwapFile.h
libkwave/SwapFile.cpp

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SwapFile()

◆ ~SwapFile()

Member Function Documentation

◆ address()

◆ allocate()

◆ close()

◆ map()

◆ mapCount()

◆ pagesize()

◆ read()

◆ resize()

◆ size()

◆ unmap()

◆ write()

Member Data Documentation

◆ m_address

◆ m_file

◆ m_map_count

◆ m_pagesize

◆ m_size