/** * Read a number of bytes from the interface. * * @param data Pointer to the data byte array to write the bytes to * @param maxLength The maximum number of bytes to write **/ void SerialLink::readBytes() { if (!validateConnection()) return; if (mode_port) // ESC32 special data read mode return readEsc32Tele(); const qint64 maxLength = 2048; char data[maxLength]; qint64 numBytes = 0, rBytes = 0; dataMutex.lock(); while ((numBytes = port->bytesAvailable())) { /* Read as much data in buffer as possible without overflow */ rBytes = numBytes; if(maxLength < rBytes) rBytes = maxLength; if (port->read(data, rBytes) == -1) { // -1 result means error emit portError(); if (!m_linkLossExpected) emit communicationError(this->getName(), tr("Could not read data - link %1 is disconnected!").arg(this->getName())); return; } QByteArray b(data, rBytes); emit bytesReceived(this, b); bitsReceivedTotal += rBytes * 8; } dataMutex.unlock(); }
void MessageQueue::readData() { bool gotmessage = false, gotsnapshot = false; int read, totalread=0; do { // Read available data read = _socket->read(_recvbuffer+_recvcount, MAX_BUF_LEN-_recvcount); if(read<0) { // Error! emit socketError(_socket->errorString()); return; } _recvcount += read; // Extract all complete messages int len; while(2 < _recvcount && (len=Message::sniffLength(_recvbuffer)) <= _recvcount) { // Whole message received! Message *msg = Message::deserialize((const uchar*)_recvbuffer); if(!msg) { emit badData(len, _recvbuffer[2]); } else { if(msg->type() == MSG_STREAMPOS) { // Special handling for Stream Position message emit expectingBytes(static_cast<StreamPos*>(msg)->bytes() + totalread); delete msg; } else if(_expectingSnapshot) { // A message preceded by SnapshotMode::SNAPSHOT goes into the snapshot queue _snapshot_recv.enqueue(MessagePtr(msg)); _expectingSnapshot = false; gotsnapshot = true; } else { if(msg->type() == MSG_SNAPSHOT && static_cast<SnapshotMode*>(msg)->mode() == SnapshotMode::SNAPSHOT) { delete msg; _expectingSnapshot = true; } else { _recvqueue.enqueue(MessagePtr(msg)); gotmessage = true; } } } if(len < _recvcount) { memmove(_recvbuffer, _recvbuffer+len, _recvcount-len); } _recvcount -= len; } totalread += read; } while(read>0); if(totalread) emit bytesReceived(totalread); if(gotmessage) emit messageAvailable(); if(gotsnapshot) emit snapshotAvailable(); }
double DownloadItem::remainingTime() const { if (!downloading()) return -1.0; double timeRemaining = ((double)(bytesTotal() - bytesReceived())) / currentSpeed(); // When downloading the eta should never be 0 if (timeRemaining == 0) timeRemaining = 1; return timeRemaining; }
void XbeeLink::readBytes() { xbee_pkt *xbeePkt; xbeePkt = xbee_getpacketwait(this->m_xbeeCon); if(!(NULL==xbeePkt)) { QByteArray data; for(unsigned int i=0;i<=xbeePkt->datalen;i++) { data.push_back(xbeePkt->data[i]); } qDebug() << data; emit bytesReceived(this,data); } }
double DownloadItem::remainingTime() const { if (m_finishedDownloading) return -1.0; double speed = currentSpeed(); double timeRemaining = 0.0; if (speed > 0.0) timeRemaining = ((double)(bytesTotal() - bytesReceived())) / speed; // When downloading the eta should never be 0 if (timeRemaining == 0) timeRemaining = 1; return timeRemaining; }
void XbeeLink::readBytes() { xbee_pkt *xbeePkt; xbeePkt = xbee_getpacketwait(this->m_xbeeCon); if(!(NULL==xbeePkt)) { QByteArray data; for(unsigned int i=0;i<=xbeePkt->datalen;i++) { data.push_back(xbeePkt->data[i]); } _logInputDataRate(data.length(), QDateTime::currentMSecsSinceEpoch()); emit bytesReceived(this, data); } }
void Connection::socketDisconnected() { tDebug() << "SOCKET DISCONNECTED" << this->name() << id() << "shutdown will happen after incoming queue empties." << "bytesavail:" << m_sock->bytesAvailable() << "bytesRecvd" << bytesReceived(); m_peer_disconnected = true; emit socketClosed(); if( m_msgprocessor_in.length() == 0 && m_sock->bytesAvailable() == 0 ) { handleIncomingQueueEmpty(); actualShutdown(); } }
void BaseShadow::logRequeueEvent( const char* reason ) { struct rusage run_remote_rusage; memset( &run_remote_rusage, 0, sizeof(struct rusage) ); run_remote_rusage = getRUsage(); int exit_reason = getExitReason(); JobEvictedEvent event; event.terminate_and_requeued = true; if( exitedBySignal() ) { event.normal = false; event.signal_number = exitSignal(); } else { event.normal = true; event.return_value = exitCode(); } if( exit_reason == JOB_COREDUMPED ) { event.setCoreFile( core_file_name ); } if( reason ) { event.setReason( reason ); } // TODO: fill in local rusage // event.run_local_rusage = r; event.run_remote_rusage = run_remote_rusage; /* we want to log the events from the perspective of the user job, so if the shadow *sent* the bytes, then that means the user job *received* the bytes */ event.recvd_bytes = bytesSent(); event.sent_bytes = bytesReceived(); if (!uLog.writeEvent (&event,jobAd)) { dprintf( D_ALWAYS, "Unable to log ULOG_JOB_EVICTED " "(and requeued) event\n" ); } }
void WindowsPlatformIntegration::updateTaskbarButtons() { const QList<Transfer*> transfers(TransfersManager::getInstance()->getTransfers()); qint64 bytesTotal(0); qint64 bytesReceived(0); bool hasActiveTransfers(false); for (int i = 0; i < transfers.count(); ++i) { if (transfers[i]->getState() == Transfer::RunningState && transfers[i]->getBytesTotal() > 0) { hasActiveTransfers = true; bytesTotal += transfers[i]->getBytesTotal(); bytesReceived += transfers[i]->getBytesReceived(); } } const QList<MainWindow*> windows(Application::getInstance()->getWindows()); for (int i = 0; i < windows.count(); ++i) { MainWindow *window(windows.at(i)); if (hasActiveTransfers) { if (!m_taskbarButtons.contains(window)) { m_taskbarButtons[window] = new QWinTaskbarButton(window); m_taskbarButtons[window]->setWindow(window->windowHandle()); m_taskbarButtons[window]->progress()->show(); } m_taskbarButtons[window]->progress()->setValue((bytesReceived > 0) ? qFloor((static_cast<qreal>(bytesReceived) / bytesTotal) * 100) : 0); } else if (m_taskbarButtons.contains(window)) { m_taskbarButtons[window]->progress()->reset(); m_taskbarButtons[window]->progress()->hide(); m_taskbarButtons[window]->deleteLater(); m_taskbarButtons.remove(window); } } }
void XbeeLink::readBytes() { xbee_pkt *xbeePkt; xbeePkt = xbee_getpacketwait(this->m_xbeeCon); if(!(NULL==xbeePkt)) { QByteArray data; for(unsigned int i=0;i<=xbeePkt->datalen;i++) { data.push_back(xbeePkt->data[i]); } emit bytesReceived(this, data); // Log the amount and time received for future data rate calculations. QMutexLocker dataRateLocker(&dataRateMutex); logDataRateToBuffer(inDataWriteAmounts, inDataWriteTimes, &inDataIndex, data.length(), QDateTime::currentMSecsSinceEpoch()); } }
void BaseShadow::logEvictEvent( int exitReason ) { struct rusage run_remote_rusage; memset( &run_remote_rusage, 0, sizeof(struct rusage) ); run_remote_rusage = getRUsage(); switch( exitReason ) { case JOB_CKPTED: case JOB_NOT_CKPTED: case JOB_KILLED: break; default: dprintf( D_ALWAYS, "logEvictEvent with unknown reason (%d), not logging.\n", exitReason ); return; } JobEvictedEvent event; event.checkpointed = (exitReason == JOB_CKPTED); // TODO: fill in local rusage // event.run_local_rusage = ??? // remote rusage event.run_remote_rusage = run_remote_rusage; set_usageAd(jobAd, &event.pusageAd); /* we want to log the events from the perspective of the user job, so if the shadow *sent* the bytes, then that means the user job *received* the bytes */ event.recvd_bytes = bytesSent(); event.sent_bytes = bytesReceived(); if (!uLog.writeEvent (&event,jobAd)) { dprintf (D_ALWAYS, "Unable to log ULOG_JOB_EVICTED event\n"); } }
void Server::processEventQueue() { runExecutables(); time_t now = time(nullptr); if (now < _nextDeadConnectionCheck) return; std::list<Connection*> toRemove; for (auto it = _connections.cbegin(); it != _connections.cend(); ++it) { time_t numSecondsSinceConnection = now - it->second; auto connection = it->first; if (connection->bytesReceived() == 0 && numSecondsSinceConnection >= _lameConnectionTimeoutSeconds) { LS_INFO(_logger, formatAddress(connection->getRemoteAddress()) << " : Killing lame connection - no bytes received after " << numSecondsSinceConnection << "s"); toRemove.push_back(connection); } } for (auto it = toRemove.begin(); it != toRemove.end(); ++it) { delete *it; } }
// Attempts to read at most 'bytes' bytes from the socket. qint64 PeerWireClient::readFromSocket(qint64 bytes) { char buffer[1024]; qint64 totalRead = 0; do { qint64 bytesRead = socket.read(buffer, qMin<qint64>(sizeof(buffer), bytes - totalRead)); if (bytesRead <= 0) break; qint64 oldSize = incomingBuffer.size(); incomingBuffer.resize(oldSize + bytesRead); memcpy(incomingBuffer.data() + oldSize, buffer, bytesRead); totalRead += bytesRead; } while (totalRead < bytes); if (totalRead > 0) { downloadSpeedData[0] += totalRead; emit bytesReceived(totalRead); processIncomingData(); } return totalRead; }
void Server::processEventQueue() { for (;;) { std::shared_ptr<Runnable> runnable = popNextRunnable(); if (!runnable) break; runnable->run(); } time_t now = time(NULL); if (now >= _nextDeadConnectionCheck) { std::list<Connection*> toRemove; for (auto it = _connections.cbegin(); it != _connections.cend(); ++it) { time_t numSecondsSinceConnection = now - it->second; auto connection = it->first; if (connection->bytesReceived() == 0 && numSecondsSinceConnection >= _lameConnectionTimeoutSeconds) { LS_INFO(_logger, formatAddress(connection->getRemoteAddress()) << " : Killing lame connection - no bytes received after " << numSecondsSinceConnection << "s"); toRemove.push_back(connection); } } for (auto it = toRemove.begin(); it != toRemove.end(); ++it) { delete *it; } } }
bool BaseShadow::updateJobInQueue( update_t type ) { // insert the bytes sent/recv'ed by this job into our job ad. // we want this from the perspective of the job, so it's // backwards from the perspective of the shadow. if this // value hasn't changed, it won't show up as dirty and we // won't actually connect to the job queue for it. we do this // here since we want it for all kinds of updates... MyString buf; buf.formatstr( "%s = %f", ATTR_BYTES_SENT, (prev_run_bytes_sent + bytesReceived()) ); jobAd->Insert( buf.Value() ); buf.formatstr( "%s = %f", ATTR_BYTES_RECVD, (prev_run_bytes_recvd + bytesSent()) ); jobAd->Insert( buf.Value() ); ASSERT( job_updater ); // Now that the ad is current, just let our QmgrJobUpdater // object take care of the rest... return job_updater->updateJob( type ); }
std::string Server::getStatsDocument() const { std::ostringstream doc; doc << "clear();" << std::endl; for (auto it = _connections.begin(); it != _connections.end(); ++it) { doc << "connection({"; auto connection = it->first; jsonKeyPairToStream(doc, "since", EpochTimeAsLocal(it->second), "fd", connection->getFd(), "id", reinterpret_cast<uint64_t>(connection), "uri", connection->getRequestUri(), "addr", formatAddress(connection->getRemoteAddress()), "user", connection->credentials() ? connection->credentials()->username : "******", "input", connection->inputBufferSize(), "read", connection->bytesReceived(), "output", connection->outputBufferSize(), "written", connection->bytesSent() ); doc << "});" << std::endl; } return doc.str(); }
void Connection::socketDisconnected() { Q_D( Connection ); qint64 bytesAvailable = 0; if ( !d->sock.isNull() ) { bytesAvailable = d->sock->bytesAvailable(); } tDebug( LOGVERBOSE ) << "SOCKET DISCONNECTED" << this->name() << id() << "shutdown will happen after incoming queue empties." << "bytesavail:" << bytesAvailable << "bytesRecvd" << bytesReceived(); d->peer_disconnected = true; emit socketClosed(); if ( d->msgprocessor_in.length() == 0 && bytesAvailable == 0 ) { handleIncomingQueueEmpty(); actualShutdown(); } }
// kind defaults to US_NORMAL. void BaseShadow::logTerminateEvent( int exitReason, update_style_t kind ) { struct rusage run_remote_rusage; JobTerminatedEvent event; MyString corefile; memset( &run_remote_rusage, 0, sizeof(struct rusage) ); switch( exitReason ) { case JOB_EXITED: case JOB_COREDUMPED: break; default: dprintf( D_ALWAYS, "UserLog logTerminateEvent with unknown reason (%d), aborting\n", exitReason ); return; } if (kind == US_TERMINATE_PENDING) { int exited_by_signal = FALSE; int exit_signal = 0; int exit_code = 0; getJobAdExitedBySignal(jobAd, exited_by_signal); if (exited_by_signal == TRUE) { getJobAdExitSignal(jobAd, exit_signal); event.normal = false; event.signalNumber = exit_signal; } else { getJobAdExitCode(jobAd, exit_code); event.normal = true; event.returnValue = exit_code; } /* grab usage information out of job ad */ double real_value; if( jobAd->LookupFloat(ATTR_JOB_REMOTE_SYS_CPU, real_value) ) { run_remote_rusage.ru_stime.tv_sec = (time_t) real_value; } if( jobAd->LookupFloat(ATTR_JOB_REMOTE_USER_CPU, real_value) ) { run_remote_rusage.ru_utime.tv_sec = (time_t) real_value; } event.run_remote_rusage = run_remote_rusage; event.total_remote_rusage = run_remote_rusage; /* we want to log the events from the perspective of the user job, so if the shadow *sent* the bytes, then that means the user job *received* the bytes */ jobAd->LookupFloat(ATTR_BYTES_SENT, event.recvd_bytes); jobAd->LookupFloat(ATTR_BYTES_RECVD, event.sent_bytes); event.total_recvd_bytes = event.recvd_bytes; event.total_sent_bytes = event.sent_bytes; if( exited_by_signal == TRUE ) { jobAd->LookupString(ATTR_JOB_CORE_FILENAME, corefile); event.setCoreFile( corefile.Value() ); } if (!uLog.writeEvent (&event,jobAd)) { dprintf (D_ALWAYS,"Unable to log " "ULOG_JOB_TERMINATED event\n"); EXCEPT("UserLog Unable to log ULOG_JOB_TERMINATED event"); } return; } // the default kind == US_NORMAL path run_remote_rusage = getRUsage(); if( exitedBySignal() ) { event.normal = false; event.signalNumber = exitSignal(); } else { event.normal = true; event.returnValue = exitCode(); } // TODO: fill in local/total rusage // event.run_local_rusage = r; event.run_remote_rusage = run_remote_rusage; // event.total_local_rusage = r; event.total_remote_rusage = run_remote_rusage; /* we want to log the events from the perspective of the user job, so if the shadow *sent* the bytes, then that means the user job *received* the bytes */ event.recvd_bytes = bytesSent(); event.sent_bytes = bytesReceived(); event.total_recvd_bytes = prev_run_bytes_recvd + bytesSent(); event.total_sent_bytes = prev_run_bytes_sent + bytesReceived(); if( exitReason == JOB_COREDUMPED ) { event.setCoreFile( core_file_name ); } #if 1 set_usageAd(jobAd, &event.pusageAd); #else std::string resslist; if ( ! jobAd->LookupString("PartitionableResources", resslist)) resslist = "Cpus, Disk, Memory"; StringList reslist(resslist.c_str()); if (reslist.number() > 0) { int64_t int64_value = 0; ClassAd * puAd = new ClassAd(); reslist.rewind(); char * resname = NULL; while ((resname = reslist.next()) != NULL) { MyString attr; int64_value = -1; attr.formatstr("%s", resname); // provisioned value if (jobAd->LookupInteger(attr.Value(), int64_value)) { puAd->Assign(resname, int64_value); } // /*for debugging*/ else { puAd->Assign(resname, 42); } int64_value = -2; attr.formatstr("Request%s", resname); // requested value if (jobAd->LookupInteger(attr.Value(), int64_value)) { puAd->Assign(attr.Value(), int64_value); } // /*for debugging*/ else { puAd->Assign(attr.Value(), 99); } int64_value = -3; attr.formatstr("%sUsage", resname); // usage value if (jobAd->LookupInteger(attr.Value(), int64_value)) { puAd->Assign(attr.Value(), int64_value); } } event.pusageAd = puAd; } #endif if (!uLog.writeEvent (&event,jobAd)) { dprintf (D_ALWAYS,"Unable to log " "ULOG_JOB_TERMINATED event\n"); EXCEPT("UserLog Unable to log ULOG_JOB_TERMINATED event"); } }
bool BaseShadow::updateJobInQueue( update_t type ) { // insert the bytes sent/recv'ed by this job into our job ad. // we want this from the perspective of the job, so it's // backwards from the perspective of the shadow. if this // value hasn't changed, it won't show up as dirty and we // won't actually connect to the job queue for it. we do this // here since we want it for all kinds of updates... ClassAd ftAd; ftAd.Assign(ATTR_BYTES_SENT, (prev_run_bytes_sent + bytesReceived()) ); ftAd.Assign(ATTR_BYTES_RECVD, (prev_run_bytes_recvd + bytesSent()) ); FileTransferStatus upload_status = XFER_STATUS_UNKNOWN; FileTransferStatus download_status = XFER_STATUS_UNKNOWN; getFileTransferStatus(upload_status,download_status); switch(upload_status) { case XFER_STATUS_UNKNOWN: break; case XFER_STATUS_QUEUED: ftAd.Assign(ATTR_TRANSFER_QUEUED,true); ftAd.Assign(ATTR_TRANSFERRING_INPUT,true); break; case XFER_STATUS_ACTIVE: ftAd.Assign(ATTR_TRANSFER_QUEUED,false); ftAd.Assign(ATTR_TRANSFERRING_INPUT,true); break; case XFER_STATUS_DONE: ftAd.Assign(ATTR_TRANSFER_QUEUED,false); ftAd.Assign(ATTR_TRANSFERRING_INPUT,false); break; } switch(download_status) { case XFER_STATUS_UNKNOWN: break; case XFER_STATUS_QUEUED: ftAd.Assign(ATTR_TRANSFER_QUEUED,true); ftAd.Assign(ATTR_TRANSFERRING_OUTPUT,true); break; case XFER_STATUS_ACTIVE: ftAd.Assign(ATTR_TRANSFER_QUEUED,false); ftAd.Assign(ATTR_TRANSFERRING_OUTPUT,true); break; case XFER_STATUS_DONE: ftAd.Assign(ATTR_TRANSFER_QUEUED,false); ftAd.Assign(ATTR_TRANSFERRING_OUTPUT,false); break; } MergeClassAdsCleanly(jobAd,&ftAd); ASSERT( job_updater ); if( type == U_PERIODIC ) { // Make an update happen soon. job_updater->resetUpdateTimer(); return true; } // Now that the ad is current, just let our QmgrJobUpdater // object take care of the rest... // // Note that we force a non-durable update for X509 updates; if the // schedd crashes, we don't really care when the proxy was updated // on the worker node. return job_updater->updateJob( type, (type == U_PERIODIC) ? NONDURABLE : 0 ); }
int main(void) { #ifdef NEED_EVENT uint32_t DVSEventPointer; uint32_t DVSEventTimeLow; uint16_t DVSEvent; uint32_t timeStampMemory = 0, timeStampDelta = 0; #endif int16_t angle = 0; uint32_t cnt =0; ExtraPinsInit(); disablePeripherals(); Chip_RIT_Init(LPC_RITIMER); RTC_TIME_T build = { .time = { BUILD_SEC_INT, BUILD_MIN_INT, BUILD_HOUR_INT, BUILD_DAY_INT, 0, 1, BUILD_MONTH_INT, BUILD_YEAR_INT } }; buildTime = build; //This should be one of the first initializations routines to run. sensorsInit(); #ifdef NEED_EVENT DVS128ChipInit(); #endif DacInit(); UARTInit(LPC_UART, BAUD_RATE_DEFAULT); /* baud rate setting */ initMotors(); PWMInit(); #if USE_IMU_DATA timerDelayMs(100); MPU9105Init(); #endif #if USE_SDCARD SDCardInit(); #endif #if USE_PUSHBOT MiniRobInit(); #endif #ifdef TEST_RUN test(); //This will not return #endif LED1SetOn(); // Start M0APP slave processor cr_start_m0(&__core_m0app_START__); LED1SetOff(); LED0SetOn(); LED0SetBlinking(ENABLE); UARTShowVersion(); for (;;) { if (ledBlinking && toggleLed0) { LED0Toggle(); toggleLed0 = 0; } // ***************************************************************************** // UARTIterate(); // ***************************************************************************** while (bytesReceived(&uart)) { // incoming char available? UART0ParseNewChar(popByteFromReceptionBuffer(&uart)); } // ***************************************************************************** // Deal with audio data // ***************************************************************************** /* * do the fft cross correlation and figure out the angle * manipulate the proceeding direction of the pushbot */ // if buffer reaches a length of 1024 /* if(process_flag != -1){ // -1 for not ready, 0 for buffer0, 1 for buffer1 // SysTick->CTRL &= ~0x1; //xprintf("%d\n", process_flag); angle = itd(); //SysTick->CTRL |= 0x1; if(++cnt>150){ xprintf("angle = %d\n", angle); cnt = 0; } }*/ // start doing math #if USE_IMU_DATA updateIMUData(); #endif #if USE_PUSHBOT refreshMiniRobSensors(); if (motor0.updateRequired) { motor0.updateRequired = 0; updateMotorController(MOTOR0); } if (motor1.updateRequired) { motor1.updateRequired = 0; updateMotorController(MOTOR1); } #endif /* // disable the data streaming through serial if (sensorRefreshRequested) { sensorRefreshRequested = 0; for (int i = 0; i < sensorsEnabledCounter; ++i) { if (enabledSensors[i]->triggered) { enabledSensors[i]->refresh(); enabledSensors[i]->triggered = 0; } } } */ #ifdef NEED_EVENT // ***************************************************************************** // processEventsIterate(); // ***************************************************************************** if (events.eventBufferWritePointer == events.eventBufferReadPointer) { // more events in buffer to process? continue; } if (eDVSProcessingMode < EDVS_PROCESS_EVENTS) { //Not processing events if (freeSpaceForTranmission(&uart) < (TX_BUFFER_SIZE - 32) || !(eDVSProcessingMode & EDVS_STREAM_EVENTS)) { #if LOW_POWER_MODE uart.txSleepingFlag = 1; __WFE(); #endif continue; //Wait until the buffer is empty. } } /*We are either processing events or streaming them. * If streaming the buffer must be empty at this point */ events.ringBufferLock = true; events.eventBufferReadPointer = ((events.eventBufferReadPointer + 1) & DVS_EVENTBUFFER_MASK); // increase read pointer DVSEventPointer = events.eventBufferReadPointer; // cache the value to be faster DVSEvent = events.eventBufferA[DVSEventPointer]; // fetch event from buffer DVSEventTimeLow = events.eventBufferTimeLow[DVSEventPointer]; // fetch event from buffer events.ringBufferLock = false; if (eDVSProcessingMode & EDVS_STREAM_EVENTS) { if (freeSpaceForTranmission(&uart) > 6) { // wait for TX to finish sending! pushByteToTransmission(&uart, (DVSEvent >> 8) | 0x80); // 1st byte to send (Y-address) pushByteToTransmission(&uart, DVSEvent & 0xFF); // 2nd byte to send (X-address) if (eDVSDataFormat == EDVS_DATA_FORMAT_BIN_TSVB) { // Calculate delta... timeStampDelta = DVSEventTimeLow - timeStampMemory; timeStampMemory = DVSEventTimeLow; // Save the current TS in delta // check how many bytes we need to send if (timeStampDelta < 0x7F) { // Only 7 TS bits need to be sent pushByteToTransmission(&uart, (timeStampDelta & 0x7F) | 0x80); // 3rd byte to send (7bit Delta TS, MSBit set to 1) } else if (timeStampDelta < 0x3FFF) { // Only 14 TS bits need to be sent pushByteToTransmission(&uart, (timeStampDelta >> 7) & 0x7F); // 3rd byte to send (upper 7bit Delta TS, MSBit set to 0) pushByteToTransmission(&uart, (timeStampDelta & 0x7F) | 0x80); // 4th byte to send (lower 7bit Delta TS, MSBit set to 1) } else if (timeStampDelta < 0x1FFFFF) { // Only 21 TS bits need to be sent pushByteToTransmission(&uart, (timeStampDelta >> 14) & 0x7F); // 3rd byte to send (upper 7bit Delta TS, MSBit set to 0) pushByteToTransmission(&uart, (timeStampDelta >> 7) & 0x7F); // 4th byte to send (middle 7bit Delta TS, MSBit set to 0) pushByteToTransmission(&uart, (timeStampDelta & 0x7F) | 0x80); // 5th byte to send (lower 7bit Delta TS, MSBit set to 1) } else {
void MpiResource::resourceExit( int reason, int status ) { dprintf( D_FULLDEBUG, "Inside MpiResource::resourceExit()\n" ); RemoteResource::resourceExit( reason, status ); // Also log a NodeTerminatedEvent to the ULog switch( reason ) { case JOB_COREDUMPED: case JOB_EXITED: { // Job exited on its own, normally or abnormally NodeTerminatedEvent event; event.node = node_num; if( exited_by_signal ) { event.normal = false; event.signalNumber = exit_value; } else { event.normal = true; event.returnValue = exit_value; } int had_core = 0; jobAd->LookupBool( ATTR_JOB_CORE_DUMPED, had_core ); if( had_core ) { event.setCoreFile( shadow->getCoreName() ); } // TODO: fill in local/total rusage // event.run_local_rusage = r; event.run_remote_rusage = remote_rusage; // event.total_local_rusage = r; event.total_remote_rusage = remote_rusage; /* we want to log the events from the perspective of the user job, so if the shadow *sent* the bytes, then that means the user job *received* the bytes */ event.recvd_bytes = bytesSent(); event.sent_bytes = bytesReceived(); // TODO: total sent and recvd event.total_recvd_bytes = bytesSent(); event.total_sent_bytes = bytesReceived(); if( !writeULogEvent(&event) ) { dprintf( D_ALWAYS,"Unable to log " "ULOG_NODE_TERMINATED event\n" ); } } break; case JOB_CKPTED: case JOB_NOT_CKPTED: // XXX Todo: Do we want a Node evicted event? break; default: dprintf( D_ALWAYS, "Warning: Unknown exit_reason %d in " "MpiResource::resourceExit()\n", reason ); } }
void ConfigurablePage::showProgress() { std::cerr << qPrintable(QString("").sprintf("%d%% %d KB/s", progress, ((bytesReceived() / (time(NULL) - startTime))) / 1024 ).leftJustified(15, ' ')) << "\r"; }