/**
* @brief Allocates memory for FSR source arrays.
* @details Deletes memory for old source arrays if they were allocated for a
* previous simulation.
*/
void VectorizedSolver::initializeSourceArrays() {
/* Delete old sources arrays if they exist */
if (_reduced_sources != NULL)
MM_FREE(_reduced_sources);
if (_fixed_sources != NULL)
MM_FREE(_fixed_sources);
int size = _num_FSRs * _num_groups * sizeof(FP_PRECISION);
/* Allocate aligned memory for all source arrays */
try{
_reduced_sources = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
_fixed_sources = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
}
catch(std::exception &e) {
log_printf(ERROR, "Could not allocate memory for FSR sources");
}
/* Initialize fixed sources to zero */
memset(_fixed_sources, 0.0, size);
/* Populate fixed source array with any user-defined sources */
initializeFixedSources();
}
/**
* @brief Computes the total source (fission, scattering, fixed) in each FSR.
* @details This method computes the total source in each FSR based on
* this iteration's current approximation to the scalar flux.
*/
void VectorizedSolver::computeFSRSources() {
#pragma omp parallel default(none)
{
int tid;
Material* material;
FP_PRECISION* sigma_t;
FP_PRECISION* sigma_s;
FP_PRECISION* fiss_mat;
FP_PRECISION scatter_source, fission_source;
int size = _num_groups * sizeof(FP_PRECISION);
FP_PRECISION* fission_sources =
(FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
FP_PRECISION* scatter_sources =
(FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
/* For all FSRs, find the source */
#pragma omp for schedule(guided)
for (int r=0; r < _num_FSRs; r++) {
tid = omp_get_thread_num();
material = _FSR_materials[r];
sigma_t = material->getSigmaT();
sigma_s = material->getSigmaS();
fiss_mat = material->getFissionMatrix();
/* Compute scatter + fission source for group G */
for (int G=0; G < _num_groups; G++) {
for (int v=0; v < _num_vector_lengths; v++) {
#pragma simd vectorlength(VEC_LENGTH)
for (int g=v*VEC_LENGTH; g < (v+1)*VEC_LENGTH; g++) {
scatter_sources[g] = sigma_s[G*_num_groups+g] * _scalar_flux(r,g);
fission_sources[g] = fiss_mat[G*_num_groups+g] * _scalar_flux(r,g);
}
}
#ifdef SINGLE
scatter_source=cblas_sasum(_num_groups, scatter_sources, 1);
fission_source=cblas_sasum(_num_groups, fission_sources, 1);
#else
scatter_source=cblas_dasum(_num_groups, scatter_sources, 1);
fission_source=cblas_dasum(_num_groups, fission_sources, 1);
#endif
fission_source /= _k_eff;
/* Compute total (scatter+fission+fixed) reduced source */
_reduced_sources(r,G) = _fixed_sources(r,G);
_reduced_sources(r,G) += scatter_source + fission_source;
_reduced_sources(r,G) *= ONE_OVER_FOUR_PI / sigma_t[G];
}
}
MM_FREE(fission_sources);
MM_FREE(scatter_sources);
}
}
/**
* @brief Compute \f$ k_{eff} \f$ from successive fission sources.
*/
void VectorizedSolver::computeKeff() {
FP_PRECISION fission;
int size = _num_FSRs * sizeof(FP_PRECISION);
FP_PRECISION* FSR_rates = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_threads * _num_groups * sizeof(FP_PRECISION);
FP_PRECISION* group_rates = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
#pragma omp parallel
{
int tid = omp_get_thread_num() * _num_groups;
Material* material;
FP_PRECISION* sigma;
FP_PRECISION volume;
/* Compute the new nu-fission rates in each FSR */
#pragma omp for schedule(guided)
for (int r=0; r < _num_FSRs; r++) {
volume = _FSR_volumes[r];
material = _FSR_materials[r];
sigma = material->getNuSigmaF();
/* Loop over each energy group vector length */
for (int v=0; v < _num_vector_lengths; v++) {
/* Loop over energy groups within this vector */
#pragma simd vectorlength(VEC_LENGTH)
for (int e=v*VEC_LENGTH; e < (v+1)*VEC_LENGTH; e++)
group_rates[tid+e] = sigma[e] * _scalar_flux(r,e);
}
#ifdef SINGLE
FSR_rates[r] = cblas_sasum(_num_groups, &group_rates[tid], 1) * volume;
#else
FSR_rates[r] = cblas_dasum(_num_groups, &group_rates[tid], 1) * volume;
#endif
}
}
/* Reduce new fission rates across FSRs */
#ifdef SINGLE
fission = cblas_sasum(_num_FSRs, FSR_rates, 1);
#else
fission = cblas_dasum(_num_FSRs, FSR_rates, 1);
#endif
_k_eff *= fission;
MM_FREE(FSR_rates);
MM_FREE(group_rates);
}
/*
-----------------------------------------------------------------------------
Function: Z_TagMalloc -Allocates zone memory blocks.
Parameters:
size -[in] Bytes to allocate.
tag -[in] Tag to associate with memory (see header for tag).
Returns:
A void pointer to the allocated space, or will shutdown application
if there is insufficient memory available.
Notes:
-----------------------------------------------------------------------------
*/
PUBLIC void *Z_TagMalloc( size_t size, int tag )
{
zhead_t *z;
// Allocate memory
size += sizeof( zhead_t );
z = MM_MALLOC( size );
if( ! z )
{
Com_Error( ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes", size );
}
// Set memory block to zero and fill in header.
memset( z, 0, size );
z_count++;
z_bytes += size;
z->magic = Z_MAGIC;
z->tag = tag;
z->size = size;
// Add new memory block to chain.
z->next = z_chain.next;
z->prev = &z_chain;
z_chain.next->prev = z;
z_chain.next = z;
return (void *)(z+1);
}
/**
* \brief Get Page file raw data.
* \param[in] pagenum Page to load.
* \param[in] length Length of data.
* \return On success pointer to data block, otherwise NULL.
* \note Caller is responsible for freeing allocated data by calling MM_FREE.
*/
PUBLIC void *PageFile_getPage( W32 pagenum, W32 *length )
{
W8 *addr;
PageList_t *page;
W32 pageOffset;
W16 pageLength;
*length = 0;
page = &PMPages[ pagenum ];
pageOffset = LittleLong( page->offset );
pageLength = LittleShort( page->length );
if( pageLength == 0 )
{
return NULL;
}
addr = (PW8)MM_MALLOC( pageLength );
if( addr == NULL )
{
return NULL;
}
PageFile_ReadFromFile( addr, pageOffset, pageLength );
*length = pageLength;
return addr;
}
/**
* \brief Decodes raw sprite data into RGB32.
* \param[in] data Raw sprite data.
* \param[in] palette Palette array.
* \return On success pointer to raw image data block, otherwise NULL.
* \note Caller is responsible for freeing allocated data by calling MM_FREE.
*/
PUBLIC void *PageFile_decodeSprite_RGB32( W8 *data, W8 *palette )
{
W32 i;
W32 temp;
W32 x, y;
W8 *buffer;
W8 *ptr;
W16 *cmdptr;
SW16 *linecmds;
t_compshape *shape;
W16 leftpix, rightpix;
buffer = (PW8)MM_MALLOC( 64 * 64 * 4 );
if( NULL == buffer )
{
return NULL;
}
for( x = 0 ; x < (64 * 64 * 4) ; x += 4 )
{
ptr = buffer + x;
ptr[ 0 ] = 0xFF; /* R */
ptr[ 1 ] = 0x00; /* G */
ptr[ 2 ] = 0xFF; /* B */
ptr[ 3 ] = 0x00; /* A */
}
shape = (t_compshape *)data;
leftpix = LittleShort( shape->leftpix );
rightpix = LittleShort( shape->rightpix );
cmdptr = shape->dataofs;
for( x = leftpix ; x <= rightpix ; ++x )
{
linecmds = (PSW16)(data + LittleShort( *cmdptr ));
cmdptr++;
for( ; LittleShort( *linecmds ) ; linecmds += 3 )
{
i = (LittleShort( linecmds[ 2 ] ) / 2) + LittleShort( linecmds[ 1 ] );
for( y = (W32)(LittleShort( linecmds[ 2 ] ) / 2) ; y < (W32)(LittleShort( linecmds[ 0 ] ) / 2) ; ++y, ++i )
{
temp = data[ i ] * 3;
ptr = buffer + (y * 64 + x) * 4;
ptr[ 0 ] = palette[ temp + 0 ]; /* R */
ptr[ 1 ] = palette[ temp + 1 ]; /* G */
ptr[ 2 ] = palette[ temp + 2 ]; /* B */
ptr[ 3 ] = 0xFF; /* A */
}
}
}
return (void *)buffer;
}
/**
* \brief Decodes raw wall data into RGB-32.
* \param[in] data Raw wall data.
* \param[in] palette Palette array.
* \return On success pointer to raw image data block, otherwise NULL.
* \note Caller is responsible for freeing allocated data by calling MM_FREE.
*/
PUBLIC void *PageFile_decodeWall_RGB32( W8 *data, W8 *palette )
{
W32 temp;
W8 *buffer;
W8 *ptr;
W32 x, y;
buffer = (PW8)MM_MALLOC( 64 * 64 * 4 );
if( NULL == buffer )
{
return NULL;
}
for( x = 0 ; x < 64 ; ++x )
{
for( y = 0 ; y < 64 ; ++y )
{
temp = ( data[ (x << 6) + y ] ) * 3;
ptr = buffer + ( ( (y << 6) + x ) * 4 );
ptr[ 0 ] = palette[ temp + 0 ]; /* R */
ptr[ 1 ] = palette[ temp + 1 ]; /* G */
ptr[ 2 ] = palette[ temp + 2 ]; /* B */
ptr[ 3 ] = 0xFF; /* A */
}
}
return (void *)buffer;
}
/**
* @brief Allocates memory for Track boundary angular and FSR scalar fluxes.
* @details Deletes memory for old flux arrays if they were allocated for a
* previous simulation.
*/
void VectorizedSolver::initializeFluxArrays() {
/* Delete old flux arrays if they exist */
if (_boundary_flux != NULL)
MM_FREE(_boundary_flux);
if (_scalar_flux != NULL && !_user_fluxes)
MM_FREE(_scalar_flux);
if (_old_scalar_flux != NULL)
MM_FREE(_old_scalar_flux);
if (_delta_psi != NULL)
MM_FREE(_delta_psi);
if (_thread_taus != NULL)
MM_FREE(_thread_taus);
int size;
/* Allocate aligned memory for all flux arrays */
try{
size = 2 * _tot_num_tracks * _num_groups * _num_polar;
size *= sizeof(FP_PRECISION);
_boundary_flux = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_FSRs * _num_groups * sizeof(FP_PRECISION);
_scalar_flux = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
_old_scalar_flux = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_threads * _num_groups * sizeof(FP_PRECISION);
_delta_psi = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_threads * _polar_times_groups * sizeof(FP_PRECISION);
_thread_taus = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
}
catch(std::exception &e) {
log_printf(ERROR, "Could not allocate memory for the fluxes");
}
}
/**
* \brief Gets the current working directory
* \return If the function succeeds, a pointer to a NUL-terminated string. Otherwise NULL.
* \note Caller is responsible for freeing allocated memory.
*/
PUBLIC char *FS_GetCurrentDirectory( void )
{
char *path;
path = MM_MALLOC( MAXPATHLEN );
if( path == NULL )
{
return NULL;
}
return getcwd( path, MAXPATHLEN );
}
/*
-----------------------------------------------------------------------------
Function: CAL_ExpandGrChunk() -Expand compressed graphic chunk.
Parameters: chunk -[in] Chunk number to expand.
source -[in] Pointer to compressed data.
version -[in] extension version.
1 -WL6
2 -SOD
Returns: Nothing.
Notes:
-----------------------------------------------------------------------------
*/
PRIVATE void CAL_ExpandGrChunk( W32 chunk, const W8 *source, W16 version )
{
W32 expanded;
W16 offset = 0;
if( version & SOD_PAK )
offset = SOD_STARTDIFF;
if( chunk >= ( STARTTILE8 + offset ) &&
chunk < ( STARTEXTERNS + offset ) )
{
//
// expanded sizes of tile8/16/32 are implicit
//
#define BLOCK 64
#define MASKBLOCK 128
if( chunk < (STARTTILE8M + offset) ) // tile 8s are all in one chunk!
expanded = BLOCK * NUMTILE8;
else if( chunk < (STARTTILE16 + offset) )
expanded = MASKBLOCK * NUMTILE8M;
else if( chunk < (STARTTILE16M + offset) ) // all other tiles are one/chunk
expanded = BLOCK << 2;
else if( chunk < (STARTTILE32 + offset) )
expanded = MASKBLOCK << 2;
else if( chunk < (STARTTILE32M + offset) )
expanded = BLOCK << 4;
else
expanded = MASKBLOCK << 4;
}
else
{
//
// everything else has an explicit size longword
//
expanded = *(PW32)source;
source += 4; // skip over length
}
//
// allocate final space and decompress it.
// Sprites need to have shifts made and various other junk.
//
grsegs[ chunk ] = MM_MALLOC( expanded );
if( grsegs[ chunk ] == NULL )
{
return;
}
CAL_HuffExpand( source, grsegs[ chunk ], expanded, grhuffman );
}
/*
-----------------------------------------------------------------------------
Function:
Parameters:
Returns:
Notes:
-----------------------------------------------------------------------------
*/
PRIVATE void R_ScreenShot_f( void )
{
W8 *buffer;
char picname[ 80 ];
char checkname[ MAX_OSPATH ];
int i;
FILE *f;
// create the scrnshots directory if it doesn't exist
my_snprintf( checkname, sizeof( checkname ), "%s/scrnshot", FS_Gamedir() );
FS_CreateDirectory( checkname );
//
// find a file name to save it to
//
my_strlcpy( picname, "scrn00.tga", sizeof( picname ) );
for( i = 0 ; i <= 99 ; ++i )
{
picname[ 4 ] = i / 10 + '0';
picname[ 5 ] = i % 10 + '0';
my_snprintf( checkname, sizeof( checkname ), "%s/scrnshot/%s", FS_Gamedir(), picname );
f = fopen( checkname, "rb" );
if( ! f )
{
break; // file doesn't exist
}
fclose( f );
}
if( i == 100 )
{
Com_Printf( "R_ScreenShot_f: Couldn't create a file\n" );
return;
}
buffer = MM_MALLOC( viddef.width * viddef.height * 3 );
pfglReadPixels( 0, 0, viddef.width, viddef.height, GL_RGB, GL_UNSIGNED_BYTE, buffer );
WriteTGA( checkname, 24, viddef.width, viddef.height, buffer, 1, 1 );
MM_FREE( buffer );
Com_Printf( "Wrote %s\n", picname );
}
/**
* \brief Create a new link list.
* \return Pointer to new link list structure.
*/
PUBLIC linkList_t *linkList_new( void )
{
linkList_t *list;
list = (linkList_t *) MM_MALLOC( sizeof( linkList_t ) );
if( list == NULL )
{
MM_OUTOFMEM( "linkList_new" );
}
list->element = NULL;
list->next = NULL;
return list;
}
/**
* @brief Allocates memory for the exponential linear interpolation table.
*/
void VectorizedSolver::initializeExpEvaluator() {
CPUSolver::initializeExpEvaluator();
/* Deallocates memory for the exponentials if it was allocated for a
* previous simulation */
if (_thread_exponentials != NULL)
MM_FREE(_thread_exponentials);
/* Allocates memory for an array of exponential values for each thread
* - this is not used by default, but can be to allow for vectorized
* evaluation of the exponentials. Unfortunately this does not appear
* to give any performance boost. */
int size = _num_threads * _polar_times_groups * sizeof(FP_PRECISION);
_thread_exponentials = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
}
/*
-----------------------------------------------------------------------------
Function: CA_CacheGrChunk() -Cache graphic chunk.
Parameters: chunk -[in] Chunk number to cache.
version -[in] extension version.
1 -WL6
2 -SOD
Returns: Nothing.
Notes: Makes sure a given chunk is in memory, loading it if needed.
-----------------------------------------------------------------------------
*/
PRIVATE void CA_CacheGrChunk( W32 chunk, W16 version )
{
SW32 pos;
W32 compressed;
void *buffer;
W32 next;
if( grsegs[ chunk ] )
{
return; // already in memory
}
//
// load the chunk into a buffer
//
pos = GRFILEPOS( chunk );
if( pos < 0 ) // $FFFFFFFF start is a sparse tile
{
return;
}
next = chunk + 1;
while( GRFILEPOS( next ) == -1 ) // skip past any sparse tiles
{
next++;
}
compressed = GRFILEPOS( next ) - pos;
fseek( grhandle, pos, SEEK_SET );
buffer = MM_MALLOC( compressed );
if( buffer == NULL )
{
return;
}
fread( buffer, 1, compressed, grhandle );
CAL_ExpandGrChunk( chunk, buffer, version );
MM_FREE( buffer );
}
/*
-----------------------------------------------------------------------------
Function:
Parameters:
Returns:
Notes:
-----------------------------------------------------------------------------
*/
PRIVATE powerup_t *Pow_AddNew( void )
{
powerup_t *newp;
newp = MM_MALLOC( sizeof( powerup_t ) );
newp->prev = NULL;
newp->next = powerups;
if( powerups )
{
powerups->prev = newp;
}
powerups = newp;
return newp;
}
/**
* \brief Cache audio data.
* \param[in] chunkId Id of chunk to cache.
* \return On success pointer to raw data, otherwise NULL.
*/
PUBLIC void *AudioFile_CacheAudioChunk( const W32 chunkId )
{
W32 pos;
W32 chunk_size;
W32 count; /* Number of bytes read from file */
SW8 *buffer;
//
// Load the chunk into a buffer
//
pos = LittleLong( audiostarts[ chunkId ] );
chunk_size = (LittleLong( audiostarts[ chunkId+1 ] )) - pos;
if( chunk_size < 1 )
{
fprintf( stderr, "[AudioFile_CacheAudioChunk]: Chunk size not valid\n" );
return NULL;
}
if( fseek( audiohandle, pos, SEEK_SET ) != 0 )
{
fprintf( stderr, "[AudioFile_CacheAudioChunk]: Could not seek in file!\n" );
return NULL;
}
buffer = (PSW8) MM_MALLOC( chunk_size );
if( buffer == NULL )
{
return NULL;
}
count = fread( buffer, 1, chunk_size, audiohandle );
if( count != chunk_size )
{
fprintf( stderr, "[AudioFile_CacheAudioChunk]: Read error!\n" );
MM_FREE( buffer );
return NULL;
}
return (void *)buffer;
}
/**
* \brief Initialize Texture Manager.
* \note Generates default texture.
*/
PUBLIC void TM_Init( void )
{
W8 *ptr;
W8 *data;
int x, y;
memset( _texWalls, 0, sizeof( _texWalls ) );
memset( _texSprites, 0, sizeof( _texSprites ) );
texture_registration_sequence = 1;
// create a checkerboard texture
data = (PW8)MM_MALLOC( 16 * 16 * 4 );
for( y = 0; y < 16; ++y )
{
for( x = 0; x < 16; ++x )
{
ptr = &data[ (y * 16 + x) * 4 ];
if( (y < 8) ^ (x < 8) )
{
ptr[ 0 ] = ptr[ 1 ] = ptr[ 2 ] = 0x00;
ptr[ 3 ] = 0xFF;
}
else
{
ptr[ 0 ] = ptr[ 1 ] = ptr[ 2 ] = 0xFF;
ptr[ 3 ] = 0xFF;
}
}
}
r_notexture = TM_LoadTexture( "***r_notexture***", data, 16, 16, TT_Pic, 4 );
MM_FREE( data );
Cmd_AddCommand( "listTextures", TM_TextureList_f );
}
/**
* \brief Add element to link list.
* \param[in] list Pointer to linkList_t structure.
* \param[in] newElement Element to add to link list.
* \return On success pointer to newly added node, otherwise NULL.
*/
PUBLIC linkList_t *linkList_addList( linkList_t *list, void *newElement )
{
if( list )
{
linkList_t *newNode;
newNode = (linkList_t *) MM_MALLOC( sizeof( linkList_t ) );
if( newNode == NULL )
{
MM_OUTOFMEM( "linkList_addList" );
}
newNode->element = newElement;
newNode->next = list->next;
list->next = newNode;
return newNode;
}
return (linkList_t *) NULL;
}
/**
* \brief Add element to link list.
* \param[in] list Pointer to linkList_t structure.
* \param[in] newElement Element to add to link list.
* \return On success true, otherwise false.
*/
PUBLIC wtBoolean linkList_add( linkList_t *list, void *newElement )
{
if( list )
{
linkList_t *newNode;
newNode = (linkList_t *) MM_MALLOC( sizeof( linkList_t ) );
if( newNode == NULL )
{
MM_OUTOFMEM( "linkList_add" );
}
newNode->element = newElement;
newNode->next = list->next;
list->next = newNode;
return true;
}
return false;
}
/**
* \brief Get map data chunk.
* \param[in] chunkOffset Source buffer to convert from
* \param[in] chunkLength Size of chunk data.
* \return NULL on error, otherwise pointer to map data.
* \note Caller must free allocated data.
*/
PUBLIC void *MapFile_getMapData( W32 chunkOffset, W32 chunkLength )
{
void *mapdata;
if( map_file_handle == NULL )
{
return NULL;
}
mapdata = MM_MALLOC( chunkLength );
if( NULL == mapdata )
{
MM_OUTOFMEM( "MapFile_getMapData" );
return NULL;
}
fseek( map_file_handle, chunkOffset, SEEK_SET );
fread( mapdata, 1, chunkLength, map_file_handle );
return mapdata;
}
/**
* @brief Allocates memory for FSR source arrays.
* @details Deletes memory for old source arrays if they were allocated for a
* previous simulation.
*/
void VectorizedSolver::initializeSourceArrays() {
/* Delete old sources arrays if they exist */
if (_fission_sources != NULL)
MM_FREE(_fission_sources);
if (_scatter_sources != NULL)
MM_FREE(_scatter_sources);
if (_source != NULL)
MM_FREE(_source);
if (_old_source != NULL)
MM_FREE(_old_source);
if (_reduced_source != NULL)
MM_FREE(_reduced_source);
if (_source_residuals != NULL)
MM_FREE(_source_residuals);
int size;
/* Allocate aligned memory for all source arrays */
try{
size = _num_FSRs * _num_groups * sizeof(FP_PRECISION);
_fission_sources = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
_source = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
_old_source = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
_reduced_source = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_threads * _num_groups * sizeof(FP_PRECISION);
_scatter_sources = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
size = _num_FSRs * sizeof(FP_PRECISION);
_source_residuals = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
}
catch(std::exception &e) {
log_printf(ERROR, "Could not allocate memory for the VectorizedSolver's "
"FSR sources array. Backtrace:%s", e.what());
}
}
/*
-----------------------------------------------------------------------------
Function: LumpExtractor() -Extract Lump gfx from Wolf3D and SOD data files.
Parameters: fextension -[in] String holding file extension
(must be in '.XXX' format).
limit -[in] max
version -[in] extension version.
1 -WL6
2 -SOD
Returns: Nothing.
Notes:
-----------------------------------------------------------------------------
*/
PUBLIC _boolean LumpExtractor( const char *fextension, W32 limit, W16 version )
{
W32 i;
W8 *buffer, *buffer2;
if( ! fextension || ! *fextension )
{
printf( "Invalid file extension passed into LumpExtractor!\n" );
return false;
}
//
// Setup
//
if( 0 == FS_Mkdir( LGFXDIR ) )
{
printf( "[%s] Could not create directory (%s)!\n", "wolf_gfx.c", LGFXDIR );
return false;
}
if( ! CAL_SetupGrFile( fextension ) )
{
CAL_Shutdown();
return false;
}
//
// Allocate buffers
//
buffer = MM_MALLOC( 320 * 416 * 2 );
if( buffer == NULL )
{
CAL_Shutdown();
return false;
}
buffer2 = MM_MALLOC( 640 * 400 * 4 );
if( buffer2 == NULL )
{
MM_FREE( buffer );
CAL_Shutdown();
return false;
}
//
// Decode GFX data
//
printf( "Decoding GFX Data...\n" );
// (void)DecodeText( version );
for( i = STARTFONT; i < STARTPICS; ++i )
{
CA_CacheGrChunk( i, version );
Fontline( i, version );
}
for( i = STARTPICS; i < limit+1; ++i )
{
CA_CacheGrChunk( i, version );
SavePic( i, version, buffer, buffer2 );
}
//
// Shutdown
//
MM_FREE( buffer2 );
MM_FREE( buffer );
CAL_Shutdown();
return true;
}
/*
-----------------------------------------------------------------------------
Function: CAL_SetupGrFile() -Initialize graphic files and arrays.
Parameters: extension -[in] Pointer to a null-terminated string that
specifies the file extension.
(must be in '.XXX' format).
Returns: 1 on success, 0 otherwise.
Notes:
Uses global variables grhandle and pictable.
1. Open vgadict.XXX, read huffman dictionary data.
2. Open vgahead.XXX, read data offsets.
3. Open vgagraph.XXX, read pic and sprite header, expand data.
-----------------------------------------------------------------------------
*/
PRIVATE W8 CAL_SetupGrFile( const char *extension )
{
void *compseg;
FILE *handle;
char filename[ 16 ];
SW32 chunkcomplen; // chunk compressed length
//
// load vgadict.ext (huffman dictionary for graphics files)
//
cs_strlcpy( filename, GFXDICTFNAME, sizeof( filename ) );
cs_strlcat( filename, extension, sizeof( filename ) );
if( ( handle = fopen( cs_strupr( filename ), "rb" ) ) == NULL )
{
if( ( handle = fopen( cs_strlwr( filename ), "rb" ) ) == NULL )
{
printf( "Could not open file (%s) for read!\n", filename );
return 0;
}
}
fread( grhuffman, sizeof( grhuffman ), 1, handle );
fclose( handle );
//
// Open then load the data offsets from vgahead.ext
//
cs_strlcpy( filename, GFXHEADFNAME, sizeof( filename ) );
cs_strlcat( filename, extension, sizeof( filename ) );
if( (handle = fopen( cs_strupr( filename ), "rb" )) == NULL )
{
if( (handle = fopen( cs_strlwr( filename ), "rb" )) == NULL )
{
printf( "Could not open file (%s) for read!\n", filename );
return 0;
}
}
grstarts = MM_MALLOC( (NUMCHUNKS+1) * FILEPOSSIZE );
if( grstarts == NULL )
{
return 0;
}
fread( grstarts, sizeof( long ), (NUMCHUNKS+1) * FILEPOSSIZE, handle );
fclose( handle );
//
// Open the graphics file 'vgagraph.XXX'.
//
cs_strlcpy( filename, GFXFNAME, sizeof( filename ) );
cs_strlcat( filename, extension, sizeof( filename ) );
if( ( grhandle = fopen( cs_strupr( filename ), "rb" ) ) == NULL )
{
if( ( grhandle = fopen( cs_strlwr( filename ), "rb" ) ) == NULL )
{
printf( "Could not open file (%s) for read!\n", filename );
return 0;
}
}
//
// load the pic and sprite headers into the arrays.
//
pictable = MM_MALLOC( NUMPICS * sizeof( pictabletype ) );
if( pictable == NULL )
{
return 0;
}
chunkcomplen = CAL_GetGrChunkLength( STRUCTPIC ); // position file pointer
compseg = MM_MALLOC( chunkcomplen );
if( compseg == NULL )
{
return 0;
}
fread( compseg, chunkcomplen, 1, grhandle );
CAL_HuffExpand( compseg, (PW8)pictable,
NUMPICS * sizeof( pictabletype ),
grhuffman );
MM_FREE( compseg );
return 1;
}
void Epoll_Engine::Engine_Loop()
{
const static int maxevents = 1024;
struct epoll_event events[1024];
if( socketpair(AF_UNIX,SOCK_STREAM,0,pipefd) == -1)
{
LOGDEBUG("libshared","create pipe error!");
return;
}
__shared_setnonblocking( pipefd[1] );
AddFd(pipefd[0]);
while(true)
{
time_t time_start = CURRENTTIME();
time_t time_end = 0;
int nfds = epoll_wait(m_EpollFd,events,maxevents,timeout);
if(nfds <= 0)
{
// epoll_wait超时...执行时间心跳
m_timeHeap->Tick();
timeout = TIME_OUT;
}
else
{
time_end = CURRENTTIME();
timeout = time_end - time_start;
for(int i = 0; i < nfds; i++)
{
int fd = events[i].data.fd;
/////////////////////////////////////////////////////
// 信号处理
////////////////////////////////////////////////////
if(fd == pipefd[0] && events[i].events & EPOLLIN)
{
// 信号处理: 主循环来完成吧～～
//LOGDEBUG("debug","收到信号～～");
OnRecvSignal();
continue;
}
////////////////////////////////////////////////////
basesocket_sptr socket = fds[fd];
if(!socket)
{
continue;
}
// 有一个潜在问题 ：当socket的异常时通过epoll_wait发现抛出，
// EPOLLERR/EPOLLHUP事件，而不是read/write流程中发现，这时
// 同样会误以为异常断开连接，所以只是再read/write流程中忽略
// 相关错误码不够完善，当epoll_wait检测到socket错误时，仍然
// 会当成fatal error处理。
//
// 正确的解决方法：
// 1.read/write流程中对非知名错误（EINTR/EAGAIN/EWOULDBLOCK...）合理处理。
// 2.遇到EPOLLERR/EPOLLHUP事件时，有两种做法：
// （1）不调用error异常流程，而是跟EPOLLIN一样调用读取流程，让读取流程
// 去确认/处理实际的错误.
// （2）通过getsocketopt SO_REEOR获取具体的错误码，并过滤掉非fatal错误.
if(events[i].events & EPOLLHUP || events[i].events & EPOLLERR)
{
int eno = -1;
int len = sizeof(int);
if( getsockopt(fd,SOL_SOCKET,SO_ERROR,(void *)&eno,(socklen_t *)&len) == 0)
{
if(eno == 0 || eno == 32)
{
// 在OnWrite中已经做过处理，这里不必再处理！
continue;
}
MM_Task * task = new (MM_MALLOC(sizeof(MM_Task))) MM_Task(SWITCH_MM_TASK_ONERROR,(Socket_Engine *)this,fd,socket->GetCtime());
//MM_Task * task = new MM_Task(SWITCH_MM_TASK_ONERROR,(Socket_Engine *)this,fd,socket->GetCtime());
if(task != NULL)
sMMThreads.AddOneTask(task);
}
}
else if(events[i].events & EPOLLIN) // recv data
{
MM_Task * task = new (MM_MALLOC(sizeof(MM_Task))) MM_Task(SWITCH_MM_TASK_ONREAD,(Socket_Engine *)this,fd,socket->GetCtime());
//MM_Task * task = new MM_Task(SWITCH_MM_TASK_ONREAD,(Socket_Engine *)this,fd,socket->GetCtime());
if(task != NULL)
sMMThreads.AddOneTask(task);
}
else if(events[i].events & EPOLLOUT) // send data
{
MM_Task * task = new (MM_MALLOC(sizeof(MM_Task))) MM_Task(SWITCH_MM_TASK_ONWRITE,(Socket_Engine *)this,fd,socket->GetCtime());
//MM_Task * task = new MM_Task(SWITCH_MM_TASK_ONWRITE,(Socket_Engine *)this,fd,socket->GetCtime());
if(task != NULL)
sMMThreads.AddOneTask(task);
}
}
}
sMMThreads.Run();
}
}
/*
-----------------------------------------------------------------------------
Function: Fontline() -Extract and save font.
Parameters: fontnumber -[in] font to save.
version -[in] extension version.
1 -WL6
2 -SOD
Returns: Nothing.
Notes: Font must be cached in grsegs[] before calling.
-----------------------------------------------------------------------------
*/
PRIVATE void Fontline( W32 fontnumber, W16 version )
{
fontstruct *font;
W16 i;
W16 x, y;
W16 px, py;
W8 *buffer;
W8 *source;
W8 *ptr;
char filename[ 256 ];
font = (fontstruct *)grsegs[ fontnumber ];
buffer = MM_MALLOC( FONTWIDTH * FONTHEIGHT * 4 );
if( buffer == NULL )
return;
ptr = buffer;
for( x = 0; x < FONTWIDTH; ++x )
{
for( y = 0; y < FONTHEIGHT; ++y, ptr += 4 )
{
ptr[ 0 ] = ptr[ 1 ] = ptr[ 2 ] = 0xFF;
ptr[ 3 ] = 0x00;
}
}
px = py = 0;
for( i = 0; i < 256; ++i )
{
if( ! font->width[ i ] )
continue;
if( px + font->width[ i ] > FONTWIDTH-1 )
{
py += font->height;
px = 0;
}
source = ((PW8) font) + font->location[ i ];
ptr = buffer + (py * FONTWIDTH + px) * 4;
for( y = 0; y < font->height; ++y, ptr += FONTWIDTH * 4 )
{
for( x = 0; x < font->width[ i ]; ++x )
{
if( *source++ )
{
ptr[ x * 4 + 3 ] = 0xFF;
}
}
}
px += 16;
} // end for i = 0; i < 256; ++i
cs_snprintf( filename, sizeof( filename ), "%s/font%d.tga", LGFXDIR, fontnumber );
WriteTGA( filename, 32, FONTWIDTH, FONTHEIGHT, buffer, 0, 1 );
MM_FREE( buffer );
}
/**
* \brief Load font details from file
* \param[in] filename File name to load details
* \return Valid pointer to font_t
*/
PUBLIC font_t *createFont( const char *filename )
{
font_t *temp_font;
char *datname;
filehandle_t *fp;
W32 size;
W32 i;
if( num_fonts == (MAX_FONTS - 1) )
{
Com_Printf( "[createFont]: No more font slots open\n" );
return NULL;
}
temp_font = (font_t *)Z_Malloc( sizeof( font_t ) );
temp_font->texfont = TM_FindTexture( filename, TT_Pic );
if( NULL == temp_font->texfont )
{
Com_Printf( "[createFont]: unable to open file (%s)\n", filename );
Z_Free( temp_font );
return NULL;
}
memset( temp_font->nCharWidth, 0, sizeof( temp_font->nCharWidth ) );
datname = (char *)MM_MALLOC( strlen( filename ) + 1 );
FS_RemoveExtension( filename, datname );
com_strlcat( datname, ".dat", strlen( filename ) + 1 );
fp = FS_OpenFile( datname, 0 );
if( NULL == fp )
{
Com_Printf( "[createFont]: unable to open file (%s)\n", datname );
MM_FREE( datname );
Z_Free( temp_font );
return NULL;
}
size = FS_GetFileSize( fp );
// check header size
if( size < 10 )
{
Com_Printf( "[createFont]: File (%s) has incorrect file length\n", datname );
MM_FREE( datname );
Z_Free( temp_font );
FS_CloseFile( fp );
return NULL;
}
// Check sig of font dat file
FS_ReadFile( &size, 1, 4, fp );
FS_ReadFile( &temp_font->nMaxWidth, 1, 1, fp );
FS_ReadFile( &temp_font->nMaxHeight, 1, 1, fp );
FS_ReadFile( &size, 1, 4, fp );
size = LittleLong( size );
if( size > 127 )
{
Com_Printf( "[createFont]: File (%s) has incorrect Character Width array\n", datname );
MM_FREE( datname );
Z_Free( temp_font );
FS_CloseFile( fp );
return NULL;
}
FS_ReadFile( &temp_font->nCharWidth, 1, size, fp );
FS_CloseFile( fp );
temp_font->nSize = 2;
temp_font->colour[ 3 ] = 255;
temp_font->hFrac = (float)(temp_font->nMaxHeight / (float)temp_font->texfont->height);
temp_font->wFrac = (float)(temp_font->nMaxWidth / (float)temp_font->texfont->width);
for( i = 0 ; i < MAX_FONTS ; ++i )
{
if( ! myfonts[ i ] )
{
break;
}
}
if( i == (MAX_FONTS - 1) )
{
Com_Printf( "[createFont]: No more font slots open\n" );
MM_FREE( datname );
Z_Free( temp_font );
return NULL;
}
myfonts[ i ] = temp_font;
MM_FREE( datname );
return temp_font;
}
/**
* \brief Setup page file for decoding.
* \param[in] pagefname Source buffer to convert from
* \param[out] nBlocks Destination buffer to convert to.
* \param[out] SpriteStart Offset index for sprite data.
* \param[out] SoundStart Offset index for sound data.
* \return On success true, otherwise false.
*/
PUBLIC wtBoolean PageFile_Setup( const char *pagefname, W32 *nBlocks, W32 *SpriteStart, W32 *SoundStart )
{
W32 i;
W32 size;
void *buf = NULL;
W32 *offsetptr;
char *temp_fileName = NULL;
PageList_t *page;
W16 *lengthptr;
W16 tval;
W32 PMNumBlocks;
W32 PMSpriteStart;
W32 PMSoundStart;
if( ! pagefname || ! *pagefname )
{
fprintf( stderr, "[PageFile_Setup]: Invalid file name\n" );
goto PMSetupFailure;
}
temp_fileName = (char *) MM_MALLOC( strlen( pagefname ) + 1 );
if( temp_fileName == NULL )
{
goto PMSetupFailure;
}
wt_strlcpy( temp_fileName, pagefname, strlen( pagefname ) + 1 );
/* Open page file */
file_handle_page = fopen( wt_strupr( temp_fileName ), "rb" );
if( file_handle_page == NULL )
{
file_handle_page = fopen( wt_strlwr( temp_fileName ), "rb" );
if( file_handle_page == NULL )
{
fprintf( stderr, "Could not open file (%s) for read!\n", temp_fileName );
goto PMSetupFailure;
}
}
/* Read in header variables */
fread( &tval, sizeof( W16 ), 1, file_handle_page );
PMNumBlocks = LittleShort( tval );
fread( &tval, sizeof( W16 ), 1, file_handle_page );
PMSpriteStart = LittleShort( tval );
fread( &tval, sizeof( W16 ), 1, file_handle_page );
PMSoundStart = LittleShort( tval );
/* Allocate and clear the page list */
PMPages = (PageList_t *) MM_MALLOC( sizeof( PageList_t ) * PMNumBlocks );
if( PMPages == NULL )
{
goto PMSetupFailure;
}
memset( PMPages, 0, sizeof( PageList_t ) * PMNumBlocks );
/* Read in the chunk offsets */
size = sizeof( W32 ) * PMNumBlocks;
buf = MM_MALLOC( size );
if( buf == NULL )
{
goto PMSetupFailure;
}
if( fread( buf, 1, size, file_handle_page ) == 0 )
{
fprintf( stderr, "Could not read chunk offsets from file (%s)\n", temp_fileName );
}
offsetptr = (PW32) buf;
for( i = 0, page = PMPages; i < PMNumBlocks; i++, page++ )
{
page->offset = LittleLong( *offsetptr++ );
}
MM_FREE( buf );
/* Read in the chunk lengths */
size = sizeof( W16 ) * PMNumBlocks;
buf = MM_MALLOC( size );
if( buf == NULL )
{
goto PMSetupFailure;
}
if( fread( buf, 1, size, file_handle_page ) == 0 )
{
fprintf( stderr, "Could not read chunk lengths from file (%s)\n", temp_fileName );
}
lengthptr = (PW16)buf;
for( i = 0, page = PMPages ; i < PMNumBlocks ; ++i, page++ )
{
page->length = LittleShort( *lengthptr++ );
}
MM_FREE( buf );
MM_FREE( temp_fileName );
*nBlocks = PMNumBlocks;
*SpriteStart = PMSpriteStart;
*SoundStart = PMSoundStart;
return true;
PMSetupFailure:
MM_FREE( temp_fileName );
MM_FREE( PMPages );
MM_FREE( buf );
return false;
}
/**
* \brief Redux the Page file data.
* \param[in] vsfname data file name.
* \param[in] wallPath Path to save wall data.
* \param[in] spritePath Path to save sprite data.
* \param[in] soundPath Path to save sound data.
* \param[in] palette Palette array.
* \return On success true, otherwise false.
* \note Caller is responsible for freeing allocated data by calling MM_FREE.
*/
PUBLIC wtBoolean PageFile_ReduxDecodePageData( const char *vsfname, const char *wallPath, const char *spritePath, const char *soundPath, W8 *palette )
{
void *data;
void *decdata;
W32 length;
char tempFileName[ 1024 ];
W32 i;
W32 SpriteStart, NumBlocks, SoundStart;
W32 soundBufferSize;
W8 *soundBuffer;
W32 totallength;
printf( "Decoding Page Data..." );
if( ! PageFile_Setup( vsfname, &NumBlocks, &SpriteStart, &SoundStart ) )
{
PageFile_Shutdown();
return false;
}
// ////////////////////////////////////////////////////////////////////////
// Decode Walls
for( i = 0 ; i < SpriteStart ; ++i )
{
data = PageFile_getPage( i, &length );
if( data == NULL )
{
continue;
}
decdata = PageFile_decodeWall_RGB32( (PW8)data, palette );
if( decdata == NULL )
{
fprintf( stderr, "[PageFile_ReduxDecodePageData]: Unable to decode wall (%d).\n", i );
MM_FREE( data );
continue;
}
if( _filterScale > 0 )
{
void *scaledImgBuf;
scaledImgBuf = (void *) MM_MALLOC( 128 * 128 * 4 );
if( NULL == scaledImgBuf )
{
MM_FREE( data );
MM_FREE( decdata );
continue;
}
// Scale2x
if( _filterScale == 1 )
{
scale( 2, (void *)scaledImgBuf, 128 * 4, decdata, 64 * 4, 4, 64, 64 );
RGB32toRGB24( (const PW8)scaledImgBuf, (PW8)scaledImgBuf, 128 * 128 * 4 );
} else {
// hq2x
RGB32toRGB24( (const PW8)decdata, (PW8)decdata, 64 * 64 * 4 );
RGB24toBGR565( decdata, decdata, 64 * 64 * 3 );
hq2x_32( (PW8)decdata, (PW8)scaledImgBuf, 64, 64, 64 * 2 * 4 );
RGB32toRGB24( (const PW8)scaledImgBuf, (PW8)scaledImgBuf, 128 * 128 * 4 );
}
wt_snprintf( tempFileName, sizeof( tempFileName ), "%s%c%.3d.tga", wallPath, PATH_SEP, GetWallMappedIndex( i ) );
TGA_write( tempFileName, 24, 128, 128, scaledImgBuf, 0, 1 );
MM_FREE( scaledImgBuf );
} else {
wt_snprintf( tempFileName, sizeof( tempFileName ), "%s%c%.3d.tga", wallPath, PATH_SEP, GetWallMappedIndex( i ) );
RGB32toRGB24( (const PW8)decdata, (PW8)decdata, 64 * 64 * 4 );
TGA_write( tempFileName, 24, 64, 64, decdata, 0, 1 );
}
MM_FREE( data );
MM_FREE( decdata );
}
// ////////////////////////////////////////////////////////////////////////
// Decode Sprites
for( i = SpriteStart ; i < SoundStart ; ++i )
{
data = PageFile_getPage( i, &length );
if( data == NULL )
{
continue;
}
decdata = PageFile_decodeSprite_RGB32( (PW8)data, palette );
if( decdata == NULL )
{
MM_FREE( data );
continue;
}
if( _filterScale_Sprites > 0 )
{
W8 *scaledImgBuf;
scaledImgBuf = (PW8) MM_MALLOC( 128 * 128 * 4 );
if( NULL == scaledImgBuf ) {
MM_FREE( data );
MM_FREE( decdata );
continue;
}
if( _filterScale_Sprites == 1 ) {
scale( 2, (void *)scaledImgBuf, 128 * 4, decdata, 64 * 4, 4, 64, 64 );
} else {
// hq2x
RGB32toRGB24( (const PW8)decdata, (PW8)decdata, 64 * 64 * 4 );
RGB24toBGR565( decdata, decdata, 64 * 64 * 3 );
hq2x_32( (PW8)decdata, (PW8)scaledImgBuf, 64, 64, 64 * 2 * 4 );
ReduxAlphaChannel_hq2x( scaledImgBuf, 128, 128 );
}
wt_snprintf( tempFileName, sizeof( tempFileName ), "%s%c%.3d.tga", spritePath, PATH_SEP, GetSpriteMappedIndex( i - SpriteStart ) );
TGA_write( tempFileName, 32, 128, 128, scaledImgBuf, 0, 1 );
MM_FREE( scaledImgBuf );
} else {
wt_snprintf( tempFileName, sizeof( tempFileName ), "%s%c%.3d.tga", spritePath, PATH_SEP, GetSpriteMappedIndex( i - SpriteStart ) );
TGA_write( tempFileName, 32, 64, 64, decdata, 0, 1 );
}
MM_FREE( data );
MM_FREE( decdata );
}
// ////////////////////////////////////////////////////////////////////////
// Decode SFX
soundBufferSize = 20 * 4096;
soundBuffer = (PW8) MM_MALLOC( soundBufferSize );
if( soundBuffer == NULL )
{
PageFile_Shutdown();
return false;
}
totallength = 0;
for( i = SoundStart ; i < NumBlocks ; ++i )
{
data = PageFile_getPage( i, &length );
if( data == NULL )
{
continue;
}
if( (totallength + length) > soundBufferSize )
{
fprintf( stderr, "[PageFile_ReduxDecodePageData]: Buffer not large enough to hold sound data!\n" );
MM_FREE( data );
MM_FREE( soundBuffer );
return false;
}
MM_MEMCPY( soundBuffer + totallength, data, length );
totallength += length;
if( length < 4096 )
{
wt_snprintf( tempFileName, sizeof( tempFileName ), "%s%c%.3d.wav", soundPath, PATH_SEP, i - SoundStart );
wav_write( tempFileName, soundBuffer, totallength, 1, SAMPLERATE, 1 );
totallength = 0;
}
MM_FREE( data );
}
MM_FREE( soundBuffer );
PageFile_Shutdown();
MM_FREE( data );
printf( "Done\n" );
return true;
}
/*
-----------------------------------------------------------------------------
Function: CAL_SetupAudioFile() -Setup for decoding audio data.
Parameters: fextension -[in] Pointer to string with file extension.
Returns: Non-zero on success, otherwise zero.
Notes:
-----------------------------------------------------------------------------
*/
PRIVATE W8 CAL_SetupAudioFile( const char *fextension )
{
FILE *handle;
SW32 length;
W32 count;
char fname[ 13 ];
if( ! fextension || ! *fextension )
{
printf( "NULL extension passed into CAL_SetupAudioFile!\n" );
return 0;
}
//
// load audiohed.XXX (offsets and lengths for audio file)
//
cs_strlcpy( fname, AHEADFNAME, sizeof( fname ) );
cs_strlcat( fname, fextension, sizeof( fname ) );
handle = fopen( cs_strupr( fname ), "rb" );
if( handle == NULL )
{
handle = fopen( cs_strlwr( fname ), "rb" );
if( handle == NULL )
{
printf( "Can not open file (%s) for read!\n", fname );
return 0;
}
}
length = FS_FileLength( handle );
if( length < 4 )
{
fclose( handle );
printf( "Incorrect audio header size on file: %s\n", fname );
return 0;
}
audiostarts = (PW32) MM_MALLOC( length );
if( audiostarts == NULL )
{
return 0;
}
count = fread( audiostarts, sizeof( W32 ), length >> 2, handle );
if( count != (W32)(length >> 2) )
{
fclose( handle );
printf( "[Error]: Read error on file: (%s)", fname );
return 0;
}
fclose( handle );
//
// open the Audio data file
//
cs_strlcpy( fname, AUDIOFNAME, sizeof( fname ) );
cs_strlcat( fname, fextension, sizeof( fname ) );
audiohandle = fopen( cs_strupr( fname ), "rb" );
if( audiohandle == NULL )
{
audiohandle = fopen( cs_strlwr( fname ), "rb" );
if( audiohandle == NULL )
{
printf( "Could not open file (%s) for read!\n", fname );
return 0;
}
}
return 1;
}
/**
* @brief Reallocates the Material's cross-section data structures along
* word-aligned boundaries
* @details This method is used to assist with SIMD auto-vectorization of the
* MOC routines in the Solver classes. Rather than using the assigned
* number of energy groups, this method adds "dummy" energy groups
* such that the total number of groups is some multiple of VEC_LENGTH
* (typically 4, 8, or 16). As a result, the SIMD-vectorized Solver
* subclasses can break up loops over energy groups in such a way
* to "expose" the SIMD nature of the algorithm.
*/
void Material::alignData() {
/* If the data has already been aligned, do nothing */
if (_data_aligned)
return;
if (_num_groups <= 0)
log_printf(ERROR, "Unable to align Material %d data since the "
"cross-sections have not yet been set\n", _id);
_num_vector_groups = (_num_groups / VEC_LENGTH) + 1;
/* Allocate memory for the new aligned xs data */
int size = _num_vector_groups * VEC_LENGTH * sizeof(FP_PRECISION);
/* Allocate word-aligned memory for cross-section data arrays */
FP_PRECISION* new_sigma_t = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
FP_PRECISION* new_sigma_a = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
FP_PRECISION* new_sigma_f = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
FP_PRECISION* new_nu_sigma_f=(FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
FP_PRECISION* new_chi = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
/* The scattering matrix will be the number of vector groups
* wide (SIMD) and the actual number of groups long since
* instructions are not SIMD in this dimension */
size = _num_vector_groups * VEC_LENGTH * _num_vector_groups;
size *= VEC_LENGTH * sizeof(FP_PRECISION);
FP_PRECISION* new_sigma_s = (FP_PRECISION*)MM_MALLOC(size, VEC_ALIGNMENT);
/* Initialize data structures to ones for sigma_t since it is used to
* divide the source in the solver, and zeroes for everything else */
size = _num_vector_groups * VEC_LENGTH * sizeof(FP_PRECISION);
for (int i=0; i < _num_vector_groups * VEC_LENGTH; i++) {
new_sigma_t[i] = 1.0;
new_sigma_a[i] = 0.0;
new_sigma_f[i] = 0.0;
new_nu_sigma_f[i] = 0.0;
new_chi[i] = 0.0;
}
size *= _num_vector_groups * VEC_LENGTH;
memset(new_sigma_s, 0.0, size);
/* Copy materials data from unaligned arrays into new aligned arrays */
size = _num_groups * sizeof(FP_PRECISION);
memcpy(new_sigma_t, _sigma_t, size);
memcpy(new_sigma_a, _sigma_a, size);
memcpy(new_sigma_f, _sigma_f, size);
memcpy(new_nu_sigma_f, _nu_sigma_f, size);
memcpy(new_chi, _chi, size);
for (int e=0; e < _num_groups; e++) {
memcpy(new_sigma_s, _sigma_s, size);
new_sigma_s += _num_vector_groups * VEC_LENGTH;
_sigma_s += _num_groups;
}
_sigma_s -= _num_groups * _num_groups;
/* Reset the new scattering cross section array pointer */
new_sigma_s -= _num_vector_groups * VEC_LENGTH * _num_groups;
/* Delete the old unaligned arrays */
delete [] _sigma_t;
delete [] _sigma_a;
delete [] _sigma_f;
delete [] _nu_sigma_f;
delete [] _chi;
delete [] _sigma_s;
/* Set the material's array pointers to the new aligned arrays */
_sigma_t = new_sigma_t;
_sigma_a = new_sigma_a;
_sigma_f = new_sigma_f;
_nu_sigma_f = new_nu_sigma_f;
_chi = new_chi;
_sigma_s = new_sigma_s;
_data_aligned = true;
return;
}