//------------------------------------------------------------------------------------
// DSt_cube<T>::datac - get
//
// Description - Does required file cache stuff to obtain location z,y,x
// Note: should never be called when CACHE_DISABLED
//------------------------------------------------------------------------------------
template <class T>
T DSt_cube<T>::dataCache( unsigned short z, unsigned short y, unsigned short x )
{
// Check what kind of caching is used
switch( cache_state )
{
case CACHE_FULL_SLICE:
// See if desired slice is in cache
if ( cache_validity_table[z][0][0] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][0][0]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
return oldest_seg_ptr->item.data[y][x];
#else
// It is a cache hit, return data
return cache_validity_table[z][0][0]->data[y][x];
#endif
}
break;
case CACHE_FULL_ROW:
// See if desired row is in cache
if ( cache_validity_table[z][y][0] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][y][0]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
return oldest_seg_ptr->item.data[0][x];
#else
// It is a cache hit, return data
return cache_validity_table[z][y][0]->data[0][x];
#endif
}
break;
case CACHE_SUB_ROW:
// See if desired row is in cache
if ( cache_validity_table[z][y][x>>cache_sub_row_shift_val] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][y][x>>cache_sub_row_shift_val]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
return oldest_seg_ptr->item.data[0][(~(0xFFFF<<cache_sub_row_shift_val)) & x];
#else
// It is a cache hit, return data
return cache_validity_table[z][y][x>>cache_sub_row_shift_val]->data[0][(~(0xFFFF<<cache_sub_row_shift_val)) & x];
#endif
}
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::Cached Get - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
// We have had a Cache miss.
// Need to read in correct data range into cache RAM
readIntoCache( z, y, x );
// Now we are guaranteed a hit, call again and return valid data
return dataCache(z, y, x);
};
//------------------------------------------------------------------------------------
// DSt_cube<T>::datac - set
//
// Description - Does required file cache stuff to write to location z,y,x
// Note: should never be called when CACHE_DISABLED
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::dataCache( unsigned short z, unsigned short y, unsigned short x, T new_value )
{
// Check what kind of caching is used
switch( cache_state )
{
case CACHE_FULL_SLICE:
// See if desired slice is in cache
if ( cache_validity_table[z][0][0] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][0][0]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
oldest_seg_ptr->item.data[y][x] = new_value;
oldest_seg_ptr->item.needs_sync = true;
#else
// It is a cache hit, set data and and sync needed status
cache_validity_table[z][0][0]->data[y][x] = new_value;
cache_validity_table[z][0][0]->needs_sync = true;
#endif
return;
}
break;
case CACHE_FULL_ROW:
// See if desired row is in cache
if ( cache_validity_table[z][y][0] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][y][0]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
oldest_seg_ptr->item.data[0][x] = new_value;
oldest_seg_ptr->item.needs_sync = true;
#else
// It is a cache hit, set data and and sync needed status
cache_validity_table[z][y][0]->data[0][x] = new_value;
cache_validity_table[z][y][0]->needs_sync = true;
#endif
return;
}
break;
case CACHE_SUB_ROW:
// See if desired row is in cache
if ( cache_validity_table[z][y][x>>cache_sub_row_shift_val] != NULL )
{
#if CACHING_USE_LINKED_LIST
// Move to head of linked list
oldest_seg_ptr = cache_validity_table[z][y][x>>cache_sub_row_shift_val]->queue_node_ptr;
cache_age_queue->unlinkNode( oldest_seg_ptr );
cache_age_queue->insertAtStart( oldest_seg_ptr );
oldest_seg_ptr->item.data[0][(~(0xFFFF<<cache_sub_row_shift_val)) & x] = new_value;
oldest_seg_ptr->item.needs_sync = true;
#else
// It is a cache hit, set data and and sync needed status
cache_validity_table[z][y][x>>cache_sub_row_shift_val]->data[0][(~(0xFFFF<<cache_sub_row_shift_val)) & x] = new_value;
cache_validity_table[z][y][x>>cache_sub_row_shift_val]->needs_sync = true;
#endif
return;
}
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::Cached Set - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
// We have had a Cache miss.
// Need to read in correct data range into cache RAM
readIntoCache( z, y, x );
// Now we are guaranteed a hit, call again and set to desired data
dataCache(z, y, x, new_value);
}
//------------------------------------------------------------------------------------
// DSt_cube<T>::invalidateValidityTable
//
// Description - Invalidates OLDEST cache location in ValidityTable
//------------------------------------------------------------------------------------
#if CACHING_USE_LINKED_LIST
template <class T>
void DSt_cube<T>::invalidateOldestInValidityTable( )
{
switch( cache_state )
{
case CACHE_FULL_SLICE:
// Invalidate the cache info in table
cache_validity_table[ oldest_seg_ptr->item.z ][ 0 ][ 0 ] = NULL;
break;
case CACHE_FULL_ROW:
// Invalidate the cache info in table
cache_validity_table[ oldest_seg_ptr->item.z ][ oldest_seg_ptr->item.y ][ 0 ] = NULL;
break;
case CACHE_SUB_ROW:
// Invalidate the cache info in table
cache_validity_table[ oldest_seg_ptr->item.z ] \
[ oldest_seg_ptr->item.y ] \
[ oldest_seg_ptr->item.x >> cache_sub_row_shift_val ] = NULL;
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::invalidateValidityTable - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
}
#else
template <class T>
void DSt_cube<T>::invalidateOldestInValidityTable( )
{
switch( cache_state )
{
case CACHE_FULL_SLICE:
// Invalidate the cache info in table
cache_validity_table[ cache_age_list[cache_oldest_indx].z ][ 0 ][ 0 ] = NULL;
break;
case CACHE_FULL_ROW:
// Invalidate the cache info in table
cache_validity_table[ cache_age_list[cache_oldest_indx].z ][ cache_age_list[cache_oldest_indx].y ][ 0 ] = NULL;
break;
case CACHE_SUB_ROW:
// Invalidate the cache info in table
cache_validity_table[ cache_age_list[cache_oldest_indx].z ] \
[ cache_age_list[cache_oldest_indx].y ] \
[ cache_age_list[cache_oldest_indx].x >> cache_sub_row_shift_val ] = NULL;
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::invalidateValidityTable - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
}
#endif
//------------------------------------------------------------------------------------
// DSt_cube<T>::obtainFreeCache
// Description - Makes available new cache in an unknown state.
// Writes out current RAM cache contents to file cache if needed.
//
// In link list mode: oldest_seg_ptr will contain new segment after call
// In array mode: cache_available_indx is new segement after call
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::obtainFreeCache( )
{
// See if we can get away with obtaining a cache entry without disc access.
#if CACHING_USE_LINKED_LIST
oldest_seg_ptr = cache_age_queue->getAndUnlinkTailNode();
// Insert the segment at head of queue (making it 'newest')
cache_age_queue->insertAtStart( oldest_seg_ptr );
// Only need to write out to disc if the following is true:
// 1) Oldest segement needs sync
if ( oldest_seg_ptr->item.needs_sync == false )
{
// Do not invalidate if we have not filled up cache yet
if ( cache_available_indx == cache_number_of_entries )
{
invalidateOldestInValidityTable();
}
else
{
++ cache_available_indx;
}
return;
}
#else
// Only need disc access if both of the following are true:
// 1) Cache is full. This happens when cache_available_indx+1 == cache_oldest_indx.
// 2) Oldest row in cache was written to and needs to be sync'ed
if ( !( (((cache_available_indx+1)%cache_number_of_entries) == cache_oldest_indx ) &&
( cache_age_list[cache_oldest_indx].needs_sync == true ) ) )
{
// We do not need disc acess, update cache available index to free one
cache_available_indx = (cache_available_indx+1) % cache_number_of_entries;
// If we are replacing an old used cache that didn't need a sync, invalidate cache info in table
if ( cache_is_full )
{
invalidateOldestInValidityTable();
}
// Once cache is full, we need to increment oldest index by 1 each time also
if ( cache_available_indx == cache_oldest_indx )
{
cache_oldest_indx = (cache_oldest_indx+1) % cache_number_of_entries;
cache_is_full = true;
}
return;
}
#endif
// Looks like we need to free up a cache entry, first write out to disc oldest one.
LARGE_INTEGER start_offset_bytes;
DWORD bytes_written, bytes_to_write = sizeof(T) * cache_entry_size;
// This is disc seek offset to desired slice in file
#if CACHING_USE_LINKED_LIST
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T) * wX * wY * oldest_seg_ptr->item.z;
unsigned short x = oldest_seg_ptr->item.x;
unsigned short y = oldest_seg_ptr->item.y;
#else
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T) * wX * wY * cache_age_list[cache_oldest_indx].z;
unsigned short x = cache_age_list[cache_oldest_indx].x;
unsigned short y = cache_age_list[cache_oldest_indx].y;
#endif
// Set cache type specific details
switch( cache_state )
{
case CACHE_FULL_SLICE: // Nothing to do
break;
case CACHE_FULL_ROW:
// Need to offset row number as well
start_offset_bytes.QuadPart = start_offset_bytes.QuadPart + sizeof(T) * y * wX;
break;
case CACHE_SUB_ROW:
if ( cache_sub_row_last_seg_indx == (x>>cache_sub_row_shift_val) )
{ // If we are in last segment of row, might be different size than normal
bytes_to_write = sizeof(T) * cache_sub_row_last_entry_size;
}
// Need to offset row and sub row number as well
start_offset_bytes.QuadPart = start_offset_bytes.QuadPart + sizeof(T)*
( y * wX + (x>>cache_sub_row_shift_val) * cache_entry_size );
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::obtainFreeCache - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
// Write out oldest row to cache file
SetFilePointerEx( cache_file, start_offset_bytes, NULL, FILE_BEGIN );
#if CACHING_USE_LINKED_LIST
WriteFile( cache_file, oldest_seg_ptr->item.data[0], bytes_to_write, &bytes_written, NULL );
// Invalidate the cache info in table
invalidateOldestInValidityTable();
// Mark newly available entry as not yet needing a sync back to disc
oldest_seg_ptr->item.needs_sync = false;
#else
WriteFile( cache_file, cache_age_list[cache_oldest_indx].data[0], bytes_to_write, &bytes_written, NULL );
// Invalidate the cache info in table
invalidateOldestInValidityTable();
// Mark newly available entry as not yet needing a sync back to disc
cache_age_list[cache_oldest_indx].needs_sync = false;
// Update cache info array indexes
cache_oldest_indx = (cache_oldest_indx+1) % cache_number_of_entries;
cache_available_indx = (cache_available_indx+1) % cache_number_of_entries;
#endif
}
//------------------------------------------------------------------------------------
// DSt_cube<T>::readIntoCache
// Description - Transfers into RAM cache desired location from file cache. Should
// only be called on a cache miss.
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::readIntoCache( unsigned short z, unsigned short y, unsigned short x )
{
// First we need to get a free cache memory block
obtainFreeCache ();
// Update cache info (z is universal, others cache type specific)
#if CACHING_USE_LINKED_LIST
oldest_seg_ptr->item.z = z;
#else
cache_age_list[cache_available_indx].z = z;
#endif
// Shared variables for file access functions
LARGE_INTEGER start_offset_bytes;
DWORD bytes_read, bytes_to_read = sizeof(T) * cache_entry_size;
// This is disc seek offset to desired slice in file
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T) * wX * wY * z;
// Set cache type specific details
switch( cache_state )
{
case CACHE_FULL_SLICE:
// Make row validity table point to correct row
#if CACHING_USE_LINKED_LIST
cache_validity_table[z][0][0] = &( oldest_seg_ptr->item );
#else
cache_validity_table[z][0][0] = &( cache_age_list[cache_available_indx] );
#endif
break;
case CACHE_FULL_ROW:
// Need to offset row number as well
start_offset_bytes.QuadPart = start_offset_bytes.QuadPart + sizeof(T)*y*wX;
// Make row validity table point to correct row
#if CACHING_USE_LINKED_LIST
cache_validity_table[z][y][0] = &( oldest_seg_ptr->item );
// Update cache y info
oldest_seg_ptr->item.y = y;
#else
cache_validity_table[z][y][0] = &( cache_age_list[cache_available_indx] );
// Update cache y info
cache_age_list[cache_available_indx].y = y;
#endif
break;
case CACHE_SUB_ROW:
if ( cache_sub_row_last_seg_indx == (x>>cache_sub_row_shift_val) )
{ // If we are in last segment of row, might be different size than normal
bytes_to_read = sizeof(T) * cache_sub_row_last_entry_size;
}
// Need to offset row and sub row number as well
start_offset_bytes.QuadPart = start_offset_bytes.QuadPart + sizeof(T)*
( y*wX + (x>>cache_sub_row_shift_val)*cache_entry_size );
// Make row validity table point to correct row
#if CACHING_USE_LINKED_LIST
cache_validity_table[z][y][x>>cache_sub_row_shift_val] = &( oldest_seg_ptr->item );
// Update cache y info
oldest_seg_ptr->item.y = y;
oldest_seg_ptr->item.x = x;
#else
cache_validity_table[z][y][x>>cache_sub_row_shift_val] = &( cache_age_list[cache_available_indx] );
// Update cache y and x info
cache_age_list[cache_available_indx].y = y;
cache_age_list[cache_available_indx].x = x;
#endif
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::Cached Set - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
// Read into available cache RAM data from cache File
SetFilePointerEx( cache_file, start_offset_bytes, NULL, FILE_BEGIN );
#if CACHING_USE_LINKED_LIST
ReadFile( cache_file, oldest_seg_ptr->item.data[0], bytes_to_read, &bytes_read, NULL );
#else
ReadFile( cache_file, cache_age_list[cache_available_indx].data[0], bytes_to_read, &bytes_read, NULL );
#endif
};
//------------------------------------------------------------------------------------
// DSt_cube<T>::forceCacheSync
// Description - If RAM cache has been written, forces it to sync with cache File.
// Preserves cache state.
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::forceCacheSync( )
{
LARGE_INTEGER start_offset_bytes;
DWORD bytes_written;
DWORD bytes_to_write = sizeof(T) * cache_entry_size;
unsigned short z, y, x;
start_offset_bytes.QuadPart = 0;
#if CACHING_USE_LINKED_LIST
oldest_seg_ptr = cache_age_queue->getHeadPtr();
#endif
// For every cache item, see if a sync is needed, and if so write to file
// Note that we look at cache items that might have no data, but those should not need sync
for (int i = 0; i < cache_number_of_entries; i++)
{
#if CACHING_USE_LINKED_LIST
if ( oldest_seg_ptr->item.needs_sync )
#else
if ( cache_age_list[i].needs_sync )
#endif
{
switch( cache_state )
{
case CACHE_FULL_SLICE:
#if CACHING_USE_LINKED_LIST
z = oldest_seg_ptr->item.z;
#else
z = cache_age_list[i].z;
#endif
// Find offset
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T) * z*wY*wX;
break;
case CACHE_FULL_ROW:
#if CACHING_USE_LINKED_LIST
z = oldest_seg_ptr->item.z;
y = oldest_seg_ptr->item.y;
#else
z = cache_age_list[i].z;
y = cache_age_list[i].y;
#endif
// Find offset
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T)*(z*wY*wX + y*wX);
break;
case CACHE_SUB_ROW:
#if CACHING_USE_LINKED_LIST
z = oldest_seg_ptr->item.z;
y = oldest_seg_ptr->item.y;
x = oldest_seg_ptr->item.x;
#else
z = cache_age_list[i].z;
y = cache_age_list[i].y;
x = cache_age_list[i].x;
#endif
bytes_to_write = (cache_sub_row_last_seg_indx == ( x>>cache_sub_row_shift_val) ) ?
(sizeof(T) * cache_sub_row_last_entry_size) : (sizeof(T) * cache_entry_size);
// Find offset
start_offset_bytes.QuadPart = (LONGLONG) sizeof(T)*( z*wY*wX + y*wX + (x>>cache_sub_row_shift_val)*cache_entry_size );
break;
default:
// Invalid, should never happen... log error, and crash :)
write_to_log("DSt_cube::forceCacheSync - Fatal Error, invalid cache state %d", cache_state);
exit( 1 );
}
// Write out cached slice to cache file
SetFilePointerEx( cache_file, start_offset_bytes, NULL, FILE_BEGIN );
#if CACHING_USE_LINKED_LIST
WriteFile( cache_file, oldest_seg_ptr->item.data[0], bytes_to_write, &bytes_written, NULL );
// Mark as no longer needing a sync
oldest_seg_ptr->item.needs_sync = false;
#else
WriteFile( cache_file, cache_age_list[i].data[0], bytes_to_write, &bytes_written, NULL );
// Mark as no longer needing a sync
cache_age_list[i].needs_sync = false;
#endif
} // End IF needs sync
#if CACHING_USE_LINKED_LIST
oldest_seg_ptr = oldest_seg_ptr->next;
#endif
}
FlushFileBuffers( cache_file );
}
//------------------------------------------------------------------------------------
// DSt_cube<T>::writeBufferToEntireCacheFile
// Description - writes buffer contents to entire cache file, invalidates table
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::writeBufferToEntireCacheFile(T *buffer, unsigned int bytes_in_buffer)
{
// Write out cache into full file
if ( cache_state == CACHE_DISABLED )
{
return;
}
LARGE_INTEGER file_length;
LARGE_INTEGER cur_pos;
DWORD bytes_written;
file_length.QuadPart = (LONGLONG) wX * wY * wZ * sizeof(T);
// Seek to start of file
cur_pos.QuadPart = 0;
SetFilePointerEx( cache_file, cur_pos, NULL, FILE_BEGIN );
for ( cur_pos.QuadPart = bytes_in_buffer;
cur_pos.QuadPart < file_length.QuadPart;
cur_pos.QuadPart = cur_pos.QuadPart + bytes_in_buffer )
{
WriteFile( cache_file, buffer, bytes_in_buffer, &bytes_written, NULL );
}
// Write out what is left
WriteFile( cache_file, buffer, (DWORD)(file_length.QuadPart - (cur_pos.QuadPart - bytes_in_buffer)),
&bytes_written, NULL );
// Invalidate the cache valididty table
memset( cache_validity_table_mem, 0,
sizeof(cache_entry_info*) * cache_validity_table_dim.z * cache_validity_table_dim.y * cache_validity_table_dim.x );
}
//------------------------------------------------------------------------------------
// DSt_cube<T>::resizeCacheBuffer
// Description - writes buffer contents to entire cache file, invalidates table. Then
// resizes the buffer to a new size (does not change cache type)
//------------------------------------------------------------------------------------
template <class T>
void DSt_cube<T>::resizeCacheBuffer( UINT64 new_cache_size_bytes )
{
// Make sure caching is enabled
if ( cache_state == CACHE_DISABLED )
{
return;
}
// First make sure current buffer is in sync with cache file
forceCacheSync();
// Free up buffer related memory
#if CACHING_USE_LINKED_LIST
delete cache_age_queue;
#else
delete[] cache_age_list;
#endif
delete[] rows;
delete[] memory_block_ptrs[0];
delete[] memory_block_ptrs;
// Allocate new number of desired segements
allocateBufferMemory( new_cache_size_bytes );
}