void MainWindow::setupBootLoader()
{
/* I have no idea why I can't give the value directly to SLOT(...) */
unsigned val = 0;
QTimer::singleShot(0, this, SLOT(val));
val += 25;
/* Set up the boot loader */
ui->statusLabel->setText(tr("Configuring bootloader"));
logger->addLine("Configuring bootloader: moving /boot to appropriate boot partition");
bc->copyBootFiles();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
logger->addLine("Configuring boot cmdline");
bc->configureEnvironment();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
logger->addLine("Configuring /etc/fstab");
bc->configureMounts();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
/* Dump the log */
logger->addLine("Successful installation. Dumping log and rebooting system");
dumpLog();
QTimer::singleShot(0, this, SLOT(val));
/* Reboot */
ui->statusLabel->setText(tr("OSMC installed successfully"));
qApp->processEvents(); /* Force GUI update */
utils->rebootSystem();
}
void MainWindow::haltInstall(QString errorMsg)
{
logger->addLine("Halting Install. Error message was: " + errorMsg);
ui->statusProgressBar->setMaximum(100);
ui->statusProgressBar->setValue(0);
ui->statusLabel->setText(tr("Install failed: ") + errorMsg);
dumpLog();
}
Program* build_Program( const char* name,
int n_shaders, Shader* shaders[],
int n_attribs, const char* attribs[],
int n_uniforms, const char* uniforms[]) {
GLuint id = glCreateProgram();
if( !id )
return NULL;
pointer pgmbuf = malloc( sizeof(Program)
+ strlen(name)+1
+ n_shaders*sizeof(Shader*) );
Program* pgm = pgmbuf;
pgm->id = id;
pgm->name = pgmbuf + sizeof(Program);
strcpy( (char*)pgm->name, name );
// Build
pgm->n_shaders = n_shaders;
pgm->shaders = pgmbuf + sizeof(Program) + strlen(name) + 1;
pgm->log = NULL;
for( int i=0; i<n_shaders; i++ ) {
glAttachShader( id, shaders[i]->id ); check_GL_error;
pgm->shaders[i] = shaders[i];
}
for( int i=0; i<n_attribs; i++ )
glBindAttribLocation( id, i, attribs[i] ); check_GL_error;
glLinkProgram( id ); check_GL_error;
// Get the results
GLint built; glGetProgramiv( id, GL_LINK_STATUS, &built ); check_GL_error;
pgm->built = GL_TRUE == built ? true : false;
// Get the log
fetchLog( pgm );
// Build the attribute and uniform metadata
if( GL_TRUE == built ) {
pgm->attribs = get_active_attribs( pgm, n_attribs, attribs );
pgm->uniforms = get_active_uniforms( pgm, n_uniforms, uniforms );
} else {
debug( "failed to link program '%s':", pgm->name );
dumpLog( pgm->log, "\t" );
}
return pgm;
}
// ~Game()
// Description: game ends, calculate & dump results to log
Game::~Game(){
m_objCount--;
if(m_objCount == 0 && m_objInit){
m_endTime = cpuTime();
updateStats();
dumpLog("open_src_version.log");
}
else
updateStats();
}
void MainWindow::setupBootLoader()
{
/* I have no idea why I can't give the value directly to SLOT(...) */
unsigned val = 0;
QTimer::singleShot(0, this, SLOT(val));
val += 25;
/* Set up the boot loader */
ui->statusLabel->setText(tr("Configuring bootloader"));
if (device->hasBootChanged())
{
logger->addLine("Boot changed. Re-mounting the real /boot");
utils->unmountPartition(device, MNT_BOOT);
utils->mountPartition(device, MNT_BOOT);
}
logger->addLine("Configuring bootloader: moving /boot to appropriate boot partition");
bc->copyBootFiles();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
logger->addLine("Configuring boot cmdline");
bc->configureEnvironment();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
logger->addLine("Configuring /etc/fstab");
bc->configureMounts();
QTimer::singleShot(0, this, SLOT(val));
val += 25;
/* Dump the log */
logger->addLine("Successful installation. Dumping log and rebooting system");
dumpLog();
QTimer::singleShot(0, this, SLOT(val));
/* Reboot */
if (utils->getOSMCDev() == "vero2")
{
system("/bin/sync");
ui->statusLabel->setText(tr("OSMC installed successfully"));
qApp->processEvents(); /* Force GUI update */
}
else
{
ui->statusLabel->setText(tr("OSMC installed successfully"));
qApp->processEvents(); /* Force GUI update */
utils->rebootSystem();
}
}
Shader* compile_Shader( shaderType_e type, const char* name, const char* src ) {
GLuint id = glCreateShader( (GLenum)type );
if( !id )
return NULL;
// Compile
glShaderSource( id, 1, &src, NULL ); check_GL_error;
if( GL_NO_ERROR != gl_lastError ) {
glDeleteShader(id); check_GL_error;
return NULL;
}
glCompileShader( id ); check_GL_error;
// Build up the Shader* object
pointer shbuf = malloc( sizeof(Shader) + strlen(name) + 1 + strlen(src) + 1 );
Shader* sh = shbuf;
sh->id = id;
sh->type = type;
sh->name = shbuf + sizeof(Shader); strcpy( sh->name, name );//clone_string(sh, name);
sh->src = sh->name + strlen(name) + 1; strcpy( sh->src, src );//clone_string(sh, src);
// Get results
GLint compiled; glGetShaderiv( id, GL_COMPILE_STATUS, &compiled ); check_GL_error;
sh->compiled = GL_TRUE == compiled ? true : false;
GLint log_length; glGetShaderiv( id, GL_INFO_LOG_LENGTH, &log_length ); check_GL_error;
if( log_length > 1 ) {
sh->log = malloc( log_length );
glGetShaderInfoLog( id, log_length, NULL, sh->log ); check_GL_error;
} else
sh->log = NULL;
if( !sh->compiled && sh->log ) {
const char* kind = (shadeVertex == type) ? "vertex" : "fragment";
warning( "compilation failed for %s shader '%s':", kind, sh->name );
dumpLog( sh->log, "\t" );
}
check_GL_error;
return sh;
}
// Function Specification
//
// Name: errlTestCreateCommitDeleteLog
//
// Description: errlTestCreateCommitDeleteLog
//
// End Function Specification
uint32_t errlTestCreateCommitDeleteLog()
{
ERRL_DBG("START");
uint32_t l_rc = 0;
do
{
/****************************************************/
// Test create log
errlHndl_t l_handle = NULL;
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_CALLHOME_DATA, g_trac_inf, 512, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
ERRL_DBG("Slots after Creating call home log" );
ppdumpslot();
/****************************************************/
// Test commit log
errlHndl_t l_handle2 = l_handle;
commitErrl( &l_handle );
CHECK_CONDITION( (l_handle == NULL) &&
(l_handle2->iv_userDetails.iv_committed == 1), l_rc);
ERRL_DBG("Slots after Commiting call home log" );
dumpLog( l_handle2, l_handle2->iv_userDetails.iv_entrySize );
ppdumpslot();
/****************************************************/
// Test delete log
deleteErrl(&l_handle2);
CHECK_CONDITION( l_handle2 == NULL, l_rc);
ERRL_DBG("Slots after delete Log" );
ppdumpslot();
ERRL_DBG("END \n");
}while(0);
return l_rc;
}
bool Log::logR ( long long now , long type , char *msg , bool asterisk ,
bool forced ) {
// filter if we should
//if ( forced ) goto skipfilter;
// return true if we should not log this
if ( ! forced && ! shouldLog ( type , msg ) ) return true;
// skipfilter:
// can we log if we're a sig handler? don't take changes
if ( g_inSigHandler )
return logLater ( now , type , msg , NULL );
//if ( g_inSigHandler ) return false;
// get "msg"'s length
long msgLen = gbstrlen ( msg );
#ifdef PTHREADS
// lock for threads
pthread_mutex_lock ( &s_lock );
#endif
// do a timestamp, too. use the time synced with host #0 because
// it is easier to debug because all log timestamps are in sync.
if ( now == 0 ) now = gettimeofdayInMillisecondsGlobalNoCore();
// . skip all logging if power out, we do not want to screw things up
// . allow logging for 10 seconds after power out though
if ( ! g_process.m_powerIsOn && now - g_process.m_powerOffTime >10000){
#ifdef PTHREADS
pthread_mutex_unlock ( &s_lock );
#endif
return false;
}
//if ( now == 0 ) now = g_nowApprox;
// chop off any spaces at the end of the msg.
while ( is_wspace_a ( msg [ msgLen - 1 ] ) && msgLen > 0 ) msgLen--;
// get this pid
pid_t pid = getpidtid();
// a tmp buffer
char tt [ MAX_LINE_LEN ];
char *p = tt;
char *pend = tt + MAX_LINE_LEN;
/*
// print timestamp, hostid, type
if ( g_hostdb.m_numHosts <= 999 )
sprintf ( p , "%llu %03li %s ",
now , g_hostdb.m_hostId , getTypeString(type) );
else if ( g_hostdb.m_numHosts <= 9999 )
sprintf ( p , "%llu %04li %s ",
now , g_hostdb.m_hostId , getTypeString(type) );
else if ( g_hostdb.m_numHosts <= 99999 )
sprintf ( p , "%llu %05li %s ",
now , g_hostdb.m_hostId , getTypeString(type) );
*/
// print timestamp, hostid, type
if ( m_logTimestamps ) {
if ( g_hostdb.m_numHosts <= 999 )
sprintf ( p , "%llu %03li ",
now , g_hostdb.m_hostId );
else if ( g_hostdb.m_numHosts <= 9999 )
sprintf ( p , "%llu %04li ",
now , g_hostdb.m_hostId );
else if ( g_hostdb.m_numHosts <= 99999 )
sprintf ( p , "%llu %05li ",
now , g_hostdb.m_hostId );
p += gbstrlen ( p );
}
// msg resource
char *x = msg;
long cc = 7;
// the first 7 bytes or up to the : must be ascii
//while ( p < pend && *x && is_alnum_a(*x) ) { *p++ = *x++; cc--; }
// space pad
//while ( cc-- > 0 ) *p++ = ' ';
// ignore the label for now...
while ( p < pend && *x && is_alnum_a(*x) ) { x++; cc--; }
// thread id if in "thread"
if ( pid != s_pid && s_pid != -1 ) {
//sprintf ( p , "[%li] " , (long)getpid() );
sprintf ( p , "[%lu] " , (unsigned long)pid );
p += gbstrlen ( p );
}
// then message itself
long avail = (MAX_LINE_LEN) - (p - tt) - 1;
if ( msgLen > avail ) msgLen = avail;
if ( *x == ':' ) x++;
if ( *x == ' ' ) x++;
strncpy ( p , x , avail );
// capitalize for consistency. no, makes grepping log msgs harder.
//if ( is_alpha_a(*p) ) *p = to_upper_a(*p);
p += gbstrlen(p);
// back up over spaces
while ( p[-1] == ' ' ) p--;
// end in period or ? or !
//if ( p[-1] != '?' && p[-1] != '.' && p[-1] != '!' )
// *p++ = '.';
*p ='\0';
// the total length, not including the \0
long tlen = p - tt;
// call sprintf, but first make sure we have room in m_buf and in
// the arrays. who know how much room the sprintf is going to need???
// NOTE: TODO: this is shaky -- fix it!
if ( m_bufPtr + tlen >= 1024 * 32 || m_numErrors >= MAX_LOG_MSGS){
// this sets m_bufPtr to 0
if ( ! dumpLog ( ) ) {
fprintf(stderr,"Log::log: could not dump to file!\n");
#ifdef PTHREADS
pthread_mutex_unlock ( &s_lock );
#endif
return false;
}
}
// . filter out nasty chars from the message
// . replace with ~'s
char cs;
char *ttp = tt;
char *ttpend = tt + tlen;
for ( ; ttp < ttpend ; ttp += cs ) {
cs = getUtf8CharSize ( ttp );
if ( is_binary_utf8 ( ttp ) ) {
for ( long k = 0 ; k < cs ; k++ ) *ttp++ = '.';
// careful not to skip the already skipped bytes
cs = 0;
continue;
}
// convert \n's and \r's to spaces
if ( *ttp == '\n' ) *ttp = ' ';
if ( *ttp == '\r' ) *ttp = ' ';
if ( *ttp == '\t' ) *ttp = ' ';
}
if ( m_fd >= 0 ) {
write ( m_fd , tt , tlen );
write ( m_fd , "\n", 1 );
}
else {
// print it out for now
fprintf ( stderr, "%s\n", tt );
}
// set the stuff in the array
m_errorMsg [m_numErrors] = msg;
m_errorMsgLen [m_numErrors] = msgLen;
m_errorTime [m_numErrors] = now;
m_errorType [m_numErrors] = type;
// increase the # of errors
m_numErrors++;
#ifdef PTHREADS
// unlock for threads
pthread_mutex_unlock ( &s_lock );
#endif
return false;
}
// Function Specification
//
// Name: errlTestCallouts
//
// Description: errlTestCallouts
//
// End Function Specification
uint32_t errlTestCallouts()
{
uint32_t l_rc = 0;
ERRL_DBG("START");
do
{
errlHndl_t l_handle = NULL;
ERRL_DBG("--------------------------------\n");
/****************************************************/
// Check max callouts
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE,g_trac_inf, 128, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
ERRL_CALLOUT_PRIORITY l_array[8] = {
ERRL_CALLOUT_PRIORITY_HIGH,
ERRL_CALLOUT_PRIORITY_MED,
ERRL_CALLOUT_PRIORITY_LOW,
ERRL_CALLOUT_PRIORITY_HIGH,
ERRL_CALLOUT_PRIORITY_MED,
ERRL_CALLOUT_PRIORITY_MED,
ERRL_CALLOUT_PRIORITY_LOW,
ERRL_CALLOUT_PRIORITY_LOW,
};
ERRL_CALLOUT_TYPE l_type[8] = {
ERRL_CALLOUT_TYPE_HUID,
ERRL_CALLOUT_TYPE_COMPONENT_ID,
ERRL_CALLOUT_TYPE_HUID,
ERRL_CALLOUT_TYPE_COMPONENT_ID,
ERRL_CALLOUT_TYPE_HUID,
ERRL_CALLOUT_TYPE_COMPONENT_ID,
ERRL_CALLOUT_TYPE_HUID,
ERRL_CALLOUT_TYPE_COMPONENT_ID,
};
// add 6 (ERRL_MAX_CALLOUTS) callouts
uint8_t l_index = 0;
for(l_index = 0; l_index < ERRL_MAX_CALLOUTS; l_index++)
{
ERRL_DBG("current callouts %d attempting to add callout # %d with type %d ,priority %d", l_handle->iv_numCallouts, l_index, l_type[l_index], l_array[l_index] );
addCalloutToErrl(l_handle,l_type[l_index],l_index,l_array[l_index]);
}
CHECK_CONDITION( l_handle->iv_numCallouts == ERRL_MAX_CALLOUTS, l_rc);
// add one more callout and it should fail
addCalloutToErrl(l_handle,l_type[0],l_index,l_array[0]);
CHECK_CONDITION( l_handle->iv_numCallouts == ERRL_MAX_CALLOUTS, l_rc);
dumpLog( l_handle, l_handle->iv_userDetails.iv_entrySize );
deleteErrl( &l_handle );
ppdumpslot();
/****************************************************/
// Check callouts after errl is committed
// Create log
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE,g_trac_inf, 32, 0x1, 0x2);
errlHndl_t l_log = l_handle;
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
// Commit log and add callout. But adding callout should fail
commitErrl( &l_handle );
addCalloutToErrl(l_handle,l_type[0],0,l_array[0]);
CHECK_CONDITION( l_log->iv_numCallouts == ERRL_MAX_CALLOUTS, l_rc);
deleteErrl(&l_log);
/****************************************************/
// Check addCalloutToErrl for ERRL_SEV_INFORMATIONAL log
// Create ERRL_SEV_INFORMATIONAL log
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_INFORMATIONAL,g_trac_inf, 128, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
if(l_handle == INVALID_ERR_HNDL)
// add one callout and it should fail
addCalloutToErrl(l_handle,l_type[0],l_index,l_array[0]);
CHECK_CONDITION( l_handle->iv_numCallouts == 0, l_rc);
dumpLog( l_handle, l_handle->iv_userDetails.iv_entrySize );
deleteErrl( &l_handle );
ppdumpslot();
ERRL_DBG("END \n");
}while(0);
return l_rc;
}
// Function Specification
//
// Name: errlTestAddTraceToErrl
//
// Description: errlTestAddTraceToErrl
//
// End Function Specification
uint32_t errlTestAddTraceToErrl()
{
uint32_t l_rc = 0;
uint16_t l_entrySizeBefore = 0;
uint16_t l_entrySizeAfter = 0;
ERRL_DBG("START");
do
{
// Create one err log
errlHndl_t l_handle = NULL;
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE, NULL, 512, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
// l_handle will set to NULL after calling the commitErrl, so we need to store it
errlHndl_t l_handleX = l_handle;
ERRL_DBG("Slots after Create - 1 slots should be used (one of each");
ppdumpslot();
/****************************************************/
// Test size limit for addTraceToErrl
// Add "trace" data that exceeds the max size
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
addTraceToErrl(g_trac_inf, MAX_BUFFER_SIZE, l_handle);
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
CHECK_CONDITION( l_entrySizeAfter <= MAX_ERRL_ENTRY_SZ, l_rc);
dumpLog( l_handle, l_handle->iv_userDetails.iv_entrySize );
commitErrl( &l_handle );
ERRL_DBG("Slots after Commit - 1 slots should be used/committed");
ppdumpslot();
deleteErrl(&l_handleX);
ERRL_DBG("Slots after delete Log - All slots should be empty");
ppdumpslot();
/****************************************************/
// Test size limit for addTraceToErrl with continuous calls
// Create log with 512 bytes trace
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE, g_trac_inf, 512, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
// l_handle will set to NULL after calling the commitErrl, so we need to store it
l_handleX = l_handle;
ppdumpslot();
// Add 256 bytes of trace (512+256)
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
addTraceToErrl(g_trac_inf, 256, l_handle); // @at012c
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 bytes" );
ppdumpslot();
// (header + 256) is the size that add to entry
CHECK_CONDITION( l_entrySizeAfter <= (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+256), l_rc);
// Add 512 bytes of trace (512+256+512)
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
addTraceToErrl(g_trac_inf, 512, l_handle); // @at012c
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 + 512 bytes");
ppdumpslot();
CHECK_CONDITION( l_entrySizeAfter <= (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+512), l_rc);
// Add 1024 bytes of trace (512+256+512+1024), the entry size is more than 2048 now
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
addTraceToErrl(g_trac_inf, 1024, l_handle); // @at012c
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 + 512 bytes");
ppdumpslot();
CHECK_CONDITION( l_entrySizeAfter <= MAX_ERRL_ENTRY_SZ, l_rc);
commitErrl( &l_handle );
deleteErrl(&l_handleX);
ERRL_DBG("Slots should now be empty");
ppdumpslot();
ERRL_DBG("END \n");
}while(0);
return l_rc;
}
// Function Specification
//
// Name: errlTestAddUsrDtlsToErrl
//
// Description: errlTestAddUsrDtlsToErrl
//
// End Function Specification
uint32_t errlTestAddUsrDtlsToErrl()
{
uint32_t l_rc = 0;
ERRL_DBG("START");
uint16_t l_entrySizeBefore = 0;
uint16_t l_entrySizeAfter = 0;
do
{
// Create three err logs
errlHndl_t l_handle = NULL;
errlHndl_t l_handle2 = NULL;
errlHndl_t l_handle3 = NULL;
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_UNRECOVERABLE, NULL, 512, 0x1, 0x2);
l_handle2 = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_CALLHOME_DATA, NULL, 512, 0x1, 0x2);
l_handle3 = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_INFORMATIONAL, NULL, 512, 0x1, 0x2);
// l_handle will set to NULL after calling the commitErrl, so we need to store it
errlHndl_t l_handleX = l_handle;
errlHndl_t l_handle2X = l_handle2;
errlHndl_t l_handle3X = l_handle3;
ERRL_DBG("Slots after Create - 3 slots should be used (one of each");
ppdumpslot();
CHECK_CONDITION( (l_handle != INVALID_ERR_HNDL) &&
(l_handle2 != INVALID_ERR_HNDL) &&
(l_handle3 != INVALID_ERR_HNDL), l_rc);
/****************************************************/
// Test size limit for addUsrDtlsToErrl
// Add "user details" data that exceeds the max size for l_handle
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
memset( G_data, 0xCC, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle, G_data, sizeof( G_data ), ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
CHECK_CONDITION( l_entrySizeAfter == MAX_ERRL_ENTRY_SZ, l_rc);
// Add "user details" data that exceeds the max size for l_handle2
l_entrySizeBefore = l_handle2->iv_userDetails.iv_entrySize;
memset( G_data, 0xDD, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle2, G_data, sizeof( G_data ), ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_CALLHOME_DATA );
l_entrySizeAfter = l_handle2->iv_userDetails.iv_entrySize;
CHECK_CONDITION( l_entrySizeAfter == MAX_ERRL_CALL_HOME_SZ, l_rc);
// Add "user details" with size 76 for l_handle3
l_entrySizeBefore = l_handle3->iv_userDetails.iv_entrySize;
memset( G_data, 0xEE, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle3, G_data, 76, ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );
l_entrySizeAfter = l_handle3->iv_userDetails.iv_entrySize;
// (header + 76) is the size that add to entry
CHECK_CONDITION( l_entrySizeAfter == (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+76), l_rc);
dumpLog( l_handle, l_handle->iv_userDetails.iv_entrySize );
dumpLog( l_handle2, l_handle2->iv_userDetails.iv_entrySize );
dumpLog( l_handle3, l_handle3->iv_userDetails.iv_entrySize );
commitErrl( &l_handle );
commitErrl( &l_handle2 );
commitErrl( &l_handle3 );
ERRL_DBG("Slots after Commit - 3 slots should be used/committed");
ppdumpslot();
deleteErrl(&l_handleX);
deleteErrl(&l_handle2X);
deleteErrl(&l_handle3X);
CHECK_CONDITION( (l_handleX == NULL) &&
(l_handle2X == NULL) &&
(l_handle3X == NULL), l_rc);
ERRL_DBG("Slots after delete Log - All slots should be empty");
ppdumpslot();
/****************************************************/
// Test size limit for addUsrDtlsToErrl with continuous calls
// Create log with 512 bytes trace
l_handle = createErrl( TEST_MODULE_ID, 0x08, OCC_NO_EXTENDED_RC, ERRL_SEV_PREDICTIVE, g_trac_inf, 512, 0x1, 0x2);
CHECK_CONDITION( l_handle != INVALID_ERR_HNDL, l_rc);
// l_handle will set to NULL after calling the commitErrl, so we need to store it
l_handleX = l_handle;
ppdumpslot();
// add 256 bytes of "user details" (512+256)
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
memset( G_data, 0xAA, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle, G_data, 256, ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 bytes" );
ppdumpslot();
// (header + 256) is the size that add to entry
CHECK_CONDITION( l_entrySizeAfter == (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+256), l_rc);
// add 512 bytes of "user details" (512+256+512)
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
memset( G_data, 0xBB, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle, G_data, 512, ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 + 512 bytes");
ppdumpslot();
// (header + 512) is the size that add to entry
CHECK_CONDITION( l_entrySizeAfter == (l_entrySizeBefore+sizeof(ErrlUserDetailsEntry_t)+512), l_rc);
// add 1024 bytes of "user details" (512+256+512+1024), the entry size is more than 2048 now
l_entrySizeBefore = l_handle->iv_userDetails.iv_entrySize;
memset( G_data, 0xCC, sizeof( G_data ) );
addUsrDtlsToErrl( l_handle, G_data, 1024, ERRL_USR_DTL_STRUCT_VERSION_1, ERRL_USR_DTL_TRACE_DATA );
l_entrySizeAfter = l_handle->iv_userDetails.iv_entrySize;
ERRL_DBG("Slots after create + 256 + 512 +1024 bytes");
ppdumpslot();
// (header + 1024) is the size that add to entry
CHECK_CONDITION( l_entrySizeAfter <= MAX_ERRL_ENTRY_SZ, l_rc); // @at012c
commitErrl( &l_handle );
deleteErrl(&l_handleX);
ERRL_DBG("Slots should now be empty");
ppdumpslot();
ERRL_DBG("END \n");
}while(0);
return l_rc;
}
/**
* Rank is processor number, name is the name of the person toiling away.
*/
void worker(int rank, char* name) {
srand(time(NULL) + rank);
int workTicks = rand_num(5);
int currWorkTick = 0;
int myFloor = rand_num(3);
int desiredFloor = myFloor;
int floorOfElevator = 0;
enum State state = Work;
int stillWorking = 1;
int wantstobeWorking = 1;
int unusedInt;
while (stillWorking) {
// send whether or not we still have work to do
MPI_Reduce(&wantstobeWorking, &unusedInt, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
// receive what floor the elevator is on
MPI_Bcast(&floorOfElevator, 1, MPI_INT, 0, MPI_COMM_WORLD);
// all workers indicated no more work, so we abandon what we were doing
if (floorOfElevator == -1) {
stillWorking = 0;
struct Bucket *curBuck = firstBuck;
int len = 0;
while (curBuck != 0) {
// printf("%d has a bucket for %s with a content of %d\n", rank, (*curBuck).key, (*curBuck).value);
// We send the key and a value.
// Here, the value is a magic number: If the value is zero, then all the buckets have been sent.
MPI_Send(&(curBuck->value), 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
len = strlen(curBuck->key);
MPI_Send(&len, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
MPI_Send(curBuck->key, len, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
curBuck = curBuck->next;
}
len = 0;
MPI_Send(&len, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
}
if (state == Elevator) {
dumpLog(1, rank, name, " is on the elevator to floor ", desiredFloor);
printf("%d is riding the elevator to floor %d\n", rank, desiredFloor);
// are we on the right floor? if so, state becomes work
if (floorOfElevator == desiredFloor) {
dumpLog(1, rank, name, " got off the elevator on floor ", desiredFloor);
printf("%d got off elevator and is now working on floor %d\n", rank, desiredFloor);
state = Work;
myFloor = desiredFloor;
}
}
else if (state == Work) {
// do work
if (assgn == 2) {
if (curLine < list->size) {
// reduce by counting the words on the lines that have been transmitted
char* thestring;
dlist_get(&list, curLine, &thestring);
printf("%d works on: %s", rank, thestring);
curLine++;
// actually do some work with thestring, e.g. count the words and put them into bins
// go through the string and write each substring into curStr;
char curStr[] = "012345678901234567890123456789012345678901234567890123456789";
int inword = 0;
int curInCurStr = 0;
for (int curInString = 0; thestring[curInString] != '\0'; curInString++) {
if ((thestring[curInString] == ' ') ||
(thestring[curInString] == '\t') ||
(thestring[curInString] == '\n') ||
(thestring[curInString] == '\r')) {
if (inword) {
inword = 0;
// for that, we iterate through all buckets to see if there already is an appropriate one,
// and if not, then we add a bucket
struct Bucket *curBuck = firstBuck;
struct Bucket *prvBuck = 0;
while (curBuck != 0) {
//printf("%d compares %s to %s\n", rank, curStr, curBuck->key);
if (strcmp(curBuck->key, curStr) == 0) {
// we increase the value of the current bucket by one
curBuck->value = curBuck->value + 1;
// printf("%d increased a bucket's value for %s\n", rank, curStr);
goto foundABucket;
}
prvBuck = curBuck;
curBuck = curBuck->next;
if (curBuck == prvBuck) {
curBuck = 0;
}
}
struct Bucket *addBuck = malloc(sizeof *addBuck);
// printf("%d added a bucket for %s\n", rank, curStr);
addBuck->key = strdup(curStr);
addBuck->value = 1;
addBuck->next = 0;
if (firstBuck == 0) {
firstBuck = addBuck;
} else {
prvBuck->next = addBuck;
}
foundABucket: ;
curStr[0] = '\0';
curInCurStr = 0;
}
} else {
inword = 1;
curStr[curInCurStr] = thestring[curInString];
curStr[curInCurStr+1] = '\0';
curInCurStr++;
}
}
} else {
wantstobeWorking = false;
}
}
currWorkTick++;
dumpLog(1, rank, name, " did some work on floor ", myFloor);
printf("%d did some work on floor %d [%d/%d]\n", rank, myFloor, currWorkTick, workTicks);
//receive our next task and wait for the elevator
if (currWorkTick >= workTicks) {
dumpLog(1, rank, name, " is done with work on floor ", myFloor);
printf("%d is done with work on floor %d\n", rank, myFloor);
currWorkTick = 0;
workTicks = rand_num(5);
desiredFloor = myFloor;
while (desiredFloor == myFloor) {
desiredFloor = rand_num(3);
}
state = Waiting;
}
}
else if (state == Waiting) {
dumpLog(1, rank, name, " waits before going to floor ", desiredFloor);
printf("%d is waiting for the elevator to go to floor %d from floor %d\n", rank, desiredFloor, myFloor);
if (floorOfElevator == myFloor) {
dumpLog(1, rank, name, " got on the elevator to floor ", desiredFloor);
printf("%d got on the elevator to go to floor %d\n", rank, desiredFloor);
state = Elevator;
}
}
}
}
void master(int rank) {
srand(time(NULL) + rank);
//master manages elevators
int floor = 1;
bool up = true;
int stillWorking = 1;
while (stillWorking) {
if (up) {
//going up
if (floor + 1 <= MAX_FLOOR) {
floor++;
}
else {
//at max floor, now going down.
up = false;
floor--;
}
}
else {
//going down
if (floor - 1 >= 1) {
floor--;
}
else {
//at ground floor, go back up
up = true;
floor++;
}
}
int valOne = 1;
int redResult = 0;
// ask the workers if they still have work to do
MPI_Reduce(&valOne, &redResult, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
printf("Reduction result is %d\n", redResult);
// all workers indicated that no work is left for them
if (redResult == 1) {
// magic number: abandon work!
floor = -1;
stillWorking = 0;
printf("The work is done!\n");
} else {
dumpLog(0, 1, "", " now passes floor ", floor);
printf("Elevator now passes floor %d\n", floor);
}
//tell workers what floor we're on
MPI_Bcast(&floor, 1, MPI_INT, 0, MPI_COMM_WORLD);
//elevator very fast, only 3 seconds to get in or out
//also possibly dangerous to occupants.
sleep(3);
}
int size;
MPI_Comm_size(MPI_COMM_WORLD, &size);
char tarStr[] = "01234567890123456789012345678901234567890123456789012345678901234567890123456789";
MPI_Status status;
for (int i = 1; i < size; i++) {
int len = 1;
int val = 1;
MPI_Recv(&val, 1, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
while (0 < val) {
MPI_Recv(&len, 1, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
MPI_Recv(&tarStr, len, MPI_CHAR, i, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
tarStr[len] = '\0';
struct Bucket *curBuck = firstBuck;
struct Bucket *prvBuck = 0;
while (curBuck != 0) {
if (strcmp(curBuck->key, tarStr) == 0) {
// we increase the value of the current bucket
curBuck->value = curBuck->value + val;
goto foundABucket;
}
prvBuck = curBuck;
curBuck = curBuck->next;
if (curBuck == prvBuck) {
curBuck = 0;
}
}
struct Bucket *addBuck = malloc(sizeof *addBuck);
addBuck->key = strdup(tarStr);
addBuck->value = val;
addBuck->next = 0;
if (firstBuck == 0) {
firstBuck = addBuck;
} else {
prvBuck->next = addBuck;
}
foundABucket: ;
MPI_Recv(&val, 1, MPI_INT, i, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
}
printf("Root received all the data from process %d.\n", i);
}
struct Bucket *cuBuck = firstBuck;
while (cuBuck != 0) {
printf("%s :: %d\n", (*cuBuck).key, (*cuBuck).value);
wordCountLog((*cuBuck).key, (*cuBuck).value);
cuBuck = cuBuck->next;
}
}
// ~Game()
// Description: game ends, calculate & dump results to log
Game::~Game(){
if(m_nRound == 100){
m_endTime = cpuTime();
dumpLog("open_src_version.log");
}
}
