void readMeta(string filename,
Mesh* mesh,
vector<DOFVector<double>*> vecs)
{
FUNCNAME("ArhReader::readMeta()");
WARNING("this function is obsolete.\n");
readMeta(filename, vecs);
}
void ContiguousMS::ReadMeta(double& u, double& v, double& w, size_t& dataDescId)
{
readMeta();
casacore::Vector<double> uvwArray = _uvwColumn(_row);
u = uvwArray(0);
v = uvwArray(1);
w = uvwArray(2);
dataDescId = _dataDescId;
}
void ContiguousMS::ReadMeta(MetaData& metaData)
{
readMeta();
casacore::Vector<double> uvwArray = _uvwColumn(_row);
metaData.uInM = uvwArray(0);
metaData.vInM = uvwArray(1);
metaData.wInM = uvwArray(2);
metaData.dataDescId = _dataDescId;
metaData.antenna1 = _antenna1Column(_row);
metaData.antenna2 = _antenna2Column(_row);
metaData.time = _timeColumn(_row);
}
void readMeta(string filename,
DOFVector<double>* vec0,
DOFVector<double>* vec1,
DOFVector<double>* vec2)
{
vector<DOFVector<double>*> vecs;
if (vec0)
vecs.push_back(vec0);
if (vec1)
vecs.push_back(vec1);
if (vec2)
vecs.push_back(vec2);
readMeta(filename, vecs);
}
void ContiguousMS::ReadWeights(float* buffer)
{
readMeta();
readData();
readWeights();
size_t startChannel, endChannel;
if(_selection.HasChannelRange())
{
startChannel = _selection.ChannelRangeStart();
endChannel = _selection.ChannelRangeEnd();
}
else {
startChannel = 0;
endChannel = _bandData[_dataDescId].ChannelCount();
}
copyWeights(buffer, startChannel, endChannel, _inputPolarizations, _dataArray, _weightSpectrumArray, _flagArray, _polOut);
}
bool VoxelReader::open(const std::string &_filename)
{
try
{
mReader = new HuMAn::Ptc::Reader(_filename);
readMeta();
mFrameIterator = mReader->begin();
} catch(...)
{
TRACE("opening %s failed!", _filename.c_str());
mReader = 0;
}
mSize = mReader->frameCount();
std::cout << "opened:" << _filename << " with " << mSize << "frames \n";
//Logger::statusMessage(msg);
return (mReader != 0);
}
void ContiguousMS::ReadModel(std::complex<float>* buffer)
{
if(!_isModelColumnPrepared)
prepareModelColumn();
readMeta();
readModel();
readWeights();
size_t startChannel, endChannel;
if(_selection.HasChannelRange())
{
startChannel = _selection.ChannelRangeStart();
endChannel = _selection.ChannelRangeEnd();
}
else {
startChannel = 0;
endChannel = _bandData[_dataDescId].ChannelCount();
}
copyData(buffer, startChannel, endChannel, _inputPolarizations, _modelArray, _polOut);
}
//
// Main Function Implementation ///////////////////////////////////
//
int main( int argc, char* argv[] )
{
struct pcb_table myPCB = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // pcb table
struct pcb_table *pcbPtr = NULL; //pcb pointer
bool isThread = false; // check if the meta a thread
bool toFile = false; // check if the log needs to output to file
int currentProcess = 0; // current running process
pthread_t myThread; // thread
currentLog = logList;
// read config file
readConfig( argv[1], &myPCB );
// check if need to print to monitor or file
if(myPCB.logMode == 1 || myPCB.logMode == 2 )
toMonitor = true;
if(myPCB.logMode == 1 || myPCB.logMode == 3 )
toFile = true;
// read meta data file, update pointer
readMeta( myPCB.dataFile, &pcbList, myPCB, &processCounter);
pcbPtr = pcbList;
// start timer
clock_gettime( CLOCK_REALTIME, &startTime );
// print start log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
recordLog( &logList, ¤tLog, totalTime, "Simulator program starting" );
if( toMonitor )
printLog( currentLog );
// print log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
recordLog( &logList, ¤tLog, totalTime, "OS: preparing all processes" );
if( toMonitor )
printLog( currentLog );
// loop around processes
while( processCounter > 0 )
{
// if the process hasn't finished
if( pcbPtr -> current != NULL )
{
// print log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
recordLog( &logList, ¤tLog, totalTime, "OS: seleting next process" );
if( toMonitor )
printLog( currentLog );
// print log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
metaStartLog( pcbPtr -> current, pcbPtr, logComment );
recordLog( &logList, ¤tLog, totalTime, logComment );
if( toMonitor )
printLog( currentLog );
// if the current meta is process
if( pcbPtr -> current -> component == 'P' )
{
runProcess( pcbPtr -> current, &pcbPtr );
if( pcbPtr -> currentLeft == 0 )
{
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
interruptLog(pcbPtr -> current, logComment);
recordLog( &logList, ¤tLog, totalTime, logComment );
if( toMonitor )
printLog( currentLog );
pcbPtr -> current = pcbPtr -> current -> next;
if( pcbPtr -> current != NULL && pcbPtr -> current -> component == 'P' )
pcbPtr -> currentLeft = pcbPtr -> current -> cyc_time;
if(pcbPtr -> current == NULL)
processCounter --;
}
}
// if the current meta needs spawn thread
else
{
// spawn thread
pthread_create( &myThread, NULL, thread_perform, (void*) pcbPtr );
// print log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
blockLog(pcbPtr->current, logComment);
recordLog( &logList, ¤tLog, totalTime, logComment );
if( toMonitor )
printLog( currentLog );
// block process
blockProcess(&pcbList, pcbPtr, &blockQueue);
}
}
// select next process in queue
if(pcbPtr -> next == NULL)
pcbPtr = pcbList;
else
pcbPtr = pcbPtr -> next;
}
// print ending log
clock_gettime( CLOCK_REALTIME, &endTime );
totalTime = timeLap( startTime, endTime );
recordLog( &logList, ¤tLog, totalTime, "Simulator program ending" );
if( toMonitor )
printLog( currentLog );
// output to file
if( toFile )
outputToFile( logList, myPCB );
return 0;
} // end of main
int main(){
readMeta();
}
bool TraceEvent::readStrMeta(TraceFieldType key, std::string& dest) const {
return readMeta(key, dest);
}
bool TraceEvent::readBoolMeta(TraceFieldType key, bool& dest) const {
return readMeta(key, dest);
}
