// EXCEPTIONS: CProcessFailure
// TO DO: clean up error reporting
// use dialog to say we're busy and give a cancel button
void CToneGenProcess::processANAFile(CProcessStatus& status)
{
LPCTSTR kOutputExt = ".txz";
LPCTSTR kLogExt = ".tgp";
LPCTSTR kCMDExt = ".cmt";
try
{
ASSERTX(status.getOutputLang());
CString sBase = status.getInputMFS()->getAbrev() + status.getOutputMFS()->getAbrev() + "-tgen";
m_sOutputTextPath = status.makeTempPath(status.sANAPath.getFileName(), kOutputExt);
m_sLOGPath = status.makeTempPath(sBase, ".log" );
m_sCMDPath =status.makeTempPath(sBase, ".cmd");
outputSupportFiles(status);
m_sOutputTextPath.deleteFile(); // don't care if it is found or not
m_sLOGPath.deleteFile(); // don't care if it is found or not
if(!executeTool(status))
{
throw(CProcessFailure(this, "Unknown execution problem"));
}
waitForCompletion(&status, &m_sLOGPath, &m_sOutputTextPath);
// register ana output so the user can view it
CString sLabel(status.getOutputMFS()->getAbrev());
sLabel += " Text";
CResultStreamFile* textStream =
new CResultStreamFile(
new CResultStreamDescriptor(this,
"Synthesized Text",
"Target text synthesized by ToneGen (ToneGen synthesis)",
sLabel // language specific
),
m_sOutputTextPath.getFullPath(),
status.getOutputLang());
status.registerResultStream(textStream);
registerLog(status, m_sLOGPath, status.getOutputLang());
status.sRAWPath = m_sOutputTextPath;
}
catch(CProcessFailure failure)
{
registerLog(status, m_sLOGPath);
throw(failure);
}
catch(CString sError)
{
registerLog(status, m_sLOGPath);
throw(CProcessFailure(this, sError));
}
}
void matrixReadFromFile(char *fileName, Matrix *matrixToLoad, int sizeMatrix, int myid, agoLogStr *agoLog)
{
FILE *fdIn;
if ((fdIn = fopen(fileName, "r")) == NULL) {
snprintf(agoLog->logMsg, LOG_SIZE, "Erro ao tentar carregar Matriz do Arquivo %s", fileName);
registerLog(agoLog, myid);
} else {
if ((fread(matrixToLoad, sizeof(double), sizeMatrix, fdIn)) == 0) {
snprintf(agoLog->logMsg, LOG_SIZE, "Erro ao Carregar Matriz do Arquivo %s", fileName);
registerLog(agoLog, myid);
} else {
snprintf(agoLog->logMsg, LOG_SIZE, "Carregado Matriz do Arquivo %s", fileName);
registerLog(agoLog, myid);
}
}
fclose(fdIn);
}
void pagamentoThread::run()
{
qsrand(time(NULL));
QThread::msleep(UNIDTEMPO * (qrand()%2) + 1);
emit registerLog("O cliente " + c->getNomeID() + " efetuou o pagameno e saiu da loja");
emit finalizouPagamento(cx);
delete c;
}
double matrixMultiplyParallel(Matrix *matrixChunkA, Matrix *matrixChunkB, Matrix *matrixC, int idPackage, int offSetA, int offSetB,
int chunkToCalc, int id, agoLogStr *agoLog)
{
int i = 0, j = 0, k = 0;
double d_multiplyTime = 0.0;
snprintf(agoLog->logMsg, LOG_SIZE, "Multiplicando pacote id %d: OffSetA %d OffSetB %d", idPackage, offSetA, offSetB);
registerLog(agoLog, id);
for (k = 0; k < chunkToCalc; k++) {
for (i = 0; i < chunkToCalc; i++) {
for (j = 0; j < MAX_MATRIX_SIZE; j++) {
matrixC[i][k] = matrixC[i][k] + (matrixChunkA[i][j] * matrixChunkB[i][j]);
}
}
}
snprintf(agoLog->logMsg, LOG_SIZE, "Multiplicao Concluida pacote id %d: OffSetA %d OffSetB %d", idPackage, offSetA, offSetB);
registerLog(agoLog, id);
return(d_multiplyTime);
}
void agoSendRepeatToWorker(unsigned int *ui_workerList, int numWorkers, agoLogStr *agoLog)
{
int i_signalFlag = FLAG_FAIL, i_workerId = 2;
while (i_workerId < numWorkers) {
MPI_Send(&i_signalFlag, 1, MPI_INT, ui_workerList[i_workerId], TAG_INFO, MPI_COMM_WORLD);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Enviado Repeat para Worker ID: %d", ui_workerList[i_workerId]);
registerLog(agoLog, i_myidWorker);
i_workerId++;
}
}
void pedidoThread::run()
{
int qtdCompra;
int idprod;
int tot;
int qtd;
logMessageCompra* lc = new logMessageCompra();
qsrand(time(NULL));
QThread::msleep(UNIDTEMPO * (qrand()%2 + 1));
idprod = p->getID();
pD = (int*)dsm.data();
dR = (int*)rsm.data();
pT = (int*)qsm.data();
pN = (int*)nsm.data();
dsm.lock();
qsm.lock();
tot = pT[idprod];
nsm.lock();
qtd = pN[idprod];
nsm.unlock();
qsm.unlock();
if(qtd == 0)qtd = 1;
qtdCompra = ((tot*1.0)/(qtd*1.0))*1.2 + 0.5;
rsm.lock();
dR[idprod] = 0;
rsm.unlock();
pD[idprod]+= qtdCompra;
dsm.unlock();
emit registerLog("Comprados " + QString::number(qtdCompra) + " para o produto " + QString::number(idprod));
lc->setProdutoComprado(idprod, qtdCompra);
emit registerLogCompra(lc);
emit finalizouPedido(e);
delete p;
}
// EXCEPTIONS: CProcessFailure
// TO DO: clean up error reporting
// use dialog to say we're busy and give a cancel button
void CToneParseProcess::processANAFile(CProcessStatus& status)
{
try
{
CString sBase = status.m_sFileNameRoot +"-tpars";
m_sOutputANAPath = status.makeTempPath(sBase,".ana");
m_sLOGPath = status.makeTempPath(sBase, ".log" );
m_sCMDPath =status.makeTempPath(sBase, ".cmd");
outputSupportFiles(status);
m_sOutputANAPath.deleteFile(); // don't care if it is found or not
m_sLOGPath.deleteFile(); // don't care if it is found or not
if(!executeTool(status))
{
throw(CProcessFailure(this, "Failed to process the file with ToneParse"));
}
waitForCompletion(&status, &m_sOutputANAPath);
// register itx output so the user can view it
CResultStreamFile* anaStream =
new CResultStreamFile(
new CResultStreamDescriptor(this,
"TPARS ANA", //short description
"ANA Output of ToneParse", // long description
"TPARS ANA" // tab label
),
m_sOutputANAPath,
status.getInputLang());
status.registerResultStream(anaStream);
registerLog(status, m_sLOGPath, status.getInputLang());
status.sANAPath = m_sOutputANAPath;
}
catch(CString sError)
{
throw(CProcessFailure(this, sError));
}
}
// EXCEPTIONS: CProcessFailure
// TO DO: clean up error reporting
// use dialog to say we're busy and give a cancel button
void CPrintANAProcess::processANAFile(CProcessStatus& status)
{
try
{
CString sBase = status.m_sFileNameRoot +_T("-prtana");
m_sLOGPath = status.makeTempPath(sBase, _T(".log") );
m_sLOGPath.deleteFile(); // don't care if it is found or not
if(!executeTool(status))
{
throw(CProcessFailure(this, _T("Failed to process the file with PrintANA")));
}
waitForCompletion(&status, &m_sLOGPath);
registerLog(status, m_sLOGPath, status.getInputLang());
}
catch(CString sError)
{
throw(CProcessFailure(this, sError));
}
}
// EXCEPTIONS: CProcessFailure
void CPCPATRDllProcess::processANAFile(CProcessStatus& status)
{
CModelFilesSet* pSourceMFS = status.getInputMFS();
ASSERTX(pSourceMFS);
CModelFilesSet* pTargetMFS = status.getOutputMFS(); // may be null
try
{
IPatrParser *pPatr;
CLSID clsid;
HRESULT hr;
#ifndef hab245
CString sBase;
sBase.Format(_T("%s%d"), (LPCTSTR)getTempFileNameBase(status), status.m_iProcNumber);
#else // hab245
CString sBase = getTempFileNameBase(status);
#endif // hab245
m_sOutPath = status.makeTempPath(sBase, _T(".ana") );
m_sLOGPath = status.makeTempPath(sBase, _T(".log") );
m_sInPath = status.sANAPath;
m_sOutPath.deleteFile();
m_sLOGPath.deleteFile();
hr = CoInitialize(NULL);
#ifndef hab245
checkResults(hr, _T("coinitialize"), (IPatrParser *)NULL);
hr = CLSIDFromProgID(L"SIL.CARLA.PatrParser.1", &clsid);
checkResults(hr, _T("get CLSID"), (IPatrParser *)NULL);
hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL,
IID_IPatrParser, (void **) &pPatr);
checkResults(hr, _T("do CoCreateInstance"), (IPatrParser *)NULL);
CString s = m_sLOGPath.getQuotedPath();
CString sLogFile = s.Mid(1, s.GetLength()-2);
hr = pPatr->OpenLog(sLogFile.AllocSysString());
checkResults(hr, _T("set log file"), (IPatrParser *)NULL);
hr = pPatr->Clear();
checkResults(hr, _T("clear"), pPatr);
hr = pPatr->put_CommentChar(status.getInputMFS()->getCommentChar());
checkResults(hr, _T("set comment character"), pPatr);
hr = pPatr->put_AmplePropertyIsFeature(m_bAmplePropertyIsFeature);
checkResults(hr, _T("set AmplePropertyIsFeature"), pPatr);
hr = pPatr->put_PromoteDefaultAtoms(m_bPromoteDefaultAtomicValues);
checkResults(hr, _T("set PromoteDefaultAtoms"), pPatr);
hr = pPatr->put_Failures(m_bShowFailures);
checkResults(hr, _T("set Failures"), pPatr);
hr = pPatr->put_DisplayFeatures(m_bDisplayFeatures);
checkResults(hr, _T("set DisplayFeatures"), pPatr);
hr = pPatr->put_TopFeatureOnly(!m_bAllFeatures);
checkResults(hr, _T("set TopFeatureOnly"), pPatr);
hr = pPatr->put_Gloss(m_bDisplayGloss);
checkResults(hr, _T("set Gloss"), pPatr);
hr = pPatr->put_TrimEmptyFeatures(m_bTrimEmptyFeatures);
checkResults(hr, _T("set TrimEmptyFeatures"), pPatr);
hr = pPatr->put_Unification(m_bPerformUnification);
checkResults(hr, _T("set Unification"), pPatr);
hr = pPatr->put_WriteAmpleParses(m_bWriteAmpleParses);
checkResults(hr, _T("set WriteAmpleParses"), pPatr);
hr = pPatr->put_MaxAmbiguity(m_uiMaxAmbiguities);
checkResults(hr, _T("set MaxAmbiguity"), pPatr);
#ifndef rde273
hr = pPatr->put_CodePage(GetCSAcp());
#endif // rde273
hr = pPatr->put_SentenceFinalPunctuation(
m_sSentenceFinalPunctuation.AllocSysString());
checkResults(hr, _T("set SentenceFinalPunctuation"), pPatr);
hr = pPatr->put_TimeLimit(m_uiTimeLimit);
checkResults(hr, _T("set TimeLimit"), pPatr);
hr = pPatr->put_TreeDisplay(m_iTreeDisplayFormat);
checkResults(hr, _T("set TreeDisplay"), pPatr);
hr = pPatr->put_FlatFeatureDisplay(m_bFlatFeatureDisplay);
checkResults(hr, _T("set FlatFeatureDisplay"), pPatr);
#ifndef hab262
if (m_iRootGlossSetting > 0)
m_iRootGlossSetting++; // need to adjust value to get correct setting
hr = pPatr->put_RootGlossFeature(m_iRootGlossSetting);
if (m_iRootGlossSetting > 0)
m_iRootGlossSetting--; // adjust the value back
checkResults(hr, _T("set RootGlossFeature"), pPatr);
#endif // hab262
hr = pPatr->LoadGrammarFile(m_sGrammarFileName.AllocSysString());
checkResults(hr, _T("load grammar file.\nSee Log File."), pPatr);
s = m_sOutPath.getQuotedPath();;
CString sOutFile = s.Mid(1, s.GetLength()-2);
hr = pPatr->DisambiguateAnaFile(m_sInPath.getShortPath().AllocSysString(),
sOutFile.AllocSysString());
checkResults(hr, _T("disambiguate ANA file"), pPatr);
hr = pPatr->CloseLog();
checkResults(hr, _T("close log file"), pPatr);
#else // hab245
checkResults(hr, _T("coinitialize"));
hr = CLSIDFromProgID(L"SIL.CARLA.PatrParser.1", &clsid);
checkResults(hr, "get CLSID");
hr = CoCreateInstance(clsid, NULL, CLSCTX_ALL,
IID_IPatrParser, (void **) &pPatr);
checkResults(hr, "do CoCreateInstance");
hr = pPatr->Clear();
checkResults(hr, "clear");
hr = pPatr->put_CommentChar(status.getInputMFS()->getCommentChar());
checkResults(hr, "set comment character");
hr = pPatr->put_AmplePropertyIsFeature(m_bAmplePropertyIsFeature);
checkResults(hr, "set AmplePropertyIsFeature");
hr = pPatr->put_PromoteDefaultAtoms(m_bPromoteDefaultAtomicValues);
checkResults(hr, "set PromoteDefaultAtoms");
hr = pPatr->put_Failures(m_bShowFailures);
checkResults(hr, "set Failures");
hr = pPatr->put_DisplayFeatures(m_bDisplayFeatures);
checkResults(hr, "set DisplayFeatures");
hr = pPatr->put_TopFeatureOnly(!m_bAllFeatures);
checkResults(hr, "set TopFeatureOnly");
hr = pPatr->put_Gloss(m_bDisplayGloss);
checkResults(hr, "set Gloss");
hr = pPatr->put_TrimEmptyFeatures(m_bTrimEmptyFeatures);
checkResults(hr, "set TrimEmptyFeatures");
hr = pPatr->put_Unification(m_bPerformUnification);
checkResults(hr, "set Unification");
hr = pPatr->put_WriteAmpleParses(m_bWriteAmpleParses);
checkResults(hr, "set WriteAmpleParses");
hr = pPatr->put_MaxAmbiguity(m_uiMaxAmbiguities);
checkResults(hr, "set MaxAmbiguity");
hr = pPatr->put_SentenceFinalPunctuation(
m_sSentenceFinalPunctuation.AllocSysString());
checkResults(hr, "set SentenceFinalPunctuation");
hr = pPatr->put_TimeLimit(m_uiTimeLimit);
checkResults(hr, "set TimeLimit");
hr = pPatr->put_TreeDisplay(m_iTreeDisplayFormat);
checkResults(hr, "set TreeDisplay");
hr = pPatr->put_FlatFeatureDisplay(m_bFlatFeatureDisplay);
checkResults(hr, "set FlatFeatureDisplay");
hr = pPatr->LoadGrammarFile(m_sGrammarFileName.AllocSysString());
checkResults(hr, "load grammar file");
CString s = m_sLOGPath.getQuotedPath();
CString sLogFile = s.Mid(1, s.GetLength()-2);
hr = pPatr->OpenLog(sLogFile.AllocSysString());
checkResults(hr, "set log file");
s = m_sOutPath.getQuotedPath();;
CString sOutFile = s.Mid(1, s.GetLength()-2);
hr = pPatr->DisambiguateAnaFile(m_sInPath.getShortPath().AllocSysString(),
sOutFile.AllocSysString());
checkResults(hr, "disambiguate ANA file");
hr = pPatr->CloseLog();
checkResults(hr, "close log file");
#endif // hab245
pPatr->Release();
pPatr = NULL;
CoUninitialize();
waitForCompletion(&status, &m_sLOGPath, &m_sOutPath);
// register ana output so the user can view it
CString sShortDesc, sLongDesc, sTabLabel;
CCarlaLanguage *pOutANALang=NULL;
sShortDesc = "PC-PATR Disambiguated ANA";
sLongDesc = "ANA of the source-language file, after filtering through PC-PATR Syntactic Grammar rules.";
sTabLabel = "PATR-Disamb ANA";
pOutANALang = status.getInputLang();
CResultStreamFile* anaStream =
new CResultStreamFile(
new CResultStreamDescriptor(this,
sShortDesc, //short description
sLongDesc, // long description
sTabLabel // tab label
),
m_sOutPath.getFullPath(),
pOutANALang);
status.registerResultStream(anaStream);
registerLog(status, m_sLOGPath, status.getInputLang());
status.sANAPath = m_sOutPath;
}
catch(CProcessFailure failure)
{
registerLog(status, m_sLOGPath);
throw(failure);
}
catch(CString sError)
{
registerLog(status, m_sLOGPath);
throw(CProcessFailure(this, sError));
}
}
// Funcao para Tolerar Falha do Mestre
int agoFaultToleranceWorker(agoDataPackageStr * agoDataPackageWorker, unsigned int *ui_workerList, int *listi_packageId,
int i_masterId, int numBlocks, double *d_workerTime, agoLogStr *agoLog)
{
char c_fileName[32];
int i_aux1 = 0, numPackageDone = 0, i_workerId = 1, i_signalFlag = 0, idFail = 0,
i_packageId = 0, i_countPackageDone = 0, offSetidPackage = 0, i_numBlocksOrig = NUM_BLOCKS;
unsigned int i_sync1 = 0, i_sync2 = 0;
double faultTime = 0.0;
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Iniciando Procedimento de Tolerancia a Falhas");
registerLog(agoLog, i_myidWorker);
i_masterId = masterFail_ago_ft = 1;
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Lista de Pacotes Processados neste Worker (Total %d) - (VERBOSE)",
QUANT_BLOCKS);
registerLog(agoLog, i_myidWorker);
#endif
i_aux1 = 1;
while (i_aux1 <= NUM_BLOCKS) {
if (listi_packageId[i_aux1] > 0) {
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Pacote id %d (%d) foi processado neste Worker (%d)",
listi_packageId[i_aux1], i_aux1, i_myidWorker);
registerLog(agoLog, i_myidWorker);
i_countPackageDone = i_countPackageDone + 1;
}
i_aux1++;
}
if (i_myidWorker == 1) { // Novo Mestre-Worker
Matrix *d_matrixA, *d_matrixB, *d_matrixC;
unsigned int timeSignal = 0;
double d_countBlock = 0.0, da_workerTime[4] = {0, 0, 0, 0};
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Assumindo a Tarefa do Master no Tempo %f", (MPI_Wtime() - *d_workerTime));
registerLog(agoLog, i_myidWorker);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Quantidade Workers: %d", (i_numprocsWorker - 2));
registerLog(agoLog, i_myidWorker);
// Aloca Memoria para as Matrizes
d_matrixA = (Matrix *) calloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE), sizeof(double));
d_matrixB = (Matrix *) calloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE), sizeof(double));
d_matrixC = (Matrix *) calloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE), sizeof(double));
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Alocado Memoria para as Matrizes");
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
if ((d_matrixA == NULL) || (d_matrixB == NULL) || (d_matrixC == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(agoWorkerProcess) - Erro Alocando Mem. Matrizes (A, B, C) - VERBOSE");
registerLog(agoLog, i_myidWorker);
}
#endif
// Cria as Matrizes a serem Calculadas pelos Workers
matrixLoad(d_matrixA, d_matrixB, (MAX_MATRIX_SIZE * MAX_MATRIX_SIZE), agoLog);
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"(agoFaultToleranceWorker) - Lista de Pacotes Processados neste Worker (Total %d) - (VERBOSE)",
QUANT_BLOCKS);
registerLog(agoLog, i_myidWorker);
#endif
i_workerId = 1;
while (i_workerId < NUM_WORKERS) {
workerStatus_ago_ft[i_workerId] = 1;
i_workerId++;
}
// Inicia Contagem de Tempo do Worker-Master
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aqui comeca a Contar o Tempo do --> Novo Mestre (Worker) <--");
registerLog(agoLog, i_myidWorker);
faultTime = MPI_Wtime();
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Requisitando Informacoes dos Workers");
registerLog(agoLog, i_myidWorker);
agoSendRepeatToWorker(ui_workerList, NUM_WORKERS, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aguardando Informacoes dos Workers");
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Recebendo Informacoes dos Workers - (VERBOSE)");
registerLog(agoLog, i_myidWorker);
#endif
i_workerId = 2;
while (i_workerId < i_numprocsWorker) {
numPackageDone = (numPackageDone + agoRecvInfoFromWorker(i_workerId, agoLog));
registerLog(agoLog, i_myidWorker);
i_workerId++;
}
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Workers informaram que %d Pacotes foram completados", numPackageDone);
registerLog(agoLog, i_myidWorker);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aguardando Pacotes Processados nos Workers");
registerLog(agoLog, i_myidWorker);
i_packageId = 1;
while (i_packageId <= numPackageDone) {
i_workerId = 2;
while (i_workerId < i_numprocsWorker) {
agoRecvDataFromWorkerFT(agoDataPackageWorker, d_matrixC, ui_workerList, i_workerId, i_myidWorker, agoLog);
i_workerId++;
i_packageId++;
d_countBlock++;
agoGetCount(&timeSignal, i_numBlocksOrig, d_countBlock, faultTime, da_workerTime, i_myidWorker, agoLog);
}
}
offSetidPackage = ((numPackageDone + i_countPackageDone) + 1);
numBlocks = ((numBlocks - numPackageDone) - i_countPackageDone);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Faltam %d Blocos a serem distribuidos/processados", numBlocks);
registerLog(agoLog, i_myidWorker);
while (numBlocks) {
// Sinaliza Inicio de Trabalho aos Workers
agoSignalWorkers(ui_workerList, i_numprocsWorker, FLAG_START, 2, i_myidWorker, workerStatus_ago_ft, agoLog);
// Envio de Dados para Trabalhadores
agoSendDataToWorker(agoDataPackageWorker, i_numBlocksOrig, d_matrixA, d_matrixB, &offSetidPackage, ui_workerList, i_numprocsWorker,
2, idFail, i_myidWorker, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - %d Bloco(s) Distribuido(s) para os Workers (%d)",
(i_numprocsWorker - 2), (i_numprocsWorker - 2));
registerLog(agoLog, i_myidWorker);
i_workerId = 2;
while (i_workerId < i_numprocsWorker) {
agoRecvDataFromWorkerFT(agoDataPackageWorker, d_matrixC, ui_workerList, i_workerId, i_myidWorker, agoLog);
i_workerId++;
d_countBlock++;
agoGetCount(&timeSignal, i_numBlocksOrig, d_countBlock, faultTime, da_workerTime, i_myidWorker, agoLog);
}
numBlocks = numBlocks - (i_numprocsWorker - 2);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Faltam %d Bloco(s) a serem Distribuido(s) para os Workers (%d)",
numBlocks, (i_numprocsWorker - 2));
registerLog(agoLog, i_myidWorker);
if ((numBlocks < (i_numprocsWorker - 2)) && (numBlocks > 0)) {
if (i_sync1 == 0) {
i_sync1 = i_sync2 = (numBlocks + 2);
// Sinaliza Inicio de Trabalho aos Workers
agoSignalWorkers(ui_workerList, i_sync2, FLAG_START, 2, i_myidWorker, workerStatus_ago_ft, agoLog);
// Envio de Dados para Trabalhadores
agoSendDataToWorker(agoDataPackageWorker, i_numBlocksOrig, d_matrixA, d_matrixB, &offSetidPackage, ui_workerList,
i_sync2, 2, idFail, i_myidWorker, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - %d Bloco(s) Distribuido(s) para os Workers (%d)",
(i_sync2 - 1), (i_sync2 - 1));
registerLog(agoLog, i_myidWorker);
i_workerId = 2;
while (i_workerId < (int) i_sync2) {
agoRecvDataFromWorkerFT(agoDataPackageWorker, d_matrixC, ui_workerList, i_workerId, i_myidWorker, agoLog);
i_workerId++;
}
}
numBlocks = 0;
}
}
// Termino Contagem de Tempo do Worker-Master
faultTime = (MPI_Wtime() - faultTime);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aqui Termina de Contar o Tempo do --> Novo Mestre (WORKER) <--");
registerLog(agoLog, i_myidWorker);
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"(FT) - Tempo de Processamento\n - Tempo 25%%: %f\n - Tempo 50%%: %f\n - Tempo 75%%: %f\n - Tempo 95%%: %f",
da_workerTime[PERCENT_25], da_workerTime[PERCENT_50], da_workerTime[PERCENT_75], da_workerTime[PERCENT_95]);
registerLog(agoLog, i_myidWorker);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Tempo da Tolerancia a Falha (Worker-Master): %f", faultTime);
registerLog(agoLog, i_myidWorker);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Enviando Finalizacao aos Workers");
registerLog(agoLog, i_myidWorker);
i_signalFlag = FLAG_STOP;
agoSignalWorkers(ui_workerList, i_numprocsWorker, FLAG_STOP, 2, i_myidWorker, workerStatus_ago_ft, agoLog);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Liberando Memoria Alocada (A, B, C) - (VERBOSE)");
registerLog(agoLog, i_myidWorker);
#endif
free(d_matrixA);
free(d_matrixB);
free(d_matrixC);
} // Fim novo Mestre
else { // Inicio Workers Assumindo Novo Mestre
Matrix *d_d_matrixChunkA, *d_d_matrixChunkB, *d_d_matrixChunkC;
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Novo Master id %d - Enviando Informacoes", i_masterId);
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"(agoFaultToleranceWorker) - Enviando Informacoes (%d) ao Novo Master - (VERBOSE)", i_countPackageDone);
registerLog(agoLog, i_myidWorker);
#endif
agoSendInfoToMasterFT(i_countPackageDone, i_myidWorker, i_masterId, agoLog);
registerLog(agoLog, i_myidWorker);
d_d_matrixChunkC = (Matrix *) calloc ((CHUNKSIZE * MAX_MATRIX_SIZE), sizeof(double));
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Alocado Memoria para a Matriz C");
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
if (d_d_matrixChunkC == NULL) {
snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Erro Alocando Mem. Matrizes (C) - VERBOSE");
registerLog(agoLog, i_myidWorker);
}
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Enviando Pacotes armazenados (%d) para o Mestre-Trabalhador: %d",
i_countPackageDone, i_masterId);
registerLog(agoLog, i_myidWorker);
i_packageId = 1;
while (i_packageId <= i_countPackageDone) {
(void) snprintf(c_fileName, LOG_SIZE, "d_matrixC%d", agoDataPackageWorker[listi_packageId[i_packageId]].id);
matrixReadFromFile(c_fileName, d_d_matrixChunkC, (CHUNKSIZE * MAX_MATRIX_SIZE), i_myidWorker, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Carregado do disco package id %d (%d - %d) - arquivo matriz c %s",
agoDataPackageWorker[listi_packageId[i_packageId]].id, listi_packageId[i_packageId], i_packageId, c_fileName);
registerLog(agoLog, i_myidWorker);
agoSendDataToMasterFT(&agoDataPackageWorker[listi_packageId[i_packageId]], d_d_matrixChunkC, i_masterId, i_myidWorker, agoLog);
i_packageId++;
}
free(d_d_matrixChunkC);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Liberada Memoria Matriz C - VERBOSE");
registerLog(agoLog, i_myidWorker);
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Fim Primeira Fase");
registerLog(agoLog, i_myidWorker);
d_d_matrixChunkA = (Matrix *) calloc ((CHUNKSIZE * MAX_MATRIX_SIZE), sizeof(double));
d_d_matrixChunkB = (Matrix *) calloc ((CHUNKSIZE * MAX_MATRIX_SIZE), sizeof(double));
d_d_matrixChunkC = (Matrix *) calloc ((CHUNKSIZE * MAX_MATRIX_SIZE), sizeof(double));
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Alocado Memoria para as Matrizes (Chunk: A, B e C)");
registerLog(agoLog, i_myidWorker);
#ifdef VERBOSE
if ((d_d_matrixChunkA == NULL) || (d_d_matrixChunkB == NULL) || (d_d_matrixChunkC == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Erro Alocando Mem. Matrizes (A, B, C) - VERBOSE");
registerLog(agoLog, i_myidWorker);
}
#endif
while (i_signalFlag) {
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aguardando Pacotes do Mestre");
registerLog(agoLog, i_myidWorker);
i_packageId = agoRecvDataFromMaster(agoDataPackageWorker, i_numBlocksOrig, d_d_matrixChunkA, d_d_matrixChunkB, i_masterId, i_myidWorker, agoLog);
registerLog(agoLog, i_myidWorker);
// Multiplicao de Matrizes (Calcular Tempo)
(void) matrixMultiplyParallel(d_d_matrixChunkA, d_d_matrixChunkB, d_d_matrixChunkC,
agoDataPackageWorker[i_packageId].id,
agoDataPackageWorker[i_packageId].offSetA,
agoDataPackageWorker[i_packageId].offSetB,
agoDataPackageWorker[i_packageId].chunkToCalc,
i_myidWorker, agoLog);
agoSendDataToMasterFT(&agoDataPackageWorker[i_packageId], d_d_matrixChunkC, i_masterId, i_myidWorker, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Aguardando Novas Instrucoes");
registerLog(agoLog, i_myidWorker);
i_signalFlag = agoWaitMasterEnd(i_masterId, agoLog);
} // Fim Workers Assumindo Novo Mestre
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoFaultToleranceWorker) - Liberando (free) Memoria Alocada (Chunk: A, B e C) - (VERBOSE)");
registerLog(agoLog, i_myidWorker);
#endif
free(d_d_matrixChunkA);
free(d_d_matrixChunkB);
free(d_d_matrixChunkC);
}
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Finalizando procedimentos de tolerancia a falhas");
registerLog(agoLog, i_myidWorker);
return(i_signalFlag);
}
void matrixCreate(Matrix *matrixA, Matrix *matrixB, int sizeMatrix, int id, agoLogStr *agoLog)
{
int i = 0, j = 0, i_numItems[2] = {0, 0};
FILE *fdA, *fdB;
// Caso nao exista as Matrizes - Crie
if (fopen(FILE_NAME_MATRIX_A, "r") == NULL) {
snprintf(agoLog->logMsg, LOG_SIZE, "Arquivo de Matriz nao Encontrado - Criando");
registerLog(agoLog, id);
fdA = fopen(FILE_NAME_MATRIX_A, "w+");
fdB = fopen(FILE_NAME_MATRIX_B, "w+");
#ifdef VERBOSE
if ((fdA == NULL) || (fdB == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Erro ao Carregar Arquivos de Matrizes (%s, %s) - (VERBOSE)"
FILE_NAME_MATRIX_A, FILE_NAME_MATRIX_B, FILE_NAME_MATRIX_B);
registerLog(agoLog, id);
}
#endif
for (i = 0; i < MAX_MATRIX_SIZE; i++) {
for (j = 0; j < MAX_MATRIX_SIZE; j++) {
matrixA[i][j] = 2.0 + (double) (100.0 * rand() / (RAND_MAX + 1.0));
matrixB[i][j] = 2.0 + (double) (100.0 * rand() / (RAND_MAX + 1.0));
}
}
#ifdef VERBOSE
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Matrizes (A, B) Criadas em Memoria - (VERBOSE)");
registerLog(agoLog, id);
#endif
i_numItems[0] = fwrite(matrixA, sizeof(double), sizeMatrix, fdA);
i_numItems[1] = fwrite(matrixB, sizeof(double), sizeMatrix, fdB);
#ifdef VERBOSE
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Arq. das Matrizes (A, B) Salvo em Disco (%s (%d), %s (%d)) - VERBOSE",
FILE_NAME_MATRIX_A, i_numItems[0], FILE_NAME_MATRIX_B, i_numItems[1]);
registerLog(agoLog, id);
#endif
fclose(fdA);
fclose(fdB);
} else {
snprintf(agoLog->logMsg, LOG_SIZE, "Arquivo de Matriz Encontrado - Carregando do Arquivo - (VERBOSE)");
fdA = fopen(FILE_NAME_MATRIX_A, "r");
fdB = fopen(FILE_NAME_MATRIX_B, "r");
#ifdef VERBOSE
if ((fdA == NULL) || (fdB == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Erro Carregando Arquivos (%s, %s)",
FILE_NAME_MATRIX_A, FILE_NAME_MATRIX_B);
registerLog(agoLog, id);
}
#endif
i_numItems[0] = fread(matrixA, sizeof(double), sizeMatrix, fdA);
i_numItems[1] = fread(matrixB, sizeof(double), sizeMatrix, fdB);
#ifdef VERBOSE
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Arq. das Matrizes (A, B) Carregados (%s (%d), %s (%d)) - VERBOSE",
FILE_NAME_MATRIX_A, i_numItems[0], FILE_NAME_MATRIX_B, i_numItems[1]);
registerLog(agoLog, id);
#endif
fclose(fdA);
fclose(fdB);
#ifdef VERBOSE
snprintf(agoLog->logMsg, LOG_SIZE, "(matrixCreate) - Matrizes Carregadas - (VERBOSE)");
registerLog(agoLog, id);
#endif
}
}
//====================================
void statusLog()
//====================================
{
int x,n,i,in_out;
char z[200];
int tempA[MAX_PIN_ANALOG_MEGA];
int tempD[MAX_PIN_DIGITAL_MEGA];
int tempM[MAX_PIN_DIGITAL_MEGA];
int pinA[MAX_PIN_ANALOG_MEGA];
int pinD[MAX_PIN_DIGITAL_MEGA];
int pinM[MAX_PIN_DIGITAL_MEGA];
tempA[0] = 0;
tempD[0] = 0;
for(i=0;i<=max_anaPin;i++)
{
tempA[i] = 0;
pinA[i] = 0;
}
for(i=0;i<=max_digPin;i++)
{
tempD[i] = 0;
pinD[i] = 0;
}
// step,status dig pins, dig pin value, n ana pair, n PWM dig pair, ( pairs)
// Value status of analog pins
n = 0;
for(i=0;i<=max_anaPin;i++)
{
x = c_analogPin[i];
if(x != 0)
{
n++;
tempA[0] = n;
tempA[n] = x;
pinA[n] = i;
}
}
// Value status of digital pins
n = 0;
for(i=0;i<=max_digPin;i++)
{
if(g_boardType==MEGA)x = c_digitalPin[i];
if(g_boardType==UNO)x = readRegister(R_PORT,i);
if(x > 0)
{
n++;
tempD[0] = n;
tempD[n] = x;
pinD[n] = i;
}
}
strcpy(z,"");
// Mode status of digital pins
for(i=0;i<=max_digPin;i++)
{
if(g_boardType==UNO)
{
in_out = readRegister(R_DDR,i);
if(in_out == 0)z[i] ='I';
if(in_out == 1)z[i] ='o';
}
else // MEGA
{
if(digitalMode[i]==INPUT)
{
in_out = 0;
z[i] ='I';
}
if(digitalMode[i]==OUTPUT)
{
in_out = 1;
z[i] ='o';
}
}
x = digitalMode[i];
if(in_out == 0) // INPUT
{
if(x == FREE)z[i] ='-';
else if(x == CHANGE)z[i] ='C';
else if(x == RISING)z[i] ='R';
else if(x == FALLING)z[i] ='F';
else if(x == LOW)z[i] ='L';
else if(x == RX)z[i] ='X';
else if(x == TX)z[i] ='Y';
//else z[i] = 'Q';
}
else // OUTPUT
{
if(x == FREE)z[i] ='-';
else if(x == CHANGE)z[i] ='c';
else if(x == RISING)z[i] ='r';
else if(x == FALLING)z[i] ='f';
else if(x == LOW)z[i] ='l';
else if(x == RX)z[i] ='x';
else if(x == TX)z[i] ='y';
//else z[i] = 'q';
}
}
z[i]='\0';
fprintf(s_log,"%d,%s,%d,%d",g_curStep,z,tempA[0],tempD[0]);
if(tempA[0] > 0)
{
for(i=1;i<=tempA[0];i++)fprintf(s_log,",%d,%d",pinA[i],tempA[i]);
}
if(tempD[0] > 0)
{
for(i=1;i<=tempD[0];i++)fprintf(s_log,",%d,%d",pinD[i],tempD[i]);
}
fprintf(s_log,"\n");
registerLog();
}
void *agoMasterProcess()
{
int i_workerId = 1, i_numBlocks = (NUM_BLOCKS - 1), i_offSetidPackage = 1, i_numBlocksOrig = NUM_BLOCKS, i_idFail = 0;
unsigned int ui_sync1 = 0, ui_sync2 = 0, ui_loopMaster = FLAG_START, ui_timeSignal = 0, ui_workerList[NUM_WORKERS];
double d_masterTime100 = 0.0, da_masterTime[4] = {0, 0, 0, 0}, d_countBlock = 0.0;
#if TURN_ON_OFF_FAIL == 1
int i_idFailTmp = 0, i_falhaPerc = 0;
double d_timeFail = 0.0;
#endif
Matrix *d_matrixA, *d_matrixB, *d_matrixC;
agoDataPackageStr *agoDataPackageMaster;
agoLogStr *agoLog;
agoLog = (agoLogStr *) malloc (sizeof(agoLogStr));
agoDataPackageMaster = (agoDataPackageStr *) calloc (sizeof(agoDataPackageStr), NUM_BLOCKS);
#ifdef VERBOSE
if ((agoDataPackageMaster == NULL) || (agoLog == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Erro Alocando Mem. agoDataPackageMaster ou agoLog - VERBOSE");
registerLog(agoLog, si_myidMaster);
}
#endif
startLog(agoLog, si_myidMaster);
// Inicia o Pacote de Dados a serem processados
// Informacoes Gerais do Processamento / Inicializando o Mestre
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"Tamanho Matriz: %d - Tamanho Pacote (Chunk): %d - Num de Pacotes: %d - Quantidade Workers: %d",
MAX_MATRIX_SIZE, CHUNKSIZE, i_numBlocks, (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"Tamanho Matriz: %d - %d bytes", sizeof(*d_matrixA), sizeof(*d_matrixB));
registerLog(agoLog, si_myidMaster);
#endif
// Aloca Memoria para as Matrizes
d_matrixA = (Matrix *) malloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE) * sizeof(double));
d_matrixB = (Matrix *) malloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE) * sizeof(double));
d_matrixC = (Matrix *) malloc ((MAX_MATRIX_SIZE * MAX_MATRIX_SIZE) * sizeof(double));
snprintf(agoLog->logMsg, LOG_SIZE, "Alocado Memoria para as Matrizes");
registerLog(agoLog, si_myidMaster);
#ifdef VERBOSE
if ((d_matrixA == NULL) || (d_matrixB == NULL) || (d_matrixC == NULL)) {
snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Erro Alocando Mem. Matrizes (A, B, C) - VERBOSE");
registerLog(agoLog, si_myidMaster);
}
#endif
matrixCreate(d_matrixA, d_matrixB, (MAX_MATRIX_SIZE * MAX_MATRIX_SIZE), si_myidMaster, agoLog);
#if TURN_ON_OFF_FAIL == 1
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Tolerancia a Falhas Ativo - Mandando Sinal para %s\n", MASTER_ADDR_AGO_FT);
registerLog(agoLog, si_myidMaster);
#else
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Tolerancia a Falhas Nao Ativo\n");
registerLog(agoLog, si_myidMaster);
#endif
// Informacoes Gerais do Processamento / Inicializando o Mestre
agoInitDataPackage(agoDataPackageMaster, NUM_BLOCKS, si_myidMaster, agoLog);
i_workerId = 1;
while (i_workerId < i_offSetidPackage) {
agoDataPackageMaster[i_workerId].status = FLAG_DONE;
i_workerId++;
}
ui_workerList[0] = 0;
// Lista de Trabalhadores
while (i_workerId < si_numprocsMaster) {
ui_workerList[i_workerId] = i_workerId;
i_workerId++;
}
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoWorkerProcess) - Lista de Workers Concluida %d (%d) - (VERBOSE)",
i_workerId, si_numprocsMaster);
registerLog(agoLog, si_myidMaster);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Numero de Blocos %d - (VERBOSE)", i_numBlocks);
registerLog(agoLog, si_myidMaster);
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Iniciando Contagem do Tempo do Mestre Local");
registerLog(agoLog, si_myidMaster);
// Inicio Contagem de Tempo do Processo Mestre
d_masterTime100 = MPI_Wtime();
// Inicio Tarefa Mestre
do {
while (i_numBlocks) {
// Sinaliza Inicio de Trabalho aos Workers
agoSignalWorkers(ui_workerList, NUM_WORKERS, FLAG_START, 1, si_myidMaster, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Iniciando Envio de Pacotes para Workers (%d)\n", (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
// Envio de Dados para Trabalhadores
agoSendDataToWorker(agoDataPackageMaster, i_numBlocksOrig, d_matrixA, d_matrixB, &i_offSetidPackage,
ui_workerList, NUM_WORKERS, 1, i_idFail, si_myidMaster, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Bloco(s) Distribuido(s) para os Workers (%d)\n", (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
#if TURN_ON_OFF_FAIL == 1
if (i_idFail > 0) {
i_falhaPerc = ui_timeSignal;
d_timeFail = (MPI_Wtime() - d_masterTime100);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Introducao da Falha Completa - worker id %d no tempo %f", i_idFail, d_timeFail);
registerLog(agoLog, si_myidMaster);
sleep(WAIT_TIME_FAIL_AGO_FT);
d_masterTime100 = (d_masterTime100 - WAIT_TIME_FAIL_AGO_FT);
i_idFailTmp = i_idFail;
i_idFail = 0;
}
#endif
i_workerId = 1;
while (i_workerId < si_numprocsMaster) {
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - worker id %d (%d) - (VERBOSE)",
i_workerId, ui_workerList[i_workerId]);
registerLog(agoLog, si_myidMaster);
#endif
agoRecvDataFromWorker(agoDataPackageMaster, d_matrixC, ui_workerList, si_myidMaster, agoLog);
d_countBlock++;
i_workerId++;
agoGetCount(&ui_timeSignal, i_numBlocksOrig, d_countBlock, d_masterTime100, da_masterTime, si_myidMaster, agoLog);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Blocos Recebidos %f - worker id %d - (VERBOSE)",
d_countBlock, i_workerId);
registerLog(agoLog, si_myidMaster);
#endif
}
i_numBlocks = i_numBlocks - (si_numprocsMaster - 1);
#if TURN_ON_OFF_FAIL == 1
if (reconfigWorker_ago_ft == 1) {
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(FT) - Ocorreu uma Falha: %d Ativos", (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
}
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Faltam %d Bloco(s) a serem Distribuido(s) para os Workers (%d)\n",
i_numBlocks, (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
if ((i_numBlocks < (si_numprocsMaster - 1)) && (i_numBlocks > 0)) {
if ((ui_sync1 == 0)
#if TURN_ON_OFF_FAIL == 1
&& (reconfigWorker_ago_ft == 0)
#endif
) {
ui_sync1 = ui_sync2 = (i_numBlocks + 1);
agoSignalWorkers(ui_workerList, ui_sync2, FLAG_START, 1, si_myidMaster, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Iniciando Envio de Pacotes para Workers (%d)\n", (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
i_idFail = 0;
agoSendDataToWorker(agoDataPackageMaster, i_numBlocksOrig, d_matrixA, d_matrixB, &i_offSetidPackage,
ui_workerList, ui_sync2, 1, i_idFail, si_myidMaster, workerStatus_ago_ft, agoLog);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Bloco(s) Distribuido(s) para os Workers (%d)\n", (si_numprocsMaster - 1));
registerLog(agoLog, si_myidMaster);
i_workerId = 1;
while (i_workerId < (int) ui_sync2) {
agoRecvDataFromWorker(agoDataPackageMaster, d_matrixC, ui_workerList, si_myidMaster, agoLog);
d_countBlock++;
i_workerId++;
agoGetCount(&ui_timeSignal, i_numBlocksOrig, d_countBlock, d_masterTime100, da_masterTime, si_myidMaster, agoLog);
}
i_numBlocks = 0;
}
#if TURN_ON_OFF_FAIL == 1
if (reconfigWorker_ago_ft == 1) {
i_numBlocks = 0;
}
#endif
}
#if TURN_ON_OFF_FAIL == 1
i_idFail = agoPutFaultOnWorker(ui_timeSignal, agoLog);
#endif
}
// Termina o Thread para Verificar Falhas atraves de Socket
#if TURN_ON_OFF_FAIL == 1
syncWorker_ago_ft = waitWorker_ago_ft = FLAG_STOP;
#endif
// Se foi detectado erro (reconfigWorker_ago_ft = 1) reconfigure o Cluster
#if TURN_ON_OFF_FAIL == 1
if (reconfigWorker_ago_ft == 1) {
agoReconfigCluster(agoDataPackageMaster, d_matrixA, d_matrixB, d_matrixC, ui_workerList, i_numBlocksOrig, agoLog);
}
#endif
ui_loopMaster = FLAG_STOP;
} while (ui_loopMaster);
agoSignalWorkers(ui_workerList, NUM_WORKERS, FLAG_STOP, 1, si_myidMaster, workerStatus_ago_ft, agoLog);
// Finaliza Contagem de Tempo do Processo Mestre
d_masterTime100 = (MPI_Wtime() - d_masterTime100);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Finalizado a Contagem do Tempo (%f) do Mestre Local\n", d_masterTime100);
registerLog(agoLog, si_myidMaster);
#if TURN_ON_OFF_FAIL == 1
// Termina o Thread o i_syncMaster (Servidor Sinalizacao)
masterSocketLoop_ago_ft = FLAG_STOP;
#endif
free(d_matrixA);
free(d_matrixB);
free(d_matrixC);
free(agoDataPackageMaster);
#ifdef VERBOSE
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Liberado (free) memoria alocada (A, B, C) - (VERBOSE)");
registerLog(agoLog, si_myidMaster);
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE,
"Tempo de Processamento\n - Tempo 25%%: %f\n - Tempo 50%%: %f\n - Tempo 75%%: %f\n - Tempo 95%%: %f",
da_masterTime[PERCENT_25], da_masterTime[PERCENT_50], da_masterTime[PERCENT_75], da_masterTime[PERCENT_95]);
registerLog(agoLog, si_myidMaster);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Finalizado - Tempo Total Local (100%%): %f", d_masterTime100);
registerLog(agoLog, si_myidMaster);
#if TURN_ON_OFF_FAIL == 1
if (reconfigWorker_ago_ft == 1) {
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Falha no id %d introduzida com (%d%%) do trabalho no tempo: %f",
i_idFailTmp, i_falhaPerc, d_timeFail);
registerLog(agoLog, si_myidMaster);
(void) snprintf(agoLog->logMsg, LOG_SIZE, "Finalizado - Tempo Total (100%%) Com Falha: %f", d_masterTime100);
registerLog(agoLog, si_myidMaster);
}
#endif
#ifdef VERBOSE
#if TURN_ON_OFF_FAIL == 1
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Tolerancia a Falha Ativo - (VERBOSE)");
registerLog(agoLog, si_myidMaster);
#else
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Tolerancia a Falha Nao Ativo - (VERBOSE)");
registerLog(agoLog, si_myidMaster);
#endif
(void) snprintf(agoLog->logMsg, LOG_SIZE, "(agoMasterProcess) - Chamando MPI_Finalize - (VERBOSE)");
registerLog(agoLog, si_myidMaster);
#endif
closeLog(agoLog);
free(agoLog);
return(NULL);
}
// EXCEPTIONS: CProcessFailure
// TO DO: clean up error reporting
// use dialog to say we're busy and give a cancel button
void CPhonruleProcess::processDictionaries(CProcessStatus& status)
{
CPathDescriptor sLOGPath;
try
{
CModelFilesSet* pMFS = NULL;
// do we operate on the src dicts or target dicts?
CTypedPtrArray<CPtrArray, CPathDescriptor*>* pRootUnifiedDicts;
switch(status.m_iCurrentSeqFunction)
{
case CProcess::kAnalysis:
pRootUnifiedDicts = & status.m_pSrcDicts;
pMFS =status.getInputMFS();
if((*pRootUnifiedDicts).GetSize()==0)
throw CProcessFailure(this, _T("There were no source dictionaries specified"));
break;
case CProcess::kSynthesis:
pMFS =status.getOutputMFS();
pRootUnifiedDicts = & status.m_pTarDicts;
if((*pRootUnifiedDicts).GetSize()==0)
throw CProcessFailure(this, _T("There were target dictionaries specified"));
break;
default: // the user should never be able to make this happen
throw CProcessFailure(this, _T("Phonrule should only be called as part of analysis or synthesis"));
}
// combine all runs into one log
sLOGPath = status.makeTempPath(pMFS->getAbrev() + _T("-phrl"), _T(".log"));
sLOGPath.deleteFile();
for(int iRootFileIndex = 0; iRootFileIndex< (*pRootUnifiedDicts).GetSize(); iRootFileIndex++)
{
CString sBaseName = (*pRootUnifiedDicts)[iRootFileIndex]->getFileName() + _T("-phrl");
CPathDescriptor sOutputDictPath = status.makeTempPath(sBaseName,_T(".dic"));
sOutputDictPath.deleteFile();
USES_CONVERSION;
char lpszErrorStr[1000];
BOOL OK = setupProcess(lpszErrorStr,
m_bTrace ||
(status.m_pProcPrefs->m_dwFlags & CProcessingPrefs::kTrace), // jdh 11/11/99
m_bMonitorRules,
m_cCommentChar,
T2CA(pMFS->getPhonrulePath()), // lpszRulesPath
T2CA((*pRootUnifiedDicts)[iRootFileIndex]->getFullPath()), // lpszDictInPath
T2CA(sOutputDictPath.getFullPath()), // lpszDictOutPath
T2CA(sLOGPath.getFullPath()), // lpszLogFilePath
TRUE); // append log
if(!OK)
throw(CProcessFailure(this, A2CT(lpszErrorStr)));
BOOL bError = runProcess();
WIN32_FIND_DATA fileInfo;
if(INVALID_HANDLE_VALUE == FindFirstFile(sOutputDictPath.getFullPath(), &fileInfo))
throw(CProcessFailure(this, _T("Phonrule DLL did not produce the expected dictionary. Check the phonrule log for more information.")));
// change the path so that latter processes will use what we produced
(*(*pRootUnifiedDicts)[iRootFileIndex]) = sOutputDictPath;//.getFullPath();
// make sure these are closed
if(logfile)
fclose(logfile); // this is the same as errlogfile
if(outfile)
fclose(outfile);
}
#ifndef rde279
#pragma message("I don't know if chopping this out is correct, but the logStream being created here is unused so it memory leaks")
#else
CResultStreamFile* logStream =
new CResultStreamFile(
new CResultStreamDescriptor(this,
_T("Phonrule Log"), //short description
_T("Log of this process; read it for status and diagnostics."), // long description
pMFS->getAbrev() + _T(" Phnrl Log")
),
sLOGPath.getFullPath(),
status.getInputLang());
#endif
#ifndef hab241
registerLog(status, sLOGPath, status.getInputLang());
#else // hab241
status.registerResultStream(logStream);
#endif // hab241
}
catch(CProcessFailure failure)
{
if(logfile)
fclose(logfile); // this is the same as errlogfile
if(outfile)
fclose(outfile);
registerLog(status, sLOGPath, status.getInputLang());
throw(failure);
}
catch(CString sError)
{
if(logfile)
fclose(logfile); // this is the same as errlogfile
if(outfile)
fclose(outfile);
registerLog(status, sLOGPath, status.getInputLang());
throw(CProcessFailure(this, sError));
}
}
void CSentransProcess::processANAFile(CProcessStatus& status)
{
// (jdh 6/99) i think this is now defunct; an impossible condition
// if((m_iFunction == kAdjustSrcGlossing)
// && (status.m_pProcPrefs->getGoal() != CProcessingPrefs::kGlossedInterlinear))
// return;
// skip this process if there is nothing to do
switch(m_iFunction)
{
case kDisambig:
if(status.getInputLang()->getSentransDisambigModel().m_rules.getSize() ==0)
return;
break;
case kAdjustSrcGlossing:
if(status.getInputLang()->getSentransGlossAdjustmentModel().m_rules.getSize() ==0)
return;
break;
// JDH 6/2/99 Added Sentrans Adjust Rules Set for analysis
case kAdjustAnalysis:
if(status.getInputLang()->getSentransAnaAdjustmentModel().m_rules.getSize() ==0)
return;
break;
case kOtherRuleFile: // jdh 15June2000
if(!m_sOtherRuleFilePath.fileExists())
{
CString sMsg;
sMsg.Format("The external SENTRANS rule file could not be found.\n\"%s\"", LPCTSTR(m_sOtherRuleFilePath));
AfxMessageBox(sMsg);
return;
}
break;
//case kTransfer:
// haven't handled this because we would have to travers the transfer models (just a little more work, probabl)
}
// remember, we could be operating on ana from any process, including another sentrans process
try
{
CString sBase = getTempFileNameBase(status);
m_sOutPath = status.makeTempPath(sBase, ".ana" );
m_sLOGPath = status.makeTempPath(sBase, ".log" );
m_sInPath = status.sANAPath;
m_sOutPath.deleteFile();
m_sLOGPath.deleteFile();
if(!executeTool(status))
{ throw(CProcessFailure(this, "SentransProccess failed"));
}
waitForCompletion(&status, &m_sLOGPath, &m_sOutPath);
// register ana output so the user can view it
CString sShortDesc, sLongDesc, sTabLabel;
CCarlaLanguage *pOutANALang=NULL;
switch(m_iFunction)
{
case kDisambig:
sShortDesc = "Disambiguated ANA";
sLongDesc = "ANA of the source-language file, after filtering through Sentrans disambiguation rules.";
sTabLabel = "ST-Disamb ANA";
pOutANALang = status.getInputLang();
break;
case kAdjustSrcGlossing: sShortDesc = "Gloss Adjusted ANA";
sLongDesc = "ANA of the source-language file, after performing 'adjustment' transfer for glossing purposes.";
sTabLabel = "ST-Gloss-Adj ANA";
pOutANALang = status.getInputLang();
break;
// JDH 6/2/99 Added Sentrans Adjust Rules Set for analysis
case kAdjustAnalysis: sShortDesc = "Analysis Adjusted ANA";
sLongDesc = "ANA of the source-language file, after performing 'adjustment' transfer for analysis purposes.";
sTabLabel = "ST-Anal-Adj ANA";
pOutANALang = status.getInputLang();
break;
// jdh 15June2000
case kOtherRuleFile: sShortDesc = "Other Rule File ANA";
sLongDesc.Format("ANA of the source-language file, after running through Sentrans using the file: %s",LPCTSTR(m_sOtherRuleFilePath));
sTabLabel = "ST-Anal-Other ANA";
pOutANALang = status.getInputLang();
break;
case kTransfer: sShortDesc = "Transfered ANA";
sLongDesc = "ANA of the target-language file, after performing Sentrans transfer.";
sTabLabel = "ST-Trans ANA";
pOutANALang = status.getOutputLang();
break;
default: ASSERTX(FALSE); break;
}
CResultStreamFile* anaStream =
new CResultStreamFile(
new CResultStreamDescriptor(this,
sShortDesc, //short description
sLongDesc, // long description
sTabLabel // tab label
),
m_sOutPath.getFullPath(),
pOutANALang);
status.registerResultStream(anaStream);
// when we're doing transfer, the log could reasonably be in either language font,
// but what to do?
registerLog(status, m_sLOGPath, status.getInputLang());
status.sANAPath = m_sOutPath;
}
catch(CProcessFailure failure)
{
registerLog(status, m_sLOGPath);
throw(failure);
}
catch(CString sError)
{
registerLog(status, m_sLOGPath);
throw(CProcessFailure(this, sError));
}
}
