/**
* Replans the path.
*
* @return bool solution found
*/
bool Planner::replan()
{
_path.clear();
bool result = _compute();
// Couldn't find a solution
if ( ! result)
return false;
Map::Cell* current = _start;
_path.push_back(current);
// Follow the path with the least cost until goal is reached
while (current != _goal)
{
if (current == NULL || _g(current) == Math::INF)
return false;
current = _min_succ(current).first;
_path.push_back(current);
}
return true;
}
void compute() final {
if (is_computed)
return;
timer.tic();
_compute(_result);
timer.toc();
is_computed = true;
}
wstring Sha1Sum::ComputeforFile()
{
_compute();
g_log.Log(L"Sha1Sum::ComputeforFile for %s returns %s", (wchar_t *) m_file.c_str(), (wchar_t *) m_sum.c_str());
return m_sum;
}
void strsm_llnu_lu( unsigned int SPE_id, LS_ShaderInfo *info, Operation_t *myop, Functions_t *funcs )
{
_DBGP_UINT( 1 );
// Make room for python meta data
PyArrayObject *A = (PyArrayObject *)info->LS_shaderMemory;
PyArrayObject *B = (PyArrayObject *)info->LS_shaderMemory+sizeof( PyArrayObject );
PyArrayObject *alpha = (PyArrayObject *)info->LS_shaderMemory+sizeof( PyArrayObject )*2;
PyArrayObject *cb = (PyArrayObject *)info->LS_shaderMemory+sizeof( PyArrayObject )*3;
// Get meta data
_GetPyArrayMetaData( myop->obj[0], A, 0 );
_GetPyArrayMetaData( myop->obj[1], B, 0 );
_GetPyArrayMetaData( myop->scalar[0], alpha, 0 );
_GetPyArrayMetaData( myop->scalar[1], cb, 0 );
_Wait(0); // WAIT!!!
_DBGP_UINT( 2 );
// Make room for data block arrays
char **blocks_A = (char**)( ( (unsigned int)( cb + sizeof( PyArrayObject )) + 127 ) &~ 127 );
char **blocks_B = (char**)( blocks_A + _Pad16bytes( A->numberOfBlocks ) );
char **blocks_alpha = (char**)( blocks_B + _Pad16bytes( B->numberOfBlocks ) );
char **blocks_cb = (char**)( blocks_alpha + _Pad16bytes( alpha->numberOfBlocks ) );
// Local vars
unsigned int idx = 0, nextidx;
unsigned int i, j, k, l, row, col;
// unsigned int c = 0;
//
// unsigned int Afourth = A->blockSize / 4;
// unsigned int xfourth = x->blockSize / 4;
// unsigned int AAfourth = A->blockSize*A->blockSize / 4;
// unsigned int t = 0;
// Uploadet scalars
float alpha_f, beta_f;
unsigned int CB;
_GetScalar( alpha, blocks_alpha, &alpha_f, 1 );
_GetScalar( cb, blocks_cb, &CB, 1 );
_DBGP_UINT( 3 );
vector float alphav = spu_splats(alpha_f);
// Fetch pointers to first __ datablocks for vectors
_GetBlockPointers( B, blocks_B, B->numberOfBlocks, _BTAG );
_GetBlockPointers( A, blocks_A, A->numberOfBlocks, _BTAG );
_Wait(_BTAG);
vector float *BKJ, *BIJ, aik;
float *AIK;
unsigned int x;
int ain, ain2;
_DBGP_UINT( 4000 );
_DBGP_UINT( CB );
// Same A, get it once
_GetBlock( blocks_A, info->LS_blockDataArea[1], CB*A->numberOfBlocksXDim+CB, A->blockSize*A->blockSize, idx );
_Wait(idx);
_DBGP_UINT( CB*B->numberOfBlocksXDim+1+CB+SPE_id );
// Get first block of B
_GetBlock( blocks_B, info->LS_blockDataArea[0], CB*B->numberOfBlocksXDim+1+CB+SPE_id, B->blockSize*B->blockSize, idx );
_Wait(idx);
_DBGP_UINT( 5000 );
//funcs->printuint(CB + SPE_id + 1);
//funcs->printuint(B->numberOfBlocksXDim-myop->num_SPES);
// For each block column
// BLOCK >
for( col = CB + SPE_id + 1 ; col < B->numberOfBlocksXDim-myop->num_SPES ; col += myop->num_SPES )
{
_DBGP_UINT( 100000 + col );
nextidx = idx ^ 1;
//funcs->printuint(CB*A->numberOfBlocksXDim+col+myop->num_SPES);
_GetBlock( blocks_B, info->LS_blockDataArea[nextidx*3], CB*B->numberOfBlocksXDim+col+myop->num_SPES, B->blockSize*B->blockSize, nextidx );
_Wait( idx );
for( l = 1 ; l < B->blockSize ; l++ )
{
_DBGP_UINT( 200000 + l );
BKJ = (vector float*)( info->LS_blockDataArea[idx*3] + (l-1) % B->blockSize * B->blockSize * 4 );
// BIJ[i] = BIJ[i] - BKJ[i] * aik;
_compute( B->blockSize, l, l-1, BKJ, (float*)info->LS_blockDataArea[idx*3], (float*)info->LS_blockDataArea[1] );
//_compute2( B->blockSize, l, l-1, BKJ, (float*)info->LS_blockDataArea[idx*3], (float*)info->LS_blockDataArea[1], funcs );
}
// Return the result to the PPE
_PutAsync( (unsigned int)blocks_B[CB*A->numberOfBlocksXDim+col], B->blockSize * B->blockSize * 4, info->LS_blockDataArea[idx*3], idx );
idx = nextidx;
}
_DBGP_UINT( 100000 + col );
_Wait( idx );
for( l = 1 ; l < B->blockSize ; l++ )
{
BKJ = (vector float*)( info->LS_blockDataArea[idx*3] + (l-1) % B->blockSize * B->blockSize * 4 );
//_compute2( B->blockSize, l, l-1, BKJ, (float*)info->LS_blockDataArea[idx*3], (float*)info->LS_blockDataArea[1], funcs );
_compute( B->blockSize, l, l-1, BKJ, (float*)info->LS_blockDataArea[idx*3], (float*)info->LS_blockDataArea[1] );
}
//funcs->printuint( 678 );
//_PrintMatrix( B, info->LS_blockDataArea[idx*3], funcs );
// Return the result to the PPE
_PutAsync( (unsigned int)blocks_B[CB*A->numberOfBlocksXDim+col], B->blockSize * B->blockSize * 4, info->LS_blockDataArea[idx*3], idx );
}
double MathSolver::_compute(TiXmlNode *node)
{
if(!node)
qDebug() << "The node is null";
TiXmlNode *child = node->FirstChild();
QString type = child->Value();
qDebug() << "The node type is:" << type;
/********************************************************/
// if numerical type, return the scalar
if("cn" == type){
TiXmlNode *text = child->FirstChild();
if(!text)
return 0;
QString t = child->FirstChild()->Value();
return t.toDouble();
}
// TODO: make the regex available somewhere else to reduce
// avoid multiple object creation
QRegExp re("^[0-9]+\.?[0-9]*");
if(type.contains(re))
return type.toDouble(); // in this case type is the scalar
/********************************************************/
// if function, process it
if("apply" == type){
return MathSolver::_compute(child);
}
/********************************************************/
if("power" == type){
double base = _compute(child->NextSibling());
double exp = _compute(child->NextSibling()->NextSibling());
return qPow(base, exp);
}
// can process as many arguments as possible
if("plus" == type){
double sum = 0;
for(TiXmlNode *summand=child->NextSibling();
summand; summand=summand->NextSibling())
{
sum += MathSolver::_compute(summand);
}
return sum;
}
// can process as many arguments as possible
if("times" == type){
double multiplication = 1;
for(TiXmlNode *multarg=child->NextSibling();
multarg; multarg=multarg->NextSibling())
{
multiplication *= MathSolver::_compute(multarg);
}
return multiplication;
}
return 0;
}
