void SimBax::operator()()
{
uniform_int_distribution<int> readStart(0, t.size());
ofstream fastq(fastqFilename);
resetStrings();
const int numReads = t.size() * depth / readLen;
int nextOut = numReads/10;
int pct = 0;
chrono::time_point<chrono::system_clock> start;
start = chrono::system_clock::now();
cout << "Inilisation finished, simulating reads.\n";
for (int readNum = 0 ; readNum < numReads ; readNum++ )
{
long addedSoFar = baseCall.size();
string fastqPhreds;
makeRead(readLen, readStart(gen), fastqPhreds);
const int lengthRead = baseCall.size() - addedSoFar;
reads.push_back(lengthRead);
writeFastq(baseCall.substr(addedSoFar, lengthRead)
,fastqPhreds
,fastq
,readNum);
if (readNum == nextOut)
{
chrono::time_point<chrono::system_clock> current;
current = chrono::system_clock::now();
chrono::duration<double> elapsed = start - current;
nextOut += numReads/10;
pct += 10;
cout << pct << "% done. Time ellapsed :"
<< elapsed.count() << " seconds\n";
}
}
cout << "Wrinting data to file.\n";
BaxH5 baxh5(baxFilename);
baxh5.writeReads(baseCall
,deletionQV
,deletionTag
,insertionQV
,mergeQV
,preBaseFrame
,pulseIndex
,substitutionQV
,subsititutionTag
,qualityValue
,widthInFrame
,reads);
}
// Called in ISR context called when a data is received
bool USBMSD::EP2_OUT_callback() {
uint32_t size = 0;
uint8_t buf[MAX_PACKET_SIZE_EPBULK];
readEP(EPBULK_OUT, buf, &size, MAX_PACKET_SIZE_EPBULK);
switch (stage) {
// the device has to decode the CBW received
case READ_CBW:
CBWDecode(buf, size);
break;
// the device has to receive data from the host
case PROCESS_CBW:
switch (cbw.CB[0]) {
case WRITE10:
case WRITE12:
memoryWrite(buf, size);
break;
case VERIFY10:
memoryVerify(buf, size);
break;
}
break;
// an error has occured: stall endpoint and send CSW
default:
stallEndpoint(EPBULK_OUT);
csw.Status = CSW_ERROR;
sendCSW();
break;
}
//reactivate readings on the OUT bulk endpoint
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
bool USBCDC::readEP_NB(uint8_t * buffer, uint16_t * size) {
if (!USBDevice::readEP_NB(EPBULK_OUT, buffer, size, MAX_CDC_REPORT_SIZE))
return false;
if (!readStart(EPBULK_OUT, MAX_CDC_REPORT_SIZE))
return false;
return true;
}
void SSLSocket::onConnect(uv_connect_t* handle, int status)
{
TraceS(this) << "On connect" << endl;
if (status) {
setUVError("SSL connect error", status);
return;
}
else
readStart();
SSL* ssl = SSL_new(_context->sslContext());
// TODO: Automatic SSL session handling.
// Maybe add a stored session to the network manager.
if (_session)
SSL_set_session(ssl, _session->sslSession());
SSL_set_connect_state(ssl);
SSL_do_handshake(ssl);
_sslAdapter.init(ssl);
_sslAdapter.flush();
//emitConnect();
onSocketConnect();
TraceS(this) << "On connect: OK" << endl;
}
// Called in ISR context on each start of frame
void USBAudio::SOF(int frameNumber) {
uint32_t size = 0;
if (!interruptOUT) {
// read the isochronous endpoint
if (buf_stream_in != NULL) {
if (USBDevice::readEP_NB(EPISO_OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN)) {
if (size) {
available = true;
readStart(EPISO_OUT, PACKET_SIZE_ISO_IN);
buf_stream_in = NULL;
}
}
}
}
if (!interruptIN) {
// write if needed
if (buf_stream_out != NULL) {
USBDevice::writeNB(EPISO_IN, (uint8_t *)buf_stream_out, PACKET_SIZE_ISO_OUT, PACKET_SIZE_ISO_OUT);
buf_stream_out = NULL;
}
}
SOF_handler = true;
}
bool USBHID::read(HID_REPORT *report)
{
uint32_t bytesRead = 0;
bool result;
result = USBDevice::readEP(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE);
if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
return false;
report->length = bytesRead;
return result;
}
//------------------------------------------------------------------------------
bool SdSpiCard::readBlocks(uint32_t block, uint8_t* dst, size_t count) {
if (!readStart(block)) {
return false;
}
for (uint16_t b = 0; b < count; b++, dst += 512) {
if (!readData(dst, 512)) {
return false;
}
}
return readStop();
}
void TCPSocket::acceptConnection()
{
// Create the shared socket pointer;
// if it is not handled it will be destroyed.
// TODO: Allow accepted sockets to use different event loops.
auto socket = net::makeSocket<net::TCPSocket>(loop()); //std::make_shared<net::TCPSocket>(this->loop());
TraceLS(this) << "Accept connection: " << socket->ptr() << endl;
uv_accept(ptr<uv_stream_t>(), socket->ptr<uv_stream_t>()); // uv_accept should always work
socket->readStart();
AcceptConnection.emit(Socket::self(), socket);
}
bool USBAudio::EP3_OUT_callback() {
uint32_t size = 0;
interruptOUT = true;
if (buf_stream_in != NULL) {
readEP(EP3OUT, (uint8_t *)buf_stream_in, &size, PACKET_SIZE_ISO_IN);
available = true;
buf_stream_in = NULL;
}
readStart(EP3OUT, PACKET_SIZE_ISO_IN);
return false;
}
// Called in ISR context
// Set configuration. Return false if the
// configuration is not supported.
bool USBCDCMSC::USBCallback_setConfiguration(uint8_t configuration) {
if (configuration != DEFAULT_CONFIGURATION) {
return false;
}
// Configure endpoints > 0
addEndpoint(EPINT_IN, MAX_PACKET_SIZE_EPINT);
addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
// Configure endpoints > 0
addEndpoint(MSDBULK_IN, MAX_PACKET_SIZE_MSDBULK);
addEndpoint(MSDBULK_OUT, MAX_PACKET_SIZE_MSDBULK);
// We activate the endpoint to be able to recceive data
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
//activate readings
readStart(MSDBULK_OUT, MAX_PACKET_SIZE_MSDBULK);
return true;
}
bool USBMouseKeyboard::EP1_OUT_callback() {
uint32_t bytesRead = 0;
uint8_t led[65];
USBDevice::readEP(EPINT_OUT, led, &bytesRead, MAX_HID_REPORT_SIZE);
// we take led[1] because led[0] is the report ID
lock_status = led[1] & 0x07;
// We activate the endpoint to be able to recceive data
if (!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
return false;
return true;
}
// Called in ISR context
// Set configuration. Return false if the configuration is not supported.
bool USBAudio::USBCallback_setConfiguration(uint8_t configuration) {
if (configuration != DEFAULT_CONFIGURATION) {
return false;
}
// Configure isochronous endpoint
realiseEndpoint(EPISO_OUT, PACKET_SIZE_ISO_IN, ISOCHRONOUS);
realiseEndpoint(EPISO_IN, PACKET_SIZE_ISO_OUT, ISOCHRONOUS);
// activate readings on this endpoint
readStart(EPISO_OUT, PACKET_SIZE_ISO_IN);
return true;
}
// Called in ISR context
// Set configuration. Return false if the
// configuration is not supported.
bool USBMSD::USBCallback_setConfiguration(uint8_t configuration) {
if (configuration != DEFAULT_CONFIGURATION) {
return false;
}
// Configure endpoints > 0
addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
//activate readings
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
bool USBHID::readNB(HID_REPORT *report)
{
uint32_t bytesRead = 0;
bool result;
result = USBDevice::readEP_NB(EPINT_OUT, report->data, &bytesRead, MAX_HID_REPORT_SIZE);
// if readEP_NB did not succeed, does not issue a readStart
if (!result)
return false;
report->length = bytesRead;
if(!readStart(EPINT_OUT, MAX_HID_REPORT_SIZE))
return false;
return result;
}
bool RJBaseUSBDevice::USBCallback_setConfiguration(uint8_t configuration) {
LOG(INIT, "RJBaseUSBDevice::USBCallback_setConfiguration() called");
// Configuration 1 is our only configuration
if (configuration != 1) return false;
addEndpoint(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
addEndpoint(EPBULK_IN, MAX_PACKET_SIZE_EPBULK);
// activate the endpoint to be able to recceive data
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
/** reads a diff file */
static
SCIP_RETCODE readDiffFile(
SCIP* scip, /**< SCIP data structure */
LPINPUT* lpinput, /**< LP reading data */
const char* filename /**< name of the input file */
)
{
assert(lpinput != NULL);
/* open file */
lpinput->file = SCIPfopen(filename, "r");
if( lpinput->file == NULL )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
SCIPprintSysError(filename);
return SCIP_NOFILE;
}
/* free transformed problem */
if( SCIPgetStage(scip) >= SCIP_STAGE_PROBLEM )
{
SCIP_CALL( SCIPfreeTransform(scip) );
}
/* parse the file */
lpinput->section = LP_START;
while( lpinput->section != LP_END && !hasError(lpinput) )
{
switch( lpinput->section )
{
case LP_START:
SCIP_CALL( readStart(scip, lpinput) );
break;
case LP_OBJECTIVE:
SCIP_CALL( readObjective(scip, lpinput) );
break;
case LP_END: /* this is already handled in the while() loop */
default:
SCIPerrorMessage("invalid Diff file section <%d>\n", lpinput->section);
return SCIP_INVALIDDATA;
}
}
/* close file */
SCIPfclose(lpinput->file);
return SCIP_OKAY;
}
bool USBMIDI::EP2_OUT_callback() {
uint8_t buf[64];
uint32_t len;
readEP(EPBULK_OUT, buf, &len, 64);
if (midi_evt != NULL) {
for (int i=0; i<len; i+=4) {
midi_evt(MIDIMessage(buf+i));
}
}
// We reactivate the endpoint to receive next characters
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
void TCPSocket::onConnect(uv_connect_t* handle, int status)
{
TraceLS(this) << "On connect" << endl;
// Error handled by static callback proxy
if (status == 0) {
if (readStart())
onSocketConnect();
}
else {
setUVError("Connection failed", status);
//ErrorLS(this) << "Connection failed: " << error().message << endl;
}
delete handle;
}
bool USBCDCMSC::EP2_OUT_callback() {
uint8_t c[65];
uint16_t size = 0;
//we read the packet received and put it on the circular buffer
readEP(c, &size);
for (int i = 0; i < size; i++) {
cdcbuf.queue(c[i]);
}
//call a potential handler
rx.call();
// We reactivate the endpoint to receive next characters
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
void BooRedisAsync::connectComplete(const boost::system::error_code& error)
{
if (!error)
{
m_connectTimer->cancel();
readStart();
m_onceConnected = true;
m_connected = true;
onLogMessage("Successfully connected to Redis " + endpointToString(getEndpointIterator()),LOG_LEVEL_INFO);
onConnect();
if (!m_writeInProgress && !m_writeBuffer.empty())
writeStart();
}
else
onError(error);
}
void SMSC95xxUSB::readFinished(FileSystemMessage *message)
{
DEBUG("identifier = " << message->identifier << " result = " << (int)message->result);
if (!m_rxPacket)
{
ERROR("unexpected readFinish with no receive packet buffer");
return;
}
// Extract packet
// USBMessage *usb = (USBMessage *) message->buffer;
// TODO: Offset field contains virtual address of input data buffer
u8 *data = (u8 *) message->offset; //usb->buffer;
u32 receiveCmd = data[0] | data[1] << 8 | data[2] << 16 | data[3] << 24;
Size frameLength = (receiveCmd & RxCommandFrameLength) >> 16;
if (frameLength == 0 || frameLength > m_packetSize)
{
ERROR("invalid framelength: " << frameLength);
}
else
{
DEBUG("packet is " << frameLength << " bytes long");
// Publish the packet to our parent
m_rxPacket->size = frameLength;
m_smsc->process(m_rxPacket, ReceiveCommandSize);
// Release the packet buffer
m_smsc->getReceiveQueue()->release(m_rxPacket);
m_rxPacket = 0;
// TODO: this should not be done like this
// Trigger retry of all FileSystemRequests here.
// m_server->interruptHandler(0);
}
// Release USB transfer
finishTransfer(message);
// Restart read transfer
readStart();
}
void BooRedisAsync::readComplete(const boost::system::error_code &error, size_t bytesTransferred)
{
if (!error)
{
std::vector<RedisMessage> result;
BooRedisDecoder::DecodeResult res = m_decoder.decode(m_readBuffer,bytesTransferred,result);
for (std::vector<RedisMessage>::iterator it=result.begin();it!=result.end();++it)
onRedisMessage(*it);
if (res != BooRedisDecoder::DecodeError)
readStart();
else {
onLogMessage("Error decoding redis message. Reconnecting",LOG_LEVEL_ERR);
onError(boost::system::error_code());
}
}
else
onError(error);
}
void
TcpHandler::handleConnect(const boost::system::error_code& error)
{
if (error) {
doClose(error);
} else {
unsigned int port = Options::commandPort();
if (port != 0) {
boost::asio::ip::tcp::endpoint cmdEndpoint(boost::asio::ip::tcp::v4(), port);
m_cmdHandler.reset(new CommandHandler(*this, cmdEndpoint));
m_pcMessageCallback = boost::bind(&CommandHandler::handlePcMessage,
m_cmdHandler, _1);
}
port = Options::dataPort();
if (port != 0) {
boost::asio::ip::tcp::endpoint dataEndpoint(boost::asio::ip::tcp::v4(), port);
m_dataHandler.reset(new DataHandler(*this, dataEndpoint));
m_valueCallback = boost::bind(&DataHandler::handleValue, m_dataHandler, _1);
}
resetWatchdog();
readStart();
}
}
Error SMSC95xxUSB::initialize()
{
DEBUG("");
Error r = USBDevice::initialize();
if (r != ESUCCESS)
{
ERROR("failed to initialize USBDevice");
return r;
}
DEBUG("setting MAC");
// Set MAC address
Ethernet::Address a;
a.addr[0] = 0x00;
a.addr[1] = 0x11;
a.addr[2] = 0x22;
a.addr[3] = 0x33;
a.addr[4] = 0x44;
a.addr[5] = 0x55;
setMACAddress(a);
#define SMSC9512_HS_USB_PKT_SIZE 512
#define SMSC9512_DEFAULT_HS_BURST_CAP_SIZE (16 * 1024 + 5 * SMSC9512_HS_USB_PKT_SIZE)
// Enable RX/TX bits on hardware
write(HardwareConfig, read(HardwareConfig) | MultipleEther | BulkIn | BCE);
write(BurstCap, SMSC9512_DEFAULT_HS_BURST_CAP_SIZE / SMSC9512_HS_USB_PKT_SIZE);
write(MACControl, read(MACControl) | MACTransmit | MACReceive);
write(TransmitConfig, TransmitOn);
// Begin packet receive transfer
readStart();
// Done
return ESUCCESS;
}
bool USBMIDI::EPBULK_OUT_callback() {
uint8_t buf[64];
uint32_t len;
readEP(EPBULK_OUT, buf, &len, 64);
if (midi_evt != NULL) {
for (uint32_t i=0; i<len; i+=4) {
uint8_t data_read;
data_end=true;
switch(buf[i]) {
case 0x2:
// Two-bytes System Common Message - undefined in USBMidi 1.0
data_read=2;
break;
case 0x4:
// SysEx start or continue
data_end=false;
data_read=3;
break;
case 0x5:
// Single-byte System Common Message or SysEx end with one byte
data_read=1;
break;
case 0x6:
// SysEx end with two bytes
data_read=2;
break;
case 0xC:
// Program change
data_read=2;
break;
case 0xD:
// Channel pressure
data_read=2;
break;
case 0xF:
// Single byte
data_read=1;
break;
default:
// Others three-bytes messages
data_read=3;
break;
}
for(uint8_t j=1;j<data_read+1;j++) {
data[cur_data]=buf[i+j];
cur_data++;
}
if(data_end) {
midi_evt(MIDIMessage(data,cur_data));
cur_data=0;
}
}
}
// We reactivate the endpoint to receive next characters
readStart(EPBULK_OUT, MAX_PACKET_SIZE_EPBULK);
return true;
}
/** reads an BLK file */
static
SCIP_RETCODE readBLKFile(
SCIP* scip, /**< SCIP data structure */
SCIP_READER* reader, /**< reader data structure */
BLKINPUT* blkinput, /**< BLK reading data */
const char* filename /**< name of the input file */
)
{
DEC_DECOMP *decdecomp;
int i;
int nconss;
int nblocksread;
int nvars;
SCIP_READERDATA* readerdata;
SCIP_CONS** conss;
nblocksread = FALSE;
assert(scip != NULL);
assert(reader != NULL);
assert(blkinput != NULL);
if( SCIPgetStage(scip) < SCIP_STAGE_TRANSFORMED )
SCIP_CALL( SCIPtransformProb(scip) );
readerdata = SCIPreaderGetData(reader);
assert(readerdata != NULL);
readerdata->nlinkingcons = SCIPgetNConss(scip);
readerdata->nlinkingvars = 0;
nvars = SCIPgetNVars(scip);
conss = SCIPgetConss(scip);
nconss = SCIPgetNConss(scip);
/* alloc: var -> block mapping */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->varstoblock, nvars) );
for( i = 0; i < nvars; i ++ )
{
readerdata->varstoblock[i] = NOVALUE;
}
/* alloc: linkingvar -> blocks mapping */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->linkingvarsblocks, nvars) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nlinkingvarsblocks, nvars) );
BMSclearMemoryArray(readerdata->linkingvarsblocks, nvars);
BMSclearMemoryArray(readerdata->nlinkingvarsblocks, nvars);
/* cons -> block mapping */
SCIP_CALL( SCIPhashmapCreate(&readerdata->constoblock, SCIPblkmem(scip), nconss) );
for( i = 0; i < SCIPgetNConss(scip); i ++ )
{
SCIP_CALL( SCIPhashmapInsert(readerdata->constoblock, conss[i], (void*)(size_t) NOVALUE) );
}
/* open file */
blkinput->file = SCIPfopen(filename, "r");
if( blkinput->file == NULL )
{
SCIPerrorMessage("cannot open file <%s> for reading\n", filename);
SCIPprintSysError(filename);
return SCIP_NOFILE;
}
/* parse the file */
blkinput->section = BLK_START;
while( blkinput->section != BLK_END && !hasError(blkinput) )
{
switch( blkinput->section )
{
case BLK_START:
SCIP_CALL( readStart(scip, blkinput) );
break;
case BLK_PRESOLVED:
SCIP_CALL( readPresolved(scip, blkinput) );
if( blkinput->presolved && SCIPgetStage(scip) < SCIP_STAGE_PRESOLVED )
{
assert(blkinput->haspresolvesection);
/** @bug GCG should be able to presolve the problem first */
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL, "decomposition belongs to the presolved problem, please presolve the problem first.\n");
goto TERMINATE;
}
break;
case BLK_NBLOCKS:
SCIP_CALL( readNBlocks(scip, blkinput) );
if( blkinput->haspresolvesection && !blkinput->presolved && SCIPgetStage(scip) >= SCIP_STAGE_PRESOLVED )
{
SCIPverbMessage(scip, SCIP_VERBLEVEL_MINIMAL, NULL, "decomposition belongs to the unpresolved problem, please re-read the problem and read the decomposition without presolving.\n");
goto TERMINATE;
}
if( !blkinput->haspresolvesection )
{
SCIPwarningMessage(scip, "decomposition has no presolve section at beginning. The behaviour is undefined. See the FAQ for further information.\n");
}
break;
case BLK_BLOCK:
if( nblocksread == FALSE )
{
/* alloc n vars per block */
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nblockvars, blkinput->nblocks) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->nblockcons, blkinput->nblocks) );
SCIP_CALL( SCIPallocMemoryArray(scip, &readerdata->blockcons, blkinput->nblocks) );
for( i = 0; i < blkinput->nblocks; ++i )
{
readerdata->nblockvars[i] = 0;
readerdata->nblockcons[i] = 0;
SCIP_CALL( SCIPallocMemoryArray(scip, &(readerdata->blockcons[i]), nconss) ); /*lint !e866*/
}
nblocksread = TRUE;
}
SCIP_CALL( readBlock(scip, blkinput, readerdata) );
break;
case BLK_MASTERCONSS:
SCIP_CALL( readMasterconss(scip, blkinput, readerdata) );
break;
case BLK_END: /* this is already handled in the while() loop */
default:
SCIPerrorMessage("invalid BLK file section <%d>\n", blkinput->section);
return SCIP_INVALIDDATA;
}
}
SCIP_CALL( DECdecompCreate(scip, &decdecomp) );
/* fill decomp */
SCIP_CALL( fillDecompStruct(scip, blkinput, decdecomp, readerdata) );
/* add decomp to cons_decomp */
SCIP_CALL( SCIPconshdlrDecompAddDecdecomp(scip, decdecomp) );
for( i = 0; i < nvars; ++i )
{
assert(readerdata->linkingvarsblocks[i] != NULL || readerdata->nlinkingvarsblocks[i] == 0);
if( readerdata->nlinkingvarsblocks[i] > 0 )
{
SCIPfreeMemoryArray(scip, &readerdata->linkingvarsblocks[i]);
}
}
TERMINATE:
if( nblocksread )
{
for( i = blkinput->nblocks - 1; i >= 0; --i )
{
SCIPfreeMemoryArray(scip, &(readerdata->blockcons[i]));
}
SCIPfreeMemoryArray(scip, &readerdata->blockcons);
SCIPfreeMemoryArray(scip, &readerdata->nblockcons);
SCIPfreeMemoryArray(scip, &readerdata->nblockvars);
}
SCIPhashmapFree(&readerdata->constoblock);
SCIPfreeMemoryArray(scip, &readerdata->nlinkingvarsblocks);
SCIPfreeMemoryArray(scip, &readerdata->linkingvarsblocks);
SCIPfreeMemoryArray(scip, &readerdata->varstoblock);
/* close file */
SCIPfclose(blkinput->file);
return SCIP_OKAY;
}
