bool NaughtyProcessMonitor::getLoad(ulong pid, uint &load) const
{
#ifdef __linux__
QFile f("/proc/" + QString::number(pid) + "/stat");
if(!f.open(IO_ReadOnly))
return false;
QTextStream t(&f);
QString line(t.readLine());
QStringList fields(QStringList::split(' ', line));
uint userTime(fields[13].toUInt());
uint sysTime(fields[14].toUInt());
load = userTime + sysTime;
return true;
#elif defined(__OpenBSD__)
// use cache
if(!d->cacheLoadMap_.contains(pid))
return false;
load = d->cacheLoadMap_[pid];
return true;
#else
Q_UNUSED(pid);
Q_UNUSED(load);
return false;
#endif
}
int main(int argc, char const ** argv)
{
double startTime = 0;
// Parse command line.
FxFaidxOptions options;
seqan::ArgumentParser::ParseResult res = parseArgs(options, argc, argv);
if (res != seqan::ArgumentParser::PARSE_OK)
return res == seqan::ArgumentParser::PARSE_ERROR; // 1 on errors, 0 otherwise
// ---------------------------------------------------------------------------
// Index I/O
// ---------------------------------------------------------------------------
// Load index, create if necessary.
startTime = sysTime();
seqan::FaiIndex faiIndex;
if (load(faiIndex, toCString(options.inFastaPath), toCString(options.inFaiPath)) != 0)
{
if (options.verbosity >= 2)
std::cerr << "Building Index " << options.inFaiPath << " ...";
if (buildIndex(toCString(options.inFastaPath), toCString(options.inFaiPath), seqan::Fai()) != 0)
{
std::cerr << "Could not build FAI index at " << options.inFaiPath
<< " for FASTA file " << options.inFastaPath << "\n";
return 1;
}
if (load(faiIndex, toCString(options.inFastaPath), toCString(options.inFaiPath)) != 0)
{
std::cerr << "Could not load FAI index we just build.\n";
return 1;
}
}
if (options.verbosity >= 3)
std::cerr << "Took " << (startTime - sysTime()) << " s\n";
// ---------------------------------------------------------------------------
// Parse and Fetch Regions.
// ---------------------------------------------------------------------------
if (empty(options.regions))
return 0;
// Parse out regions.
seqan::String<Region> regions;
for (unsigned i = 0; i < length(options.regions); ++i)
{
Region region;
if (!parseRegion(region, options.regions[i]))
{
std::cerr << "Could not parse region " << options.regions[i] << "\n";
return 1;
}
unsigned seqId;
if (!getIdByName(faiIndex, region.seqName, seqId))
{
std::cerr << "Unknown sequence for region " << options.regions[i] << "\n";
return 1;
}
region.seqId = seqId;
if (region.seqId < 0 || (unsigned)region.seqId >= length(faiIndex.indexEntryStore))
{
std::cerr << "Invalid region " << options.regions[i] << "\n";
return 1;
}
appendValue(regions, region);
}
// Open output file.
std::ostream * outPtr = &std::cout;
std::ofstream outF;
if (!empty(options.outFastaPath))
{
outF.open(toCString(options.outFastaPath), std::ios::binary | std::ios::out);
if (!outF.good())
{
std::cerr << "Could not open output file " << options.outFastaPath << "\n";
return 1;
}
}
// Retrieve output infixes and write to result.
for (unsigned i = 0; i < length(regions); ++i)
{
Region const & region = regions[i];
seqan::CharString id = options.regions[i];
seqan::CharString seq;
unsigned beginPos = 0;
if (region.beginPos > 0)
beginPos = region.beginPos;
unsigned endPos = sequenceLength(faiIndex, (unsigned)region.seqId);
if (region.endPos > 0 && (unsigned)region.endPos < endPos)
endPos = region.endPos;
if (beginPos > endPos)
endPos = beginPos;
getSequenceInfix(seq, faiIndex, region.seqId, beginPos, endPos);
if (writeRecord(*outPtr, id, seq, seqan::Fasta()) != 0)
{
std::cerr << "Could not write infix for region " << options.regions[i] << " to output.\n";
return 1;
}
}
return 0;
}
int main(int argc, char const ** argv)
{
double startTime = 0;
// -----------------------------------------------------------------------
// Parse command line.
// -----------------------------------------------------------------------
FxSamCoverageOptions options;
seqan::ArgumentParser::ParseResult res = parseArgs(options, argc, argv);
if (res != seqan::ArgumentParser::PARSE_OK)
return res == seqan::ArgumentParser::PARSE_ERROR; // 1 on errors, 0 otherwise
// -----------------------------------------------------------------------
// Show options.
// -----------------------------------------------------------------------
if (options.verbosity >= 1)
{
std::cerr << "____OPTIONS___________________________________________________________________\n"
<< "\n"
<< "VERBOSITY " << options.verbosity << "\n"
<< "GENOME " << options.inGenomePath << "\n"
<< "SAM " << options.inSamPath << "\n"
<< "OUT " << options.outPath << "\n"
<< "WINDOW SIZE " << options.windowSize << "\n";
}
// -----------------------------------------------------------------------
// Load Genome FAI Index
// -----------------------------------------------------------------------
std::cerr << "\n"
<< "___PREPRATION_____________________________________________________________________\n"
<< "\n"
<< "Indexing GENOME file " << options.inGenomePath << " ...";
seqan::FaiIndex faiIndex;
if (build(faiIndex, toCString(options.inGenomePath)) != 0)
{
std::cerr << "Could not build FAI index.\n";
return 1;
}
std::cerr << " OK\n";
// Prepare bins.
seqan::String<seqan::String<BinData> > bins;
resize(bins, numSeqs(faiIndex));
// -----------------------------------------------------------------------
// Compute C+G content
// -----------------------------------------------------------------------
std::cerr << "\n"
<< "___C+G CONTENT COMPUTATION________________________________________________________\n"
<< "\n";
for (unsigned i = 0; i < numSeqs(faiIndex); ++i)
{
std::cerr << "[" << sequenceName(faiIndex, i) << "] ...";
unsigned numBins = (sequenceLength(faiIndex, i) + options.windowSize - 1) / options.windowSize;
resize(bins[i], numBins);
seqan::Dna5String contigSeq;
if (readSequence(contigSeq, faiIndex, i) != 0)
{
std::cerr << "\nERROR: Could not read sequence " << sequenceName(faiIndex, i) << " from file!\n";
return 1;
}
for (unsigned bin = 0; bin < numBins; ++bin)
{
unsigned cgCounter = 0;
unsigned binSize = 0;
bins[i][bin].length = options.windowSize;
if ((bin + 1) * options.windowSize > length(contigSeq))
bins[i][bin].length = length(contigSeq) - bin * options.windowSize;
for (unsigned pos = bin * options.windowSize; pos < length(contigSeq) && pos < (bin + 1) * options.windowSize; ++pos, ++binSize)
cgCounter += (contigSeq[pos] == 'C' || contigSeq[pos] == 'G');
bins[i][bin].cgContent = 1.0 * cgCounter / binSize;
}
std::cerr << "DONE\n";
}
// -----------------------------------------------------------------------
// Compute Coverage
// -----------------------------------------------------------------------
std::cerr << "\n"
<< "___COVERAGE COMPUATATION________________________________________________________\n"
<< "\n"
<< "Computing Coverage...";
seqan::BamStream bamStream(toCString(options.inSamPath));
if (!isGood(bamStream))
{
std::cerr << "Could not open " << options.inSamPath << "!\n";
return 1;
}
seqan::BamAlignmentRecord record;
while (!atEnd(bamStream))
{
if (readRecord(record, bamStream) != 0)
{
std::cerr << "ERROR: Could not read record from BAM file!\n";
return 1;
}
if (hasFlagUnmapped(record) || hasFlagSecondary(record) || record.rId == seqan::BamAlignmentRecord::INVALID_REFID)
continue; // Skip these records.
int contigId = 0;
seqan::CharString const & contigName = nameStore(bamStream.bamIOContext)[record.rId];
if (!getIdByName(faiIndex, contigName, contigId))
{
std::cerr << "ERROR: Alignment to unknown contig " << contigId << "!\n";
return 1;
}
unsigned binNo = record.pos / options.windowSize;
bins[contigId][binNo].coverage += 1;
}
std::cerr << "DONE\n";
// -----------------------------------------------------------------------
// Write Output
// -----------------------------------------------------------------------
std::ostream * out = &std::cout;
std::ofstream outFile;
if (options.outPath != "-")
{
outFile.open(toCString(options.outPath), std::ios::binary | std::ios::out);
if (!outFile.good())
{
std::cerr << "ERROR: Could not open output file " << options.outPath << "!\n";
return 1;
}
out = &outFile;
}
(*out) << "#BIN\tREF_NAME\tREF_BIN\tBIN_BEGIN\tBIN_LENGTH\tCOVERAGE\tCG_CONTENT\n";
for (unsigned i = 0, globalBin = 0; i < length(bins); ++i)
{
for (unsigned refBin = 0; refBin < length(bins[i]); ++refBin, ++globalBin)
{
(*out) << globalBin << '\t'
<< sequenceName(faiIndex, i) << '\t'
<< refBin << '\t'
<< refBin * options.windowSize << '\t'
<< bins[i][refBin].length << '\t'
<< bins[i][refBin].coverage << '\t'
<< bins[i][refBin].cgContent << '\n';
}
}
if (options.verbosity >= 2)
std::cerr << "Took " << (sysTime() - startTime) << " s\n";
return 0;
}
/*
* A function implementing system time queries for different platforms.
* Be aware that granularity of time measurement may vary on different
* hardware and operating systems. Returns FALSE, if system time can't
* be retrieved (i.e. system call fails). This function returns time
* measured from arbitrary moment in the past. This can be time of
* last boot or some other random epoch.
*/
Boolean ssh_time_measure_system_time(SshTimeVal timeval)
{
#if defined(WIN32)
struct _timeb tv;
#elif defined(CHORUS)
KnTimeVal tv;
#elif defined(HAVE_GETTIMEOFDAY)
struct timeval tv;
#else /* !WIN32 && !CHORUS && !HAVE_GETTIMEOFDAY */
SshTime tv;
#endif /* !WIN32 && !CHORUS && !HAVE_GETTIMEOFDAY */
#if defined(WIN32)
_ftime(&tv);
if (timeval != NULL)
{
timeval->seconds = (SshUInt64)tv.time;
timeval->nanoseconds = ((SshUInt32)tv.millitm) * 1000000;
}
return TRUE;
#elif defined(CHORUS)
if (sysTime(&tv) == K_OK)
{
if (timeval != NULL)
{
timeval->seconds = (SshUInt64)tv.tmSec;
timeval->nanoseconds = (SshUInt32)tv.tmNSec;
}
return TRUE;
}
else
{
ssh_warning("ssh_time_measure_system_time: sysTime failed.");
if (timeval != NULL)
{
timeval->seconds = 0;
timeval->nanoseconds = 0;
}
return FALSE;
}
#elif defined(HAVE_GETTIMEOFDAY)
if (gettimeofday(&tv, NULL) == 0)
{
if (timeval != NULL)
{
timeval->seconds = (SshUInt64)tv.tv_sec;
timeval->nanoseconds = ((SshUInt32)tv.tv_usec) * 1000;
}
return TRUE;
}
else
{
ssh_warning("ssh_time_measure_system_time: gettimeofday failed.");
if (timeval != NULL)
{
timeval->seconds = 0;
timeval->nanoseconds = 0;
}
return FALSE;
}
#else /* !WIN32 && !CHORUS && !HAVE_GETTIMEOFDAY */
tv = ssh_time();
if (timeval != NULL)
{
timeval->seconds = (SshUInt64)tv;
timeval->nanoseconds = (SshUint32)0;
}
return TRUE;
#endif /* !WIN32 && !CHORUS && !HAVE_GETTIMEOFDAY */
}
