int readData( TFiltrParams& filtrParams, int length ) {
in_data = new short[length];
if( readDataFile( in_data, inputFileName, 2*length, 512 ) != 0) {
return 1;
}
if( chan2_is_need(filtrParams) ) {
in2_data = new short[length];
if( readDataFile( in2_data, inputFileName2, 2*length, 512 ) != 0) {
return 1;
}
}
if( chan3_is_need(filtrParams) ) {
in3_data = new short[length];
if( readDataFile( in3_data, inputFileName3, 2*length, 512 ) != 0) {
return 1;
}
}
if( chan4_is_need(filtrParams) ) {
in4_data = new short[length];
if( readDataFile( in4_data, inputFileName4, 2*length, 512 ) != 0) {
return 1;
}
}
if( chan5_is_need(filtrParams) ) {
in5_data = new short[length];
if( readDataFile( in5_data, inputFileName5, 2*length, 512 ) != 0) {
return 1;
}
}
return 0;
}
int inputDriver::setDaemon()
{
procId = fork();
if(procId < 0)
{
exit(EXIT_FAILURE);
}
if(procId > 0)
{
exit(EXIT_SUCCESS);
}
umask(0);
sid = setsid();
if(sid < 0)
{
exit(EXIT_FAILURE);
}
if(chdir("/") < 0)
{
exit(EXIT_FAILURE);
}
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
while(1)
{
readDataFile();
}
return 0;
}
void _initialReadDataFile() {
//char *datfname = (char*)"datafile.dat";
ProgramData *programData = newProgramData();
int i;
if(!readDataFile(datfname, programData, 0)) {
if(programData->version != _instrumentationInfo->id) {
fprintf(stderr, "Data corruption reading file:\n");
fprintf(stderr, " Invalid instrumentation version of existing datafile.\n");
fprintf(stderr, " Remove or rename datafile and try again.\n");
abort();
}
if(programData->opMode==0) {
TRAINING=1; /* set training mode */
} else if(programData->opMode==1) {
TRAINING=0; /* set testing mode */
}
for(i=0; i<MAX_INVARIANTTYPES; i++) {
unsigned int ii;
for(ii=0; ii<INVARIANTTYPE(i).nInvariants; ii++) {
_Invariant *source, *target;
source = &programData->invariantType[i].data[ii];
target = &INVARIANTTYPE(i).data[ii];
if(source->datatype == DATA_TYPE_UNSET) {
continue;
}
target->datatype = source->datatype;
target->usage = source->usage;
target->activatedScreener = source->activatedScreener;
switch(target->datatype) {
case DATA_TYPE_UINT:
target->range.u.min = source->range.u.min;
target->range.u.max = source->range.u.max;
break;
case DATA_TYPE_INT:
target->range.i.min = source->range.i.min;
target->range.i.max = source->range.i.max;
break;
case DATA_TYPE_DOUBLE:
target->range.d.min = source->range.d.min;
target->range.d.max = source->range.d.max;
break;
case DATA_TYPE_PTR:
target->range.p.min = source->range.p.min;
target->range.p.max = source->range.p.max;
break;
default:
fprintf(stderr, "unknown datatype in datafile!\n");
abort();
}
target->bitmask.first = source->bitmask.first;
target->bitmask.mask = source->bitmask.mask;
}
}
}
freeProgramData(programData);
}
XFE_URLDesktopType::XFE_URLDesktopType(FILE *fp)
{
_numItems=0;
_url=NULL;
_title=NULL;
_description=NULL;
_filename=NULL;
readDataFile(fp);
}
EGS_TrackView::EGS_TrackView(const char *filename) {
m_trspFile = NULL;
int err = readDataFile(filename);
if ( err ) return;
m_maxE = 0;
for (int i = 0; i < m_nTracks; i++) {
for (int j = 0; j < m_buffer[i]->getNumVertices(); j++) {
if (m_buffer[i]->getVertex(j)->e > m_maxE)
m_maxE = m_buffer[i]->getVertex(j)->e;
}
}
}
void Menu::performUserAction()
{
showMenu();
int option = askUserOption();
//If the selected option is 1 then we want to read user data from a file
if(option == 1)
readDataFile();
else if(option == 2) //If the selection option is 2 then the user will be able to create a graph in a more intuitive way
createGraphFile();
else if(option == 3)
showFileData();
}
bool FileWatcherThread::scanDataDirectory(size_t voiceNumber) {
File directory(kDatabasePath + kDirPrefix + (char)((int) '0' + voiceNumber));
voiceBufferReady[voiceNumber] = false;
if (!directory.exists()) {
// printf("Creating subdirectory %ld\n", voiceNumber);
directory.createDirectory();
return false;
}
DirectoryIterator iterator(directory, "*");
if (directory.exists()) {
bool filesFound = false;
while (iterator.next()) {
File dataFile(iterator.getFile());
std::vector<String> &voiceVector = loadedSampleNames[voiceNumber];
std::vector<String>::iterator iter = std::find(voiceVector.begin(),
voiceVector.end(),
dataFile.getFileName());
// Found this sample already
if (iter != voiceVector.end()) {
continue;
}
AudioSampleBuffer buffer;
if (readDataFile(&buffer, dataFile)) {
printf("Loaded file: %s\n", dataFile.getFileName().toRawUTF8());
voiceVector.push_back(dataFile.getFileName());
voiceBuffers[voiceNumber].push_back(buffer);
filesFound = true;
}
}
voiceBufferReady[voiceNumber] = true;
return filesFound;
}
return false;
}
/* /////////////////////////////////////////////////////////////////////////////////////////////////
// Funcao main
///////////////////////////////////////////////////////////////////////////////////////////////// */
int main(int argc,char *argv[])
{
int n; /* / Numero de Equacoes */
double **A; /* / Matriz dos Coeficientes */
double *b; /* / Vetor b */
double *x0; /* / Vetor x0 */
double tol; /* / Tolerancia admitida */
int nmaxite; /* / Numero maximo de iteracoes */
double *x; /* / Vetor solucao */
int i; /* / Indexadores da matriz*/
int nite; /* / Numero total de iteracoes*/
FILE *fpin; /* / Ponteiro para o arquivo de dados*/
/* // Inicializa o MPI*/
MPI_Init(&argc,&argv);
/* //inicia a contagem do tempo total de execução*/
Time.t_total = MPI_Wtime();
fpin = fopen(argv[1],"r");
if (fpin==NULL){
fprintf(stdout,"Erro ao tentar abrir o arquivo de dados\n");
fflush(stdout);
}
/* // Leitura do arquivo de dados */
n = readDataFile(fpin, &A, &b, &x0, &x, &nmaxite, &tol);
/* //inicia a contagem do tempo de processamento */
Time.t_proc = MPI_Wtime() ;
/* // Chama a funçao que gerencia os processos */
GaussJacobi(n,A,b,x0,nmaxite,tol,x,&nite);
/* //finaliza a contagem do tempo de processamento */
Time.t_proc = MPI_Wtime() - Time.t_proc ;
/* // Impressao da solucao do sistema */
fprintf(stdout,"A solucao do encontrada apos %d iteracoes foi:\n",nite);
fprintf(stdout,"X[%d] = %f\n",0,x[0]);
fprintf(stdout,"X[%d] = %f\n",n-1,x[n-1]);
fflush(stdout);
/* // Fecha os arquivos de entrada e saida */
fclose(fpin);
/* // Libera memoria alocada */
for(i=0;i<n;i++)
if (A[i]!=NULL) free(A[i]);
if (A!=NULL) free(A);
if (b!=NULL) free(b);
if (x0!=NULL) free(x0);
if (x!=NULL)free(x);
/* //finaliza a contagem do tempo total de execução*/
Time.t_total = MPI_Wtime() -Time.t_total;
/* //impressão dos tempos */
printf(" \n\nFIM DA EXECUCAO : ");
printf( " \n\nNome do Executavel:%s",argv[0]);
printf("\nArquivo de Entrada:%s",argv[1]);
printf("\n\nTempo de Alocacao:%f",Time.t_aloc);
printf("\nTempo de Leitura:%f",Time.t_leit);
printf("\nTempo de Processamento:%f",Time.t_proc);
printf("\nTempo total:%f\n\n",Time.t_total);
/* // Finaliza o MPI em todos os processos */
MPI_Finalize();
return 0;
}
// ----------------------------------------
// ----------------- MAIN -----------------
int main(int argc, char* argv[])
{
std::clock_t start = std::clock();
// --------------- Initialization ----------------
// constant variables required by the model
const double tol = 1e3;
const double G = 6.674e-11;
// Loads the data for the simulation into matrix. Separator is a comma ' ' (space)
// Only the main processor does this, then sends the split data to workers
int nbBodies;
std::vector<double> data_read;
std::vector<double> mass;
std::vector<double> positions;
std::vector<double> velocities;
// --------------- Loading data ----------------
std::cout << "Loading data... ";
data_read = readDataFile(argv[1]);
nbBodies = data_read.size() / 5;
if (nbBodies < 0)
throw std::invalid_argument("Number of bodies smaller than number of nodes");
for (int i = 0; i<nbBodies; i++)
{
mass.push_back(data_read[i*5]);
positions.push_back(data_read[i*5+1]);
positions.push_back(data_read[i*5+2]);
velocities.push_back(data_read[i*5+3]);
velocities.push_back(data_read[i*5+4]);
}
std::vector<double> positions_fixed(positions);
std::cout << "done" << std::endl;
// --------------- Dumper ----------------
// Creates file to write data to
std::string file_name = argv[2];
std::ofstream outputFile;
/*
outputFile.open(file_name.c_str());
outputFile.precision(10);
outputFile << "t,px,py" << std::endl;
for (int k = 0; k < nbBodies;k++)
outputFile << 0 << "," << positions[2*k] << "," << positions[2*k+1] << std::endl;
*/
// --------------- Time iterations ----------------
double dt = 0.1;
double time_max = 0.1;
double t = 0;
for (; t < time_max; t += dt)
{
//std:: cout << "At time: " << t+dt << std::endl;
for(int i = 0; i < nbBodies; i++)
{
for(int j = 0; j<nbBodies; j++)
{
double distance = sqrt(pow(positions_fixed[2*j]-positions[2*i],2) + pow(positions_fixed[2*j+1]-positions[2*i+1],2));
if (distance > tol)
{
velocities[2*i] += dt * (positions_fixed[2*j] - positions[2*i]) * G*mass[j]/(distance*distance*distance);
velocities[2*i+1] += dt * (positions_fixed[2*j+1] - positions[2*i+1]) * G*mass[j]/(distance*distance*distance);
}
}
positions[2*i] += dt * velocities[2*i];
positions[2*i+1] += dt * velocities[2*i+1];
}
positions_fixed = positions;
//for (int k = 0; k < nbBodies;k++)
// outputFile << t+dt << "," << positions[2*k] << "," << positions[2*k+1] << std::endl;
}
// --------------- Finalization ----------------
//outputFile.close();
double total_time = (std::clock() - start) / (double) CLOCKS_PER_SEC;
std::cout << "time taken: " << total_time << std::endl;
}
XFE_WebJumperDesktopType::XFE_WebJumperDesktopType(FILE *fp)
{
_url=NULL;
readDataFile(fp);
}
void _updateDataFile() {
//char *datfname = (char*)"datafile.dat";
char *tmpdatfname = tmpfname(datfname);
ProgramData *programData = newProgramData();
int i, res;
if(!readDataFile(datfname, programData, 1)) {
/* datafile exists, update */
if(programData->version != _instrumentationInfo->id) {
fprintf(stderr, "Data corruption reading file:\n");
fprintf(stderr, " Invalid instrumentation version of existing datafile.\n");
fprintf(stderr, " Remove or rename datafile and try again.\n");
abort();
}
programData->passFail = realloc(programData->passFail, (programData->nRuns+_instrumentationInfo->run+1) * sizeof(char));
for(i=0; i<(int)_instrumentationInfo->run; i++) {
programData->passFail[programData->nRuns+i] = _instrumentationInfo->passFail[i];
}
programData->nRuns+=_instrumentationInfo->run;
programData->passFail[programData->nRuns] = 0;
for(i=0; i<MAX_SPECTRA; i++) {
int comps = programData->spectrum[i].nComponents;
programData->spectrum[i].data = (unsigned int*)realloc(programData->spectrum[i].data, comps * programData->nRuns * sizeof(unsigned int));
if(comps > 0) {
int r;
for(r=0; r<(int)_instrumentationInfo->run; r++) {
int c;
int pdRun = programData->nRuns - _instrumentationInfo->run + r;
for(c=0; c<comps; c++) {
programData->spectrum[i].data[pdRun*comps + c] = SPECTRUM(i).data[r*comps + c];
}
}
}
}
for(i=0; i<MAX_INVARIANTTYPES; i++) {
int invs = programData->invariantType[i].nInvariants;
int inv;
for(inv=0; inv<invs; inv++) {
programData->invariantType[i].data[inv] = INVARIANTTYPE(i).data[inv];
}
}
/* write data */
res = writeDataFile(tmpdatfname, programData);
if(res) {
fprintf(stderr, "Error writing datafile: res=%d\n", res);
} else {
if(remove(datfname)) {
fprintf(stderr, "Error removing outdated datafile '%s'\n", datfname);
fprintf(stderr, "New datafile is stored in '%s'\n", tmpdatfname);
} else if(rename(tmpdatfname, datfname)) {
fprintf(stderr, "Error renaming temporary datafile '%s' to '%s'\n", tmpdatfname, datfname);
fprintf(stderr, "New datafile is stored in '%s'\n", tmpdatfname);
} else {
}
}
} else {
/* no datafile exists, create */
programData->version = _instrumentationInfo->id;
programData->opMode = 0;
programData->nRuns = _instrumentationInfo->run;
programData->passFail = calloc(_instrumentationInfo->run+1, sizeof(char));
for(i=0; i<(int)_instrumentationInfo->run; i++) {
programData->passFail[i] = _instrumentationInfo->passFail[i];
}
for(i=0; i<MAX_SPECTRA; i++) {
int comps = SPECTRUM(i).nComponents;
programData->spectrum[i] = SPECTRUM(i);
programData->spectrum[i].data = (unsigned int*)calloc(comps * programData->nRuns, sizeof(unsigned int));
if(comps > 0) {
int r;
for(r=0; r<(int)_instrumentationInfo->run; r++) {
int c;
int pdRun = programData->nRuns - _instrumentationInfo->run + r;
for(c=0; c<comps; c++) {
programData->spectrum[i].data[pdRun*comps + c] = SPECTRUM(i).data[r*comps + c];
}
}
}
}
for(i=0; i<MAX_INVARIANTTYPES; i++) {
int invs = INVARIANTTYPE(i).nInvariants;
int inv;
programData->invariantType[i] = INVARIANTTYPE(i);
programData->invariantType[i].name = (char*)calloc(strlen(INVARIANTTYPE(i).name)+1, sizeof(char));
strcpy(programData->invariantType[i].name, INVARIANTTYPE(i).name);
programData->invariantType[i].data = (_Invariant*)calloc(invs, sizeof(_Invariant));
for(inv=0; inv<invs; inv++) {
programData->invariantType[i].data[inv] = INVARIANTTYPE(i).data[inv];
}
}
res = writeDataFile(tmpdatfname, programData);
if(res) {
fprintf(stderr, "Error writing datafile: res=%d\n", res);
} else {
if(rename(tmpdatfname, datfname)) {
fprintf(stderr, "Error renaming temporary datafile '%s' to '%s'\n", tmpdatfname, datfname);
fprintf(stderr, "New datafile is stored in '%s'\n", tmpdatfname);
} else {
}
}
}
free(tmpdatfname);
freeProgramData(programData);
}
bool
DataItem::readData(string &fileName, uint64_t &coprocReq, uint64_t &hostReq)
{
int64_t t;
int b;
int c;
map<int64_t, DataItem *>::iterator itr;
int64_t timeMax;
unsigned short *reqP;
int cntr = 0;
size_t pos;
string fn;
//
// load the data
//
pos = fileName.find_last_of("/\\");
if(pos == string::npos) {
pos = 0;
} else {
pos++; // skip the /
}
hostReq = 0;
fn = fileName.substr(pos);
if(fn.compare("__internal1.htmt") == 0) {
coprocReq = generateItems(1);
} else if(fn.compare("__internal2.htmt") == 0) {
coprocReq = generateItems(2);
} else {
if(readDataFile(fileName, coprocReq, hostReq) == false) {
return(false);
}
}
//
// Now generate the outstanding request map for the data
// NOTE: it is 0 based
//
StatusData status("Generating Tables...", 0, CTLR_MAX * BANKS);
markTime(true, "Table Start");
timeMax = lastRetire - firstStart + 1;
for(c=0; c<CTLR_MAX; c++) { // controller
for(b=0; b<BANKS; b++) { // bank
status.setValue(++cntr);
if((cntr%100)==0 && status.wasCanceled()) {
status.clear();
cleanup(); // remove any data
return(false);
}
unsigned short *sp;
ctlrBandTimeReq[c][b] = sp = (unsigned short *)calloc(timeMax, sizeof(*reqP));
map<int64_t, DataItem *>::iterator itrEnd;
itrEnd = dataMap[c][b].end();
for(itr = dataMap[c][b].begin(); itr != itrEnd; itr++) {
int64_t tStart = itr->second->getStartTime();
int64_t tEnd = itr->second->getRetireTime();
tStart -= firstStart;
tEnd -= firstStart;
for(t=tStart; t<= tEnd; t++) {
sp[t]++;
}
}
#ifdef NEVER
for(itr = dataMap[c][b].begin(); itr != dataMap[c][b].end(); itr++) {
for(t=itr->second->getStartTime(); t<= itr->second->getRetireTime(); t++) {
ctlrBandTimeReq[c][b][t - firstStart]++;
}
}
#endif
}
}
markTime(false, "Table Stop");
status.clear();
return(true);
}
